@arifwidianto/rpc-agent
Version:
RPC Agent for both client and server, extends more methods easily
230 lines (228 loc) • 8.46 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const inquirer_1 = __importDefault(require("inquirer"));
const path = __importStar(require("path"));
const fs = __importStar(require("fs-extra"));
const schema_generator_1 = require("./utils/schema-generator");
const DEFAULT_EXTENSION_TEMPLATE = `import { Extension, ExtensionStatus, ExtensionConfig, ExtensionMetadata, ExtensionMethod } from "@arifwidianto/rpc-agent"
export default class {className} implements Extension {
readonly name = "{extensionName}"
readonly status: ExtensionStatus = "active" as const
readonly config: ExtensionConfig = { enabled: true }
readonly metadata: ExtensionMetadata = {
name: this.name,
version: "1.0.0",
author: "RPC Agent",
description: "{extensionDescription}",
}
methods: Record<string, ExtensionMethod> = {
async sum(args: { a: number; b: number }): Promise<{ result: number }> {
const { a, b } = args;
return { result: a + b };
}
}
}`;
async function generateNewExtension(extensionsDir, extensionName) {
const extensionDirPath = path.join(process.cwd(), extensionsDir, extensionName);
const indexFilePath = path.join(extensionDirPath, "index.ts");
try {
await fs.ensureDir(extensionDirPath);
const className = extensionName
.split("-")
.reduce((acc, word) => {
if (word.includes("-")) {
acc.push(...word.split("-"));
}
else {
acc.push(word);
}
return acc;
}, [])
.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
.join("")
.concat("Extension");
const extensionDescription = `Place the ${className} (${extensionName}) description here.`;
const extensionContent = DEFAULT_EXTENSION_TEMPLATE.replace("{className}", `${className}`)
.replace("{extensionName}", extensionName)
.replace("{extensionDescription}", extensionDescription);
await fs.writeFile(indexFilePath, extensionContent);
console.log(`✅ Successfully generated extension "${extensionName}" at ${extensionDirPath}`);
return extensionDirPath;
}
catch (error) {
console.error("❌ Error generating extension:", error);
process.exit(1);
}
}
async function promptForExtensionPath() {
const { extensionPath } = await inquirer_1.default.prompt([
{
type: "input",
name: "extensionPath",
message: "Enter extension entry point path (index.ts):",
default: "./src/rpcs/index.ts",
validate: (input) => {
if (!input.endsWith(".ts")) {
return "Extension entry point must be a TypeScript file";
}
return true;
},
},
]);
return path.resolve(process.cwd(), extensionPath);
}
async function promptForExtensionDetails(defaultDir, defaultName) {
const questions = [];
if (!defaultDir) {
questions.push({
type: "input",
name: "extensionsDir",
message: "Enter extensions directory path:",
default: "./src/rpcs",
});
}
if (!defaultName) {
questions.push({
type: "input",
name: "extensionName",
message: "Enter extension name:",
validate: (input) => {
if (!input.match(/^[a-zA-Z0-9-]+$/)) {
return "Extension name can only contain letters, numbers, and hyphens";
}
return true;
},
});
}
const answers = await inquirer_1.default.prompt(questions);
return {
dir: defaultDir || answers.extensionsDir,
name: defaultName || answers.extensionName,
};
}
async function generateSchema(extensionPath) {
try {
const generator = new schema_generator_1.SchemaGenerator();
await generator.generateSchema(extensionPath);
console.log("✅ Schema generated successfully!");
}
catch (error) {
console.error("❌ Failed to generate schema:", error);
process.exit(1);
}
}
async function handleGenerateSchema(args) {
let extensionPath;
if (args.length >= 1) {
extensionPath = path.resolve(process.cwd(), args[0]);
console.log("Using provided extension path:", extensionPath);
}
else {
extensionPath = await promptForExtensionPath();
}
await generateSchema(extensionPath);
}
async function handleGenerateExtension(args) {
let extensionsDir;
let extensionName;
if (args.length >= 2) {
extensionsDir = args[0];
extensionName = args[1];
console.log("Using provided directory and name:", { extensionsDir, extensionName });
}
else if (args.length === 1) {
extensionsDir = args[0];
console.log("Using provided directory:", extensionsDir);
}
const details = await promptForExtensionDetails(extensionsDir, extensionName);
const extensionPath = await generateNewExtension(details.dir, details.name);
const { generateSchema: shouldGenerateSchema } = await inquirer_1.default.prompt([
{
type: "confirm",
name: "generateSchema",
message: "Would you like to generate a schema for this extension?",
default: true,
},
]);
if (shouldGenerateSchema) {
await generateSchema(path.join(extensionPath, "index.ts"));
}
}
async function main() {
try {
const args = process.argv.slice(2);
const command = args[0]?.toLowerCase();
if (command) {
switch (command) {
case "generate-extension":
case "ge":
await handleGenerateExtension(args.slice(1));
break;
case "generate-schema":
case "gs":
await handleGenerateSchema(args.slice(1));
break;
default:
console.error("❌ Unknown command. Available commands: generate-extension (ge), generate-schema (gs)");
process.exit(1);
}
return;
}
const answers = await inquirer_1.default.prompt([
{
type: "list",
name: "action",
message: "What would you like to do?",
choices: [
{ name: "Generate Extension", value: "generate-extension" },
{ name: "Generate Schema", value: "generate-schema" },
{ name: "Exit", value: "exit" },
],
},
]);
switch (answers.action) {
case "generate-extension":
await handleGenerateExtension([]);
break;
case "generate-schema":
await handleGenerateSchema([]);
break;
case "exit":
console.log("👋 Goodbye!");
break;
}
}
catch (error) {
console.error("❌ An error occurred:", error);
process.exit(1);
}
}
main();
//# sourceMappingURL=cli.js.map