@proompteng/temporal-bun-sdk 0.2.0 → 0.4.0

package/dist/src/workflow/context.js

@@ -1,14 +1,22 @@
 import { Effect } from 'effect';
-import { ContinueAsNewWorkflowError, WorkflowBlockedError } from './errors';
+import * as Schema from 'effect/Schema';
+import { ContinueAsNewWorkflowError, WorkflowBlockedError, WorkflowQueryHandlerMissingError } from './errors';
+import { normalizeInboundArguments, } from './inbound';
 const DEFAULT_ACTIVITY_START_TO_CLOSE_TIMEOUT_MS = 10_000;
+const MARKER_SIDE_EFFECT = 'temporal-bun-sdk/side-effect';
+const MARKER_VERSION = 'temporal-bun-sdk/get-version';
+const MARKER_PATCH = 'temporal-bun-sdk/patch';
+const MARKER_LOCAL_ACTIVITY = 'temporal-bun-sdk/local-activity';
 export class WorkflowCommandContext {
     #info;
     #guard;
     #intents = [];
+    #activityScheduleEventIds;
     #sequence = 0;
     constructor(params) {
         this.#info = params.info;
         this.#guard = params.guard;
+        this.#activityScheduleEventIds = params.activityScheduleEventIds;
     }
     get intents() {
         return this.#intents;
@@ -25,13 +33,29 @@ export class WorkflowCommandContext {
         this.#sequence += 1;
         return seq;
     }
+    resolveScheduledActivityEventId(activityId) {
+        return this.#activityScheduleEventIds?.get(activityId);
+    }
+    previousIntent(sequence) {
+        return this.#guard.getPreviousIntent(sequence);
+    }
     get info() {
         return this.#info;
     }
 }
 export const createWorkflowContext = (params) => {
-    const commandContext = new WorkflowCommandContext({ info: params.info, guard: params.determinismGuard });
+    const commandContext = new WorkflowCommandContext({
+        info: params.info,
+        guard: params.determinismGuard,
+        activityScheduleEventIds: params.activityScheduleEventIds,
+    });
+    const updateRegistry = new WorkflowUpdateRegistry();
     const activityResults = params.activityResults ?? new Map();
+    const inboundSignals = new WorkflowInboundSignals({
+        guard: params.determinismGuard,
+        deliveries: params.signalDeliveries,
+    });
+    const queryRegistry = new WorkflowQueryRegistry({ guard: params.determinismGuard });
     const activities = {
         schedule(activityType, args = [], options = {}) {
             return Effect.sync(() => {
@@ -39,12 +63,27 @@ export const createWorkflowContext = (params) => {
                 commandContext.addIntent(intent);
                 const resolution = activityResults.get(intent.activityId);
                 if (!resolution) {
+                    // In query mode we must not block; return a deterministic command ref so query
+                    // handlers can surface the latest known state without introducing new commands.
+                    if (params.determinismGuard.isQueryMode()) {
+                        return createCommandRef(intent, { activityId: intent.activityId });
+                    }
                     throw new WorkflowBlockedError(`Activity ${intent.activityId} pending`);
                 }
                 if (resolution.status === 'failed') {
                     throw resolution.error;
                 }
-                return createCommandRef(intent, { activityId: intent.activityId, result: resolution.value });
+                // When the activity result is already available (e.g., during replay/query),
+                // return the resolved value instead of a command reference so workflow code
+                // sees the decoded activity output.
+                return resolution.value;
+            });
+        },
+        cancel(activityId, options = {}) {
+            return Effect.sync(() => {
+                const intent = buildRequestCancelActivityIntent(commandContext, activityId, options);
+                commandContext.addIntent(intent);
+                return createCommandRef(intent, { activityId });
             });
         },
     };
@@ -56,7 +95,22 @@ export const createWorkflowContext = (params) => {
                 }
                 const intent = buildStartTimerIntent(commandContext, options);
                 commandContext.addIntent(intent);
-                return createCommandRef(intent, { timerId: intent.timerId });
+                // If the timer hasn't fired yet, block the workflow so it will resume
+                // when the corresponding TimerFired event is observed on replay.
+                if (!params.timerResults?.has(intent.timerId)) {
+                    if (params.determinismGuard.isQueryMode()) {
+                        return { timerId: intent.timerId };
+                    }
+                    throw new WorkflowBlockedError(`Timer ${intent.timerId} pending`);
+                }
+                return { timerId: intent.timerId };
+            });
+        },
+        cancel(timerId, options = {}) {
+            return Effect.sync(() => {
+                const intent = buildCancelTimerIntent(commandContext, timerId, options);
+                commandContext.addIntent(intent);
+                return createCommandRef(intent, { timerId });
             });
         },
     };
