@reboot-dev/reboot 0.34.0 → 0.36.0

package/index.d.ts

@@ -1,4 +1,5 @@
 import { errors_pb, IdempotencyOptions, protobuf_es, tasks_pb } from "@reboot-dev/reboot-api";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import { z } from "zod/v4";
 import * as reboot_native from "./reboot_native.cjs";
 import { Application as ExpressApplication, NextFunction as ExpressNextFunction, Request as ExpressRequest, Response as ExpressResponse } from "express";
@@ -55,8 +56,8 @@ export declare class Context {
     readonly stateId: string;
     readonly method: string;
     readonly stateTypeName: string;
-    readonly callerBearerToken: string;
-    readonly cookie: string;
+    readonly callerBearerToken: string | null;
+    readonly cookie: string | null;
     readonly appInternal: boolean;
     readonly auth: Auth | null;
     constructor({ external, stateId, method, stateTypeName, callerBearerToken, cookie, appInternal, auth, cancelled, }: {
@@ -64,8 +65,8 @@ export declare class Context {
         stateId: string;
         method: string;
         stateTypeName: string;
-        callerBearerToken: string;
-        cookie: string;
+        callerBearerToken: string | null;
+        cookie: string | null;
         appInternal: boolean;
         auth: Auth | null;
         cancelled: Promise<void>;
@@ -245,7 +246,7 @@ export declare namespace Application {
     }
 }
 export declare function retryReactivelyUntil(context: WorkflowContext, condition: () => Promise<boolean>): Promise<void>;
-export declare function retryReactivelyUntil<T>(context: WorkflowContext, condition: () => Promise<false | Exclude<T, boolean>>): Promise<Exclude<T, boolean>>;
+export declare function retryReactivelyUntil<T>(context: WorkflowContext, condition: () => Promise<false | T>): Promise<T>;
 export declare const ALWAYS: "ALWAYS";
 export declare const PER_WORKFLOW: "PER_WORKFLOW";
 export declare const PER_ITERATION: "PER_ITERATION";
@@ -255,99 +256,49 @@ export type AtMostLeastOnceTupleType = [
     "PER_WORKFLOW" | "PER_ITERATION"
 ];
 export declare function atMostOnce(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<void>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function atMostOnce<T>(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<T>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<T>;
+export declare function atMostOnce<Schema extends StandardSchemaV1>(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare function atMostOncePerWorkflow(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<void>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function atMostOncePerWorkflow<T>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<T>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<T>;
+export declare function atMostOncePerWorkflow<Schema extends StandardSchemaV1>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare function atLeastOnce(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<void>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function atLeastOnce<T>(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<T>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<T>;
+export declare function atLeastOnce<Schema extends StandardSchemaV1>(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare function atLeastOncePerWorkflow(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<void>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function atLeastOncePerWorkflow<T>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<T>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<T>;
+export declare function atLeastOncePerWorkflow<Schema extends StandardSchemaV1>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export type UntilTupleType = [
     string,
     "ALWAYS" | "PER_WORKFLOW" | "PER_ITERATION"
 ];
 export declare function until(idempotencyAliasOrTuple: string | UntilTupleType, context: WorkflowContext, callable: () => Promise<boolean>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function until<T>(idempotencyAliasOrTuple: string | UntilTupleType, context: WorkflowContext, callable: () => Promise<false | Exclude<T, boolean>>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<Exclude<T, boolean>>;
+export declare function until<Schema extends StandardSchemaV1>(idempotencyAliasOrTuple: string | UntilTupleType, context: WorkflowContext, callable: () => Promise<false | StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare function untilPerWorkflow(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<boolean>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function untilPerWorkflow<T>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<false | Exclude<T, boolean>>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    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 function untilPerWorkflow<Schema extends StandardSchemaV1>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<false | StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
+export declare function untilChanges<Schema extends StandardSchemaV1>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, { equals, schema, }: {
+    equals: (previous: StandardSchemaV1.InferOutput<Schema>, current: StandardSchemaV1.InferOutput<Schema>) => boolean;
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare const zod: {
     tasks: {
         TaskId: z.ZodCustom<protobuf_es.PartialMessage<tasks_pb.TaskId>, protobuf_es.PartialMessage<tasks_pb.TaskId>>;

package/index.js

@@ -10,8 +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 { auth_pb, errors_pb, nodejs_pb, protobuf_es, tasks_pb, toCamelCase, } from "@reboot-dev/reboot-api";
-import { strict as assert } from "assert";
+import { assert, auth_pb, 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";
@@ -726,9 +725,7 @@ export async function retryReactivelyUntil(context, condition) {
 export const ALWAYS = "ALWAYS";
 export const PER_WORKFLOW = "PER_WORKFLOW";
 export const PER_ITERATION = "PER_ITERATION";
-async function memoize(idempotencyAliasOrTuple, context, callable, { stringify = JSON.stringify, parse = JSON.parse, validate, atMostOnce, until = false, }) {
-    assert(stringify !== undefined);
-    assert(parse !== undefined);
+async function memoize(idempotencyAliasOrTuple, context, callable, { schema, atMostOnce, until = false, }) {
     assert(atMostOnce !== undefined);
     if (!(typeof idempotencyAliasOrTuple === "string" ||
         (Array.isArray(idempotencyAliasOrTuple) &&
@@ -744,27 +741,38 @@ async function memoize(idempotencyAliasOrTuple, context, callable, { stringify =
         try {
             const t = await callable();
             if (t !== undefined) {
-                if (validate === undefined) {
-                    // TODO: link to docs about why this is required, when those docs exist.
-                    throw new Error(`Result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' is not 'boolean' but 'validate' option is undefined`);
+                // Fail early if the developer forgot to pass `schema`.
+                if (schema === undefined) {
+                    throw new Error(`Expecting 'schema' as you are returning a value from the function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}'`);
                 }
-                else if (!validate(t)) {
-                    throw new Error(`Calling 'validate' on result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' returned 'false'`);
+                let validate = schema["~standard"].validate(t);
+                if (validate instanceof Promise) {
+                    validate = await validate;
                 }
+                // If the `issues` field exists, the validation failed.
+                if (validate.issues) {
+                    throw new Error(`Failed to validate result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}': ${JSON.stringify(validate.issues, null, 2)}`);
+                }
+                // We use `stringify` from `@reboot-dev/reboot-api` because
+                // it can handle `BigInt` and `Uint8Array` which are common
+                // types from protobuf.
+                //
                 // NOTE: to differentiate `callable` returning `void` (or
-                // explicitly `undefined`) from `stringify` returning an empty
-                // string we use `{ value: stringify(t) }`.
-                const result = { value: stringify(t) };
-                return JSON.stringify(result);
+                // explicitly `undefined`) from `stringify` returning
+                // an empty string we use `{ value: t }`.
+                const result = { value: t };
+                return stringify(result);
             }
-            // Fail early if the developer thinks that they have some value
-            // that they want to validate but we got `undefined`.
-            if (validate !== undefined) {
-                throw new Error("Not expecting `validate` as you are returning `void` (or explicitly `undefined`); did you mean to return a value (or if you want to explicitly return the absence of a value use `null`)");
+            else {
+                // Fail early if the developer thinks that they have some
+                // value that they want to validate but we got `undefined`.
+                if (schema !== undefined) {
+                    throw new Error(`Not expecting 'schema' as you are returning 'void' (or explicitly 'undefined') from the function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' ; did you mean to return a value (or if you want to explicitly return the absence of a value use 'null')`);
+                }
+                // NOTE: using the empty string to represent a `callable`
+                // returning `void` (or explicitly `undefined`).
+                return "";
             }
-            // NOTE: using the empty string to represent a `callable`
-            // returning `void` (or explicitly `undefined`).
-            return "";
         }
         catch (e) {
             const error = ensureError(e);
@@ -782,22 +790,27 @@ async function memoize(idempotencyAliasOrTuple, context, callable, { stringify =
     // instead of the `parse` and `validate` properties we use here).
     assert(result !== undefined);
     if (result !== "") {
-        const { value } = JSON.parse(result);
-        const t = parse(value);
-        if (parse !== JSON.parse) {
-            if (validate === undefined) {
-                throw new Error(`Result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' is not 'boolean' but 'validate' option is undefined`);
-            }
-            else if (!validate(t)) {
-                throw new Error(`Calling 'validate' on result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' returned 'false'`);
-            }
+        // We use `parse` from `@reboot-dev/reboot-api` because it can
+        // handle `BigInt` and `Uint8Array` which are common types from
+        // protobuf.
+        const { value } = parse(result);
+        if (schema === undefined) {
+            throw new Error(`Expecting 'schema' as we have already memoized a result for the function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' has the code been updated to remove a previously existing 'schema'`);
+        }
+        let validate = schema["~standard"].validate(value);
+        if (validate instanceof Promise) {
+            validate = await validate;
+        }
+        // If the `issues` field exists, the validation failed.
+        if (validate.issues) {
+            throw new Error(`Failed to validate result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}': ${JSON.stringify(validate.issues, null, 2)}`);
         }
-        return t;
+        return validate.value;
     }
     // Otherwise `callable` must have returned void (or explicitly
     // `undefined`), fall through.
 }
-export async function atMostOnce(idempotencyAliasOrTuple, context, callable, options = { validate: undefined }) {
+export async function atMostOnce(idempotencyAliasOrTuple, context, callable, options = {}) {
     try {
         return await memoize(idempotencyAliasOrTuple, context, callable, {
             ...options,
@@ -811,19 +824,19 @@ export async function atMostOnce(idempotencyAliasOrTuple, context, callable, opt
         throw e;
     }
 }
-export async function atMostOncePerWorkflow(idempotencyAlias, context, callable, options = { validate: undefined }) {
+export async function atMostOncePerWorkflow(idempotencyAlias, context, callable, options = {}) {
     return atMostOnce([idempotencyAlias, PER_WORKFLOW], context, callable, options);
 }
-export async function atLeastOnce(idempotencyAliasOrTuple, context, callable, options = { validate: undefined }) {
+export async function atLeastOnce(idempotencyAliasOrTuple, context, callable, options = {}) {
     return memoize(idempotencyAliasOrTuple, context, callable, {
         ...options,
         atMostOnce: false,
     });
 }
-export async function atLeastOncePerWorkflow(idempotencyAlias, context, callable, options = { validate: undefined }) {
+export async function atLeastOncePerWorkflow(idempotencyAlias, context, callable, options = {}) {
     return await atLeastOnce([idempotencyAlias, PER_WORKFLOW], context, callable, options);
 }
-export async function until(idempotencyAliasOrTuple, context, callable, options = { validate: undefined }) {
+export async function until(idempotencyAliasOrTuple, context, callable, options = {}) {
     // TODO(benh): figure out how to not use `as` type assertions here
     // to appease the TypeScript compiler which otherwise isn't happy
     // with passing on these types.
@@ -838,26 +851,25 @@ export async function until(idempotencyAliasOrTuple, context, callable, options
         until: true,
     });
 }
-export async function untilPerWorkflow(idempotencyAlias, context, callable, options = { validate: undefined }) {
+export async function untilPerWorkflow(idempotencyAlias, context, callable, options = {}) {
     return await until([idempotencyAlias, PER_WORKFLOW], context, callable, options);
 }
-export async function untilChanges(idempotencyAlias, context, callable, options) {
+export async function untilChanges(idempotencyAlias, context, callable, { equals, schema, }) {
     const iteration = getLoopIteration();
     if (iteration === undefined) {
         throw new Error("Waiting for changes must be done _within_ a control loop");
     }
-    if (options.equals === undefined) {
+    if (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));
+        }), { schema }));
     }
     // Wait until previous result does not equal current result.
     return (await untilPerWorkflow(`${idempotencyAlias} #${iteration}`, context, (async () => {
@@ -870,7 +882,7 @@ export async function untilChanges(idempotencyAlias, context, callable, options)
             return current;
         }
         return false;
-    }), optionsWithoutEquals));
+    }), { schema }));
 }
 const launchSubprocessConsensus = (base64_args) => {
     // Create a child process via `fork` (which does not mean `fork` as

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.34.0",
+    "@reboot-dev/reboot-api": "0.36.0",
     "chalk": "^4.1.2",
     "node-addon-api": "^7.0.0",
     "node-gyp": ">=10.2.0",
@@ -15,11 +15,12 @@
     "@scarf/scarf": "1.4.0",
     "tsx": "^4.19.2",
     "zod": "^3.25.51",
-    "toobusy-js": "^0.5.1"
+    "toobusy-js": "^0.5.1",
+    "@standard-schema/spec": "1.0.0"
   },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "npm package for Reboot",
   "scripts": {
     "preinstall": "node preinstall.cjs",

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.34.0";
+export declare const REBOOT_VERSION = "0.36.0";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.34.0";
+export const REBOOT_VERSION = "0.36.0";