From 9e0f26adb49dff1c0e7359f3a3bef13581653cb3 Mon Sep 17 00:00:00 2001 From: James Martinez Date: Fri, 17 Apr 2026 15:45:25 -0500 Subject: [PATCH 1/4] refactor(openworkflow): extract StepHistory from execution.ts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Move the in-memory step-attempt ledger (successful-result cache, running/ failed maps, failure counts, resolved step names, step-attempt limit) out of StepExecutor and into a dedicated StepHistory class. StepExecutor now delegates to a narrow API instead of manipulating several parallel maps inline. Pure refactor — no behavior change. --- packages/openworkflow/worker/execution.ts | 443 ++++-------------- .../openworkflow/worker/step-history.test.ts | 262 +++++++++++ packages/openworkflow/worker/step-history.ts | 372 +++++++++++++++ 3 files changed, 728 insertions(+), 349 deletions(-) create mode 100644 packages/openworkflow/worker/step-history.test.ts create mode 100644 packages/openworkflow/worker/step-history.ts diff --git a/packages/openworkflow/worker/execution.ts b/packages/openworkflow/worker/execution.ts index 84eb8fc8..9f2c9b62 100644 --- a/packages/openworkflow/worker/execution.ts +++ b/packages/openworkflow/worker/execution.ts @@ -7,10 +7,8 @@ import { } from "../core/error.js"; import type { JsonValue } from "../core/json.js"; import type { StandardSchemaV1 } from "../core/standard-schema.js"; -import type { StepAttempt, StepAttemptCache } from "../core/step-attempt.js"; +import type { StepAttempt } from "../core/step-attempt.js"; import { - getCachedStepAttempt, - addToStepAttemptCache, normalizeStepOutput, calculateDateFromDuration, createSleepContext, @@ -36,6 +34,20 @@ import { validateInput, type WorkflowRun, } from "../core/workflow-run.js"; +import { + defaultWaitTimeoutAt, + getContextTimeoutAt, + StepHistory, + StepLimitExceededError, + WORKFLOW_STEP_LIMIT, +} from "./step-history.js"; + +export { + WORKFLOW_STEP_LIMIT, + STEP_LIMIT_EXCEEDED_ERROR_CODE, + createStepExecutionStateFromAttempts, + type StepExecutionState, +} from "./step-history.js"; /** * Signal thrown when a workflow needs to sleep. Contains the time when the @@ -135,30 +147,6 @@ const TERMINAL_STEP_RETRY_POLICY: RetryPolicy = { maximumAttempts: 1, }; -/** Maximum number of step attempts allowed for a single workflow run. */ -export const WORKFLOW_STEP_LIMIT = 1000; - -/** Error code used when a workflow run exceeds the step-attempt limit. */ -export const STEP_LIMIT_EXCEEDED_ERROR_CODE = "STEP_LIMIT_EXCEEDED"; - -/** - * Error thrown when a workflow run reaches the maximum allowed step attempts. - */ -class StepLimitExceededError extends Error { - readonly code = STEP_LIMIT_EXCEEDED_ERROR_CODE; - readonly limit: number; - readonly stepCount: number; - - constructor(limit: number, stepCount: number) { - super( - `Exceeded the step limit of ${String(limit)} attempts (current count: ${String(stepCount)})`, - ); - this.name = "StepLimitExceededError"; - this.limit = limit; - this.stepCount = stepCount; - } -} - /** * Convert a step-limit error to a persisted serialized error payload. * @param error - Step-limit error @@ -192,53 +180,6 @@ function resolveStepRetryPolicy(partial?: Partial): RetryPolicy { return { ...DEFAULT_STEP_RETRY_POLICY, ...partial }; } -/** - * Derived in-memory step state for a single workflow execution pass. - */ -export interface StepExecutionState { - cache: StepAttemptCache; - failedCountsByStepName: ReadonlyMap; - failedByStepName: ReadonlyMap; - runningByStepName: ReadonlyMap; -} - -/** - * Build step execution state from loaded attempts in one pass. - * @param attempts - Loaded step attempts for the workflow run - * @returns Successful cache plus failed-attempt counts by step name - */ -export function createStepExecutionStateFromAttempts( - attempts: readonly StepAttempt[], -): StepExecutionState { - const cache = new Map(); - const failedCountsByStepName = new Map(); - const failedByStepName = new Map(); - const runningByStepName = new Map(); - - for (const attempt of attempts) { - if (attempt.status === "completed" || attempt.status === "succeeded") { - cache.set(attempt.stepName, attempt); - continue; - } - - if (attempt.status === "failed") { - const previousCount = failedCountsByStepName.get(attempt.stepName) ?? 0; - failedCountsByStepName.set(attempt.stepName, previousCount + 1); - failedByStepName.set(attempt.stepName, attempt); - continue; - } - - runningByStepName.set(attempt.stepName, attempt); - } - - return { - cache, - failedCountsByStepName, - failedByStepName, - runningByStepName, - }; -} - /** * Resolve wait timeout input to an absolute deadline. * @param timeout - Relative/absolute timeout input @@ -270,40 +211,6 @@ function resolveWaitTimeoutAt( return result.value; } -/** - * Default wait timeout: 1 year from a base time. - * @param base - Base timestamp (defaults to now) - * @returns Timeout deadline - */ -function defaultWaitTimeoutAt(base: Readonly = new Date()): Date { - const timeoutAt = new Date(base); - timeoutAt.setFullYear(timeoutAt.getFullYear() + 1); - return timeoutAt; -} - -/** - * Extract the timeout from a persisted step attempt's context. - * Works for both workflow and signal-wait step types. - * @param attempt - Running step attempt - * @returns Timeout deadline, or null when context has no timeout - */ -function getContextTimeoutAt(attempt: Readonly): Date | null { - if ( - attempt.context?.kind !== "workflow" && - attempt.context?.kind !== "signal-wait" - ) { - return null; - } - - const { timeoutAt } = attempt.context; - if (timeoutAt === null) { - // backward compatibility for previously persisted workflow contexts - // (signal-wait timeoutAt is never null per SignalWaitStepAttemptContext). - return defaultWaitTimeoutAt(attempt.createdAt); - } - return new Date(timeoutAt); -} - /** * Determine whether the workflow timeout has elapsed before the child completed. * @param attempt - Running workflow step attempt @@ -328,58 +235,6 @@ function hasWorkflowTimedOut( return true; } -/** - * Resolve the next wake-up timestamp for a running wait step attempt. - * @param attempt - Running step attempt - * @returns Wake-up timestamp, or null when the attempt is not a wait step - */ -function getRunningWaitAttemptResumeAt( - attempt: Readonly, -): Date | null { - if (attempt.status !== "running") { - return null; - } - - if (attempt.kind === "sleep" && attempt.context?.kind === "sleep") { - const resumeAt = new Date(attempt.context.resumeAt); - return Number.isFinite(resumeAt.getTime()) ? resumeAt : null; - } - - if (attempt.kind !== "signal-wait" && attempt.kind !== "workflow") { - return null; - } - - const timeoutAt = - getContextTimeoutAt(attempt) ?? defaultWaitTimeoutAt(attempt.createdAt); - return Number.isFinite(timeoutAt.getTime()) - ? timeoutAt - : defaultWaitTimeoutAt(attempt.createdAt); -} - -/** - * Compute the earliest wake-up timestamp across running wait step attempts. - * @param attempts - Persisted step attempts for the workflow run - * @returns Earliest wake-up timestamp, or null when no running wait exists - */ -function getEarliestRunningWaitResumeAt( - attempts: readonly StepAttempt[], -): Date | null { - let earliest: Date | null = null; - - for (const attempt of attempts) { - const resumeAt = getRunningWaitAttemptResumeAt(attempt); - if (!resumeAt) { - continue; - } - - if (!earliest || resumeAt.getTime() < earliest.getTime()) { - earliest = resumeAt; - } - } - - return earliest; -} - /** * Complete running sleep step attempts whose resume timestamp has elapsed. * Malformed historical resume timestamps are treated as elapsed for backward @@ -392,20 +247,16 @@ async function completeElapsedRunningSleepAttempts( backend: Backend; workflowRunId: string; workerId: string; - attempts: StepAttempt[]; + history: StepHistory; }>, ): Promise { let hasPendingRunningSleep = false; - for (let i = 0; i < options.attempts.length; i += 1) { - const attempt = options.attempts[i]; - if (!attempt) continue; + // Snapshot running attempts since we mutate history during iteration. + const running = [...options.history.runningAttempts()]; - if ( - attempt.status !== "running" || - attempt.kind !== "sleep" || - attempt.context?.kind !== "sleep" - ) { + for (const attempt of running) { + if (attempt.kind !== "sleep" || attempt.context?.kind !== "sleep") { continue; } @@ -423,7 +274,7 @@ async function completeElapsedRunningSleepAttempts( output: null, }); - options.attempts[i] = completed; + options.history.recordCompletion(completed); } return hasPendingRunningSleep; @@ -487,8 +338,7 @@ export interface StepExecutorOptions { backend: Backend; workflowRunId: string; workerId: string; - attempts: StepAttempt[]; - stepLimit?: number; + history: StepHistory; executionFence: ExecutionFenceController; } @@ -510,30 +360,14 @@ class StepExecutor implements StepApi { private readonly backend: Backend; private readonly workflowRunId: string; private readonly workerId: string; - private readonly stepLimit: number; - private stepCount: number; - private cache: StepAttemptCache; - private readonly failedCountsByStepName: Map; - private readonly failedByStepName: Map; - private readonly runningByStepName: Map; - private readonly expectedNextStepIndexByName: Map; - private readonly resolvedStepNames: Set; + private readonly history: StepHistory; private readonly executionFence: ExecutionFenceController; constructor(options: Readonly) { this.backend = options.backend; this.workflowRunId = options.workflowRunId; this.workerId = options.workerId; - this.stepLimit = Math.max(1, options.stepLimit ?? WORKFLOW_STEP_LIMIT); - this.stepCount = options.attempts.length; - - const state = createStepExecutionStateFromAttempts(options.attempts); - this.cache = state.cache; - this.failedCountsByStepName = new Map(state.failedCountsByStepName); - this.failedByStepName = new Map(state.failedByStepName); - this.runningByStepName = new Map(state.runningByStepName); - this.expectedNextStepIndexByName = new Map(); - this.resolvedStepNames = new Set(); + this.history = options.history; this.executionFence = options.executionFence; } @@ -541,62 +375,6 @@ class StepExecutor implements StepApi { this.executionFence.assertActive(); } - /** - * Resolve the earliest known wake-up timestamp for running wait attempts in - * this execution pass. - * @param fallbackResumeAt - Candidate wake-up timestamp for the current wait - * @returns Earliest known wake-up timestamp - */ - private resolveEarliestRunningWaitResumeAt( - fallbackResumeAt: Readonly, - ): Date { - const earliestRunningWaitResumeAt = getEarliestRunningWaitResumeAt([ - ...this.runningByStepName.values(), - ]); - if (!earliestRunningWaitResumeAt) { - return new Date(fallbackResumeAt); - } - - const fallbackMs = fallbackResumeAt.getTime(); - if (!Number.isFinite(fallbackMs)) { - return earliestRunningWaitResumeAt; - } - - if (earliestRunningWaitResumeAt.getTime() < fallbackMs) { - return earliestRunningWaitResumeAt; - } - - return new Date(fallbackResumeAt); - } - - /** - * Resolve a step name to a deterministic, unique key for this workflow - * execution pass. When a name collides, suffixes are appended as - * `name:1`, `name:2`, etc. If those suffixes already exist (including - * user-provided names), indexing continues until an unused name is found. - * @param stepName - User-provided step name - * @returns Resolved step name used for durable step state - */ - private resolveStepName(stepName: string): string { - if (!this.resolvedStepNames.has(stepName)) { - this.resolvedStepNames.add(stepName); - return stepName; - } - - const expectedNextIndex = - this.expectedNextStepIndexByName.get(stepName) ?? 1; - for (let index = expectedNextIndex; ; index += 1) { - const resolvedName = `${stepName}:${String(index)}`; - if (this.resolvedStepNames.has(resolvedName)) { - continue; - } - - this.expectedNextStepIndexByName.set(stepName, index + 1); - this.resolvedStepNames.add(resolvedName); - return resolvedName; - } - } - // ---- step.run ----------------------------------------------------------- async run( @@ -604,17 +382,15 @@ class StepExecutor implements StepApi { fn: StepFunction, ): Promise { const { name: baseStepName, retryPolicy: retryPolicyOverride } = config; - const stepName = this.resolveStepName(baseStepName); + const stepName = this.history.resolveStepName(baseStepName); - // return cached result if available - const existingAttempt = getCachedStepAttempt(this.cache, stepName); + const existingAttempt = this.history.findCached(stepName); if (existingAttempt) { return existingAttempt.output as Output; } - // not in cache, create new step attempt this.assertExecutionActive(); - this.ensureStepLimitNotReached(); + this.history.ensureCanRecordNewAttempt(); const attempt = await this.backend.createStepAttempt({ workflowRunId: this.workflowRunId, workerId: this.workerId, @@ -623,27 +399,18 @@ class StepExecutor implements StepApi { config: {}, context: null, }); - - this.stepCount += 1; - this.runningByStepName.set(stepName, attempt); + this.history.recordNewAttempt(attempt); try { - // execute step function const result = await fn(); const output = normalizeStepOutput(result); - - // mark success const savedAttempt = await this.backend.completeStepAttempt({ workflowRunId: this.workflowRunId, stepAttemptId: attempt.id, workerId: this.workerId, output, }); - - // cache result - this.cache = addToStepAttemptCache(this.cache, savedAttempt); - this.runningByStepName.delete(stepName); - + this.history.recordCompletion(savedAttempt); return savedAttempt.output as Output; } catch (error) { return this.failStepWithError( @@ -658,13 +425,10 @@ class StepExecutor implements StepApi { // ---- step.sleep --------------------------------------------------------- async sleep(baseStepName: string, duration: DurationString): Promise { - const stepName = this.resolveStepName(baseStepName); + const stepName = this.history.resolveStepName(baseStepName); - // return cached result if this sleep already completed - const existingAttempt = getCachedStepAttempt(this.cache, stepName); - if (existingAttempt) return; + if (this.history.findCached(stepName)) return; - // create new step attempt for the sleep const result = calculateDateFromDuration(duration); if (!result.ok) { throw result.error; @@ -673,7 +437,7 @@ class StepExecutor implements StepApi { const context = createSleepContext(resumeAt); this.assertExecutionActive(); - this.ensureStepLimitNotReached(); + this.history.ensureCanRecordNewAttempt(); const attempt = await this.backend.createStepAttempt({ workflowRunId: this.workflowRunId, workerId: this.workerId, @@ -682,44 +446,41 @@ class StepExecutor implements StepApi { config: {}, context, }); - this.stepCount += 1; - this.runningByStepName.set(stepName, attempt); + this.history.recordNewAttempt(attempt); - // throw sleep signal to trigger postponement - // we do not mark the step as completed here; it will be updated - // when the workflow resumes - throw new SleepSignal(this.resolveEarliestRunningWaitResumeAt(resumeAt)); + // Sleep attempts are not marked completed here — that happens when the + // workflow resumes. + throw new SleepSignal( + this.history.resolveEarliestRunningWaitResumeAt(resumeAt), + ); } - // ---- step.runWorkflow ----------------------------------------------- + // ---- step.runWorkflow -------------------------------------------------- async runWorkflow( spec: WorkflowSpec, input?: RunInput, options?: Readonly, ): Promise { - const stepName = this.resolveStepName(options?.name ?? spec.name); + const stepName = this.history.resolveStepName(options?.name ?? spec.name); const request: RunWorkflowStepRequest = { workflowSpec: spec, input, timeout: options?.timeout, }; - const existingAttempt = getCachedStepAttempt(this.cache, stepName); + const existingAttempt = this.history.findCached(stepName); if (existingAttempt) { return existingAttempt.output as Output; } - // Workflow steps are terminal once a failure is persisted. This prevents + // Workflow steps are terminal once a failure is persisted. Prevents // replay from spawning duplicate children when Promise.all short-circuits // on a sibling SleepSignal in the same pass. - const failedAttempt = this.failedByStepName.get(stepName); - if ( - failedAttempt?.kind === "workflow" && - failedAttempt.childWorkflowRunNamespaceId && - failedAttempt.childWorkflowRunId - ) { - const serializedFailedError = failedAttempt.error; + const terminallyFailedAttempt = + this.history.findTerminallyFailedWorkflow(stepName); + if (terminallyFailedAttempt) { + const serializedFailedError = terminallyFailedAttempt.error; const failedError = serializedFailedError && typeof serializedFailedError === "object" && @@ -729,14 +490,14 @@ class StepExecutor implements StepApi { : new Error(`Workflow step "${stepName}" previously failed`); throw new StepError({ stepName, - stepFailedAttempts: this.failedCountsByStepName.get(stepName) ?? 1, + stepFailedAttempts: this.history.failedAttemptCount(stepName), retryPolicy: TERMINAL_STEP_RETRY_POLICY, error: failedError, }); } // Resume a running workflow attempt (replay path) - const runningAttempt = this.runningByStepName.get(stepName); + const runningAttempt = this.history.findRunning(stepName); if (runningAttempt?.kind === "workflow") { return await this.resolveRunningWorkflow( stepName, @@ -748,7 +509,7 @@ class StepExecutor implements StepApi { // First encounter — create the workflow step and child workflow run const timeoutAt = resolveWaitTimeoutAt(request.timeout); this.assertExecutionActive(); - this.ensureStepLimitNotReached(); + this.history.ensureCanRecordNewAttempt(); const attempt = await this.backend.createStepAttempt({ workflowRunId: this.workflowRunId, workerId: this.workerId, @@ -757,11 +518,9 @@ class StepExecutor implements StepApi { config: {}, context: createWorkflowContext(timeoutAt), }); - this.stepCount += 1; - this.runningByStepName.set(stepName, attempt); + this.history.recordNewAttempt(attempt); const linkedAttempt = await this.linkChildWorkflowRun( - stepName, attempt, request, ).catch( @@ -791,7 +550,7 @@ class StepExecutor implements StepApi { runningAttempt.childWorkflowRunId && runningAttempt.childWorkflowRunNamespaceId ? runningAttempt - : await this.linkChildWorkflowRun(stepName, runningAttempt, request); + : await this.linkChildWorkflowRun(runningAttempt, request); const failWorkflowStep = (error: Error): Promise => this.failStepWithError( @@ -836,8 +595,7 @@ class StepExecutor implements StepApi { workerId: this.workerId, output: childRun.output, }); - this.runningByStepName.delete(stepName); - this.cache = addToStepAttemptCache(this.cache, completed); + this.history.recordCompletion(completed); return completed.output as Output; } @@ -865,19 +623,19 @@ class StepExecutor implements StepApi { timeoutAt && Number.isFinite(timeoutAt.getTime()) ? timeoutAt : defaultWaitTimeoutAt(workflowAttempt.createdAt); - throw new SleepSignal(this.resolveEarliestRunningWaitResumeAt(resumeAt)); + throw new SleepSignal( + this.history.resolveEarliestRunningWaitResumeAt(resumeAt), + ); } /** * Create (or dedupe) the child workflow run and persist the linkage on the * parent workflow step attempt. - * @param stepName - Parent workflow step name * @param attempt - Parent workflow step attempt * @param request - Workflow step request * @returns Updated step attempt with child linkage */ private async linkChildWorkflowRun( - stepName: string, attempt: Readonly, request: Readonly>, ): Promise { @@ -912,14 +670,15 @@ class StepExecutor implements StepApi { childWorkflowRunNamespaceId: childRun.namespaceId, childWorkflowRunId: childRun.id, }); - this.runningByStepName.set(stepName, linked); + this.history.replaceRunningAttempt(linked); return linked; } /** - * Record a step failure, update the failed-attempt counter, and throw a - * StepError. Shared by both `step.run` failures and workflow failures. + * Record a step failure and throw a StepError. Shared by `step.run` + * failures, workflow failures, signal-send failures, and signal-wait + * validation failures. * @param stepName - Step name * @param stepAttemptId - Step attempt id * @param error - Error that caused the failure @@ -935,7 +694,6 @@ class StepExecutor implements StepApi { throw new StaleExecutionBranchError(); } - this.runningByStepName.delete(stepName); let failedAttempt: StepAttempt; try { failedAttempt = await this.backend.failStepAttempt({ @@ -951,10 +709,7 @@ class StepExecutor implements StepApi { throw stepFailError; } - const stepFailedAttempts = - (this.failedCountsByStepName.get(stepName) ?? 0) + 1; - this.failedCountsByStepName.set(stepName, stepFailedAttempts); - this.failedByStepName.set(stepName, failedAttempt); + const stepFailedAttempts = this.history.recordFailedAttempt(failedAttempt); throw new StepError({ stepName, @@ -994,20 +749,22 @@ class StepExecutor implements StepApi { data?: JsonValue; }>, ): Promise<{ workflowRunIds: string[] }> { - const stepName = this.resolveStepName(options.name ?? options.signal); + const stepName = this.history.resolveStepName( + options.name ?? options.signal, + ); - const existingAttempt = getCachedStepAttempt(this.cache, stepName); + const existingAttempt = this.history.findCached(stepName); if (existingAttempt) { return existingAttempt.output as { workflowRunIds: string[] }; } - const runningAttempt = this.runningByStepName.get(stepName); + const runningAttempt = this.history.findRunning(stepName); if (runningAttempt?.kind === "signal-send") { return await this.resolveSignalSend(stepName, runningAttempt, options); } this.assertExecutionActive(); - this.ensureStepLimitNotReached(); + this.history.ensureCanRecordNewAttempt(); const attempt = await this.backend.createStepAttempt({ workflowRunId: this.workflowRunId, workerId: this.workerId, @@ -1016,8 +773,7 @@ class StepExecutor implements StepApi { config: {}, context: null, }); - this.stepCount += 1; - this.runningByStepName.set(stepName, attempt); + this.history.recordNewAttempt(attempt); return await this.resolveSignalSend(stepName, attempt, options); } @@ -1040,8 +796,7 @@ class StepExecutor implements StepApi { workerId: this.workerId, output: { ...result }, }); - this.cache = addToStepAttemptCache(this.cache, completed); - this.runningByStepName.delete(stepName); + this.history.recordCompletion(completed); return completed.output as { workflowRunIds: string[] }; } catch (error) { return await this.failStepWithError( @@ -1063,14 +818,16 @@ class StepExecutor implements StepApi { schema?: StandardSchemaV1; }>, ): Promise<{ data: Output } | null> { - const stepName = this.resolveStepName(options.name ?? options.signal); + const stepName = this.history.resolveStepName( + options.name ?? options.signal, + ); - const existingAttempt = getCachedStepAttempt(this.cache, stepName); + const existingAttempt = this.history.findCached(stepName); if (existingAttempt) { return existingAttempt.output as { data: Output } | null; } - const runningAttempt = this.runningByStepName.get(stepName); + const runningAttempt = this.history.findRunning(stepName); if (runningAttempt?.kind === "signal-wait") { return await this.resolveSignalWait( stepName, @@ -1079,22 +836,19 @@ class StepExecutor implements StepApi { ); } - for (const [name, a] of this.runningByStepName) { - if ( - name !== stepName && - a.kind === "signal-wait" && - a.context?.kind === "signal-wait" && - a.context.signal === options.signal - ) { - throw new Error( - `Signal "${options.signal}" is already being waited on by step "${name}"`, - ); - } + const conflict = this.history.findConflictingSignalWait( + options.signal, + stepName, + ); + if (conflict) { + throw new Error( + `Signal "${options.signal}" is already being waited on by step "${conflict.stepName}"`, + ); } const timeoutAt = resolveWaitTimeoutAt(options.timeout); this.assertExecutionActive(); - this.ensureStepLimitNotReached(); + this.history.ensureCanRecordNewAttempt(); const attempt = await this.backend.createStepAttempt({ workflowRunId: this.workflowRunId, workerId: this.workerId, @@ -1103,8 +857,7 @@ class StepExecutor implements StepApi { config: {}, context: createSignalWaitContext(options.signal, timeoutAt), }); - this.stepCount += 1; - this.runningByStepName.set(stepName, attempt); + this.history.recordNewAttempt(attempt); return await this.resolveSignalWait(stepName, attempt, options); } @@ -1152,7 +905,9 @@ class StepExecutor implements StepApi { return await this.completeSignalWaitStep(attempt, null); } - throw new SleepSignal(this.resolveEarliestRunningWaitResumeAt(timeoutAt)); + throw new SleepSignal( + this.history.resolveEarliestRunningWaitResumeAt(timeoutAt), + ); } /** @@ -1171,16 +926,9 @@ class StepExecutor implements StepApi { workerId: this.workerId, output: output as JsonValue | null, }); - this.cache = addToStepAttemptCache(this.cache, completed); - this.runningByStepName.delete(attempt.stepName); + this.history.recordCompletion(completed); return completed.output as { data: Output } | null; } - - private ensureStepLimitNotReached(): void { - if (this.stepCount >= this.stepLimit) { - throw new StepLimitExceededError(this.stepLimit, this.stepCount); - } - } } /** @@ -1270,24 +1018,21 @@ export async function executeWorkflow( backend, workflowRun.id, ); + const history = new StepHistory({ attempts }); - // complete any elapsed sleep waits first, then park on the earliest + // Complete any elapsed sleep waits first, then park on the earliest // remaining running wait (sleep or runWorkflow timeout). const hasPendingRunningSleep = await completeElapsedRunningSleepAttempts({ backend, workflowRunId: workflowRun.id, workerId, - attempts, + history, }); if (hasPendingRunningSleep) { - const earliestRunningWaitResumeAt = - getEarliestRunningWaitResumeAt(attempts); - if ( - earliestRunningWaitResumeAt && - Date.now() < earliestRunningWaitResumeAt.getTime() - ) { - throw new SleepSignal(earliestRunningWaitResumeAt); + const earliestResumeAt = history.earliestRunningWaitResumeAt(); + if (earliestResumeAt && Date.now() < earliestResumeAt.getTime()) { + throw new SleepSignal(earliestResumeAt); } } @@ -1295,7 +1040,7 @@ export async function executeWorkflow( backend, workflowRunId: workflowRun.id, workerId, - attempts, + history, executionFence, }); diff --git a/packages/openworkflow/worker/step-history.test.ts b/packages/openworkflow/worker/step-history.test.ts new file mode 100644 index 00000000..a218c6f3 --- /dev/null +++ b/packages/openworkflow/worker/step-history.test.ts @@ -0,0 +1,262 @@ +import type { StepAttempt } from "../core/step-attempt.js"; +import { StepHistory, StepLimitExceededError } from "./step-history.js"; +import { describe, test, expect } from "vitest"; + +describe("StepHistory", () => { + describe("resolveStepName", () => { + test("returns the base name on first use", () => { + const history = new StepHistory({ attempts: [] }); + expect(history.resolveStepName("step")).toBe("step"); + }); + + test("appends incrementing suffixes for collisions", () => { + const history = new StepHistory({ attempts: [] }); + expect(history.resolveStepName("step")).toBe("step"); + expect(history.resolveStepName("step")).toBe("step:1"); + expect(history.resolveStepName("step")).toBe("step:2"); + }); + + test("skips suffixes that were user-supplied as base names", () => { + const history = new StepHistory({ attempts: [] }); + history.resolveStepName("step"); + history.resolveStepName("step:1"); // user-supplied collision + expect(history.resolveStepName("step")).toBe("step:2"); + }); + }); + + describe("find*", () => { + test("findCached returns successful attempts only", () => { + const completed = createMockStepAttempt({ + stepName: "a", + status: "completed", + output: "done", + }); + const failed = createMockStepAttempt({ + stepName: "b", + status: "failed", + }); + const history = new StepHistory({ attempts: [completed, failed] }); + + expect(history.findCached("a")).toBe(completed); + expect(history.findCached("b")).toBeUndefined(); + }); + + test("findTerminallyFailedWorkflow requires linked child ids", () => { + const unlinked = createMockStepAttempt({ + stepName: "a", + kind: "workflow", + status: "failed", + }); + const linked = createMockStepAttempt({ + stepName: "b", + kind: "workflow", + status: "failed", + childWorkflowRunNamespaceId: "default", + childWorkflowRunId: "child-run", + }); + const nonWorkflow = createMockStepAttempt({ + stepName: "c", + kind: "function", + status: "failed", + }); + + const history = new StepHistory({ + attempts: [unlinked, linked, nonWorkflow], + }); + + expect(history.findTerminallyFailedWorkflow("a")).toBeUndefined(); + expect(history.findTerminallyFailedWorkflow("b")).toBe(linked); + expect(history.findTerminallyFailedWorkflow("c")).toBeUndefined(); + }); + + test("findConflictingSignalWait matches signal name, excluding caller", () => { + const waitingA = createMockStepAttempt({ + stepName: "wait-a", + kind: "signal-wait", + status: "running", + context: { + kind: "signal-wait", + signal: "approve", + timeoutAt: "2026-05-01T00:00:00.000Z", + }, + }); + const waitingB = createMockStepAttempt({ + stepName: "wait-b", + kind: "signal-wait", + status: "running", + context: { + kind: "signal-wait", + signal: "cancel", + timeoutAt: "2026-05-01T00:00:00.000Z", + }, + }); + + const history = new StepHistory({ attempts: [waitingA, waitingB] }); + + expect(history.findConflictingSignalWait("approve", "other")).toEqual({ + stepName: "wait-a", + attempt: waitingA, + }); + expect(history.findConflictingSignalWait("approve", "wait-a")).toBeNull(); + expect(history.findConflictingSignalWait("unknown", "other")).toBeNull(); + }); + }); + + describe("mutations", () => { + test("recordNewAttempt enforces the step limit", () => { + const history = new StepHistory({ attempts: [], stepLimit: 1 }); + history.ensureCanRecordNewAttempt(); + history.recordNewAttempt( + createMockStepAttempt({ id: "a", stepName: "a", status: "running" }), + ); + expect(() => { + history.ensureCanRecordNewAttempt(); + }).toThrow(StepLimitExceededError); + }); + + test("recordCompletion moves a running attempt into the cache", () => { + const running = createMockStepAttempt({ + stepName: "a", + status: "running", + }); + const history = new StepHistory({ attempts: [running] }); + expect(history.findRunning("a")).toBe(running); + expect(history.findCached("a")).toBeUndefined(); + + const completed = createMockStepAttempt({ + stepName: "a", + status: "completed", + output: "value", + }); + history.recordCompletion(completed); + + expect(history.findRunning("a")).toBeUndefined(); + expect(history.findCached("a")).toBe(completed); + }); + + test("recordFailedAttempt increments the failure count", () => { + const running = createMockStepAttempt({ + stepName: "a", + status: "running", + }); + const history = new StepHistory({ attempts: [running] }); + + const failed = createMockStepAttempt({ + stepName: "a", + status: "failed", + }); + expect(history.recordFailedAttempt(failed)).toBe(1); + expect(history.recordFailedAttempt(failed)).toBe(2); + expect(history.failedAttemptCount("a")).toBe(2); + expect(history.findRunning("a")).toBeUndefined(); + }); + + test("replaceRunningAttempt updates the running entry in place", () => { + const initial = createMockStepAttempt({ + id: "attempt-1", + stepName: "wf", + kind: "workflow", + status: "running", + }); + const history = new StepHistory({ + attempts: [initial], + stepLimit: 2, + }); + + const linked = { + ...initial, + childWorkflowRunId: "child-run", + childWorkflowRunNamespaceId: "default", + }; + history.replaceRunningAttempt(linked); + + expect(history.findRunning("wf")).toBe(linked); + + // Counter should not have moved, so we can still record a second attempt. + history.ensureCanRecordNewAttempt(); + }); + }); + + describe("wait-time helpers", () => { + test("earliestRunningWaitResumeAt returns null with no running waits", () => { + const history = new StepHistory({ attempts: [] }); + expect(history.earliestRunningWaitResumeAt()).toBeNull(); + }); + + test("earliestRunningWaitResumeAt picks the earliest running wait", () => { + const sleepLate = createMockStepAttempt({ + stepName: "sleep-late", + kind: "sleep", + status: "running", + context: { kind: "sleep", resumeAt: "2026-06-01T00:00:00.000Z" }, + }); + const sleepEarly = createMockStepAttempt({ + stepName: "sleep-early", + kind: "sleep", + status: "running", + context: { kind: "sleep", resumeAt: "2026-05-01T00:00:00.000Z" }, + }); + const history = new StepHistory({ attempts: [sleepLate, sleepEarly] }); + + expect(history.earliestRunningWaitResumeAt()?.toISOString()).toBe( + "2026-05-01T00:00:00.000Z", + ); + }); + + test("resolveEarliestRunningWaitResumeAt picks the earlier of fallback or running", () => { + const sleep = createMockStepAttempt({ + stepName: "sleep", + kind: "sleep", + status: "running", + context: { kind: "sleep", resumeAt: "2026-06-01T00:00:00.000Z" }, + }); + const history = new StepHistory({ attempts: [sleep] }); + + const earlierFallback = new Date("2026-05-01T00:00:00.000Z"); + expect( + history + .resolveEarliestRunningWaitResumeAt(earlierFallback) + .toISOString(), + ).toBe("2026-05-01T00:00:00.000Z"); + + const laterFallback = new Date("2026-07-01T00:00:00.000Z"); + expect( + history.resolveEarliestRunningWaitResumeAt(laterFallback).toISOString(), + ).toBe("2026-06-01T00:00:00.000Z"); + }); + + test("resolveEarliestRunningWaitResumeAt falls back when no running waits", () => { + const history = new StepHistory({ attempts: [] }); + const fallback = new Date("2026-05-01T00:00:00.000Z"); + expect( + history.resolveEarliestRunningWaitResumeAt(fallback).toISOString(), + ).toBe("2026-05-01T00:00:00.000Z"); + }); + }); +}); + +function createMockStepAttempt( + overrides: Partial = {}, +): StepAttempt { + const status = overrides.status ?? "completed"; + return { + namespaceId: "default", + id: "step-attempt-id", + workflowRunId: "workflow-run-id", + stepName: "step", + kind: "function", + status, + config: {}, + context: null, + output: null, + error: null, + childWorkflowRunNamespaceId: null, + childWorkflowRunId: null, + startedAt: new Date("2026-01-01T00:00:00.000Z"), + finishedAt: + status === "running" ? null : new Date("2026-01-01T00:00:01.000Z"), + createdAt: new Date("2026-01-01T00:00:00.000Z"), + updatedAt: new Date("2026-01-01T00:00:01.000Z"), + ...overrides, + }; +} diff --git a/packages/openworkflow/worker/step-history.ts b/packages/openworkflow/worker/step-history.ts new file mode 100644 index 00000000..ea98730a --- /dev/null +++ b/packages/openworkflow/worker/step-history.ts @@ -0,0 +1,372 @@ +import type { StepAttempt, StepAttemptCache } from "../core/step-attempt.js"; +import { + addToStepAttemptCache, + getCachedStepAttempt, +} from "../core/step-attempt.js"; + +/** Maximum number of step attempts allowed for a single workflow run. */ +export const WORKFLOW_STEP_LIMIT = 1000; + +/** Error code used when a workflow run exceeds the step-attempt limit. */ +export const STEP_LIMIT_EXCEEDED_ERROR_CODE = "STEP_LIMIT_EXCEEDED"; + +/** + * Error thrown when a workflow run reaches the maximum allowed step attempts. + */ +export class StepLimitExceededError extends Error { + readonly code = STEP_LIMIT_EXCEEDED_ERROR_CODE; + readonly limit: number; + readonly stepCount: number; + + constructor(limit: number, stepCount: number) { + super( + `Exceeded the step limit of ${String(limit)} attempts (current count: ${String(stepCount)})`, + ); + this.name = "StepLimitExceededError"; + this.limit = limit; + this.stepCount = stepCount; + } +} + +/** + * Derived in-memory step state for a single workflow execution pass. + */ +export interface StepExecutionState { + cache: StepAttemptCache; + failedCountsByStepName: ReadonlyMap; + failedByStepName: ReadonlyMap; + runningByStepName: ReadonlyMap; +} + +/** + * Build step execution state from loaded attempts in one pass. + * @param attempts - Loaded step attempts for the workflow run + * @returns Successful cache plus failed-attempt counts by step name + */ +export function createStepExecutionStateFromAttempts( + attempts: readonly StepAttempt[], +): StepExecutionState { + const cache = new Map(); + const failedCountsByStepName = new Map(); + const failedByStepName = new Map(); + const runningByStepName = new Map(); + + for (const attempt of attempts) { + if (attempt.status === "completed" || attempt.status === "succeeded") { + cache.set(attempt.stepName, attempt); + continue; + } + + if (attempt.status === "failed") { + const previousCount = failedCountsByStepName.get(attempt.stepName) ?? 0; + failedCountsByStepName.set(attempt.stepName, previousCount + 1); + failedByStepName.set(attempt.stepName, attempt); + continue; + } + + runningByStepName.set(attempt.stepName, attempt); + } + + return { + cache, + failedCountsByStepName, + failedByStepName, + runningByStepName, + }; +} + +/** + * Default wait timeout: 1 year from a base time. + * @param base - Base timestamp (defaults to now) + * @returns Timeout deadline + */ +export function defaultWaitTimeoutAt(base: Readonly = new Date()): Date { + const timeoutAt = new Date(base); + timeoutAt.setFullYear(timeoutAt.getFullYear() + 1); + return timeoutAt; +} + +/** + * Extract the timeout from a persisted step attempt's context. + * Works for both workflow and signal-wait step types. + * @param attempt - Running step attempt + * @returns Timeout deadline, or null when context has no timeout + */ +export function getContextTimeoutAt( + attempt: Readonly, +): Date | null { + if ( + attempt.context?.kind !== "workflow" && + attempt.context?.kind !== "signal-wait" + ) { + return null; + } + + const { timeoutAt } = attempt.context; + if (timeoutAt === null) { + // backward compatibility for previously persisted workflow contexts + // (signal-wait timeoutAt is never null per SignalWaitStepAttemptContext). + return defaultWaitTimeoutAt(attempt.createdAt); + } + return new Date(timeoutAt); +} + +/** + * Resolve the next wake-up timestamp for a running wait step attempt. + * @param attempt - Running step attempt + * @returns Wake-up timestamp, or null when the attempt is not a wait step + */ +function getRunningWaitAttemptResumeAt( + attempt: Readonly, +): Date | null { + if (attempt.status !== "running") { + return null; + } + + if (attempt.kind === "sleep" && attempt.context?.kind === "sleep") { + const resumeAt = new Date(attempt.context.resumeAt); + return Number.isFinite(resumeAt.getTime()) ? resumeAt : null; + } + + if (attempt.kind !== "signal-wait" && attempt.kind !== "workflow") { + return null; + } + + const timeoutAt = + getContextTimeoutAt(attempt) ?? defaultWaitTimeoutAt(attempt.createdAt); + return Number.isFinite(timeoutAt.getTime()) + ? timeoutAt + : defaultWaitTimeoutAt(attempt.createdAt); +} + +/** + * Compute the earliest wake-up timestamp across running wait step attempts. + * @param attempts - Persisted step attempts for the workflow run + * @returns Earliest wake-up timestamp, or null when no running wait exists + */ +export function getEarliestRunningWaitResumeAt( + attempts: readonly StepAttempt[], +): Date | null { + let earliest: Date | null = null; + + for (const attempt of attempts) { + const resumeAt = getRunningWaitAttemptResumeAt(attempt); + if (!resumeAt) { + continue; + } + + if (!earliest || resumeAt.getTime() < earliest.getTime()) { + earliest = resumeAt; + } + } + + return earliest; +} + +/** + * Options for constructing a {@link StepHistory}. + */ +export interface StepHistoryOptions { + attempts: readonly StepAttempt[]; + stepLimit?: number; +} + +/** + * Encapsulates the in-memory step-attempt ledger for a single workflow + * execution pass: the successful-result cache, running/failed maps, failure + * counts, resolved step names, and the step-attempt limit. Exposes a narrow + * API so step-kind logic in {@link StepExecutor} doesn't touch these maps + * directly. + */ +export class StepHistory { + private cache: StepAttemptCache; + private readonly failedCountsByStepName: Map; + private readonly failedByStepName: Map; + private readonly runningByStepName: Map; + private readonly resolvedStepNames = new Set(); + private readonly expectedNextStepIndexByName = new Map(); + private readonly stepLimit: number; + private stepCount: number; + + constructor(options: Readonly) { + this.stepLimit = Math.max(1, options.stepLimit ?? WORKFLOW_STEP_LIMIT); + this.stepCount = options.attempts.length; + + const state = createStepExecutionStateFromAttempts(options.attempts); + this.cache = state.cache; + this.failedCountsByStepName = new Map(state.failedCountsByStepName); + this.failedByStepName = new Map(state.failedByStepName); + this.runningByStepName = new Map(state.runningByStepName); + } + + /** + * Resolve a step name to a deterministic, unique key for this workflow + * execution pass. When a name collides, suffixes are appended as + * `name:1`, `name:2`, etc. If those suffixes already exist (including + * user-provided names), indexing continues until an unused name is found. + * @param baseStepName - User-provided step name + * @returns Resolved step name used for durable step state + */ + resolveStepName(baseStepName: string): string { + if (!this.resolvedStepNames.has(baseStepName)) { + this.resolvedStepNames.add(baseStepName); + return baseStepName; + } + + const expectedNextIndex = + this.expectedNextStepIndexByName.get(baseStepName) ?? 1; + for (let index = expectedNextIndex; ; index += 1) { + const resolvedName = `${baseStepName}:${String(index)}`; + if (this.resolvedStepNames.has(resolvedName)) { + continue; + } + + this.expectedNextStepIndexByName.set(baseStepName, index + 1); + this.resolvedStepNames.add(resolvedName); + return resolvedName; + } + } + + findCached(stepName: string): StepAttempt | undefined { + return getCachedStepAttempt(this.cache, stepName); + } + + findRunning(stepName: string): StepAttempt | undefined { + return this.runningByStepName.get(stepName); + } + + /** + * Find a previously-failed workflow step attempt that already created a + * child workflow run. Workflow steps are terminal once a failure is + * persisted with linkage: the caller should surface the failure instead of + * spawning another child. + * @param stepName - Resolved step name + * @returns Terminally-failed workflow attempt, or undefined + */ + findTerminallyFailedWorkflow(stepName: string): StepAttempt | undefined { + const attempt = this.failedByStepName.get(stepName); + if ( + attempt?.kind === "workflow" && + attempt.childWorkflowRunNamespaceId && + attempt.childWorkflowRunId + ) { + return attempt; + } + return undefined; + } + + /** + * Find a running signal-wait step that is already waiting on the given + * signal, excluding a specific step name. + * @param signal - Signal address + * @param excludeStepName - Step name to skip (usually the caller) + * @returns Conflict descriptor, or null when none exists + */ + findConflictingSignalWait( + signal: string, + excludeStepName: string, + ): { stepName: string; attempt: StepAttempt } | null { + for (const [stepName, attempt] of this.runningByStepName) { + if ( + stepName !== excludeStepName && + attempt.kind === "signal-wait" && + attempt.context?.kind === "signal-wait" && + attempt.context.signal === signal + ) { + return { stepName, attempt }; + } + } + return null; + } + + failedAttemptCount(stepName: string): number { + return this.failedCountsByStepName.get(stepName) ?? 0; + } + + /** + * Iterate over currently-running step attempts. + * @returns Iterator over running step attempts + */ + runningAttempts(): IterableIterator { + return this.runningByStepName.values(); + } + + /** + * Earliest wake-up timestamp across running wait attempts. + * @returns Earliest wake-up timestamp, or null when no running wait exists + */ + earliestRunningWaitResumeAt(): Date | null { + return getEarliestRunningWaitResumeAt([...this.runningByStepName.values()]); + } + + /** + * Earliest wake-up timestamp considering running waits and a fallback (from + * the in-progress wait the caller is about to park on). Always returns a + * concrete date. + * @param fallback - Candidate timestamp for the in-progress wait + * @returns The earlier of the fallback or any known running wait + */ + resolveEarliestRunningWaitResumeAt(fallback: Readonly): Date { + const earliest = this.earliestRunningWaitResumeAt(); + if (!earliest) return new Date(fallback); + + const fallbackMs = fallback.getTime(); + if (!Number.isFinite(fallbackMs)) return earliest; + + return earliest.getTime() < fallbackMs ? earliest : new Date(fallback); + } + + /** + * Assert that recording another step attempt would not exceed the step + * limit. + * @throws {StepLimitExceededError} When the step-attempt limit is reached + */ + ensureCanRecordNewAttempt(): void { + if (this.stepCount >= this.stepLimit) { + throw new StepLimitExceededError(this.stepLimit, this.stepCount); + } + } + + /** + * Record a newly-created step attempt as running and increment the attempt + * counter. Callers must invoke {@link ensureCanRecordNewAttempt} beforehand. + * @param attempt - Step attempt just created in the backend + */ + recordNewAttempt(attempt: Readonly): void { + this.runningByStepName.set(attempt.stepName, attempt); + this.stepCount += 1; + } + + /** + * Replace the running entry for a step (e.g. after linking a child workflow + * run onto an existing attempt). Does not change the attempt counter. + * @param attempt - Updated step attempt + */ + replaceRunningAttempt(attempt: Readonly): void { + this.runningByStepName.set(attempt.stepName, attempt); + } + + /** + * Mark a step attempt as completed: remove from running, add to the cache. + * @param attempt - Completed step attempt + */ + recordCompletion(attempt: Readonly): void { + this.runningByStepName.delete(attempt.stepName); + this.cache = addToStepAttemptCache(this.cache, attempt); + } + + /** + * Mark a step attempt as failed: remove from running, record failure, and + * return the new failed-attempt count for that step name. + * @param attempt - Failed step attempt + * @returns The new cumulative failed-attempt count for this step name + */ + recordFailedAttempt(attempt: Readonly): number { + this.runningByStepName.delete(attempt.stepName); + const nextCount = + (this.failedCountsByStepName.get(attempt.stepName) ?? 0) + 1; + this.failedCountsByStepName.set(attempt.stepName, nextCount); + this.failedByStepName.set(attempt.stepName, attempt); + return nextCount; + } +} From 9fb06afe11c35a643022f39e66f9e6bb4ad89ed7 Mon Sep 17 00:00:00 2001 From: James Martinez Date: Fri, 17 Apr 2026 16:46:53 -0500 Subject: [PATCH 2/4] fix: feedback --- packages/openworkflow/worker/step-history.ts | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/packages/openworkflow/worker/step-history.ts b/packages/openworkflow/worker/step-history.ts index ea98730a..39532890 100644 --- a/packages/openworkflow/worker/step-history.ts +++ b/packages/openworkflow/worker/step-history.ts @@ -144,7 +144,7 @@ function getRunningWaitAttemptResumeAt( * @param attempts - Persisted step attempts for the workflow run * @returns Earliest wake-up timestamp, or null when no running wait exists */ -export function getEarliestRunningWaitResumeAt( +function getEarliestRunningWaitResumeAt( attempts: readonly StepAttempt[], ): Date | null { let earliest: Date | null = null; @@ -301,10 +301,11 @@ export class StepHistory { /** * Earliest wake-up timestamp considering running waits and a fallback (from - * the in-progress wait the caller is about to park on). Always returns a - * concrete date. + * the in-progress wait the caller is about to park on). * @param fallback - Candidate timestamp for the in-progress wait - * @returns The earlier of the fallback or any known running wait + * @returns The earlier of the fallback or any known running wait. If no + * running wait exists, returns a clone of `fallback`, which will also be + * invalid when `fallback` is invalid. */ resolveEarliestRunningWaitResumeAt(fallback: Readonly): Date { const earliest = this.earliestRunningWaitResumeAt(); From 9e3094d37e4ccbb22a14dd76b5628abc69e0b00a Mon Sep 17 00:00:00 2001 From: James Martinez Date: Fri, 17 Apr 2026 15:39:08 -0500 Subject: [PATCH 3/4] chore: @openworkflow/backend-postgres v0.6.3 & @openworkflow/backend-sqlite v0.6.3 --- package-lock.json | 8 ++++---- packages/backend-postgres/CHANGELOG.md | 10 ++++++++++ packages/backend-postgres/README.md | 20 ++++++++++++++++++++ packages/backend-postgres/index.ts | 5 +++++ packages/backend-postgres/package.json | 4 ++-- packages/backend-sqlite/CHANGELOG.md | 10 ++++++++++ packages/backend-sqlite/README.md | 20 ++++++++++++++++++++ packages/backend-sqlite/index.ts | 5 +++++ packages/backend-sqlite/package.json | 4 ++-- 9 files changed, 78 insertions(+), 8 deletions(-) create mode 100644 packages/backend-postgres/README.md create mode 100644 packages/backend-sqlite/README.md diff --git a/package-lock.json b/package-lock.json index 2b479887..4be8c7b7 100644 --- a/package-lock.json +++ b/package-lock.json @@ -16926,7 +16926,7 @@ }, "packages/backend-postgres": { "name": "@openworkflow/backend-postgres", - "version": "0.6.2", + "version": "0.6.3", "dependencies": { "postgres": "^3.4.9" }, @@ -16934,12 +16934,12 @@ "openworkflow": "*" }, "peerDependencies": { - "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0" + "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0" } }, "packages/backend-sqlite": { "name": "@openworkflow/backend-sqlite", - "version": "0.6.2", + "version": "0.6.3", "devDependencies": { "openworkflow": "*" }, @@ -16947,7 +16947,7 @@ "node": ">=22.5.0" }, "peerDependencies": { - "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0" + "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0" } }, "packages/cli": { diff --git a/packages/backend-postgres/CHANGELOG.md b/packages/backend-postgres/CHANGELOG.md index 7b74dd57..3ffc7f70 100644 --- a/packages/backend-postgres/CHANGELOG.md +++ b/packages/backend-postgres/CHANGELOG.md @@ -1,5 +1,15 @@ # @openworkflow/backend-postgres +## 0.6.3 + +### Patch Changes + +- Deprecate this package. It has moved into `openworkflow` core — import + `BackendPostgres` from `openworkflow/postgres` or `BackendSqlite` from + `openworkflow/sqlite` instead. A runtime warning is now emitted on import, and + the peer dependency range is widened to include `openworkflow` v0.9.0. This + package will be removed in a future release. + ## 0.6.2 - Add support for `openworkflow` v0.8.0 diff --git a/packages/backend-postgres/README.md b/packages/backend-postgres/README.md new file mode 100644 index 00000000..7a57591b --- /dev/null +++ b/packages/backend-postgres/README.md @@ -0,0 +1,20 @@ +# @openworkflow/backend-postgres + +> **Deprecated.** This package has moved into `openworkflow` core and will be +> removed in a future release. + +## Migration + +Import `BackendPostgres` from `openworkflow/postgres` directly: + +```diff +- import { BackendPostgres } from "@openworkflow/backend-postgres"; ++ import { BackendPostgres } from "openworkflow/postgres"; +``` + +Then remove `@openworkflow/backend-postgres` from your dependencies. No other +code changes are required — this package has been a thin re-export of +`openworkflow/postgres` since v0.6.0. + +See the [openworkflow README](https://github.com/openworkflowdev/openworkflow) +for current documentation. diff --git a/packages/backend-postgres/index.ts b/packages/backend-postgres/index.ts index 09be88c1..07fcb994 100644 --- a/packages/backend-postgres/index.ts +++ b/packages/backend-postgres/index.ts @@ -1 +1,6 @@ +console.warn( + "[@openworkflow/backend-postgres] This package is deprecated and will be removed. " + + 'Import `BackendPostgres` from "openworkflow/postgres" instead.', +); + export { BackendPostgres } from "openworkflow/postgres"; diff --git a/packages/backend-postgres/package.json b/packages/backend-postgres/package.json index 0055d5ba..ac18d9f5 100644 --- a/packages/backend-postgres/package.json +++ b/packages/backend-postgres/package.json @@ -1,6 +1,6 @@ { "name": "@openworkflow/backend-postgres", - "version": "0.6.2", + "version": "0.6.3", "type": "module", "exports": { ".": { @@ -24,6 +24,6 @@ "openworkflow": "*" }, "peerDependencies": { - "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0" + "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0" } } diff --git a/packages/backend-sqlite/CHANGELOG.md b/packages/backend-sqlite/CHANGELOG.md index 1e97063b..e236d09e 100644 --- a/packages/backend-sqlite/CHANGELOG.md +++ b/packages/backend-sqlite/CHANGELOG.md @@ -1,5 +1,15 @@ # @openworkflow/backend-sqlite +## 0.6.3 + +### Patch Changes + +- Deprecate this package. It has moved into `openworkflow` core — import + `BackendPostgres` from `openworkflow/postgres` or `BackendSqlite` from + `openworkflow/sqlite` instead. A runtime warning is now emitted on import, and + the peer dependency range is widened to include `openworkflow` v0.9.0. This + package will be removed in a future release. + ## 0.6.2 - Add support for `openworkflow` v0.8.0 diff --git a/packages/backend-sqlite/README.md b/packages/backend-sqlite/README.md new file mode 100644 index 00000000..ff332031 --- /dev/null +++ b/packages/backend-sqlite/README.md @@ -0,0 +1,20 @@ +# @openworkflow/backend-sqlite + +> **Deprecated.** This package has moved into `openworkflow` core and will be +> removed in a future release. + +## Migration + +Import `BackendSqlite` from `openworkflow/sqlite` directly: + +```diff +- import { BackendSqlite } from "@openworkflow/backend-sqlite"; ++ import { BackendSqlite } from "openworkflow/sqlite"; +``` + +Then remove `@openworkflow/backend-sqlite` from your dependencies. No other +code changes are required — this package has been a thin re-export of +`openworkflow/sqlite` since v0.6.0. + +See the [openworkflow README](https://github.com/openworkflowdev/openworkflow) +for current documentation. diff --git a/packages/backend-sqlite/index.ts b/packages/backend-sqlite/index.ts index 6ceecb8a..1618ca5f 100644 --- a/packages/backend-sqlite/index.ts +++ b/packages/backend-sqlite/index.ts @@ -1 +1,6 @@ +console.warn( + "[@openworkflow/backend-sqlite] This package is deprecated and will be removed. " + + 'Import `BackendSqlite` from "openworkflow/sqlite" instead.', +); + export { BackendSqlite } from "openworkflow/sqlite"; diff --git a/packages/backend-sqlite/package.json b/packages/backend-sqlite/package.json index 46176704..281caa0b 100644 --- a/packages/backend-sqlite/package.json +++ b/packages/backend-sqlite/package.json @@ -1,6 +1,6 @@ { "name": "@openworkflow/backend-sqlite", - "version": "0.6.2", + "version": "0.6.3", "type": "module", "exports": { ".": { @@ -21,7 +21,7 @@ "openworkflow": "*" }, "peerDependencies": { - "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0" + "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0" }, "engines": { "node": ">=22.5.0" From 385aab33d813b600945607c297358f50846b6331 Mon Sep 17 00:00:00 2001 From: James Martinez Date: Fri, 17 Apr 2026 16:53:31 -0500 Subject: [PATCH 4/4] chore: remove deprecated backend-postgres and backend-sqlite packages (#475) --- benchmarks/basic/index.ts | 2 +- benchmarks/basic/package-lock.json | 600 --------------- benchmarks/basic/package.json | 4 +- examples/basic/index.ts | 2 +- examples/basic/package-lock.json | 600 --------------- examples/basic/package.json | 4 +- examples/declare-workflow/index.ts | 2 +- examples/declare-workflow/package-lock.json | 600 --------------- examples/declare-workflow/package.json | 4 +- examples/with-schema-validation/arktype.ts | 2 +- .../with-schema-validation/package-lock.json | 704 ------------------ examples/with-schema-validation/package.json | 2 +- examples/with-schema-validation/valibot.ts | 2 +- examples/with-schema-validation/yup.ts | 2 +- examples/with-schema-validation/zod.ts | 2 +- examples/workflow-discovery/index.ts | 2 +- .../workflow-discovery/openworkflow.config.js | 2 +- examples/workflow-discovery/package-lock.json | 613 --------------- examples/workflow-discovery/package.json | 1 - package-lock.json | 49 +- packages/backend-postgres/CHANGELOG.md | 30 - packages/backend-postgres/README.md | 20 - packages/backend-postgres/index.ts | 6 - packages/backend-postgres/package.json | 29 - packages/backend-postgres/tsconfig.json | 9 - packages/backend-sqlite/CHANGELOG.md | 30 - packages/backend-sqlite/README.md | 20 - packages/backend-sqlite/index.ts | 6 - packages/backend-sqlite/package.json | 29 - packages/backend-sqlite/tsconfig.json | 9 - tsconfig.json | 2 - 31 files changed, 23 insertions(+), 3366 deletions(-) delete mode 100644 benchmarks/basic/package-lock.json delete mode 100644 examples/basic/package-lock.json delete mode 100644 examples/declare-workflow/package-lock.json delete mode 100644 examples/with-schema-validation/package-lock.json delete mode 100644 examples/workflow-discovery/package-lock.json delete mode 100644 packages/backend-postgres/CHANGELOG.md delete mode 100644 packages/backend-postgres/README.md delete mode 100644 packages/backend-postgres/index.ts delete mode 100644 packages/backend-postgres/package.json delete mode 100644 packages/backend-postgres/tsconfig.json delete mode 100644 packages/backend-sqlite/CHANGELOG.md delete mode 100644 packages/backend-sqlite/README.md delete mode 100644 packages/backend-sqlite/index.ts delete mode 100644 packages/backend-sqlite/package.json delete mode 100644 packages/backend-sqlite/tsconfig.json diff --git a/benchmarks/basic/index.ts b/benchmarks/basic/index.ts index 59baff92..3214a83c 100644 --- a/benchmarks/basic/index.ts +++ b/benchmarks/basic/index.ts @@ -1,6 +1,6 @@ -import { BackendPostgres } from "@openworkflow/backend-postgres"; import { randomUUID } from "node:crypto"; import { OpenWorkflow } from "openworkflow"; +import { BackendPostgres } from "openworkflow/postgres"; const WORKFLOW_RUN_COUNT = 1000; const WORKER_CONCURRENCY = 100; diff --git a/benchmarks/basic/package-lock.json b/benchmarks/basic/package-lock.json deleted file mode 100644 index e256bb08..00000000 --- a/benchmarks/basic/package-lock.json +++ /dev/null @@ -1,600 +0,0 @@ -{ - "name": "benchmark-basic", - "lockfileVersion": 3, - "requires": true, - "packages": { - "": { - "name": "benchmark-basic", - "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" - }, - "devDependencies": { - "tsx": "^4.21.0" - } - }, - "../../packages/backend-postgres": { - "name": "@openworkflow/backend-postgres", - "version": "0.5.0", - "dependencies": { - "postgres": "^3.4.8" - }, - "devDependencies": { - "openworkflow": "*", - "squawk-cli": "^2.38.0", - "vitest": "^4.0.18" - }, - "peerDependencies": { - "openworkflow": "^0.5.0" - } - }, - "../../packages/openworkflow": { - "version": "0.5.0", - "license": "Apache-2.0", - "bin": { - "openworkflow": "dist/bin/openworkflow.js", - "ow": "dist/bin/openworkflow.js" - }, - "devDependencies": { - "arktype": "^2.1.29", - "valibot": "^1.2.0", - "vitest": "^4.0.18", - "yup": "^1.7.1", - "zod": "^4.3.6" - }, - "engines": { - "node": ">=20" - } - }, - "node_modules/@esbuild/aix-ppc64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.0.tgz", - "integrity": "sha512-KuZrd2hRjz01y5JK9mEBSD3Vj3mbCvemhT466rSuJYeE/hjuBrHfjjcjMdTm/sz7au+++sdbJZJmuBwQLuw68A==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "aix" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.0.tgz", - "integrity": "sha512-j67aezrPNYWJEOHUNLPj9maeJte7uSMM6gMoxfPC9hOg8N02JuQi/T7ewumf4tNvJadFkvLZMlAq73b9uwdMyQ==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.0.tgz", - "integrity": "sha512-CC3vt4+1xZrs97/PKDkl0yN7w8edvU2vZvAFGD16n9F0Cvniy5qvzRXjfO1l94efczkkQE6g1x0i73Qf5uthOQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.0.tgz", - "integrity": "sha512-wurMkF1nmQajBO1+0CJmcN17U4BP6GqNSROP8t0X/Jiw2ltYGLHpEksp9MpoBqkrFR3kv2/te6Sha26k3+yZ9Q==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.0.tgz", - "integrity": "sha512-uJOQKYCcHhg07DL7i8MzjvS2LaP7W7Pn/7uA0B5S1EnqAirJtbyw4yC5jQ5qcFjHK9l6o/MX9QisBg12kNkdHg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.0.tgz", - "integrity": "sha512-8mG6arH3yB/4ZXiEnXof5MK72dE6zM9cDvUcPtxhUZsDjESl9JipZYW60C3JGreKCEP+p8P/72r69m4AZGJd5g==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.0.tgz", - "integrity": "sha512-9FHtyO988CwNMMOE3YIeci+UV+x5Zy8fI2qHNpsEtSF83YPBmE8UWmfYAQg6Ux7Gsmd4FejZqnEUZCMGaNQHQw==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.0.tgz", - "integrity": "sha512-zCMeMXI4HS/tXvJz8vWGexpZj2YVtRAihHLk1imZj4efx1BQzN76YFeKqlDr3bUWI26wHwLWPd3rwh6pe4EV7g==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.0.tgz", - "integrity": "sha512-t76XLQDpxgmq2cNXKTVEB7O7YMb42atj2Re2Haf45HkaUpjM2J0UuJZDuaGbPbamzZ7bawyGFUkodL+zcE+jvQ==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.0.tgz", - "integrity": "sha512-AS18v0V+vZiLJyi/4LphvBE+OIX682Pu7ZYNsdUHyUKSoRwdnOsMf6FDekwoAFKej14WAkOef3zAORJgAtXnlQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.0.tgz", - "integrity": "sha512-Mz1jxqm/kfgKkc/KLHC5qIujMvnnarD9ra1cEcrs7qshTUSksPihGrWHVG5+osAIQ68577Zpww7SGapmzSt4Nw==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.0.tgz", - "integrity": "sha512-QbEREjdJeIreIAbdG2hLU1yXm1uu+LTdzoq1KCo4G4pFOLlvIspBm36QrQOar9LFduavoWX2msNFAAAY9j4BDg==", - "cpu": [ - "loong64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.0.tgz", - "integrity": "sha512-sJz3zRNe4tO2wxvDpH/HYJilb6+2YJxo/ZNbVdtFiKDufzWq4JmKAiHy9iGoLjAV7r/W32VgaHGkk35cUXlNOg==", - "cpu": [ - "mips64el" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.0.tgz", - "integrity": "sha512-z9N10FBD0DCS2dmSABDBb5TLAyF1/ydVb+N4pi88T45efQ/w4ohr/F/QYCkxDPnkhkp6AIpIcQKQ8F0ANoA2JA==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.0.tgz", - "integrity": "sha512-pQdyAIZ0BWIC5GyvVFn5awDiO14TkT/19FTmFcPdDec94KJ1uZcmFs21Fo8auMXzD4Tt+diXu1LW1gHus9fhFQ==", - "cpu": [ - "riscv64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.0.tgz", - "integrity": "sha512-hPlRWR4eIDDEci953RI1BLZitgi5uqcsjKMxwYfmi4LcwyWo2IcRP+lThVnKjNtk90pLS8nKdroXYOqW+QQH+w==", - "cpu": [ - "s390x" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.0.tgz", - "integrity": "sha512-1hBWx4OUJE2cab++aVZ7pObD6s+DK4mPGpemtnAORBvb5l/g5xFGk0vc0PjSkrDs0XaXj9yyob3d14XqvnQ4gw==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.0.tgz", - "integrity": "sha512-6m0sfQfxfQfy1qRuecMkJlf1cIzTOgyaeXaiVaaki8/v+WB+U4hc6ik15ZW6TAllRlg/WuQXxWj1jx6C+dfy3w==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.0.tgz", - "integrity": "sha512-xbbOdfn06FtcJ9d0ShxxvSn2iUsGd/lgPIO2V3VZIPDbEaIj1/3nBBe1AwuEZKXVXkMmpr6LUAgMkLD/4D2PPA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.0.tgz", - "integrity": "sha512-fWgqR8uNbCQ/GGv0yhzttj6sU/9Z5/Sv/VGU3F5OuXK6J6SlriONKrQ7tNlwBrJZXRYk5jUhuWvF7GYzGguBZQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.0.tgz", - "integrity": "sha512-aCwlRdSNMNxkGGqQajMUza6uXzR/U0dIl1QmLjPtRbLOx3Gy3otfFu/VjATy4yQzo9yFDGTxYDo1FfAD9oRD2A==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openharmony-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.0.tgz", - "integrity": "sha512-nyvsBccxNAsNYz2jVFYwEGuRRomqZ149A39SHWk4hV0jWxKM0hjBPm3AmdxcbHiFLbBSwG6SbpIcUbXjgyECfA==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openharmony" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.0.tgz", - "integrity": "sha512-Q1KY1iJafM+UX6CFEL+F4HRTgygmEW568YMqDA5UV97AuZSm21b7SXIrRJDwXWPzr8MGr75fUZPV67FdtMHlHA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.0.tgz", - "integrity": "sha512-W1eyGNi6d+8kOmZIwi/EDjrL9nxQIQ0MiGqe/AWc6+IaHloxHSGoeRgDRKHFISThLmsewZ5nHFvGFWdBYlgKPg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.0.tgz", - "integrity": "sha512-30z1aKL9h22kQhilnYkORFYt+3wp7yZsHWus+wSKAJR8JtdfI76LJ4SBdMsCopTR3z/ORqVu5L1vtnHZWVj4cQ==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.0.tgz", - "integrity": "sha512-aIitBcjQeyOhMTImhLZmtxfdOcuNRpwlPNmlFKPcHQYPhEssw75Cl1TSXJXpMkzaua9FUetx/4OQKq7eJul5Cg==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@openworkflow/backend-postgres": { - "resolved": "../../packages/backend-postgres", - "link": true - }, - "node_modules/esbuild": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.0.tgz", - "integrity": "sha512-jd0f4NHbD6cALCyGElNpGAOtWxSq46l9X/sWB0Nzd5er4Kz2YTm+Vl0qKFT9KUJvD8+fiO8AvoHhFvEatfVixA==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "bin": { - "esbuild": "bin/esbuild" - }, - "engines": { - "node": ">=18" - }, - "optionalDependencies": { - "@esbuild/aix-ppc64": "0.27.0", - "@esbuild/android-arm": "0.27.0", - "@esbuild/android-arm64": "0.27.0", - "@esbuild/android-x64": "0.27.0", - "@esbuild/darwin-arm64": "0.27.0", - "@esbuild/darwin-x64": "0.27.0", - "@esbuild/freebsd-arm64": "0.27.0", - "@esbuild/freebsd-x64": "0.27.0", - "@esbuild/linux-arm": "0.27.0", - "@esbuild/linux-arm64": "0.27.0", - "@esbuild/linux-ia32": "0.27.0", - "@esbuild/linux-loong64": "0.27.0", - "@esbuild/linux-mips64el": "0.27.0", - "@esbuild/linux-ppc64": "0.27.0", - "@esbuild/linux-riscv64": "0.27.0", - "@esbuild/linux-s390x": "0.27.0", - "@esbuild/linux-x64": "0.27.0", - "@esbuild/netbsd-arm64": "0.27.0", - "@esbuild/netbsd-x64": "0.27.0", - "@esbuild/openbsd-arm64": "0.27.0", - "@esbuild/openbsd-x64": "0.27.0", - "@esbuild/openharmony-arm64": "0.27.0", - "@esbuild/sunos-x64": "0.27.0", - "@esbuild/win32-arm64": "0.27.0", - "@esbuild/win32-ia32": "0.27.0", - "@esbuild/win32-x64": "0.27.0" - } - }, - "node_modules/fsevents": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, - "node_modules/get-tsconfig": { - "version": "4.13.0", - "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.0.tgz", - "integrity": "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "resolve-pkg-maps": "^1.0.0" - }, - "funding": { - "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" - } - }, - "node_modules/openworkflow": { - "resolved": "../../packages/openworkflow", - "link": true - }, - "node_modules/resolve-pkg-maps": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", - "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", - "dev": true, - "license": "MIT", - "funding": { - "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" - } - }, - "node_modules/tsx": { - "version": "4.21.0", - "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", - "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", - "dev": true, - "license": "MIT", - "dependencies": { - "esbuild": "~0.27.0", - "get-tsconfig": "^4.7.5" - }, - "bin": { - "tsx": "dist/cli.mjs" - }, - "engines": { - "node": ">=18.0.0" - }, - "optionalDependencies": { - "fsevents": "~2.3.3" - } - } - } -} diff --git a/benchmarks/basic/package.json b/benchmarks/basic/package.json index 44837571..eff775a9 100644 --- a/benchmarks/basic/package.json +++ b/benchmarks/basic/package.json @@ -6,8 +6,8 @@ "start": "tsx index.ts" }, "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" + "openworkflow": "*", + "postgres": "^3.4.9" }, "devDependencies": { "tsx": "^4.21.0" diff --git a/examples/basic/index.ts b/examples/basic/index.ts index aeeab7a4..cacd3a9c 100644 --- a/examples/basic/index.ts +++ b/examples/basic/index.ts @@ -1,6 +1,6 @@ -import { BackendPostgres } from "@openworkflow/backend-postgres"; import { randomUUID } from "node:crypto"; import { OpenWorkflow } from "openworkflow"; +import { BackendPostgres } from "openworkflow/postgres"; const databaseUrl = "postgresql://postgres:postgres@localhost:5432/postgres"; const backend = await BackendPostgres.connect(databaseUrl, { diff --git a/examples/basic/package-lock.json b/examples/basic/package-lock.json deleted file mode 100644 index 07a27acb..00000000 --- a/examples/basic/package-lock.json +++ /dev/null @@ -1,600 +0,0 @@ -{ - "name": "example-basic", - "lockfileVersion": 3, - "requires": true, - "packages": { - "": { - "name": "example-basic", - "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" - }, - "devDependencies": { - "tsx": "^4.21.0" - } - }, - "../../packages/backend-postgres": { - "name": "@openworkflow/backend-postgres", - "version": "0.5.0", - "dependencies": { - "postgres": "^3.4.8" - }, - "devDependencies": { - "openworkflow": "*", - "squawk-cli": "^2.38.0", - "vitest": "^4.0.18" - }, - "peerDependencies": { - "openworkflow": "^0.5.0" - } - }, - "../../packages/openworkflow": { - "version": "0.5.0", - "license": "Apache-2.0", - "bin": { - "openworkflow": "dist/bin/openworkflow.js", - "ow": "dist/bin/openworkflow.js" - }, - "devDependencies": { - "arktype": "^2.1.29", - "valibot": "^1.2.0", - "vitest": "^4.0.18", - "yup": "^1.7.1", - "zod": "^4.3.6" - }, - "engines": { - "node": ">=20" - } - }, - "node_modules/@esbuild/aix-ppc64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.0.tgz", - "integrity": "sha512-KuZrd2hRjz01y5JK9mEBSD3Vj3mbCvemhT466rSuJYeE/hjuBrHfjjcjMdTm/sz7au+++sdbJZJmuBwQLuw68A==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "aix" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.0.tgz", - "integrity": "sha512-j67aezrPNYWJEOHUNLPj9maeJte7uSMM6gMoxfPC9hOg8N02JuQi/T7ewumf4tNvJadFkvLZMlAq73b9uwdMyQ==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.0.tgz", - "integrity": "sha512-CC3vt4+1xZrs97/PKDkl0yN7w8edvU2vZvAFGD16n9F0Cvniy5qvzRXjfO1l94efczkkQE6g1x0i73Qf5uthOQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.0.tgz", - "integrity": "sha512-wurMkF1nmQajBO1+0CJmcN17U4BP6GqNSROP8t0X/Jiw2ltYGLHpEksp9MpoBqkrFR3kv2/te6Sha26k3+yZ9Q==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.0.tgz", - "integrity": "sha512-uJOQKYCcHhg07DL7i8MzjvS2LaP7W7Pn/7uA0B5S1EnqAirJtbyw4yC5jQ5qcFjHK9l6o/MX9QisBg12kNkdHg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.0.tgz", - "integrity": "sha512-8mG6arH3yB/4ZXiEnXof5MK72dE6zM9cDvUcPtxhUZsDjESl9JipZYW60C3JGreKCEP+p8P/72r69m4AZGJd5g==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.0.tgz", - "integrity": "sha512-9FHtyO988CwNMMOE3YIeci+UV+x5Zy8fI2qHNpsEtSF83YPBmE8UWmfYAQg6Ux7Gsmd4FejZqnEUZCMGaNQHQw==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.0.tgz", - "integrity": "sha512-zCMeMXI4HS/tXvJz8vWGexpZj2YVtRAihHLk1imZj4efx1BQzN76YFeKqlDr3bUWI26wHwLWPd3rwh6pe4EV7g==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.0.tgz", - "integrity": "sha512-t76XLQDpxgmq2cNXKTVEB7O7YMb42atj2Re2Haf45HkaUpjM2J0UuJZDuaGbPbamzZ7bawyGFUkodL+zcE+jvQ==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.0.tgz", - "integrity": "sha512-AS18v0V+vZiLJyi/4LphvBE+OIX682Pu7ZYNsdUHyUKSoRwdnOsMf6FDekwoAFKej14WAkOef3zAORJgAtXnlQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.0.tgz", - "integrity": "sha512-Mz1jxqm/kfgKkc/KLHC5qIujMvnnarD9ra1cEcrs7qshTUSksPihGrWHVG5+osAIQ68577Zpww7SGapmzSt4Nw==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.0.tgz", - "integrity": "sha512-QbEREjdJeIreIAbdG2hLU1yXm1uu+LTdzoq1KCo4G4pFOLlvIspBm36QrQOar9LFduavoWX2msNFAAAY9j4BDg==", - "cpu": [ - "loong64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.0.tgz", - "integrity": "sha512-sJz3zRNe4tO2wxvDpH/HYJilb6+2YJxo/ZNbVdtFiKDufzWq4JmKAiHy9iGoLjAV7r/W32VgaHGkk35cUXlNOg==", - "cpu": [ - "mips64el" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.0.tgz", - "integrity": "sha512-z9N10FBD0DCS2dmSABDBb5TLAyF1/ydVb+N4pi88T45efQ/w4ohr/F/QYCkxDPnkhkp6AIpIcQKQ8F0ANoA2JA==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.0.tgz", - "integrity": "sha512-pQdyAIZ0BWIC5GyvVFn5awDiO14TkT/19FTmFcPdDec94KJ1uZcmFs21Fo8auMXzD4Tt+diXu1LW1gHus9fhFQ==", - "cpu": [ - "riscv64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.0.tgz", - "integrity": "sha512-hPlRWR4eIDDEci953RI1BLZitgi5uqcsjKMxwYfmi4LcwyWo2IcRP+lThVnKjNtk90pLS8nKdroXYOqW+QQH+w==", - "cpu": [ - "s390x" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.0.tgz", - "integrity": "sha512-1hBWx4OUJE2cab++aVZ7pObD6s+DK4mPGpemtnAORBvb5l/g5xFGk0vc0PjSkrDs0XaXj9yyob3d14XqvnQ4gw==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.0.tgz", - "integrity": "sha512-6m0sfQfxfQfy1qRuecMkJlf1cIzTOgyaeXaiVaaki8/v+WB+U4hc6ik15ZW6TAllRlg/WuQXxWj1jx6C+dfy3w==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.0.tgz", - "integrity": "sha512-xbbOdfn06FtcJ9d0ShxxvSn2iUsGd/lgPIO2V3VZIPDbEaIj1/3nBBe1AwuEZKXVXkMmpr6LUAgMkLD/4D2PPA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.0.tgz", - "integrity": "sha512-fWgqR8uNbCQ/GGv0yhzttj6sU/9Z5/Sv/VGU3F5OuXK6J6SlriONKrQ7tNlwBrJZXRYk5jUhuWvF7GYzGguBZQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.0.tgz", - "integrity": "sha512-aCwlRdSNMNxkGGqQajMUza6uXzR/U0dIl1QmLjPtRbLOx3Gy3otfFu/VjATy4yQzo9yFDGTxYDo1FfAD9oRD2A==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openharmony-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.0.tgz", - "integrity": "sha512-nyvsBccxNAsNYz2jVFYwEGuRRomqZ149A39SHWk4hV0jWxKM0hjBPm3AmdxcbHiFLbBSwG6SbpIcUbXjgyECfA==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openharmony" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.0.tgz", - "integrity": "sha512-Q1KY1iJafM+UX6CFEL+F4HRTgygmEW568YMqDA5UV97AuZSm21b7SXIrRJDwXWPzr8MGr75fUZPV67FdtMHlHA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.0.tgz", - "integrity": "sha512-W1eyGNi6d+8kOmZIwi/EDjrL9nxQIQ0MiGqe/AWc6+IaHloxHSGoeRgDRKHFISThLmsewZ5nHFvGFWdBYlgKPg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.0.tgz", - "integrity": "sha512-30z1aKL9h22kQhilnYkORFYt+3wp7yZsHWus+wSKAJR8JtdfI76LJ4SBdMsCopTR3z/ORqVu5L1vtnHZWVj4cQ==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.0.tgz", - "integrity": "sha512-aIitBcjQeyOhMTImhLZmtxfdOcuNRpwlPNmlFKPcHQYPhEssw75Cl1TSXJXpMkzaua9FUetx/4OQKq7eJul5Cg==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@openworkflow/backend-postgres": { - "resolved": "../../packages/backend-postgres", - "link": true - }, - "node_modules/esbuild": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.0.tgz", - "integrity": "sha512-jd0f4NHbD6cALCyGElNpGAOtWxSq46l9X/sWB0Nzd5er4Kz2YTm+Vl0qKFT9KUJvD8+fiO8AvoHhFvEatfVixA==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "bin": { - "esbuild": "bin/esbuild" - }, - "engines": { - "node": ">=18" - }, - "optionalDependencies": { - "@esbuild/aix-ppc64": "0.27.0", - "@esbuild/android-arm": "0.27.0", - "@esbuild/android-arm64": "0.27.0", - "@esbuild/android-x64": "0.27.0", - "@esbuild/darwin-arm64": "0.27.0", - "@esbuild/darwin-x64": "0.27.0", - "@esbuild/freebsd-arm64": "0.27.0", - "@esbuild/freebsd-x64": "0.27.0", - "@esbuild/linux-arm": "0.27.0", - "@esbuild/linux-arm64": "0.27.0", - "@esbuild/linux-ia32": "0.27.0", - "@esbuild/linux-loong64": "0.27.0", - "@esbuild/linux-mips64el": "0.27.0", - "@esbuild/linux-ppc64": "0.27.0", - "@esbuild/linux-riscv64": "0.27.0", - "@esbuild/linux-s390x": "0.27.0", - "@esbuild/linux-x64": "0.27.0", - "@esbuild/netbsd-arm64": "0.27.0", - "@esbuild/netbsd-x64": "0.27.0", - "@esbuild/openbsd-arm64": "0.27.0", - "@esbuild/openbsd-x64": "0.27.0", - "@esbuild/openharmony-arm64": "0.27.0", - "@esbuild/sunos-x64": "0.27.0", - "@esbuild/win32-arm64": "0.27.0", - "@esbuild/win32-ia32": "0.27.0", - "@esbuild/win32-x64": "0.27.0" - } - }, - "node_modules/fsevents": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, - "node_modules/get-tsconfig": { - "version": "4.13.0", - "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.0.tgz", - "integrity": "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "resolve-pkg-maps": "^1.0.0" - }, - "funding": { - "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" - } - }, - "node_modules/openworkflow": { - "resolved": "../../packages/openworkflow", - "link": true - }, - "node_modules/resolve-pkg-maps": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", - "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", - "dev": true, - "license": "MIT", - "funding": { - "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" - } - }, - "node_modules/tsx": { - "version": "4.21.0", - "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", - "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", - "dev": true, - "license": "MIT", - "dependencies": { - "esbuild": "~0.27.0", - "get-tsconfig": "^4.7.5" - }, - "bin": { - "tsx": "dist/cli.mjs" - }, - "engines": { - "node": ">=18.0.0" - }, - "optionalDependencies": { - "fsevents": "~2.3.3" - } - } - } -} diff --git a/examples/basic/package.json b/examples/basic/package.json index c153ad78..deebfc60 100644 --- a/examples/basic/package.json +++ b/examples/basic/package.json @@ -6,8 +6,8 @@ "start": "tsx index.ts" }, "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" + "openworkflow": "*", + "postgres": "^3.4.9" }, "devDependencies": { "tsx": "^4.21.0" diff --git a/examples/declare-workflow/index.ts b/examples/declare-workflow/index.ts index 957c7746..bded5c63 100644 --- a/examples/declare-workflow/index.ts +++ b/examples/declare-workflow/index.ts @@ -1,6 +1,6 @@ -import { BackendPostgres } from "@openworkflow/backend-postgres"; import { randomUUID } from "node:crypto"; import { OpenWorkflow, defineWorkflowSpec } from "openworkflow"; +import { BackendPostgres } from "openworkflow/postgres"; const databaseUrl = "postgresql://postgres:postgres@localhost:5432/postgres"; const backend = await BackendPostgres.connect(databaseUrl, { diff --git a/examples/declare-workflow/package-lock.json b/examples/declare-workflow/package-lock.json deleted file mode 100644 index c660b08b..00000000 --- a/examples/declare-workflow/package-lock.json +++ /dev/null @@ -1,600 +0,0 @@ -{ - "name": "example-declare-workflow", - "lockfileVersion": 3, - "requires": true, - "packages": { - "": { - "name": "example-declare-workflow", - "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" - }, - "devDependencies": { - "tsx": "^4.21.0" - } - }, - "../../packages/backend-postgres": { - "name": "@openworkflow/backend-postgres", - "version": "0.5.0", - "dependencies": { - "postgres": "^3.4.8" - }, - "devDependencies": { - "openworkflow": "*", - "squawk-cli": "^2.38.0", - "vitest": "^4.0.18" - }, - "peerDependencies": { - "openworkflow": "^0.5.0" - } - }, - "../../packages/openworkflow": { - "version": "0.5.0", - "license": "Apache-2.0", - "bin": { - "openworkflow": "dist/bin/openworkflow.js", - "ow": "dist/bin/openworkflow.js" - }, - "devDependencies": { - "arktype": "^2.1.29", - "valibot": "^1.2.0", - "vitest": "^4.0.18", - "yup": "^1.7.1", - "zod": "^4.3.6" - }, - "engines": { - "node": ">=20" - } - }, - "node_modules/@esbuild/aix-ppc64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.0.tgz", - "integrity": "sha512-KuZrd2hRjz01y5JK9mEBSD3Vj3mbCvemhT466rSuJYeE/hjuBrHfjjcjMdTm/sz7au+++sdbJZJmuBwQLuw68A==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "aix" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.0.tgz", - "integrity": "sha512-j67aezrPNYWJEOHUNLPj9maeJte7uSMM6gMoxfPC9hOg8N02JuQi/T7ewumf4tNvJadFkvLZMlAq73b9uwdMyQ==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.0.tgz", - "integrity": "sha512-CC3vt4+1xZrs97/PKDkl0yN7w8edvU2vZvAFGD16n9F0Cvniy5qvzRXjfO1l94efczkkQE6g1x0i73Qf5uthOQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.0.tgz", - "integrity": "sha512-wurMkF1nmQajBO1+0CJmcN17U4BP6GqNSROP8t0X/Jiw2ltYGLHpEksp9MpoBqkrFR3kv2/te6Sha26k3+yZ9Q==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.0.tgz", - "integrity": "sha512-uJOQKYCcHhg07DL7i8MzjvS2LaP7W7Pn/7uA0B5S1EnqAirJtbyw4yC5jQ5qcFjHK9l6o/MX9QisBg12kNkdHg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.0.tgz", - "integrity": "sha512-8mG6arH3yB/4ZXiEnXof5MK72dE6zM9cDvUcPtxhUZsDjESl9JipZYW60C3JGreKCEP+p8P/72r69m4AZGJd5g==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.0.tgz", - "integrity": "sha512-9FHtyO988CwNMMOE3YIeci+UV+x5Zy8fI2qHNpsEtSF83YPBmE8UWmfYAQg6Ux7Gsmd4FejZqnEUZCMGaNQHQw==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.0.tgz", - "integrity": "sha512-zCMeMXI4HS/tXvJz8vWGexpZj2YVtRAihHLk1imZj4efx1BQzN76YFeKqlDr3bUWI26wHwLWPd3rwh6pe4EV7g==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.0.tgz", - "integrity": "sha512-t76XLQDpxgmq2cNXKTVEB7O7YMb42atj2Re2Haf45HkaUpjM2J0UuJZDuaGbPbamzZ7bawyGFUkodL+zcE+jvQ==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.0.tgz", - "integrity": "sha512-AS18v0V+vZiLJyi/4LphvBE+OIX682Pu7ZYNsdUHyUKSoRwdnOsMf6FDekwoAFKej14WAkOef3zAORJgAtXnlQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.0.tgz", - "integrity": "sha512-Mz1jxqm/kfgKkc/KLHC5qIujMvnnarD9ra1cEcrs7qshTUSksPihGrWHVG5+osAIQ68577Zpww7SGapmzSt4Nw==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.0.tgz", - "integrity": "sha512-QbEREjdJeIreIAbdG2hLU1yXm1uu+LTdzoq1KCo4G4pFOLlvIspBm36QrQOar9LFduavoWX2msNFAAAY9j4BDg==", - "cpu": [ - "loong64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.0.tgz", - "integrity": "sha512-sJz3zRNe4tO2wxvDpH/HYJilb6+2YJxo/ZNbVdtFiKDufzWq4JmKAiHy9iGoLjAV7r/W32VgaHGkk35cUXlNOg==", - "cpu": [ - "mips64el" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.0.tgz", - "integrity": "sha512-z9N10FBD0DCS2dmSABDBb5TLAyF1/ydVb+N4pi88T45efQ/w4ohr/F/QYCkxDPnkhkp6AIpIcQKQ8F0ANoA2JA==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.0.tgz", - "integrity": "sha512-pQdyAIZ0BWIC5GyvVFn5awDiO14TkT/19FTmFcPdDec94KJ1uZcmFs21Fo8auMXzD4Tt+diXu1LW1gHus9fhFQ==", - "cpu": [ - "riscv64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.0.tgz", - "integrity": "sha512-hPlRWR4eIDDEci953RI1BLZitgi5uqcsjKMxwYfmi4LcwyWo2IcRP+lThVnKjNtk90pLS8nKdroXYOqW+QQH+w==", - "cpu": [ - "s390x" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.0.tgz", - "integrity": "sha512-1hBWx4OUJE2cab++aVZ7pObD6s+DK4mPGpemtnAORBvb5l/g5xFGk0vc0PjSkrDs0XaXj9yyob3d14XqvnQ4gw==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.0.tgz", - "integrity": "sha512-6m0sfQfxfQfy1qRuecMkJlf1cIzTOgyaeXaiVaaki8/v+WB+U4hc6ik15ZW6TAllRlg/WuQXxWj1jx6C+dfy3w==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.0.tgz", - "integrity": "sha512-xbbOdfn06FtcJ9d0ShxxvSn2iUsGd/lgPIO2V3VZIPDbEaIj1/3nBBe1AwuEZKXVXkMmpr6LUAgMkLD/4D2PPA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.0.tgz", - "integrity": "sha512-fWgqR8uNbCQ/GGv0yhzttj6sU/9Z5/Sv/VGU3F5OuXK6J6SlriONKrQ7tNlwBrJZXRYk5jUhuWvF7GYzGguBZQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.0.tgz", - "integrity": "sha512-aCwlRdSNMNxkGGqQajMUza6uXzR/U0dIl1QmLjPtRbLOx3Gy3otfFu/VjATy4yQzo9yFDGTxYDo1FfAD9oRD2A==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openharmony-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.0.tgz", - "integrity": "sha512-nyvsBccxNAsNYz2jVFYwEGuRRomqZ149A39SHWk4hV0jWxKM0hjBPm3AmdxcbHiFLbBSwG6SbpIcUbXjgyECfA==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openharmony" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.0.tgz", - "integrity": "sha512-Q1KY1iJafM+UX6CFEL+F4HRTgygmEW568YMqDA5UV97AuZSm21b7SXIrRJDwXWPzr8MGr75fUZPV67FdtMHlHA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.0.tgz", - "integrity": "sha512-W1eyGNi6d+8kOmZIwi/EDjrL9nxQIQ0MiGqe/AWc6+IaHloxHSGoeRgDRKHFISThLmsewZ5nHFvGFWdBYlgKPg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.0.tgz", - "integrity": "sha512-30z1aKL9h22kQhilnYkORFYt+3wp7yZsHWus+wSKAJR8JtdfI76LJ4SBdMsCopTR3z/ORqVu5L1vtnHZWVj4cQ==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.0.tgz", - "integrity": "sha512-aIitBcjQeyOhMTImhLZmtxfdOcuNRpwlPNmlFKPcHQYPhEssw75Cl1TSXJXpMkzaua9FUetx/4OQKq7eJul5Cg==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@openworkflow/backend-postgres": { - "resolved": "../../packages/backend-postgres", - "link": true - }, - "node_modules/esbuild": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.0.tgz", - "integrity": "sha512-jd0f4NHbD6cALCyGElNpGAOtWxSq46l9X/sWB0Nzd5er4Kz2YTm+Vl0qKFT9KUJvD8+fiO8AvoHhFvEatfVixA==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "bin": { - "esbuild": "bin/esbuild" - }, - "engines": { - "node": ">=18" - }, - "optionalDependencies": { - "@esbuild/aix-ppc64": "0.27.0", - "@esbuild/android-arm": "0.27.0", - "@esbuild/android-arm64": "0.27.0", - "@esbuild/android-x64": "0.27.0", - "@esbuild/darwin-arm64": "0.27.0", - "@esbuild/darwin-x64": "0.27.0", - "@esbuild/freebsd-arm64": "0.27.0", - "@esbuild/freebsd-x64": "0.27.0", - "@esbuild/linux-arm": "0.27.0", - "@esbuild/linux-arm64": "0.27.0", - "@esbuild/linux-ia32": "0.27.0", - "@esbuild/linux-loong64": "0.27.0", - "@esbuild/linux-mips64el": "0.27.0", - "@esbuild/linux-ppc64": "0.27.0", - "@esbuild/linux-riscv64": "0.27.0", - "@esbuild/linux-s390x": "0.27.0", - "@esbuild/linux-x64": "0.27.0", - "@esbuild/netbsd-arm64": "0.27.0", - "@esbuild/netbsd-x64": "0.27.0", - "@esbuild/openbsd-arm64": "0.27.0", - "@esbuild/openbsd-x64": "0.27.0", - "@esbuild/openharmony-arm64": "0.27.0", - "@esbuild/sunos-x64": "0.27.0", - "@esbuild/win32-arm64": "0.27.0", - "@esbuild/win32-ia32": "0.27.0", - "@esbuild/win32-x64": "0.27.0" - } - }, - "node_modules/fsevents": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, - "node_modules/get-tsconfig": { - "version": "4.13.0", - "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.0.tgz", - "integrity": "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "resolve-pkg-maps": "^1.0.0" - }, - "funding": { - "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" - } - }, - "node_modules/openworkflow": { - "resolved": "../../packages/openworkflow", - "link": true - }, - "node_modules/resolve-pkg-maps": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", - "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", - "dev": true, - "license": "MIT", - "funding": { - "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" - } - }, - "node_modules/tsx": { - "version": "4.21.0", - "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", - "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", - "dev": true, - "license": "MIT", - "dependencies": { - "esbuild": "~0.27.0", - "get-tsconfig": "^4.7.5" - }, - "bin": { - "tsx": "dist/cli.mjs" - }, - "engines": { - "node": ">=18.0.0" - }, - "optionalDependencies": { - "fsevents": "~2.3.3" - } - } - } -} diff --git a/examples/declare-workflow/package.json b/examples/declare-workflow/package.json index 9def4f3f..e3249ff5 100644 --- a/examples/declare-workflow/package.json +++ b/examples/declare-workflow/package.json @@ -6,8 +6,8 @@ "start": "tsx index.ts" }, "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" + "openworkflow": "*", + "postgres": "^3.4.9" }, "devDependencies": { "tsx": "^4.21.0" diff --git a/examples/with-schema-validation/arktype.ts b/examples/with-schema-validation/arktype.ts index c6823198..e7726750 100644 --- a/examples/with-schema-validation/arktype.ts +++ b/examples/with-schema-validation/arktype.ts @@ -1,7 +1,7 @@ -import { BackendPostgres } from "@openworkflow/backend-postgres"; import { type as arkType } from "arktype"; import { randomUUID } from "node:crypto"; import { OpenWorkflow } from "openworkflow"; +import { BackendPostgres } from "openworkflow/postgres"; const databaseUrl = "postgresql://postgres:postgres@localhost:5432/postgres"; const backend = await BackendPostgres.connect(databaseUrl, { diff --git a/examples/with-schema-validation/package-lock.json b/examples/with-schema-validation/package-lock.json deleted file mode 100644 index 4177df82..00000000 --- a/examples/with-schema-validation/package-lock.json +++ /dev/null @@ -1,704 +0,0 @@ -{ - "name": "example-with-zod-schema", - "lockfileVersion": 3, - "requires": true, - "packages": { - "": { - "name": "example-with-zod-schema", - "dependencies": { - "@openworkflow/backend-postgres": "*", - "arktype": "^2.1.29", - "openworkflow": "*", - "valibot": "^1.2.0", - "yup": "^1.7.1", - "zod": "^4.3.6" - }, - "devDependencies": { - "tsx": "^4.21.0" - } - }, - "../../packages/backend-postgres": { - "name": "@openworkflow/backend-postgres", - "version": "0.5.0", - "dependencies": { - "postgres": "^3.4.8" - }, - "devDependencies": { - "openworkflow": "*", - "squawk-cli": "^2.38.0", - "vitest": "^4.0.18" - }, - "peerDependencies": { - "openworkflow": "^0.5.0" - } - }, - "../../packages/openworkflow": { - "version": "0.5.0", - "license": "Apache-2.0", - "bin": { - "openworkflow": "dist/bin/openworkflow.js", - "ow": "dist/bin/openworkflow.js" - }, - "devDependencies": { - "arktype": "^2.1.29", - "valibot": "^1.2.0", - "vitest": "^4.0.18", - "yup": "^1.7.1", - "zod": "^4.3.6" - }, - "engines": { - "node": ">=20" - } - }, - "node_modules/@ark/schema": { - "version": "0.56.0", - "resolved": "https://registry.npmjs.org/@ark/schema/-/schema-0.56.0.tgz", - "integrity": "sha512-ECg3hox/6Z/nLajxXqNhgPtNdHWC9zNsDyskwO28WinoFEnWow4IsERNz9AnXRhTZJnYIlAJ4uGn3nlLk65vZA==", - "license": "MIT", - "dependencies": { - "@ark/util": "0.56.0" - } - }, - "node_modules/@ark/util": { - "version": "0.56.0", - "resolved": "https://registry.npmjs.org/@ark/util/-/util-0.56.0.tgz", - "integrity": "sha512-BghfRC8b9pNs3vBoDJhcta0/c1J1rsoS1+HgVUreMFPdhz/CRAKReAu57YEllNaSy98rWAdY1gE+gFup7OXpgA==", - "license": "MIT" - }, - "node_modules/@esbuild/aix-ppc64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.0.tgz", - "integrity": "sha512-KuZrd2hRjz01y5JK9mEBSD3Vj3mbCvemhT466rSuJYeE/hjuBrHfjjcjMdTm/sz7au+++sdbJZJmuBwQLuw68A==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "aix" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.0.tgz", - "integrity": "sha512-j67aezrPNYWJEOHUNLPj9maeJte7uSMM6gMoxfPC9hOg8N02JuQi/T7ewumf4tNvJadFkvLZMlAq73b9uwdMyQ==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.0.tgz", - "integrity": "sha512-CC3vt4+1xZrs97/PKDkl0yN7w8edvU2vZvAFGD16n9F0Cvniy5qvzRXjfO1l94efczkkQE6g1x0i73Qf5uthOQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.0.tgz", - "integrity": "sha512-wurMkF1nmQajBO1+0CJmcN17U4BP6GqNSROP8t0X/Jiw2ltYGLHpEksp9MpoBqkrFR3kv2/te6Sha26k3+yZ9Q==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.0.tgz", - "integrity": "sha512-uJOQKYCcHhg07DL7i8MzjvS2LaP7W7Pn/7uA0B5S1EnqAirJtbyw4yC5jQ5qcFjHK9l6o/MX9QisBg12kNkdHg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.0.tgz", - "integrity": "sha512-8mG6arH3yB/4ZXiEnXof5MK72dE6zM9cDvUcPtxhUZsDjESl9JipZYW60C3JGreKCEP+p8P/72r69m4AZGJd5g==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.0.tgz", - "integrity": "sha512-9FHtyO988CwNMMOE3YIeci+UV+x5Zy8fI2qHNpsEtSF83YPBmE8UWmfYAQg6Ux7Gsmd4FejZqnEUZCMGaNQHQw==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.0.tgz", - "integrity": "sha512-zCMeMXI4HS/tXvJz8vWGexpZj2YVtRAihHLk1imZj4efx1BQzN76YFeKqlDr3bUWI26wHwLWPd3rwh6pe4EV7g==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.0.tgz", - "integrity": "sha512-t76XLQDpxgmq2cNXKTVEB7O7YMb42atj2Re2Haf45HkaUpjM2J0UuJZDuaGbPbamzZ7bawyGFUkodL+zcE+jvQ==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.0.tgz", - "integrity": "sha512-AS18v0V+vZiLJyi/4LphvBE+OIX682Pu7ZYNsdUHyUKSoRwdnOsMf6FDekwoAFKej14WAkOef3zAORJgAtXnlQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.0.tgz", - "integrity": "sha512-Mz1jxqm/kfgKkc/KLHC5qIujMvnnarD9ra1cEcrs7qshTUSksPihGrWHVG5+osAIQ68577Zpww7SGapmzSt4Nw==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.0.tgz", - "integrity": "sha512-QbEREjdJeIreIAbdG2hLU1yXm1uu+LTdzoq1KCo4G4pFOLlvIspBm36QrQOar9LFduavoWX2msNFAAAY9j4BDg==", - "cpu": [ - "loong64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.0.tgz", - "integrity": "sha512-sJz3zRNe4tO2wxvDpH/HYJilb6+2YJxo/ZNbVdtFiKDufzWq4JmKAiHy9iGoLjAV7r/W32VgaHGkk35cUXlNOg==", - "cpu": [ - "mips64el" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.0.tgz", - "integrity": "sha512-z9N10FBD0DCS2dmSABDBb5TLAyF1/ydVb+N4pi88T45efQ/w4ohr/F/QYCkxDPnkhkp6AIpIcQKQ8F0ANoA2JA==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.0.tgz", - "integrity": "sha512-pQdyAIZ0BWIC5GyvVFn5awDiO14TkT/19FTmFcPdDec94KJ1uZcmFs21Fo8auMXzD4Tt+diXu1LW1gHus9fhFQ==", - "cpu": [ - "riscv64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.0.tgz", - "integrity": "sha512-hPlRWR4eIDDEci953RI1BLZitgi5uqcsjKMxwYfmi4LcwyWo2IcRP+lThVnKjNtk90pLS8nKdroXYOqW+QQH+w==", - "cpu": [ - "s390x" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.0.tgz", - "integrity": "sha512-1hBWx4OUJE2cab++aVZ7pObD6s+DK4mPGpemtnAORBvb5l/g5xFGk0vc0PjSkrDs0XaXj9yyob3d14XqvnQ4gw==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.0.tgz", - "integrity": "sha512-6m0sfQfxfQfy1qRuecMkJlf1cIzTOgyaeXaiVaaki8/v+WB+U4hc6ik15ZW6TAllRlg/WuQXxWj1jx6C+dfy3w==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.0.tgz", - "integrity": "sha512-xbbOdfn06FtcJ9d0ShxxvSn2iUsGd/lgPIO2V3VZIPDbEaIj1/3nBBe1AwuEZKXVXkMmpr6LUAgMkLD/4D2PPA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.0.tgz", - "integrity": "sha512-fWgqR8uNbCQ/GGv0yhzttj6sU/9Z5/Sv/VGU3F5OuXK6J6SlriONKrQ7tNlwBrJZXRYk5jUhuWvF7GYzGguBZQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.0.tgz", - "integrity": "sha512-aCwlRdSNMNxkGGqQajMUza6uXzR/U0dIl1QmLjPtRbLOx3Gy3otfFu/VjATy4yQzo9yFDGTxYDo1FfAD9oRD2A==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openharmony-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.0.tgz", - "integrity": "sha512-nyvsBccxNAsNYz2jVFYwEGuRRomqZ149A39SHWk4hV0jWxKM0hjBPm3AmdxcbHiFLbBSwG6SbpIcUbXjgyECfA==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openharmony" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.0.tgz", - "integrity": "sha512-Q1KY1iJafM+UX6CFEL+F4HRTgygmEW568YMqDA5UV97AuZSm21b7SXIrRJDwXWPzr8MGr75fUZPV67FdtMHlHA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.0.tgz", - "integrity": "sha512-W1eyGNi6d+8kOmZIwi/EDjrL9nxQIQ0MiGqe/AWc6+IaHloxHSGoeRgDRKHFISThLmsewZ5nHFvGFWdBYlgKPg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.0.tgz", - "integrity": "sha512-30z1aKL9h22kQhilnYkORFYt+3wp7yZsHWus+wSKAJR8JtdfI76LJ4SBdMsCopTR3z/ORqVu5L1vtnHZWVj4cQ==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-x64": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.0.tgz", - "integrity": "sha512-aIitBcjQeyOhMTImhLZmtxfdOcuNRpwlPNmlFKPcHQYPhEssw75Cl1TSXJXpMkzaua9FUetx/4OQKq7eJul5Cg==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@openworkflow/backend-postgres": { - "resolved": "../../packages/backend-postgres", - "link": true - }, - "node_modules/arkregex": { - "version": "0.0.5", - "resolved": "https://registry.npmjs.org/arkregex/-/arkregex-0.0.5.tgz", - "integrity": "sha512-ncYjBdLlh5/QnVsAA8De16Tc9EqmYM7y/WU9j+236KcyYNUXogpz3sC4ATIZYzzLxwI+0sEOaQLEmLmRleaEXw==", - "license": "MIT", - "dependencies": { - "@ark/util": "0.56.0" - } - }, - "node_modules/arktype": { - "version": "2.1.29", - "resolved": "https://registry.npmjs.org/arktype/-/arktype-2.1.29.tgz", - "integrity": "sha512-jyfKk4xIOzvYNayqnD8ZJQqOwcrTOUbIU4293yrzAjA3O1dWh61j71ArMQ6tS/u4pD7vabSPe7nG3RCyoXW6RQ==", - "license": "MIT", - "dependencies": { - "@ark/schema": "0.56.0", - "@ark/util": "0.56.0", - "arkregex": "0.0.5" - } - }, - "node_modules/esbuild": { - "version": "0.27.0", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.0.tgz", - "integrity": "sha512-jd0f4NHbD6cALCyGElNpGAOtWxSq46l9X/sWB0Nzd5er4Kz2YTm+Vl0qKFT9KUJvD8+fiO8AvoHhFvEatfVixA==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "bin": { - "esbuild": "bin/esbuild" - }, - "engines": { - "node": ">=18" - }, - "optionalDependencies": { - "@esbuild/aix-ppc64": "0.27.0", - "@esbuild/android-arm": "0.27.0", - "@esbuild/android-arm64": "0.27.0", - "@esbuild/android-x64": "0.27.0", - "@esbuild/darwin-arm64": "0.27.0", - "@esbuild/darwin-x64": "0.27.0", - "@esbuild/freebsd-arm64": "0.27.0", - "@esbuild/freebsd-x64": "0.27.0", - "@esbuild/linux-arm": "0.27.0", - "@esbuild/linux-arm64": "0.27.0", - "@esbuild/linux-ia32": "0.27.0", - "@esbuild/linux-loong64": "0.27.0", - "@esbuild/linux-mips64el": "0.27.0", - "@esbuild/linux-ppc64": "0.27.0", - "@esbuild/linux-riscv64": "0.27.0", - "@esbuild/linux-s390x": "0.27.0", - "@esbuild/linux-x64": "0.27.0", - "@esbuild/netbsd-arm64": "0.27.0", - "@esbuild/netbsd-x64": "0.27.0", - "@esbuild/openbsd-arm64": "0.27.0", - "@esbuild/openbsd-x64": "0.27.0", - "@esbuild/openharmony-arm64": "0.27.0", - "@esbuild/sunos-x64": "0.27.0", - "@esbuild/win32-arm64": "0.27.0", - "@esbuild/win32-ia32": "0.27.0", - "@esbuild/win32-x64": "0.27.0" - } - }, - "node_modules/fsevents": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, - "node_modules/get-tsconfig": { - "version": "4.13.0", - "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.0.tgz", - "integrity": "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "resolve-pkg-maps": "^1.0.0" - }, - "funding": { - "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" - } - }, - "node_modules/openworkflow": { - "resolved": "../../packages/openworkflow", - "link": true - }, - "node_modules/property-expr": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/property-expr/-/property-expr-2.0.6.tgz", - "integrity": "sha512-SVtmxhRE/CGkn3eZY1T6pC8Nln6Fr/lu1mKSgRud0eC73whjGfoAogbn78LkD8aFL0zz3bAFerKSnOl7NlErBA==", - "license": "MIT" - }, - "node_modules/resolve-pkg-maps": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", - "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", - "dev": true, - "license": "MIT", - "funding": { - "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" - } - }, - "node_modules/tiny-case": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/tiny-case/-/tiny-case-1.0.3.tgz", - "integrity": "sha512-Eet/eeMhkO6TX8mnUteS9zgPbUMQa4I6Kkp5ORiBD5476/m+PIRiumP5tmh5ioJpH7k51Kehawy2UDfsnxxY8Q==", - "license": "MIT" - }, - "node_modules/toposort": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/toposort/-/toposort-2.0.2.tgz", - "integrity": "sha512-0a5EOkAUp8D4moMi2W8ZF8jcga7BgZd91O/yabJCFY8az+XSzeGyTKs0Aoo897iV1Nj6guFq8orWDS96z91oGg==", - "license": "MIT" - }, - "node_modules/tsx": { - "version": "4.21.0", - "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", - "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", - "dev": true, - "license": "MIT", - "dependencies": { - "esbuild": "~0.27.0", - "get-tsconfig": "^4.7.5" - }, - "bin": { - "tsx": "dist/cli.mjs" - }, - "engines": { - "node": ">=18.0.0" - }, - "optionalDependencies": { - "fsevents": "~2.3.3" - } - }, - "node_modules/type-fest": { - "version": "2.19.0", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz", - "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==", - "license": "(MIT OR CC0-1.0)", - "engines": { - "node": ">=12.20" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/valibot": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/valibot/-/valibot-1.2.0.tgz", - "integrity": "sha512-mm1rxUsmOxzrwnX5arGS+U4T25RdvpPjPN4yR0u9pUBov9+zGVtO84tif1eY4r6zWxVxu3KzIyknJy3rxfRZZg==", - "license": "MIT", - "peerDependencies": { - "typescript": ">=5" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } - } - }, - "node_modules/yup": { - "version": "1.7.1", - "resolved": "https://registry.npmjs.org/yup/-/yup-1.7.1.tgz", - "integrity": "sha512-GKHFX2nXul2/4Dtfxhozv701jLQHdf6J34YDh2cEkpqoo8le5Mg6/LrdseVLrFarmFygZTlfIhHx/QKfb/QWXw==", - "license": "MIT", - "dependencies": { - "property-expr": "^2.0.5", - "tiny-case": "^1.0.3", - "toposort": "^2.0.2", - "type-fest": "^2.19.0" - } - }, - "node_modules/zod": { - "version": "4.3.6", - "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz", - "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==", - "license": "MIT", - "funding": { - "url": "https://github.com/sponsors/colinhacks" - } - } - } -} diff --git a/examples/with-schema-validation/package.json b/examples/with-schema-validation/package.json index a9b90f0a..2c8c5c0d 100644 --- a/examples/with-schema-validation/package.json +++ b/examples/with-schema-validation/package.json @@ -9,9 +9,9 @@ "zod": "tsx zod.ts" }, "dependencies": { - "@openworkflow/backend-postgres": "*", "arktype": "^2.2.0", "openworkflow": "*", + "postgres": "^3.4.9", "valibot": "^1.3.1", "yup": "^1.7.1", "zod": "^4.3.6" diff --git a/examples/with-schema-validation/valibot.ts b/examples/with-schema-validation/valibot.ts index 9ed52516..3f741a03 100644 --- a/examples/with-schema-validation/valibot.ts +++ b/examples/with-schema-validation/valibot.ts @@ -1,6 +1,6 @@ -import { BackendPostgres } from "@openworkflow/backend-postgres"; import { randomUUID } from "node:crypto"; import { OpenWorkflow } from "openworkflow"; +import { BackendPostgres } from "openworkflow/postgres"; import * as v from "valibot"; const databaseUrl = "postgresql://postgres:postgres@localhost:5432/postgres"; diff --git a/examples/with-schema-validation/yup.ts b/examples/with-schema-validation/yup.ts index e2551061..16f97368 100644 --- a/examples/with-schema-validation/yup.ts +++ b/examples/with-schema-validation/yup.ts @@ -1,6 +1,6 @@ -import { BackendPostgres } from "@openworkflow/backend-postgres"; import { randomUUID } from "node:crypto"; import { OpenWorkflow } from "openworkflow"; +import { BackendPostgres } from "openworkflow/postgres"; import { object as yupObject, string as yupString } from "yup"; const databaseUrl = "postgresql://postgres:postgres@localhost:5432/postgres"; diff --git a/examples/with-schema-validation/zod.ts b/examples/with-schema-validation/zod.ts index f175d7c6..23677daf 100644 --- a/examples/with-schema-validation/zod.ts +++ b/examples/with-schema-validation/zod.ts @@ -1,6 +1,6 @@ -import { BackendPostgres } from "@openworkflow/backend-postgres"; import { randomUUID } from "node:crypto"; import { OpenWorkflow } from "openworkflow"; +import { BackendPostgres } from "openworkflow/postgres"; import { z } from "zod"; const databaseUrl = "postgresql://postgres:postgres@localhost:5432/postgres"; diff --git a/examples/workflow-discovery/index.ts b/examples/workflow-discovery/index.ts index b65fd705..873be367 100644 --- a/examples/workflow-discovery/index.ts +++ b/examples/workflow-discovery/index.ts @@ -1,8 +1,8 @@ import greetingDefaultWorkflow from "./openworkflow/greeting-default.js"; import { greetingWorkflow } from "./openworkflow/greeting.js"; import { addWorkflow, multiplyWorkflow } from "./openworkflow/math.js"; -import { BackendSqlite } from "@openworkflow/backend-sqlite"; import { OpenWorkflow } from "openworkflow"; +import { BackendSqlite } from "openworkflow/sqlite"; // eslint-disable-next-line sonarjs/publicly-writable-directories const sqliteFileName = "/tmp/openworkflow_example_workflow_discovery.db"; diff --git a/examples/workflow-discovery/openworkflow.config.js b/examples/workflow-discovery/openworkflow.config.js index 1004eb4e..77128164 100644 --- a/examples/workflow-discovery/openworkflow.config.js +++ b/examples/workflow-discovery/openworkflow.config.js @@ -1,5 +1,5 @@ -import { BackendSqlite } from "@openworkflow/backend-sqlite"; import { defineConfig } from "@openworkflow/cli"; +import { BackendSqlite } from "openworkflow/sqlite"; // eslint-disable-next-line sonarjs/publicly-writable-directories const sqliteFileName = "/tmp/openworkflow_example_workflow_discovery.db"; diff --git a/examples/workflow-discovery/package-lock.json b/examples/workflow-discovery/package-lock.json deleted file mode 100644 index 7b69b835..00000000 --- a/examples/workflow-discovery/package-lock.json +++ /dev/null @@ -1,613 +0,0 @@ -{ - "name": "example-workflow-discovery", - "lockfileVersion": 3, - "requires": true, - "packages": { - "": { - "name": "example-workflow-discovery", - "dependencies": { - "@openworkflow/backend-sqlite": "*", - "openworkflow": "*" - }, - "devDependencies": { - "tsx": "^4.21.0" - } - }, - "../../packages/backend-sqlite": { - "name": "@openworkflow/backend-sqlite", - "version": "0.5.0", - "devDependencies": { - "openworkflow": "*", - "vitest": "^4.0.18" - }, - "engines": { - "node": ">=22.5.0" - }, - "peerDependencies": { - "openworkflow": "^0.5.0" - } - }, - "../../packages/cli": { - "name": "@openworkflow/cli", - "version": "0.1.0", - "extraneous": true, - "dependencies": { - "@clack/prompts": "^0.11.0", - "commander": "^14.0.2", - "consola": "^3.4.2", - "dotenv": "^17.2.3", - "jiti": "^2.6.1", - "nypm": "^0.6.2" - }, - "bin": { - "openworkflow": "dist/cli.js", - "ow": "dist/cli.js" - }, - "devDependencies": { - "openworkflow": "file:../openworkflow", - "vitest": "^4.0.16" - }, - "peerDependencies": { - "openworkflow": "^0.5.0" - } - }, - "../../packages/openworkflow": { - "version": "0.5.0", - "license": "Apache-2.0", - "bin": { - "openworkflow": "dist/bin/openworkflow.js", - "ow": "dist/bin/openworkflow.js" - }, - "devDependencies": { - "arktype": "^2.1.29", - "valibot": "^1.2.0", - "vitest": "^4.0.18", - "yup": "^1.7.1", - "zod": "^4.3.6" - }, - "engines": { - "node": ">=20" - } - }, - "node_modules/@esbuild/aix-ppc64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz", - "integrity": "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "aix" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz", - "integrity": "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz", - "integrity": "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-x64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz", - "integrity": "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-arm64": { - "version": "0.27.2", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz", - "integrity": "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz", - "integrity": "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz", - "integrity": "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz", - "integrity": "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==", - "cpu": [ - "arm" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz", - "integrity": "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz", - "integrity": "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz", - "integrity": "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==", - "cpu": [ - "loong64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz", - "integrity": "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==", - "cpu": [ - "mips64el" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz", - "integrity": "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==", - "cpu": [ - "ppc64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz", - "integrity": "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==", - "cpu": [ - "riscv64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz", - "integrity": "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==", - "cpu": [ - "s390x" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-x64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz", - "integrity": "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-arm64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz", - "integrity": "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz", - "integrity": "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-arm64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz", - "integrity": "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz", - "integrity": "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openharmony-arm64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz", - "integrity": "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "openharmony" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz", - "integrity": "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz", - "integrity": "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==", - "cpu": [ - "arm64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz", - "integrity": "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==", - "cpu": [ - "ia32" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-x64": { - "version": "0.27.2", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz", - "integrity": "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==", - "cpu": [ - "x64" - ], - "dev": true, - "license": "MIT", - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@openworkflow/backend-sqlite": { - "resolved": "../../packages/backend-sqlite", - "link": true - }, - "node_modules/esbuild": { - "version": "0.27.2", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "bin": { - "esbuild": "bin/esbuild" - }, - "engines": { - "node": ">=18" - }, - "optionalDependencies": { - "@esbuild/aix-ppc64": "0.27.2", - "@esbuild/android-arm": "0.27.2", - "@esbuild/android-arm64": "0.27.2", - "@esbuild/android-x64": "0.27.2", - "@esbuild/darwin-arm64": "0.27.2", - "@esbuild/darwin-x64": "0.27.2", - "@esbuild/freebsd-arm64": "0.27.2", - "@esbuild/freebsd-x64": "0.27.2", - "@esbuild/linux-arm": "0.27.2", - "@esbuild/linux-arm64": "0.27.2", - "@esbuild/linux-ia32": "0.27.2", - "@esbuild/linux-loong64": "0.27.2", - "@esbuild/linux-mips64el": "0.27.2", - "@esbuild/linux-ppc64": "0.27.2", - "@esbuild/linux-riscv64": "0.27.2", - "@esbuild/linux-s390x": "0.27.2", - "@esbuild/linux-x64": "0.27.2", - "@esbuild/netbsd-arm64": "0.27.2", - "@esbuild/netbsd-x64": "0.27.2", - "@esbuild/openbsd-arm64": "0.27.2", - "@esbuild/openbsd-x64": "0.27.2", - "@esbuild/openharmony-arm64": "0.27.2", - "@esbuild/sunos-x64": "0.27.2", - "@esbuild/win32-arm64": "0.27.2", - "@esbuild/win32-ia32": "0.27.2", - "@esbuild/win32-x64": "0.27.2" - } - }, - "node_modules/fsevents": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, - "node_modules/get-tsconfig": { - "version": "4.13.0", - "dev": true, - "license": "MIT", - "dependencies": { - "resolve-pkg-maps": "^1.0.0" - }, - "funding": { - "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" - } - }, - "node_modules/openworkflow": { - "resolved": "../../packages/openworkflow", - "link": true - }, - "node_modules/resolve-pkg-maps": { - "version": "1.0.0", - "dev": true, - "license": "MIT", - "funding": { - "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" - } - }, - "node_modules/tsx": { - "version": "4.21.0", - "dev": true, - "license": "MIT", - "dependencies": { - "esbuild": "~0.27.0", - "get-tsconfig": "^4.7.5" - }, - "bin": { - "tsx": "dist/cli.mjs" - }, - "engines": { - "node": ">=18.0.0" - }, - "optionalDependencies": { - "fsevents": "~2.3.3" - } - } - } -} diff --git a/examples/workflow-discovery/package.json b/examples/workflow-discovery/package.json index 45b4a61b..43022097 100644 --- a/examples/workflow-discovery/package.json +++ b/examples/workflow-discovery/package.json @@ -7,7 +7,6 @@ "worker": "tsx ../../packages/cli/cli.ts worker start" }, "dependencies": { - "@openworkflow/backend-sqlite": "*", "openworkflow": "*" }, "devDependencies": { diff --git a/package-lock.json b/package-lock.json index 4be8c7b7..a2a95775 100644 --- a/package-lock.json +++ b/package-lock.json @@ -54,8 +54,8 @@ "benchmarks/basic": { "name": "benchmark-basic", "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" + "openworkflow": "*", + "postgres": "^3.4.9" }, "devDependencies": { "tsx": "^4.21.0" @@ -64,8 +64,8 @@ "examples/basic": { "name": "example-basic", "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" + "openworkflow": "*", + "postgres": "^3.4.9" }, "devDependencies": { "tsx": "^4.21.0" @@ -74,8 +74,8 @@ "examples/declare-workflow": { "name": "example-declare-workflow", "dependencies": { - "@openworkflow/backend-postgres": "*", - "openworkflow": "*" + "openworkflow": "*", + "postgres": "^3.4.9" }, "devDependencies": { "tsx": "^4.21.0" @@ -84,9 +84,9 @@ "examples/with-schema-validation": { "name": "example-with-zod-schema", "dependencies": { - "@openworkflow/backend-postgres": "*", "arktype": "^2.2.0", "openworkflow": "*", + "postgres": "^3.4.9", "valibot": "^1.3.1", "yup": "^1.7.1", "zod": "^4.3.6" @@ -98,7 +98,6 @@ "examples/workflow-discovery": { "name": "example-workflow-discovery", "dependencies": { - "@openworkflow/backend-sqlite": "*", "openworkflow": "*" }, "devDependencies": { @@ -3256,14 +3255,6 @@ "node": ">=8.0.0" } }, - "node_modules/@openworkflow/backend-postgres": { - "resolved": "packages/backend-postgres", - "link": true - }, - "node_modules/@openworkflow/backend-sqlite": { - "resolved": "packages/backend-sqlite", - "link": true - }, "node_modules/@openworkflow/cli": { "resolved": "packages/cli", "link": true @@ -16924,32 +16915,6 @@ "zod": "^3.25 || ^4" } }, - "packages/backend-postgres": { - "name": "@openworkflow/backend-postgres", - "version": "0.6.3", - "dependencies": { - "postgres": "^3.4.9" - }, - "devDependencies": { - "openworkflow": "*" - }, - "peerDependencies": { - "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0" - } - }, - "packages/backend-sqlite": { - "name": "@openworkflow/backend-sqlite", - "version": "0.6.3", - "devDependencies": { - "openworkflow": "*" - }, - "engines": { - "node": ">=22.5.0" - }, - "peerDependencies": { - "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0" - } - }, "packages/cli": { "name": "@openworkflow/cli", "version": "0.4.4", diff --git a/packages/backend-postgres/CHANGELOG.md b/packages/backend-postgres/CHANGELOG.md deleted file mode 100644 index 3ffc7f70..00000000 --- a/packages/backend-postgres/CHANGELOG.md +++ /dev/null @@ -1,30 +0,0 @@ -# @openworkflow/backend-postgres - -## 0.6.3 - -### Patch Changes - -- Deprecate this package. It has moved into `openworkflow` core — import - `BackendPostgres` from `openworkflow/postgres` or `BackendSqlite` from - `openworkflow/sqlite` instead. A runtime warning is now emitted on import, and - the peer dependency range is widened to include `openworkflow` v0.9.0. This - package will be removed in a future release. - -## 0.6.2 - -- Add support for `openworkflow` v0.8.0 - -## 0.6.1 - -- Add support for `openworkflow` v0.7.0 - -## 0.6.0 - -- This package is now a thin compatibility shim. Prefer importing - `BackendPostgres` from `openworkflow/postgres`. - -## 0.5.1 - -- Change listWorkflowRuns to DESC ordering - -See the [openworkflow CHANGELOG](https://github.com/openworkflowdev/openworkflow/blob/main/packages/openworkflow/CHANGELOG.md) for details. diff --git a/packages/backend-postgres/README.md b/packages/backend-postgres/README.md deleted file mode 100644 index 7a57591b..00000000 --- a/packages/backend-postgres/README.md +++ /dev/null @@ -1,20 +0,0 @@ -# @openworkflow/backend-postgres - -> **Deprecated.** This package has moved into `openworkflow` core and will be -> removed in a future release. - -## Migration - -Import `BackendPostgres` from `openworkflow/postgres` directly: - -```diff -- import { BackendPostgres } from "@openworkflow/backend-postgres"; -+ import { BackendPostgres } from "openworkflow/postgres"; -``` - -Then remove `@openworkflow/backend-postgres` from your dependencies. No other -code changes are required — this package has been a thin re-export of -`openworkflow/postgres` since v0.6.0. - -See the [openworkflow README](https://github.com/openworkflowdev/openworkflow) -for current documentation. diff --git a/packages/backend-postgres/index.ts b/packages/backend-postgres/index.ts deleted file mode 100644 index 07fcb994..00000000 --- a/packages/backend-postgres/index.ts +++ /dev/null @@ -1,6 +0,0 @@ -console.warn( - "[@openworkflow/backend-postgres] This package is deprecated and will be removed. " + - 'Import `BackendPostgres` from "openworkflow/postgres" instead.', -); - -export { BackendPostgres } from "openworkflow/postgres"; diff --git a/packages/backend-postgres/package.json b/packages/backend-postgres/package.json deleted file mode 100644 index ac18d9f5..00000000 --- a/packages/backend-postgres/package.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "name": "@openworkflow/backend-postgres", - "version": "0.6.3", - "type": "module", - "exports": { - ".": { - "types": "./dist/index.d.ts", - "default": "./dist/index.js" - } - }, - "files": [ - "dist", - "!**/*.tsbuildinfo" - ], - "scripts": { - "build": "npm run clean && tsc", - "clean": "rm -rf dist", - "prepublishOnly": "npm run build" - }, - "dependencies": { - "postgres": "^3.4.9" - }, - "devDependencies": { - "openworkflow": "*" - }, - "peerDependencies": { - "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0" - } -} diff --git a/packages/backend-postgres/tsconfig.json b/packages/backend-postgres/tsconfig.json deleted file mode 100644 index b3db5ed0..00000000 --- a/packages/backend-postgres/tsconfig.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "extends": ["../../tsconfig.base.json"], - "compilerOptions": { - "outDir": "dist" - }, - "references": [{ "path": "../openworkflow" }], - "include": ["**/*.ts"], - "exclude": ["dist"] -} diff --git a/packages/backend-sqlite/CHANGELOG.md b/packages/backend-sqlite/CHANGELOG.md deleted file mode 100644 index e236d09e..00000000 --- a/packages/backend-sqlite/CHANGELOG.md +++ /dev/null @@ -1,30 +0,0 @@ -# @openworkflow/backend-sqlite - -## 0.6.3 - -### Patch Changes - -- Deprecate this package. It has moved into `openworkflow` core — import - `BackendPostgres` from `openworkflow/postgres` or `BackendSqlite` from - `openworkflow/sqlite` instead. A runtime warning is now emitted on import, and - the peer dependency range is widened to include `openworkflow` v0.9.0. This - package will be removed in a future release. - -## 0.6.2 - -- Add support for `openworkflow` v0.8.0 - -## 0.6.1 - -- Add support for `openworkflow` v0.7.0 - -## 0.6.0 - -- This package is now a thin compatibility shim. Prefer importing - `BackendSqlite` from `openworkflow/sqlite`. - -## 0.5.1 - -- Change listWorkflowRuns to DESC ordering - -See the [openworkflow CHANGELOG](https://github.com/openworkflowdev/openworkflow/blob/main/packages/openworkflow/CHANGELOG.md) for details. diff --git a/packages/backend-sqlite/README.md b/packages/backend-sqlite/README.md deleted file mode 100644 index ff332031..00000000 --- a/packages/backend-sqlite/README.md +++ /dev/null @@ -1,20 +0,0 @@ -# @openworkflow/backend-sqlite - -> **Deprecated.** This package has moved into `openworkflow` core and will be -> removed in a future release. - -## Migration - -Import `BackendSqlite` from `openworkflow/sqlite` directly: - -```diff -- import { BackendSqlite } from "@openworkflow/backend-sqlite"; -+ import { BackendSqlite } from "openworkflow/sqlite"; -``` - -Then remove `@openworkflow/backend-sqlite` from your dependencies. No other -code changes are required — this package has been a thin re-export of -`openworkflow/sqlite` since v0.6.0. - -See the [openworkflow README](https://github.com/openworkflowdev/openworkflow) -for current documentation. diff --git a/packages/backend-sqlite/index.ts b/packages/backend-sqlite/index.ts deleted file mode 100644 index 1618ca5f..00000000 --- a/packages/backend-sqlite/index.ts +++ /dev/null @@ -1,6 +0,0 @@ -console.warn( - "[@openworkflow/backend-sqlite] This package is deprecated and will be removed. " + - 'Import `BackendSqlite` from "openworkflow/sqlite" instead.', -); - -export { BackendSqlite } from "openworkflow/sqlite"; diff --git a/packages/backend-sqlite/package.json b/packages/backend-sqlite/package.json deleted file mode 100644 index 281caa0b..00000000 --- a/packages/backend-sqlite/package.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "name": "@openworkflow/backend-sqlite", - "version": "0.6.3", - "type": "module", - "exports": { - ".": { - "types": "./dist/index.d.ts", - "default": "./dist/index.js" - } - }, - "files": [ - "dist", - "!**/*.tsbuildinfo" - ], - "scripts": { - "build": "npm run clean && tsc", - "clean": "rm -rf dist", - "prepublishOnly": "npm run build" - }, - "devDependencies": { - "openworkflow": "*" - }, - "peerDependencies": { - "openworkflow": "^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0" - }, - "engines": { - "node": ">=22.5.0" - } -} diff --git a/packages/backend-sqlite/tsconfig.json b/packages/backend-sqlite/tsconfig.json deleted file mode 100644 index b3db5ed0..00000000 --- a/packages/backend-sqlite/tsconfig.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "extends": ["../../tsconfig.base.json"], - "compilerOptions": { - "outDir": "dist" - }, - "references": [{ "path": "../openworkflow" }], - "include": ["**/*.ts"], - "exclude": ["dist"] -} diff --git a/tsconfig.json b/tsconfig.json index 1a59f758..685a5de3 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -8,8 +8,6 @@ { "path": "./examples/with-schema-validation" }, { "path": "./examples/workflow-discovery" }, { "path": "./packages/openworkflow" }, - { "path": "./packages/backend-postgres" }, - { "path": "./packages/backend-sqlite" }, { "path": "./packages/cli" }, { "path": "./packages/dashboard" } ],