@multiplier-labs/stepflow 0.3.3 → 0.3.6

package/src/utils/logger.test.ts

@@ -1,121 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { ConsoleLogger, SilentLogger, createScopedLogger } from './logger';
-
-describe('ConsoleLogger', () => {
-  it('should log debug messages with prefix', () => {
-    const spy = vi.spyOn(console, 'debug').mockImplementation(() => {});
-    const logger = new ConsoleLogger('[test]', 'debug');
-
-    logger.debug('hello', { extra: true });
-
-    expect(spy).toHaveBeenCalledWith('[test] [DEBUG]', 'hello', { extra: true });
-    spy.mockRestore();
-  });
-
-  it('should log info messages with prefix', () => {
-    const spy = vi.spyOn(console, 'info').mockImplementation(() => {});
-    const logger = new ConsoleLogger('[test]');
-
-    logger.info('info msg');
-
-    expect(spy).toHaveBeenCalledWith('[test] [INFO]', 'info msg');
-    spy.mockRestore();
-  });
-
-  it('should log warn messages with prefix', () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const logger = new ConsoleLogger('[test]');
-
-    logger.warn('warning');
-
-    expect(spy).toHaveBeenCalledWith('[test] [WARN]', 'warning');
-    spy.mockRestore();
-  });
-
-  it('should log error messages with prefix', () => {
-    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const logger = new ConsoleLogger('[test]');
-
-    logger.error('error msg', new Error('boom'));
-
-    expect(spy).toHaveBeenCalledWith('[test] [ERROR]', 'error msg', expect.any(Error));
-    spy.mockRestore();
-  });
-
-  it('should use default prefix when none provided', () => {
-    const spy = vi.spyOn(console, 'info').mockImplementation(() => {});
-    const logger = new ConsoleLogger();
-
-    logger.info('test');
-
-    expect(spy).toHaveBeenCalledWith('[workflow] [INFO]', 'test');
-    spy.mockRestore();
-  });
-});
-
-describe('SilentLogger', () => {
-  it('should not throw on any log level', () => {
-    const logger = new SilentLogger();
-
-    expect(() => logger.debug('test')).not.toThrow();
-    expect(() => logger.info('test')).not.toThrow();
-    expect(() => logger.warn('test')).not.toThrow();
-    expect(() => logger.error('test')).not.toThrow();
-  });
-});
-
-describe('createScopedLogger', () => {
-  it('should prefix messages with run ID', () => {
-    const calls: string[] = [];
-    const baseLogger = {
-      debug: (msg: string) => calls.push(`debug:${msg}`),
-      info: (msg: string) => calls.push(`info:${msg}`),
-      warn: (msg: string) => calls.push(`warn:${msg}`),
-      error: (msg: string) => calls.push(`error:${msg}`),
-    };
-
-    const scoped = createScopedLogger(baseLogger, 'run-123');
-
-    scoped.debug('d');
-    scoped.info('i');
-    scoped.warn('w');
-    scoped.error('e');
-
-    expect(calls).toEqual([
-      'debug:[run:run-123] d',
-      'info:[run:run-123] i',
-      'warn:[run:run-123] w',
-      'error:[run:run-123] e',
-    ]);
-  });
-
-  it('should include step key when provided', () => {
-    const calls: string[] = [];
-    const baseLogger = {
-      debug: (msg: string) => calls.push(msg),
-      info: (msg: string) => calls.push(msg),
-      warn: (msg: string) => calls.push(msg),
-      error: (msg: string) => calls.push(msg),
-    };
-
-    const scoped = createScopedLogger(baseLogger, 'run-1', 'step-a');
-    scoped.info('hello');
-
-    expect(calls[0]).toBe('[run:run-1][step:step-a] hello');
-  });
-
-  it('should forward extra arguments', () => {
-    const captured: unknown[][] = [];
-    const baseLogger = {
-      debug: (...args: unknown[]) => captured.push(args),
-      info: (...args: unknown[]) => captured.push(args),
-      warn: (...args: unknown[]) => captured.push(args),
-      error: (...args: unknown[]) => captured.push(args),
-    };
-
-    const scoped = createScopedLogger(baseLogger, 'r1');
-    scoped.info('msg', { data: 1 }, 42);
-
-    expect(captured[0]).toEqual(['[run:r1] msg', { data: 1 }, 42]);
-  });
-});

