@node-core/utils 6.4.0 → 7.0.0

package/lib/update-v8/minorUpdate.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
 
-import { getCurrentV8Version } from './common.js';
+import { getV8Version } from './common.js';
 import { isVersionString } from './util.js';
 import { forceRunAsync } from '../run.js';
 
@@ -10,13 +10,13 @@ export default function minorUpdate() {
     title: 'Minor V8 update',
     task: (ctx, task) => {
       return task.newListr([
-        getCurrentV8Version(),
+        getV8Version('current'),
         getLatestV8Version(),
         doMinorUpdate()
       ]);
     }
   };
-};
+}
 
 function getLatestV8Version() {
   return {
@@ -74,7 +74,7 @@ async function applyPatch(ctx, latestStr) {
   } catch (e) {
     const file = path.join(ctx.nodeDir, `${latestStr}.diff`);
     await fs.writeFile(file, diff);
-    throw new Error(`Could not apply patch.\n${e}\nDiff was stored in ${file}`);
+    throw new Error(`Could not apply patch.\n${e}\nDiff was stored in ${file}`, { cause: e });
   }
 }
 

package/lib/update-v8/updateCrates.js

@@ -0,0 +1,192 @@
+import semver from 'semver';
+import * as TOML from 'smol-toml';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+import { removeDirectory } from './util.js';
+import { forceRunAsync } from '../run.js';
+
+export default function updateCrates() {
+  return {
+    title: 'Update Rust crates',
+    skip: (ctx) => ctx.newVersion.majorMinor < 139,
+    task: (ctx, task) => {
+      return task.newListr([
+        enumerateTemporalDependencies(),
+        removeExistingCrates(),
+        vendorCrates(),
+        buildManifest(),
+        generateLockfile(),
+        updateGYP(),
+        commitChanges()
+      ]);
+    }
+  };
+}
+
+const chromiumCratesDir = 'deps/v8/third_party/rust/chromium_crates_io';
+const nodeCratesDir = 'deps/crates';
+
+function enumerateTemporalDependencies() {
+  return {
+    title: 'Enumerate Temporal dependency tree',
+    task: async(ctx) => {
+      const tree = await forceRunAsync(
+        ctx.cargo,
+        ['tree', '-Z', 'bindeps', '--package', 'temporal_capi', '--prefix', 'none'],
+        {
+          ignoreFailure: false,
+          captureStdout: true,
+          spawnArgs: {
+            cwd: path.join(ctx.nodeDir, chromiumCratesDir),
+            env: { ...process.env, RUSTC_BOOTSTRAP: '1' }
+          }
+        }
+      );
+      const crates = new Set();
+      for (const crate of tree.trimEnd().split('\n').sort()) {
+        const [name, version] = crate.split(' ', 2);
+        crates.add(`${name}@${version.substring(1)}`);
+      }
+      ctx.temporalCrates = crates;
+    },
+  };
+}
+
+function removeExistingCrates() {
+  return {
+    title: 'Remove existing crates',
+    task: (ctx) => removeDirectory(path.join(ctx.nodeDir, nodeCratesDir, 'vendor'))
+  };
+}
+
+// Note that the crates vendored in third_party/rust/chromium_crates_io already have any custom
+// Chromium patches applied by gnrt, so we don't need to worry about patching them ourselves.
+function vendorCrates() {
+  return {
+    title: 'Copy vendored crates',
+    task: async(ctx, task) => {
+      const chromiumVendor = path.join(ctx.nodeDir, chromiumCratesDir, 'vendor');
+      const nodeVendor = path.join(ctx.nodeDir, nodeCratesDir, 'vendor');
+      await fs.mkdir(nodeVendor);
+
+      const subtasks = [];
+      const rustVersions = [];
+      for (const dir of await fs.readdir(chromiumVendor)) {
+        const crate = await getCrateInfo(dir);
+        if (!crate || !ctx.temporalCrates.has(`${crate.name}@${crate.version}`)) continue;
+        if (crate.name === 'temporal_capi') {
+          ctx.temporalCAPIDirectory = dir;
+        }
+        if (crate['rust-version']) {
+          rustVersions.push(crate['rust-version']);
+        }
+        subtasks.push({
+          title: dir,
+          task: async(ctx) => {
+            await fs.cp(
+              path.join(chromiumVendor, dir),
+              path.join(nodeVendor, dir),
+              { recursive: true }
+            );
+          }
+        });
+      }
+
+      if (rustVersions.length) {
+        const msrv = rustVersions.map(semver.coerce).reduce((a, b) => (semver.gt(a, b) ? a : b));
+        ctx.msrv = `${msrv.major}.${msrv.minor}`;
+      }
+
+      return task.newListr(subtasks, { concurrent: ctx.concurrent });
+
+      async function getCrateInfo(crate) {
+        try {
+          const manifest = TOML.parse(
+            await fs.readFile(path.join(chromiumVendor, crate, 'Cargo.toml'), 'utf8')
+          );
+          return manifest.package;
+        } catch {
+          return null;
+        }
+      }
+    }
+  };
+}
+
+function buildManifest() {
+  return {
+    title: 'Build new manifest',
+    task: async(ctx) => {
+      const sourceManifest = TOML.parse(
+        await fs.readFile(path.join(ctx.nodeDir, chromiumCratesDir, 'Cargo.toml'), 'utf8')
+      );
+
+      const header =
+      '# This manifest is generated by node-core-utils. Do not modify it directly.\n\n';
+      const manifest = {
+        package: {
+          edition: sourceManifest.package.edition,
+          name: 'node_crates',
+          version: `${ctx.newVersion.major}.${ctx.newVersion.minor}.${ctx.newVersion.build}`
+        },
+        lib: {
+          'crate-type': ['staticlib']
+        },
+        dependencies: {}
+      };
+      if (ctx.msrv) {
+        manifest.package['rust-version'] = ctx.msrv;
+      }
+      for (const crate of ctx.temporalCrates) {
+        const name = crate.split('@', 1)[0];
+        if (name === 'temporal_capi' || typeof sourceManifest.dependencies[name] === 'object') {
+          manifest.dependencies[name] = sourceManifest.dependencies[name];
+        }
+      }
+
+      const cargoTOML = header + TOML.stringify(manifest);
+      await fs.writeFile(path.join(ctx.nodeDir, nodeCratesDir, 'Cargo.toml'), cargoTOML);
+    },
+  };
+}
+
+function generateLockfile() {
+  return {
+    title: 'Generate lockfile',
+    task: (ctx) => forceRunAsync(ctx.cargo, ['generate-lockfile', '--quiet', '--offline'], {
+      ignoreFailure: false,
+      spawnArgs: { cwd: path.join(ctx.nodeDir, nodeCratesDir) }
+    })
+  };
+}
+
+function updateGYP() {
+  return {
+    title: 'Update include path in crates.gyp',
+    task: async(ctx, task) => {
+      const filePath = path.join(ctx.nodeDir, nodeCratesDir, 'crates.gyp');
+      let gyp = await fs.readFile(filePath, 'utf8');
+      const [definition, currentDirectory] = gyp.match(/'temporal_capi_dir': '(.+?)'/);
+      if (currentDirectory === ctx.temporalCAPIDirectory) {
+        task.skip('crates.gyp already up-to-date');
+        return;
+      }
+      gyp = gyp.replace(definition, `'temporal_capi_dir': '${ctx.temporalCAPIDirectory}'`);
+      await fs.writeFile(filePath, gyp);
+    }
+  };
+}
+
+function commitChanges() {
+  return {
+    title: 'Commit changes',
+    task: async(ctx) => {
+      await ctx.execGitNode('add', ['--force', 'deps/crates']);
+      await ctx.execGitNode(
+        'commit',
+        ['-m', `deps: update Rust crates for V8 ${ctx.newVersion}`]
+      );
+    }
+  };
+}

package/lib/update-v8/updateV8Clone.js

@@ -10,7 +10,7 @@ export default function updateV8Clone() {
       return task.newListr([fetchOrigin(), createClone()]);
     }
   };
