feat: enhance lockfile management with latest version tracking and validation improvements

Author: luxass

src/cli.ts

@@ -228,9 +228,19 @@ cli.command(
     consola.log(versions.map((v) => `${yellow(v.emoji_version)}${v.draft ? ` ${red("(draft)")}` : ""}`).join(", "));
 
     if (args.writeLockfile) {
+      const sortedVersions = versions.filter((v) => !v.draft).sort((a, b) => semver.rcompare(a.unicode_version, b.unicode_version));
+
+      if (sortedVersions.length === 0 || sortedVersions[0] == null) {
+        consola.warn("no stable versions found, skipping lockfile update");
+        return;
+      }
+
+      const latestVersion = sortedVersions[0].emoji_version;
+
       const lockfile = await readLockfile();
 
       lockfile.versions = Array.from(versions);
+      lockfile.latest_version = latestVersion;
 
       await writeLockfile(lockfile);
       consola.log(`updated ${yellow("emojis.lock")}`);

src/lockfile.ts

@@ -3,22 +3,37 @@ import process from "node:process";
 import fs from "fs-extra";
 import * as v from "valibot";
 
+const EMOJI_VERSION_METADATA_SCHEMA = v.object({
+  emojis: v.nullable(v.string()),
+  sequences: v.nullable(v.string()),
+  variations: v.nullable(v.string()),
+  metadata: v.nullable(v.string()),
+  shortcodes: v.nullable(v.string()),
+  zwj: v.nullable(v.string()),
+});
+
 const EMOJI_VERSION_SCHEMA = v.object({
-  emoji_version: v.nullable(v.string()),
-  unicode_version: v.nullable(v.string()),
+  emoji_version: v.string(),
+  unicode_version: v.string(),
   draft: v.boolean(),
+  generated: v.boolean(),
+  metadata: v.nullable(EMOJI_VERSION_METADATA_SCHEMA),
 });
 
 export type EmojiVersion = v.InferInput<typeof EMOJI_VERSION_SCHEMA>;
 
 const LOCKFILE_SCHEMA = v.object({
+  updated_at: v.optional(v.number(), new Date().getTime()),
+  latest_version: v.optional(v.nullable(v.string())),
   versions: v.array(EMOJI_VERSION_SCHEMA),
 });
 
 export type EmojiLockfile = v.InferInput<typeof LOCKFILE_SCHEMA>;
 
 const DEFAULT_LOCKFILE = {
+  updated_at: new Date().getTime(),
   versions: [],
+  latest_version: null,
 } satisfies EmojiLockfile;
 
 /**
@@ -49,7 +64,9 @@ export async function writeLockfile(lockfile: EmojiLockfile, cwd: string = proce
   const result = await v.safeParseAsync(LOCKFILE_SCHEMA, lockfile);
 
   if (result.success === false) {
-    throw new Error(`invalid lockfile: ${result.issues.join(", ")}`);
+    // if lockfile is invalid, throw an error with the pretty-printed validation errors
+    console.error(result.issues);
+    throw new Error("invalid lockfile");
   }
 
   await fs.writeJSON(path.join(cwd, "emojis.lock"), result.output, { spaces: 2 });

src/versions.ts

@@ -239,9 +239,11 @@ export async function getAllEmojiVersions(): Promise<EmojiVersion[]> {
     }
 
     versions.push({
-      emoji_version: null,
+      emoji_version: version,
       unicode_version: version,
       draft: version === draft.unicode_version || version === draft.emoji_version,
+      metadata: null,
+      generated: false,
     });
   }
 
@@ -293,8 +295,10 @@ export async function getAllEmojiVersions(): Promise<EmojiVersion[]> {
 
     versions.push({
       emoji_version: match[1],
-      unicode_version,
+      unicode_version: unicode_version || match[1],
       draft: version === draft.unicode_version || version === draft.emoji_version,
+      metadata: null,
+      generated: false,
     });
   }
 

test/lockfile.test.ts

@@ -29,9 +29,11 @@ describe("writeLockfile", () => {
         emoji_version: "15.0",
         unicode_version: "15.0",
         draft: false,
+        generated: false,
+        metadata: null,
       }],
-      latestVersion: "15.0",
-    };
+      latest_version: "15.0",
+    } satisfies EmojiLockfile;
 
     await writeLockfile(lockfile, path);
     expect(await fs.exists(`${path}/emojis.lock`)).toBe(true);
@@ -43,7 +45,7 @@ describe("writeLockfile", () => {
       versions: [{
         // @ts-expect-error invalid type for emoji_version
         emoji_version: 123,
-        unicode_version: null,
+        unicode_version: "15.0.0",
         draft: false,
       }],
     } satisfies EmojiLockfile;
@@ -60,9 +62,11 @@ describe("readLockfile", () => {
           emoji_version: "15.0",
           unicode_version: "15.0",
           draft: false,
+          generated: false,
+          metadata: null,
         }],
-        latestVersion: "15.0",
-      }),
+        latest_version: "15.0",
+      } satisfies EmojiLockfile),
     });
 
     const result = await readLockfile(path);
@@ -71,9 +75,12 @@ describe("readLockfile", () => {
         emoji_version: "15.0",
         unicode_version: "15.0",
         draft: false,
+        generated: false,
+        metadata: null,
       }],
-      latestVersion: "15.0",
-    });
+      latest_version: "15.0",
+      updated_at: expect.any(Number),
+    } satisfies EmojiLockfile);
   });
 
   it("should return default lockfile when file does not exist", async () => {
@@ -82,8 +89,9 @@ describe("readLockfile", () => {
     const result = await readLockfile(path);
     expect(result).toEqual({
       versions: [],
-      latestVersion: null,
-    });
+      latest_version: null,
+      updated_at: expect.any(Number),
+    } satisfies EmojiLockfile);
   });
 
   it("should throw error for invalid lockfile content", async () => {
@@ -92,7 +100,7 @@ describe("readLockfile", () => {
         versions: [{
           // @ts-expect-error invalid type for emoji_version
           emoji_version: 123,
-          unicode_version: null,
+          unicode_version: "15.0.0",
           draft: false,
         }],
       } satisfies EmojiLockfile),