@temelj/workflow 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/store/idempotency.mjs

@@ -1,167 +0,0 @@
-import { WorkflowStateError } from "../errors/base.mjs";
-import "../errors/mod.mjs";
-import { supportsWorkflowAtomicBatchWrite, supportsWorkflowConditionalWrite } from "./capabilities.mjs";
-import { makeEventsKey, makeIdempotencyKey, makeRunKey } from "../store-keys.mjs";
-import { toStorageValue } from "./storage-value.mjs";
-import { isReadableWorkflowRunRecord } from "./validation.mjs";
-//#region src/store/idempotency.ts
-const MAX_IDEMPOTENT_CREATE_WAIT_ATTEMPTS = 16;
-async function createRunWithIdempotency(storage, namespace, store, run) {
-	if (run.namespace !== namespace) throw WorkflowStateError.runNamespaceMismatch(String(run.namespace), namespace);
-	const keyOptions = idempotencyKeyOptionsForRun(run);
-	if (supportsWorkflowAtomicBatchWrite(storage)) return await createRunAtomicallyWithIdempotency(storage, namespace, store, run, keyOptions);
-	const idempotencyClaim = keyOptions === void 0 ? void 0 : await claimWorkflowIdempotencyIndex(storage, namespace, store, run, keyOptions);
-	if (idempotencyClaim?.status === "existing") return idempotencyClaim.run;
-	if (keyOptions !== void 0) assertWorkflowIdempotencyClaimed(run.id, idempotencyClaim);
-	try {
-		await createRunRecordAndEventHistory(storage, namespace, run);
-		return run;
-	} catch (error) {
-		await rollbackWorkflowIdempotencyClaim(storage, idempotencyClaim);
-		throw error;
-	}
-}
-async function createRunRecordAndEventHistory(storage, namespace, run) {
-	const runKey = makeRunKey(namespace, run.id);
-	const eventsKey = makeEventsKey(namespace, run.id);
-	let claim = {};
-	try {
-		if (!supportsWorkflowConditionalWrite(storage)) {
-			if (await storage.get(runKey) !== void 0) WorkflowStateError.runIdAlreadyExists(run.id);
-			if (await storage.get(eventsKey) !== void 0) WorkflowStateError.eventHistoryAlreadyExists(run.id);
-			await storage.set(runKey, toStorageValue(run));
-			claim = { runKey };
-			await storage.set(eventsKey, toStorageValue([]));
-			return {
-				...claim,
-				eventsKey
-			};
-		}
-		if (!await storage.compareAndSet(runKey, void 0, toStorageValue(run))) WorkflowStateError.runIdAlreadyExists(run.id);
-		claim = { runKey };
-		if (!await storage.compareAndSet(eventsKey, void 0, toStorageValue([]))) WorkflowStateError.eventHistoryAlreadyExists(run.id);
-		return {
-			...claim,
-			eventsKey
-		};
-	} catch (error) {
-		await rollbackRunCreationClaim(storage, claim);
-		throw error;
-	}
-}
-async function rollbackRunCreationClaim(storage, claim) {
-	await storage.deleteMany([...claim.runKey === void 0 ? [] : [claim.runKey], ...claim.eventsKey === void 0 ? [] : [claim.eventsKey]]);
-}
-async function rollbackWorkflowIdempotencyClaim(storage, claim) {
-	if (claim?.status !== "claimed") return;
-	if (!supportsWorkflowConditionalWrite(storage)) {
-		await storage.delete(claim.key);
-		return;
-	}
-	await storage.compareAndSet(claim.key, claim.value, void 0);
-}
-async function claimWorkflowIdempotencyIndex(storage, namespace, store, run, keyOptions) {
-	const key = makeIdempotencyKey(namespace, keyOptions);
-	const value = toStorageValue(run.id);
-	if (!supportsWorkflowConditionalWrite(storage)) {
-		const existingRun = await getRunByIdempotencyKey(storage, namespace, store, keyOptions);
-		if (existingRun !== void 0) return {
-			status: "existing",
-			run: existingRun
-		};
-		await storage.set(key, value);
-		return {
-			status: "claimed",
-			key,
-			value
-		};
-	}
-	if (await storage.compareAndSet(key, void 0, value)) return {
-		status: "claimed",
-		key,
-		value
-	};
-	const existingRun = await waitForRunByIdempotencyKey(storage, namespace, store, keyOptions);
-	if (existingRun !== void 0) return {
-		status: "existing",
-		run: existingRun
-	};
-	if (!await releaseStaleWorkflowIdempotencyIndex(storage, namespace, store, keyOptions)) WorkflowStateError.idempotencyKeyClaimedWithoutRun(run.id);
-	if (await storage.compareAndSet(key, void 0, value)) return {
-		status: "claimed",
-		key,
-		value
-	};
-	const reclaimedExistingRun = await waitForRunByIdempotencyKey(storage, namespace, store, keyOptions);
-	if (reclaimedExistingRun !== void 0) return {
-		status: "existing",
-		run: reclaimedExistingRun
-	};
-	WorkflowStateError.idempotencyKeyClaimedWithoutRun(run.id);
-}
-function assertWorkflowIdempotencyClaimed(runId, claim) {
-	if (claim?.status !== "claimed") WorkflowStateError.idempotencyKeyClaimedWithoutRun(runId);
-}
-async function createRunAtomicallyWithIdempotency(storage, namespace, store, run, keyOptions) {
-	for (let attempt = 0; attempt < 2; attempt++) {
-		if (await storage.compareAndSetMany([
-			...atomicIdempotencyClaimItems(namespace, run, keyOptions),
-			{
-				key: makeRunKey(namespace, run.id),
-				expected: void 0,
-				value: toStorageValue(run)
-			},
-			{
-				key: makeEventsKey(namespace, run.id),
-				expected: void 0,
-				value: toStorageValue([])
-			}
-		])) return run;
-		if (keyOptions === void 0) WorkflowStateError.runIdAlreadyExists(run.id);
-		const existingRun = await waitForRunByIdempotencyKey(storage, namespace, store, keyOptions);
-		if (existingRun !== void 0) return existingRun;
-		if (attempt === 0 && await releaseStaleWorkflowIdempotencyIndex(storage, namespace, store, keyOptions)) continue;
-		WorkflowStateError.idempotencyKeyClaimedWithoutRun(run.id);
-	}
-	throw WorkflowStateError.runIdAlreadyExists(run.id);
-}
-function atomicIdempotencyClaimItems(namespace, run, keyOptions) {
-	return keyOptions === void 0 ? [] : [{
-		key: makeIdempotencyKey(namespace, keyOptions),
-		expected: void 0,
-		value: toStorageValue(run.id)
-	}];
-}
-async function getRunByIdempotencyKey(storage, namespace, store, options) {
-	const runId = await storage.get(makeIdempotencyKey(namespace, options));
-	if (!(typeof runId === "string" && runId.trim() !== "")) return;
-	const run = await store.getRun(runId);
-	return run !== void 0 && isReadableWorkflowRunRecord(run, run.namespace) && run.workflowName === options.workflowName && run.workflowVersion === options.workflowVersion && run.idempotencyKey === options.idempotencyKey ? run : void 0;
-}
-function idempotencyKeyOptionsForRun(run) {
-	return run.idempotencyKey === void 0 ? void 0 : {
-		workflowName: run.workflowName,
-		...run.workflowVersion === void 0 ? {} : { workflowVersion: run.workflowVersion },
-		idempotencyKey: run.idempotencyKey
-	};
-}
-async function waitForRunByIdempotencyKey(storage, namespace, store, options) {
-	for (let attempt = 0; attempt < MAX_IDEMPOTENT_CREATE_WAIT_ATTEMPTS; attempt++) {
-		const run = await getRunByIdempotencyKey(storage, namespace, store, options);
-		if (run !== void 0) return run;
-		await Promise.resolve();
-	}
-}
-async function releaseStaleWorkflowIdempotencyIndex(storage, namespace, store, options) {
-	if (!supportsWorkflowConditionalWrite(storage)) return false;
-	const key = makeIdempotencyKey(namespace, options);
-	const value = await storage.get(key);
-	if (value === void 0) return false;
-	if (typeof value === "string" && value.trim() !== "") {
-		const run = await store.getRun(value);
-		if (run !== void 0 && isReadableWorkflowRunRecord(run, run.namespace) && run.workflowName === options.workflowName && run.workflowVersion === options.workflowVersion && run.idempotencyKey === options.idempotencyKey) return false;
-	}
-	return await storage.compareAndSet(key, value, void 0);
-}
-//#endregion
-export { createRunWithIdempotency, getRunByIdempotencyKey };

