pgflow 0.0.0-test-snapshot-releases2-8d5d9bc1-20250922101158 → 0.0.0-update-supabase-868977e5-20251119071204

package/README.md

@@ -1,4 +1,4 @@
-# @pgflow/cli
+# pgflow CLI
 
 The Command Line Interface for pgflow - a PostgreSQL-native workflow engine.
 
@@ -7,7 +7,7 @@ The Command Line Interface for pgflow - a PostgreSQL-native workflow engine.
 
 ## Overview
 
-`@pgflow/cli` provides essential tools for setting up, managing, and deploying pgflow workflows in your Supabase environment. The CLI handles:
+This package provides essential tools for setting up, managing, and deploying pgflow workflows in your Supabase environment. The CLI handles:
 
 - Installing pgflow in your Supabase project
 - Compiling TypeScript workflow definitions into SQL migrations
@@ -15,8 +15,8 @@ The Command Line Interface for pgflow - a PostgreSQL-native workflow engine.
 
 ## Prerequisites
 
-- Supabase CLI v2.0.2 or higher
-- Deno v1.45.x or higher (for flow compilation)
+- Supabase CLI v2.34.3 or higher
+- Deno v2.1.x or higher (for flow compilation)
 - Local Supabase project initialized
 
 ## Installation
@@ -70,7 +70,7 @@ npx pgflow@latest compile supabase/functions/_flows/my_flow.ts
 
 Options:
 
-- `--deno-json <path>` - Path to custom deno.json with import map
+- `--deno-json <path>` - Path to custom deno.json configuration file
 - `--supabase-path <path>` - Path to custom Supabase directory
 
 The compiler will:

package/dist/commands/compile/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/compile/index.d.ts.map

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

package/dist/commands/compile/index.js