-};
+}
 
 function fetchOrigin() {
   return {

package/lib/update-v8/updateVersionNumbers.js

@@ -1,8 +1,6 @@
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
 
-import { getNodeV8Version } from './util.js';
-
 export default function updateVersionNumbers() {
   return {
     title: 'Update version numbers',
@@ -10,16 +8,15 @@ export default function updateVersionNumbers() {
       return task.newListr([resetEmbedderString(), bumpNodeModule()]);
     }
   };
-};
+}
 
 function bumpNodeModule() {
   return {
     title: 'Bump NODE_MODULE_VERSION',
     task: async(ctx) => {
-      const v8Version = await getNodeV8Version(ctx.nodeDir);
       const newModuleVersion = await updateModuleVersionRegistry(
         ctx.nodeDir,
-        v8Version,
+        ctx.newVersion,
         ctx.nodeMajorVersion
       );
       await updateModuleVersion(ctx.nodeDir, newModuleVersion);
@@ -33,7 +30,7 @@ function bumpNodeModule() {
           '-m',
           getCommitTitle(newModuleVersion),
           '-m',
-          getCommitBody(v8Version)
+          getCommitBody(ctx.newVersion)
         ]
       );
     },

package/lib/update-v8/util.js

@@ -23,10 +23,10 @@ export async function getNodeV8Version(cwd) {
           : `${this.major}.${this.minor}.${this.build}`;
       }
     };
-  } catch (e) {
-    throw new Error('Could not find V8 version');
+  } catch (cause) {
+    throw new Error('Could not find V8 version', { cause });
   }
-};
+}
 
 export function filterForVersion(list, version) {
   return list.filter((dep) => {