@@ -77,11 +131,89 @@ export const createWorkflowContext = (params) => {
                 return createCommandRef(intent);
             });
         },
+        on(handle, handler, options) {
+            return inboundSignals.on(handle, handler, options);
+        },
+        waitFor(handle, options) {
+            return inboundSignals.waitFor(handle, options);
+        },
+        drain(handle, options) {
+            return inboundSignals.drain(handle, options);
+        },
+        requestCancel(workflowId, options = {}) {
+            return Effect.sync(() => {
+                const intent = buildRequestCancelExternalWorkflowIntent(commandContext, workflowId, options);
+                commandContext.addIntent(intent);
+                return createCommandRef(intent);
+            });
+        },
+    };
+    const queries = {
+        register(handle, resolver, options) {
+            const effect = queryRegistry.register(handle, resolver, options);
+            // Ensure registration occurs immediately even if caller forgets to yield/await.
+            Effect.runSync(effect);
+            return effect;
+        },
+        resolve(handle, input, metadata) {
+            return queryRegistry.resolve(handle, input, metadata);
+        },
     };
     const determinism = {
         now: () => params.determinismGuard.nextTime(() => Date.now()),
         random: () => params.determinismGuard.nextRandom(() => Math.random()),
+        sideEffect: ({ compute, identifier }) => runSideEffect({
+            commandContext,
+            markerName: MARKER_SIDE_EFFECT,
+            identifier,
+            compute,
+        }),
+        getVersion: ({ changeId, minSupported, maxSupported }) => runGetVersion({ commandContext, changeId, minSupported, maxSupported }),
+        patched: (patchId) => runPatchMarker({ commandContext, patchId, deprecated: false }),
+        deprecatePatch: (patchId) => {
+            runPatchMarker({ commandContext, patchId, deprecated: true });
+        },
+        recordMarker: (options) => {
+            const intent = buildRecordMarkerIntent(commandContext, options.markerName, options.details);
+            commandContext.addIntent(intent);
+        },
+        localActivity: (activityType, args = [], options) => runLocalActivity({
+            commandContext,
+            activityType,
+            args,
+            handler: options?.handler,
+            activityId: options?.activityId,
+        }),
+    };
+    const upsertSearchAttributes = (attributes) => {
+        const intent = buildUpsertSearchAttributesIntent(commandContext, attributes);
+        commandContext.addIntent(intent);
     };
