@reboot-dev/reboot 0.19.1 → 0.20.0

package/package.json

@@ -1,33 +1,35 @@
 {
   "dependencies": {
-    "chalk": "^4.1.2",
-    "esbuild": "^0.24.0",
-    "node-addon-api": "^7.0.0",
-    "protobufjs": "^7.2.5",
-    "@types/node": "20.11.5",
-    "@types/uuid": "^9.0.4",
-    "uuid": "^9.0.1",
-    "which-pm-runs": "^1.1.0"
-  },
-  "peerDependencies": {
     "@bufbuild/protobuf": "1.3.2",
     "@bufbuild/protoplugin": "1.3.2",
     "@bufbuild/protoc-gen-es": "1.3.2",
-    "@reboot-dev/reboot-api": "0.19.1",
-    "typescript": ">=4.9.5"
+    "@reboot-dev/reboot-api": "0.20.0",
+    "chalk": "^4.1.2",
+    "node-addon-api": "^7.0.0",
+    "node-gyp": ">=10.2.0",
+    "uuid": "^9.0.1",
+    "which-pm-runs": "^1.1.0",
+    "extensionless": "^1.9.9",
+    "esbuild": "^0.24.0"
   },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "description": "npm package for Reboot",
   "scripts": {
     "postinstall": "rbt || exit 0",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "prepare": "tsc"
+    "prepack": "tsc"
+  },
+  "devDependencies": {
+    "typescript": ">=4.9.5",
+    "@types/node": "20.11.5",
+    "@types/uuid": "^9.0.4"
   },
   "bin": {
     "rbt": "./rbt.js",
-    "rbt-esbuild": "./rbt-esbuild.js"
+    "rbt-esbuild": "./rbt-esbuild.js",
+    "protoc-gen-es": "./protoc-gen-es.js"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -41,6 +43,8 @@
     "include",
     "internal",
     "package.json",
+    "protoc-gen-es.d.ts",
+    "protoc-gen-es.js",
     "rbt.d.ts",
     "rbt-esbuild.d.ts",
     "rbt-esbuild.js",

package/protoc-gen-es.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "@bufbuild/protoc-gen-es/bin/protoc-gen-es";

package/protoc-gen-es.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// NOTE: Yarn doesn't add transitive binary dependencies to PATH!!!
+// Thus this script which "proxies" to `protoc-gen-es`.
+import "@bufbuild/protoc-gen-es/bin/protoc-gen-es";

package/rbt-esbuild.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import chalk from "chalk";
 import esbuild from "esbuild";
 import { writeFileSync } from "node:fs";
 import * as path from "path";
@@ -11,12 +12,14 @@ const args = process.argv.slice(2);
 const application = args[0];
 const name = args[1];
 export const BUNDLE_PATH = path.join(__dirname, ".bundles", name);
-const workspaces = await locateWorkspaces();
-if (!workspaces) {
-    console.error(`Could not determine the package manager for ${application}.`);
+let workspaces = [];
+try {
+    workspaces = (await locateWorkspaces()).map(({ name }) => name);
+}
+catch (e) {
+    console.error(chalk.stderr.bold.red(`Failed to use your package manager to determine your workspaces (if any): ${e}`));
     process.exit(-1);
 }
-const workspaceModules = workspaces.map((workspace) => workspace.name);
 const plugin = {
     name: "rbt-esbuild",
     setup(build) {
@@ -27,9 +30,8 @@ const plugin = {
                 return null;
             }
             // Workspace modules are also local, not external.
-            for (const workspaceModule of workspaceModules) {
-                if (args.path === workspaceModule ||
-                    args.path.startsWith(workspaceModule + "/")) {
+            for (const workspace of workspaces) {
+                if (args.path === workspace || args.path.startsWith(workspace + "/")) {
                     return null;
                 }
             }
@@ -81,6 +83,7 @@ esbuild
 })
     .then(async (result) => {
     writeFileSync(path.join(BUNDLE_PATH, "meta.json"), JSON.stringify(result.metafile));
+    // Output the path where we bundled for `rbt dev` to consume.
     console.log(BUNDLE_PATH);
     process.exit(0);
 })

package/rbt.js

@@ -1,11 +1,48 @@
 #!/usr/bin/env node
 import { spawnSync } from "child_process";
 import * as path from "path";
+import whichPMRuns from "which-pm-runs";
+import { ensureYarnNodeLinker } from "./utils/index.js";
 import { ensurePythonVenv, VENV_EXEC_PATH } from "./venv.js";
+async function ensureSupportedYarn() {
+    const packageManager = await whichPMRuns();
+    if (!packageManager) {
+        return;
+    }
+    if (packageManager.name === "yarn") {
+        ensureYarnNodeLinker();
+    }
+}
+function addExtensionlessToNodeOptions() {
+    // Add the `extensionless` loader to the `NODE_OPTIONS` env var so
+    // subsequent invocations of Node.js will use it. Depending on which
+    // version of Node.js we're using we have to add it differently.
+    const [major, minor] = process.versions.node.split(".").map(Number);
+    // Make sure that we can append to the `NODE_OPTIONS` env var.
+    process.env.NODE_OPTIONS =
+        (process.env.NODE_OPTIONS && process.env.NODE_OPTIONS + " ") || "";
+    // The `module.register()` function was added to Node.js in 20.6.0
+    // for the main release line and 18.19.0 for the LTS release line.
+    //
+    // If we have one of those two versions then we can pre import
+    // `extensionless/register` to use the `module.register()` function,
+    // otherwise we need to fall back to `--experimental-loader`.
+    if (major > 20 ||
+        (major == 20 && minor >= 6) ||
+        (major == 18 && minor >= 19)) {
+        process.env.NODE_OPTIONS += "--import=extensionless/register";
+    }
+    else {
+        process.env.NODE_OPTIONS += "--experimental-loader=extensionless";
+    }
+}
 async function main() {
     ensurePythonVenv();
+    await ensureSupportedYarn();
     // Set env var to indicate that `rbt` is being invoked from Node.js.
     process.env.RBT_FROM_NODEJS = "true";
+    // Add extensionless loader.
+    addExtensionlessToNodeOptions();
     const rbt = spawnSync(`${path.join(VENV_EXEC_PATH, "rbt")} ${process.argv.slice(2).join(" ")}`, {
         stdio: [process.stdin, process.stdout, process.stderr],
         shell: true,

package/reboot.d.ts

@@ -88,10 +88,10 @@ export type ServicerFactory = {
  */
 export declare class Auth {
     userId?: string;
-    properties: unknown;
+    properties: protobuf_es.JsonValue;
     constructor(options?: {
         userId?: string;
-        properties?: unknown;
+        properties?: protobuf_es.JsonValue;
     });
     toProtoBytes(): Uint8Array;
     static fromProtoBytes(bytes: Uint8Array): Auth;

package/reboot.js

@@ -95,7 +95,7 @@ export class ExternalContext {
             __classPrivateFieldSet(this, _ExternalContext_external, args.external, "f");
         }
         else {
-            if (!args.url.startsWith("http")) {
+            if (!args.url || !args.url.startsWith("http")) {
                 throw new Error("`ExternalContext` must be constructed with a `url` " +
                     "including an explicit 'http' or 'https' protocol");
             }
@@ -277,7 +277,7 @@ export class Auth {
     toProtoBytes() {
         const auth = new auth_pb.Auth({
             userId: this.userId,
-            properties: this.properties,
+            properties: protobuf_es.Struct.fromJson(this.properties),
         });
         return auth.toBinary();
     }

package/reboot_native.cjs

@@ -7,7 +7,7 @@ const [major, minor, patch] = process.versions.node.split(".").map(Number);
 
 if (major < 18) {
   console.error(
-    chalk.red(
+    chalk.stderr.bold.red(
       `Reboot requires nodejs version >=18 (found ${major}.${minor}.${patch})`
     )
   );
@@ -19,12 +19,21 @@ const reboot_native = { exports: {} };
 // If we are in a Next.js context, check that serverExternalPackages is
 // correctly set. If not correctly set, Reboot backend TS code will not work
 // with React Server Components inside Next.
-
 if (__dirname.includes(".next")) {
   throw new Error(
-    "For Next.js to work correctly with Reboot native code, you " +
-      "must include option 'serverExternalPackages: ['@reboot-dev/reboot']' " +
-      "in your next.config.ts"
+    `For Next.js to work correctly with Reboot native code, an external
+    package must be added to 'next.config.ts':
+
+    In Next.js 14:
+      experimental: {
+        serverComponentsExternalPackages: ["@reboot-dev/reboot"],
+      },
+      ...
+
+    In Next.js 15
+      'serverExternalPackages: ['@reboot-dev/reboot']',
+      ...
+    `
   );
 }
 

package/utils/index.d.ts

@@ -1 +1,12 @@
 export * from "./errors.js";
+export declare function parseVersion(version: string): [number, number, number];
+export type Version = [number, number, number];
+export declare function supportedVersion({ required: [requiredMajor, requiredMinor, requiredPatch], found: [foundMajor, foundMinor, foundPatch], }: {
+    required: Version;
+    found: Version;
+}): boolean;
+export declare function ensureYarnNodeLinker(): void;
+/**
+ * Spawn a process with the given arguments, and return its stdout as a string.
+ */
+export declare function spawnAndReturnStdout(command: string, args: string[]): string;

package/utils/index.js

@@ -1 +1,47 @@
+import chalk from "chalk";
+import { spawnSync } from "child_process";
 export * from "./errors.js";
+export function parseVersion(version) {
+    const match = version.trim().match(/(\d+\.\d+\.\d+)/);
+    if (!match) {
+        throw new Error(`Failed to parse '${version}' into a version`);
+    }
+    return version.split(".").map(Number);
+}
+export function supportedVersion({ required: [requiredMajor, requiredMinor, requiredPatch], found: [foundMajor, foundMinor, foundPatch], }) {
+    return (foundMajor > requiredMajor ||
+        (foundMajor === requiredMajor && foundMinor > requiredMinor) ||
+        (foundMajor === requiredMajor &&
+            foundMinor === requiredMinor &&
+            foundPatch >= requiredPatch));
+}
+export function ensureYarnNodeLinker() {
+    // Ensure that they aren't using Yarn Plug'n'Play which we don't yet
+    // support.
+    const nodeLinker = spawnAndReturnStdout("yarn", [
+        "config",
+        "get",
+        "nodeLinker",
+    ]);
+    if (nodeLinker.trim() !== "node-modules") {
+        console.error(chalk.stderr.bold.red("Yarn Plug'n'Play is not yet supported, you must use 'node-modules' as your 'nodeLinker'"));
+        process.exit(-1);
+    }
+}
+/**
+ * Spawn a process with the given arguments, and return its stdout as a string.
+ */
+export function spawnAndReturnStdout(command, args) {
+    const result = spawnSync(command, args, {
+        stdio: ["ignore", "pipe", "inherit"],
+    });
+    if (result.error) {
+        throw new Error(`Failed to run '${command} ${args.join(" ")}': ${result.error}\n` +
+            `\n` +
+            `Please report this bug to the maintainers!`);
+    }
+    else if (result.status !== 0) {
+        throw new Error(`Running '${command} ${args.join(" ")}' exited with status ${result.status}. Please report this bug including the output of that command (if any) to the maintainers!`);
+    }
+    return result.stdout.toString();
+}

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.19.1";
+export declare const REBOOT_VERSION = "0.20.0";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.19.1";
+export const REBOOT_VERSION = "0.20.0";

package/workspaces.js

@@ -1,5 +1,5 @@
-import { spawnSync } from "child_process";
 import whichPMRuns from "which-pm-runs";
+import { parseVersion, spawnAndReturnStdout, supportedVersion, } from "./utils/index.js";
 /**
  * Returns package-manager Workspaces of which a project in the given directory
  * is a member.
@@ -9,16 +9,13 @@ export async function locateWorkspaces() {
     if (!packageManager) {
         return null;
     }
-    // NOTE: These methods will error if they fail to extract workspaces, based on the
-    // assumption that `preferredPM` will do a reasonable job of detecting a package
-    // manager, and based on having validated that it falls back to `null` if it doesn't
-    // have a reasonable guess.
+    // NOTE: These methods will error if they fail to extract
+    // workspaces, based on the assumption that `whichPMRuns` will do a
+    // reasonable job of detecting a package manager, otherwise throws
+    // an exception.
     switch (packageManager.name) {
         case "yarn": {
-            if (packageManager.version.startswith("4.")) {
-                return extractYarnWorkspaces();
-            }
-            throw new Error(`'yarn' version '${packageManager.version}' is not supported. Please report this issue to the maintainers!`);
+            return extractYarnWorkspaces();
         }
         case "npm": {
             return extractNpmWorkspaces();
@@ -27,52 +24,73 @@ export async function locateWorkspaces() {
             return extractPnpmWorkspaces();
         }
         default: {
-            throw new Error(`Unsupported package manager: '${packageManager}'. Please report this issue to the maintainers!`);
+            throw new Error(`Unsupported package manager '${packageManager}'`);
         }
     }
 }
 function extractYarnWorkspaces() {
-    const workspacesJSON = spawnAndParseJSON("yarn", [
-        "workspaces",
-        "list",
-        "--json",
-        "--recursive",
-    ]);
-    return workspacesJSON.map((entry) => ({
-        name: entry.name,
-    }));
+    // TODO: what is the actual minimum version we need?
+    const YARN_VERSION_REQUIRED = "4.0.0";
+    const required = parseVersion(YARN_VERSION_REQUIRED);
+    const found = parseVersion(spawnAndReturnStdout("yarn", ["--version"]));
+    if (!supportedVersion({ required, found })) {
+        throw new Error(`yarn version >=${YARN_VERSION_REQUIRED} is required, found ${found.join(".")}`);
+    }
+    const command = "yarn";
+    const args = ["workspaces", "list", "--json", "--recursive"];
+    // `yarn workspaces list --json` returns JSON lines, not complete
+    // JSON, so we have to do some extra parsing ourselves.
+    return spawnAndReturnStdout(command, args)
+        .trim()
+        .split("\n")
+        .map((line) => {
+        const { name } = JSON.parse(line.trim());
+        return { name };
+    });
 }
 function extractNpmWorkspaces() {
-    const workspacesJSON = spawnAndParseJSON("npm", ["query", ".workspace"]);
-    const workspaces = workspacesJSON.map((entry) => ({
-        name: entry.name,
+    // We need >=8.16.0 which is when `npm query` was introduced.
+    const NPM_VERSION_REQUIRED = "8.16.0";
+    const required = parseVersion(NPM_VERSION_REQUIRED);
+    const found = parseVersion(spawnAndReturnStdout("npm", ["--version"]));
+    if (!supportedVersion({ required, found })) {
+        throw new Error(`npm version >=${NPM_VERSION_REQUIRED} is required, found ${found.join(".")}`);
+    }
+    const command = "npm";
+    const args = ["query", ".workspace"];
+    const workspaces = spawnAndParseJSON(command, args).map(({ name }) => ({
+        name,
     }));
-    // Also get the package name as it might be used. This is also
-    // consistent with both `yarn` and `pnpm` which always include the
-    // top-level package name even if they aren't explicitly in
-    // `workspaces`.
+    // Include the package name as it might be used and it is consistent
+    // with both `yarn` and `pnpm` which always include the top-level
+    // package name even if they aren't explicitly in `workspaces`.
     const name = spawnAndParseJSON("npm", ["pkg", "get", "name"]);
-    if (typeof name !== "string") {
+    // `npm pkg get name` returns an empty object if there is no
+    // top-level package name.
+    if (Object.keys(name).length === 0) {
         return workspaces;
     }
-    return [...workspaces, { name: name }];
+    else if (typeof name !== "string") {
+        throw new Error(`Failed to get name of your package. Please report this issue to the maintainers!`);
+    }
+    return [{ name }, ...workspaces];
 }
 function extractPnpmWorkspaces() {
+    // TODO: is there a minimum version required?
     const command = "pnpm";
     const args = ["list", "--recursive", "--depth", "-1", "--only-projects"];
-    const workspacesString = spawnAndParseJSON(command, args);
-    // TODO: `pnpm list --recursive --depth -1 --only-projects --json` emits something
+    // `pnpm list --recursive --depth -1 --only-projects --json` emits something
     // which is not quite valid JSON: closer to JSON lines, but not easily splittable.
     //
     // Instead, we parse the human-readable output -- a series of lines like:
     //    @reboot-pm/prosemirror@0.0.1 /Users/example/src/repo_root/project_dir (PRIVATE)
-    return workspacesString
+    return spawnAndReturnStdout(command, args)
         .trim()
         .split("\n")
         .map((line) => {
         const parts = line.trim().split(" ");
         if (parts.length !== 3) {
-            throw new Error(`Unexpected output from '${command} ${args}'. Please report the output of that command to the maintainers!`);
+            throw new Error(`Unexpected output from '${command} ${args.join(" ")}'. Please report the output of that command to the maintainers!`);
         }
         // Strip off the version from the name.
         const lastAtSign = parts[0].lastIndexOf("@");
@@ -83,10 +101,7 @@ function extractPnpmWorkspaces() {
         else {
             name = parts[0];
         }
-        ({
-            name: name,
-            path: parts[1],
-        });
+        return { name };
     });
 }
 /**
@@ -97,25 +112,9 @@ function extractPnpmWorkspaces() {
 function spawnAndParseJSON(command, args) {
     const stdout = spawnAndReturnStdout(command, args);
     try {
-        const json = JSON.parse(stdout.toString());
-        return json;
+        return JSON.parse(stdout);
     }
     catch (error) {
-        throw new Error(`Failed to parse output of '${command} ${args}': ${error}`);
-    }
-}
-/**
- * Spawn a process with the given arguments, and return its stdout.
- */
-function spawnAndReturnStdout(command, args) {
-    const result = spawnSync(command, args, {
-        stdio: ["pipe", "pipe", process.stderr],
-    });
-    if (result.status !== 0) {
-        const errorStr = result.error
-            ? result.error.toString()
-            : result.stderr.toString();
-        throw new Error(`Process '${command} ${args}' exited with code ${result.status} and error: ${errorStr}`);
+        throw new Error(`Failed to parse output of '${command} ${args.join(" ")}' as JSON: ${error}`);
     }
-    return result.stdout;
 }