@multiplier-labs/stepflow 0.3.1 → 0.3.4

package/src/scheduler/cron.ts

@@ -4,13 +4,13 @@
  * Provides time-based and workflow-completion-based triggers for workflows.
  */
 
-import { CronExpressionParser } from "cron-parser";
-import type { WorkflowKind, RunStatus, Logger } from "../core/types";
-import type { WorkflowEngine } from "../core/engine";
-import type { Scheduler, WorkflowSchedule, TriggerType } from "./types";
-import type { WorkflowEvent } from "../events/types";
-import { generateId } from "../utils/id";
-import { ConsoleLogger } from "../utils/logger";
+import { CronExpressionParser } from 'cron-parser';
+import type { WorkflowKind, RunStatus, Logger } from '../core/types';
+import type { WorkflowEngine } from '../core/engine';
+import type { Scheduler, WorkflowSchedule, TriggerType } from './types';
+import type { WorkflowEvent } from '../events/types';
+import { generateId } from '../utils/id';
+import { ConsoleLogger } from '../utils/logger';
 
 // ============================================================================
 // Configuration Types
@@ -45,10 +45,7 @@ export interface SchedulePersistence {
   saveSchedule(schedule: WorkflowSchedule): Promise<void>;
 
   /** Update a schedule */
-  updateSchedule(
-    scheduleId: string,
-    updates: Partial<WorkflowSchedule>,
-  ): Promise<void>;
+  updateSchedule(scheduleId: string, updates: Partial<WorkflowSchedule>): Promise<void>;
 
   /** Delete a schedule */
   deleteSchedule(scheduleId: string): Promise<void>;
@@ -116,11 +113,21 @@ export class CronScheduler implements Scheduler {
    */
   async start(): Promise<void> {
     if (this.running) {
-      this.logger.warn("Scheduler is already running");
+      this.logger.warn('Scheduler is already running');
       return;
     }
 
-    this.logger.info("Starting scheduler...");
+    // Clean up any leftover subscriptions from a previous start/stop cycle
+    if (this.eventUnsubscribe) {
+      this.eventUnsubscribe();
+      this.eventUnsubscribe = null;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+
+    this.logger.info('Starting scheduler...');
 
     // Load schedules from persistence if available
     if (this.persistence) {
@@ -131,18 +138,29 @@ export class CronScheduler implements Scheduler {
       this.logger.info(`Loaded ${loaded.length} schedules from persistence`);
     }
 
-    // Calculate next run times for cron schedules
+    // Calculate next run times for cron schedules.
+    // Wrap each schedule in try-catch so one invalid persisted cron expression
+    // doesn't prevent the rest from loading.
     for (const schedule of this.schedules.values()) {
-      if (schedule.triggerType === "cron" && schedule.cronExpression) {
-        this.updateNextRunTime(schedule);
+      if (schedule.triggerType === 'cron' && schedule.cronExpression) {
+        try {
+          CronExpressionParser.parse(schedule.cronExpression, {
+            tz: schedule.timezone,
+          });
+          this.updateNextRunTime(schedule);
+        } catch (error) {
+          this.logger.error(
+            `Invalid cron expression "${schedule.cronExpression}" for schedule ${schedule.id}, disabling schedule:`,
+            error
+          );
+          schedule.enabled = false;
+          schedule.nextRunAt = undefined;
+        }
       }
     }
 
     // Start polling for cron schedules
-    this.pollTimer = setInterval(
-      () => this.checkSchedules(),
-      this.pollInterval,
-    );
+    this.pollTimer = setInterval(() => this.checkSchedules(), this.pollInterval);
 
     // Subscribe to workflow completion events
     this.eventUnsubscribe = this.engine.subscribeToAll((event) => {
@@ -150,7 +168,7 @@ export class CronScheduler implements Scheduler {
     });
 
     this.running = true;
-    this.logger.info("Scheduler started");
+    this.logger.info('Scheduler started');
   }
 
   /**
@@ -162,7 +180,7 @@ export class CronScheduler implements Scheduler {
       return;
     }
 
-    this.logger.info("Stopping scheduler...");
+    this.logger.info('Stopping scheduler...');
 
     if (this.pollTimer) {
       clearInterval(this.pollTimer);
@@ -175,22 +193,20 @@ export class CronScheduler implements Scheduler {
     }
 
     this.running = false;
-    this.logger.info("Scheduler stopped");
+    this.logger.info('Scheduler stopped');
   }
 
   /**
    * Add a new schedule.
    */
-  async addSchedule(
-    scheduleData: Omit<WorkflowSchedule, "id">,
-  ): Promise<WorkflowSchedule> {
+  async addSchedule(scheduleData: Omit<WorkflowSchedule, 'id'>): Promise<WorkflowSchedule> {
     const schedule: WorkflowSchedule = {
       ...scheduleData,
       id: generateId(),
     };
 
     // Validate cron expression if provided
-    if (schedule.triggerType === "cron" && schedule.cronExpression) {
+    if (schedule.triggerType === 'cron' && schedule.cronExpression) {
       try {
         CronExpressionParser.parse(schedule.cronExpression, {
           tz: schedule.timezone,
@@ -204,11 +220,9 @@ export class CronScheduler implements Scheduler {
     }
 
     // Validate workflow completion trigger
-    if (schedule.triggerType === "workflow_completed") {
+    if (schedule.triggerType === 'workflow_completed') {
       if (!schedule.triggerOnWorkflowKind) {
-        throw new Error(
-          "triggerOnWorkflowKind is required for workflow_completed triggers",
-        );
+        throw new Error('triggerOnWorkflowKind is required for workflow_completed triggers');
       }
     }
 
@@ -219,9 +233,7 @@ export class CronScheduler implements Scheduler {
       await this.persistence.saveSchedule(schedule);
     }
 
-    this.logger.info(
-      `Added schedule: ${schedule.id} (${schedule.workflowKind})`,
-    );
+    this.logger.info(`Added schedule: ${schedule.id} (${schedule.workflowKind})`);
 
     return schedule;
   }
@@ -246,10 +258,7 @@ export class CronScheduler implements Scheduler {
   /**
    * Update a schedule.
    */
-  async updateSchedule(
-    scheduleId: string,
-    updates: Partial<WorkflowSchedule>,
-  ): Promise<void> {
+  async updateSchedule(scheduleId: string, updates: Partial<WorkflowSchedule>): Promise<void> {
     const schedule = this.schedules.get(scheduleId);
     if (!schedule) {
       throw new Error(`Schedule not found: ${scheduleId}`);
@@ -262,10 +271,7 @@ export class CronScheduler implements Scheduler {
     Object.assign(schedule, updates);
 
     // Revalidate and update next run time if cron expression changed
-    if (
-      updates.cronExpression !== undefined ||
-      updates.timezone !== undefined
-    ) {
+    if (updates.cronExpression !== undefined || updates.timezone !== undefined) {
       if (schedule.cronExpression) {
         try {
           CronExpressionParser.parse(schedule.cronExpression, {
@@ -273,9 +279,7 @@ export class CronScheduler implements Scheduler {
           });
           this.updateNextRunTime(schedule);
         } catch (error) {
-          throw new Error(
-            `Invalid cron expression: ${schedule.cronExpression}`,
-          );
+          throw new Error(`Invalid cron expression: ${schedule.cronExpression}`);
         }
       }
     }
@@ -325,16 +329,13 @@ export class CronScheduler implements Scheduler {
 
     for (const schedule of this.schedules.values()) {
       if (!schedule.enabled) continue;
-      if (schedule.triggerType !== "cron") continue;
+      if (schedule.triggerType !== 'cron') continue;
       if (!schedule.nextRunAt) continue;
 
       if (schedule.nextRunAt <= now) {
         // Execute the schedule
         this.executeSchedule(schedule).catch((error) => {
-          this.logger.error(
-            `Failed to execute schedule ${schedule.id}:`,
-            error,
-          );
+          this.logger.error(`Failed to execute schedule ${schedule.id}:`, error);
         });
 
         // Update next run time
@@ -349,28 +350,21 @@ export class CronScheduler implements Scheduler {
   private handleWorkflowEvent(event: WorkflowEvent): void {
     // Only handle run completion events
     // Note: orchestrator emits 'run.completed' for success, 'run.failed' for failure
-    if (
-      event.eventType !== "run.completed" &&
-      event.eventType !== "run.failed"
-    ) {
+    if (event.eventType !== 'run.completed' && event.eventType !== 'run.failed') {
       return;
     }
 
-    const completedStatus: RunStatus =
-      event.eventType === "run.completed" ? "succeeded" : "failed";
+    const completedStatus: RunStatus = event.eventType === 'run.completed' ? 'succeeded' : 'failed';
     const completedKind = event.kind;
 
     // Find schedules triggered by this workflow completion
     for (const schedule of this.schedules.values()) {
       if (!schedule.enabled) continue;
-      if (schedule.triggerType !== "workflow_completed") continue;
+      if (schedule.triggerType !== 'workflow_completed') continue;
       if (schedule.triggerOnWorkflowKind !== completedKind) continue;
 
       // Check if the status matches
-      if (
-        schedule.triggerOnStatus &&
-        !schedule.triggerOnStatus.includes(completedStatus)
-      ) {
+      if (schedule.triggerOnStatus && !schedule.triggerOnStatus.includes(completedStatus)) {
         continue;
       }
 
@@ -389,11 +383,9 @@ export class CronScheduler implements Scheduler {
    */
   private async executeSchedule(
     schedule: WorkflowSchedule,
-    triggerContext?: { triggerRunId?: string; triggerStatus?: RunStatus },
+    triggerContext?: { triggerRunId?: string; triggerStatus?: RunStatus }
   ): Promise<string> {
-    this.logger.info(
-      `Executing schedule: ${schedule.id} (${schedule.workflowKind})`,
-    );
+    this.logger.info(`Executing schedule: ${schedule.id} (${schedule.workflowKind})`);
 
     // Build metadata with trigger info
     const metadata = {
@@ -439,10 +431,7 @@ export class CronScheduler implements Scheduler {
 
       schedule.nextRunAt = interval.next().toDate();
     } catch (error) {
-      this.logger.error(
-        `Failed to parse cron expression for schedule ${schedule.id}:`,
-        error,
-      );
+      this.logger.error(`Failed to parse cron expression for schedule ${schedule.id}:`, error);
       schedule.nextRunAt = undefined;
     }
   }

package/src/scheduler/index.ts

@@ -2,17 +2,7 @@
  * Scheduler module exports.
  */
 
-export * from "./types";
-export {
-  CronScheduler,
-  type CronSchedulerConfig,
-  type SchedulePersistence,
-} from "./cron";
-export {
-  SQLiteSchedulePersistence,
-  type SQLiteSchedulePersistenceConfig,
-} from "./sqlite-persistence";
-export {
-  PostgresSchedulePersistence,
-  type PostgresSchedulePersistenceConfig,
-} from "./postgres-persistence";
+export * from './types';
+export { CronScheduler, type CronSchedulerConfig, type SchedulePersistence } from './cron';
+export { SQLiteSchedulePersistence, type SQLiteSchedulePersistenceConfig } from './sqlite-persistence';
+export { PostgresSchedulePersistence, type PostgresSchedulePersistenceConfig } from './postgres-persistence';

package/src/scheduler/postgres-persistence.ts

@@ -4,17 +4,19 @@
  * Stores workflow schedules in a PostgreSQL database table using Kysely.
  */
 
-import type { Kysely as KyselyType } from "kysely";
-import type { Pool, PoolConfig } from "pg";
-import { loadPostgresDeps } from "../utils/postgres-deps.js";
+import type { Kysely as KyselyType } from 'kysely';
+import type { Pool, PoolConfig } from 'pg';
+import { loadPostgresDeps } from '../utils/postgres-deps.js';
 
 // Lazy-loaded dependencies - populated by loadPostgresDeps() during initialize()
 let Kysely: any;
 let PostgresDialect: any;
 let sql: any;
 let pgModule: any;
-import type { WorkflowSchedule } from "./types.js";
-import type { SchedulePersistence } from "./cron.js";
+import type { WorkflowSchedule } from './types.js';
+import type { SchedulePersistence } from './cron.js';
+import type { Logger, RunStatus } from '../core/types.js';
+import { safeJsonParse as sharedSafeJsonParse } from '../utils/safe-json.js';
 
 // ============================================================================
 // Database Types (Kysely schema)
@@ -97,6 +99,13 @@ export interface PostgresSchedulePersistenceConfig {
    * @default true
    */
   autoMigrate?: boolean;
+
+  /**
+   * Optional structured logger used to surface JSON corruption events.
+   * Without one, parse failures still increment the corruption counter
+   * exposed via `getJsonParseCorruptionCount()` but produce no log output.
+   */
+  logger?: Logger;
 }
 
 // ============================================================================
@@ -141,24 +150,26 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
   private autoMigrate: boolean;
   private initialized = false;
   private config: PostgresSchedulePersistenceConfig;
+  private logger: Logger | undefined;
 
   constructor(config: PostgresSchedulePersistenceConfig) {
-    this.schema = config.schema ?? "public";
+    this.schema = config.schema ?? 'public';
     if (!/^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/.test(this.schema)) {
       throw new Error(
         `Invalid schema name "${this.schema}". Schema must start with a letter or underscore, ` +
-          `contain only alphanumeric characters and underscores, and be at most 63 characters.`,
+        `contain only alphanumeric characters and underscores, and be at most 63 characters.`
       );
     }
-    this.tableName = config.tableName ?? "workflow_schedules";
+    this.tableName = config.tableName ?? 'workflow_schedules';
     if (!/^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/.test(this.tableName)) {
       throw new Error(
         `Invalid table name "${this.tableName}". Table name must start with a letter or underscore, ` +
-          `contain only alphanumeric characters and underscores, and be at most 63 characters.`,
+        `contain only alphanumeric characters and underscores, and be at most 63 characters.`
       );
     }
     this.autoMigrate = config.autoMigrate !== false;
     this.config = config;
+    this.logger = config.logger;
   }
 
   /**
@@ -172,7 +183,7 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
   private ensureInitialized(): void {
     if (!this.initialized) {
       throw new Error(
-        "PostgresSchedulePersistence is not initialized. Call initialize() before using the adapter.",
+        'PostgresSchedulePersistence is not initialized. Call initialize() before using the adapter.'
       );
     }
   }
@@ -196,16 +207,14 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
       this.pool = this.config.pool;
       this.ownsPool = false;
     } else if (this.config.connectionString) {
-      this.pool = new pgModule.Pool({
-        connectionString: this.config.connectionString,
-      });
+      this.pool = new pgModule.Pool({ connectionString: this.config.connectionString });
       this.ownsPool = true;
     } else if (this.config.poolConfig) {
       this.pool = new pgModule.Pool(this.config.poolConfig);
       this.ownsPool = true;
     } else {
       throw new Error(
-        "PostgresSchedulePersistenceConfig must include either pool, connectionString, or poolConfig",
+        'PostgresSchedulePersistenceConfig must include either pool, connectionString, or poolConfig'
       );
     }
 
@@ -238,16 +247,13 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
   // ============================================================================
 
   private async createTables(): Promise<void> {
-    const fullTableName =
-      this.schema === "public"
-        ? this.tableName
-        : `${this.schema}.${this.tableName}`;
+    const fullTableName = this.schema === 'public'
+      ? this.tableName
+      : `${this.schema}.${this.tableName}`;
 
     // Create schema if not public
-    if (this.schema !== "public") {
-      await sql`CREATE SCHEMA IF NOT EXISTS ${sql.ref(this.schema)}`.execute(
-        this.db,
-      );
+    if (this.schema !== 'public') {
+      await sql`CREATE SCHEMA IF NOT EXISTS ${sql.ref(this.schema)}`.execute(this.db);
     }
 
     // Create schedules table.
@@ -316,12 +322,12 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
 
   async loadSchedules(): Promise<WorkflowSchedule[]> {
     this.ensureInitialized();
-    const rows = (await this.qb
+    const rows = await this.qb
       .selectFrom(this.tableName as any)
       .selectAll()
-      .execute()) as WorkflowSchedulesTable[];
+      .execute() as WorkflowSchedulesTable[];
 
-    return rows.map((row) => this.rowToSchedule(row));
+    return rows.map(row => this.rowToSchedule(row));
   }
 
   async saveSchedule(schedule: WorkflowSchedule): Promise<void> {
@@ -335,13 +341,9 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
         cron_expression: schedule.cronExpression ?? null,
         timezone: schedule.timezone ?? null,
         trigger_on_workflow_kind: schedule.triggerOnWorkflowKind ?? null,
-        trigger_on_status: schedule.triggerOnStatus
-          ? JSON.stringify(schedule.triggerOnStatus)
-          : null,
+        trigger_on_status: schedule.triggerOnStatus ? JSON.stringify(schedule.triggerOnStatus) : null,
         input_json: schedule.input ? JSON.stringify(schedule.input) : null,
-        metadata_json: schedule.metadata
-          ? JSON.stringify(schedule.metadata)
-          : null,
+        metadata_json: schedule.metadata ? JSON.stringify(schedule.metadata) : null,
         enabled: schedule.enabled,
         last_run_at: schedule.lastRunAt ?? null,
         last_run_id: schedule.lastRunId ?? null,
@@ -352,20 +354,17 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
       .execute();
   }
 
-  async updateSchedule(
-    scheduleId: string,
-    updates: Partial<WorkflowSchedule>,
-  ): Promise<void> {
+  async updateSchedule(scheduleId: string, updates: Partial<WorkflowSchedule>): Promise<void> {
     this.ensureInitialized();
     // Partial update pattern: fetch the existing row, merge with incoming updates,
     // then build a column-level update object. Each field is only included if it was
     // explicitly provided in `updates` (or affected by the merge), so unchanged
     // columns are left untouched in the database.
-    const existing = (await this.qb
+    const existing = await this.qb
       .selectFrom(this.tableName as any)
       .selectAll()
-      .where("id", "=", scheduleId)
-      .executeTakeFirst()) as WorkflowSchedulesTable | undefined;
+      .where('id', '=', scheduleId)
+      .executeTakeFirst() as WorkflowSchedulesTable | undefined;
 
     if (!existing) {
       throw new Error(`Schedule not found: ${scheduleId}`);
@@ -383,30 +382,18 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
       dbKey: keyof WorkflowSchedulesTable;
       serialize?: (value: any) => any;
     }> = [
-      { domainKey: "workflowKind", dbKey: "workflow_kind" },
-      { domainKey: "triggerType", dbKey: "trigger_type" },
-      { domainKey: "cronExpression", dbKey: "cron_expression" },
-      { domainKey: "timezone", dbKey: "timezone" },
-      { domainKey: "triggerOnWorkflowKind", dbKey: "trigger_on_workflow_kind" },
-      {
-        domainKey: "triggerOnStatus",
-        dbKey: "trigger_on_status",
-        serialize: (v) => (v ? JSON.stringify(v) : null),
-      },
-      {
-        domainKey: "input",
-        dbKey: "input_json",
-        serialize: (v) => (v ? JSON.stringify(v) : null),
-      },
-      {
-        domainKey: "metadata",
-        dbKey: "metadata_json",
-        serialize: (v) => (v ? JSON.stringify(v) : null),
-      },
-      { domainKey: "enabled", dbKey: "enabled" },
-      { domainKey: "lastRunAt", dbKey: "last_run_at" },
-      { domainKey: "lastRunId", dbKey: "last_run_id" },
-      { domainKey: "nextRunAt", dbKey: "next_run_at" },
+      { domainKey: 'workflowKind', dbKey: 'workflow_kind' },
+      { domainKey: 'triggerType', dbKey: 'trigger_type' },
+      { domainKey: 'cronExpression', dbKey: 'cron_expression' },
+      { domainKey: 'timezone', dbKey: 'timezone' },
+      { domainKey: 'triggerOnWorkflowKind', dbKey: 'trigger_on_workflow_kind' },
+      { domainKey: 'triggerOnStatus', dbKey: 'trigger_on_status', serialize: v => v ? JSON.stringify(v) : null },
+      { domainKey: 'input', dbKey: 'input_json', serialize: v => v ? JSON.stringify(v) : null },
+      { domainKey: 'metadata', dbKey: 'metadata_json', serialize: v => v ? JSON.stringify(v) : null },
+      { domainKey: 'enabled', dbKey: 'enabled' },
+      { domainKey: 'lastRunAt', dbKey: 'last_run_at' },
+      { domainKey: 'lastRunId', dbKey: 'last_run_id' },
+      { domainKey: 'nextRunAt', dbKey: 'next_run_at' },
     ];
 
     const updateData: Partial<WorkflowSchedulesTable> = {
@@ -425,7 +412,7 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
     await this.qb
       .updateTable(this.tableName as any)
       .set(updateData)
-      .where("id", "=", scheduleId)
+      .where('id', '=', scheduleId)
       .execute();
   }
 
@@ -433,7 +420,7 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
     this.ensureInitialized();
     await this.qb
       .deleteFrom(this.tableName as any)
-      .where("id", "=", scheduleId)
+      .where('id', '=', scheduleId)
       .execute();
   }
 
@@ -446,11 +433,11 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
    */
   async getSchedule(scheduleId: string): Promise<WorkflowSchedule | null> {
     this.ensureInitialized();
-    const row = (await this.qb
+    const row = await this.qb
       .selectFrom(this.tableName as any)
       .selectAll()
-      .where("id", "=", scheduleId)
-      .executeTakeFirst()) as WorkflowSchedulesTable | undefined;
+      .where('id', '=', scheduleId)
+      .executeTakeFirst() as WorkflowSchedulesTable | undefined;
 
     return row ? this.rowToSchedule(row) : null;
   }
@@ -462,78 +449,75 @@ export class PostgresSchedulePersistence implements SchedulePersistence {
     this.ensureInitialized();
     const now = new Date();
 
-    const rows = (await this.qb
+    const rows = await this.qb
       .selectFrom(this.tableName as any)
       .selectAll()
-      .where("enabled", "=", true)
-      .where("trigger_type", "=", "cron")
-      .where("next_run_at", "<=", now)
-      .execute()) as WorkflowSchedulesTable[];
+      .where('enabled', '=', true)
+      .where('trigger_type', '=', 'cron')
+      .where('next_run_at', '<=', now)
+      .execute() as WorkflowSchedulesTable[];
 
-    return rows.map((row) => this.rowToSchedule(row));
+    return rows.map(row => this.rowToSchedule(row));
   }
 
   /**
    * Get schedules by workflow kind.
    */
-  async getSchedulesByWorkflowKind(
-    workflowKind: string,
-  ): Promise<WorkflowSchedule[]> {
+  async getSchedulesByWorkflowKind(workflowKind: string): Promise<WorkflowSchedule[]> {
     this.ensureInitialized();
-    const rows = (await this.qb
+    const rows = await this.qb
       .selectFrom(this.tableName as any)
       .selectAll()
-      .where("workflow_kind", "=", workflowKind)
-      .execute()) as WorkflowSchedulesTable[];
+      .where('workflow_kind', '=', workflowKind)
+      .execute() as WorkflowSchedulesTable[];
 
-    return rows.map((row) => this.rowToSchedule(row));
+    return rows.map(row => this.rowToSchedule(row));
   }
 
   /**
    * Get workflow completion triggers for a specific workflow kind.
    */
-  async getCompletionTriggers(
-    triggerOnWorkflowKind: string,
-  ): Promise<WorkflowSchedule[]> {
+  async getCompletionTriggers(triggerOnWorkflowKind: string): Promise<WorkflowSchedule[]> {
     this.ensureInitialized();
-    const rows = (await this.qb
+    const rows = await this.qb
       .selectFrom(this.tableName as any)
       .selectAll()
-      .where("enabled", "=", true)
-      .where("trigger_type", "=", "workflow_completed")
-      .where("trigger_on_workflow_kind", "=", triggerOnWorkflowKind)
-      .execute()) as WorkflowSchedulesTable[];
+      .where('enabled', '=', true)
+      .where('trigger_type', '=', 'workflow_completed')
+      .where('trigger_on_workflow_kind', '=', triggerOnWorkflowKind)
+      .execute() as WorkflowSchedulesTable[];
 
-    return rows.map((row) => this.rowToSchedule(row));
+    return rows.map(row => this.rowToSchedule(row));
   }
 
   // ============================================================================
   // Helper Methods
   // ============================================================================
 
+  private safeParseOptionalField(value: unknown, rowId: string, column: string): unknown {
+    if (!value) return undefined;
+    if (typeof value === 'string') {
+      return sharedSafeJsonParse(value, undefined, {
+        component: 'PostgresSchedulePersistence',
+        rowId,
+        column,
+        logger: this.logger,
+      });
+    }
+    return value;
+  }
+
   private rowToSchedule(row: WorkflowSchedulesTable): WorkflowSchedule {
     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,
-      triggerOnStatus: row.trigger_on_status
-        ? typeof row.trigger_on_status === "string"
-          ? JSON.parse(row.trigger_on_status)
-          : row.trigger_on_status
-        : undefined,
-      input: row.input_json
-        ? typeof row.input_json === "string"
-          ? JSON.parse(row.input_json)
-          : row.input_json
-        : undefined,
-      metadata: row.metadata_json
-        ? typeof row.metadata_json === "string"
-          ? JSON.parse(row.metadata_json)
-          : row.metadata_json
-        : undefined,
+      triggerOnStatus: this.safeParseOptionalField(row.trigger_on_status, row.id, 'trigger_on_status') as RunStatus[] | undefined,
+      input: this.safeParseOptionalField(row.input_json, row.id, 'input_json') as Record<string, unknown> | undefined,
+      metadata: this.safeParseOptionalField(row.metadata_json, row.id, 'metadata_json') as Record<string, unknown> | undefined,
       enabled: row.enabled,
       lastRunAt: row.last_run_at ? new Date(row.last_run_at) : undefined,
       lastRunId: row.last_run_id ?? undefined,