pgflow 0.0.16 → 0.0.17-yolo

package/dist/commands/install/copy-migrations.d.ts

@@ -0,0 +1,4 @@
+export declare function copyMigrations({ supabasePath, }: {
+    supabasePath: string;
+}): Promise<boolean>;
+//# sourceMappingURL=copy-migrations.d.ts.map

package/dist/commands/install/copy-migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-migrations.d.ts","sourceRoot":"","sources":["../../../src/commands/install/copy-migrations.ts"],"names":[],"mappings":"AAaA,wBAAsB,cAAc,CAAC,EACnC,YAAY,GACb,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,OAAO,CAAC,CAmFnB"}

package/dist/commands/install/copy-migrations.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { log, confirm, note } from '@clack/prompts';
+import chalk from 'chalk';
+// Get the directory name in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Path to the pgflow migrations
+const sourcePath = path.resolve(__dirname, '../../../migrations');
+export async function copyMigrations({ supabasePath, }) {
+    const migrationsPath = path.join(supabasePath, 'migrations');
+    if (!fs.existsSync(migrationsPath)) {
+        fs.mkdirSync(migrationsPath);
+    }
+    // Check if pgflow migrations directory exists
+    if (!fs.existsSync(sourcePath)) {
+        log.error(`Source migrations directory not found at ${sourcePath}`);
+        log.info("This might happen if you're running from source instead of the built package.");
+        log.info('Try building the package first with: nx build cli');
+        return false;
+    }
+    const files = fs.readdirSync(sourcePath);
+    const filesToCopy = [];
+    const skippedFiles = [];
+    // Determine which files need to be copied
+    for (const file of files) {
+        const destination = path.join(migrationsPath, file);
+        if (fs.existsSync(destination)) {
+            skippedFiles.push(file);
+        }
+        else {
+            filesToCopy.push(file);
+        }
+    }
+    // If no files to copy, show message and return false (no changes made)
+    if (filesToCopy.length === 0) {
+        log.info('No new migrations to copy - all migrations are already in place');
+        return false;
+    }
+    // Prepare summary message with colored output
+    const summaryParts = [];
+    if (filesToCopy.length > 0) {
+        summaryParts.push(`${chalk.green('Files to be copied:')}
+${filesToCopy.map((file) => `${chalk.green('+')} ${file}`).join('\n')}`);
+    }
+    if (skippedFiles.length > 0) {
+        summaryParts.push(`${chalk.yellow('Files to be skipped (already exist):')}
+${skippedFiles.map((file) => `${chalk.yellow('=')} ${file}`).join('\n')}`);
+    }
+    // Show summary and ask for confirmation
+    note(summaryParts.join('\n\n'), 'Migration Summary');
+    const shouldContinue = await confirm({
+        message: `Do you want to proceed with copying ${filesToCopy.length} migration file${filesToCopy.length !== 1 ? 's' : ''}?`,
+    });
+    if (!shouldContinue) {
+        log.info('Migration copy cancelled');
+        return false;
+    }
+    log.info(`Copying migrations`);
+    // Copy the files
+    for (const file of filesToCopy) {
+        const source = path.join(sourcePath, file);
+        const destination = path.join(migrationsPath, file);
+        fs.copyFileSync(source, destination);
+        log.step(`Copied ${file}`);
+    }
+    log.success(`Successfully copied ${filesToCopy.length} migration file${filesToCopy.length !== 1 ? 's' : ''}`);
+    return true; // Return true to indicate migrations were copied
+}

package/dist/commands/install/index.d.ts

@@ -0,0 +1,4 @@
+import { type Command } from 'commander';
+declare const _default: (program: Command) => void;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/install/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/install/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;kCAMhB,OAAO;AAAhC,wBAsCE"}

package/dist/commands/install/index.js

