@pgsql/cli 1.30.0

package/dist/utils/help.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showVersion = showVersion;
+exports.showHelp = showHelp;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+function showVersion() {
+    // Try to find package.json in various locations
+    const possiblePaths = [
+        (0, path_1.join)(process.cwd(), 'package.json'),
+        (0, path_1.join)(process.argv[1], '../../package.json'),
+        (0, path_1.join)(process.argv[1], '../../../package.json')
+    ];
+    for (const path of possiblePaths) {
+        try {
+            const packageJson = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+            if (packageJson.name === '@pgsql/cli') {
+                console.log(packageJson.version);
+                return;
+            }
+        }
+        catch {
+            // Continue to next path
+        }
+    }
+    // Fallback: just show the version we know
+    console.log('1.29.2');
+}
+function showHelp(command) {
+    if (command) {
+        switch (command) {
+            case 'parse':
+                showParseHelp();
+                break;
+            case 'deparse':
+                showDeparseHelp();
+                break;
+            case 'proto-gen':
+                showProtoGenHelp();
+                break;
+            case 'proto-fetch':
+                showProtoFetchHelp();
+                break;
+            case 'runtime-schema':
+                showRuntimeSchemaHelp();
+                break;
+            default:
+                showGeneralHelp();
+        }
+    }
+    else {
+        showGeneralHelp();
+    }
+}
+function showGeneralHelp() {
+    console.log(`
+${chalk_1.default.bold('pgsql')} - Unified CLI for PostgreSQL AST operations
+
+${chalk_1.default.yellow('Usage:')}
+  pgsql <command> [options]
+
+${chalk_1.default.yellow('Commands:')}
+  ${chalk_1.default.green('parse')}           Parse SQL to AST
+  ${chalk_1.default.green('deparse')}         Convert AST to SQL
+  ${chalk_1.default.green('proto-gen')}       Generate TypeScript from protobuf
+  ${chalk_1.default.green('proto-fetch')}     Download and process proto files
+  ${chalk_1.default.green('runtime-schema')}  Generate runtime schema for AST nodes
+
+${chalk_1.default.yellow('Global Options:')}
+  -h, --help       Show help
+  -v, --version    Show version
+
+${chalk_1.default.yellow('Examples:')}
+  pgsql parse query.sql
+  pgsql deparse ast.json
+  pgsql proto-gen --inFile pg_query.proto --outDir out
+  pgsql proto-fetch --url https://example.com/pg_query.proto --inFile pg_query.proto
+
+Run 'pgsql <command> --help' for detailed help on a specific command.
+`);
+}
+function showParseHelp() {
+    console.log(`
+${chalk_1.default.bold('pgsql parse')} - Parse SQL to AST
+
+${chalk_1.default.yellow('Usage:')}
+  pgsql parse <sqlfile> [options]
+
+${chalk_1.default.yellow('Options:')}
+  -o, --output <file>    Output to file instead of stdout
+  -f, --format <format>  Output format: json, pretty (default: pretty)
+  --clean                Clean the AST tree (remove location info)
+  -h, --help            Show help
+
+${chalk_1.default.yellow('Examples:')}
+  pgsql parse query.sql
+  pgsql parse query.sql -o ast.json
+  pgsql parse query.sql --format json --clean
+`);
+}
+function showDeparseHelp() {
+    console.log(`
+${chalk_1.default.bold('pgsql deparse')} - Convert AST to SQL
+
+${chalk_1.default.yellow('Usage:')}
+  pgsql deparse [options]
+
+${chalk_1.default.yellow('Options:')}
+  -i, --input <file>     Input JSON file (or use stdin)
+  -o, --output <file>    Output to file instead of stdout
+  -h, --help            Show help
+
+${chalk_1.default.yellow('Examples:')}
+  pgsql deparse -i ast.json
+  pgsql deparse -i ast.json -o query.sql
+  cat ast.json | pgsql deparse
+  pgsql parse query.sql | pgsql deparse
+`);
+}
+function showProtoGenHelp() {
+    console.log(`
+${chalk_1.default.bold('pgsql proto-gen')} - Generate TypeScript from protobuf
+
+${chalk_1.default.yellow('Usage:')}
+  pgsql proto-gen --inFile <proto> --outDir <dir> [options]
+
+${chalk_1.default.yellow('Required Options:')}
+  --inFile <file>        Input .proto file
+  --outDir <dir>         Output directory
+
+${chalk_1.default.yellow('Optional Flags:')}
+  --enums                Generate TypeScript enums
+  --enums-json           Generate JSON enum mappings
+  --types                Generate TypeScript interfaces
+  --utils                Generate utility functions
+  --ast-helpers          Generate AST helper methods
+  --wrapped-helpers      Generate wrapped AST helpers
+  --optional             Make all fields optional
+  --keep-case            Keep original field casing
+  --remove-undefined     Remove UNDEFINED enum at position 0
+  -h, --help            Show help
+
+${chalk_1.default.yellow('Examples:')}
+  pgsql proto-gen --inFile pg_query.proto --outDir out --types --enums
+  pgsql proto-gen --inFile pg_query.proto --outDir out --types --utils --ast-helpers
+  pgsql proto-gen --inFile pg_query.proto --outDir out --types --optional --keep-case
+`);
+}
+function showProtoFetchHelp() {
+    console.log(`
+${chalk_1.default.bold('pgsql proto-fetch')} - Download and process proto files
+
+${chalk_1.default.yellow('Usage:')}
+  pgsql proto-fetch [options]
+
+${chalk_1.default.yellow('Options:')}
+  --url <url>            Proto file URL to download
+  --inFile <file>        Where to save the proto file
+  --outFile <file>       Generated JS output file
+  --replace-pkg <old>    Original package name to replace
+  --with-pkg <new>       New package name
+  -h, --help            Show help
+
+${chalk_1.default.yellow('Examples:')}
+  pgsql proto-fetch --url https://raw.githubusercontent.com/pganalyze/libpg_query/16-latest/protobuf/pg_query.proto \\
+                    --inFile pg_query.proto \\
+                    --outFile pg_query.js \\
+                    --replace-pkg "protobufjs/minimal" \\
+                    --with-pkg "@launchql/protobufjs/minimal"
+`);
+}
+function showRuntimeSchemaHelp() {
+    console.log(`
+${chalk_1.default.bold('pgsql runtime-schema')} - Generate runtime schema for AST nodes
+
+${chalk_1.default.yellow('Usage:')}
+  pgsql runtime-schema --inFile <proto> --outDir <dir> [options]
+
+${chalk_1.default.yellow('Required Options:')}
+  --inFile <file>        Input .proto file
+  --outDir <dir>         Output directory
+
+${chalk_1.default.yellow('Optional Options:')}
+  --format <format>      Output format: json, typescript (default: json)
+  --filename <name>      Output filename (default: runtime-schema)
+  -h, --help            Show help
+
+${chalk_1.default.yellow('Examples:')}
+  pgsql runtime-schema --inFile pg_query.proto --outDir out
+  pgsql runtime-schema --inFile pg_query.proto --outDir out --format typescript
+  pgsql runtime-schema --inFile pg_query.proto --outDir out --filename ast-schema
+`);
+}

