Commit 7eb7b4f4a36aea3b858494e5983ee9bc9a288933 | the-knife

author	Julius Marminge <julius0216@outlook.com> 2026-06-20 11:31:09-07:00
committer	GitHub <noreply@github.com> 2026-06-20 11:31:09-07:00
log	7eb7b4f4a36aea3b858494e5983ee9bc9a288933
tree	7fdb256de8a6cabf020f9227874f52cbccec38fb
parent	e01b1903de403c720792a896d8c50ebcd8163b44
signature	Signed by PGP key B5690EEEBB952194

[codex] Structure release metadata failures (#3296)

Co-authored-by: codex <codex@users.noreply.github.com>

4 files changed, 111 insertions(+), 33 deletions(-)

scripts

scripts/resolve-nightly-release.test.ts+18-5

 @@ -1,4 +1,5 @@
 import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
 import {
   resolveNightlyBaseVersion,
 @@ -12,11 +13,23 @@ it("strips prerelease and build metadata when deriving the nightly base version"
   assert.equal(resolveNightlyBaseVersion("1.2.3-beta.4+build.9"), "1.2.3");
 });
-it("bumps the patch version before deriving nightly prerelease versions", () => {
+it.effect("bumps the patch version before deriving nightly prerelease versions", () =>
-  assert.equal(resolveNightlyTargetVersion("0.0.17"), "0.0.18");
+  Effect.gen(function* () {
-  assert.equal(resolveNightlyTargetVersion("9.9.9-smoke.0"), "9.9.10");
+    assert.equal(yield* resolveNightlyTargetVersion("0.0.17"), "0.0.18");
-  assert.equal(resolveNightlyTargetVersion("1.2.3-beta.4+build.9"), "1.2.4");
+    assert.equal(yield* resolveNightlyTargetVersion("9.9.9-smoke.0"), "9.9.10");
-});
+    assert.equal(yield* resolveNightlyTargetVersion("1.2.3-beta.4+build.9"), "1.2.4");
+  }),
+);
+it.effect("reports the invalid desktop package version", () =>
+  Effect.gen(function* () {
+    const error = yield* resolveNightlyTargetVersion("nightly").pipe(Effect.flip);
+    assert.equal(error._tag, "InvalidDesktopPackageVersionError");
+    assert.equal(error.version, "nightly");
+    assert.equal(error.message, "Invalid desktop package version 'nightly'.");
+  }),
+);
 it("derives nightly metadata including the short commit sha in the release name", () => {
   assert.deepStrictEqual(

scripts/resolve-nightly-release.ts+14-3

 @@ -29,6 +29,17 @@ const DesktopPackageJsonSchema = Schema.Struct({
   version: Schema.NonEmptyString,
 });
+export class InvalidDesktopPackageVersionError extends Schema.TaggedErrorClass<InvalidDesktopPackageVersionError>()(
+  "InvalidDesktopPackageVersionError",
+  {
+    version: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `Invalid desktop package version '${this.version}'.`;
+  }
+}
 const RepoRoot = Effect.service(Path.Path).pipe(
   Effect.flatMap((path) => path.fromFileUrl(new URL("..", import.meta.url))),
 );
 @@ -42,11 +53,11 @@ export const resolveNightlyTargetVersion = (version: string) => {
   const stableCore = resolveNightlyBaseVersion(version);
   const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(stableCore);
   if (!match) {
-    throw new Error(`Invalid desktop package version '${version}'.`);
+    return Effect.fail(new InvalidDesktopPackageVersionError({ version }));
   }
   const [, major, minor, patch] = match;
-  return `${major}.${minor}.${Number(patch) + 1}`;
+  return Effect.succeed(`${major}.${minor}.${Number(patch) + 1}`);
 };
 export const resolveNightlyReleaseMetadata = (
 @@ -76,7 +87,7 @@ const readDesktopBaseVersion = Effect.fn("readDesktopBaseVersion")(function* (
   const packageJson = yield* fs
     .readFileString(packageJsonPath)
     .pipe(Effect.flatMap(decodeDesktopPackageJson));
-  return resolveNightlyTargetVersion(packageJson.version);
+  return yield* resolveNightlyTargetVersion(packageJson.version);
 });
 const writeOutput = Effect.fn("writeOutput")(function* (

scripts/resolve-previous-release-tag.test.ts created+39

...	@@ -0,0 +1,39 @@
1	import { assert, it } from "@effect/vitest";
2	import * as Effect from "effect/Effect";
3
4	import { resolvePreviousReleaseTag } from "./resolve-previous-release-tag.ts";
5
6	it.effect("selects the latest earlier stable tag and ignores nightlies", () =>
7	Effect.gen(function* () {
8	const previous = yield* resolvePreviousReleaseTag("stable", "v1.2.0", [
9	"v1.1.0",
10	"v1.1.1-nightly.20260619.1",
11	"v1.1.2",
12	"v1.2.0",
13	]);
14
15	assert.equal(previous, "v1.1.2");
16	}),
17	);
18
19	it.effect("accepts legacy nightly tags when selecting the previous nightly", () =>
20	Effect.gen(function* () {
21	const previous = yield* resolvePreviousReleaseTag("nightly", "v1.2.0-nightly.20260620.2", [
22	"nightly-v1.2.0-nightly.20260620.1",
23	"v1.1.0-nightly.20260619.9",
24	]);
25
26	assert.equal(previous, "nightly-v1.2.0-nightly.20260620.1");
27	}),
28	);
29
30	it.effect("reports the invalid tag with its release channel", () =>
31	Effect.gen(function* () {
32	const error = yield* resolvePreviousReleaseTag("nightly", "v1.2.0", []).pipe(Effect.flip);
33
34	assert.equal(error._tag, "InvalidReleaseTagError");
35	assert.equal(error.channel, "nightly");
36	assert.equal(error.currentTag, "v1.2.0");
37	assert.equal(error.message, "Invalid nightly release tag 'v1.2.0'.");
38	}),
39	);

scripts/resolve-previous-release-tag.ts+40-25

 @@ -15,6 +15,18 @@ import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 const ReleaseChannel = Schema.Literals(["stable", "nightly"]);
 type ReleaseChannel = typeof ReleaseChannel.Type;
+export class InvalidReleaseTagError extends Schema.TaggedErrorClass<InvalidReleaseTagError>()(
+  "InvalidReleaseTagError",
+  {
+    channel: ReleaseChannel,
+    currentTag: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `Invalid ${this.channel} release tag '${this.currentTag}'.`;
+  }
+}
 interface StableVersion {
   readonly major: number;
   readonly minor: number;
 @@ -121,41 +133,44 @@ const parseNightlyTag = (tag: string): NightlyVersion | undefined => {
   };
 };
-const resolvePreviousReleaseTag = (
+export const resolvePreviousReleaseTag = (
   channel: ReleaseChannel,
   currentTag: string,
   tags: ReadonlyArray<string>,
-): string | undefined => {
+) =>
-  if (channel === "stable") {
+  Effect.gen(function* () {
-    const current = parseStableTag(currentTag);
+    if (channel === "stable") {
+      const current = parseStableTag(currentTag);
+      if (!current) {
+        return yield* new InvalidReleaseTagError({ channel, currentTag });
+      }
+      const candidates = tags
+        .map((tag) => ({ tag, parsed: parseStableTag(tag) }))
+        .filter(
+          (entry): entry is { tag: string; parsed: StableVersion } => entry.parsed !== undefined,
+        )
+        .filter((entry) => compareStableVersions(entry.parsed, current) < 0)
+        .toSorted((left, right) => compareStableVersions(right.parsed, left.parsed));
+      return candidates[0]?.tag;
+    }
+    const current = parseNightlyTag(currentTag);
     if (!current) {
-      throw new Error(`Invalid stable release tag '${currentTag}'.`);
+      return yield* new InvalidReleaseTagError({ channel, currentTag });
     }
     const candidates = tags
-      .map((tag) => ({ tag, parsed: parseStableTag(tag) }))
+      .map((tag) => ({ tag, parsed: parseNightlyTag(tag) }))
       .filter(
-        (entry): entry is { tag: string; parsed: StableVersion } => entry.parsed !== undefined,
+        (entry): entry is { tag: string; parsed: NightlyVersion } => entry.parsed !== undefined,
       )
-      .filter((entry) => compareStableVersions(entry.parsed, current) < 0)
+      .filter((entry) => compareNightlyVersions(entry.parsed, current) < 0)
-      .toSorted((left, right) => compareStableVersions(right.parsed, left.parsed));
+      .toSorted((left, right) => compareNightlyVersions(right.parsed, left.parsed));
     return candidates[0]?.tag;
-  }
+  });
-  const current = parseNightlyTag(currentTag);
-  if (!current) {
-    throw new Error(`Invalid nightly release tag '${currentTag}'.`);
-  }
-  const candidates = tags
-    .map((tag) => ({ tag, parsed: parseNightlyTag(tag) }))
-    .filter((entry): entry is { tag: string; parsed: NightlyVersion } => entry.parsed !== undefined)
-    .filter((entry) => compareNightlyVersions(entry.parsed, current) < 0)
-    .toSorted((left, right) => compareNightlyVersions(right.parsed, left.parsed));
-  return candidates[0]?.tag;
-};
 const listGitTags = Effect.fn("listGitTags")(function* () {
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 @@ -205,7 +220,7 @@ const command = Command.make(
   },
   ({ channel, currentTag, githubOutput }) =>
     listGitTags().pipe(
-      Effect.map((tags) => resolvePreviousReleaseTag(channel, currentTag, tags)),
+      Effect.flatMap((tags) => resolvePreviousReleaseTag(channel, currentTag, tags)),
       Effect.flatMap((previousTag) => writeOutput(previousTag, githubOutput)),
     ),
 ).pipe(Command.withDescription("Resolve the previous release tag for a stable or nightly series."));