@cascade-flow/backend-postgres 0.1.0

package/README.md

@@ -0,0 +1,446 @@
+# Backend Postgres
+
+PostgreSQL-based implementation of the Backend interface for the workflow orchestrator.
+
+## Features
+
+- **Event Sourcing**: Immutable append-only event storage in PostgreSQL
+- **Automatic Schema Initialization**: Idempotent migrations run automatically on first connection
+- **Race-Safe Step Claiming**: Atomic step claiming using `SELECT FOR UPDATE SKIP LOCKED`
+- **Events-as-Queue Pattern**: Queue state derived from events (no separate queue table)
+- **JSONB Storage**: Flexible schema evolution with JSONB columns
+- **Full TypeScript Support**: Complete type safety across all operations
+- **Easy Database Migration**: All `pg` usage isolated in `db.ts` for easy library swapping
+
+## Installation
+
+```bash
+bun add backend-postgres pg
+bun add -d @types/pg
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { PostgresBackend } from "backend-postgres";
+
+// Create backend with connection string
+const backend = new PostgresBackend("postgres://user:password@localhost:5432/workflow_db");
+
+// The database schema is automatically initialized on first use
+// No manual migration commands needed!
+
+// Use with the runner
+import { runAll } from "runner";
+const result = await runAll(workflow, input, { backend });
+
+// Don't forget to close the connection pool when done
+await backend.close();
+```
+
+### With CLI
+
+You can use the Postgres backend with the CLI by setting the `POSTGRES_URL` environment variable:
+
+```bash
+# Set the Postgres connection string
+export POSTGRES_URL="postgres://user:password@localhost:5432/workflow_db"
+
+# Run workflows
+wfo run my-workflow --input '{"key": "value"}'
+
+# Queue-based execution
+wfo worker start  # Uses Postgres backend
+wfo submit my-workflow --input '{...}'
+```
+
+### Programmatic Usage
+
+```typescript
+import { PostgresBackend } from "backend-postgres";
+import { Client } from "client";
+
+const backend = new PostgresBackend(process.env.POSTGRES_URL!);
+const client = new Client({ backend });
+
+// Submit a workflow run
+const runId = await client.submit({
+  workflowSlug: "my-workflow",
+  input: { message: "Hello" },
+  tags: ["production"],
+  idempotencyKey: "unique-key-123", // Optional deduplication
+});
+
+// Wait for completion
+const result = await client.waitForCompletion(runId);
+console.log("Output:", result.output);
+
+// Cleanup
+await backend.close();
+```
+
+## Connection String Format
+
+The connection string follows the standard PostgreSQL format:
+
+```
+postgres://[user[:password]@][host][:port][/database][?option=value]
+```
+
+Examples:
+
+```bash
+# Local development
+postgres://postgres:postgres@localhost:5432/workflow_dev
+
+# With SSL
+postgres://user:pass@db.example.com:5432/workflows?sslmode=require
+
+# Unix socket
+postgres://user@/dbname?host=/var/run/postgresql
+
+# Cloud providers (example: Neon, Supabase, etc.)
+postgres://user:password@ep-xyz.region.provider.com/dbname?sslmode=require
+```
+
+## Database Schema
+
+The backend creates and manages the following tables:
+
+### Event Tables
+
+**`workflow_events`** - Workflow-level events
+- `id` (serial) - Primary key
+- `event_id` (text) - Microsecond timestamp string
+- `workflow_slug` (text) - Workflow identifier
+- `run_id` (text) - Run identifier
+- `timestamp_us` (bigint) - Event timestamp in microseconds
+- `category` (text) - Always 'workflow'
+- `type` (text) - Event type (WorkflowStarted, WorkflowCompleted, etc.)
+- `data` (jsonb) - Full event payload
+
+**`step_events`** - Step-level events
+- `id` (serial) - Primary key
+- `event_id` (text) - Microsecond timestamp string
+- `workflow_slug` (text) - Workflow identifier
+- `run_id` (text) - Run identifier
+- `step_id` (text) - Step identifier
+- `timestamp_us` (bigint) - Event timestamp in microseconds
+- `category` (text) - Always 'step'
+- `type` (text) - Event type (StepScheduled, StepStarted, etc.)
+- `data` (jsonb) - Full event payload
+
+### Registry Tables
+
+**`workflow_metadata`** - Workflow registry
+- `slug` (text) - Primary key
+- `name` (text) - Display name
+- `description` (text) - Optional description
+- `input_schema_json` (jsonb) - JSON Schema for input validation
+- `tags` (text[]) - Tags array
+
+**`step_definitions`** - Step definitions
+- `workflow_slug` (text) - References workflow_metadata(slug)
+- `id` (text) - Step identifier
+- `dependencies` (jsonb) - Step dependencies
+- `export_output` (boolean) - Whether output is exported
+- `input_schema_json` (jsonb) - JSON Schema for step input
+- `timeout_ms` (integer) - Step timeout
+- `max_retries` (integer) - Maximum retry attempts
+- `retry_delay_ms` (integer) - Delay between retries
+
+### Supporting Tables
+
+**`step_outputs`** - Serialized step outputs
+- `workflow_slug`, `run_id`, `step_id`, `attempt_number` - Composite primary key
+- `output` (jsonb) - Step output data
+
+**`idempotency_keys`** - Deduplication
+- `hash` (text) - Primary key (SHA256 of idempotency key)
+- `run_id` (text) - Associated run ID
+
+## Migration Strategy
+
+The backend uses **idempotent migrations** that are safe to rerun. Migrations are automatically executed on the first database connection.
+
+### Current Migrations
+
+1. **Migration 001**: Create tables - Uses `CREATE TABLE IF NOT EXISTS`
+2. **Migration 002**: Create indexes - Uses `CREATE INDEX IF NOT EXISTS`
+
+### Adding New Migrations
+
+To add a new migration:
+
+1. Add a new migration function to `src/migrations.ts`:
+
+```typescript
+async function migration003_addNewFeature(pool: Pool): Promise<void> {
+  const client = await pool.connect();
+  try {
+    // Your migration code here (must be idempotent!)
+    await client.query(`
+      ALTER TABLE workflow_metadata
+      ADD COLUMN IF NOT EXISTS new_field TEXT
+    `);
+
+    console.log("[Migration 003] Added new feature");
+  } catch (error) {
+    console.error("[Migration 003] Error:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+```
+
+2. Add it to the `runMigrations()` function:
+
+```typescript
+export async function runMigrations(pool: Pool): Promise<void> {
+  await migration001_createTables(pool);
+  await migration002_createIndexes(pool);
+  await migration003_addNewFeature(pool);  // Add here
+}
+```
+
+### Idempotency Best Practices
+
+All migrations must be idempotent (safe to run multiple times):
+
+✅ **Good** (idempotent):
+```sql
+CREATE TABLE IF NOT EXISTS my_table (...);
+CREATE INDEX IF NOT EXISTS idx_name ON table (column);
+ALTER TABLE table ADD COLUMN IF NOT EXISTS new_col TEXT;
+```
+
+❌ **Bad** (not idempotent):
+```sql
+CREATE TABLE my_table (...);  -- Fails if table exists
+ALTER TABLE table ADD COLUMN new_col TEXT;  -- Fails if column exists
+```
+
+## Architecture Details
+
+### Event Sourcing
+
+All state changes are stored as immutable events:
+
+```typescript
+// Events are never updated or deleted
+await backend.appendEvent(workflowSlug, runId, {
+  category: "step",
+  type: "StepStarted",
+  eventId: "1234567890123456",
+  timestampUs: 1234567890123456,
+  stepId: "my-step",
+  workerId: "worker-1",
+  // ... other event-specific fields
+});
+
+// Current state is computed by projecting events
+const events = await backend.loadEvents(workflowSlug, runId);
+const currentState = projectRunStateFromEvents(events, workflowSlug);
+```
+
+### Events-as-Queue Pattern
+
+There is no separate "queue" table. Queue state is derived by projecting the `RunSubmitted` event along with workflow events:
+
+```typescript
+// Submitting creates a RunSubmitted event
+const runId = await backend.submitRun({
+  workflowSlug: "my-workflow",
+  input: { data: "..." },
+});
+
+// Listing runs projects events to compute status
+const runs = await backend.listRuns({
+  statuses: ["pending", "running"],
+});
+```
+
+### Atomic Step Claiming
+
+Step claiming uses PostgreSQL's `SELECT FOR UPDATE SKIP LOCKED` for race-safe concurrency:
+
+```typescript
+// Multiple workers can safely claim different steps
+const claimed = await backend.claimScheduledStep(
+  workflowSlug,
+  runId,
+  stepId,
+  "worker-1"
+);
+
+// Only one worker succeeds per step
+console.log(claimed); // true or false
+```
+
+Implementation (simplified):
+
+```sql
+BEGIN;
+
+-- Acquire lock (SKIP LOCKED prevents blocking)
+SELECT * FROM step_events
+WHERE workflow_slug = $1 AND run_id = $2 AND step_id = $3
+ORDER BY timestamp_us DESC
+LIMIT 1
+FOR UPDATE SKIP LOCKED;
+
+-- Verify step is in scheduled state
+-- Write StepStarted event
+
+COMMIT;
+```
+
+### Time Precision
+
+All timestamps use **microsecond precision** (`timestampUs` fields) for correct event ordering in concurrent execution:
+
+```typescript
+// Example: 1762916097401523 (microseconds since epoch)
+const timestamp = getMicrosecondTimestamp();
+```
+
+## Testing
+
+### Integration Tests
+
+Integration tests require a running PostgreSQL database:
+
+```bash
+# Set test database URL
+export POSTGRES_TEST_URL="postgres://postgres:postgres@localhost:5432/workflow_test"
+
+# Run tests
+bun test
+
+# Run specific test file
+bun test tests/integration/postgres-backend.integration.test.ts
+```
+
+### Docker PostgreSQL for Testing
+
+```bash
+# Start PostgreSQL in Docker
+docker run -d \
+  --name postgres-test \
+  -e POSTGRES_PASSWORD=postgres \
+  -e POSTGRES_DB=workflow_test \
+  -p 5432:5432 \
+  postgres:16
+
+# Run tests
+export POSTGRES_TEST_URL="postgres://postgres:postgres@localhost:5432/workflow_test"
+bun test
+
+# Cleanup
+docker stop postgres-test
+docker rm postgres-test
+```
+
+## Performance Considerations
+
+### Indexes
+
+The backend creates indexes optimized for common query patterns:
+
+- Event lookups: `(workflow_slug, run_id, timestamp_us)`
+- Step claiming: `(workflow_slug, run_id, step_id, type, timestamp_us)`
+- Registry queries: `(workflow_slug)`
+
+### Connection Pooling
+
+The backend uses `pg.Pool` for efficient connection management. Configure pool size via connection string:
+
+```
+postgres://user:pass@host/db?max=20&min=5&idle_timeout=10000
+```
+
+### JSONB Storage
+
+JSONB columns allow flexible schema evolution but have storage/query trade-offs:
+
+- ✅ Flexible schema changes without migrations
+- ✅ Can index specific JSONB fields if needed
+- ⚠️ Slightly larger storage than normalized tables
+- ⚠️ Complex queries on nested JSONB can be slower
+
+For high-volume production use, consider adding indexes on frequently-queried JSONB fields:
+
+```sql
+CREATE INDEX idx_event_type ON workflow_events ((data->>'type'));
+```
+
+## Switching Database Libraries
+
+All `pg` usage is isolated in `src/db.ts`, making it easy to swap to another library:
+
+1. Install new library (e.g., `postgres`, `kysely`, `drizzle`)
+2. Update `src/db.ts` to use new library's API
+3. Keep function signatures the same
+4. Update `src/migrations.ts` if needed
+
+The `PostgresBackend` class in `src/index.ts` doesn't need changes.
+
+## Comparison to FileSystemBackend
+
+| Feature | FileSystemBackend | PostgresBackend |
+|---------|------------------|-----------------|
+| Storage | Local filesystem | PostgreSQL database |
+| Concurrency | File locks | Database transactions |
+| Scalability | Single machine | Multi-machine clusters |
+| Persistence | Local `.runs/` directory | Remote database |
+| Setup | Zero config | Requires PostgreSQL server |
+| Best for | Development, single-machine | Production, distributed workers |
+
+## Troubleshooting
+
+### Connection Issues
+
+```typescript
+// Error: connection refused
+// Fix: Check PostgreSQL is running and connection string is correct
+
+// Error: authentication failed
+// Fix: Verify username/password in connection string
+
+// Error: database does not exist
+// Fix: Create database first: createdb workflow_db
+```
+
+### Migration Failures
+
+```typescript
+// Error: relation already exists
+// Fix: Ensure migrations use IF NOT EXISTS
+
+// Error: permission denied
+// Fix: Grant required permissions to database user
+```
+
+### Performance Issues
+
+```bash
+# Check for missing indexes
+EXPLAIN ANALYZE SELECT ...;
+
+# Monitor connection pool
+SELECT * FROM pg_stat_activity WHERE datname = 'workflow_db';
+
+# Check table sizes
+SELECT pg_size_pretty(pg_total_relation_size('step_events'));
+```
+
+## See Also
+
+- [Main CLAUDE.md](../../CLAUDE.md) - Backend architecture overview
+- [Backend Interface](../backend-interface/README.md) - Abstract backend contract
+- [Backend Filesystem](../backend-filesystem/README.md) - Filesystem implementation
+- [Worker README](../worker/README.md) - Distributed worker architecture
+- [Client README](../client/README.md) - Programmatic API usage

