pgflow 0.1.3 → 0.1.5

package/dist/commands/compile/index.js

@@ -55,8 +55,8 @@ export default (program) => {
                 log.error(`Flow file not found: ${resolvedFlowPath}`);
                 process.exit(1);
             }
-            // Find the internal_compile.ts script
-            const internalCompileScript = path.resolve(__dirname, '../../../deno/internal_compile.ts');
+            // 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(process.cwd(), 'migrations');
             if (!fs.existsSync(migrationsDir)) {

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

@@ -74,36 +74,36 @@ export async function copyMigrations({ supabasePath, }) {
     }
     // 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');
+        log.info('All pgflow 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:')}
+        summaryParts.push(`${chalk.green('New migrations to install:')}
 ${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')}`);
+        summaryParts.push(`${chalk.yellow('Already installed:')}
+${skippedFiles.map((file) => `${chalk.yellow('•')} ${file}`).join('\n')}`);
     }
     // Show summary and ask for confirmation
-    note(summaryParts.join('\n\n'), 'Migration Summary');
+    note(summaryParts.join('\n\n'), 'pgflow Migrations');
     const shouldContinue = await confirm({
-        message: `Do you want to proceed with copying ${filesToCopy.length} migration file${filesToCopy.length !== 1 ? 's' : ''}?`,
+        message: `Install ${filesToCopy.length} new migration${filesToCopy.length !== 1 ? 's' : ''}?`,
     });
     if (!shouldContinue) {
-        log.info('Migration copy cancelled');
+        log.info('Migration installation skipped');
         return false;
     }
-    log.info(`Copying migrations`);
+    log.step(`Installing pgflow 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.step(`Added ${file}`);
     }
-    log.success(`Successfully copied ${filesToCopy.length} migration file${filesToCopy.length !== 1 ? 's' : ''}`);
+    log.success(`Installed ${filesToCopy.length} migration${filesToCopy.length !== 1 ? 's' : ''} to your Supabase project`);
     return true; // Return true to indicate migrations were copied
 }

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

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

package/dist/commands/install/index.js

@@ -1,32 +1,38 @@
-import { intro, isCancel, log } from '@clack/prompts';
+import { intro, isCancel, log, note } 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')
+        .description('Set up pgflow in your Supabase project')
         .action(async () => {
         intro('pgflow - Postgres-native workflows for Supabase');
         const supabasePath = await supabasePathPrompt();
         if (isCancel(supabasePath)) {
-            log.error('Aborting installation');
+            log.error('Installation cancelled');
             return;
         }
-        const migrationsCopied = await copyMigrations({ supabasePath });
+        // First update config.toml, then copy migrations
         const configUpdated = await updateConfigToml({ supabasePath });
+        const migrationsCopied = await copyMigrations({ supabasePath });
+        // Show completion message
         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!');
+            log.success('pgflow setup completed successfully');
+            // Show next steps if changes were made
+            const nextSteps = [];
+            if (configUpdated) {
+                nextSteps.push('• Restart your Supabase instance for configuration changes to take effect');
+            }
+            if (migrationsCopied) {
+                nextSteps.push('• Apply the migrations with: supabase db push');
+            }
+            if (nextSteps.length > 0) {
+                note(nextSteps.join('\n'), 'Next steps');
+            }
         }
-        if (migrationsCopied) {
-            log.warn('Remember to apply the migrations!');
+        else {
+            log.success('pgflow is already properly configured - no changes needed');
         }
     });
 };

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

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

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

@@ -1,24 +1,34 @@
 import fs from 'fs';
 import path from 'path';
-import { text } from '@clack/prompts';
+import { text, log } from '@clack/prompts';
 export async function supabasePathPrompt() {
+    // 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;
+        }
+    }
+    if (detectedPath) {
+        log.success(`Found Supabase project at: ${detectedPath}`);
+    }
+    const promptMessage = 'Where is your Supabase project located?';
     return await text({
-        message: 'Enter the path to your supabase/ directory',
-        placeholder: 'supabase/',
+        message: promptMessage,
+        placeholder: detectedPath || 'supabase/',
+        initialValue: detectedPath,
         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}`;
-        }
+    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)`;
     }
-    // otherwise, return undefined
     return undefined;
 }

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

@@ -1 +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,CAwHnB"}
+{"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,CAoHnB"}

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

@@ -34,36 +34,36 @@ export async function updateConfigToml({ supabasePath, }) {
             currentSettings.poolMode !== 'transaction' ||
             currentSettings.edgeRuntimePolicy !== 'per_worker';
         if (!needsChanges) {
-            log.info(`No changes needed in config.toml - all required settings are already configured`);
+            log.info(`Supabase configuration is already set up for pgflow`);
             return false;
         }
         const changes = [];
         if (currentSettings.poolerEnabled !== true) {
-            changes.push(`[db.pooler]
+            changes.push(`${chalk.bold('Enable connection pooler:')}
 ${chalk.red(`- enabled = ${currentSettings.poolerEnabled}`)}
 ${chalk.green('+ enabled = true')}`);
         }
         if (currentSettings.poolMode !== 'transaction') {
-            changes.push(`[db.pooler]
+            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(`[edge_runtime]
+            changes.push(`${chalk.bold('Set edge runtime policy:')}
 ${chalk.red(`- policy = "${currentSettings.edgeRuntimePolicy}"`)}
 ${chalk.green('+ policy = "per_worker"')}`);
         }
-        note(changes.join('\n\n'), 'Config Changes');
+        note(changes.join('\n\n'), 'Required Configuration Changes');
         const shouldContinue = await confirm({
-            message: `Do you want to proceed with these configuration changes? A backup will be created at ${backupPath}`,
+            message: `Update Supabase configuration? (a backup will be created)`,
         });
         if (!shouldContinue) {
-            log.info('Configuration update cancelled');
+            log.info('Configuration update skipped');
             return false;
         }
         fs.copyFileSync(configPath, backupPath);
-        log.info(`Created backup at ${backupPath}`);
-        log.info(`Updating config.toml`);
+        log.step(`Created backup of config.toml`);
+        log.step(`Updating Supabase configuration...`);
         const updatedConfig = { ...config };
         // Ensure required objects exist and set values
         if (!updatedConfig.db)
@@ -100,11 +100,11 @@ ${chalk.green('+ policy = "per_worker"')}`);
         // Fix edge_runtime.policy line - transforms "policy = "per_worker"," into "policy = "per_worker""
         /policy = "per_worker",(\s*$|\s*#|\s*\n)/g, 'policy = "per_worker"$1');
         fs.writeFileSync(configPath, updatedContent);
-        log.success(`Successfully updated ${configPath} (backup created at ${backupPath})`);
+        log.success(`Supabase configuration updated successfully`);
         return true;
     }
     catch (error) {
-        log.error(`Failed to update ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+        log.error(`Configuration update failed: ${error instanceof Error ? error.message : String(error)}`);
         throw error;
     }
 }

