@pgsql/cli 1.30.0

package/dist/esm/commands/proto-fetch.js

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import { showHelp } from '../utils/help';
+import { downloadProtoFile, generateProtoJS, replaceTextInProtoJS } from './proto-fetch/helpers';
+export async function protoFetchCommand(argv) {
+    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) {
+        console.error(chalk.red('Proto fetch error:'), error.message || error);
+        process.exit(1);
+    }
+}

package/dist/esm/commands/proto-gen.js

@@ -0,0 +1,53 @@
+import { PgProtoParser, getOptionsWithDefaults } from 'pg-proto-parser';
+import o from 'nested-obj';
+import chalk from 'chalk';
+import { showHelp } from '../utils/help';
+export async function protoGenCommand(argv) {
+    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 = 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) {
+        console.error(chalk.red('Proto generation error:'), error.message || error);
+        process.exit(1);
+    }
+}

package/dist/esm/commands/runtime-schema.js

@@ -0,0 +1,64 @@
+import { PgProtoParser, 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) {
+    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 = 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;
+        let fileExt;
+        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) {
+        console.error(chalk.red('Runtime schema error:'), error.message || error);
+        process.exit(1);
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import chalk from 'chalk';
+import { parseCommand } from './commands/parse';
+import { deparseCommand } from './commands/deparse';
+import { protoGenCommand } from './commands/proto-gen';
+import { protoFetchCommand } from './commands/proto-fetch';
+import { runtimeSchemaCommand } from './commands/runtime-schema';
+import { showHelp, showVersion } from './utils/help';
+const argv = minimist(process.argv.slice(2), {
+    alias: {
+        h: 'help',
+        v: 'version',
+        o: 'output',
+        f: 'format'
+    }
+});
+const command = argv._[0];
+async function main() {
+    try {
+        if (argv.version) {
+            showVersion();
+            process.exit(0);
+        }
+        if (!command || argv.help) {
+            showHelp(command);
+            process.exit(0);
+        }
+        switch (command) {
+            case 'parse':
+                await parseCommand(argv);
+                break;
+            case 'deparse':
+                await deparseCommand(argv);
+                break;
+            case 'proto-gen':
+                await protoGenCommand(argv);
+                break;
+            case 'proto-fetch':
+                await protoFetchCommand(argv);
+                break;
+            case 'runtime-schema':
+                await runtimeSchemaCommand(argv);
+                break;
+            default:
+                console.error(chalk.red(`Unknown command: ${command}`));
+                showHelp();
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error.message || error);
+        process.exit(1);
+    }
+}
+main();

package/dist/esm/package.js

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+// need to search due to the dist/ folder and src/, etc. 
+function findPackageJson(currentDir) {
+    const filePath = join(currentDir, 'package.json');
+    // Check if package.json exists in the current directory
+    if (existsSync(filePath)) {
+        return filePath;
+    }
+    // Get the parent directory
+    const parentDir = dirname(currentDir);
+    // If reached the root directory, package.json is not found
+    if (parentDir === currentDir) {
+        throw new Error('package.json not found in any parent directory');
+    }
+    // Recursively look in the parent directory
+    return findPackageJson(parentDir);
+}
+export function readAndParsePackageJson() {
+    // Start searching from the current directory
+    const pkgPath = findPackageJson(__dirname);
+    // Read and parse the package.json
+    const str = readFileSync(pkgPath, 'utf8');
+    const pkg = JSON.parse(str);
+    return pkg;
+}

package/dist/esm/utils/help.js

@@ -0,0 +1,190 @@
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+export function showVersion() {
+    // Try to find package.json in various locations
+    const possiblePaths = [
+        join(process.cwd(), 'package.json'),
+        join(process.argv[1], '../../package.json'),
+        join(process.argv[1], '../../../package.json')
+    ];
+    for (const path of possiblePaths) {
+        try {
+            const packageJson = JSON.parse(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');
+}
+export 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.bold('pgsql')} - Unified CLI for PostgreSQL AST operations
+
+${chalk.yellow('Usage:')}
+  pgsql <command> [options]
+
+${chalk.yellow('Commands:')}
+  ${chalk.green('parse')}           Parse SQL to AST
+  ${chalk.green('deparse')}         Convert AST to SQL
+  ${chalk.green('proto-gen')}       Generate TypeScript from protobuf
+  ${chalk.green('proto-fetch')}     Download and process proto files
+  ${chalk.green('runtime-schema')}  Generate runtime schema for AST nodes
+
+${chalk.yellow('Global Options:')}
+  -h, --help       Show help
+  -v, --version    Show version
+
+${chalk.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.bold('pgsql parse')} - Parse SQL to AST
+
+${chalk.yellow('Usage:')}
+  pgsql parse <sqlfile> [options]
+
+${chalk.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.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.bold('pgsql deparse')} - Convert AST to SQL
+
+${chalk.yellow('Usage:')}
+  pgsql deparse [options]
+
+${chalk.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.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.bold('pgsql proto-gen')} - Generate TypeScript from protobuf
+
+${chalk.yellow('Usage:')}
+  pgsql proto-gen --inFile <proto> --outDir <dir> [options]
+
+${chalk.yellow('Required Options:')}
+  --inFile <file>        Input .proto file
+  --outDir <dir>         Output directory
+
+${chalk.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.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.bold('pgsql proto-fetch')} - Download and process proto files
+
+${chalk.yellow('Usage:')}
+  pgsql proto-fetch [options]
+
+${chalk.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.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.bold('pgsql runtime-schema')} - Generate runtime schema for AST nodes
+
+${chalk.yellow('Usage:')}
+  pgsql runtime-schema --inFile <proto> --outDir <dir> [options]
+
+${chalk.yellow('Required Options:')}
+  --inFile <file>        Input .proto file
+  --outDir <dir>         Output directory
+
+${chalk.yellow('Optional Options:')}
+  --format <format>      Output format: json, typescript (default: json)
+  --filename <name>      Output filename (default: runtime-schema)
+  -h, --help            Show help
+
+${chalk.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/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const minimist_1 = __importDefault(require("minimist"));
+const chalk_1 = __importDefault(require("chalk"));
+const parse_1 = require("./commands/parse");
+const deparse_1 = require("./commands/deparse");
+const proto_gen_1 = require("./commands/proto-gen");
+const proto_fetch_1 = require("./commands/proto-fetch");
+const runtime_schema_1 = require("./commands/runtime-schema");
+const help_1 = require("./utils/help");
+const argv = (0, minimist_1.default)(process.argv.slice(2), {
+    alias: {
+        h: 'help',
+        v: 'version',
+        o: 'output',
+        f: 'format'
+    }
+});
+const command = argv._[0];
+async function main() {
+    try {
+        if (argv.version) {
+            (0, help_1.showVersion)();
+            process.exit(0);
+        }
+        if (!command || argv.help) {
+            (0, help_1.showHelp)(command);
+            process.exit(0);
+        }
+        switch (command) {
+            case 'parse':
+                await (0, parse_1.parseCommand)(argv);
+                break;
+            case 'deparse':
+                await (0, deparse_1.deparseCommand)(argv);
+                break;
+            case 'proto-gen':
+                await (0, proto_gen_1.protoGenCommand)(argv);
+                break;
+            case 'proto-fetch':
+                await (0, proto_fetch_1.protoFetchCommand)(argv);
+                break;
+            case 'runtime-schema':
+                await (0, runtime_schema_1.runtimeSchemaCommand)(argv);
+                break;
+            default:
+                console.error(chalk_1.default.red(`Unknown command: ${command}`));
+                (0, help_1.showHelp)();
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Error:'), error.message || error);
+        process.exit(1);
+    }
+}
+main();

package/dist/package.d.ts

@@ -0,0 +1 @@
+export declare function readAndParsePackageJson(): any;

package/dist/package.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAndParsePackageJson = readAndParsePackageJson;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// need to search due to the dist/ folder and src/, etc. 
+function findPackageJson(currentDir) {
+    const filePath = (0, path_1.join)(currentDir, 'package.json');
+    // Check if package.json exists in the current directory
+    if ((0, fs_1.existsSync)(filePath)) {
+        return filePath;
+    }
+    // Get the parent directory
+    const parentDir = (0, path_1.dirname)(currentDir);
+    // If reached the root directory, package.json is not found
+    if (parentDir === currentDir) {
+        throw new Error('package.json not found in any parent directory');
+    }
+    // Recursively look in the parent directory
+    return findPackageJson(parentDir);
+}
+function readAndParsePackageJson() {
+    // Start searching from the current directory
+    const pkgPath = findPackageJson(__dirname);
+    // Read and parse the package.json
+    const str = (0, fs_1.readFileSync)(pkgPath, 'utf8');
+    const pkg = JSON.parse(str);
+    return pkg;
+}

package/dist/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/dist/utils/help.d.ts

@@ -0,0 +1,2 @@
+export declare function showVersion(): void;
+export declare function showHelp(command?: string): void;