package/src/utils/logger.ts

@@ -1,96 +0,0 @@
-/**
- * Logger utilities for the workflow engine.
- */
-
-import type { Logger, WorkflowError } from '../core/types';
-
-/** Log level for ConsoleLogger. Levels are ordered: debug < info < warn < error. */
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-};
-
-/**
- * Console-based logger implementation.
- * Uses console.log with prefixes for different levels.
- * Supports a configurable minimum log level (default: 'info').
- */
-export class ConsoleLogger implements Logger {
-  private prefix: string;
-  private minLevel: number;
-
-  constructor(prefix = '[workflow]', level: LogLevel = 'info') {
-    this.prefix = prefix;
-    this.minLevel = LOG_LEVEL_PRIORITY[level];
-  }
-
-  debug(message: string, ...args: unknown[]): void {
-    if (this.minLevel <= LOG_LEVEL_PRIORITY.debug) {
-      console.debug(`${this.prefix} [DEBUG]`, message, ...args);
-    }
-  }
-
-  info(message: string, ...args: unknown[]): void {
-    if (this.minLevel <= LOG_LEVEL_PRIORITY.info) {
-      console.info(`${this.prefix} [INFO]`, message, ...args);
-    }
-  }
-
-  warn(message: string, ...args: unknown[]): void {
-    if (this.minLevel <= LOG_LEVEL_PRIORITY.warn) {
-      console.warn(`${this.prefix} [WARN]`, message, ...args);
-    }
-  }
-
-  error(message: string, ...args: unknown[]): void {
-    if (this.minLevel <= LOG_LEVEL_PRIORITY.error) {
-      console.error(`${this.prefix} [ERROR]`, message, ...args);
-    }
-  }
-}
-
-/**
- * Silent logger that does nothing.
- * Useful for testing or when logs are not wanted.
- */
-export class SilentLogger implements Logger {
-  debug(): void {}
-  info(): void {}
-  warn(): void {}
-  error(): void {}
-}
-
-/**
- * Strip stack traces from a WorkflowError before persisting to storage.
- * Stack traces expose internal file paths and should be kept in logs only.
- */
-export function sanitizeErrorForStorage(error: WorkflowError): WorkflowError {
-  const { stack: _stack, ...rest } = error;
-  return rest;
-}
-
-/**
- * Create a scoped logger that includes run/step context.
- */
-export function createScopedLogger(
-  logger: Logger,
-  runId: string,
-  stepKey?: string
-): Logger {
-  const prefix = stepKey ? `[run:${runId}][step:${stepKey}]` : `[run:${runId}]`;
-
-  return {
-    debug: (message: string, ...args: unknown[]) =>
-      logger.debug(`${prefix} ${message}`, ...args),
-    info: (message: string, ...args: unknown[]) =>
-      logger.info(`${prefix} ${message}`, ...args),
-    warn: (message: string, ...args: unknown[]) =>
-      logger.warn(`${prefix} ${message}`, ...args),
-    error: (message: string, ...args: unknown[]) =>
-      logger.error(`${prefix} ${message}`, ...args),
-  };
-}

package/src/utils/postgres-deps.ts

