@multiplier-labs/stepflow 0.3.1 → 0.3.3

package/src/scheduler/sqlite-persistence.test.ts

@@ -1,15 +1,15 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import Database from "better-sqlite3";
-import { SQLiteSchedulePersistence } from "./sqlite-persistence";
-import type { WorkflowSchedule } from "./types";
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import Database from 'better-sqlite3';
+import { SQLiteSchedulePersistence } from './sqlite-persistence';
+import type { WorkflowSchedule } from './types';
 
-describe("SQLiteSchedulePersistence", () => {
+describe('SQLiteSchedulePersistence', () => {
   let db: Database.Database;
   let persistence: SQLiteSchedulePersistence;
 
   beforeEach(() => {
     // Use in-memory database for testing
-    db = new Database(":memory:");
+    db = new Database(':memory:');
     persistence = new SQLiteSchedulePersistence({ db });
   });
 
@@ -17,35 +17,35 @@ describe("SQLiteSchedulePersistence", () => {
     db.close();
   });
 
-  describe("saveSchedule", () => {
-    it("should save a cron schedule", async () => {
+  describe('saveSchedule', () => {
+    it('should save a cron schedule', async () => {
       const schedule: WorkflowSchedule = {
-        id: "test-1",
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
-        timezone: "UTC",
+        id: 'test-1',
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
+        timezone: 'UTC',
         enabled: true,
-        input: { foo: "bar" },
-        metadata: { user: "test" },
+        input: { foo: 'bar' },
+        metadata: { user: 'test' },
       };
 
       await persistence.saveSchedule(schedule);
 
       const loaded = await persistence.loadSchedules();
       expect(loaded).toHaveLength(1);
-      expect(loaded[0].id).toBe("test-1");
-      expect(loaded[0].cronExpression).toBe("0 * * * *");
-      expect(loaded[0].input).toEqual({ foo: "bar" });
+      expect(loaded[0].id).toBe('test-1');
+      expect(loaded[0].cronExpression).toBe('0 * * * *');
+      expect(loaded[0].input).toEqual({ foo: 'bar' });
     });
 
-    it("should save a workflow completion trigger", async () => {
+    it('should save a workflow completion trigger', async () => {
       const schedule: WorkflowSchedule = {
-        id: "test-2",
-        workflowKind: "notification.send",
-        triggerType: "workflow_completed",
-        triggerOnWorkflowKind: "order.process",
-        triggerOnStatus: ["succeeded", "failed"],
+        id: 'test-2',
+        workflowKind: 'notification.send',
+        triggerType: 'workflow_completed',
+        triggerOnWorkflowKind: 'order.process',
+        triggerOnStatus: ['succeeded', 'failed'],
         enabled: true,
       };
 
@@ -53,23 +53,23 @@ describe("SQLiteSchedulePersistence", () => {
 
       const loaded = await persistence.loadSchedules();
       expect(loaded).toHaveLength(1);
-      expect(loaded[0].triggerType).toBe("workflow_completed");
-      expect(loaded[0].triggerOnWorkflowKind).toBe("order.process");
-      expect(loaded[0].triggerOnStatus).toEqual(["succeeded", "failed"]);
+      expect(loaded[0].triggerType).toBe('workflow_completed');
+      expect(loaded[0].triggerOnWorkflowKind).toBe('order.process');
+      expect(loaded[0].triggerOnStatus).toEqual(['succeeded', 'failed']);
     });
 
-    it("should save schedule with dates", async () => {
-      const lastRunAt = new Date("2024-01-01T12:00:00Z");
-      const nextRunAt = new Date("2024-01-01T13:00:00Z");
+    it('should save schedule with dates', async () => {
+      const lastRunAt = new Date('2024-01-01T12:00:00Z');
+      const nextRunAt = new Date('2024-01-01T13:00:00Z');
 
       const schedule: WorkflowSchedule = {
-        id: "test-3",
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        id: 'test-3',
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
         lastRunAt,
-        lastRunId: "run-123",
+        lastRunId: 'run-123',
         nextRunAt,
       };
 
@@ -77,30 +77,30 @@ describe("SQLiteSchedulePersistence", () => {
 
       const loaded = await persistence.loadSchedules();
       expect(loaded[0].lastRunAt).toEqual(lastRunAt);
-      expect(loaded[0].lastRunId).toBe("run-123");
+      expect(loaded[0].lastRunId).toBe('run-123');
       expect(loaded[0].nextRunAt).toEqual(nextRunAt);
     });
   });
 
-  describe("loadSchedules", () => {
-    it("should return empty array when no schedules", async () => {
+  describe('loadSchedules', () => {
+    it('should return empty array when no schedules', async () => {
       const schedules = await persistence.loadSchedules();
       expect(schedules).toHaveLength(0);
     });
 
-    it("should load multiple schedules", async () => {
+    it('should load multiple schedules', async () => {
       await persistence.saveSchedule({
-        id: "schedule-1",
-        workflowKind: "workflow.a",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        id: 'schedule-1',
+        workflowKind: 'workflow.a',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
       await persistence.saveSchedule({
-        id: "schedule-2",
-        workflowKind: "workflow.b",
-        triggerType: "manual",
+        id: 'schedule-2',
+        workflowKind: 'workflow.b',
+        triggerType: 'manual',
         enabled: false,
       });
 
@@ -109,102 +109,102 @@ describe("SQLiteSchedulePersistence", () => {
     });
   });
 
-  describe("updateSchedule", () => {
-    it("should update enabled status", async () => {
+  describe('updateSchedule', () => {
+    it('should update enabled status', async () => {
       await persistence.saveSchedule({
-        id: "update-1",
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        id: 'update-1',
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
-      await persistence.updateSchedule("update-1", { enabled: false });
+      await persistence.updateSchedule('update-1', { enabled: false });
 
       const loaded = await persistence.loadSchedules();
       expect(loaded[0].enabled).toBe(false);
     });
 
-    it("should update cron expression", async () => {
+    it('should update cron expression', async () => {
       await persistence.saveSchedule({
-        id: "update-2",
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        id: 'update-2',
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
-      await persistence.updateSchedule("update-2", {
-        cronExpression: "30 * * * *",
+      await persistence.updateSchedule('update-2', {
+        cronExpression: '30 * * * *',
       });
 
       const loaded = await persistence.loadSchedules();
-      expect(loaded[0].cronExpression).toBe("30 * * * *");
+      expect(loaded[0].cronExpression).toBe('30 * * * *');
     });
 
-    it("should update lastRunAt and lastRunId", async () => {
+    it('should update lastRunAt and lastRunId', async () => {
       await persistence.saveSchedule({
-        id: "update-3",
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        id: 'update-3',
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
       const now = new Date();
-      await persistence.updateSchedule("update-3", {
+      await persistence.updateSchedule('update-3', {
         lastRunAt: now,
-        lastRunId: "run-456",
+        lastRunId: 'run-456',
       });
 
       const loaded = await persistence.loadSchedules();
       expect(loaded[0].lastRunAt).toEqual(now);
-      expect(loaded[0].lastRunId).toBe("run-456");
+      expect(loaded[0].lastRunId).toBe('run-456');
     });
 
-    it("should throw for non-existent schedule", async () => {
+    it('should throw for non-existent schedule', async () => {
       await expect(
-        persistence.updateSchedule("nonexistent", { enabled: false }),
-      ).rejects.toThrow("Schedule not found");
+        persistence.updateSchedule('nonexistent', { enabled: false })
+      ).rejects.toThrow('Schedule not found');
     });
   });
 
-  describe("deleteSchedule", () => {
-    it("should delete a schedule", async () => {
+  describe('deleteSchedule', () => {
+    it('should delete a schedule', async () => {
       await persistence.saveSchedule({
-        id: "delete-1",
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        id: 'delete-1',
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
-      await persistence.deleteSchedule("delete-1");
+      await persistence.deleteSchedule('delete-1');
 
       const loaded = await persistence.loadSchedules();
       expect(loaded).toHaveLength(0);
     });
 
-    it("should handle deleting non-existent schedule gracefully", async () => {
+    it('should handle deleting non-existent schedule gracefully', async () => {
       // This should not throw
-      await persistence.deleteSchedule("nonexistent");
+      await persistence.deleteSchedule('nonexistent');
     });
   });
 
-  describe("data integrity", () => {
-    it("should preserve all fields through save/load cycle", async () => {
+  describe('data integrity', () => {
+    it('should preserve all fields through save/load cycle', async () => {
       const schedule: WorkflowSchedule = {
-        id: "integrity-1",
-        workflowKind: "complex.workflow",
-        triggerType: "workflow_completed",
-        triggerOnWorkflowKind: "parent.workflow",
-        triggerOnStatus: ["succeeded"],
+        id: 'integrity-1',
+        workflowKind: 'complex.workflow',
+        triggerType: 'workflow_completed',
+        triggerOnWorkflowKind: 'parent.workflow',
+        triggerOnStatus: ['succeeded'],
         input: { nested: { value: 123 } },
-        metadata: { tags: ["a", "b"] },
+        metadata: { tags: ['a', 'b'] },
         enabled: true,
-        lastRunAt: new Date("2024-06-15T10:30:00Z"),
-        lastRunId: "run-789",
-        nextRunAt: new Date("2024-06-15T11:00:00Z"),
+        lastRunAt: new Date('2024-06-15T10:30:00Z'),
+        lastRunId: 'run-789',
+        nextRunAt: new Date('2024-06-15T11:00:00Z'),
       };
 
       await persistence.saveSchedule(schedule);
@@ -213,11 +213,11 @@ describe("SQLiteSchedulePersistence", () => {
       expect(loaded[0]).toEqual(schedule);
     });
 
-    it("should handle null/undefined values correctly", async () => {
+    it('should handle null/undefined values correctly', async () => {
       const schedule: WorkflowSchedule = {
-        id: "nullable-1",
-        workflowKind: "test.workflow",
-        triggerType: "manual",
+        id: 'nullable-1',
+        workflowKind: 'test.workflow',
+        triggerType: 'manual',
         enabled: false,
         // All other optional fields are undefined
       };

package/src/scheduler/sqlite-persistence.ts

@@ -4,10 +4,10 @@
  * Stores workflow schedules in a SQLite database table.
  */
 
-import type { Database, Statement } from "better-sqlite3";
-import type { WorkflowSchedule } from "./types";
-import type { SchedulePersistence } from "./cron";
-import { generateId } from "../utils/id";
+import type { Database, Statement } from 'better-sqlite3';
+import type { WorkflowSchedule } from './types';
+import type { SchedulePersistence } from './cron';
+import { generateId } from '../utils/id';
 
 // ============================================================================
 // Configuration Types
@@ -57,7 +57,7 @@ export class SQLiteSchedulePersistence implements SchedulePersistence {
 
   constructor(config: SQLiteSchedulePersistenceConfig) {
     this.db = config.db;
-    this.tableName = config.tableName ?? "workflow_schedules";
+    this.tableName = config.tableName ?? 'workflow_schedules';
     if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(this.tableName)) {
       throw new Error(`Invalid table name: ${this.tableName}`);
     }
@@ -159,7 +159,7 @@ export class SQLiteSchedulePersistence implements SchedulePersistence {
 
   async loadSchedules(): Promise<WorkflowSchedule[]> {
     const rows = this.stmts!.getAll.all() as ScheduleRow[];
-    return rows.map((row) => this.rowToSchedule(row));
+    return rows.map(row => this.rowToSchedule(row));
   }
 
   async saveSchedule(schedule: WorkflowSchedule): Promise<void> {
@@ -170,26 +170,19 @@ export class SQLiteSchedulePersistence implements SchedulePersistence {
       schedule.cronExpression ?? null,
       schedule.timezone ?? null,
       schedule.triggerOnWorkflowKind ?? null,
-      schedule.triggerOnStatus
-        ? JSON.stringify(schedule.triggerOnStatus)
-        : null,
+      schedule.triggerOnStatus ? JSON.stringify(schedule.triggerOnStatus) : null,
       schedule.input ? JSON.stringify(schedule.input) : null,
       schedule.metadata ? JSON.stringify(schedule.metadata) : null,
       schedule.enabled ? 1 : 0,
       schedule.lastRunAt?.toISOString() ?? null,
       schedule.lastRunId ?? null,
-      schedule.nextRunAt?.toISOString() ?? null,
+      schedule.nextRunAt?.toISOString() ?? null
     );
   }
 
-  async updateSchedule(
-    scheduleId: string,
-    updates: Partial<WorkflowSchedule>,
-  ): Promise<void> {
+  async updateSchedule(scheduleId: string, updates: Partial<WorkflowSchedule>): Promise<void> {
     // Get existing schedule to merge with updates
-    const existing = this.stmts!.getById.get(scheduleId) as
-      | ScheduleRow
-      | undefined;
+    const existing = this.stmts!.getById.get(scheduleId) as ScheduleRow | undefined;
     if (!existing) {
       throw new Error(`Schedule not found: ${scheduleId}`);
     }
@@ -212,7 +205,7 @@ export class SQLiteSchedulePersistence implements SchedulePersistence {
       merged.lastRunAt?.toISOString() ?? null,
       merged.lastRunId ?? null,
       merged.nextRunAt?.toISOString() ?? null,
-      scheduleId,
+      scheduleId
     );
   }
 
@@ -228,7 +221,7 @@ export class SQLiteSchedulePersistence implements SchedulePersistence {
     return {
       id: row.id,
       workflowKind: row.workflow_kind,
-      triggerType: row.trigger_type as WorkflowSchedule["triggerType"],
+      triggerType: row.trigger_type as WorkflowSchedule['triggerType'],
       cronExpression: row.cron_expression ?? undefined,
       timezone: row.timezone ?? undefined,
       triggerOnWorkflowKind: row.trigger_on_workflow_kind ?? undefined,

package/src/scheduler/types.ts

@@ -5,12 +5,12 @@
  * and {@link PostgresSchedulePersistence}.
  */
 
-import type { WorkflowKind, RunStatus } from "../core/types";
+import type { WorkflowKind, RunStatus } from '../core/types';
 
 /**
  * Schedule trigger types.
  */
-export type TriggerType = "cron" | "workflow_completed" | "manual";
+export type TriggerType = 'cron' | 'workflow_completed' | 'manual';
 
 /**
  * Schedule definition.
@@ -57,18 +57,13 @@ export interface Scheduler {
   stop(): Promise<void>;
 
   /** Add a schedule */
-  addSchedule(
-    schedule: Omit<WorkflowSchedule, "id">,
-  ): Promise<WorkflowSchedule>;
+  addSchedule(schedule: Omit<WorkflowSchedule, 'id'>): Promise<WorkflowSchedule>;
 
   /** Remove a schedule */
   removeSchedule(scheduleId: string): Promise<void>;
 
   /** Update a schedule */
-  updateSchedule(
-    scheduleId: string,
-    updates: Partial<WorkflowSchedule>,
-  ): Promise<void>;
+  updateSchedule(scheduleId: string, updates: Partial<WorkflowSchedule>): Promise<void>;
 
   /** Get all schedules */
   getSchedules(): Promise<WorkflowSchedule[]>;

package/src/storage/index.ts

@@ -2,10 +2,10 @@
  * Storage module exports.
  */
 
-export * from "./types";
-export * from "./memory";
-export * from "./sqlite";
-export * from "./postgres";
+export * from './types';
+export * from './memory';
+export * from './sqlite';
+export * from './postgres';
 
 // Re-export specific types for convenience
 export type {
@@ -24,4 +24,4 @@ export type {
   StepflowRunsTable,
   StepflowStepResultsTable,
   StepflowDatabase,
-} from "./types";
+} from './types';