+    const upsertMemo = (memo) => {
+        const intent = buildModifyWorkflowPropertiesIntent(commandContext, memo);
+        commandContext.addIntent(intent);
+    };
+    const cancelWorkflow = (details) => {
+        const intent = buildCancelWorkflowIntent(commandContext, details);
+        commandContext.addIntent(intent);
+    };
+    const updates = {
+        register(definition, handler, options) {
+            updateRegistry.register(definition, handler, options?.validator);
+        },
+        registerDefault(handler) {
+            updateRegistry.registerDefault(handler);
+        },
+    };
+    if (params.updates) {
+        for (const definition of params.updates) {
+            // Some callers supply update definitions as metadata and register handlers at runtime.
+            // Only auto-register when a handler is present to avoid throwing during workflow replay.
+            if ('handler' in definition && typeof definition.handler === 'function') {
+                updateRegistry.register(definition, definition.handler, definition.validator);
+            }
+        }
+    }
     const context = {
         input: params.input,
         info: params.info,
@@ -89,7 +221,12 @@ export const createWorkflowContext = (params) => {
         timers,
         childWorkflows,
         signals,
+        queries,
         determinism,
+        updates,
+        upsertSearchAttributes,
+        upsertMemo,
+        cancelWorkflow,
         continueAsNew(options) {
             return Effect.sync(() => {
                 const intent = buildContinueAsNewIntent(commandContext, options);
@@ -98,7 +235,7 @@ export const createWorkflowContext = (params) => {
             }).pipe(Effect.flatMap(() => Effect.fail(new ContinueAsNewWorkflowError())));
         },
     };
-    return { context, commandContext };
+    return { context, commandContext, queryRegistry, updateRegistry };
 };
 const createCommandRef = (intent, extras) => ({
     id: intent.id,
@@ -132,12 +269,37 @@ const buildScheduleActivityIntent = (ctx, activityType, args, options) => {
 };
 const buildStartTimerIntent = (ctx, options) => {
     const sequence = ctx.nextSequence();
+    const previous = ctx.previousIntent(sequence);
+    const timeoutMs = previous && previous.kind === 'start-timer' && typeof previous.timeoutMs === 'number'
+        ? previous.timeoutMs
+        : options.timeoutMs;
     return {
         id: `start-timer-${sequence}`,
         kind: 'start-timer',
         sequence,
         timerId: options.timerId ?? `timer-${sequence}`,
-        timeoutMs: options.timeoutMs,
+        timeoutMs,
+    };
+};
+const buildCancelTimerIntent = (ctx, timerId, options) => {
+    const sequence = ctx.nextSequence();
+    return {
+        id: `cancel-timer-${sequence}`,
+        kind: 'cancel-timer',
+        sequence,
+        timerId,
+        startedEventId: options.startedEventId ? String(options.startedEventId) : undefined,
+    };
+};
+const buildRequestCancelActivityIntent = (ctx, activityId, options) => {
+    const sequence = ctx.nextSequence();
+    const scheduledEventId = options.scheduledEventId ?? ctx.resolveScheduledActivityEventId(activityId);
+    return {
+        id: `cancel-activity-${sequence}`,
+        kind: 'request-cancel-activity',
+        sequence,
+        activityId,
+        scheduledEventId: scheduledEventId !== undefined ? String(scheduledEventId) : undefined,
     };
 };
 const buildStartChildWorkflowIntent = (ctx, workflowType, args, options) => {
@@ -162,6 +324,191 @@ const buildStartChildWorkflowIntent = (ctx, workflowType, args, options) => {
         cronSchedule: options.cronSchedule,
     };
 };
+const buildRequestCancelExternalWorkflowIntent = (ctx, workflowId, options) => {
+    const sequence = ctx.nextSequence();
+    return {
+        id: `cancel-external-${sequence}`,
+        kind: 'request-cancel-external-workflow',
+        sequence,
+        namespace: options.namespace ?? ctx.info.namespace,
+        workflowId,
+        runId: options.runId,
+        childWorkflowOnly: options.childWorkflowOnly ?? false,
+        reason: options.reason,
+    };
+};
+const buildCancelWorkflowIntent = (ctx, details) => {
+    const sequence = ctx.nextSequence();
+    return {
+        id: `cancel-workflow-${sequence}`,
+        kind: 'cancel-workflow',
+        sequence,
+        details,
+    };
+};
+const buildRecordMarkerIntent = (ctx, markerName, details) => {
+    const sequence = ctx.nextSequence();
+    return {
+        id: `record-marker-${sequence}`,
+        kind: 'record-marker',
+        sequence,
+        markerName,
+        details,
+    };
+};
+const buildUpsertSearchAttributesIntent = (ctx, attributes) => {
+    const sequence = ctx.nextSequence();
+    return {
+        id: `upsert-search-attributes-${sequence}`,
+        kind: 'upsert-search-attributes',
+        sequence,
+        searchAttributes: attributes,
+    };
+};
+const buildModifyWorkflowPropertiesIntent = (ctx, memo) => {
+    const sequence = ctx.nextSequence();
+    return {
+        id: `modify-workflow-properties-${sequence}`,
+        kind: 'modify-workflow-properties',
+        sequence,
+        memo,
+    };
+};
+const runSideEffect = (params) => {
+    const sequence = params.commandContext.nextSequence();
+    const previous = params.commandContext.previousIntent(sequence);
+    if (previous && previous.kind === 'record-marker' && previous.markerName === params.markerName) {
+        const intent = {
+            ...previous,
+            sequence,
+        };
+        params.commandContext.addIntent(intent);
+        const details = intent.details ?? {};
+        if ('result' in details) {
+            return details.result;
+        }
+        return details;
+    }
+    const value = params.compute();
+    const intent = {
+        id: `record-marker-${sequence}`,
+        kind: 'record-marker',
+        sequence,
+        markerName: params.markerName,
+        details: {
+            ...(params.identifier ? { id: params.identifier } : {}),
+            result: value,
+        },
+    };
+    params.commandContext.addIntent(intent);
+    return value;
+};
+const runGetVersion = (params) => {
+    const sequence = params.commandContext.nextSequence();
+    const previous = params.commandContext.previousIntent(sequence);
+    if (previous && previous.kind === 'record-marker' && previous.markerName === MARKER_VERSION) {
+        const intent = { ...previous, sequence };
+        params.commandContext.addIntent(intent);
+        const details = intent.details ?? {};
+        const version = typeof details.version === 'number' ? details.version : undefined;
+        if (version === undefined) {
+            throw new WorkflowBlockedError('Version marker missing version payload');
+        }
+        return version;
+    }
+    if (params.maxSupported < params.minSupported) {
+        throw new WorkflowBlockedError('maxSupported version must be >= minSupported version');
+    }
+    const version = params.maxSupported;
+    const intent = {
+        id: `version-${sequence}`,
+        kind: 'record-marker',
+        sequence,
+        markerName: MARKER_VERSION,
+        details: {
+            changeId: params.changeId,
+            version,
+        },
+    };
+    params.commandContext.addIntent(intent);
+    return version;
+};
+const runPatchMarker = (params) => {
+    const sequence = params.commandContext.nextSequence();
+    const previous = params.commandContext.previousIntent(sequence);
+    if (previous && previous.kind === 'record-marker' && previous.markerName === MARKER_PATCH) {
+        const intent = { ...previous, sequence };
+        params.commandContext.addIntent(intent);
+        return true;
+    }
+    const intent = {
+        id: `patch-${sequence}`,
+        kind: 'record-marker',
+        sequence,
+        markerName: MARKER_PATCH,
+        details: {
+            patchId: params.patchId,
+            deprecated: params.deprecated,
+        },
+    };
+    params.commandContext.addIntent(intent);
+    return true;
+};
+const runLocalActivity = (params) => {
+    const sequence = params.commandContext.nextSequence();
+    const activityId = params.activityId ?? `local-activity-${sequence}`;
+    const previous = params.commandContext.previousIntent(sequence);
+    const readPreviousResult = (intent) => {
+        const details = intent.details ?? {};
+        if ('status' in details && details.status === 'failed') {
+            const message = typeof details.errorMessage === 'string' ? details.errorMessage : 'Local activity failed';
+            throw new Error(message);
+        }
+        return details.result ?? details.payload;
+    };
+    if (previous && previous.kind === 'record-marker' && previous.markerName === MARKER_LOCAL_ACTIVITY) {
+        const intent = { ...previous, sequence };
+        params.commandContext.addIntent(intent);
+        return readPreviousResult(intent);
+    }
+    if (!params.handler) {
+        throw new WorkflowBlockedError('Local activity handler is required during initial execution');
+    }
+    try {
+        const value = params.handler(...params.args);
+        const intent = {
+            id: `local-activity-${sequence}`,
+            kind: 'record-marker',
+            sequence,
+            markerName: MARKER_LOCAL_ACTIVITY,
+            details: {
+                activityId,
+                activityType: params.activityType,
+                status: 'completed',
+                result: value,
+            },
+        };
+        params.commandContext.addIntent(intent);
+        return value;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const intent = {
+            id: `local-activity-${sequence}`,
+            kind: 'record-marker',
+            sequence,
+            markerName: MARKER_LOCAL_ACTIVITY,
+            details: {
+                activityId,
+                activityType: params.activityType,
+                status: 'failed',
+                errorMessage: message,
+            },
+        };
+        params.commandContext.addIntent(intent);
+        throw error;
+    }
+};
 const buildSignalExternalWorkflowIntent = (ctx, signalName, args, options) => {
     const sequence = ctx.nextSequence();
     return {
@@ -194,4 +541,177 @@ const buildContinueAsNewIntent = (ctx, options = {}) => {
         cronSchedule: options.cronSchedule,
     };
 };
+class WorkflowInboundSignals {
+    #guard;
+    #buffers = new Map();
+    constructor(params) {
+        this.#guard = params.guard;
+        for (const delivery of params.deliveries ?? []) {
+            const queue = this.#buffers.get(delivery.name) ?? [];
+            queue.push({ args: [...delivery.args], metadata: delivery.metadata ?? {} });
+            this.#buffers.set(delivery.name, queue);
+        }
+    }
+    on(handle, handler, options) {
+        const entry = this.#shift(handle.name);
+        if (!entry) {
+            return Effect.fail(new WorkflowBlockedError(`Signal "${handle.name}" not yet delivered`));
+        }
+        const handlerName = resolveHandlerName(options?.name, handler, handle.name);
+        return this.#decode(handle, entry)
+            .pipe(Effect.tap((payload) => this.#record(handle.name, handlerName, payload, entry.metadata)))
+            .pipe(Effect.flatMap((payload) => handler(payload, entry.metadata)));
+    }
+    waitFor(handle, options) {
+        const entry = this.#shift(handle.name);
+        if (!entry) {
+            return Effect.fail(new WorkflowBlockedError(`Signal "${handle.name}" not yet delivered`));
+        }
+        const handlerName = options?.name ?? 'waitFor';
+        return this.#decode(handle, entry)
+            .pipe(Effect.tap((payload) => this.#record(handle.name, handlerName, payload, entry.metadata)))
+            .pipe(Effect.map((payload) => ({ payload, metadata: entry.metadata })));
+    }
+    drain(handle, options) {
+        const entries = this.#drain(handle.name);
+        if (entries.length === 0) {
+            return Effect.fail(new WorkflowBlockedError(`Signal "${handle.name}" not yet delivered`));
+        }
+        const handlerName = options?.name ?? 'drain';
+        return runSequential(entries, (entry) => this.#decode(handle, entry)
+            .pipe(Effect.tap((payload) => this.#record(handle.name, handlerName, payload, entry.metadata)))
+            .pipe(Effect.map((payload) => ({ payload, metadata: entry.metadata }))));
+    }
+    #shift(name) {
+        const queue = this.#buffers.get(name);
+        if (!queue || queue.length === 0) {
+            return undefined;
+        }
+        return queue.shift();
+    }
+    #drain(name) {
+        const queue = this.#buffers.get(name);
+        if (!queue || queue.length === 0) {
+            return [];
+        }
+        this.#buffers.set(name, []);
+        return queue;
+    }
+    #decode(handle, entry) {
+        const normalized = normalizeInboundArguments(entry.args, handle.decodeArgumentsAsArray);
+        return Schema.decodeUnknown(handle.schema)(normalized);
+    }
+    #record(signalName, handlerName, payload, metadata) {
+        return Effect.sync(() => this.#guard.recordSignalDelivery({
+            signalName,
+            handlerName,
+            payload,
+            eventId: metadata.eventId ?? null,
+            workflowTaskCompletedEventId: metadata.workflowTaskCompletedEventId ?? null,
+            identity: metadata.identity ?? null,
+        }));
+    }
+}
+export class WorkflowUpdateRegistry {
+    #handlers = new Map();
+    #defaultHandler;
+    register(definition, handler, validator) {
+        if (typeof handler !== 'function') {
+            throw new Error(`Workflow update "${definition.name}" must provide a handler`);
+        }
+        this.#handlers.set(definition.name, {
+            name: definition.name,
+            input: definition.input,
+            handler: handler,
+            validator: validator,
+        });
+    }
+    registerDefault(handler) {
+        this.#defaultHandler = {
+            name: '__default__',
+            input: Schema.Unknown,
+            handler,
+        };
+    }
+    get(name) {
+        return this.#handlers.get(name);
+    }
+    getDefault() {
+        return this.#defaultHandler;
+    }
+    list() {
+        return Array.from(this.#handlers.values());
+    }
+}
+export class WorkflowQueryRegistry {
+    #guard;
+    #handlers = new Map();
+    constructor(params) {
+        this.#guard = params.guard;
+    }
+    register(handle, resolver, options) {
+        return Effect.sync(() => {
+            this.#handlers.set(handle.name, {
+                handle: handle,
+                resolver: resolver,
+                handlerName: options?.name ?? resolver.name ?? handle.name,
+            });
+        });
+    }
+    resolve(handle, input, metadata) {
+        const entry = this.#handlers.get(handle.name);
+        if (!entry) {
+            return Effect.fail(new WorkflowQueryHandlerMissingError(handle.name));
+        }
+        const invocationMetadata = metadata ?? {};
+        const value = (input ?? undefined);
+        const resolver = entry.resolver;
+        return resolver(value, invocationMetadata)
+            .pipe(Effect.tap((result) => this.#recordQueryEvaluation(entry, {
+            status: 'success',
+            decoded: value,
+            result,
+        }, invocationMetadata, { name: handle.name, id: invocationMetadata.id ?? `local:${handle.name}` })))
+            .pipe(Effect.tapError((error) => this.#recordQueryEvaluation(entry, { status: 'failure', decoded: value, error }, invocationMetadata, {
+            name: handle.name,
+            id: invocationMetadata.id ?? `local:${handle.name}`,
+        })));
+    }
+    evaluate(request) {
+        const entry = this.#handlers.get(request.name);
+        if (!entry) {
+            return Effect.fail(new WorkflowQueryHandlerMissingError(request.name));
+        }
+        const metadata = request.metadata ?? {};
+        const normalized = normalizeInboundArguments(request.args, entry.handle.decodeInputAsArray) ?? {};
+        return Schema.decodeUnknown(entry.handle.inputSchema)(normalized)
+            .pipe(Effect.flatMap((decoded) => entry.resolver(decoded, metadata)
+            .pipe(Effect.map((result) => ({ status: 'success', decoded, result })))
+            .pipe(Effect.catchAll((error) => Effect.succeed({ status: 'failure', decoded, error })))))
+            .pipe(Effect.tap((payload) => this.#recordQueryEvaluation(entry, payload, metadata, request)))
+            .pipe(Effect.map((payload) => payload.status === 'success'
+            ? { request, status: 'success', result: payload.result }
+            : { request, status: 'failure', error: payload.error }));
+    }
+    list() {
+        return Array.from(this.#handlers.values());
+    }
+    #recordQueryEvaluation(entry, payload, metadata, request) {
+        return Effect.sync(() => this.#guard.recordQueryEvaluation({
+            queryName: request.name,
+            handlerName: entry.handlerName,
+            request: payload.decoded,
+            identity: metadata.identity ?? null,
+            queryId: request.id,
+            result: payload.status === 'success' ? payload.result : undefined,
+            error: payload.status === 'failure' ? payload.error : undefined,
+        }));
+    }
+}
+const resolveHandlerName = (configured, handler, fallback) => configured ?? handler?.name ?? fallback;
+const runSequential = (entries, factory) => entries.reduce((effect, entry) => effect.pipe(Effect.flatMap((results) => factory(entry).pipe(Effect.map((result) => {
+    const next = results.slice();
+    next.push(result);
+    return next;
+})))), Effect.succeed([]));
 //# sourceMappingURL=context.js.map