@@ -0,0 +1,32 @@
+import { intro, isCancel, log } from '@clack/prompts';
+import { copyMigrations } from './copy-migrations.js';
+import { updateConfigToml } from './update-config-toml.js';
+import { supabasePathPrompt } from './supabase-path-prompt.js';
+export default (program) => {
+    program
+        .command('install')
+        .description('Copies migrations and sets config.toml values')
+        .action(async () => {
+        intro('pgflow - Postgres-native workflows for Supabase');
+        const supabasePath = await supabasePathPrompt();
+        if (isCancel(supabasePath)) {
+            log.error('Aborting installation');
+            return;
+        }
+        const migrationsCopied = await copyMigrations({ supabasePath });
+        const configUpdated = await updateConfigToml({ supabasePath });
+        if (migrationsCopied || configUpdated) {
+            log.success('pgflow installation is completed');
+        }
+        if (!migrationsCopied && !configUpdated) {
+            log.success('No changes were made - pgflow is already properly configured.');
+        }
+        // Show specific reminders based on what was actually done
+        if (configUpdated) {
+            log.warn('Remember to restart Supabase for the configuration changes to take effect!');
+        }
+        if (migrationsCopied) {
+            log.warn('Remember to apply the migrations!');
+        }
+    });
+};

package/dist/commands/install/supabase-path-prompt.d.ts

@@ -0,0 +1,2 @@
+export declare function supabasePathPrompt(): Promise<string | symbol>;
+//# sourceMappingURL=supabase-path-prompt.d.ts.map

package/dist/commands/install/supabase-path-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase-path-prompt.d.ts","sourceRoot":"","sources":["../../../src/commands/install/supabase-path-prompt.ts"],"names":[],"mappings":"AAIA,wBAAsB,kBAAkB,6BAMvC"}

package/dist/commands/install/supabase-path-prompt.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+import { text } from '@clack/prompts';
+export async function supabasePathPrompt() {
+    return await text({
+        message: 'Enter the path to your supabase/ directory',
+        placeholder: 'supabase/',
+        validate,
+    });
+}
+function validate(inputPath) {
+    const pathsToTest = [
+        [inputPath, 'is not a valid path'],
+        [path.join(inputPath, 'config.toml'), 'does not contain config.toml'],
+    ];
+    // if any of the pathsToTest fail, return the error message
+    for (const [testPath, errorMessage] of pathsToTest) {
+        if (!fs.existsSync(testPath)) {
+            return `${testPath} ${errorMessage}`;
+        }
+    }
+    // otherwise, return undefined
+    return undefined;
+}

package/dist/commands/install/update-config-toml.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Updates the config.toml file with necessary configurations for EdgeWorker
+ * while preserving comments and formatting
+ *
+ * Makes the following changes:
+ * 1. Enables the connection pooler
+ * 2. Ensures pool_mode is set to "transaction"
+ * 3. Changes edge_runtime policy from "oneshot" to "per_worker"
+ * 4. Creates a backup of the original config.toml file before making changes
+ *
+ * @param options.supabasePath - Path to the supabase directory
+ * @returns Promise<boolean> - True if changes were made, false otherwise
+ */
+export declare function updateConfigToml({ supabasePath, }: {
+    supabasePath: string;
+}): Promise<boolean>;
+//# sourceMappingURL=update-config-toml.d.ts.map

package/dist/commands/install/update-config-toml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-config-toml.d.ts","sourceRoot":"","sources":["../../../src/commands/install/update-config-toml.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,YAAY,GACb,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,OAAO,CAAC,CA2FnB"}