@@ -1,63 +0,0 @@
-/**
- * Shared lazy-loader for PostgreSQL dependencies (kysely + pg).
- *
- * Both `PostgresStorageAdapter` and `PostgresSchedulePersistence` need the same
- * set of optional peer dependencies. This module loads them once and caches the
- * result so the logic isn't duplicated across files.
- */
-
-/**
- * Dynamic imports prevent static type resolution for these modules;
- * `any` is intentional here — callers cast to the appropriate Kysely/pg types.
- */
-export interface PostgresDeps {
-  Kysely: any;
-  PostgresDialect: any;
-  sql: any;
-  pgModule: any;
-}
-
-let cached: PostgresDeps | undefined;
-let loadingPromise: Promise<PostgresDeps> | undefined;
-
-/**
- * Lazily load and cache the PostgreSQL peer dependencies (kysely + pg).
- * @returns The cached `{Kysely, PostgresDialect, sql, pgModule}` object.
- * @throws {Error} If the `kysely` optional peer dependency is not installed.
- * @throws {Error} If the `pg` optional peer dependency is not installed.
- */
-export async function loadPostgresDeps(): Promise<PostgresDeps> {
-  if (cached) return cached;
-  if (loadingPromise) return loadingPromise;
-
-  loadingPromise = (async () => {
-    let Kysely: any;
-    let PostgresDialect: any;
-    let sql: any;
-    let pgModule: any;
-
-    try {
-      const kyselyMod = await import('kysely');
-      Kysely = kyselyMod.Kysely;
-      PostgresDialect = kyselyMod.PostgresDialect;
-      sql = kyselyMod.sql;
-    } catch {
-      throw new Error(
-        'PostgreSQL support requires the "kysely" package. Install it with: npm install kysely'
-      );
-    }
-    try {
-      const pg = await import('pg');
-      pgModule = pg.default ?? pg;
-    } catch {
-      throw new Error(
-        'PostgreSQL support requires the "pg" package. Install it with: npm install pg'
-      );
-    }
-
-    cached = { Kysely, PostgresDialect, sql, pgModule };
-    return cached;
-  })();
-
-  return loadingPromise;
-}

package/src/utils/retry.test.ts