package/jest.config.js

@@ -0,0 +1,18 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+    preset: "ts-jest",
+    testEnvironment: "node",
+    transform: {
+        "^.+\\.tsx?$": [
+            "ts-jest",
+            {
+                babelConfig: false,
+                tsconfig: "tsconfig.json",
+            },
+        ],
+    },
+    transformIgnorePatterns: [`/node_modules/*`],
+    testRegex: "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
+    moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+    modulePathIgnorePatterns: ["dist/*"]
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@pgsql/cli",
+  "version": "1.30.0",
+  "description": "Unified CLI for PostgreSQL AST parsing, deparsing, and code generation",
+  "author": "Dan Lynch <pyramation@gmail.com>",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/launchql/pgsql-parser/tree/master/packages/pgsql-cli#readme",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/launchql/pgsql-parser"
+  },
+  "bugs": {
+    "url": "https://github.com/launchql/pgsql-parser/issues"
+  },
+  "bin": {
+    "pgsql": "index.js"
+  },
+  "scripts": {
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist",
+    "prepare": "npm run build",
+    "build": "npm run clean && tsc && tsc -p tsconfig.esm.json && npm run copy",
+    "build:dev": "npm run clean && tsc --declarationMap && tsc -p tsconfig.esm.json && npm run copy",
+    "dev": "ts-node src/index",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": [
+    "sql",
+    "postgres",
+    "postgresql",
+    "pg",
+    "query",
+    "ast",
+    "proto",
+    "parser",
+    "deparser",
+    "database"
+  ],
+  "dependencies": {
+    "@launchql/protobufjs": "7.2.6",
+    "@launchql/protobufjs-cli": "1.1.5",
+    "chalk": "^4.1.0",
+    "glob": "8.0.3",
+    "minimist": "1.2.8",
+    "mkdirp": "3.0.1",
+    "nested-obj": "^0.0.1",
+    "pg-proto-parser": "^1.29.0",
+    "pgsql-deparser": "^17.7.0",
+    "pgsql-parser": "^17.6.0"
+  },
+  "gitHead": "e0f9b0579328f4206c315d499e0e2045d3b8f845"
+}