package/dist/commands/install/update-config-toml.js

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import path from 'path';
+import { log, confirm, note } from '@clack/prompts';
+import * as TOML from 'toml-patch';
+import chalk from 'chalk';
+/**
+ * Updates the config.toml file with necessary configurations for EdgeWorker
+ * while preserving comments and formatting
+ *
+ * Makes the following changes:
+ * 1. Enables the connection pooler
+ * 2. Ensures pool_mode is set to "transaction"
+ * 3. Changes edge_runtime policy from "oneshot" to "per_worker"
+ * 4. Creates a backup of the original config.toml file before making changes
+ *
+ * @param options.supabasePath - Path to the supabase directory
+ * @returns Promise<boolean> - True if changes were made, false otherwise
+ */
+export async function updateConfigToml({ supabasePath, }) {
+    const configPath = path.join(supabasePath, 'config.toml');
+    const backupPath = `${configPath}.backup`;
+    try {
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`config.toml not found at ${configPath}`);
+        }
+        const configContent = fs.readFileSync(configPath, 'utf8');
+        const config = TOML.parse(configContent);
+        const currentSettings = {
+            poolerEnabled: config.db?.pooler?.enabled ?? false,
+            poolMode: config.db?.pooler?.pool_mode ?? 'none',
+            edgeRuntimePolicy: config.edge_runtime?.policy ?? 'oneshot',
+        };
+        const needsChanges = currentSettings.poolerEnabled !== true ||
+            currentSettings.poolMode !== 'transaction' ||
+            currentSettings.edgeRuntimePolicy !== 'per_worker';
+        if (!needsChanges) {
+            log.info(`No changes needed in config.toml - all required settings are already configured`);
+            return false;
+        }
+        const changes = [];
+        if (currentSettings.poolerEnabled !== true) {
+            changes.push(`[db.pooler]
+${chalk.red(`- enabled = ${currentSettings.poolerEnabled}`)}
+${chalk.green('+ enabled = true')}`);
+        }
+        if (currentSettings.poolMode !== 'transaction') {
+            changes.push(`[db.pooler]
+${chalk.red(`- pool_mode = "${currentSettings.poolMode}"`)}
+${chalk.green('+ pool_mode = "transaction"')}`);
+        }
+        if (currentSettings.edgeRuntimePolicy !== 'per_worker') {
+            changes.push(`[edge_runtime]
+${chalk.red(`- policy = "${currentSettings.edgeRuntimePolicy}"`)}
+${chalk.green('+ policy = "per_worker"')}`);
+        }
+        note(changes.join('\n\n'), 'Config Changes');
+        const shouldContinue = await confirm({
+            message: `Do you want to proceed with these configuration changes? A backup will be created at ${backupPath}`,
+        });
+        if (!shouldContinue) {
+            log.info('Configuration update cancelled');
+            return false;
+        }
+        fs.copyFileSync(configPath, backupPath);
+        log.info(`Created backup at ${backupPath}`);
+        log.info(`Updating config.toml`);
+        const updatedConfig = { ...config };
+        // Ensure required objects exist and set values
+        if (!updatedConfig.db)
+            updatedConfig.db = {};
+        if (!updatedConfig.db.pooler)
+            updatedConfig.db.pooler = {};
+        if (!updatedConfig.edge_runtime)
+            updatedConfig.edge_runtime = {};
+        updatedConfig.db.pooler.enabled = true;
+        updatedConfig.db.pooler.pool_mode = 'transaction';
+        updatedConfig.edge_runtime.policy = 'per_worker';
+        const updatedContent = TOML.patch(configContent, updatedConfig);
+        fs.writeFileSync(configPath, updatedContent);
+        log.success(`Successfully updated ${configPath} (backup created at ${backupPath})`);
+        return true;
+    }
+    catch (error) {
+        log.error(`Failed to update ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { fileURLToPath } from 'url';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import installCommand from './commands/install/index.js';
+// Create a function to handle errors
+const errorHandler = (error) => {
+    console.error('Error:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+};
+// Set up process-wide unhandled rejection handler
+process.on('unhandledRejection', errorHandler);
+// Function to get version from package.json
+function getVersion() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageJsonPath = join(__dirname, '..', 'package.json');
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return packageJson.version || 'unknown';
+    }
+    catch (error) {
+        // Log error but don't display it to the user when showing version
+        console.error('Error reading package.json:', error);
+        return 'unknown';
+    }
+}
+const program = new Command();
+program
+    .name('npx pgflow')
+    .description('Command line interface to help you work with pgflow')
+    .version(getVersion())
+    .exitOverride((err) => {
+    // Don't treat version display as an error
+    if (err.code === 'commander.version') {
+        process.exit(0);
+    }
+    throw err;
+});
+installCommand(program);
+// Use a promise-aware approach to parse arguments
+async function main() {
+    try {
+        await program.parseAsync(process.argv);
+        // If we get here with no command specified, it's not an error
+        process.exitCode = 0;
+    }
+    catch (err) {
+        // Commander throws a CommanderError when help or version is displayed
+        // We want to exit with code 0 in these cases
+        if (err &&
+            typeof err === 'object' &&
+            'code' in err &&
+            (err.code === 'commander.helpDisplayed' ||
+                err.code === 'commander.help' ||
+                err.code === 'commander.version')) {
+            process.exitCode = 0;
+        }
+        else {
+            // For other errors, use our error handler
+            errorHandler(err);
+        }
+    }
+}
+// Execute and handle any errors
+main();

package/dist/migrations/000000_schema.sql

@@ -0,0 +1,150 @@
+create extension if not exists pgmq version '1.4.4';
+
+create schema if not exists pgflow;
+set search_path to pgflow;
+
+--------------------------------------------------------------------------
+------------------ TODO: fix me, UNSECURE --------------------------------
+--------------------------------------------------------------------------
+grant usage on schema pgflow to anon, authenticated, service_role;
+grant all on all tables in schema pgflow to anon, authenticated, service_role;
+grant all on all routines in schema pgflow to anon, authenticated, service_role;
+grant all on all sequences in schema pgflow to anon,
+authenticated,
+service_role;
+alter default privileges for role postgres in schema pgflow
+grant all on tables to anon, authenticated, service_role;
+alter default privileges for role postgres in schema pgflow
+grant all on routines to anon, authenticated, service_role;
+alter default privileges for role postgres in schema pgflow
+grant all on sequences to anon, authenticated, service_role;
+
+------------------------------------------
+-- Core flow definition tables
+------------------------------------------
+
+----- check constraint helper function -------
+create or replace function pgflow.is_valid_slug(
+  slug text
+)
+returns boolean
+language plpgsql
+immutable
+as $$
+begin
+    return
+      slug is not null
+      and slug <> ''
+      and length(slug) <= 128
+      and slug ~ '^[a-zA-Z_][a-zA-Z0-9_]*$'
+      and slug NOT IN ('run'); -- reserved words
+end;
+$$;
+
+-- Flows table - stores flow definitions
+create table pgflow.flows (
+  flow_slug text primary key not null,  -- Unique identifier for the flow
+  opt_max_attempts int not null default 3,
+  opt_base_delay int not null default 1,
+  opt_timeout int not null default 60,
+  constraint slug_is_valid check (is_valid_slug(flow_slug)),
+  constraint opt_max_attempts_is_nonnegative check (opt_max_attempts >= 0),
+  constraint opt_base_delay_is_nonnegative check (opt_base_delay >= 0),
+  constraint opt_timeout_is_positive check (opt_timeout > 0)
+);
+
+-- Steps table - stores individual steps within flows
+create table pgflow.steps (
+  flow_slug text not null references flows (flow_slug),
+  step_slug text not null,
+  step_type text not null default 'single',
+  deps_count int not null default 0 check (deps_count >= 0),
+  opt_max_attempts int,
+  opt_base_delay int,
+  opt_timeout int,
+  primary key (flow_slug, step_slug),
+  check (is_valid_slug(step_slug)),
+  check (step_type in ('single')),
+  constraint opt_max_attempts_is_nonnegative check (opt_max_attempts is null or opt_max_attempts >= 0),
+  constraint opt_base_delay_is_nonnegative check (opt_base_delay is null or opt_base_delay >= 0),
+  constraint opt_timeout_is_positive check (opt_timeout is null or opt_timeout > 0)
+);
+
+-- Dependencies table - stores relationships between steps
+create table pgflow.deps (
+  flow_slug text not null references pgflow.flows (flow_slug),
+  dep_slug text not null, -- slug of the dependency
+  step_slug text not null, -- slug of the dependent
+  primary key (flow_slug, dep_slug, step_slug),
+  foreign key (flow_slug, dep_slug)
+  references pgflow.steps (flow_slug, step_slug),
+  foreign key (flow_slug, step_slug)
+  references pgflow.steps (flow_slug, step_slug),
+  check (dep_slug != step_slug)  -- Prevent self-dependencies
+);
+
+------------------------------------------
+-- Runtime State Tables
+------------------------------------------
+
+-- Runs table - tracks flow execution instances
+create table pgflow.runs (
+  run_id uuid primary key not null default gen_random_uuid(),
+  flow_slug text not null references pgflow.flows (flow_slug), -- denormalized
+  status text not null default 'started',
+  input jsonb not null,
+  output jsonb,
+  remaining_steps int not null default 0 check (remaining_steps >= 0),
+  check (status in ('started', 'failed', 'completed'))
+);
+
+-- Step states table - tracks the state of individual steps within a run
+create table pgflow.step_states (
+  flow_slug text not null references pgflow.flows (flow_slug),
+  run_id uuid not null references pgflow.runs (run_id),
+  step_slug text not null,
+  status text not null default 'created',
+  remaining_tasks int not null default 1 check (remaining_tasks >= 0),
+  remaining_deps int not null default 0 check (remaining_deps >= 0),
+  primary key (run_id, step_slug),
+  foreign key (flow_slug, step_slug)
+  references pgflow.steps (flow_slug, step_slug),
+  check (status in ('created', 'started', 'completed', 'failed')),
+  check (status != 'completed' or remaining_tasks = 0)
+);
+
+-- Step tasks table - tracks units of work for step
+create table pgflow.step_tasks (
+  flow_slug text not null references pgflow.flows (flow_slug),
+  run_id uuid not null references pgflow.runs (run_id),
+  step_slug text not null,
+  message_id bigint,
+  task_index int not null default 0,
+  status text not null default 'queued',
+  attempts_count int not null default 0,
+  error_message text,
+  output jsonb,
+  constraint step_tasks_pkey primary key (run_id, step_slug, task_index),
+  foreign key (run_id, step_slug)
+  references pgflow.step_states (run_id, step_slug),
+  constraint valid_status check (
+    status in ('queued', 'completed', 'failed')
+  ),
+  constraint output_valid_only_for_completed check (
+    output is null or status = 'completed'
+  ),
+  constraint only_single_task_per_step check (task_index = 0),
+  constraint attempts_count_nonnegative check (attempts_count >= 0)
+);
+
+------------------------------------------
+-- Types
+------------------------------------------
+
+create type pgflow.step_task_record as (
+  flow_slug text,
+  run_id uuid,
+  step_slug text,
+  input jsonb,
+  msg_id bigint
+);

package/dist/migrations/000005_create_flow.sql

@@ -0,0 +1,29 @@
+create or replace function pgflow.create_flow(
+  flow_slug text,
+  max_attempts int default 3,
+  base_delay int default 5,
+  timeout int default 60
+)
+returns pgflow.flows
+language sql
+set search_path to ''
+volatile
+as $$
+WITH
+  flow_upsert AS (
+    INSERT INTO pgflow.flows (flow_slug, opt_max_attempts, opt_base_delay, opt_timeout)
+    VALUES (flow_slug, max_attempts, base_delay, timeout)
+    ON CONFLICT (flow_slug) DO UPDATE
+    SET flow_slug = pgflow.flows.flow_slug -- Dummy update
+    RETURNING *
+  ),
+  ensure_queue AS (
+    SELECT pgmq.create(flow_slug)
+    WHERE NOT EXISTS (
+      SELECT 1 FROM pgmq.list_queues() WHERE queue_name = flow_slug
+    )
+  )
+SELECT f.*
+FROM flow_upsert f
+LEFT JOIN (SELECT 1 FROM ensure_queue) _dummy ON true; -- Left join ensures flow is returned
+$$;

package/dist/migrations/000010_add_step.sql

@@ -0,0 +1,48 @@
+create or replace function pgflow.add_step(
+  flow_slug text,
+  step_slug text,
+  deps_slugs text [],
+  max_attempts int default null,
+  base_delay int default null,
+  timeout int default null
+)
+returns pgflow.steps
+language sql
+set search_path to ''
+volatile
+as $$
+WITH
+  create_step AS (
+    INSERT INTO pgflow.steps (flow_slug, step_slug, deps_count, opt_max_attempts, opt_base_delay, opt_timeout)
+    VALUES (flow_slug, step_slug, COALESCE(array_length(deps_slugs, 1), 0), max_attempts, base_delay, timeout)
+    ON CONFLICT (flow_slug, step_slug)
+    DO UPDATE SET step_slug = pgflow.steps.step_slug
+    RETURNING *
+  ),
+  insert_deps AS (
+    INSERT INTO pgflow.deps (flow_slug, dep_slug, step_slug)
+    SELECT add_step.flow_slug, d.dep_slug, add_step.step_slug
+    FROM unnest(deps_slugs) AS d(dep_slug)
+    ON CONFLICT (flow_slug, dep_slug, step_slug) DO NOTHING
+    RETURNING 1
+  )
+-- Return the created step
+SELECT * FROM create_step;
+$$;
+
+-- New overloaded function without deps_slugs parameter
+create or replace function pgflow.add_step(
+  flow_slug text,
+  step_slug text,
+  max_attempts int default null,
+  base_delay int default null,
+  timeout int default null
+)
+returns pgflow.steps
+language sql
+set search_path to ''
+volatile
+as $$
+    -- Call the original function with an empty array
+    SELECT * FROM pgflow.add_step(flow_slug, step_slug, ARRAY[]::text[], max_attempts, base_delay, timeout);
+$$;

package/dist/migrations/000015_start_ready_steps.sql

@@ -0,0 +1,45 @@
+create or replace function pgflow.start_ready_steps(run_id uuid)
+returns void
+language sql
+set search_path to ''
+as $$
+
+WITH ready_steps AS (
+  SELECT *
+  FROM pgflow.step_states AS step_state
+  WHERE step_state.run_id = start_ready_steps.run_id
+    AND step_state.status = 'created'
+    AND step_state.remaining_deps = 0
+  ORDER BY step_state.step_slug
+  FOR UPDATE
+),
+started_step_states AS (
+  UPDATE pgflow.step_states
+  SET status = 'started'
+  FROM ready_steps
+  WHERE pgflow.step_states.run_id = start_ready_steps.run_id
+    AND pgflow.step_states.step_slug = ready_steps.step_slug
+  RETURNING pgflow.step_states.*
+),
+sent_messages AS (
+  SELECT
+    started_step.flow_slug,
+    started_step.run_id,
+    started_step.step_slug,
+    pgmq.send(started_step.flow_slug, jsonb_build_object(
+      'flow_slug', started_step.flow_slug,
+      'run_id', started_step.run_id,
+      'step_slug', started_step.step_slug,
+      'task_index', 0
+    )) AS msg_id
+  FROM started_step_states AS started_step
+)
+INSERT INTO pgflow.step_tasks (flow_slug, run_id, step_slug, message_id)
+SELECT
+  sent_messages.flow_slug,
+  sent_messages.run_id,
+  sent_messages.step_slug,
+  sent_messages.msg_id
+FROM sent_messages;
+
+$$;

package/dist/migrations/000020_start_flow.sql

@@ -0,0 +1,46 @@
+-- drop function if exists pgflow.start_flow;
+create or replace function pgflow.start_flow(
+  flow_slug TEXT,
+  input JSONB
+)
+returns setof PGFLOW.RUNS
+language plpgsql
+set search_path to ''
+volatile
+as $$
+declare
+  v_created_run pgflow.runs%ROWTYPE;
+begin
+
+WITH
+  flow_steps AS (
+    SELECT steps.flow_slug, steps.step_slug, steps.deps_count
+    FROM pgflow.steps
+    WHERE steps.flow_slug = start_flow.flow_slug
+  ),
+  created_run AS (
+    INSERT INTO pgflow.runs (flow_slug, input, remaining_steps)
+    VALUES (
+      start_flow.flow_slug,
+      start_flow.input,
+      (SELECT count(*) FROM flow_steps)
+    )
+    RETURNING *
+  ),
+  created_step_states AS (
+    INSERT INTO pgflow.step_states (flow_slug, run_id, step_slug, remaining_deps)
+    SELECT
+      fs.flow_slug,
+      (SELECT run_id FROM created_run),
+      fs.step_slug,
+      fs.deps_count
+    FROM flow_steps fs
+  )
+SELECT * FROM created_run INTO v_created_run;
+
+PERFORM pgflow.start_ready_steps(v_created_run.run_id);
+
+RETURN QUERY SELECT * FROM pgflow.runs where run_id = v_created_run.run_id;
+
+end;
+$$;