@zhivex-ai/core 1.18.0 → 1.19.1

package/dist/workflow-state-service.js

@@ -1,628 +1,8 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { ConflictError, ValidationError } from "./errors.js";
-import { assertPostgresClient } from "./postgres-client.js";
-import { canonicalStoreFileStem, canonicalStoreKey, ensurePrivateDirectory, writePrivateFile } from "./store-security.js";
-import { normalizeWorkflowRunState, WORKFLOW_RUN_STATE_SCHEMA_VERSION, WORKFLOW_STATE_RECORD_SCHEMA_VERSION } from "./workflow-state-contracts.js";
+/** Compatibility facade. Backend implementations live in dedicated internal modules. */
 export { WORKFLOW_STATE_RECORD_SCHEMA_VERSION } from "./workflow-state-contracts.js";
-const cloneJson = (value) => JSON.parse(JSON.stringify(value));
-const identifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const workflowStateParts = (input) => [input.appName, input.userId, input.sessionId, input.workflowKey];
-const workflowStateKey = (input) => canonicalStoreKey("workflow-state", workflowStateParts(input));
-const legacyWorkflowStateKey = (input) => `${input.appName}:${input.userId}:${input.sessionId}:${input.workflowKey}`;
-const matchesWorkflowStateLookup = (record, input) => record.appName === input.appName &&
-    record.userId === input.userId &&
-    record.sessionId === input.sessionId &&
-    record.workflowKey === input.workflowKey;
-const fileNameForWorkflowState = (input) => `${canonicalStoreFileStem("workflow-state", workflowStateParts(input))}.json`;
-const legacyFileNameForWorkflowState = (input) => workflowStateParts(input).map((part) => encodeURIComponent(part)).join("__") + ".json";
-export const normalizeWorkflowStateRecord = (value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new ValidationError("WorkflowStateRecord must be an object.");
-    }
-    const record = value;
-    if (record.schemaVersion !== undefined && record.schemaVersion > WORKFLOW_STATE_RECORD_SCHEMA_VERSION) {
-        throw new ValidationError(`Unsupported WorkflowStateRecord schemaVersion ${record.schemaVersion}.`);
-    }
-    if (typeof record.appName !== "string" ||
-        typeof record.userId !== "string" ||
-        typeof record.sessionId !== "string" ||
-        typeof record.workflowKey !== "string" ||
-        typeof record.runId !== "string" ||
-        typeof record.status !== "string" ||
-        typeof record.createdAt !== "number" ||
-        typeof record.updatedAt !== "number" ||
-        !record.state) {
-        throw new ValidationError("WorkflowStateRecord is missing required fields.");
-    }
-    return {
-        schemaVersion: WORKFLOW_STATE_RECORD_SCHEMA_VERSION,
-        revision: typeof record.revision === "number" ? record.revision : 1,
-        appName: record.appName,
-        userId: record.userId,
-        sessionId: record.sessionId,
-        workflowKey: record.workflowKey,
-        state: normalizeWorkflowRunState(record.state),
-        status: record.status,
-        runId: record.runId,
-        createdAt: record.createdAt,
-        updatedAt: record.updatedAt
-    };
-};
-export const migrateWorkflowStateRecord = (value, targetVersion = WORKFLOW_STATE_RECORD_SCHEMA_VERSION) => {
-    if (targetVersion !== WORKFLOW_STATE_RECORD_SCHEMA_VERSION) {
-        throw new ValidationError(`Unsupported WorkflowStateRecord migration target ${targetVersion}.`);
-    }
-    return normalizeWorkflowStateRecord(value);
-};
-const assertExpectedRevision = (current, expectedRevision) => {
-    if (expectedRevision !== undefined && (current?.revision ?? 0) !== expectedRevision) {
-        throw new ConflictError("WorkflowStateRecord revision conflict.");
-    }
-};
-const sqliteMutationCount = (result) => {
-    if (!result || typeof result !== "object") {
-        return undefined;
-    }
-    const record = result;
-    const value = record.changes ?? record.changeset ?? record.rowCount;
-    return typeof value === "number" ? value : undefined;
-};
-const cloneRecord = (record) => cloneJson(normalizeWorkflowStateRecord(record));
-const createRecord = (input, existing) => {
-    const now = Date.now();
-    const state = normalizeWorkflowRunState(input.state);
-    return {
-        schemaVersion: WORKFLOW_STATE_RECORD_SCHEMA_VERSION,
-        revision: existing ? existing.revision + 1 : 1,
-        appName: input.appName,
-        userId: input.userId,
-        sessionId: input.sessionId,
-        workflowKey: input.workflowKey,
-        state: cloneJson({ ...state, schemaVersion: WORKFLOW_RUN_STATE_SCHEMA_VERSION }),
-        status: state.status,
-        runId: state.runId,
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now
-    };
-};
-const matchesListInput = (record, input) => record.appName === input.appName &&
-    record.userId === input.userId &&
-    (input.sessionId === undefined || record.sessionId === input.sessionId) &&
-    (input.workflowKey === undefined || record.workflowKey === input.workflowKey) &&
-    (input.status === undefined || record.status === input.status);
-const validateIdentifier = (value, fieldName) => {
-    if (!identifierPattern.test(value)) {
-        throw new ValidationError(`The "${fieldName}" option must match the SQL identifier pattern [A-Za-z_][A-Za-z0-9_]*.`);
-    }
-    return value;
-};
-const getRecordField = (value, candidates) => {
-    if (!value || typeof value !== "object") {
-        return undefined;
-    }
-    const record = value;
-    for (const candidate of candidates) {
-        if (candidate in record) {
-            return record[candidate];
-        }
-    }
-    return undefined;
-};
-const parseWorkflowStateJson = (value) => {
-    if (!value) {
-        return undefined;
-    }
-    if (typeof value === "string") {
-        return normalizeWorkflowStateRecord(JSON.parse(value));
-    }
-    return normalizeWorkflowStateRecord(value);
-};
-const prepareSqliteStatement = (db, sql) => {
-    if (typeof db.prepare === "function") {
-        return db.prepare(sql);
-    }
-    if (typeof db.query === "function") {
-        return db.query(sql);
-    }
-    throw new ValidationError('The "db" option must expose either a "prepare()" or "query()" method.');
-};
-const ensurePostgresTable = (() => {
-    const initializedTables = new WeakMap();
-    return async (client, tableName, createSql) => {
-        let tables = initializedTables.get(client);
-        if (!tables) {
-            tables = new Map();
-            initializedTables.set(client, tables);
-        }
-        let initialization = tables.get(tableName);
-        if (!initialization) {
-            initialization = Promise.resolve(client.query(createSql, [])).then(() => undefined);
-            tables.set(tableName, initialization);
-        }
-        await initialization;
-    };
-})();
-export const createInMemoryWorkflowStateService = () => {
-    const states = new Map();
-    return {
-        saveWorkflowState(input) {
-            const existing = states.get(workflowStateKey(input));
-            assertExpectedRevision(existing, input.expectedRevision);
-            const record = createRecord(input, existing);
-            states.set(workflowStateKey(input), cloneRecord(record));
-            return cloneRecord(record);
-        },
-        loadWorkflowState(input) {
-            const record = states.get(workflowStateKey(input));
-            return record ? cloneRecord(record) : undefined;
-        },
-        listWorkflowStates(input) {
-            return [...states.values()]
-                .filter((record) => matchesListInput(record, input))
-                .sort((left, right) => left.updatedAt - right.updatedAt || left.workflowKey.localeCompare(right.workflowKey))
-                .map(cloneRecord);
-        },
-        deleteWorkflowState(input) {
-            states.delete(workflowStateKey(input));
-        }
-    };
-};
-export const createFileWorkflowStateService = (options) => {
-    const filePath = (input) => path.join(options.directory, fileNameForWorkflowState(input));
-    const legacyFilePath = (input) => path.join(options.directory, legacyFileNameForWorkflowState(input));
-    const load = async (input) => {
-        for (const candidate of [filePath(input), legacyFilePath(input)]) {
-            try {
-                const record = normalizeWorkflowStateRecord(JSON.parse(await fs.readFile(candidate, "utf8")));
-                if (matchesWorkflowStateLookup(record, input)) {
-                    return record;
-                }
-            }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    throw error;
-                }
-            }
-        }
-        return undefined;
-    };
-    return {
-        async saveWorkflowState(input) {
-            const existing = await load(input);
-            assertExpectedRevision(existing, input.expectedRevision);
-            const record = createRecord(input, existing);
-            await ensurePrivateDirectory(options.directory);
-            await writePrivateFile(filePath(input), JSON.stringify(record, null, 2));
-            try {
-                const legacy = normalizeWorkflowStateRecord(JSON.parse(await fs.readFile(legacyFilePath(input), "utf8")));
-                if (matchesWorkflowStateLookup(legacy, input)) {
-                    await fs.unlink(legacyFilePath(input));
-                }
-            }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    throw error;
-                }
-            }
-            return cloneRecord(record);
-        },
-        loadWorkflowState(input) {
-            return load(input);
-        },
-        async listWorkflowStates(input) {
-            let entries;
-            try {
-                entries = await fs.readdir(options.directory);
-            }
-            catch (error) {
-                if (error.code === "ENOENT") {
-                    return [];
-                }
-                throw error;
-            }
-            const records = new Map();
-            for (const entry of entries) {
-                if (!entry.endsWith(".json")) {
-                    continue;
-                }
-                const record = normalizeWorkflowStateRecord(JSON.parse(await fs.readFile(path.join(options.directory, entry), "utf8")));
-                if (matchesListInput(record, input)) {
-                    const key = workflowStateKey(record);
-                    if (!records.has(key) || entry === fileNameForWorkflowState(record)) {
-                        records.set(key, cloneRecord(record));
-                    }
-                }
-            }
-            return [...records.values()].sort((left, right) => left.updatedAt - right.updatedAt || left.workflowKey.localeCompare(right.workflowKey));
-        },
-        async deleteWorkflowState(input) {
-            await fs.unlink(filePath(input)).catch((error) => {
-                if (error.code !== "ENOENT") {
-                    throw error;
-                }
-            });
-            try {
-                const legacy = normalizeWorkflowStateRecord(JSON.parse(await fs.readFile(legacyFilePath(input), "utf8")));
-                if (matchesWorkflowStateLookup(legacy, input)) {
-                    await fs.unlink(legacyFilePath(input));
-                }
-            }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    throw error;
-                }
-            }
-        }
-    };
-};
-export const pruneFileWorkflowStateStore = async (options) => {
-    const now = options.now ?? Date.now();
-    const dryRun = options.dryRun ?? true;
-    let entries;
-    try {
-        entries = await fs.readdir(options.directory);
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return { directory: options.directory, dryRun, deletedWorkflowStateKeys: [], keptWorkflowStateKeys: [] };
-        }
-        throw error;
-    }
-    const records = new Map();
-    for (const entry of entries) {
-        if (!entry.endsWith(".json")) {
-            continue;
-        }
-        const filePath = path.join(options.directory, entry);
-        const record = normalizeWorkflowStateRecord(JSON.parse(await fs.readFile(filePath, "utf8")));
-        const key = workflowStateKey(record);
-        const existing = records.get(key);
-        records.set(key, {
-            filePaths: [...(existing?.filePaths ?? []), filePath],
-            key,
-            updatedAt: entry === fileNameForWorkflowState(record) || !existing ? record.updatedAt : existing.updatedAt
-        });
-    }
-    const sorted = [...records.values()].sort((left, right) => right.updatedAt - left.updatedAt || left.key.localeCompare(right.key));
-    const keepByCount = new Set(options.keepLast === undefined ? [] : sorted.slice(0, Math.max(0, options.keepLast)).map((record) => record.key));
-    const shouldDelete = (record) => !keepByCount.has(record.key) &&
-        (options.olderThanMs !== undefined ? now - record.updatedAt > options.olderThanMs : options.keepLast !== undefined);
-    const deleted = sorted.filter(shouldDelete);
-    if (!dryRun) {
-        for (const record of deleted) {
-            for (const filePath of record.filePaths) {
-                await fs.unlink(filePath);
-            }
-        }
-    }
-    return {
-        directory: options.directory,
-        dryRun,
-        deletedWorkflowStateKeys: deleted.map((record) => record.key),
-        keptWorkflowStateKeys: sorted.filter((record) => !shouldDelete(record)).map((record) => record.key)
-    };
-};
-export const createSqliteWorkflowStateService = (options) => {
-    const tableName = validateIdentifier(options.tableName ?? "zhivex_workflow_states", "tableName");
-    options.db.exec(`
-    CREATE TABLE IF NOT EXISTS ${tableName} (
-      workflow_state_key TEXT PRIMARY KEY,
-      app_name TEXT NOT NULL,
-      user_id TEXT NOT NULL,
-      session_id TEXT NOT NULL,
-      workflow_key TEXT NOT NULL,
-      run_id TEXT NOT NULL,
-      status TEXT NOT NULL,
-      state_json TEXT NOT NULL,
-      created_at_ms INTEGER NOT NULL,
-      updated_at_ms INTEGER NOT NULL
-    )
-  `);
-    const loadStatement = prepareSqliteStatement(options.db, `SELECT state_json FROM ${tableName} WHERE workflow_state_key = ?`);
-    const listStatement = prepareSqliteStatement(options.db, `SELECT state_json FROM ${tableName}
-     WHERE app_name = ?
-       AND user_id = ?
-       AND (? IS NULL OR session_id = ?)
-       AND (? IS NULL OR workflow_key = ?)
-       AND (? IS NULL OR status = ?)
-     ORDER BY updated_at_ms ASC, workflow_key ASC`);
-    const saveStatement = prepareSqliteStatement(options.db, `
-    INSERT INTO ${tableName} (
-      workflow_state_key, app_name, user_id, session_id, workflow_key, run_id, status, state_json, created_at_ms, updated_at_ms
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(workflow_state_key) DO UPDATE SET
-      app_name = excluded.app_name,
-      user_id = excluded.user_id,
-      session_id = excluded.session_id,
-      workflow_key = excluded.workflow_key,
-      run_id = excluded.run_id,
-      status = excluded.status,
-      state_json = excluded.state_json,
-      updated_at_ms = excluded.updated_at_ms
-  `);
-    const updateCasStatement = prepareSqliteStatement(options.db, `
-    UPDATE ${tableName}
-    SET app_name = ?,
-        user_id = ?,
-        session_id = ?,
-        workflow_key = ?,
-        run_id = ?,
-        status = ?,
-        state_json = ?,
-        updated_at_ms = ?
-    WHERE workflow_state_key = ?
-      AND updated_at_ms = ?
-  `);
-    const deleteStatement = prepareSqliteStatement(options.db, `DELETE FROM ${tableName} WHERE workflow_state_key = ?`);
-    const load = (input) => {
-        for (const key of [workflowStateKey(input), legacyWorkflowStateKey(input)]) {
-            const record = parseWorkflowStateJson(getRecordField(loadStatement.get([key]), ["state_json", "stateJson"]));
-            if (record && matchesWorkflowStateLookup(record, input)) {
-                return record;
-            }
-        }
-        return undefined;
-    };
-    const save = (record, options) => {
-        if (options?.expectedRevision !== undefined && options.existing) {
-            const canonical = parseWorkflowStateJson(getRecordField(loadStatement.get([workflowStateKey(record)]), ["state_json", "stateJson"]));
-            if (canonical && matchesWorkflowStateLookup(canonical, record)) {
-                const result = updateCasStatement.run([
-                    record.appName,
-                    record.userId,
-                    record.sessionId,
-                    record.workflowKey,
-                    record.runId,
-                    record.status,
-                    JSON.stringify(record),
-                    record.updatedAt,
-                    workflowStateKey(record),
-                    options.existing.updatedAt
-                ]);
-                if (sqliteMutationCount(result) === 0) {
-                    throw new ConflictError("WorkflowStateRecord revision conflict.");
-                }
-            }
-            else {
-                const legacy = parseWorkflowStateJson(getRecordField(loadStatement.get([legacyWorkflowStateKey(record)]), ["state_json", "stateJson"]));
-                if (!legacy || !matchesWorkflowStateLookup(legacy, record) || legacy.updatedAt !== options.existing.updatedAt) {
-                    throw new ConflictError("WorkflowStateRecord revision conflict.");
-                }
-                saveStatement.run([
-                    workflowStateKey(record),
-                    record.appName,
-                    record.userId,
-                    record.sessionId,
-                    record.workflowKey,
-                    record.runId,
-                    record.status,
-                    JSON.stringify(record),
-                    record.createdAt,
-                    record.updatedAt
-                ]);
-            }
-        }
-        else {
-            saveStatement.run([
-                workflowStateKey(record),
-                record.appName,
-                record.userId,
-                record.sessionId,
-                record.workflowKey,
-                record.runId,
-                record.status,
-                JSON.stringify(record),
-                record.createdAt,
-                record.updatedAt
-            ]);
-        }
-        const legacy = parseWorkflowStateJson(getRecordField(loadStatement.get([legacyWorkflowStateKey(record)]), ["state_json", "stateJson"]));
-        if (legacy && matchesWorkflowStateLookup(legacy, record)) {
-            deleteStatement.run([legacyWorkflowStateKey(record)]);
-        }
-        return cloneRecord(record);
-    };
-    return {
-        saveWorkflowState(input) {
-            const existing = load(input);
-            assertExpectedRevision(existing, input.expectedRevision);
-            return save(createRecord(input, existing), {
-                existing,
-                expectedRevision: input.expectedRevision
-            });
-        },
-        loadWorkflowState(input) {
-            return load(input);
-        },
-        listWorkflowStates(input) {
-            const params = [
-                input.appName,
-                input.userId,
-                input.sessionId ?? null,
-                input.sessionId ?? null,
-                input.workflowKey ?? null,
-                input.workflowKey ?? null,
-                input.status ?? null,
-                input.status ?? null
-            ];
-            const rows = listStatement.all?.(params) ?? [];
-            const records = new Map();
-            for (const row of rows) {
-                const record = parseWorkflowStateJson(getRecordField(row, ["state_json", "stateJson"]));
-                if (record) {
-                    records.set(workflowStateKey(record), record);
-                }
-            }
-            return [...records.values()];
-        },
-        deleteWorkflowState(input) {
-            deleteStatement.run([workflowStateKey(input)]);
-            const legacy = parseWorkflowStateJson(getRecordField(loadStatement.get([legacyWorkflowStateKey(input)]), ["state_json", "stateJson"]));
-            if (legacy && matchesWorkflowStateLookup(legacy, input)) {
-                deleteStatement.run([legacyWorkflowStateKey(input)]);
-            }
-        }
-    };
-};
-export const createPostgresWorkflowStateService = (options) => {
-    assertPostgresClient(options.client);
-    const tableName = validateIdentifier(options.tableName ?? "zhivex_workflow_states", "tableName");
-    const createSql = `
-    CREATE TABLE IF NOT EXISTS ${tableName} (
-      workflow_state_key TEXT PRIMARY KEY,
-      app_name TEXT NOT NULL,
-      user_id TEXT NOT NULL,
-      session_id TEXT NOT NULL,
-      workflow_key TEXT NOT NULL,
-      run_id TEXT NOT NULL,
-      status TEXT NOT NULL,
-      state_json JSONB NOT NULL,
-      created_at_ms BIGINT NOT NULL,
-      updated_at_ms BIGINT NOT NULL
-    )
-  `;
-    const load = async (input) => {
-        await ensurePostgresTable(options.client, tableName, createSql);
-        for (const key of [workflowStateKey(input), legacyWorkflowStateKey(input)]) {
-            const result = await options.client.query(`SELECT state_json FROM ${tableName} WHERE workflow_state_key = $1`, [key]);
-            const record = parseWorkflowStateJson(getRecordField(result.rows[0], ["state_json", "stateJson"]));
-            if (record && matchesWorkflowStateLookup(record, input)) {
-                return record;
-            }
-        }
-        return undefined;
-    };
-    const save = async (record, saveOptions) => {
-        await ensurePostgresTable(options.client, tableName, createSql);
-        if (saveOptions?.expectedRevision !== undefined && saveOptions.existing) {
-            const result = await options.client.query(`UPDATE ${tableName}
-         SET app_name = $2,
-             user_id = $3,
-             session_id = $4,
-             workflow_key = $5,
-             run_id = $6,
-             status = $7,
-             state_json = $8::jsonb,
-             updated_at_ms = $9
-         WHERE workflow_state_key = $1
-           AND updated_at_ms = $10
-         RETURNING state_json`, [
-                workflowStateKey(record),
-                record.appName,
-                record.userId,
-                record.sessionId,
-                record.workflowKey,
-                record.runId,
-                record.status,
-                JSON.stringify(record),
-                record.updatedAt,
-                saveOptions.existing.updatedAt
-            ]);
-            if (result.rows.length === 0) {
-                const migrated = await options.client.query(`UPDATE ${tableName}
-           SET workflow_state_key = $1,
-               app_name = $2,
-               user_id = $3,
-               session_id = $4,
-               workflow_key = $5,
-               run_id = $6,
-               status = $7,
-               state_json = $8::jsonb,
-               updated_at_ms = $9
-           WHERE workflow_state_key = $10
-             AND updated_at_ms = $11
-           RETURNING state_json`, [
-                    workflowStateKey(record),
-                    record.appName,
-                    record.userId,
-                    record.sessionId,
-                    record.workflowKey,
-                    record.runId,
-                    record.status,
-                    JSON.stringify(record),
-                    record.updatedAt,
-                    legacyWorkflowStateKey(record),
-                    saveOptions.existing.updatedAt
-                ]);
-                if (migrated.rows.length === 0) {
-                    throw new ConflictError("WorkflowStateRecord revision conflict.");
-                }
-            }
-        }
-        else {
-            await options.client.query(`INSERT INTO ${tableName} (
-           workflow_state_key, app_name, user_id, session_id, workflow_key, run_id, status, state_json, created_at_ms, updated_at_ms
-         )
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9, $10)
-         ON CONFLICT(workflow_state_key) DO UPDATE SET
-           app_name = EXCLUDED.app_name,
-           user_id = EXCLUDED.user_id,
-           session_id = EXCLUDED.session_id,
-           workflow_key = EXCLUDED.workflow_key,
-           run_id = EXCLUDED.run_id,
-           status = EXCLUDED.status,
-           state_json = EXCLUDED.state_json,
-           updated_at_ms = EXCLUDED.updated_at_ms`, [
-                workflowStateKey(record),
-                record.appName,
-                record.userId,
-                record.sessionId,
-                record.workflowKey,
-                record.runId,
-                record.status,
-                JSON.stringify(record),
-                record.createdAt,
-                record.updatedAt
-            ]);
-        }
-        const legacyResult = await options.client.query(`SELECT state_json FROM ${tableName} WHERE workflow_state_key = $1`, [legacyWorkflowStateKey(record)]);
-        const legacy = parseWorkflowStateJson(getRecordField(legacyResult.rows[0], ["state_json", "stateJson"]));
-        if (legacy && matchesWorkflowStateLookup(legacy, record)) {
-            await options.client.query(`DELETE FROM ${tableName} WHERE workflow_state_key = $1`, [legacyWorkflowStateKey(record)]);
-        }
-        return cloneRecord(record);
-    };
-    return {
-        async saveWorkflowState(input) {
-            const existing = await load(input);
-            assertExpectedRevision(existing, input.expectedRevision);
-            return save(createRecord(input, existing), {
-                existing,
-                expectedRevision: input.expectedRevision
-            });
-        },
-        loadWorkflowState(input) {
-            return load(input);
-        },
-        async listWorkflowStates(input) {
-            await ensurePostgresTable(options.client, tableName, createSql);
-            const result = await options.client.query(`SELECT state_json FROM ${tableName}
-         WHERE app_name = $1
-           AND user_id = $2
-           AND ($3::text IS NULL OR session_id = $3)
-           AND ($4::text IS NULL OR workflow_key = $4)
-           AND ($5::text IS NULL OR status = $5)
-         ORDER BY updated_at_ms ASC, workflow_key ASC`, [input.appName, input.userId, input.sessionId ?? null, input.workflowKey ?? null, input.status ?? null]);
-            const records = new Map();
-            for (const row of result.rows) {
-                const record = parseWorkflowStateJson(getRecordField(row, ["state_json", "stateJson"]));
-                if (record) {
-                    records.set(workflowStateKey(record), record);
-                }
-            }
-            return [...records.values()];
-        },
-        async deleteWorkflowState(input) {
-            await ensurePostgresTable(options.client, tableName, createSql);
-            await options.client.query(`DELETE FROM ${tableName} WHERE workflow_state_key = $1`, [workflowStateKey(input)]);
-            const legacyResult = await options.client.query(`SELECT state_json FROM ${tableName} WHERE workflow_state_key = $1`, [legacyWorkflowStateKey(input)]);
-            const legacy = parseWorkflowStateJson(getRecordField(legacyResult.rows[0], ["state_json", "stateJson"]));
-            if (legacy && matchesWorkflowStateLookup(legacy, input)) {
-                await options.client.query(`DELETE FROM ${tableName} WHERE workflow_state_key = $1`, [legacyWorkflowStateKey(input)]);
-            }
-        }
-    };
-};
+export { normalizeWorkflowStateRecord, migrateWorkflowStateRecord } from "./workflow-state-service/shared.js";
+export { createInMemoryWorkflowStateService } from "./workflow-state-service/memory.js";
+export { createFileWorkflowStateService, pruneFileWorkflowStateStore } from "./workflow-state-service/file.js";
+export { createSqliteWorkflowStateService } from "./workflow-state-service/sqlite.js";
+export { createPostgresWorkflowStateService } from "./workflow-state-service/postgres.js";
 //# sourceMappingURL=workflow-state-service.js.map