package/dist/deno/internal_compile.js

@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+
+// 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);
+  }
+
+  // Import the DSL module
+  // The import map in deno.json will resolve this import
+  const dslModule = await import('npm:@pgflow/dsl');
+
+  // Debug available exports
+  console.error('Available exports from @pgflow/dsl:', Object.keys(dslModule));
+
+  // Get the flow instance
+  const flow = flowModule.default;
+
+  let compileFlow;
+  let sqlStatements;
+
+  // Try different ways to access the compileFlow function
+  if (typeof dslModule.compileFlow === 'function') {
+    // Direct export
+    compileFlow = dslModule.compileFlow;
+  } else if (
+    dslModule.default &&
+    typeof dslModule.default.compileFlow === 'function'
+  ) {
+    // Default export with compileFlow as a property
+    compileFlow = dslModule.default.compileFlow;
+  } else {
+    // Try to import the compile-flow module directly
+    try {
+      const compileFlowModule = await import(
+        'npm:@pgflow/dsl/dist/compile-flow.js'
+      );
+      if (typeof compileFlowModule.compileFlow === 'function') {
+        compileFlow = compileFlowModule.compileFlow;
+      } else if (
+        compileFlowModule.default &&
+        typeof compileFlowModule.default === 'function'
+      ) {
+        compileFlow = compileFlowModule.default;
+      }
+    } catch (importError) {
+      console.error(
+        'Failed to import compile-flow module:',
+        importError.message
+      );
+
+      // Try another path
+      try {
+        const altModule = await import('npm:@pgflow/dsl/src/compile-flow.js');
+        if (typeof altModule.compileFlow === 'function') {
+          compileFlow = altModule.compileFlow;
+        } else if (
+          altModule.default &&
+          typeof altModule.default === 'function'
+        ) {
+          compileFlow = altModule.default;
+        }
+      } catch (altError) {
+        console.error(
+          'Failed to import alternative compile-flow module:',
+          altError.message
+        );
+      }
+    }
+  }
+
+  // Check if we found a valid compileFlow function
+  if (typeof compileFlow !== 'function') {
+    console.error('Error: compileFlow function not found in @pgflow/dsl');
+    console.error('Available exports:', Object.keys(dslModule));
+    Deno.exit(1);
+  }
+
+  // Compile the flow to SQL
+  sqlStatements = compileFlow(flow);
+
+  // Output the SQL statements to stdout
+  console.log(sqlStatements.join('\n'));
+} catch (error) {
+  console.error(`Error compiling flow: ${error.message}`);
+  Deno.exit(1);
+}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgflow",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgflow",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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.1.3"
+    "@pgflow/core": "0.1.5"
   },
   "publishConfig": {
     "access": "public",