pgflow 0.0.0-add-workerconfig-to-context--20250905094004-b98e1fec-20250905074005 → 0.0.0-test-snapshot-releases-8d5d9bc1-20250922101013

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgflow",
-  "version": "0.0.0-add-workerconfig-to-context--20250905094004-b98e1fec-20250905074005",
+  "version": "0.0.0-test-snapshot-releases-8d5d9bc1-20250922101013",
   "type": "module",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -24,7 +24,7 @@
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "toml-patch": "^0.2.3",
-    "@pgflow/core": "0.0.0-add-workerconfig-to-context--20250905094004-b98e1fec-20250905074005"
+    "@pgflow/core": "0.0.0-test-snapshot-releases-8d5d9bc1-20250922101013"
   },
   "publishConfig": {
     "access": "public"

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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,201 +0,0 @@
-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 import map and file paths differently
-        if (arg.startsWith('--import-map=')) {
-            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 with valid importMap')
-        .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 import-map argument if denoJsonPath is provided and valid
-        if (denoJsonPath && typeof denoJsonPath === 'string') {
-            args.push(`--import-map=${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

@@ -1,5 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,253 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,90 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-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;
-}