package/dist/db.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Database layer - isolates all pg usage and SQL queries
+ * This makes it easy to swap to a different Postgres library in the future
+ */
+import pg from "pg";
+import type { Event, StepEvent, WorkflowMetadata, StepDefinition } from "@cascade-flow/backend-interface";
+export type { Pool } from "pg";
+/**
+ * Create a connection pool from a connection string
+ */
+export declare function createPool(connectionString: string): pg.Pool;
+/**
+ * Generic event append - handles both workflow and step events
+ * Extracts normalized fields from events for efficient querying
+ */
+export declare function appendEvent(pool: pg.Pool, table: "workflow_events" | "step_events", event: Event): Promise<void>;
+/**
+ * Append event using an existing client (for transactions)
+ * Same as appendEvent but doesn't manage the client connection
+ */
+export declare function appendEventWithClient(client: pg.PoolClient, table: "workflow_events" | "step_events", event: Event): Promise<void>;
+/**
+ * Load events with optional filtering
+ */
+export declare function loadEvents(pool: pg.Pool, table: "workflow_events" | "step_events", filters: {
+    workflowSlug?: string;
+    runId?: string;
+    stepId?: string;
+    category?: "workflow" | "step";
+    types?: string[];
+}): Promise<Event[]>;
+/**
+ * Load all events for a specific run (both workflow and step events)
+ */
+export declare function loadAllRunEvents(pool: pg.Pool, workflowSlug: string, runId: string): Promise<Event[]>;
+/**
+ * Atomic step claiming using SELECT FOR UPDATE SKIP LOCKED
+ * Returns true if claim succeeded, false if already claimed
+ */
+export declare function claimScheduledStep(pool: pg.Pool, workflowSlug: string, runId: string, stepId: string, workerId: string, eventToWrite: StepEvent): Promise<boolean>;
+/**
+ * Get all scheduled steps across workflows
+ * Filters by available_at_us for delayed scheduling support
+ */
+export declare function listScheduledSteps(pool: pg.Pool, options?: {
+    workflowSlugs?: string[];
+    limit?: number;
+}): Promise<Array<{
+    workflowSlug: string;
+    runId: string;
+    stepId: string;
+}>>;
+/**
+ * Find stale steps (last heartbeat older than threshold)
+ * Uses normalized worker_id column for efficient querying
+ */
+export declare function findStaleSteps(pool: pg.Pool, staleThresholdUs: number): Promise<Array<{
+    workflowSlug: string;
+    runId: string;
+    stepId: string;
+    workerId: string;
+}>>;
+/**
+ * Save step output
+ */
+export declare function saveStepOutput(pool: pg.Pool, workflowSlug: string, runId: string, stepId: string, attemptNumber: number, output: any): Promise<void>;
+/**
+ * Load step output
+ */
+export declare function loadStepOutput(pool: pg.Pool, workflowSlug: string, runId: string, stepId: string, attemptNumber: number): Promise<any | null>;
+/**
+ * Register workflow metadata (upsert)
+ */
+export declare function upsertWorkflowMetadata(pool: pg.Pool, slug: string, name: string, location: string | undefined, inputSchemaJSON: any | undefined): Promise<void>;
+/**
+ * Register step definition (upsert)
+ */
+export declare function upsertStepDefinition(pool: pg.Pool, workflowSlug: string, step: StepDefinition): Promise<void>;
+/**
+ * Get workflow metadata by slug
+ */
+export declare function getWorkflowMetadata(pool: pg.Pool, slug: string): Promise<WorkflowMetadata | null>;
+/**
+ * List all workflow metadata
+ */
+export declare function listWorkflowMetadata(pool: pg.Pool): Promise<WorkflowMetadata[]>;
+/**
+ * Get step definitions for a workflow
+ */
+export declare function getWorkflowSteps(pool: pg.Pool, workflowSlug: string): Promise<StepDefinition[]>;
+/**
+ * Save idempotency key (returns existing runId if key already exists)
+ */
+export declare function saveIdempotencyKey(pool: pg.Pool, hash: string, runId: string): Promise<string>;
+/**
+ * Get all distinct run IDs for a workflow
+ */
+export declare function listRunIds(pool: pg.Pool, workflowSlug: string): Promise<string[]>;
+/**
+ * Get all workflows that have active (incomplete) runs
+ */
+export declare function listActiveWorkflows(pool: pg.Pool): Promise<string[]>;
+/**
+ * Check if a run exists
+ */
+export declare function runExists(pool: pg.Pool, workflowSlug: string, runId: string): Promise<boolean>;
+//# sourceMappingURL=db.d.ts.map

package/dist/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"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"}