@workflow/world-local 5.0.0-beta.10 → 5.0.0-beta.12

package/dist/storage/runs-storage.js

@@ -0,0 +1,130 @@
+import path from 'node:path';
+import { WorkflowRunNotFoundError } from '@workflow/errors';
+import { applyAttributeChanges, AttributeValidationError, validateAttributeChanges, WorkflowRunSchema, } from '@workflow/world';
+import { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';
+import { assertSafeEntityId, paginatedFileSystemQuery, readJSONWithFallback, taggedPath, writeJSON, } from '../fs.js';
+import { filterRunData } from './filters.js';
+import { getObjectCreatedAt } from './helpers.js';
+/**
+ * Per-run in-process async mutex. Serializes concurrent writes that
+ * touch the same run JSON file — both attribute writes via
+ * `experimentalSetAttributes` and run-lifecycle writes (run_started,
+ * run_completed, run_failed, run_cancelled) acquire it. Without the
+ * shared lock, an attribute write that lands between a lifecycle
+ * handler's read and write would be silently overwritten by the
+ * lifecycle write's stale attribute snapshot.
+ *
+ * Lifecycle writers acquire the lock and re-read the run file inside
+ * the critical section to pick up any attributes that landed since
+ * their pre-validation read.
+ */
+const runFileLocks = new Map();
+export function withRunFileLock(key, fn) {
+    const prev = runFileLocks.get(key);
+    const taskBox = {};
+    const task = (async () => {
+        if (prev)
+            await prev.catch(() => undefined);
+        try {
+            return await fn();
+        }
+        finally {
+            if (runFileLocks.get(key) === taskBox.task) {
+                runFileLocks.delete(key);
+            }
+        }
+    })();
+    taskBox.task = task;
+    runFileLocks.set(key, task);
+    return task;
+}
+/**
+ * Creates the runs storage implementation using the filesystem.
+ * Implements the Storage['runs'] interface with get and list operations,
+ * plus an internal `fileIdFilter` on `list` for tag-scoped recovery queries.
+ */
+export function createRunsStorage(basedir, tag) {
+    return {
+        get: (async (id, params) => {
+            assertSafeEntityId('runId', id);
+            const run = await readJSONWithFallback(basedir, 'runs', id, WorkflowRunSchema, tag);
+            if (!run) {
+                throw new WorkflowRunNotFoundError(id);
+            }
+            const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+            return filterRunData(run, resolveData);
+        }),
+        list: (async (params) => {
+            const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+            const result = await paginatedFileSystemQuery({
+                directory: path.join(basedir, 'runs'),
+                schema: WorkflowRunSchema,
+                fileIdFilter: params?.fileIdFilter,
+                filter: (run) => {
+                    if (params?.workflowName &&
+                        run.workflowName !== params.workflowName) {
+                        return false;
+                    }
+                    if (params?.status && run.status !== params.status) {
+                        return false;
+                    }
+                    return true;
+                },
+                sortOrder: params?.pagination?.sortOrder ?? 'desc',
+                limit: params?.pagination?.limit,
+                cursor: params?.pagination?.cursor,
+                getCreatedAt: getObjectCreatedAt('wrun'),
+                getId: (run) => run.runId,
+            });
+            // If resolveData is "none", replace input/output with undefined
+            if (resolveData === 'none') {
+                return {
+                    ...result,
+                    data: result.data.map((run) => ({
+                        ...run,
+                        input: undefined,
+                        output: undefined,
+                    })),
+                };
+            }
+            return result;
+        }),
+        experimentalSetAttributes: async (runId, changes, options) => {
+            assertSafeEntityId('runId', runId);
+            return withRunFileLock(runId, async () => {
+                const run = await readJSONWithFallback(basedir, 'runs', runId, WorkflowRunSchema, tag);
+                if (!run) {
+                    throw new WorkflowRunNotFoundError(runId);
+                }
+                // Server-side validation. The SDK validates before sending, but
+                // the world is the final authority — re-check so direct callers
+                // (tests, other consumers) cannot bypass the limits.
+                try {
+                    validateAttributeChanges(changes, {
+                        existingKeys: Object.keys(run.attributes ?? {}),
+                        allowReservedAttributes: options?.allowReservedAttributes,
+                    });
+                }
+                catch (err) {
+                    if (err instanceof AttributeValidationError) {
+                        // Re-throw as a plain error; callers (the SDK) wrap as
+                        // FatalError on their side.
+                        throw err;
+                    }
+                    throw err;
+                }
+                const nextAttributes = applyAttributeChanges(run.attributes, changes);
+                const updatedRun = {
+                    ...run,
+                    attributes: nextAttributes,
+                    updatedAt: new Date(),
+                };
+                await writeJSON(taggedPath(basedir, 'runs', runId, tag), updatedRun, {
+                    overwrite: true,
+                });
+                return { attributes: nextAttributes };
+            });
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runs-storage.js","sourceRoot":"","sources":["../../src/storage/runs-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport { WorkflowRunNotFoundError } from '@workflow/errors';\nimport type {\n  AttributeChange,\n  ExperimentalSetAttributesResult,\n  ListWorkflowRunsParams,\n  PaginatedResponse,\n  Storage,\n  WorkflowRun,\n  WorkflowRunWithoutData,\n} from '@workflow/world';\nimport {\n  applyAttributeChanges,\n  AttributeValidationError,\n  validateAttributeChanges,\n  WorkflowRunSchema,\n} from '@workflow/world';\nimport { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';\nimport {\n  assertSafeEntityId,\n  paginatedFileSystemQuery,\n  readJSONWithFallback,\n  taggedPath,\n  writeJSON,\n} from '../fs.js';\nimport { filterRunData } from './filters.js';\nimport { getObjectCreatedAt } from './helpers.js';\n\n/**\n * Internal extension of `ListWorkflowRunsParams` that adds a `fileIdFilter`\n * for scoping queries by raw filename (e.g., by tag suffix). Kept out of the\n * public `Storage['runs']['list']` surface — consumers of `@workflow/world`\n * must not see this option.\n */\nexport interface LocalListWorkflowRunsParams extends ListWorkflowRunsParams {\n  fileIdFilter?: (fileId: string) => boolean;\n}\n\nexport interface LocalRunsStorage {\n  get: Storage['runs']['get'];\n  list: {\n    (\n      params: LocalListWorkflowRunsParams & { resolveData: 'none' }\n    ): Promise<PaginatedResponse<WorkflowRunWithoutData>>;\n    (\n      params?: LocalListWorkflowRunsParams & { resolveData?: 'all' }\n    ): Promise<PaginatedResponse<WorkflowRun>>;\n    (\n      params?: LocalListWorkflowRunsParams\n    ): Promise<PaginatedResponse<WorkflowRun | WorkflowRunWithoutData>>;\n  };\n  experimentalSetAttributes(\n    runId: string,\n    changes: AttributeChange[],\n    options?: { allowReservedAttributes?: boolean }\n  ): Promise<ExperimentalSetAttributesResult>;\n}\n\n/**\n * Per-run in-process async mutex. Serializes concurrent writes that\n * touch the same run JSON file — both attribute writes via\n * `experimentalSetAttributes` and run-lifecycle writes (run_started,\n * run_completed, run_failed, run_cancelled) acquire it. Without the\n * shared lock, an attribute write that lands between a lifecycle\n * handler's read and write would be silently overwritten by the\n * lifecycle write's stale attribute snapshot.\n *\n * Lifecycle writers acquire the lock and re-read the run file inside\n * the critical section to pick up any attributes that landed since\n * their pre-validation read.\n */\nconst runFileLocks = new Map<string, Promise<unknown>>();\n\nexport function withRunFileLock<T>(\n  key: string,\n  fn: () => Promise<T>\n): Promise<T> {\n  const prev = runFileLocks.get(key);\n  const taskBox: { task?: Promise<T> } = {};\n  const task = (async () => {\n    if (prev) await prev.catch(() => undefined);\n    try {\n      return await fn();\n    } finally {\n      if (runFileLocks.get(key) === taskBox.task) {\n        runFileLocks.delete(key);\n      }\n    }\n  })();\n  taskBox.task = task;\n  runFileLocks.set(key, task);\n  return task;\n}\n\n/**\n * Creates the runs storage implementation using the filesystem.\n * Implements the Storage['runs'] interface with get and list operations,\n * plus an internal `fileIdFilter` on `list` for tag-scoped recovery queries.\n */\nexport function createRunsStorage(\n  basedir: string,\n  tag?: string\n): LocalRunsStorage {\n  return {\n    get: (async (id: string, params?: any) => {\n      assertSafeEntityId('runId', id);\n      const run = await readJSONWithFallback(\n        basedir,\n        'runs',\n        id,\n        WorkflowRunSchema,\n        tag\n      );\n      if (!run) {\n        throw new WorkflowRunNotFoundError(id);\n      }\n      const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;\n      return filterRunData(run, resolveData);\n    }) as Storage['runs']['get'],\n\n    list: (async (params?: LocalListWorkflowRunsParams) => {\n      const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;\n      const result = await paginatedFileSystemQuery({\n        directory: path.join(basedir, 'runs'),\n        schema: WorkflowRunSchema,\n        fileIdFilter: params?.fileIdFilter,\n        filter: (run) => {\n          if (\n            params?.workflowName &&\n            run.workflowName !== params.workflowName\n          ) {\n            return false;\n          }\n          if (params?.status && run.status !== params.status) {\n            return false;\n          }\n          return true;\n        },\n        sortOrder: params?.pagination?.sortOrder ?? 'desc',\n        limit: params?.pagination?.limit,\n        cursor: params?.pagination?.cursor,\n        getCreatedAt: getObjectCreatedAt('wrun'),\n        getId: (run) => run.runId,\n      });\n\n      // If resolveData is \"none\", replace input/output with undefined\n      if (resolveData === 'none') {\n        return {\n          ...result,\n          data: result.data.map((run) => ({\n            ...run,\n            input: undefined,\n            output: undefined,\n          })) as WorkflowRunWithoutData[],\n        };\n      }\n\n      return result;\n    }) as LocalRunsStorage['list'],\n\n    experimentalSetAttributes: async (runId, changes, options) => {\n      assertSafeEntityId('runId', runId);\n\n      return withRunFileLock(runId, async () => {\n        const run = await readJSONWithFallback(\n          basedir,\n          'runs',\n          runId,\n          WorkflowRunSchema,\n          tag\n        );\n        if (!run) {\n          throw new WorkflowRunNotFoundError(runId);\n        }\n\n        // Server-side validation. The SDK validates before sending, but\n        // the world is the final authority — re-check so direct callers\n        // (tests, other consumers) cannot bypass the limits.\n        try {\n          validateAttributeChanges(changes, {\n            existingKeys: Object.keys(run.attributes ?? {}),\n            allowReservedAttributes: options?.allowReservedAttributes,\n          });\n        } catch (err) {\n          if (err instanceof AttributeValidationError) {\n            // Re-throw as a plain error; callers (the SDK) wrap as\n            // FatalError on their side.\n            throw err;\n          }\n          throw err;\n        }\n\n        const nextAttributes = applyAttributeChanges(run.attributes, changes);\n        const updatedRun = {\n          ...run,\n          attributes: nextAttributes,\n          updatedAt: new Date(),\n        };\n\n        await writeJSON(taggedPath(basedir, 'runs', runId, tag), updatedRun, {\n          overwrite: true,\n        });\n\n        return { attributes: nextAttributes };\n      });\n    },\n  };\n}\n"]}

package/dist/storage/steps-storage.d.ts

@@ -0,0 +1,7 @@
+import type { Storage } from '@workflow/world';
+/**
+ * Creates the steps storage implementation using the filesystem.
+ * Implements the Storage['steps'] interface with get and list operations.
+ */
+export declare function createStepsStorage(basedir: string, tag?: string): Storage['steps'];
+//# sourceMappingURL=steps-storage.d.ts.map

package/dist/storage/steps-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps-storage.d.ts","sourceRoot":"","sources":["../../src/storage/steps-storage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAWhE;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAiDlB"}

package/dist/storage/steps-storage.js

@@ -0,0 +1,52 @@
+import path from 'node:path';
+import { StepSchema } from '@workflow/world';
+import { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';
+import { assertSafeEntityId, paginatedFileSystemQuery, readJSONWithFallback, } from '../fs.js';
+import { filterStepData } from './filters.js';
+import { getObjectCreatedAt } from './helpers.js';
+/**
+ * Creates the steps storage implementation using the filesystem.
+ * Implements the Storage['steps'] interface with get and list operations.
+ */
+export function createStepsStorage(basedir, tag) {
+    return {
+        get: (async (runId, stepId, params) => {
+            assertSafeEntityId('runId', runId);
+            assertSafeEntityId('stepId', stepId);
+            const compositeKey = `${runId}-${stepId}`;
+            const step = await readJSONWithFallback(basedir, 'steps', compositeKey, StepSchema, tag);
+            if (!step) {
+                throw new Error(`Step ${stepId} in run ${runId} not found`);
+            }
+            const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+            return filterStepData(step, resolveData);
+        }),
+        list: (async (params) => {
+            assertSafeEntityId('runId', params.runId);
+            const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+            const result = await paginatedFileSystemQuery({
+                directory: path.join(basedir, 'steps'),
+                schema: StepSchema,
+                filePrefix: `${params.runId}-`,
+                sortOrder: params.pagination?.sortOrder ?? 'desc',
+                limit: params.pagination?.limit,
+                cursor: params.pagination?.cursor,
+                getCreatedAt: getObjectCreatedAt('step'),
+                getId: (step) => step.stepId,
+            });
+            // If resolveData is "none", replace input/output with undefined
+            if (resolveData === 'none') {
+                return {
+                    ...result,
+                    data: result.data.map((step) => ({
+                        ...step,
+                        input: undefined,
+                        output: undefined,
+                    })),
+                };
+            }
+            return result;
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/storage.d.ts

@@ -1,3 +1,10 @@
-import { type Storage } from '@workflow/world';
-export declare function createStorage(basedir: string): Storage;
+/**
+ * Filesystem-based storage implementation for workflow data.
+ *
+ * This module provides a complete Storage implementation that persists
+ * workflow runs, steps, events, and hooks to the local filesystem.
+ *
+ * @module
+ */
+export { createStorage } from './storage/index.js';
 //# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAEA,OAAO,EAWL,KAAK,OAAO,EAGb,MAAM,iBAAiB,CAAC;AA4NzB,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA0UtD"}
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}