@reboot-dev/reboot 0.38.4 → 0.39.1

package/index.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _Reboot_external, _ExternalContext_external, _a, _Context_external, _Context_isInternalConstructing, _ReaderContext_kind, _WriterContext_kind, _TransactionContext_kind, _WorkflowContext_kind, _Application_servicers, _Application_tokenVerifier, _Application_express, _Application_http, _Application_servers, _Application_createExternalContext, _Application_external;
-import { assert, auth_pb, errors_pb, nodejs_pb, parse, protobuf_es, stringify, tasks_pb, toCamelCase, } from "@reboot-dev/reboot-api";
+import { assert, auth_pb, check_bufbuild_protobuf_library, errors_pb, nodejs_pb, parse, protobuf_es, stringify, tasks_pb, toCamelCase, } from "@reboot-dev/reboot-api";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { fork } from "node:child_process";
 import { createRequire } from "node:module";
@@ -19,6 +19,7 @@ import { z } from "zod/v4";
 import * as reboot_native from "./reboot_native.cjs";
 import { ensureError } from "./utils/errors.js";
 import { ensurePythonVenv } from "./venv.js";
+check_bufbuild_protobuf_library(protobuf_es.Message);
 const require = createRequire(import.meta.url);
 const express = require("express");
 export { reboot_native };
@@ -318,7 +319,7 @@ export function clearField(field, target) {
                 break;
             case "scalar":
                 target[localName] = implicitPresence
-                    ? protobuf_es.codegenInfo.scalarDefaultValue(field.T)
+                    ? protobuf_es.codegenInfo.scalarDefaultValue(field.T, field.L)
                     : undefined;
                 break;
             case "message":
@@ -533,7 +534,7 @@ export class Application {
             assert(kind === "initialize");
             return InitializeContext.fromNativeExternal(external);
         }, servicers, {
-            start: async (consensusId, port, createExternalContext) => {
+            start: async (serverId, port, createExternalContext) => {
                 // Store `createExternalContext` function before listening
                 // so we don't attempt to serve any traffic and try and use
                 // an `undefined` function.
@@ -554,11 +555,11 @@ export class Application {
                         }
                     });
                 });
-                __classPrivateFieldGet(this, _Application_servers, "f").set(consensusId, server);
+                __classPrivateFieldGet(this, _Application_servers, "f").set(serverId, server);
                 return port;
             },
-            stop: async (consensusId) => {
-                const server = __classPrivateFieldGet(this, _Application_servers, "f").get(consensusId);
+            stop: async (serverId) => {
+                const server = __classPrivateFieldGet(this, _Application_servers, "f").get(serverId);
                 if (server !== undefined) {
                     await new Promise((resolve, reject) => {
                         server.close((err) => {
@@ -570,7 +571,7 @@ export class Application {
                             }
                         });
                     });
-                    __classPrivateFieldGet(this, _Application_servers, "f").delete(consensusId);
+                    __classPrivateFieldGet(this, _Application_servers, "f").delete(serverId);
                 }
             },
         }, async (context) => {
@@ -884,18 +885,18 @@ export async function untilChanges(idempotencyAlias, context, callable, { equals
         return false;
     }), { schema }));
 }
