pgflow 0.0.18 → 0.0.20

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

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

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

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

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

@@ -0,0 +1,109 @@
+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;
+}
+// Find the migrations directory
+const sourcePath = findMigrationsDirectory();
+export async function copyMigrations({ supabasePath, }) {
+    const migrationsPath = path.join(supabasePath, 'migrations');
+    if (!fs.existsSync(migrationsPath)) {
+        fs.mkdirSync(migrationsPath);
+    }
+    // Check if pgflow migrations directory exists
+    if (!sourcePath || !fs.existsSync(sourcePath)) {
+        log.error(`Could not find migrations directory`);
+        log.info('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;
+    }
+    const files = fs.readdirSync(sourcePath);
+    const filesToCopy = [];
+    const skippedFiles = [];
+    // Determine which files need to be copied
+    for (const file of files) {
+        const destination = path.join(migrationsPath, file);
+        if (fs.existsSync(destination)) {
+            skippedFiles.push(file);
+        }
+        else {
+            filesToCopy.push(file);
+        }
+    }
+    // If no files to copy, show message and return false (no changes made)
+    if (filesToCopy.length === 0) {
+        log.info('No new migrations to copy - all migrations are already in place');
+        return false;
+    }
+    // Prepare summary message with colored output
+    const summaryParts = [];
+    if (filesToCopy.length > 0) {
+        summaryParts.push(`${chalk.green('Files to be copied:')}
+${filesToCopy.map((file) => `${chalk.green('+')} ${file}`).join('\n')}`);
+    }
+    if (skippedFiles.length > 0) {
+        summaryParts.push(`${chalk.yellow('Files to be skipped (already exist):')}
+${skippedFiles.map((file) => `${chalk.yellow('=')} ${file}`).join('\n')}`);
+    }
+    // Show summary and ask for confirmation
+    note(summaryParts.join('\n\n'), 'Migration Summary');
+    const shouldContinue = await confirm({
+        message: `Do you want to proceed with copying ${filesToCopy.length} migration file${filesToCopy.length !== 1 ? 's' : ''}?`,
+    });
+    if (!shouldContinue) {
+        log.info('Migration copy cancelled');
+        return false;
+    }
+    log.info(`Copying migrations`);
+    // Copy the files
+    for (const file of filesToCopy) {
+        const source = path.join(sourcePath, file);
+        const destination = path.join(migrationsPath, file);
+        fs.copyFileSync(source, destination);
+        log.step(`Copied ${file}`);
+    }
+    log.success(`Successfully copied ${filesToCopy.length} migration file${filesToCopy.length !== 1 ? 's' : ''}`);
+    return true; // Return true to indicate migrations were copied
+}

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

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

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

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

package/dist/commands/install/index.js

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/index.d.ts

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

package/dist/index.d.ts.map

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

package/dist/index.js

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

package/dist/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "pgflow",
+  "version": "0.0.19",
+  "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",
+    "@pgflow/core": "workspace:*",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "toml-patch": "^0.2.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "."
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "postinstall": "chmod +x dist/index.js || true"
+  }
+}

package/dist/tsconfig.lib.tsbuildinfo

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgflow",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "type": "module",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -23,7 +23,8 @@
     "@commander-js/extra-typings": "^13.1.0",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
-    "toml-patch": "^0.2.3"
+    "toml-patch": "^0.2.3",
+    "@pgflow/core": "0.0.20"
   },
   "publishConfig": {
     "access": "public",