package/dist/store/message-index.d.mts

@@ -1,21 +0,0 @@
-import { RunId } from "../types/run-id.mjs";
-import "../types/run.mjs";
-import { EventRecord } from "../types/events.mjs";
-import { WorkflowMessageIdempotencyIndex, WorkflowStorage } from "../types/store.mjs";
-import { WorkflowEventAppendSuccessOutcome } from "./event-append.mjs";
-//#region src/store/message-index.d.ts
-interface WorkflowDuplicateMessageAppendOutcome {
-  readonly status: "duplicate";
-  readonly events: readonly EventRecord[];
-}
-declare function duplicateMessageAppendOutcome(runId: RunId, events: readonly EventRecord[], event: EventRecord): WorkflowDuplicateMessageAppendOutcome | undefined;
-declare function projectMessageIdempotencyIndexForAppendOutcome(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, outcome: WorkflowEventAppendSuccessOutcome): Promise<readonly EventRecord[]>;
-declare function reconcileMessageIdempotencyIndexes(storage: WorkflowStorage, namespace: string, runId: RunId, events: readonly EventRecord[]): Promise<readonly WorkflowMessageIdempotencyIndex[]>;
-declare function repairMessageIdempotencyIndexes(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<readonly WorkflowMessageIdempotencyIndex[]>;
-declare function hasMessageIdempotencyKey(storage: WorkflowStorage, namespace: string, runId: RunId, idempotencyKey: string): Promise<boolean>;
-declare function messageIdempotencyIndexValuesFromEvents(events: readonly EventRecord[], runId: RunId): readonly {
-  readonly idempotencyKey: string;
-  readonly value: WorkflowMessageIdempotencyIndex;
-}[];
-//#endregion
-export { WorkflowDuplicateMessageAppendOutcome, duplicateMessageAppendOutcome, hasMessageIdempotencyKey, messageIdempotencyIndexValuesFromEvents, projectMessageIdempotencyIndexForAppendOutcome, reconcileMessageIdempotencyIndexes, repairMessageIdempotencyIndexes };

package/dist/store/message-index.mjs

@@ -1,122 +0,0 @@
-import { WorkflowMessageIdempotencyConflictError } from "../errors/message.mjs";
-import "../errors/mod.mjs";
-import { WorkflowHistory } from "../history/mod.mjs";
-import { supportsWorkflowConditionalWrite } from "./capabilities.mjs";
-import { makeEventsKey, makeMessageIdempotencyKey } from "../store-keys.mjs";
-import { isSameWorkflowStorageValue } from "./revision.mjs";
-import { toStorageValue } from "./storage-value.mjs";
-import { isSameMessageIdempotencyIndex } from "./validation.mjs";
-import { getStoredEventHistory, rollbackAppendedEventIfCurrent } from "./event-history.mjs";
-import { requireReadableStoredWorkflowRun } from "./run.mjs";
-//#region src/store/message-index.ts
-function duplicateMessageAppendOutcome(runId, events, event) {
-	if (!isMessageIdempotencyEvent(event)) return;
-	const existing = new WorkflowHistory(events).messageByIdempotencyKey(event.idempotencyKey);
-	if (existing === void 0) return;
-	requireDuplicateMessageEventMatches(runId, existing, event);
-	return {
-		status: "duplicate",
-		events
-	};
-}
-function isMessageIdempotencyEvent(event) {
-	return event.kind === "message_sent" && event.idempotencyKey !== void 0;
-}
-function requireDuplicateMessageEventMatches(runId, existing, event) {
-	if (existing.messageId === event.messageId && isSameWorkflowStorageValue(existing.payload, event.payload)) return;
-	WorkflowMessageIdempotencyConflictError.conflict({
-		runId,
-		messageId: existing.messageId,
-		idempotencyKey: event.idempotencyKey
-	});
-}
-async function indexMessageIdempotencyKey(storage, namespace, runId, event, events) {
-	if (event.kind !== "message_sent" || event.idempotencyKey === void 0) return;
-	await requireReadableStoredWorkflowRun(storage, namespace, runId);
-	const indexedEvent = indexableMessageEventByIdempotencyKey(new WorkflowHistory(events), event.idempotencyKey);
-	if (indexedEvent === void 0) return;
-	const key = makeMessageIdempotencyKey(namespace, runId, event.idempotencyKey);
-	const value = {
-		runId,
-		messageId: indexedEvent.messageId,
-		timestamp: indexedEvent.timestamp
-	};
-	if (!supportsWorkflowConditionalWrite(storage)) {
-		const current = await storage.get(key);
-		if (current !== void 0) {
-			if (isSameMessageIdempotencyIndex(current, value)) return;
-			WorkflowMessageIdempotencyConflictError.conflict({
-				runId,
-				messageId: indexedEvent.messageId,
-				idempotencyKey: event.idempotencyKey
-			});
-		}
-		await storage.set(key, toStorageValue(value));
-		return;
-	}
-	if (await storage.compareAndSet(key, void 0, toStorageValue(value))) return;
-	const current = await storage.get(key);
-	if (isSameMessageIdempotencyIndex(current, value)) return;
-	WorkflowMessageIdempotencyConflictError.conflict({
-		runId,
-		messageId: indexedEvent.messageId,
-		idempotencyKey: event.idempotencyKey
-	});
-}
-async function projectMessageIdempotencyIndexForAppendOutcome(storage, namespace, runId, event, outcome) {
-	try {
-		await indexMessageIdempotencyKey(storage, namespace, runId, event, outcome.events);
-	} catch (error) {
-		if (outcome.status === "appended") await rollbackAppendedEventIfCurrent(storage, namespace, runId, outcome.events, outcome.previousEventHistory);
-		throw error;
-	}
-	return outcome.events;
-}
-async function reconcileMessageIdempotencyIndexes(storage, namespace, runId, events) {
-	await requireReadableStoredWorkflowRun(storage, namespace, runId);
-	const indexes = messageIdempotencyIndexValuesFromEvents(events, runId);
-	await Promise.all(indexes.map(async ({ idempotencyKey, value }) => {
-		await storeMessageIdempotencyIndex(storage, namespace, runId, idempotencyKey, value);
-	}));
-	return indexes.map((index) => index.value);
-}
-async function repairMessageIdempotencyIndexes(storage, namespace, runId) {
-	await requireReadableStoredWorkflowRun(storage, namespace, runId);
-	return await reconcileMessageIdempotencyIndexes(storage, namespace, runId, (await getStoredEventHistory(storage, makeEventsKey(namespace, runId))).events);
-}
-async function hasMessageIdempotencyKey(storage, namespace, runId, idempotencyKey) {
-	return await storage.get(makeMessageIdempotencyKey(namespace, runId, idempotencyKey)) !== void 0;
-}
-function indexableMessageEventByIdempotencyKey(history, idempotencyKey) {
-	const event = history.messageByIdempotencyKey(idempotencyKey);
-	return event !== void 0 && isIndexableMessageIdempotencyEvent(event) ? event : void 0;
-}
-function messageIdempotencyIndexValuesFromEvents(events, runId) {
-	return new WorkflowHistory(events).latestMessagesByIdempotencyKey().filter(isIndexableMessageIdempotencyEvent).map((event) => ({
-		idempotencyKey: event.idempotencyKey,
-		value: {
-			runId,
-			messageId: event.messageId,
-			timestamp: event.timestamp
-		}
-	}));
-}
-function isIndexableMessageIdempotencyEvent(event) {
-	return event.kind === "message_sent" && event.idempotencyKey !== void 0 && typeof event.messageId === "string" && event.messageId.trim() !== "";
-}
-async function storeMessageIdempotencyIndex(storage, namespace, runId, idempotencyKey, value) {
-	const key = makeMessageIdempotencyKey(namespace, runId, idempotencyKey);
-	const current = await storage.get(key);
-	if (isSameMessageIdempotencyIndex(current, value)) return;
-	if (!supportsWorkflowConditionalWrite(storage)) {
-		await storage.set(key, toStorageValue(value));
-		return;
-	}
-	if (!await storage.compareAndSet(key, current, toStorageValue(value))) WorkflowMessageIdempotencyConflictError.conflict({
-		runId,
-		messageId: value.messageId,
-		idempotencyKey
-	});
-}
-//#endregion
-export { duplicateMessageAppendOutcome, hasMessageIdempotencyKey, messageIdempotencyIndexValuesFromEvents, projectMessageIdempotencyIndexForAppendOutcome, reconcileMessageIdempotencyIndexes, repairMessageIdempotencyIndexes };

package/dist/store/revision.d.mts

@@ -1,4 +0,0 @@
-//#region src/store/revision.d.ts
-declare function isSameWorkflowStorageValue(left: unknown, right: unknown): boolean;
-//#endregion
-export { isSameWorkflowStorageValue };

package/dist/store/revision.mjs

@@ -1,7 +0,0 @@
-import { deepEquals } from "@temelj/value";
-//#region src/store/revision.ts
-function isSameWorkflowStorageValue(left, right) {
-	return deepEquals(left, right);
-}
-//#endregion
-export { isSameWorkflowStorageValue };

package/dist/store/schema.d.mts

@@ -1,14 +0,0 @@
-import { StorageValue } from "@temelj/storage";
-import { z } from "zod";
-//#region src/store/schema.d.ts
-declare const workflowCleanupIndexKeySchema: z.ZodObject<{
-  key: z.ZodString;
-  value: z.ZodCustom<StorageValue, StorageValue>;
-}, z.core.$strip>;
-declare const workflowMessageIdempotencyIndexSchema: z.ZodObject<{
-  runId: z.ZodString;
-  messageId: z.ZodString;
-  timestamp: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
-}, z.core.$strip>;
-//#endregion
-export { workflowCleanupIndexKeySchema, workflowMessageIdempotencyIndexSchema };

package/dist/store/schema.mjs

@@ -1,17 +0,0 @@
-import { nonBlankStringSchema, temporalInstantSchema } from "../types/common.mjs";
-import { runIdSchema } from "../types/run-id.mjs";
-import { persistedValueIssue } from "../types/run.mjs";
-import { messageIdSchema } from "../types/message-id.mjs";
-import { z } from "zod";
-//#region src/store/schema.ts
-const workflowCleanupIndexKeySchema = z.object({
-	key: nonBlankStringSchema,
-	value: z.custom((value) => value !== void 0 && persistedValueIssue(value, "value", /* @__PURE__ */ new WeakSet(), true) === void 0)
-});
-const workflowMessageIdempotencyIndexSchema = z.object({
-	runId: runIdSchema,
-	messageId: messageIdSchema,
-	timestamp: temporalInstantSchema
-});
-//#endregion
-export { workflowCleanupIndexKeySchema, workflowMessageIdempotencyIndexSchema };

package/dist/types/common.d.mts

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import "temporal-polyfill/global";
-//#region src/types/common.d.ts
-declare const temporalInstantSchema: z.ZodCustom<Temporal.Instant, Temporal.Instant>;
-declare const temporalDurationSchema: z.ZodCustom<Temporal.Duration, Temporal.Duration>;
-declare const temporalPositiveDurationSchema: z.ZodCustom<Temporal.Duration, Temporal.Duration>;
-declare const temporalPositiveSafeDurationSchema: z.ZodCustom<Temporal.Duration, Temporal.Duration>;
-declare const temporalNonNegativeDurationSchema: z.ZodCustom<Temporal.Duration, Temporal.Duration>;
-declare const temporalNonNegativeSafeDurationSchema: z.ZodCustom<Temporal.Duration, Temporal.Duration>;
-declare const nonBlankStringSchema: z.ZodString;
-declare const nonBlankStringListSchema: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-declare const positiveSafeIntegerSchema: z.ZodNumber;
-declare const nonNegativeSafeIntegerSchema: z.ZodNumber;
-/** Timer delay after validation and runtime clamping. */
-interface TimerDelay {
-  readonly duration: Temporal.Duration;
-  readonly clampedDelay: number;
-}
-//#endregion
-export { TimerDelay, nonBlankStringListSchema, nonBlankStringSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, temporalDurationSchema, temporalInstantSchema, temporalNonNegativeDurationSchema, temporalNonNegativeSafeDurationSchema, temporalPositiveDurationSchema, temporalPositiveSafeDurationSchema };

package/dist/types/common.mjs

@@ -1,16 +0,0 @@
-import { durationTotal } from "../utility.mjs";
-import { z } from "zod";
-import "temporal-polyfill/global";
-//#region src/types/common.ts
-const temporalInstantSchema = z.instanceof(Temporal.Instant, { error: "Expected a Temporal.Instant" });
-const temporalDurationSchema = z.instanceof(Temporal.Duration, { error: "Expected a Temporal.Duration" });
-const temporalPositiveDurationSchema = temporalDurationSchema.refine((value) => durationTotal(value) > 0, { error: "Expected a positive duration" });
-const temporalPositiveSafeDurationSchema = temporalPositiveDurationSchema.refine((value) => Number.isSafeInteger(durationTotal(value)), { error: "Expected a positive safe duration" });
-const temporalNonNegativeDurationSchema = temporalDurationSchema.refine((value) => durationTotal(value) >= 0, { error: "Expected a non-negative duration" });
-const temporalNonNegativeSafeDurationSchema = temporalNonNegativeDurationSchema.refine((value) => Number.isSafeInteger(durationTotal(value)), { error: "Expected a non-negative safe duration" });
-const nonBlankStringSchema = z.string().refine((value) => value.trim().length > 0, "Expected a non-blank string");
-const nonBlankStringListSchema = z.array(nonBlankStringSchema).readonly();
-const positiveSafeIntegerSchema = z.number().int().positive();
-const nonNegativeSafeIntegerSchema = z.number().int().nonnegative();
-//#endregion
-export { nonBlankStringListSchema, nonBlankStringSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, temporalDurationSchema, temporalInstantSchema, temporalNonNegativeDurationSchema, temporalNonNegativeSafeDurationSchema, temporalPositiveDurationSchema, temporalPositiveSafeDurationSchema };