@reboot-dev/reboot 0.20.0 → 0.22.0

package/{reboot.d.ts → index.d.ts}

@@ -12,14 +12,16 @@ export declare class Reboot {
     createExternalContext(name: string, options?: {
         idempotencySeed?: string;
         bearerToken?: string;
-        useInternalApiKeyFrom?: string;
+        appInternal?: boolean;
     }): ExternalContext;
     start(): Promise<void>;
     stop(): Promise<void>;
     up(servicers: any, options?: {
         tokenVerifier?: TokenVerifier;
+        localEnvoy?: boolean;
     }): Promise<ApplicationConfig>;
     down(): Promise<void>;
+    url(): string;
 }
 export declare class ExternalContext {
     #private;

package/{reboot.js → index.js}

@@ -59,10 +59,10 @@ export class Reboot {
         __classPrivateFieldSet(this, _Reboot_external, reboot_native.Reboot_constructor(), "f");
     }
     createExternalContext(name, options) {
-        if (options?.bearerToken && options?.useInternalApiKeyFrom) {
-            throw new Error("At most one of `bearerToken` and `useInternalApiKeyFrom` may be set.");
+        if (options?.bearerToken && options?.appInternal) {
+            throw new Error("At most one of `bearerToken` and `appInternal` may be set.");
         }
-        return reboot_native.Reboot_createExternalContext(__classPrivateFieldGet(this, _Reboot_external, "f"), ExternalContext.fromNativeExternal, name, options?.idempotencySeed, options?.bearerToken, options?.useInternalApiKeyFrom);
+        return reboot_native.Reboot_createExternalContext(__classPrivateFieldGet(this, _Reboot_external, "f"), ExternalContext.fromNativeExternal, name, options?.idempotencySeed, options?.bearerToken, options?.appInternal);
     }
     async start() {
         await reboot_native.Reboot_start(__classPrivateFieldGet(this, _Reboot_external, "f"));
@@ -81,11 +81,14 @@ export class Reboot {
     async up(servicers, options) {
         // TODO(benh): determine module and file name so that we can
         // namespace if we have more than one implementation of servicers.
-        return await reboot_native.Reboot_up(__classPrivateFieldGet(this, _Reboot_external, "f"), servicers, options?.tokenVerifier);
+        return await reboot_native.Reboot_up(__classPrivateFieldGet(this, _Reboot_external, "f"), servicers, options?.tokenVerifier, options?.localEnvoy);
     }
     async down() {
         await reboot_native.Reboot_down(__classPrivateFieldGet(this, _Reboot_external, "f"));
     }
+    url() {
+        return reboot_native.Reboot_url(__classPrivateFieldGet(this, _Reboot_external, "f"));
+    }
 }
 _Reboot_external = new WeakMap();
 export class ExternalContext {

package/package.json

@@ -3,7 +3,7 @@
     "@bufbuild/protobuf": "1.3.2",
     "@bufbuild/protoplugin": "1.3.2",
     "@bufbuild/protoc-gen-es": "1.3.2",
-    "@reboot-dev/reboot-api": "0.20.0",
+    "@reboot-dev/reboot-api": "0.22.0",
     "chalk": "^4.1.2",
     "node-addon-api": "^7.0.0",
     "node-gyp": ">=10.2.0",
@@ -14,7 +14,7 @@
   },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "npm package for Reboot",
   "scripts": {
     "postinstall": "rbt || exit 0",
@@ -49,8 +49,8 @@
     "rbt-esbuild.d.ts",
     "rbt-esbuild.js",
     "rbt.js",
-    "reboot.d.ts",
-    "reboot.js",
+    "index.d.ts",
+    "index.js",
     "reboot_native.cc",
     "reboot_native.cjs",
     "reboot_native.d.ts",
@@ -63,7 +63,7 @@
   ],
   "exports": {
     "./package.json": "./package.json",
-    ".": "./reboot.js",
+    ".": "./index.js",
     "./utils": "./utils/index.js"
   }
 }

package/reboot_native.cc

@@ -437,9 +437,9 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
     bearer_token = info[4].As<Napi::String>().Utf8Value();
   }
 
-  std::optional<std::string> use_internal_api_key_from;
+  bool app_internal = false;
   if (!info[5].IsUndefined()) {
-    use_internal_api_key_from = info[5].As<Napi::String>().Utf8Value();
+    app_internal = info[5].As<Napi::Boolean>();
   }
 
   std::promise<py::object*> promise;
@@ -449,7 +449,7 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
        &name,
        &idempotency_seed,
        &bearer_token,
-       &use_internal_api_key_from,
+       app_internal,
        &promise]() {
         py::object py_idempotency_seed = py::none();
         if (idempotency_seed.has_value()) {
@@ -461,18 +461,13 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
         if (bearer_token.has_value()) {
           py_bearer_token = py::str(*bearer_token);
         }
-        py::object py_use_internal_api_key_from = py::none();
-        if (use_internal_api_key_from.has_value()) {
-          py_use_internal_api_key_from = py::str(*use_internal_api_key_from);
-        }
         promise.set_value(
             new py::object(
                 py_reboot->attr("create_external_context")(
                     "name"_a = name,
                     "idempotency_seed"_a = py_idempotency_seed,
                     "bearer_token"_a = py_bearer_token,
-                    "use_internal_api_key_from"_a =
-                        py_use_internal_api_key_from)));
+                    "app_internal"_a = app_internal)));
       });
 
   py::object* py_context = promise.get_future().get();