package/src/commands/deparse.ts

@@ -0,0 +1,60 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { deparse } from 'pgsql-deparser';
+import chalk from 'chalk';
+import { showHelp } from '../utils/help';
+
+export async function deparseCommand(argv: any) {
+  if (argv.help) {
+    showHelp('deparse');
+    process.exit(0);
+  }
+
+  try {
+    let ast;
+    
+    // Read AST from file or stdin
+    if (argv.input || argv.i) {
+      const inputFile = argv.input || argv.i;
+      const filePath = inputFile.startsWith('/')
+        ? inputFile
+        : resolve(join(process.cwd(), inputFile));
+      
+      const content = readFileSync(filePath, 'utf-8');
+      ast = JSON.parse(content);
+    } else if (!process.stdin.isTTY) {
+      // Read from stdin
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      const content = Buffer.concat(chunks).toString();
+      ast = JSON.parse(content);
+    } else {
+      console.error(chalk.red('Error: No input provided. Use -i <file> or pipe input via stdin'));
+      showHelp('deparse');
+      process.exit(1);
+    }
+    
+    // Deparse AST to SQL
+    const sql = await deparse(ast);
+    
+    // Write output
+    if (argv.output || argv.o) {
+      const outputFile = argv.output || argv.o;
+      writeFileSync(outputFile, sql);
+      console.log(chalk.green(`✓ SQL written to ${outputFile}`));
+    } else {
+      process.stdout.write(sql);
+    }
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      console.error(chalk.red(`Error: File not found: ${argv.input || argv.i}`));
+    } else if (error instanceof SyntaxError) {
+      console.error(chalk.red('Error: Invalid JSON input'));
+    } else {
+      console.error(chalk.red('Deparse error:'), error.message || error);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/parse.ts

@@ -0,0 +1,60 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { parse } from 'pgsql-parser';
+import chalk from 'chalk';
+import { showHelp } from '../utils/help';
+
+export async function parseCommand(argv: any) {
+  if (argv.help) {
+    showHelp('parse');
+    process.exit(0);
+  }
+
+  const sqlFile = argv._[1];
+  
+  if (!sqlFile) {
+    console.error(chalk.red('Error: SQL file required'));
+    showHelp('parse');
+    process.exit(1);
+  }
+
+  try {
+    // Resolve file path
+    const filePath = sqlFile.startsWith('/')
+      ? sqlFile
+      : resolve(join(process.cwd(), sqlFile));
+    
+    // Read SQL content
+    const content = readFileSync(filePath, 'utf-8');
+    
+    // Parse SQL
+    const ast = await parse(content);
+    
+    // Clean AST if requested
+    if (argv.clean) {
+      // For now, we'll skip the clean functionality until we can import it properly
+      console.warn(chalk.yellow('Warning: --clean flag is not yet implemented'));
+    }
+    
+    // Format output
+    const format = argv.format || 'pretty';
+    const output = format === 'json' 
+      ? JSON.stringify(ast)
+      : JSON.stringify(ast, null, 2);
+    
+    // Write output
+    if (argv.output) {
+      writeFileSync(argv.output, output);
+      console.log(chalk.green(`✓ AST written to ${argv.output}`));
+    } else {
+      process.stdout.write(output);
+    }
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      console.error(chalk.red(`Error: File not found: ${sqlFile}`));
+    } else {
+      console.error(chalk.red('Parse error:'), error.message || error);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/proto-fetch/cli.ts

@@ -0,0 +1,52 @@
+import { downloadProtoFile, generateProtoJS, replaceTextInProtoJS } from './helpers';
+
+export interface CommandOptions {
+  help?: boolean;
+  h?: boolean;
+  version?: boolean;
+  v?: boolean;
+  protoUrl?: string;
+  inFile: string;
+  outFile: string;
+  originalPackageName: string;
+  newPackageName: string;
+}
+
+export const help = (): void => {
+  console.log(`
+  Usage:
+  
+  pg-proto-parser protogen --protoUrl <URL to proto file>
+                     --inFile <path to proto file>
+                     --outFile <path to output JS file>
+                     --originalPackageName <original package name>
+                     --newPackageName <new package name>
+
+  Options:
+  
+  --help, -h                 Show this help message.
+  --version, -v              Show the version number.
+  --protoUrl                 Full URL to download the proto file (optional).
+  --inFile                   Path where the proto file will be saved or path to an existing proto file.
+  --outFile                  Path where the generated JavaScript file will be saved.
+  --originalPackageName      Original package name to be replaced in the JS file.
+  --newPackageName           New package name to replace in the JS file.
+  `);
+}
+
+export default async (argv: CommandOptions): Promise<CommandOptions> => {
+
+  try {
+    if (argv.protoUrl) {
+      await downloadProtoFile(argv.protoUrl, argv.inFile);
+    }
+    await generateProtoJS(argv.inFile, argv.outFile);
+    await replaceTextInProtoJS(argv.outFile, argv.originalPackageName, argv.newPackageName);
+    console.log('All operations completed successfully.');
+  } catch (error) {
+    // @ts-ignore
+    console.error('An error occurred:', error.message);
+  }
+
+  return argv;
+};

package/src/commands/proto-fetch/helpers.ts

@@ -0,0 +1,72 @@
+import https from 'https';
+import fs from 'fs';
+import { exec } from 'child_process';
+import { sync as mkdirp } from 'mkdirp';
+import { dirname } from 'path';
+
+// Download .proto file if URL
+export const downloadProtoFile = (protoUrl: string, filePath: string): Promise<void> => {
+  mkdirp(dirname(filePath));
+
+  return new Promise((resolve, reject) => {
+    https.get(protoUrl, (response) => {
+      if (response.statusCode !== 200) {
+        console.error(`Failed to download file: Status Code: ${response.statusCode}`);
+        response.resume(); // consume response data to free up memory
+        reject(new Error('Failed to download file'));
+        return;
+      }
+
+      const fileStream = fs.createWriteStream(filePath);
+      response.pipe(fileStream);
+      fileStream.on('finish', () => {
+        fileStream.close();
+        console.log('Downloaded proto file.');
+        resolve();
+      });
+    }).on('error', (err) => {
+      console.error(`Error downloading the file: ${err.message}`);
+      fs.unlink(filePath, () => {}); // Delete the file async. (No need to check error here)
+      reject(err);
+    });
+  });
+}
+
+// Generate JavaScript from proto file using pbjs
+export const generateProtoJS = (inFile: string, outFile: string): Promise<void> => new Promise((resolve, reject) => {
+  const command = `pbjs --keep-case -t static-module -o ${outFile} ${inFile}`;
+  mkdirp(dirname(outFile));
+
+  exec(command, (error, _stdout, _stderr) => {
+    if (error) {
+      console.error(`Error during code generation: ${error.message}`);
+      reject(error);
+      return;
+    }
+    console.log('Generated proto.js from proto file.');
+    resolve();
+  });
+});
+
+// Replace text in generated JS file
+export const replaceTextInProtoJS = (filePath: string, originalPackage: string, newPackage: string): Promise<void> => new Promise((resolve, reject) => {
+  fs.readFile(filePath, 'utf8', (err, data) => {
+    if (err) {
+      console.error(`Error reading proto.js: ${err.message}`);
+      reject(err);
+      return;
+    }
+
+    const result = data.replace(new RegExp(originalPackage, 'g'), newPackage);
+    
+    fs.writeFile(filePath, result, 'utf8', (err) => {
+      if (err) {
+        console.error(`Error writing back to proto.js: ${err.message}`);
+        reject(err);
+        return;
+      }
+      console.log('Replaced text in proto.js successfully.');
+      resolve();
+    });
+  });
+});

package/src/commands/proto-fetch.ts

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+import { showHelp } from '../utils/help';
+import { downloadProtoFile, generateProtoJS, replaceTextInProtoJS } from './proto-fetch/helpers';
+
+export async function protoFetchCommand(argv: any) {
+  if (argv.help) {
+    showHelp('proto-fetch');
+    process.exit(0);
+  }
+
+  const url = argv.url;
+  const inFile = argv.inFile;
+  const outFile = argv.outFile;
+  const replacePkg = argv['replace-pkg'] || 'protobufjs/minimal';
+  const withPkg = argv['with-pkg'] || '@launchql/protobufjs/minimal';
+
+  if (!inFile || !outFile) {
+    console.error(chalk.red('Error: --inFile and --outFile are required'));
+    showHelp('proto-fetch');
+    process.exit(1);
+  }
+
+  try {
+    if (url) {
+      console.log(chalk.blue(`Downloading proto file from ${url}...`));
+      await downloadProtoFile(url, inFile);
+      console.log(chalk.green(`✓ Proto file saved to ${inFile}`));
+    }
+    
+    console.log(chalk.blue('Generating JavaScript from proto file...'));
+    await generateProtoJS(inFile, outFile);
+    
+    console.log(chalk.blue(`Replacing package references...`));
+    await replaceTextInProtoJS(outFile, replacePkg, withPkg);
+    
+    console.log(chalk.green(`✓ All operations completed successfully`));
+    console.log(chalk.green(`✓ Generated file: ${outFile}`));
+  } catch (error: any) {
+    console.error(chalk.red('Proto fetch error:'), error.message || error);
+    process.exit(1);
+  }
+}

package/src/commands/proto-gen.ts

@@ -0,0 +1,49 @@
+import { PgProtoParser, PgProtoParserOptions, getOptionsWithDefaults } from 'pg-proto-parser';
+import o from 'nested-obj';
+import chalk from 'chalk';
+import { showHelp } from '../utils/help';
+
+export async function protoGenCommand(argv: any) {
+  if (argv.help) {
+    showHelp('proto-gen');
+    process.exit(0);
+  }
+
+  if (!argv.inFile || !argv.outDir) {
+    console.error(chalk.red('Error: --inFile and --outDir are required'));
+    showHelp('proto-gen');
+    process.exit(1);
+  }
+
+  try {
+    const options: PgProtoParserOptions = getOptionsWithDefaults({
+      outDir: argv.outDir
+    });
+
+    // Set options based on flags
+    if (argv.enums) o.set(options, 'enums.enabled', true);
+    if (argv['enums-json']) o.set(options, 'enums.json.enabled', true);
+    if (argv.types) o.set(options, 'types.enabled', true);
+    if (argv.utils) o.set(options, 'utils.enums.enabled', true);
+    if (argv['ast-helpers']) o.set(options, 'utils.astHelpers.enabled', true);
+    if (argv['wrapped-helpers']) o.set(options, 'utils.wrappedAstHelpers.enabled', true);
+    if (argv.optional) o.set(options, 'types.optionalFields', true);
+    if (argv['keep-case']) o.set(options, 'parser.keepCase', true);
+    if (argv['remove-undefined']) o.set(options, 'enums.removeUndefinedAt0', true);
+    
+    // Additional options that might be useful
+    if (argv['type-union']) o.set(options, 'enums.enumsAsTypeUnion', true);
+    if (argv.header) o.set(options, 'includeHeader', true);
+
+    console.log(chalk.blue('Parsing protobuf file...'));
+    const parser = new PgProtoParser(argv.inFile, options);
+    
+    console.log(chalk.blue('Generating TypeScript files...'));
+    await parser.write();
+    
+    console.log(chalk.green(`✓ Files generated in ${argv.outDir}`));
+  } catch (error: any) {
+    console.error(chalk.red('Proto generation error:'), error.message || error);
+    process.exit(1);
+  }
+}

package/src/commands/runtime-schema.ts

@@ -0,0 +1,74 @@
+import { PgProtoParser, PgProtoParserOptions, getOptionsWithDefaults } from 'pg-proto-parser';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { showHelp } from '../utils/help';
+
+export async function runtimeSchemaCommand(argv: any) {
+  if (argv.help) {
+    showHelp('runtime-schema');
+    process.exit(0);
+  }
+
+  if (!argv.inFile || !argv.outDir) {
+    console.error(chalk.red('Error: --inFile and --outDir are required'));
+    showHelp('runtime-schema');
+    process.exit(1);
+  }
+
+  const format = argv.format || 'json';
+  const filename = argv.filename || 'runtime-schema';
+
+  try {
+    console.log(chalk.blue('Parsing protobuf file...'));
+    
+    const options: PgProtoParserOptions = getOptionsWithDefaults({
+      outDir: argv.outDir
+    });
+
+    const parser = new PgProtoParser(argv.inFile, options);
+    
+    // Generate runtime schema
+    console.log(chalk.blue(`Generating runtime schema in ${format} format...`));
+    console.log(chalk.yellow('Warning: Runtime schema generation is not yet fully implemented'));
+    
+    // Generate placeholder schema based on format
+    let content: string;
+    let fileExt: string;
+    
+    if (format === 'typescript') {
+      // Generate TypeScript runtime schema placeholder
+      content = `// Runtime schema for PostgreSQL AST nodes
+// Generated from: ${argv.inFile}
+
+export interface RuntimeSchema {
+  // TODO: Implement runtime schema generation
+  nodes: Record<string, any>;
+}
+
+export const runtimeSchema: RuntimeSchema = {
+  nodes: {}
+};
+`;
+      fileExt = '.ts';
+    } else {
+      // Generate JSON runtime schema placeholder
+      content = JSON.stringify({
+        generated: new Date().toISOString(),
+        source: argv.inFile,
+        nodes: {}
+      }, null, 2);
+      fileExt = '.json';
+    }
+    
+    // Write file
+    const outputPath = join(argv.outDir, `${filename}${fileExt}`);
+    writeFileSync(outputPath, content);
+    
+    console.log(chalk.green(`✓ Runtime schema generated: ${outputPath}`));
+  } catch (error: any) {
+    console.error(chalk.red('Runtime schema error:'), error.message || error);
+    process.exit(1);
+  }
+}
+