@reboot-dev/reboot 0.30.0 → 0.32.0

package/index.d.ts

@@ -44,6 +44,7 @@ export declare class ExternalContext {
 export declare function getContext(): Context;
 export declare function isWithinUntil(): boolean;
 export declare function isWithinLoop(): boolean;
+export declare function getLoopIteration(): number;
 export declare function runWithContext<T>(context: Context, callback: () => T): Promise<T>;
 export declare class Context {
     #private;
@@ -53,6 +54,8 @@ export declare class Context {
     get __external(): any;
     get auth(): Auth | null;
     get stateId(): string;
+    get stateTypeName(): string;
+    get method(): string;
     get callerBearerToken(): string | null;
     get cookie(): string;
     get appInternal(): boolean;
@@ -323,6 +326,12 @@ export declare function untilPerWorkflow<T>(idempotencyAlias: string, context: W
     parse?: undefined;
     validate: (result: T) => boolean;
 }): Promise<Exclude<T, boolean>>;
+export declare function untilChanges<T>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<T>, options: {
+    equals: (previous: T, current: T) => boolean;
+    stringify?: (result: T) => string;
+    parse?: (value: string) => T;
+    validate?: (result: T) => boolean;
+}): Promise<T>;
 export declare const zod: {
     tasks: {
         TaskId: z.ZodCustom<protobuf_es.PartialMessage<tasks_pb.TaskId>, protobuf_es.PartialMessage<tasks_pb.TaskId>>;

package/index.js

@@ -9,8 +9,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     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 { auth_pb, errors_pb, protobuf_es, tasks_pb, } from "@reboot-dev/reboot-api";
+var _Reboot_external, _ExternalContext_external, _a, _Context_external, _Context_isInternalConstructing, _Context_stateId, _Context_method, _Context_stateTypeName, _ReaderContext_kind, _WriterContext_kind, _TransactionContext_kind, _WorkflowContext_kind, _Application_servicers, _Application_tokenVerifier, _Application_express, _Application_http, _Application_servers, _Application_createExternalContext, _Application_external;
+import { auth_pb, errors_pb, protobuf_es, toCamelCase, tasks_pb, } from "@reboot-dev/reboot-api";
 import { strict as assert } from "assert";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { fork } from "node:child_process";
@@ -148,6 +148,13 @@ export function isWithinLoop() {
     }
     return store.withinLoop;
 }
+export function getLoopIteration() {
+    const store = contextStorage.getStore();
+    if (!store) {
+        throw new Error("`getLoopIteration` may only be called within a `Servicer` method.");
+    }
+    return store.loopIteration;
+}
 export async function runWithContext(context, callback) {
     return await contextStorage.run({
         context,
@@ -158,6 +165,9 @@ export async function runWithContext(context, callback) {
 export class Context {
     constructor(external, cancelled) {
         _Context_external.set(this, void 0);
+        _Context_stateId.set(this, void 0);
+        _Context_method.set(this, void 0);
+        _Context_stateTypeName.set(this, void 0);
         if (!__classPrivateFieldGet(_a, _a, "f", _Context_isInternalConstructing)) {
             throw new TypeError("Context is not publicly constructable");
         }
@@ -192,7 +202,22 @@ export class Context {
         return null;
     }
     get stateId() {
-        return reboot_native.Context_stateId(__classPrivateFieldGet(this, _Context_external, "f"));
+        if (__classPrivateFieldGet(this, _Context_stateId, "f") === undefined) {
+            __classPrivateFieldSet(this, _Context_stateId, reboot_native.Context_stateId(__classPrivateFieldGet(this, _Context_external, "f")), "f");
+        }
+        return __classPrivateFieldGet(this, _Context_stateId, "f");
+    }
+    get stateTypeName() {
+        if (__classPrivateFieldGet(this, _Context_stateTypeName, "f") === undefined) {
+            __classPrivateFieldSet(this, _Context_stateTypeName, reboot_native.Context_stateTypeName(__classPrivateFieldGet(this, _Context_external, "f")), "f");
+        }
+        return __classPrivateFieldGet(this, _Context_stateTypeName, "f");
+    }
+    get method() {
+        if (__classPrivateFieldGet(this, _Context_method, "f") === undefined) {
+            __classPrivateFieldSet(this, _Context_method, toCamelCase(reboot_native.Context_method(__classPrivateFieldGet(this, _Context_external, "f"))), "f");
+        }
+        return __classPrivateFieldGet(this, _Context_method, "f");
     }
     get callerBearerToken() {
         return reboot_native.Context_callerBearerToken(__classPrivateFieldGet(this, _Context_external, "f"));
@@ -207,7 +232,7 @@ export class Context {
         return reboot_native.Context_generateIdempotentStateId(__classPrivateFieldGet(this, _Context_external, "f"), stateType, serviceName, method, idempotency);
     }
 }
-_a = Context, _Context_external = new WeakMap();
+_a = Context, _Context_external = new WeakMap(), _Context_stateId = new WeakMap(), _Context_method = new WeakMap(), _Context_stateTypeName = new WeakMap();
 _Context_isInternalConstructing = { value: false };
 export class ReaderContext extends Context {
     constructor(external, cancelled) {
@@ -278,6 +303,7 @@ export class WorkflowContext extends Context {
                 if (iteration === null) {
                     return;
                 }
+                store.loopIteration = iteration;
                 yield iteration;
                 if (ms > 0) {
                     await new Promise((resolve) => setTimeout(resolve, ms));
@@ -289,6 +315,7 @@ export class WorkflowContext extends Context {
                 await iterate(false);
             }
             store.withinLoop = false;
+            delete store.loopIteration;
         }
     }
 }
@@ -678,12 +705,9 @@ export async function retryReactivelyUntil(context, condition) {
             }
         }
         catch (e) {
-            if (e instanceof Error) {
-                throw e;
-            }
-            else {
-                throw new Error(`${e}`);
-            }
+            const error = ensureError(e);
+            console.error(error);
+            throw error;
         }
         finally {
             store.withinUntil = false;
@@ -737,10 +761,15 @@ async function memoize(idempotencyAliasOrTuple, context, callable, { stringify =
             return "";
         }
         catch (e) {
-            console.warn(e);
-            throw e;
+            const error = ensureError(e);
+            // We handle printing the exception for `until` in
+            // `retryReactivelyUntil`.
+            if (!until) {
+                console.error(error);
+            }
+            throw error;
         }
-    }), atMostOnce);
+    }), atMostOnce, until);
     // NOTE: we parse and validate `value` every time (even the first
     // time, even though we validate above). These semantics are the
     // same as Python (although Python uses the `type` keyword argument
@@ -806,6 +835,37 @@ export async function until(idempotencyAliasOrTuple, context, callable, options
 export async function untilPerWorkflow(idempotencyAlias, context, callable, options = { validate: undefined }) {
     return await until([idempotencyAlias, PER_WORKFLOW], context, callable, options);
 }
+export async function untilChanges(idempotencyAlias, context, callable, options) {
+    const iteration = getLoopIteration();
+    if (iteration === undefined) {
+        throw new Error("Waiting for changes must be done _within_ a control loop");
+    }
+    if (options.equals === undefined) {
+        // TODO: don't make `equals` required, instead use one of the
+        // various libraries that does deep equality.
+        throw new Error("Missing 'equals' option");
+    }
+    const { equals, ...optionsWithoutEquals } = options;
+    let previous = null;
+    if (iteration > 0) {
+        // Get the previous memoized result!
+        previous = (await untilPerWorkflow(`${idempotencyAlias} #${iteration - 1}`, context, (async () => {
+            throw new Error(`Missing memoized value for '${idempotencyAlias}'`);
+        }), optionsWithoutEquals));
+    }
+    // Wait until previous result does not equal current result.
+    return (await untilPerWorkflow(`${idempotencyAlias} #${iteration}`, context, (async () => {
+        const current = await callable();
+        if (iteration === 0) {
+            return current;
+        }
+        assert(previous !== null);
+        if (!equals(previous, current)) {
+            return current;
+        }
+        return false;
+    }), optionsWithoutEquals));
+}
 const launchSubprocessConsensus = (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

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.30.0",
+    "@reboot-dev/reboot-api": "0.32.0",
     "chalk": "^4.1.2",
     "node-addon-api": "^7.0.0",
     "node-gyp": ">=10.2.0",
@@ -18,7 +18,7 @@
   },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "description": "npm package for Reboot",
   "scripts": {
     "preinstall": "node preinstall.cjs",

package/reboot_native.cc

@@ -2374,6 +2374,43 @@ Napi::Value Context_stateId(const Napi::CallbackInfo& info) {
   return Napi::String::New(info.Env(), state_id);
 }
 
+
+Napi::Value Context_stateTypeName(const Napi::CallbackInfo& info) {
+  Napi::External<py::object> js_external_context =
+      info[0].As<Napi::External<py::object>>();
+
+  // CHECK(...CheckTypeTag(...));
+
+  py::object* py_context = js_external_context.Data();
+
+  std::string state_type_name = RunCallbackOnPythonEventLoop(
+      [py_context]() {
+        py::str state_type_name = py_context->attr("state_type_name");
+        return std::string(state_type_name);
+      });
+
+  return Napi::String::New(info.Env(), state_type_name);
+}
+
+
+Napi::Value Context_method(const Napi::CallbackInfo& info) {
+  Napi::External<py::object> js_external_context =
+      info[0].As<Napi::External<py::object>>();
+
+  // CHECK(...CheckTypeTag(...));
+
+  py::object* py_context = js_external_context.Data();
+
+  std::string method = RunCallbackOnPythonEventLoop(
+      [py_context]() {
+        py::str method = py_context->attr("method");
+        return std::string(method);
+      });
+
+  return Napi::String::New(info.Env(), method);
+}
+
+
 Napi::Value Context_callerBearerToken(
     const Napi::CallbackInfo& info) {
   Napi::External<py::object> js_external_context =
@@ -2672,6 +2709,8 @@ Napi::Value memoize(const Napi::CallbackInfo& info) {
 
   bool at_most_once = info[3].As<Napi::Boolean>();
 
+  bool until = info[4].As<Napi::Boolean>();
+
   return NodePromiseFromPythonTaskWithContext(
       info.Env(),
       "memoize(...) in nodejs",
@@ -2681,7 +2720,8 @@ Napi::Value memoize(const Napi::CallbackInfo& info) {
        alias = std::move(alias),
        how = std::move(how),
        js_callable = std::move(js_callable),
-       at_most_once]() {
+       at_most_once,
+       until]() {
         py::object py_callable = py::cpp_function(
             [js_callable = std::move(js_callable)]() mutable {
               return PythonFutureFromNodePromise(
@@ -2704,7 +2744,8 @@ Napi::Value memoize(const Napi::CallbackInfo& info) {
                 py_context,
                 py_callable,
                 "type_t"_a = py::eval("str"),
-                "at_most_once"_a = at_most_once);
+                "at_most_once"_a = at_most_once,
+                "until"_a = until);
       },
       [](py::object py_json) {
         return py_json.cast<std::string>();
@@ -2875,6 +2916,14 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
       Napi::String::New(env, "Context_stateId"),
       Napi::Function::New<Context_stateId>(env));
 
+  exports.Set(
+      Napi::String::New(env, "Context_stateTypeName"),
+      Napi::Function::New<Context_stateTypeName>(env));
+
+  exports.Set(
+      Napi::String::New(env, "Context_method"),
+      Napi::Function::New<Context_method>(env));
+
   exports.Set(
       Napi::String::New(env, "Context_callerBearerToken"),
       Napi::Function::New<Context_callerBearerToken>(env));

package/reboot_native.cjs

@@ -76,6 +76,8 @@ 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_stateTypeName = reboot_native.exports.Context_stateTypeName;
+exports.Context_method = reboot_native.exports.Context_method;
 exports.Context_callerBearerToken =
   reboot_native.exports.Context_callerBearerToken;
 exports.Context_cookie = reboot_native.exports.Context_cookie;

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.30.0";
+export declare const REBOOT_VERSION = "0.32.0";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.30.0";
+export const REBOOT_VERSION = "0.32.0";