@@ -1,177 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { sleep, withRetry, calculateRetryDelay, DEFAULT_RETRY_OPTIONS } from './retry';
-import { WorkflowCanceledError } from './errors';
-
-describe('sleep', () => {
-  it('should resolve after the given time', async () => {
-    const start = Date.now();
-    await sleep(50);
-    const elapsed = Date.now() - start;
-    expect(elapsed).toBeGreaterThanOrEqual(40);
-  });
-
-  it('should reject immediately if signal is already aborted', async () => {
-    const controller = new AbortController();
-    controller.abort();
-
-    await expect(sleep(1000, controller.signal)).rejects.toThrow(WorkflowCanceledError);
-  });
-
-  it('should reject when signal is aborted during sleep', async () => {
-    const controller = new AbortController();
-
-    const promise = sleep(5000, controller.signal);
-    setTimeout(() => controller.abort(), 20);
-
-    await expect(promise).rejects.toThrow(WorkflowCanceledError);
-  });
-});
-
-describe('calculateRetryDelay', () => {
-  it('should return base delay for first attempt', () => {
-    expect(calculateRetryDelay(1, 1000, 2)).toBe(1000);
-  });
-
-  it('should apply backoff multiplier', () => {
-    expect(calculateRetryDelay(2, 1000, 2)).toBe(2000);
-    expect(calculateRetryDelay(3, 1000, 2)).toBe(4000);
-  });
-
-  it('should work with non-integer backoff', () => {
-    expect(calculateRetryDelay(2, 100, 1.5)).toBe(150);
-  });
-});
-
-describe('DEFAULT_RETRY_OPTIONS', () => {
-  it('should have expected defaults', () => {
-    expect(DEFAULT_RETRY_OPTIONS.maxRetries).toBe(3);
-    expect(DEFAULT_RETRY_OPTIONS.delay).toBe(1000);
-    expect(DEFAULT_RETRY_OPTIONS.backoff).toBe(2);
-  });
-});
-
-describe('withRetry', () => {
-  it('should return result on first success', async () => {
-    const fn = vi.fn().mockResolvedValue('ok');
-    const result = await withRetry(fn, { maxRetries: 3, delay: 10, backoff: 1 });
-
-    expect(result).toBe('ok');
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should retry on failure and succeed', async () => {
-    let attempt = 0;
-    const fn = vi.fn(async () => {
-      attempt++;
-      if (attempt < 3) throw new Error(`fail ${attempt}`);
-      return 'success';
-    });
-
-    const result = await withRetry(fn, { maxRetries: 3, delay: 10, backoff: 1 });
-
-    expect(result).toBe('success');
-    expect(fn).toHaveBeenCalledTimes(3);
-  });
-
-  it('should throw after exhausting retries', async () => {
-    const fn = vi.fn().mockRejectedValue(new Error('always fails'));
-
-    await expect(
-      withRetry(fn, { maxRetries: 2, delay: 10, backoff: 1 })
-    ).rejects.toThrow('always fails');
-
-    // 1 initial + 2 retries = 3 calls
-    expect(fn).toHaveBeenCalledTimes(3);
-  });
-
-  it('should call onRetry callback', async () => {
-    let attempt = 0;
-    const onRetryCalls: Array<{ attempt: number; delay: number }> = [];
-
-    const fn = vi.fn(async () => {
-      attempt++;
-      if (attempt < 3) throw new Error('fail');
-      return 'ok';
-    });
-
-    await withRetry(fn, {
-      maxRetries: 3,
-      delay: 100,
-      backoff: 2,
-      onRetry: (a, _err, d) => onRetryCalls.push({ attempt: a, delay: d }),
-    });
-
-    expect(onRetryCalls).toHaveLength(2);
-    expect(onRetryCalls[0]).toEqual({ attempt: 1, delay: 100 });
-    expect(onRetryCalls[1]).toEqual({ attempt: 2, delay: 200 });
-  });
-
-  it('should respect abort signal before first attempt', async () => {
-    const controller = new AbortController();
-    controller.abort();
-
-    const fn = vi.fn().mockResolvedValue('ok');
-
-    await expect(
-      withRetry(fn, { maxRetries: 3, delay: 10, backoff: 1, signal: controller.signal })
-    ).rejects.toThrow('canceled');
-
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it('should respect abort signal during retry wait', async () => {
-    const controller = new AbortController();
-
-    const fn = vi.fn().mockRejectedValue(new Error('fail'));
-
-    const promise = withRetry(fn, {
-      maxRetries: 5,
-      delay: 5000,
-      backoff: 1,
-      signal: controller.signal,
-    });
-
-    // Abort during the retry delay
-    setTimeout(() => controller.abort(), 50);
-
-    await expect(promise).rejects.toThrow(WorkflowCanceledError);
-  });
-
-  it('should apply backoff between retries', async () => {
-    const timestamps: number[] = [];
-    let attempt = 0;
-
-    const fn = vi.fn(async () => {
-      timestamps.push(Date.now());
-      attempt++;
-      if (attempt <= 2) throw new Error('fail');
-      return 'ok';
-    });
-
-    await withRetry(fn, { maxRetries: 3, delay: 50, backoff: 2 });
-
-    // Check that delay increases between retries
-    const gap1 = timestamps[1] - timestamps[0];
-    const gap2 = timestamps[2] - timestamps[1];
-
-    expect(gap1).toBeGreaterThanOrEqual(40); // ~50ms first delay
-    expect(gap2).toBeGreaterThanOrEqual(80); // ~100ms second delay (50*2)
-  });
-
-  it('should convert non-Error throws to Error', async () => {
-    const fn = vi.fn(async () => {
-      throw 'string error';
-    });
-
-    await expect(
-      withRetry(fn, { maxRetries: 0, delay: 10, backoff: 1 })
-    ).rejects.toThrow('string error');
-  });
-
-  it('should use default options when none provided', async () => {
-    const fn = vi.fn().mockResolvedValue('ok');
-    const result = await withRetry(fn);
-
-    expect(result).toBe('ok');
-  });
-});

package/src/utils/retry.ts

@@ -1,121 +0,0 @@
-/**
- * Retry utilities for the workflow engine.
- */
-
-import { WorkflowCanceledError } from './errors';
-
-/**
- * Options for retry behavior.
- */
-export interface RetryOptions {
-  /** Maximum number of retry attempts (default: 3) */
-  maxRetries: number;
-  /** Initial delay between retries in ms (default: 1000) */
-  delay: number;
-  /** Backoff multiplier (default: 2) */
-  backoff: number;
-  /** Optional abort signal to cancel retries */
-  signal?: AbortSignal;
-  /** Optional callback before each retry */
-  onRetry?: (attempt: number, error: Error, nextDelay: number) => void;
-}
-
-/**
- * Default retry options.
- */
-export const DEFAULT_RETRY_OPTIONS: RetryOptions = {
-  maxRetries: 3,
-  delay: 1000,
-  backoff: 2,
-};
-
-/**
- * Sleep for a given number of milliseconds.
- * Can be canceled via AbortSignal.
- */
-export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new WorkflowCanceledError('run'));
-      return;
-    }
-
-    const cleanup = () => {
-      clearTimeout(timeoutId);
-      if (onAbort) signal?.removeEventListener('abort', onAbort);
-    };
-
-    let onAbort: (() => void) | undefined;
-
-    const timeoutId = setTimeout(() => {
-      cleanup();
-      resolve();
-    }, ms);
-
-    if (signal) {
-      onAbort = () => {
-        cleanup();
-        reject(new WorkflowCanceledError('run'));
-      };
-      signal.addEventListener('abort', onAbort, { once: true });
-    }
-  });
-}
-
-/**
- * Execute a function with retry logic.
- *
- * @param fn - The async function to execute
- * @param options - Retry configuration
- * @returns The result of the function
- * @throws The last error if all retries are exhausted
- */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  options: Partial<RetryOptions> = {}
-): Promise<T> {
-  const opts: RetryOptions = { ...DEFAULT_RETRY_OPTIONS, ...options };
-  let lastError: Error | undefined;
-  let currentDelay = opts.delay;
-
-  for (let attempt = 1; attempt <= opts.maxRetries + 1; attempt++) {
-    // Check if aborted before attempting
-    if (opts.signal?.aborted) {
-      throw new WorkflowCanceledError('run');
-    }
-
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-
-      // If this was the last attempt, throw
-      if (attempt > opts.maxRetries) {
-        throw lastError;
-      }
-
-      // Call onRetry callback if provided
-      opts.onRetry?.(attempt, lastError, currentDelay);
-
-      // Wait before next attempt
-      await sleep(currentDelay, opts.signal);
-
-      // Apply backoff multiplier
-      currentDelay = Math.round(currentDelay * opts.backoff);
-    }
-  }
-
-  // This should never be reached, but TypeScript needs it
-  throw lastError ?? new Error('Retry failed');
-}
-
-/**
- * Calculate the delay for a specific retry attempt.
- */
-export function calculateRetryDelay(
-  attempt: number,
-  baseDelay: number,
-  backoff: number
-): number {
-  return Math.round(baseDelay * Math.pow(backoff, attempt - 1));
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2022", "DOM"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}

package/tsup.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: {
-    index: 'src/index.ts',
-    'storage/index': 'src/storage/index.ts',
-    'events/index': 'src/events/index.ts',
-    'scheduler/index': 'src/scheduler/index.ts',
-  },
-  format: ['esm'],
-  dts: true,
-  clean: true,
-  sourcemap: true,
-});

package/vitest.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-});