@spfn/workflow 0.1.0-alpha.2

package/dist/index.js

@@ -0,0 +1,824 @@
+import { eq, and, desc, inArray } from 'drizzle-orm';
+import { Value } from '@sinclair/typebox/value';
+import { createSchema, timestamps } from '@spfn/core/db';
+import { timestamp, text, integer, jsonb, index } from 'drizzle-orm/pg-core';
+
+// src/builder/workflow-builder.ts
+var WorkflowBuilder = class _WorkflowBuilder {
+  _name;
+  _inputSchema;
+  _steps = [];
+  _resumable = false;
+  _rollbackEnabled = true;
+  _notifyConfigs = [];
+  constructor(name) {
+    this._name = name;
+  }
+  /**
+   * Define input schema
+   */
+  input(schema) {
+    const builder = new _WorkflowBuilder(this._name);
+    builder._inputSchema = schema;
+    builder._steps = this._steps;
+    builder._resumable = this._resumable;
+    builder._rollbackEnabled = this._rollbackEnabled;
+    builder._notifyConfigs = [...this._notifyConfigs];
+    return builder;
+  }
+  /**
+   * Add a sequential step
+   */
+  pipe(job, mapper) {
+    const stepName = job.name;
+    const step = {
+      name: stepName,
+      job,
+      mapper,
+      type: "sequential"
+    };
+    const builder = new _WorkflowBuilder(this._name);
+    builder._inputSchema = this._inputSchema;
+    builder._steps = [...this._steps, step];
+    builder._resumable = this._resumable;
+    builder._rollbackEnabled = this._rollbackEnabled;
+    builder._notifyConfigs = [...this._notifyConfigs];
+    return builder;
+  }
+  /**
+   * Add parallel steps
+   */
+  parallel(steps) {
+    const parallelGroup = `parallel_${this._steps.length}`;
+    const parallelSteps = [];
+    for (const [name, [job, mapper]] of Object.entries(steps)) {
+      parallelSteps.push({
+        name,
+        job,
+        mapper,
+        type: "parallel",
+        parallelGroup
+      });
+    }
+    const builder = new _WorkflowBuilder(this._name);
+    builder._inputSchema = this._inputSchema;
+    builder._steps = [...this._steps, ...parallelSteps];
+    builder._resumable = this._resumable;
+    builder._rollbackEnabled = this._rollbackEnabled;
+    builder._notifyConfigs = [...this._notifyConfigs];
+    return builder;
+  }
+  /**
+   * Enable/disable resumable (restart from failure point)
+   */
+  resumable(enabled = true) {
+    this._resumable = enabled;
+    return this;
+  }
+  /**
+   * Enable/disable rollback on failure
+   */
+  rollback(enabled = true) {
+    this._rollbackEnabled = enabled;
+    return this;
+  }
+  /**
+   * Configure notifications (chainable — each call adds a separate config)
+   */
+  notify(config) {
+    this._notifyConfigs.push(config);
+    return this;
+  }
+  /**
+   * Build the workflow definition
+   */
+  build() {
+    return {
+      name: this._name,
+      inputSchema: this._inputSchema,
+      steps: this._steps,
+      resumable: this._resumable,
+      rollbackEnabled: this._rollbackEnabled,
+      notifyConfigs: this._notifyConfigs,
+      _input: void 0
+    };
+  }
+};
+function workflow(name) {
+  return new WorkflowBuilder(name);
+}
+var workflowSchema = createSchema("@spfn/workflow");
+var workflowExecutions = workflowSchema.table(
+  "executions",
+  {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    /**
+     * Workflow name (identifier)
+     */
+    workflowName: text("workflow_name").notNull(),
+    /**
+     * Execution status
+     */
+    status: text("status").$type().notNull().default("pending"),
+    /**
+     * Input data (JSON)
+     */
+    input: jsonb("input"),
+    /**
+     * Current step index
+     */
+    currentStep: integer("current_step").notNull().default(0),
+    /**
+     * Error message (if failed)
+     */
+    error: text("error"),
+    /**
+     * Completed timestamp
+     */
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    ...timestamps()
+  },
+  (table) => [
+    index("wf_exec_workflow_name_idx").on(table.workflowName),
+    index("wf_exec_status_idx").on(table.status),
+    index("wf_exec_created_at_idx").on(table.createdAt),
+    index("wf_exec_workflow_status_idx").on(table.workflowName, table.status)
+  ]
+);
+var workflowStepExecutions = workflowSchema.table(
+  "step_executions",
+  {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    /**
+     * Parent workflow execution ID
+     */
+    executionId: text("execution_id").notNull().references(() => workflowExecutions.id, { onDelete: "cascade" }),
+    /**
+     * Step name (job name)
+     */
+    stepName: text("step_name").notNull(),
+    /**
+     * Step index in the workflow
+     */
+    stepIndex: integer("step_index").notNull(),
+    /**
+     * Step execution status
+     */
+    status: text("status").$type().notNull().default("pending"),
+    /**
+     * Step output data (JSON or URL reference for large data)
+     */
+    output: jsonb("output"),
+    /**
+     * Error message (if failed)
+     */
+    error: text("error"),
+    /**
+     * Started timestamp
+     */
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    /**
+     * Completed timestamp
+     */
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    ...timestamps()
+  },
+  (table) => [
+    index("wf_step_exec_execution_id_idx").on(table.executionId),
+    index("wf_step_exec_status_idx").on(table.status),
+    index("wf_step_exec_exec_step_idx").on(table.executionId, table.stepIndex)
+  ]
+);
+
+// src/engine/types.ts
+var defaultLogger = {
+  info: (message, ...args) => console.log(message, ...args),
+  error: (message, ...args) => console.error(message, ...args),
+  warn: (message, ...args) => console.warn(message, ...args),
+  debug: (message, ...args) => console.debug(message, ...args)
+};
+
+// src/engine/workflow-engine.ts
+var DEFAULT_LARGE_OUTPUT_THRESHOLD = 1024 * 1024;
+var WorkflowEngineImpl = class {
+  config;
+  workflows;
+  subscribers;
+  logger;
+  /** Track executions currently being processed to prevent race conditions */
+  processingExecutions;
+  constructor(workflows, config) {
+    this.config = config;
+    this.workflows = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.logger = config.logger ?? defaultLogger;
+    this.processingExecutions = /* @__PURE__ */ new Set();
+    for (const wf of workflows) {
+      this.workflows.set(wf.name, wf);
+    }
+  }
+  /**
+   * Get database instance
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get db() {
+    return this.config.db;
+  }
+  /**
+   * Start a workflow execution
+   */
+  async start(name, input) {
+    const workflow2 = this.workflows.get(name);
+    if (!workflow2) {
+      throw new Error(`Workflow '${name}' not found`);
+    }
+    if (this.config.validateInput !== false && workflow2.inputSchema) {
+      if (!Value.Check(workflow2.inputSchema, input)) {
+        const errors = [...Value.Errors(workflow2.inputSchema, input)];
+        const errorMessages = errors.map((e) => `${e.path}: ${e.message}`).join(", ");
+        throw new Error(`Invalid workflow input: ${errorMessages}`);
+      }
+    }
+    const execution = await this.db.transaction(async (tx) => {
+      const [exec] = await tx.insert(workflowExecutions).values({
+        workflowName: name,
+        status: "pending",
+        input,
+        currentStep: 0
+      }).returning();
+      const stepRecords = workflow2.steps.map((step, index3) => ({
+        executionId: exec.id,
+        stepName: step.name,
+        stepIndex: index3,
+        status: "pending"
+      }));
+      if (stepRecords.length > 0) {
+        await tx.insert(workflowStepExecutions).values(stepRecords);
+      }
+      return exec;
+    });
+    this.emitEvent({
+      type: "started",
+      workflowName: name,
+      executionId: execution.id,
+      input,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    this.executeNextStep(execution.id, workflow2, input).catch((error) => {
+      this.logger.error(`[Workflow:${name}] Execution error:`, error);
+    });
+    return {
+      id: execution.id,
+      workflowName: name,
+      status: "pending"
+    };
+  }
+  /**
+   * Execute steps iteratively until completion or failure
+   */
+  async executeNextStep(executionId, workflow2, input) {
+    while (true) {
+      const execution = await this.getExecution(executionId);
+      if (!execution || execution.status !== "pending" && execution.status !== "running") {
+        return;
+      }
+      if (execution.status === "pending") {
+        await this.updateExecutionStatus(executionId, "running");
+      }
+      const results = await this.getCompletedResults(executionId);
+      const pendingSteps = execution.steps.filter((s) => s.status === "pending");
+      if (pendingSteps.length === 0) {
+        await this.completeExecution(executionId);
+        return;
+      }
+      const currentStepIndex = Math.min(...pendingSteps.map((s) => s.stepIndex));
+      await this.db.update(workflowExecutions).set({ currentStep: currentStepIndex, updatedAt: /* @__PURE__ */ new Date() }).where(eq(workflowExecutions.id, executionId));
+      const stepDef = workflow2.steps[currentStepIndex];
+      if (stepDef.type === "parallel") {
+        const parallelSteps = workflow2.steps.filter(
+          (s) => s.parallelGroup === stepDef.parallelGroup
+        );
+        const errors = await Promise.all(
+          parallelSteps.map(
+            (step) => this.executeStep(executionId, workflow2, step, input, results)
+          )
+        );
+        const firstError = errors.find((e) => e !== null);
+        if (firstError) {
+          await this.handleStepFailure(executionId, workflow2, firstError);
+          return;
+        }
+      } else {
+        const error = await this.executeStep(executionId, workflow2, stepDef, input, results);
+        if (error) {
+          await this.handleStepFailure(executionId, workflow2, error);
+          return;
+        }
+      }
+    }
+  }
+  /**
+   * Execute a single step
+   *
+   * Returns the error message if the step failed, or null if successful.
+   */
+  async executeStep(executionId, workflow2, step, input, results) {
+    const stepExecution = await this.getStepExecution(executionId, step.name);
+    if (!stepExecution || stepExecution.status !== "pending") {
+      return null;
+    }
+    await this.updateStepStatus(stepExecution.id, "running");
+    this.emitEvent({
+      type: "step.started",
+      workflowName: workflow2.name,
+      executionId,
+      stepName: step.name,
+      stepIndex: stepExecution.stepIndex,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    try {
+      const context = {
+        input,
+        results,
+        execution: {
+          id: executionId,
+          workflowName: workflow2.name,
+          startedAt: /* @__PURE__ */ new Date()
+        }
+      };
+      const stepInput = step.mapper(context);
+      const output = await step.job.run(stepInput);
+      const storedOutput = await this.storeOutput(output);
+      await this.updateStepStatus(stepExecution.id, "completed", storedOutput);
+      this.emitEvent({
+        type: "step.completed",
+        workflowName: workflow2.name,
+        executionId,
+        stepName: step.name,
+        stepIndex: stepExecution.stepIndex,
+        output: storedOutput,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      return null;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      await this.updateStepStatus(stepExecution.id, "failed", void 0, errorMessage);
+      this.emitEvent({
+        type: "step.failed",
+        workflowName: workflow2.name,
+        executionId,
+        stepName: step.name,
+        stepIndex: stepExecution.stepIndex,
+        error: errorMessage,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      return errorMessage;
+    }
+  }
+  /**
+   * Handle step failure - rollback if enabled
+   */
+  async handleStepFailure(executionId, workflow2, error) {
+    await this.db.update(workflowExecutions).set({
+      status: "failed",
+      error,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq(workflowExecutions.id, executionId));
+    this.emitEvent({
+      type: "failed",
+      workflowName: workflow2.name,
+      executionId,
+      error,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (workflow2.rollbackEnabled) {
+      await this.executeRollback(executionId, workflow2);
+    }
+  }
+  /**
+   * Execute rollback in reverse order
+   */
+  async executeRollback(executionId, workflow2) {
+    await this.updateExecutionStatus(executionId, "compensating");
+    const execution = await this.getExecution(executionId);
+    if (!execution) return;
+    const completedSteps = execution.steps.filter((s) => s.status === "completed").sort((a, b) => b.stepIndex - a.stepIndex);
+    for (const stepExecution of completedSteps) {
+      const stepDef = workflow2.steps.find((s) => s.name === stepExecution.stepName);
+      if (!stepDef || !stepDef.job.compensate) {
+        continue;
+      }
+      try {
+        const input = execution.input;
+        const output = await this.resolveOutput(stepExecution.output);
+        await stepDef.job.compensate(input, output);
+        await this.updateStepStatus(stepExecution.id, "compensated");
+      } catch (compensateError) {
+        this.logger.error(
+          `[Workflow:${workflow2.name}] Compensate error for step ${stepExecution.stepName}:`,
+          compensateError
+        );
+      }
+    }
+    await this.updateExecutionStatus(executionId, "compensated");
+  }
+  /**
+   * Complete the workflow execution
+   */
+  async completeExecution(executionId) {
+    const execution = await this.getExecution(executionId);
+    if (!execution) return;
+    await this.db.update(workflowExecutions).set({
+      status: "completed",
+      completedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq(workflowExecutions.id, executionId));
+    this.emitEvent({
+      type: "completed",
+      workflowName: execution.workflowName,
+      executionId,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Get execution with steps
+   */
+  async getExecution(executionId) {
+    const [execution] = await this.db.select().from(workflowExecutions).where(eq(workflowExecutions.id, executionId));
+    if (!execution) return null;
+    const steps = await this.db.select().from(workflowStepExecutions).where(eq(workflowStepExecutions.executionId, executionId)).orderBy(workflowStepExecutions.stepIndex);
+    return { ...execution, steps };
+  }
+  /**
+   * Get step execution
+   */
+  async getStepExecution(executionId, stepName) {
+    const [step] = await this.db.select().from(workflowStepExecutions).where(
+      and(
+        eq(workflowStepExecutions.executionId, executionId),
+        eq(workflowStepExecutions.stepName, stepName)
+      )
+    );
+    return step || null;
+  }
+  /**
+   * Get completed step results
+   */
+  async getCompletedResults(executionId) {
+    const steps = await this.db.select().from(workflowStepExecutions).where(
+      and(
+        eq(workflowStepExecutions.executionId, executionId),
+        eq(workflowStepExecutions.status, "completed")
+      )
+    );
+    const results = {};
+    for (const step of steps) {
+      results[step.stepName] = await this.resolveOutput(step.output);
+    }
+    return results;
+  }
+  /**
+   * Update execution status
+   */
+  async updateExecutionStatus(executionId, status) {
+    await this.db.update(workflowExecutions).set({
+      status,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq(workflowExecutions.id, executionId));
+  }
+  /**
+   * Update step status
+   */
+  async updateStepStatus(stepId, status, output, error) {
+    const updates = {
+      status,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (status === "running") {
+      updates.startedAt = /* @__PURE__ */ new Date();
+    }
+    if (status === "completed" || status === "failed") {
+      updates.completedAt = /* @__PURE__ */ new Date();
+    }
+    if (output !== void 0) {
+      updates.output = output;
+    }
+    if (error !== void 0) {
+      updates.error = error;
+    }
+    await this.db.update(workflowStepExecutions).set(updates).where(eq(workflowStepExecutions.id, stepId));
+  }
+  /**
+   * Store output (handle large data)
+   */
+  async storeOutput(output) {
+    if (!output || !this.config.storage) return output;
+    const json = JSON.stringify(output);
+    const threshold = this.config.largeOutputThreshold ?? DEFAULT_LARGE_OUTPUT_THRESHOLD;
+    if (Buffer.byteLength(json, "utf8") > threshold) {
+      const url = await this.config.storage.upload(output);
+      return { $ref: url };
+    }
+    return output;
+  }
+  /**
+   * Resolve output (fetch from storage if needed)
+   */
+  async resolveOutput(output) {
+    if (!output) return output;
+    const ref = output;
+    if (ref.$ref && this.config.storage) {
+      return await this.config.storage.download(ref.$ref);
+    }
+    return output;
+  }
+  /**
+   * Emit event to subscribers and notification providers
+   */
+  emitEvent(event) {
+    const subscribers = this.subscribers.get(event.executionId);
+    if (subscribers) {
+      for (const callback of subscribers) {
+        try {
+          callback(event);
+        } catch (error) {
+          this.logger.error("[WorkflowEngine] Subscriber error:", error);
+        }
+      }
+      const terminalEvents = ["completed", "failed", "cancelled"];
+      if (terminalEvents.includes(event.type)) {
+        this.subscribers.delete(event.executionId);
+      }
+    }
+    this.sendNotifications(event).catch((error) => {
+      this.logger.error("[WorkflowEngine] Notification error:", error);
+    });
+  }
+  /**
+   * Send notifications based on workflow config
+   */
+  async sendNotifications(event) {
+    const workflow2 = this.workflows.get(event.workflowName);
+    if (!workflow2 || workflow2.notifyConfigs.length === 0) {
+      return;
+    }
+    for (const { on, when, providers } of workflow2.notifyConfigs) {
+      if (!on.includes(event.type)) {
+        continue;
+      }
+      if (when && !when(event)) {
+        continue;
+      }
+      await Promise.all(
+        providers.map(async (provider) => {
+          try {
+            await provider.notify(event);
+          } catch (error) {
+            this.logger.error(
+              `[WorkflowEngine] Notification provider '${provider.name}' error:`,
+              error
+            );
+          }
+        })
+      );
+    }
+  }
+  // Public API methods
+  async get(executionId) {
+    return this.getExecution(executionId);
+  }
+  async getStepOutput(executionId, stepName) {
+    const step = await this.getStepExecution(executionId, stepName);
+    if (!step) return null;
+    return this.resolveOutput(step.output);
+  }
+  async list(options) {
+    const conditions = [];
+    if (options?.workflowName) {
+      conditions.push(eq(workflowExecutions.workflowName, options.workflowName));
+    }
+    if (options?.status) {
+      conditions.push(eq(workflowExecutions.status, options.status));
+    }
+    let query = this.db.select().from(workflowExecutions).orderBy(desc(workflowExecutions.createdAt));
+    if (conditions.length > 0) {
+      query = query.where(conditions.length === 1 ? conditions[0] : and(...conditions));
+    }
+    if (options?.limit) {
+      query = query.limit(options.limit);
+    }
+    if (options?.offset) {
+      query = query.offset(options.offset);
+    }
+    const executions = await query;
+    if (executions.length === 0) {
+      return [];
+    }
+    const executionIds = executions.map((e) => e.id);
+    const allSteps = await this.db.select().from(workflowStepExecutions).where(inArray(workflowStepExecutions.executionId, executionIds)).orderBy(workflowStepExecutions.stepIndex);
+    const stepsByExecutionId = /* @__PURE__ */ new Map();
+    for (const step of allSteps) {
+      const steps = stepsByExecutionId.get(step.executionId) ?? [];
+      steps.push(step);
+      stepsByExecutionId.set(step.executionId, steps);
+    }
+    return executions.map((execution) => ({
+      ...execution,
+      steps: stepsByExecutionId.get(execution.id) ?? []
+    }));
+  }
+  async retry(executionId) {
+    if (this.processingExecutions.has(executionId)) {
+      throw new Error(`Execution '${executionId}' is already being processed`);
+    }
+    const execution = await this.getExecution(executionId);
+    if (!execution) {
+      throw new Error(`Execution '${executionId}' not found`);
+    }
+    const retryableStatuses = ["failed", "compensated"];
+    if (!retryableStatuses.includes(execution.status)) {
+      throw new Error(
+        `Cannot retry execution '${executionId}' with status '${execution.status}'. Only 'failed' or 'compensated' executions can be retried.`
+      );
+    }
+    const workflow2 = this.workflows.get(execution.workflowName);
+    if (!workflow2) {
+      throw new Error(`Workflow '${execution.workflowName}' not found`);
+    }
+    this.processingExecutions.add(executionId);
+    try {
+      if (workflow2.resumable) {
+        await this.updateExecutionStatus(executionId, "running");
+        const failedSteps = execution.steps.filter((s) => s.status === "failed");
+        for (const step of failedSteps) {
+          await this.updateStepStatus(step.id, "pending");
+        }
+      } else {
+        await this.resetAllSteps(execution.steps);
+        await this.db.update(workflowExecutions).set({
+          status: "pending",
+          currentStep: 0,
+          error: null,
+          completedAt: null,
+          updatedAt: /* @__PURE__ */ new Date()
+        }).where(eq(workflowExecutions.id, executionId));
+      }
+      this.executeNextStep(
+        executionId,
+        workflow2,
+        execution.input
+      ).catch((error) => {
+        this.logger.error(`[Workflow:${workflow2.name}] Retry error:`, error);
+      }).finally(() => {
+        this.processingExecutions.delete(executionId);
+      });
+      return {
+        id: executionId,
+        workflowName: execution.workflowName,
+        status: "pending"
+      };
+    } catch (error) {
+      this.processingExecutions.delete(executionId);
+      throw error;
+    }
+  }
+  /**
+   * Reset all steps to pending state
+   */
+  async resetAllSteps(steps) {
+    if (steps.length === 0) return;
+    await this.db.update(workflowStepExecutions).set({
+      status: "pending",
+      output: null,
+      error: null,
+      startedAt: null,
+      completedAt: null,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(inArray(workflowStepExecutions.id, steps.map((s) => s.id)));
+  }
+  async cancel(executionId, options) {
+    const execution = await this.getExecution(executionId);
+    if (!execution) {
+      throw new Error(`Execution '${executionId}' not found`);
+    }
+    const cancellableStatuses = ["pending", "running"];
+    if (!cancellableStatuses.includes(execution.status)) {
+      throw new Error(
+        `Cannot cancel execution '${executionId}' with status '${execution.status}'. Only 'pending' or 'running' executions can be cancelled.`
+      );
+    }
+    const workflow2 = this.workflows.get(execution.workflowName);
+    await this.updateExecutionStatus(executionId, "cancelled");
+    this.emitEvent({
+      type: "cancelled",
+      workflowName: execution.workflowName,
+      executionId,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (options?.rollback && workflow2) {
+      await this.executeRollback(executionId, workflow2);
+    }
+  }
+  subscribe(executionId, callback) {
+    if (!this.subscribers.has(executionId)) {
+      this.subscribers.set(executionId, /* @__PURE__ */ new Set());
+    }
+    this.subscribers.get(executionId).add(callback);
+    return () => {
+      this.subscribers.get(executionId)?.delete(callback);
+    };
+  }
+};
+function createWorkflowEngine(options) {
+  const { workflows, ...config } = options;
+  return new WorkflowEngineImpl(workflows, config);
+}
+
+// src/notification/providers.ts
+var consoleProvider = {
+  name: "console",
+  async notify(event) {
+    const timestamp3 = event.timestamp.toISOString();
+    const prefix = `[Workflow:${event.workflowName}]`;
+    switch (event.type) {
+      case "started":
+        console.log(`${timestamp3} ${prefix} Started (id: ${event.executionId})`);
+        break;
+      case "completed":
+        console.log(`${timestamp3} ${prefix} Completed (id: ${event.executionId})`);
+        break;
+      case "failed":
+        console.error(`${timestamp3} ${prefix} Failed: ${event.error} (id: ${event.executionId})`);
+        break;
+      case "cancelled":
+        console.log(`${timestamp3} ${prefix} Cancelled (id: ${event.executionId})`);
+        break;
+      case "step.started":
+        console.log(`${timestamp3} ${prefix} Step '${event.stepName}' started`);
+        break;
+      case "step.completed":
+        console.log(`${timestamp3} ${prefix} Step '${event.stepName}' completed`);
+        break;
+      case "step.failed":
+        console.error(`${timestamp3} ${prefix} Step '${event.stepName}' failed: ${event.error}`);
+        break;
+    }
+  }
+};
+function formatEventAsText(event) {
+  const lines = [
+    `Workflow: ${event.workflowName}`,
+    `Event: ${event.type}`,
+    `Execution ID: ${event.executionId}`,
+    `Timestamp: ${event.timestamp.toISOString()}`
+  ];
+  if (event.stepName) {
+    lines.push(`Step: ${event.stepName}`);
+  }
+  if (event.error) {
+    lines.push(`Error: ${event.error}`);
+  }
+  return lines.join("\n");
+}
+
+// src/config/workflow-router.ts
+function defineWorkflowRouter(workflows) {
+  const state = {
+    engine: null
+  };
+  return {
+    workflows,
+    _workflows: workflows,
+    get engine() {
+      if (!state.engine) {
+        throw new Error(
+          "Workflow engine not initialized. Make sure the server is started with .workflows(router) configuration."
+        );
+      }
+      return state.engine;
+    },
+    get isInitialized() {
+      return state.engine !== null;
+    },
+    _init(db, options) {
+      if (state.engine) {
+        return;
+      }
+      state.engine = createWorkflowEngine({
+        db,
+        workflows,
+        largeOutputThreshold: options?.largeOutputThreshold,
+        storage: options?.storage,
+        logger: options?.logger,
+        validateInput: options?.validateInput
+      });
+    }
+  };
+}
+function isWorkflowRouter(value) {
+  return typeof value === "object" && value !== null && "_workflows" in value && "_init" in value && typeof value._init === "function";
+}
+
+export { WorkflowBuilder, consoleProvider, createWorkflowEngine, defaultLogger, defineWorkflowRouter, formatEventAsText, isWorkflowRouter, workflow, workflowExecutions, workflowStepExecutions };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map