-const launchSubprocessConsensus = (base64_args) => {
+const launchSubprocessServer = (base64_args) => {
     // Create a child process via `fork` (which does not mean `fork` as
     // in POSIX fork/clone) that uses the exact same module that was
     // used to start the initial application, however we set some env
     // vars in order to trigger the child process to run as a
-    // consensus subprocess.
+    // server subprocess.
     const subprocess = fork(process.argv[1], {
         env: {
             ...process.env,
-            // Pass over the consensus args in an env var.
-            REBOOT_NODEJS_CONSENSUS: "true",
-            REBOOT_NODEJS_CONSENSUS_BASE64_ARGS: base64_args,
+            // Pass over the server args in an env var.
+            REBOOT_NODEJS_SERVER: "true",
+            REBOOT_NODEJS_SERVER_BASE64_ARGS: base64_args,
         },
     });
     return subprocess.pid;
@@ -904,7 +905,7 @@ const callback = (...args) => {
     console.log(new Date(), ...args);
 };
 ensurePythonVenv();
-reboot_native.initialize(callback, launchSubprocessConsensus);
+reboot_native.initialize(callback, launchSubprocessServer);
 // TODO: move these into @reboot-dev/reboot-api and also generate them
 // via plugin, perhaps via a new plugin which emits the Zod schemas
 // for all protobuf messages, which might be easier after we've moved

package/package.json

@@ -1,9 +1,8 @@
 {
   "dependencies": {
-    "@bufbuild/protobuf": "1.3.2",
-    "@bufbuild/protoplugin": "1.3.2",
-    "@bufbuild/protoc-gen-es": "1.3.2",
-    "@reboot-dev/reboot-api": "0.38.4",
+    "@bufbuild/protoplugin": "1.10.1",
+    "@bufbuild/protoc-gen-es": "1.10.1",
+    "@reboot-dev/reboot-api": "0.39.1",
     "chalk": "^4.1.2",
     "node-addon-api": "^7.0.0",
     "node-gyp": ">=10.2.0",
@@ -18,9 +17,12 @@
     "toobusy-js": "^0.5.1",
     "@standard-schema/spec": "1.0.0"
   },
+  "peerDependencies": {
+    "@bufbuild/protobuf": "1.10.1"
+  },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.38.4",
+  "version": "0.39.1",
   "description": "npm package for Reboot",
   "scripts": {
     "preinstall": "node preinstall.cjs",

package/rbt-schema-to-proto.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env tsx
-import { toCamelCase, toPascalCase, toSnakeCase, ZOD_ERROR_NAMES, } from "@reboot-dev/reboot-api";
+import { toCamelCase, toPascalCase, toSnakeCase, typeSchema, ZOD_ERROR_NAMES, } from "@reboot-dev/reboot-api";
 import { strict as assert } from "assert";
 import chalk from "chalk";
 import { mkdtemp } from "fs/promises";
@@ -11,40 +11,6 @@ import { z } from "zod/v4";
 const args = process.argv.slice(2);
 const filesDirectory = args[0];
 const files = args.slice(1);
-const requestSchema = z.union([
-    z.instanceof(z.ZodObject),
-    z.record(z.string(), z.instanceof(z.ZodType)),
-]);
-const responseSchema = z.union([
-    z.instanceof(z.ZodObject),
-    z.record(z.string(), z.instanceof(z.ZodType)),
-    z.instanceof(z.ZodVoid),
-]);
-const errorsSchema = z.union([
-    z.tuple([z.instanceof(z.ZodObject)], z.instanceof(z.ZodObject)),
-    z.instanceof(z.ZodDiscriminatedUnion),
-]);
-const typeSchema = z.object({
-    state: z.union([
-        z.instanceof(z.ZodObject),
-        z.record(z.string(), z.instanceof(z.ZodType)),
-    ]),
-    methods: z.record(z.string(), z.discriminatedUnion("kind", [
-        z.object({
-            kind: z.literal(["reader", "workflow"]),
-            request: requestSchema,
-            response: responseSchema,
-            errors: errorsSchema.optional(),
-        }),
-        z.object({
-            kind: z.literal(["writer", "transaction"]),
-            factory: z.object({}).optional(),
-            request: requestSchema,
-            response: responseSchema,
-            errors: errorsSchema.optional(),
-        }),
-    ])),
-});
 // TODO:
 //
 // z.date (use well-known proto)
@@ -501,6 +467,12 @@ const main = async () => {
                 }
                 process.exit(-1);
             }
+            // Doing 'as any' here because Typescript can't figure out the
+            // inferred Zod type if we import from another module and will
+            // throw 'TS2589: Type instantiation is excessively deep and
+            // possibly infinite.' error.
+            // It is safe to do so, because right before that we call
+            // 'safeParse()', which ensures that the type is correct.
             const type = result.data;
             generate(proto, {
                 schema: type.state instanceof z.ZodObject ? type.state : z.object(type.state),

package/reboot_native.cc

@@ -286,7 +286,7 @@ struct PythonNodeAdaptor {
 static PythonNodeAdaptor* adaptor = new PythonNodeAdaptor();
 
 // References to nodejs functions so we don't have to look them up.
-static Napi::FunctionReference* js_launchSubprocessConsensus =
+static Napi::FunctionReference* js_launchSubprocessServer =
     new Napi::FunctionReference();
 
 
@@ -419,7 +419,7 @@ void PythonNodeAdaptor::Initialize(
         try {
           py::object module = py::module::import("rebootdev.nodejs.python");
 
-          module.attr("launch_subprocess_consensus") = py::cpp_function(
+          module.attr("launch_subprocess_server") = py::cpp_function(
               [](py::str py_base64_args) {
                 py::object py_future =
                     py::module::import("asyncio").attr("Future")();
@@ -429,7 +429,7 @@ void PythonNodeAdaptor::Initialize(
                      py_future = new py::object(py_future)](Napi::Env env) {
                       try {
                         Napi::Number js_pid =
-                            js_launchSubprocessConsensus
+                            js_launchSubprocessServer
                                 ->Call(
                                     {Napi::String::New(env, base64_args)})
                                 .As<Napi::Number>();
@@ -1091,7 +1091,7 @@ void Initialize(const Napi::CallbackInfo& info) {
   std::call_once(initialize_once, [&]() {
     Napi::Env env = info.Env();
 
-    js_launchSubprocessConsensus->Reset(
+    js_launchSubprocessServer->Reset(
         info[1].As<Napi::Function>(),
         /* refcount = */ 1);
 
@@ -1768,7 +1768,7 @@ Napi::Value Reboot_up(const Napi::CallbackInfo& info) {
        local_envoy_port]() {
         return py_reboot->attr("up")(
             py_application,
-            // NOTE: while we support subprocess consensuses
+            // NOTE: while we support subprocess servers
             // for `rbt dev` and `rbt serve` we do not support
             // them for tests because we don't have a way to
             // clone a process like we do with multiprocessing
@@ -2163,7 +2163,7 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
         py::object py_web_framework_start = py::cpp_function(
             [js_web_framework_start = std::move(js_web_framework_start),
              js_from_native_external /* Need a copy because it is shared. */](
-                std::string consensus_id,
+                std::string server_id,
                 py::object py_port,
                 py::object py_channel_manager) {
               std::optional<int> port;
@@ -2174,7 +2174,7 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
               return PythonFutureFromNodePromise(
                   [js_web_framework_start = std::move(js_web_framework_start),
                    js_from_native_external = std::move(js_from_native_external),
-                   consensus_id = std::move(consensus_id),
+                   server_id = std::move(server_id),
                    port,
                    py_channel_manager = new py::object(py_channel_manager)](
                       Napi::Env env) mutable {
@@ -2268,7 +2268,7 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
                         .Value(env)
                         .Call(
                             env.Global(),
-                            {Napi::String::New(env, consensus_id),
+                            {Napi::String::New(env, server_id),
                              port.has_value()
                                  ? Napi::Number::New(env, *port)
                                  : env.Null(),
@@ -2283,16 +2283,16 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
 
         py::object py_web_framework_stop = py::cpp_function(
             [js_web_framework_stop = std::move(js_web_framework_stop)](
-                std::string consensus_id) {
+                std::string server_id) {
               return PythonFutureFromNodePromise(
                   [js_web_framework_stop = std::move(js_web_framework_stop),
-                   consensus_id = std::move(consensus_id)](
+                   server_id = std::move(server_id)](
                       Napi::Env env) mutable {
                     return js_web_framework_stop
                         .Value(env)
                         .Call(
                             env.Global(),
-                            {Napi::String::New(env, consensus_id)})
+                            {Napi::String::New(env, server_id)})
                         .As<Napi::Object>();
                   });
             });

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.38.4";
+export declare const REBOOT_VERSION = "0.39.1";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.38.4";
+export const REBOOT_VERSION = "0.39.1";