📝 CodeRabbit Chat: Simplify PR code and implementation

Author: coderabbitai[bot]

packages/zodrs/scripts/verify-artifacts.mjs

@@ -103,12 +103,13 @@ const extraDeps = [...actualKeys].filter((k) => !expectedKeys.has(k));
 const mismatchedDeps = [...expectedKeys].filter(
   (k) => actualKeys.has(k) && optionalDeps[k] !== expectedOptionalDeps[k],
 );
-const depDetail =
-  (missingDeps.length ? `; missing: ${missingDeps.join(", ")}` : "") +
-  (extraDeps.length ? `; extra: ${extraDeps.join(", ")}` : "") +
-  (mismatchedDeps.length
-    ? `; wrong version: ${mismatchedDeps.map((k) => `${k} (expected ${expectedOptionalDeps[k]}, got ${optionalDeps[k]})`).join(", ")}`
-    : "");
+const depProblems = [
+  missingDeps.length && `missing: ${missingDeps.join(", ")}`,
+  extraDeps.length && `extra: ${extraDeps.join(", ")}`,
+  mismatchedDeps.length &&
+    `wrong version: ${mismatchedDeps.map((k) => `${k} (expected ${expectedOptionalDeps[k]}, got ${optionalDeps[k]})`).join(", ")}`,
+].filter(Boolean);
+const depDetail = depProblems.length ? `; ${depProblems.join("; ")}` : "";
 assert(
   missingDeps.length === 0 && extraDeps.length === 0 && mismatchedDeps.length === 0,
   `${mainManifestPath} optionalDependencies must list exactly the eight native platform packages at version ${cargoVersion}${depDetail}`,

packages/zodrs/scripts/verify-installed.mjs

@@ -123,23 +123,36 @@ function regularFile(packageDir, relativePath) {
   return { path, relativePath, sha256 };
 }
 
+function isEnoent(error) {
+  return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+
 function requireAbsent(packageDir, relativePath) {
   try {
     lstatSync(resolve(packageDir, relativePath));
   } catch (error) {
-    if (
-      error !== null &&
-      typeof error === "object" &&
-      "code" in error &&
-      error.code === "ENOENT"
-    ) {
-      return;
-    }
+    if (isEnoent(error)) return;
     throw error;
   }
   throw new Error(`${relativePath} must not exist in a release package`);
 }
 
+/**
+ * Asserts a package manifest's name/version match what is expected. `label`
+ * identifies the manifest in error messages (a directory path or a
+ * description such as "platform package").
+ */
+function assertManifestMatches(label, manifest, expectedName, expectedVersion) {
+  if (manifest.name !== expectedName) {
+    throw new Error(`${label} name is ${JSON.stringify(manifest.name)}, expected ${JSON.stringify(expectedName)}`);
+  }
+  if (manifest.version !== expectedVersion) {
+    throw new Error(
+      `${label} version is ${JSON.stringify(manifest.version)}, expected ${JSON.stringify(expectedVersion)}`,
+    );
+  }
+}
+
 /**
  * Reject any `.node` file inside `<installedMain>/native`.  The main package
  * tarball excludes `native/*.node` via the `files` array, so a `.node` file
@@ -152,14 +165,7 @@ function rejectEmbeddedNodeFiles(installedMain) {
   try {
     entries = readdirSync(nativeDir, { withFileTypes: true });
   } catch (error) {
-    if (
-      error !== null &&
-      typeof error === "object" &&
-      "code" in error &&
-      error.code === "ENOENT"
-    ) {
-      return; // no native/ dir — fine
-    }
+    if (isEnoent(error)) return; // no native/ dir — fine
     throw error;
   }
   const nodeFiles = entries.filter((e) => e.name.endsWith(".node")).map((e) => e.name);
@@ -184,6 +190,29 @@ function errorMessage(error) {
   return error instanceof Error ? (error.stack ?? error.message) : String(error);
 }
 
+function loadAddon(loaded, label) {
+  const addon = isAddon(loaded) ? loaded : isAddon(loaded?.default) ? loaded.default : null;
+  if (addon === null) throw new Error(`${label} does not expose compile, validateJson, and dispose`);
+  return addon;
+}
+
+/** Compiles and validates one fixed plan/input pair, returning the verdict status. */
+function exerciseAddon(addon, label) {
+  let handle;
+  try {
+    handle = addon.compile(PLAN);
+    if (!Number.isInteger(handle)) throw new Error(`${label} returned a non-integer plan handle`);
+
+    const verdict = addon.validateJson(handle, INPUT);
+    if (verdict === null || typeof verdict !== "object" || verdict.status !== 0) {
+      throw new Error(`${label} returned verdict ${JSON.stringify(verdict)}; expected status 0`);
+    }
+    return verdict.status;
+  } finally {
+    if (Number.isInteger(handle)) addon.dispose(handle);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Native verification — resolves the platform package from the installed
 // main package's dependency graph, never from the source tree or workspace.
@@ -195,14 +224,7 @@ function verifyNative(packageDir, expectedPackageDir, expectedPlatformDir) {
   const expectedVersion = expectedManifest.version;
 
   const manifest = readManifest(packageDir);
-  if (manifest.name !== expectedName) {
-    throw new Error(`${packageDir} name is ${JSON.stringify(manifest.name)}, expected ${JSON.stringify(expectedName)}`);
-  }
-  if (manifest.version !== expectedVersion) {
-    throw new Error(
-      `${packageDir} version is ${JSON.stringify(manifest.version)}, expected ${JSON.stringify(expectedVersion)}`,
-    );
-  }
+  assertManifestMatches(packageDir, manifest, expectedName, expectedVersion);
 
   // Reject embedded .node files so a host addon inside the main package
   // cannot mask optional-dependency selection.
@@ -259,18 +281,7 @@ function verifyNative(packageDir, expectedPackageDir, expectedPlatformDir) {
   }
   const platformEntryReal = realpathSync(platformEntry);
   const platformManifest = readManifest(platformDir);
-
-  // Validate the platform package manifest.
-  if (platformManifest.name !== pkgName) {
-    throw new Error(
-      `platform package name is ${JSON.stringify(platformManifest.name)}, expected ${JSON.stringify(pkgName)}`,
-    );
-  }
-  if (platformManifest.version !== expectedVersion) {
-    throw new Error(
-      `platform package version is ${JSON.stringify(platformManifest.version)}, expected ${JSON.stringify(expectedVersion)}`,
-    );
-  }
+  assertManifestMatches("platform package", platformManifest, pkgName, expectedVersion);
 
   const nodeFile = platformManifest.main;
   if (typeof nodeFile !== "string" || !nodeFile.endsWith(".node")) {
@@ -310,21 +321,18 @@ function verifyNative(packageDir, expectedPackageDir, expectedPlatformDir) {
     throw new Error(`platform package files must include ${nodeFile}`);
   }
 
-  // The resolved entry must be the declared main .node file.
+  // The resolved entry must be the declared main .node file, and it must
+  // stay contained within the platform package directory.
   const entryBasename = relative(platformDir, platformEntryReal);
+  if (entryBasename === ".." || entryBasename.startsWith(`..${sep}`) || isAbsolute(entryBasename)) {
+    throw new Error(`platform entry ${platformEntry} resolves outside ${platformDir}`);
+  }
   if (entryBasename !== nodeFile) {
     throw new Error(
       `resolved platform entry ${entryBasename} does not match manifest main ${nodeFile}`,
     );
   }
 
-  // Containment: the entry realpath must be inside the platform dir.
-  const fromRoot = relative(platformDir, platformEntryReal);
-  if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
-    throw new Error(`platform entry ${platformEntry} resolves outside ${platformDir}`);
-  }
-
-
   // If an expected platform dir is supplied, compare the raw addon SHA.
   let sha256 = null;
   if (expectedPlatformDir !== undefined) {
@@ -350,27 +358,10 @@ function verifyNative(packageDir, expectedPackageDir, expectedPlatformDir) {
     sha256 = installedSha;
   }
 
-  // Directly load the raw addon from the resolved platform package entry.
-  const loaded = installedRequire(platformEntry);
-  const addon = isAddon(loaded) ? loaded : isAddon(loaded?.default) ? loaded.default : null;
-  if (addon === null) {
-    throw new Error(`${nodeFile} does not expose compile, validateJson, and dispose`);
-  }
-
-  let handle;
-  let status;
-  try {
-    handle = addon.compile(PLAN);
-    if (!Number.isInteger(handle)) throw new Error(`${nodeFile} returned a non-integer plan handle`);
-
-    const verdict = addon.validateJson(handle, INPUT);
-    if (verdict === null || typeof verdict !== "object" || verdict.status !== 0) {
-      throw new Error(`${nodeFile} returned verdict ${JSON.stringify(verdict)}; expected status 0`);
-    }
-    status = verdict.status;
-  } finally {
-    if (Number.isInteger(handle)) addon.dispose(handle);
-  }
+  // Directly load and exercise the raw addon from the resolved platform
+  // package entry.
+  const addon = loadAddon(installedRequire(platformEntry), nodeFile);
+  const status = exerciseAddon(addon, nodeFile);
 
   return {
     tool: TOOL,
@@ -396,14 +387,7 @@ function verifyWasm(packageDir, expectedPackageDir) {
   const expectedVersion = expectedManifest.version;
 
   const manifest = readManifest(packageDir);
-  if (manifest.name !== expectedName) {
-    throw new Error(`${packageDir} name is ${JSON.stringify(manifest.name)}, expected ${JSON.stringify(expectedName)}`);
-  }
-  if (manifest.version !== expectedVersion) {
-    throw new Error(
-      `${packageDir} version is ${JSON.stringify(manifest.version)}, expected ${JSON.stringify(expectedVersion)}`,
-    );
-  }
+  assertManifestMatches(packageDir, manifest, expectedName, expectedVersion);
 
   requireAbsent(expectedPackageDir, DEBUG_WASM);
   requireAbsent(packageDir, DEBUG_WASM);
@@ -419,24 +403,8 @@ function verifyWasm(packageDir, expectedPackageDir) {
   });
 
   const entry = regularFile(packageDir, tierFiles.entry);
-  const loaded = createRequire(import.meta.url)(entry.path);
-  const addon = isAddon(loaded) ? loaded : isAddon(loaded?.default) ? loaded.default : null;
-  if (addon === null) throw new Error(`${tierFiles.entry} does not expose compile, validateJson, and dispose`);
-
-  let handle;
-  let status;
-  try {
-    handle = addon.compile(PLAN);
-    if (!Number.isInteger(handle)) throw new Error(`${tierFiles.entry} returned a non-integer plan handle`);
-
-    const verdict = addon.validateJson(handle, INPUT);
-    if (verdict === null || typeof verdict !== "object" || verdict.status !== 0) {
-      throw new Error(`${tierFiles.entry} returned verdict ${JSON.stringify(verdict)}; expected status 0`);
-    }
-    status = verdict.status;
-  } finally {
-    if (Number.isInteger(handle)) addon.dispose(handle);
-  }
+  const addon = loadAddon(createRequire(import.meta.url)(entry.path), tierFiles.entry);
+  const status = exerciseAddon(addon, tierFiles.entry);
 
   return {
     tool: TOOL,

scripts/release.sh

@@ -66,20 +66,11 @@ for dir in $platform_dirs; do
 		die "$expected_name is not bootstrapped on npm; publish an initial version and configure trusted publishing before tagging"
 done
 
-VERSION="$version" node -e '
+VERSION="$version" PLATFORM_DIRS="$platform_dirs" node -e '
   const fs = require("fs");
   const main = JSON.parse(fs.readFileSync("packages/zodrs/package.json", "utf8"));
   const version = process.env.VERSION;
-  const expected = [
-    "zod-rs-node-linux-x64-gnu",
-    "zod-rs-node-linux-arm64-gnu",
-    "zod-rs-node-linux-x64-musl",
-    "zod-rs-node-linux-arm64-musl",
-    "zod-rs-node-darwin-x64",
-    "zod-rs-node-darwin-arm64",
-    "zod-rs-node-win32-x64-msvc",
-    "zod-rs-node-win32-arm64-msvc",
-  ];
+  const expected = process.env.PLATFORM_DIRS.split(/\s+/).filter(Boolean).map((dir) => `zod-rs-node-${dir}`);
   const opt = main.optionalDependencies || {};
   const expectedSet = new Set(expected);
   const actual = Object.keys(opt);