@pgsql/cli 1.30.0

package/dist/commands/deparse.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deparseCommand = deparseCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pgsql_deparser_1 = require("pgsql-deparser");
+const chalk_1 = __importDefault(require("chalk"));
+const help_1 = require("../utils/help");
+async function deparseCommand(argv) {
+    if (argv.help) {
+        (0, help_1.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
+                : (0, path_1.resolve)((0, path_1.join)(process.cwd(), inputFile));
+            const content = (0, fs_1.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_1.default.red('Error: No input provided. Use -i <file> or pipe input via stdin'));
+            (0, help_1.showHelp)('deparse');
+            process.exit(1);
+        }
+        // Deparse AST to SQL
+        const sql = await (0, pgsql_deparser_1.deparse)(ast);
+        // Write output
+        if (argv.output || argv.o) {
+            const outputFile = argv.output || argv.o;
+            (0, fs_1.writeFileSync)(outputFile, sql);
+            console.log(chalk_1.default.green(`✓ SQL written to ${outputFile}`));
+        }
+        else {
+            process.stdout.write(sql);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            console.error(chalk_1.default.red(`Error: File not found: ${argv.input || argv.i}`));
+        }
+        else if (error instanceof SyntaxError) {
+            console.error(chalk_1.default.red('Error: Invalid JSON input'));
+        }
+        else {
+            console.error(chalk_1.default.red('Deparse error:'), error.message || error);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/parse.d.ts

@@ -0,0 +1 @@
+export declare function parseCommand(argv: any): Promise<void>;

package/dist/commands/parse.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = parseCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pgsql_parser_1 = require("pgsql-parser");
+const chalk_1 = __importDefault(require("chalk"));
+const help_1 = require("../utils/help");
+async function parseCommand(argv) {
+    if (argv.help) {
+        (0, help_1.showHelp)('parse');
+        process.exit(0);
+    }
+    const sqlFile = argv._[1];
+    if (!sqlFile) {
+        console.error(chalk_1.default.red('Error: SQL file required'));
+        (0, help_1.showHelp)('parse');
+        process.exit(1);
+    }
+    try {
+        // Resolve file path
+        const filePath = sqlFile.startsWith('/')
+            ? sqlFile
+            : (0, path_1.resolve)((0, path_1.join)(process.cwd(), sqlFile));
+        // Read SQL content
+        const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        // Parse SQL
+        const ast = await (0, pgsql_parser_1.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_1.default.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) {
+            (0, fs_1.writeFileSync)(argv.output, output);
+            console.log(chalk_1.default.green(`✓ AST written to ${argv.output}`));
+        }
+        else {
+            process.stdout.write(output);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            console.error(chalk_1.default.red(`Error: File not found: ${sqlFile}`));
+        }
+        else {
+            console.error(chalk_1.default.red('Parse error:'), error.message || error);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/proto-fetch/cli.d.ts

@@ -0,0 +1,14 @@
+export interface CommandOptions {
+    help?: boolean;
+    h?: boolean;
+    version?: boolean;
+    v?: boolean;
+    protoUrl?: string;
+    inFile: string;
+    outFile: string;
+    originalPackageName: string;
+    newPackageName: string;
+}
+export declare const help: () => void;
+declare const _default: (argv: CommandOptions) => Promise<CommandOptions>;
+export default _default;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = void 0;
+const helpers_1 = require("./helpers");
+const help = () => {
+    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.
+  `);
+};
+exports.help = help;
+exports.default = async (argv) => {
+    try {
+        if (argv.protoUrl) {
+            await (0, helpers_1.downloadProtoFile)(argv.protoUrl, argv.inFile);
+        }
+        await (0, helpers_1.generateProtoJS)(argv.inFile, argv.outFile);
+        await (0, helpers_1.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/dist/commands/proto-fetch/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare const downloadProtoFile: (protoUrl: string, filePath: string) => Promise<void>;
+export declare const generateProtoJS: (inFile: string, outFile: string) => Promise<void>;
+export declare const replaceTextInProtoJS: (filePath: string, originalPackage: string, newPackage: string) => Promise<void>;

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

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceTextInProtoJS = exports.generateProtoJS = exports.downloadProtoFile = void 0;
+const https_1 = __importDefault(require("https"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const mkdirp_1 = require("mkdirp");
+const path_1 = require("path");
+// Download .proto file if URL
+const downloadProtoFile = (protoUrl, filePath) => {
+    (0, mkdirp_1.sync)((0, path_1.dirname)(filePath));
+    return new Promise((resolve, reject) => {
+        https_1.default.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_1.default.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_1.default.unlink(filePath, () => { }); // Delete the file async. (No need to check error here)
+            reject(err);
+        });
+    });
+};
+exports.downloadProtoFile = downloadProtoFile;
+// Generate JavaScript from proto file using pbjs
+const generateProtoJS = (inFile, outFile) => new Promise((resolve, reject) => {
+    const command = `pbjs --keep-case -t static-module -o ${outFile} ${inFile}`;
+    (0, mkdirp_1.sync)((0, path_1.dirname)(outFile));
+    (0, child_process_1.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();
+    });
+});
+exports.generateProtoJS = generateProtoJS;
+// Replace text in generated JS file
+const replaceTextInProtoJS = (filePath, originalPackage, newPackage) => new Promise((resolve, reject) => {
+    fs_1.default.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_1.default.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();
+        });
+    });
+});
+exports.replaceTextInProtoJS = replaceTextInProtoJS;

package/dist/commands/proto-fetch.d.ts

@@ -0,0 +1 @@
+export declare function protoFetchCommand(argv: any): Promise<void>;

package/dist/commands/proto-fetch.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protoFetchCommand = protoFetchCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const help_1 = require("../utils/help");
+const helpers_1 = require("./proto-fetch/helpers");
+async function protoFetchCommand(argv) {
+    if (argv.help) {
+        (0, help_1.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_1.default.red('Error: --inFile and --outFile are required'));
+        (0, help_1.showHelp)('proto-fetch');
+        process.exit(1);
+    }
+    try {
+        if (url) {
+            console.log(chalk_1.default.blue(`Downloading proto file from ${url}...`));
+            await (0, helpers_1.downloadProtoFile)(url, inFile);
+            console.log(chalk_1.default.green(`✓ Proto file saved to ${inFile}`));
+        }
+        console.log(chalk_1.default.blue('Generating JavaScript from proto file...'));
+        await (0, helpers_1.generateProtoJS)(inFile, outFile);
+        console.log(chalk_1.default.blue(`Replacing package references...`));
+        await (0, helpers_1.replaceTextInProtoJS)(outFile, replacePkg, withPkg);
+        console.log(chalk_1.default.green(`✓ All operations completed successfully`));
+        console.log(chalk_1.default.green(`✓ Generated file: ${outFile}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Proto fetch error:'), error.message || error);
+        process.exit(1);
+    }
+}

package/dist/commands/proto-gen.d.ts

@@ -0,0 +1 @@
+export declare function protoGenCommand(argv: any): Promise<void>;

package/dist/commands/proto-gen.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protoGenCommand = protoGenCommand;
+const pg_proto_parser_1 = require("pg-proto-parser");
+const nested_obj_1 = __importDefault(require("nested-obj"));
+const chalk_1 = __importDefault(require("chalk"));
+const help_1 = require("../utils/help");
+async function protoGenCommand(argv) {
+    if (argv.help) {
+        (0, help_1.showHelp)('proto-gen');
+        process.exit(0);
+    }
+    if (!argv.inFile || !argv.outDir) {
+        console.error(chalk_1.default.red('Error: --inFile and --outDir are required'));
+        (0, help_1.showHelp)('proto-gen');
+        process.exit(1);
+    }
+    try {
+        const options = (0, pg_proto_parser_1.getOptionsWithDefaults)({
+            outDir: argv.outDir
+        });
+        // Set options based on flags
+        if (argv.enums)
+            nested_obj_1.default.set(options, 'enums.enabled', true);
+        if (argv['enums-json'])
+            nested_obj_1.default.set(options, 'enums.json.enabled', true);
+        if (argv.types)
+            nested_obj_1.default.set(options, 'types.enabled', true);
+        if (argv.utils)
+            nested_obj_1.default.set(options, 'utils.enums.enabled', true);
+        if (argv['ast-helpers'])
+            nested_obj_1.default.set(options, 'utils.astHelpers.enabled', true);
+        if (argv['wrapped-helpers'])
+            nested_obj_1.default.set(options, 'utils.wrappedAstHelpers.enabled', true);
+        if (argv.optional)
+            nested_obj_1.default.set(options, 'types.optionalFields', true);
+        if (argv['keep-case'])
+            nested_obj_1.default.set(options, 'parser.keepCase', true);
+        if (argv['remove-undefined'])
+            nested_obj_1.default.set(options, 'enums.removeUndefinedAt0', true);
+        // Additional options that might be useful
+        if (argv['type-union'])
+            nested_obj_1.default.set(options, 'enums.enumsAsTypeUnion', true);
+        if (argv.header)
+            nested_obj_1.default.set(options, 'includeHeader', true);
+        console.log(chalk_1.default.blue('Parsing protobuf file...'));
+        const parser = new pg_proto_parser_1.PgProtoParser(argv.inFile, options);
+        console.log(chalk_1.default.blue('Generating TypeScript files...'));
+        await parser.write();
+        console.log(chalk_1.default.green(`✓ Files generated in ${argv.outDir}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Proto generation error:'), error.message || error);
+        process.exit(1);
+    }
+}

package/dist/commands/runtime-schema.d.ts

@@ -0,0 +1 @@
+export declare function runtimeSchemaCommand(argv: any): Promise<void>;

package/dist/commands/runtime-schema.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeSchemaCommand = runtimeSchemaCommand;
+const pg_proto_parser_1 = require("pg-proto-parser");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
+const help_1 = require("../utils/help");
+async function runtimeSchemaCommand(argv) {
+    if (argv.help) {
+        (0, help_1.showHelp)('runtime-schema');
+        process.exit(0);
+    }
+    if (!argv.inFile || !argv.outDir) {
+        console.error(chalk_1.default.red('Error: --inFile and --outDir are required'));
+        (0, help_1.showHelp)('runtime-schema');
+        process.exit(1);
+    }
+    const format = argv.format || 'json';
+    const filename = argv.filename || 'runtime-schema';
+    try {
+        console.log(chalk_1.default.blue('Parsing protobuf file...'));
+        const options = (0, pg_proto_parser_1.getOptionsWithDefaults)({
+            outDir: argv.outDir
+        });
+        const parser = new pg_proto_parser_1.PgProtoParser(argv.inFile, options);
+        // Generate runtime schema
+        console.log(chalk_1.default.blue(`Generating runtime schema in ${format} format...`));
+        console.log(chalk_1.default.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 = (0, path_1.join)(argv.outDir, `${filename}${fileExt}`);
+        (0, fs_1.writeFileSync)(outputPath, content);
+        console.log(chalk_1.default.green(`✓ Runtime schema generated: ${outputPath}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Runtime schema error:'), error.message || error);
+        process.exit(1);
+    }
+}

package/dist/esm/commands/deparse.js

@@ -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) {
+    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) {
+        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/dist/esm/commands/parse.js

@@ -0,0 +1,54 @@
+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) {
+    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) {
+        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/dist/esm/commands/proto-fetch/cli.js

@@ -0,0 +1,37 @@
+import { downloadProtoFile, generateProtoJS, replaceTextInProtoJS } from './helpers';
+export const help = () => {
+    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) => {
+    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/dist/esm/commands/proto-fetch/helpers.js

@@ -0,0 +1,64 @@
+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, filePath) => {
+    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, outFile) => 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, originalPackage, newPackage) => 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();
+        });
+    });
+});