@@ -0,0 +1,201 @@
+import chalk from 'chalk';
+import { intro, log, note, outro } from '@clack/prompts';
+import path from 'path';
+import fs from 'fs';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+// Get the directory name in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Formats a command and its arguments for display with syntax highlighting
+ * Each argument is displayed on a separate line for better readability
+ */
+function formatCommand(command, args) {
+    const cmd = chalk.cyan(command);
+    const formattedArgs = args.map((arg) => {
+        // Highlight config and file paths differently
+        if (arg.startsWith('--config=')) {
+            const [flag, value] = arg.split('=');
+            return `  ${chalk.yellow(flag)}=${chalk.green(value)}`;
+        }
+        else if (arg.startsWith('--')) {
+            return `  ${chalk.yellow(arg)}`;
+        }
+        else if (arg.endsWith('.ts') || arg.endsWith('.json')) {
+            return `  ${chalk.green(arg)}`;
+        }
+        return `  ${chalk.white(arg)}`;
+    });
+    return `$ ${cmd}\n${formattedArgs.join('\n')}`;
+}
+/**
+ * Creates a task log entry with a command and its output
+ */
+function createTaskLog(command, args, output) {
+    return [
+        chalk.bold('Command:'),
+        formatCommand(command, args),
+        '',
+        chalk.bold('Output:'),
+        output.trim() ? output.trim() : '(no output)',
+    ].join('\n');
+}
+export default (program) => {
+    program
+        .command('compile')
+        .description('Compiles a TypeScript-defined flow into SQL migration')
+        .argument('<flowPath>', 'Path to the flow TypeScript file')
+        .option('--deno-json <denoJsonPath>', 'Path to deno.json configuration file')
+        .option('--supabase-path <supabasePath>', 'Path to the Supabase folder')
+        .action(async (flowPath, options) => {
+        intro('pgflow - Compile Flow to SQL');
+        try {
+            // Resolve paths
+            const resolvedFlowPath = path.resolve(process.cwd(), flowPath);
+            // Only resolve denoJsonPath if it's provided
+            let resolvedDenoJsonPath;
+            if (options.denoJson) {
+                resolvedDenoJsonPath = path.resolve(process.cwd(), options.denoJson);
+                // Validate deno.json path if provided
+                if (!fs.existsSync(resolvedDenoJsonPath)) {
+                    log.error(`deno.json file not found: ${resolvedDenoJsonPath}`);
+                    process.exit(1);
+                }
+            }
+            // Validate flow path
+            if (!fs.existsSync(resolvedFlowPath)) {
+                log.error(`Flow file not found: ${resolvedFlowPath}`);
+                process.exit(1);
+            }
+            // Validate Supabase path
+            let supabasePath;
+            if (options.supabasePath) {
+                supabasePath = path.resolve(process.cwd(), options.supabasePath);
+            }
+            else {
+                // Default to ./supabase/ if not provided
+                supabasePath = path.resolve(process.cwd(), 'supabase');
+            }
+            // Check if Supabase path exists
+            if (!fs.existsSync(supabasePath)) {
+                log.error(`Supabase directory not found: ${supabasePath}\n` +
+                    `Please provide a valid Supabase path using --supabase-path option or ensure ./supabase/ directory exists.`);
+                process.exit(1);
+            }
+            // Find the internal_compile.js script
+            const internalCompileScript = path.resolve(__dirname, '../../deno/internal_compile.js');
+            // Create migrations directory if it doesn't exist
+            const migrationsDir = path.resolve(supabasePath, 'migrations');
+            if (!fs.existsSync(migrationsDir)) {
+                fs.mkdirSync(migrationsDir, { recursive: true });
+                log.success(`Created migrations directory: ${migrationsDir}`);
+            }
+            // Generate timestamp for migration file in format YYYYMMDDHHMMSS using UTC
+            const now = new Date();
+            const timestamp = [
+                now.getUTCFullYear(),
+                String(now.getUTCMonth() + 1).padStart(2, '0'),
+                String(now.getUTCDate()).padStart(2, '0'),
+                String(now.getUTCHours()).padStart(2, '0'),
+                String(now.getUTCMinutes()).padStart(2, '0'),
+                String(now.getUTCSeconds()).padStart(2, '0'),
+            ].join('');
+            // Run the compilation
+            log.info(`Compiling flow: ${path.basename(resolvedFlowPath)}`);
+            const compiledSql = await runDenoCompilation(internalCompileScript, resolvedFlowPath, resolvedDenoJsonPath);
+            // Extract flow name from the first line of the SQL output using regex
+            // Looking for pattern: SELECT pgflow.create_flow('flow_name', ...);
+            const flowNameMatch = compiledSql.match(/SELECT\s+pgflow\.create_flow\s*\(\s*'([^']+)'/i);
+            // Use extracted flow name or fallback to the file basename if extraction fails
+            let flowName;
+            if (flowNameMatch && flowNameMatch[1]) {
+                flowName = flowNameMatch[1];
+                log.info(`Extracted flow name: ${flowName}`);
+            }
+            else {
+                // Fallback to file basename if regex doesn't match
+                flowName = path.basename(resolvedFlowPath, path.extname(resolvedFlowPath));
+                log.warn(`Could not extract flow name from SQL, using file basename: ${flowName}`);
+            }
+            // Create migration filename in the format: <timestamp>_create_<flow_name>_flow.sql
+            const migrationFileName = `${timestamp}_create_${flowName}_flow.sql`;
+            const migrationFilePath = path.join(migrationsDir, migrationFileName);
+            // Write the SQL to a migration file
+            fs.writeFileSync(migrationFilePath, compiledSql);
+            // Show the migration file path relative to the current directory
+            const relativeFilePath = path.relative(process.cwd(), migrationFilePath);
+            log.success(`Migration file created: ${relativeFilePath}`);
+            // Display next steps with outro
+            outro([
+                chalk.bold('Flow compilation completed successfully!'),
+                '',
+                `- Run ${chalk.cyan('supabase migration up')} to apply the migration`,
+                '',
+                chalk.bold('Continue the setup:'),
+                chalk.blue.underline('https://pgflow.dev/getting-started/run-flow/')
+            ].join('\n'));
+        }
+        catch (error) {
+            log.error(`Compilation failed: ${error instanceof Error ? error.message : String(error)}`);
+            outro([
+                chalk.bold('Compilation failed!'),
+                '',
+                chalk.bold('For troubleshooting help:'),
+                chalk.blue.underline('https://pgflow.dev/getting-started/compile-to-sql/')
+            ].join('\n'));
+            process.exit(1);
+        }
+    });
+};
+/**
+ * Runs the Deno compilation script and returns the compiled SQL
+ */
+async function runDenoCompilation(scriptPath, flowPath, denoJsonPath) {
+    return new Promise((resolve, reject) => {
+        // Validate input paths
+        if (!scriptPath) {
+            return reject(new Error('Internal script path is required'));
+        }
+        if (!flowPath) {
+            return reject(new Error('Flow path is required'));
+        }
+        // Build the command arguments array
+        const args = ['run', '--allow-read', '--allow-net', '--allow-env'];
+        // Only add the config argument if denoJsonPath is provided and valid
+        if (denoJsonPath && typeof denoJsonPath === 'string') {
+            args.push(`--config=${denoJsonPath}`);
+        }
+        // Add the script path and flow path
+        args.push(scriptPath, flowPath);
+        // Log the command for debugging with colored output
+        log.info('Running Deno compiler');
+        const deno = spawn('deno', args);
+        let stdout = '';
+        let stderr = '';
+        deno.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        deno.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        deno.on('close', (code) => {
+            // Always display the task log with command and output
+            note(createTaskLog('deno', args, stdout));
+            if (code === 0) {
+                if (stdout.trim().length === 0) {
+                    reject(new Error('Compilation produced no output'));
+                }
+                else {
+                    resolve(stdout);
+                }
+            }
+            else {
+                reject(new Error(`Deno process exited with code ${code}${stderr ? `\n${stderr}` : ''}`));
+            }
+        });
+        deno.on('error', (err) => {
+            reject(new Error(`Failed to start Deno process: ${err.message}. Make sure Deno is installed.`));
+        });
+    });
+}

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

