pgflow 0.1.1 → 0.1.3

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;kCAkChB,OAAO;AAAhC,wBA4EE"}

package/dist/commands/compile/index.js

@@ -0,0 +1,133 @@
+import chalk from 'chalk';
+import { intro, log, spinner, note } 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')}`;
+}
+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')
+        .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);
+            }
+            // Find the internal_compile.ts script
+            const internalCompileScript = path.resolve(__dirname, '../../../deno/internal_compile.ts');
+            // Create migrations directory if it doesn't exist
+            const migrationsDir = path.resolve(process.cwd(), 'migrations');
+            if (!fs.existsSync(migrationsDir)) {
+                fs.mkdirSync(migrationsDir, { recursive: true });
+                log.info(`Created migrations directory: ${migrationsDir}`);
+            }
+            // Generate timestamp for migration file
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '_');
+            const migrationFileName = `pgflow_${timestamp}.sql`;
+            const migrationFilePath = path.join(migrationsDir, migrationFileName);
+            // Run the compilation
+            const s = spinner();
+            s.start(`Compiling flow: ${path.basename(resolvedFlowPath)}`);
+            const compiledSql = await runDenoCompilation(internalCompileScript, resolvedFlowPath, resolvedDenoJsonPath);
+            // Write the SQL to a migration file
+            fs.writeFileSync(migrationFilePath, compiledSql);
+            s.stop(`Successfully compiled flow to SQL`);
+            log.success(`Migration file created: ${migrationFilePath}`);
+        }
+        catch (error) {
+            log.error(`Compilation failed: ${error instanceof Error ? error.message : String(error)}`);
+            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
+        note(formatCommand('deno', args), 'Compile in Deno');
+        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) => {
+            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/deno/internal_compile.ts

@@ -0,0 +1,105 @@
+/**
+ * internal_compile.ts
+ *
+ * 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;
+  const 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/index.js

@@ -4,6 +4,7 @@ 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));
@@ -38,7 +39,31 @@ program
     }
     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('|_|    |___/')}`,
+    ``,
+    `  ${f('Postgres-native Workflow Engine')}`,
+].join('\n');
+console.log(banner);
+console.log();
+console.log();
+console.log();
 // Use a promise-aware approach to parse arguments
 async function main() {
     try {

package/dist/package.json

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

package/package.json

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