@@ -1264,6 +1259,11 @@ Napi::Value Reboot_up(const Napi::CallbackInfo& info) {
     js_token_verifier = NapiSafeReference(info[2].As<Napi::Object>());
   }
 
+  bool local_envoy = false;
+  if (!info[3].IsUndefined()) {
+    local_envoy = info[3].As<Napi::Boolean>();
+  }
+
   auto env = info.Env();
   auto servicer_details = make_servicer_details(env, js_servicers);
 
@@ -1275,6 +1275,7 @@ Napi::Value Reboot_up(const Napi::CallbackInfo& info) {
       [js_external_reboot, // Ensures `py_reboot` remains valid.
        py_reboot,
        js_token_verifier,
+       local_envoy,
        servicer_details = std::move(servicer_details),
        deferred = std::move(deferred)]() {
         py::list py_servicers = make_py_servicers(servicer_details);
@@ -1294,7 +1295,7 @@ Napi::Value Reboot_up(const Napi::CallbackInfo& info) {
                     // clone a process like we do with multiprocessing
                     // in Python.
                     "in_process"_a = true,
-                    "local_envoy"_a = false),
+                    "local_envoy"_a = local_envoy),
                 "name"_a = "Reboot.up(...) in nodejs");
 
         py_task.attr("add_done_callback")(py::cpp_function(
@@ -1475,6 +1476,29 @@ Napi::Value Reboot_stop(const Napi::CallbackInfo& info) {
   return promise;
 }
 
+// NOTE: We block on a promise here, so this method should not be called outside
+// of tests.
+Napi::Value Reboot_url(const Napi::CallbackInfo& info) {
+  // NOTE: we immediately get a safe reference to the `Napi::External`
+  // so that Node will not garbage collect it and the `py::object*` we
+  // get out of it will remain valid.
+  auto js_external_reboot = NapiSafeReference(
+      info[0].As<Napi::External<py::object>>());
+
+  // CHECK(...CheckTypeTag(...));
+
+  py::object* py_reboot = js_external_reboot.Value(info.Env()).Data();
+
+  std::promise<std::string> promise;
+
+  adaptor->ScheduleCallbackOnPythonEventLoop(
+      [py_reboot, &promise]() {
+        py::str url = py_reboot->attr("url")();
+        promise.set_value(std::string(url));
+      });
+
+  return Napi::String::New(info.Env(), promise.get_future().get());
+}
 
 Napi::Value Service_constructor(const Napi::CallbackInfo& info) {
   Napi::Object js_args = info[0].As<Napi::Object>();
@@ -1786,14 +1810,6 @@ Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
             return py::none();
           }
         };
-        auto convert_bool =
-            [](const std::optional<bool>& optional) -> py::object {
-          if (optional.has_value()) {
-            return py::bool_(*optional);
-          } else {
-            return py::none();
-          }
-        };
 
         promise.set_value(
             new py::object(py_external.attr("ExternalContext")(
@@ -2806,6 +2822,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
       Napi::String::New(env, "Reboot_down"),
       Napi::Function::New<Reboot_down>(env));
 
+  exports.Set(
+      Napi::String::New(env, "Reboot_url"),
+      Napi::Function::New<Reboot_url>(env));
+
   exports.Set(
       Napi::String::New(env, "Service_constructor"),
       Napi::Function::New<Service_constructor>(env));

package/reboot_native.cjs

@@ -64,6 +64,7 @@ exports.Reboot_start = reboot_native.exports.Reboot_start;
 exports.Reboot_stop = reboot_native.exports.Reboot_stop;
 exports.Reboot_up = reboot_native.exports.Reboot_up;
 exports.Reboot_down = reboot_native.exports.Reboot_down;
+exports.Reboot_url = reboot_native.exports.Reboot_url;
 exports.Context_auth = reboot_native.exports.Context_auth;
 exports.Context_stateId = reboot_native.exports.Context_stateId;
 exports.Context_iteration = reboot_native.exports.Context_iteration;

package/reboot_native.d.ts

@@ -4,11 +4,10 @@ import {
   Context,
   ExternalContext,
   Servicer,
+  TokenVerifier,
   TransactionContext,
   WorkflowContext,
-  WriterContext,
-  TokenVerifier,
-} from "./reboot.js";
+} from "./index.js";
 
 // The Nodejs addon API does not expose TypeScript types so we alias
 // our C++ `Napi::External` type to `NapiExternal` to make it more

package/version.d.ts

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

package/version.js

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