@@ -0,0 +1,5 @@
+export declare function copyMigrations({ supabasePath, autoConfirm, }: {
+    supabasePath: string;
+    autoConfirm?: boolean;
+}): 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":"AA6JA,wBAAsB,cAAc,CAAC,EACnC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CA6LnB"}

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

@@ -0,0 +1,253 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+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);
+// Create a require function to use require.resolve
+const require = createRequire(import.meta.url);
+// Function to find migrations directory
+function findMigrationsDirectory() {
+    try {
+        // First try: resolve from installed @pgflow/core package
+        const corePackageJsonPath = require.resolve('@pgflow/core/package.json');
+        const corePackageFolder = path.dirname(corePackageJsonPath);
+        const packageMigrationsPath = path.join(corePackageFolder, 'dist', 'supabase', 'migrations');
+        if (fs.existsSync(packageMigrationsPath)) {
+            return packageMigrationsPath;
+        }
+        // If that fails, try development path
+        log.info('Could not find migrations in installed package, trying development paths...');
+    }
+    catch (error) {
+        log.info('Could not resolve @pgflow/core package, trying development paths...');
+    }
+    // Try development paths
+    // 1. Try relative to CLI dist folder (when running built CLI)
+    const distRelativePath = path.resolve(__dirname, '../../../../core/supabase/migrations');
+    if (fs.existsSync(distRelativePath)) {
+        return distRelativePath;
+    }
+    // 2. Try relative to CLI source folder (when running from source)
+    const sourceRelativePath = path.resolve(__dirname, '../../../../../core/supabase/migrations');
+    if (fs.existsSync(sourceRelativePath)) {
+        return sourceRelativePath;
+    }
+    // 3. Try local migrations directory (for backward compatibility)
+    const localMigrationsPath = path.resolve(__dirname, '../../migrations');
+    if (fs.existsSync(localMigrationsPath)) {
+        return localMigrationsPath;
+    }
+    // No migrations found
+    return null;
+}
+// Helper function to get the timestamp part from a migration filename
+function getTimestampFromFilename(filename) {
+    const match = filename.match(/^(\d+)_/);
+    // Return the timestamp only if it exists and has the correct length (14 digits)
+    if (match && match[1] && match[1].length === 14 && /^\d{14}$/.test(match[1])) {
+        return match[1];
+    }
+    return '';
+}
+// Helper function to format a Date object into a migration timestamp string (YYYYMMDDhhmmss) using UTC
+function formatDateToTimestamp(date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+    const seconds = String(date.getUTCSeconds()).padStart(2, '0');
+    return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+// Helper function to parse a timestamp string into a Date object (interpreted as UTC)
+function parseTimestampToDate(timestamp) {
+    // Validate format: YYYYMMDDhhmmss
+    if (!timestamp || timestamp.length !== 14 || !/^\d{14}$/.test(timestamp)) {
+        return null;
+    }
+    const year = parseInt(timestamp.substring(0, 4), 10);
+    const month = parseInt(timestamp.substring(4, 6), 10) - 1; // months are 0-indexed in JS Date
+    const day = parseInt(timestamp.substring(6, 8), 10);
+    const hours = parseInt(timestamp.substring(8, 10), 10);
+    const minutes = parseInt(timestamp.substring(10, 12), 10);
+    const seconds = parseInt(timestamp.substring(12, 14), 10);
+    // Create date in UTC and validate (invalid dates like Feb 31 will be auto-corrected by JS Date)
+    const date = new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+    // Additional validation to ensure the parsed date matches the input
+    // This catches edge cases like month=13 that JS Date would autocorrect
+    if (date.getUTCFullYear() !== year ||
+        date.getUTCMonth() !== month ||
+        date.getUTCDate() !== day ||
+        date.getUTCHours() !== hours ||
+        date.getUTCMinutes() !== minutes ||
+        date.getUTCSeconds() !== seconds) {
+        return null;
+    }
+    return date;
+}
+// Helper function to generate a new timestamp that's higher than the reference timestamp (using UTC)
+function generateNewTimestamp(referenceTimestamp, increment = 1) {
+    // First try to parse the reference timestamp to a Date
+    const parsedDate = parseTimestampToDate(referenceTimestamp);
+    // If we couldn't parse it, use current UTC time
+    if (!parsedDate) {
+        return formatDateToTimestamp(new Date());
+    }
+    // Add the specified number of seconds (default: 1)
+    parsedDate.setUTCSeconds(parsedDate.getUTCSeconds() + increment);
+    // Get current UTC time for comparison
+    const now = new Date();
+    // Return either the incremented timestamp or current time, whichever is later
+    // This ensures we never go backwards in time
+    if (parsedDate > now) {
+        return formatDateToTimestamp(parsedDate);
+    }
+    else {
+        // If we're already at or past current time, add increment to now
+        now.setUTCSeconds(now.getUTCSeconds() + increment);
+        return formatDateToTimestamp(now);
+    }
+}
+// Find the migrations directory
+const sourcePath = findMigrationsDirectory();
+export async function copyMigrations({ supabasePath, autoConfirm = false, }) {
+    const migrationsPath = path.join(supabasePath, 'migrations');
+    if (!fs.existsSync(migrationsPath)) {
+        fs.mkdirSync(migrationsPath);
+    }
+    // Check if pgflow migrations directory exists
+    if (!sourcePath || !fs.existsSync(sourcePath)) {
+        log.error(`Could not find migrations directory`);
+        log.warn('This might happen if @pgflow/core is not properly installed or built.');
+        log.info('Make sure @pgflow/core is installed and contains the migrations.');
+        log.info('If running in development mode, try building the core package first with: nx build core');
+        return false;
+    }
+    // Get all existing migrations in user's directory
+    const existingFiles = fs.existsSync(migrationsPath)
+        ? fs.readdirSync(migrationsPath)
+        : [];
+    // Find the latest migration timestamp in user's directory
+    let latestTimestamp = '00000000000000';
+    for (const file of existingFiles) {
+        if (file.endsWith('.sql')) {
+            const timestamp = getTimestampFromFilename(file);
+            // Only consider timestamps that have been validated by getTimestampFromFilename
+            // to have the correct length and format
+            if (timestamp && timestamp.length === 14) {
+                const parsedDate = parseTimestampToDate(timestamp);
+                // If we have a valid date and this timestamp is newer, update latestTimestamp
+                if (parsedDate && parseInt(timestamp, 10) > parseInt(latestTimestamp, 10)) {
+                    latestTimestamp = timestamp;
+                }
+            }
+        }
+    }
+    // Get all source migrations
+    const sourceFiles = fs
+        .readdirSync(sourcePath)
+        .filter((file) => file.endsWith('.sql'));
+    const filesToCopy = [];
+    const skippedFiles = [];
+    // Check which migrations need to be installed
+    for (const sourceFile of sourceFiles) {
+        // Check if this migration is already installed (by checking if the original filename
+        // appears in any existing migration filename)
+        const isAlreadyInstalled = existingFiles.some((existingFile) => existingFile.includes(sourceFile));
+        if (isAlreadyInstalled) {
+            skippedFiles.push(sourceFile);
+        }
+        else {
+            filesToCopy.push({
+                source: sourceFile,
+                destination: sourceFile, // Will be updated later with new timestamp
+            });
+        }
+    }
+    // If no files to copy, show message with details and return false (no changes made)
+    if (filesToCopy.length === 0) {
+        // Show success message
+        log.success('All pgflow migrations are already in place');
+        // Show details of already installed migrations
+        if (skippedFiles.length > 0) {
+            const detailedMsg = [
+                'Already installed migrations:',
+                ...skippedFiles.map((file) => {
+                    // Find the matching existing file to show how it was installed
+                    const matchingFile = existingFiles.find((existingFile) => existingFile.includes(file));
+                    if (matchingFile === file) {
+                        // Installed with old direct method
+                        return `  ${chalk.dim('•')} ${chalk.bold(file)}`;
+                    }
+                    else {
+                        // Installed with new timestamped method
+                        const timestampPart = matchingFile?.substring(0, matchingFile.indexOf(file) - 1) || '';
+                        return `  ${chalk.dim('•')} ${chalk.dim(timestampPart + '_')}${chalk.bold(file)}`;
+                    }
+                }),
+            ].join('\n');
+            note(detailedMsg, 'Existing pgflow Migrations');
+        }
+        return false;
+    }
+    // Generate new timestamps for migrations to install
+    let baseTimestamp = latestTimestamp;
+    filesToCopy.forEach((file) => {
+        // Generate timestamp with increasing values to maintain order
+        // Each iteration uses the timestamp generated by the previous iteration as the base
+        baseTimestamp = generateNewTimestamp(baseTimestamp);
+        // Create new filename with format: newTimestamp_originalFilename
+        file.destination = `${baseTimestamp}_${file.source}`;
+    });
+    log.info(`Found ${filesToCopy.length} migration${filesToCopy.length !== 1 ? 's' : ''} to install`);
+    // Prepare summary message with colored output
+    const summaryParts = [];
+    if (filesToCopy.length > 0) {
+        summaryParts.push(`${chalk.green('New migrations to install:')}\n${filesToCopy
+            .map((file) => {
+            // Extract the timestamp part from the new filename
+            const newTimestamp = file.destination.substring(0, 14);
+            // Format: dim timestamp + bright original name
+            return `${chalk.green('+')} ${file.source} → ${chalk.dim(newTimestamp + '_')}${chalk.bold(file.source)}`;
+        })
+            .join('\n')}`);
+    }
+    if (skippedFiles.length > 0) {
+        summaryParts.push(`${chalk.yellow('Already installed:')}\n${skippedFiles
+            .map((file) => `${chalk.yellow('•')} ${file}`)
+            .join('\n')}`);
+    }
+    // Show summary and ask for confirmation if not auto-confirming
+    note(summaryParts.join('\n\n'), 'pgflow Migrations');
+    let shouldContinue = autoConfirm;
+    if (!autoConfirm) {
+        const confirmResult = await confirm({
+            message: `Install ${filesToCopy.length} new migration${filesToCopy.length !== 1 ? 's' : ''}?`,
+        });
+        shouldContinue = confirmResult === true;
+    }
+    if (!shouldContinue) {
+        log.warn('Migration installation skipped');
+        return false;
+    }
+    // Install migrations with new filenames
+    for (const file of filesToCopy) {
+        const sourcePath1 = path.join(sourcePath, file.source);
+        const destinationPath = path.join(migrationsPath, file.destination);
+        fs.copyFileSync(sourcePath1, destinationPath);
+    }
+    // Show detailed success message with styled filenames
+    const detailedSuccessMsg = [
+        `Installed ${filesToCopy.length} migration${filesToCopy.length !== 1 ? 's' : ''} to your Supabase project:`,
+        ...filesToCopy.map((file) => {
+            const newTimestamp = file.destination.substring(0, 14);
+            return `  ${chalk.dim(newTimestamp + '_')}${chalk.bold(file.source)}`;
+        }),
+    ].join('\n');
+    log.success(detailedSuccessMsg);
+    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;yBAQzB,SAAS,OAAO;AAAhC,wBAiHE"}

package/dist/commands/install/index.js

@@ -0,0 +1,90 @@
+import { intro, group, cancel, outro } from '@clack/prompts';
+import chalk from 'chalk';
+import { copyMigrations } from './copy-migrations.js';
+import { updateConfigToml } from './update-config-toml.js';
+import { updateEnvFile } from './update-env-file.js';
+import { supabasePathPrompt } from './supabase-path-prompt.js';
+export default (program) => {
+    program
+        .command('install')
+        .description('Set up pgflow in your Supabase project')
+        .option('--supabase-path <path>', 'Path to the Supabase folder')
+        .option('-y, --yes', 'Automatically confirm all prompts', false)
+        .action(async (options) => {
+        intro('Installing pgflow in your Supabase project');
+        // Use the group feature to organize installation steps
+        const results = await group({
+            // Step 1: Determine Supabase path
+            supabasePath: () => supabasePathPrompt({ supabasePath: options.supabasePath }),
+            // Step 2: Update config.toml
+            configUpdate: async ({ results: { supabasePath } }) => {
+                if (!supabasePath)
+                    return false;
+                return await updateConfigToml({
+                    supabasePath,
+                    autoConfirm: options.yes,
+                });
+            },
+            // Step 3: Copy migrations
+            migrations: async ({ results: { supabasePath } }) => {
+                if (!supabasePath)
+                    return false;
+                return await copyMigrations({
+                    supabasePath,
+                    autoConfirm: options.yes,
+                });
+            },
+            // Step 4: Update environment variables
+            envFile: async ({ results: { supabasePath } }) => {
+                if (!supabasePath)
+                    return false;
+                return await updateEnvFile({
+                    supabasePath,
+                    autoConfirm: options.yes,
+                });
+            },
+        }, {
+            // Handle cancellation
+            onCancel: () => {
+                cancel('Installation cancelled');
+                process.exit(1);
+            },
+        });
+        // Extract the results from the group operation
+        const supabasePath = results.supabasePath;
+        const configUpdate = results.configUpdate;
+        const migrations = results.migrations;
+        const envFile = results.envFile;
+        // Exit if supabasePath is null (validation failed or user cancelled)
+        if (!supabasePath) {
+            cancel('Installation cancelled - valid Supabase path is required');
+            process.exit(1);
+        }
+        // Show completion message
+        const outroMessages = [];
+        // Always start with a bolded acknowledgement
+        if (migrations || configUpdate || envFile) {
+            outroMessages.push(chalk.bold('pgflow setup completed successfully!'));
+        }
+        else {
+            outroMessages.push(chalk.bold('pgflow is already properly configured - no changes needed!'));
+        }
+        // Add a newline after the acknowledgement
+        outroMessages.push('');
+        // Add specific next steps if changes were made
+        if (configUpdate || envFile) {
+            outroMessages.push(`- Restart your Supabase instance for configuration changes to take effect`);
+        }
+        if (migrations) {
+            outroMessages.push(`- Apply the migrations with: ${chalk.cyan('supabase migrations up')}`);
+        }
+        // Always add documentation link with consistent formatting
+        if (outroMessages.length > 2) {
+            // If we have specific steps, add another newline
+            outroMessages.push('');
+        }
+        outroMessages.push(chalk.bold('Continue the setup:'), chalk.blue.underline('https://pgflow.dev/getting-started/create-first-flow/'));
+        // Single outro for all paths
+        outro(outroMessages.join('\n'));
+    });
+};

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

@@ -0,0 +1,4 @@
+export declare function supabasePathPrompt(options?: {
+    supabasePath?: string;
+}): 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,CAAC,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,4BA6C3E"}

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

@@ -0,0 +1,49 @@
+import fs from 'fs';
+import path from 'path';
+import { text, log } from '@clack/prompts';
+export async function supabasePathPrompt(options) {
+    // If supabasePath is provided as an option and it's valid, use it directly without prompting
+    if (options?.supabasePath) {
+        const validationError = validate(options.supabasePath);
+        if (validationError === undefined) {
+            log.info(`Using Supabase project at: ${options.supabasePath}`);
+            return options.supabasePath;
+        }
+        // If validation failed, log the error and continue to prompt
+        log.warn(validationError);
+    }
+    // Try to detect the Supabase directory automatically
+    const possiblePaths = ['./supabase', '../supabase', '../../supabase'];
+    let detectedPath = '';
+    for (const testPath of possiblePaths) {
+        if (fs.existsSync(testPath) &&
+            fs.existsSync(path.join(testPath, 'config.toml'))) {
+            detectedPath = testPath;
+            break;
+        }
+    }
+    // Always prompt for detected paths - don't skip
+    if (detectedPath) {
+        log.info(`Found Supabase project at: ${detectedPath}`);
+    }
+    const promptMessage = 'Where is your Supabase project located?';
+    const supabasePath = await text({
+        message: promptMessage,
+        placeholder: detectedPath || 'supabase/',
+        initialValue: options?.supabasePath || detectedPath,
+        validate,
+    });
+    if (!supabasePath) {
+        throw new Error('User cancelled');
+    }
+    return supabasePath;
+}
+function validate(inputPath) {
+    if (!fs.existsSync(inputPath)) {
+        return `Directory not found: ${inputPath}`;
+    }
+    if (!fs.existsSync(path.join(inputPath, 'config.toml'))) {
+        return `Not a valid Supabase project (missing config.toml)`;
+    }
+    return undefined;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * 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
+ * @param options.autoConfirm - Whether to automatically confirm changes
+ * @returns Promise<boolean> - True if changes were made, false otherwise
+ */
+export declare function updateConfigToml({ supabasePath, autoConfirm, }: {
+    supabasePath: string;
+    autoConfirm?: boolean;
+}): 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;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CAwHnB"}

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

@@ -0,0 +1,119 @@
+import fs from 'fs';
+import path from 'path';
+import { log, confirm, note } from '@clack/prompts';
+import * as TOML from '@decimalturn/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
+ * @param options.autoConfirm - Whether to automatically confirm changes
+ * @returns Promise<boolean> - True if changes were made, false otherwise
+ */
+export async function updateConfigToml({ supabasePath, autoConfirm = false, }) {
+    // Check Supabase configuration
+    const configPath = path.join(supabasePath, 'config.toml');
+    const backupPath = `${configPath}.backup`;
+    try {
+        if (!fs.existsSync(configPath)) {
+            log.error(`config.toml not found at ${configPath}`);
+            throw new Error(`config.toml not found at ${configPath}`);
+        }
+        const configContent = fs.readFileSync(configPath, 'utf8');
+        let config;
+        try {
+            config = TOML.parse(configContent);
+        }
+        catch (parseError) {
+            const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+            log.error(`Invalid TOML syntax in ${configPath}: ${errorMsg}`);
+            throw new Error(`Invalid TOML syntax in ${configPath}: ${errorMsg}`);
+        }
+        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.success('Supabase configuration is already set up for pgflow');
+            return false;
+        }
+        const changes = [];
+        if (currentSettings.poolerEnabled !== true) {
+            changes.push(`${chalk.bold('Enable connection pooler:')}
+${chalk.red(`- enabled = ${currentSettings.poolerEnabled}`)}
+${chalk.green('+ enabled = true')}`);
+        }
+        if (currentSettings.poolMode !== 'transaction') {
+            changes.push(`${chalk.bold('Set pool mode to transaction:')}
+${chalk.red(`- pool_mode = "${currentSettings.poolMode}"`)}
+${chalk.green('+ pool_mode = "transaction"')}`);
+        }
+        if (currentSettings.edgeRuntimePolicy !== 'per_worker') {
+            changes.push(`${chalk.bold('Set edge runtime policy:')}
+${chalk.red(`- policy = "${currentSettings.edgeRuntimePolicy}"`)}
+${chalk.green('+ policy = "per_worker"')}`);
+        }
+        note(changes.join('\n\n'), 'Required Configuration Changes');
+        let shouldContinue = autoConfirm;
+        if (!autoConfirm) {
+            const confirmResult = await confirm({
+                message: `Update Supabase configuration? (a backup will be created)`,
+            });
+            shouldContinue = confirmResult === true;
+        }
+        if (!shouldContinue) {
+            log.warn('Configuration update skipped');
+            return false;
+        }
+        // Update Supabase configuration
+        // Create backup
+        fs.copyFileSync(configPath, backupPath);
+        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';
+        let updatedContent;
+        try {
+            updatedContent = TOML.patch(configContent, updatedConfig, {
+                trailingComma: false,
+            });
+        }
+        catch (stringifyError) {
+            const errorMsg = stringifyError instanceof Error ? stringifyError.message : String(stringifyError);
+            log.error(`Failed to generate TOML for ${configPath}: ${errorMsg}`);
+            throw new Error(`Failed to generate TOML for ${configPath}: ${errorMsg}`);
+        }
+        try {
+            fs.writeFileSync(configPath, updatedContent);
+        }
+        catch (writeError) {
+            const errorMsg = writeError instanceof Error ? writeError.message : String(writeError);
+            log.error(`Failed to write ${configPath}: ${errorMsg}`);
+            throw new Error(`Failed to write ${configPath}: ${errorMsg}`);
+        }
+        log.success('Supabase configuration updated successfully');
+        return true;
+    }
+    catch (error) {
+        log.error(`Configuration update failed: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/dist/commands/install/update-env-file.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Updates the functions/.env file with required environment variables for pgflow
+ *
+ * @param options.supabasePath - Path to the supabase directory
+ * @param options.autoConfirm - Whether to automatically confirm changes
+ * @returns Promise<boolean> - True if changes were made, false otherwise
+ */
+export declare function updateEnvFile({ supabasePath, autoConfirm, }: {
+    supabasePath: string;
+    autoConfirm?: boolean;
+}): Promise<boolean>;
+//# sourceMappingURL=update-env-file.d.ts.map

package/dist/commands/install/update-env-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-env-file.d.ts","sourceRoot":"","sources":["../../../src/commands/install/update-env-file.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,EAClC,YAAY,EACZ,WAAmB,GACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,OAAO,CAAC,CAqHnB"}

package/dist/commands/install/update-env-file.js

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+import { log, note, confirm } from '@clack/prompts';
+import chalk from 'chalk';
+/**
+ * Updates the functions/.env file with required environment variables for pgflow
+ *
+ * @param options.supabasePath - Path to the supabase directory
+ * @param options.autoConfirm - Whether to automatically confirm changes
+ * @returns Promise<boolean> - True if changes were made, false otherwise
+ */
+export async function updateEnvFile({ supabasePath, autoConfirm = false, }) {
+    // Check environment variables
+    const functionsDir = path.join(supabasePath, 'functions');
+    const envFilePath = path.join(functionsDir, '.env');
+    // Create functions directory if it doesn't exist
+    if (!fs.existsSync(functionsDir)) {
+        fs.mkdirSync(functionsDir, { recursive: true });
+    }
+    // Variables to add
+    const envVars = {
+        EDGE_WORKER_DB_URL: 'postgresql://postgres.pooler-dev:postgres@pooler:6543/postgres',
+        EDGE_WORKER_LOG_LEVEL: 'info',
+    };
+    // Check if file exists and read its content
+    let currentContent = '';
+    let isNewFile = false;
+    if (fs.existsSync(envFilePath)) {
+        currentContent = fs.readFileSync(envFilePath, 'utf8');
+    }
+    else {
+        isNewFile = true;
+    }
+    // Prepare new content
+    let newContent = currentContent;
+    // Build diff preview
+    const missingVars = [];
+    const existingVars = [];
+    // Check which variables need to be added
+    for (const [key, value] of Object.entries(envVars)) {
+        if (!newContent.includes(`${key}=`)) {
+            missingVars.push({ key, value });
+        }
+        else {
+            existingVars.push(key);
+        }
+    }
+    // If no changes needed, return early
+    if (missingVars.length === 0) {
+        log.success('Environment variables are already set');
+        return false;
+    }
+    log.info(`Found ${missingVars.length} variable${missingVars.length !== 1 ? 's' : ''} to add`);
+    // Build diff preview
+    const diffPreview = [];
+    if (isNewFile) {
+        diffPreview.push(`${chalk.green('Creating new .env file with:')}`);
+    }
+    else {
+        diffPreview.push(`${chalk.green('Adding to existing .env file:')}`);
+    }
+    // Show variables to be added
+    for (const { key, value } of missingVars) {
+        diffPreview.push(`${chalk.green('+')} ${key}="${value}"`);
+    }
+    // Show existing variables if any
+    if (existingVars.length > 0) {
+        diffPreview.push('');
+        diffPreview.push(`${chalk.yellow('Already present:')}`);
+        for (const key of existingVars) {
+            diffPreview.push(`${chalk.yellow('•')} ${key}`);
+        }
+    }
+    // Show the diff preview
+    note(diffPreview.join('\n'), 'Environment Variables');
+    // Ask for confirmation if not auto-confirming
+    let shouldContinue = autoConfirm;
+    if (!autoConfirm) {
+        const confirmResult = await confirm({
+            message: `Update environment variables?`,
+        });
+        shouldContinue = confirmResult === true;
+    }
+    if (!shouldContinue) {
+        log.warn('Environment variable update skipped');
+        return false;
+    }
+    // Update environment variables
+    // Apply changes if confirmed
+    for (const { key, value } of missingVars) {
+        // Add a newline at the end if the file doesn't end with one and isn't empty
+        if (newContent && !newContent.endsWith('\n')) {
+            newContent += '\n';
+        }
+        // Add the new variable
+        newContent += `${key}="${value}"\n`;
+    }
+    // Write the file if changes were made
+    try {
+        fs.writeFileSync(envFilePath, newContent);
+        log.success('Environment variables updated successfully');
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log.error(`Failed to update environment variables: ${errorMessage}`);
+        return false;
+    }
+}

package/dist/deno/internal_compile.js

@@ -0,0 +1,55 @@
+/**
+ * internal_compile.js
+ *
+ * This script is executed by Deno to compile a Flow into SQL statements.
+ * It takes a path to a flow file as an argument, imports the default export,
+ * and passes it to compileFlow() from the DSL package.
+ */
+
+// Import the compileFlow function directly from @pgflow/dsl
+// The import map in deno.json will resolve this import
+import { compileFlow } from '@pgflow/dsl';
+
+// Get the flow file path from command line arguments
+const flowFilePath = Deno.args[0];
+
+if (!flowFilePath) {
+  console.error('Error: No flow file path provided');
+  Deno.exit(1);
+}
+
+try {
+  // Dynamically import the flow file
+  const flowModule = await import(`file://${flowFilePath}`);
+
+  // Check if there's a default export
+  if (!flowModule.default) {
+    console.error(`Error: No default export found in ${flowFilePath}`);
+    Deno.exit(1);
+  }
+
+  // Get the flow instance
+  const flow = flowModule.default;
+
+  // Compile the flow to SQL
+  const sqlStatements = compileFlow(flow);
+
+  // Output the SQL statements to stdout
+  console.log(sqlStatements.join('\n'));
+} catch (error) {
+  console.error(`Error compiling flow: ${error.message}`);
+
+  // If the error is related to importing compileFlow, provide more detailed error
+  if (error.message.includes('@pgflow/dsl')) {
+    console.error(
+      'Failed to import compileFlow from @pgflow/dsl. This might be due to:'
+    );
+    console.error(
+      '1. The function not being exported correctly from the package'
+    );
+    console.error('2. A version mismatch between the CLI and DSL packages');
+    console.error('3. Issues with the Deno import map configuration');
+  }
+
+  Deno.exit(1);
+}

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,90 @@
+#!/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';
+import compileCommand from './commands/compile/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;
+});
+// Register commands
+installCommand(program);
+compileCommand(program);
+import chalk from 'chalk';
+// Tokyo Night inspired colors
+// const p = chalk.hex('#7aa2f7'); // blue-violet
+const g = chalk.hex('#9ece6a'); // vibrant green
+// const f = chalk.hex('#bb9af7'); // light purple/pink
+const l = chalk.hex('#2ac3de'); // bright teal/cyan
+// const o = chalk.hex('#ff9e64'); // orange
+// const w = chalk.hex('#f7768e'); // magenta/pink
+const banner = [
+    `                ${l('__ _')}                 `,
+    `   ${g('_ __   __ _')} ${l('/ _| | _____      __')}  `,
+    `  ${g("| '_ \\ / _'")} ${l('| |_| |/ _ \\ \\ /\\ / /')}  `,
+    `  ${g('| |_) | (_|')} ${l('|  _| | (_) \\ V  V /')}   `,
+    `  ${g('| .__/ \\__,')} ${l('|_| |_|\\___/ \\_/\\_/')}    `,
+    `  ${g('|_|    |___/')}`,
+].join('\n');
+console.log(banner);
+console.log();
+console.log();
+console.log();
+// 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/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "pgflow",
+  "version": "0.0.0-update-supabase-868977e5-20251119071204",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "bin": "./dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "devDependencies": {
+    "@types/node": "^22.14.1",
+    "tsx": "^4.19.3"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.10.1",
+    "@commander-js/extra-typings": "^13.1.0",
+    "@decimalturn/toml-patch": "0.3.7",
+    "@pgflow/core": "workspace:*",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "postinstall": "chmod +x dist/index.js || true"
+  }
+}

package/dist/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.8.3"}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "pgflow",
-  "version": "0.0.0-test-snapshot-releases2-8d5d9bc1-20250922101158",
+  "version": "0.0.0-update-supabase-868977e5-20251119071204",
+  "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -21,10 +22,10 @@
   "dependencies": {
     "@clack/prompts": "^0.10.1",
     "@commander-js/extra-typings": "^13.1.0",
+    "@decimalturn/toml-patch": "0.3.7",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
-    "toml-patch": "^0.2.3",
-    "@pgflow/core": "0.0.0-test-snapshot-releases2-8d5d9bc1-20250922101158"
+    "@pgflow/core": "0.0.0-update-supabase-868977e5-20251119071204"
   },
   "publishConfig": {
     "access": "public"