@apso/cli 0.7.4 → 0.8.2

package/dist/autogen/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: never[];
+export default _default;

package/dist/autogen/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [];

package/dist/commands/server/new.d.ts

@@ -1,4 +1,5 @@
 import BaseCommand from "../../lib/base-command";
+import { TargetLanguage } from "../../lib/types";
 export default class New extends BaseCommand {
     static description: string;
     static examples: string[];
@@ -6,6 +7,7 @@ export default class New extends BaseCommand {
     static flags: {
         name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        language: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };
     static args: {
         name: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
@@ -13,10 +15,11 @@ export default class New extends BaseCommand {
     installModules(projectPath: string): Promise<void>;
     formatApp(projectPath: string): Promise<void>;
     startApp(projectPath: string): Promise<void>;
-    cloneTemplate(projectPath: string): Promise<void>;
+    cloneTemplate(projectPath: string, language: TargetLanguage): Promise<void>;
     validateFlags(): Promise<{
         projectName: string;
         apiType: string;
+        language: TargetLanguage;
     }>;
     run(): Promise<void>;
 }

package/dist/commands/server/new.js

@@ -5,8 +5,15 @@ const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
 const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
 const base_command_1 = tslib_1.__importDefault(require("../../lib/base-command"));
 const path = tslib_1.__importStar(require("path"));
+const TEMPLATE_REPOS = {
+    typescript: "https://github.com/apsoai/service-template.git",
+    python: "https://github.com/apsoai/service-template-python.git",
+    go: "https://github.com/apsoai/service-template-go.git",
+};
+const PROJECT_NAME_PATTERN = /^[A-Za-z][\w-]*$/;
 class New extends base_command_1.default {
     constructor() {
         super(...arguments);
@@ -46,33 +53,63 @@ class New extends base_command_1.default {
             });
         });
     }
-    async cloneTemplate(projectPath) {
-        this.log("Cloning service template...");
-        if (!fs.existsSync(projectPath) && this.CURR_DIR !== projectPath) {
-            fs.mkdirSync(projectPath);
+    async cloneTemplate(projectPath, language) {
+        const repoUrl = TEMPLATE_REPOS[language];
+        this.log(`Cloning ${language} service template...`);
+        // Create directory if it doesn't exist
+        if (fs.existsSync(projectPath)) {
+            this.error(`Directory already exists: ${projectPath}`);
         }
-        shelljs_1.default.cd(projectPath);
-        const cloneResult = shelljs_1.default.exec(`git clone --depth=1 --branch=main https://github.com/apsoai/service-template.git ${projectPath}`, { silent: true }); // Use silent: true to suppress default output
+        else {
+            try {
+                fs.mkdirSync(projectPath, { recursive: true });
+            }
+            catch (error) {
+                this.error(`Failed to create directory: ${error.message}`);
+            }
+        }
+        // Use quoted paths to prevent command injection
+        const cloneResult = shelljs_1.default.exec(`git clone --depth=1 --branch=main "${repoUrl}" "${projectPath}"`, { silent: true });
         // Check if the command failed
         if (cloneResult.code !== 0) {
-            // Provide a more generic error message for clone failures
+            // Clean up the failed directory
+            shelljs_1.default.rm("-rf", projectPath);
             this.error(`Failed to clone the template repository from GitHub.\n` +
                 `Error Output:\n${cloneResult.stderr}\n\n` +
-                `Please check your network connection and ensure the repository exists at https://github.com/apsoai/service-template.git\n\n` +
-                `If the problem persists, please remove the partially created directory "${projectPath}" and try again.`);
-            // Throwing error via this.error will stop execution
+                `Please check your network connection and ensure the repository exists at ${repoUrl}`);
         }
-        // If clone was successful, proceed to remove the .git directory
-        shelljs_1.default.exec(`rm -rf ${projectPath}/.git`);
-        shelljs_1.default.cd(this.CURR_DIR);
+        // If clone was successful, proceed to remove the .git directory using safe shelljs method
+        shelljs_1.default.rm("-rf", path.join(projectPath, ".git"));
     }
     async validateFlags() {
         var _a;
         const { flags } = await this.parse(New);
         let projectName = flags.name;
         let apiType = (_a = flags.type) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        let language = flags.language;
+        // Prompt for project name if not provided
         if (!projectName) {
-            projectName = "";
+            const response = await inquirer_1.default.prompt([
+                {
+                    type: "input",
+                    name: "projectName",
+                    message: "Enter your project name:",
+                    validate: (input) => {
+                        if (!input.trim()) {
+                            return "Project name is required";
+                        }
+                        if (!PROJECT_NAME_PATTERN.test(input)) {
+                            return "Project name must start with a letter and contain only letters, numbers, hyphens, and underscores";
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            projectName = response.projectName;
+        }
+        // Validate project name format (security: prevent command injection and path traversal)
+        if (!projectName || !PROJECT_NAME_PATTERN.test(projectName)) {
+            this.error("Project name must start with a letter and contain only letters, numbers, hyphens, and underscores");
         }
         if (!apiType) {
             apiType = "rest";
@@ -80,20 +117,71 @@ class New extends base_command_1.default {
         if (!["rest", "graphql"].includes(apiType)) {
             this.error("`apiType` must be 'rest' or 'graphql'");
         }
-        return { projectName, apiType };
+        // Prompt for language if not provided
+        if (!language) {
+            const response = await inquirer_1.default.prompt([
+                {
+                    type: "list",
+                    name: "language",
+                    message: "Select your target language:",
+                    choices: [
+                        { name: "TypeScript", value: "typescript" },
+                        { name: "Python", value: "python" },
+                        { name: "Go", value: "go" },
+                    ],
+                    default: "typescript",
+                },
+            ]);
+            language = response.language;
+        }
+        return { projectName: projectName, apiType, language };
     }
     async run() {
+        // Check for required dependencies
+        if (!shelljs_1.default.which("git")) {
+            this.error("git is required but not found. Please install git and try again.");
+        }
         this.log("Initializing New Apso Server...");
-        const { projectName } = await this.validateFlags();
-        const CURR_DIR = process.cwd();
-        const projectPath = path.join(CURR_DIR, projectName);
-        await this.cloneTemplate(projectPath);
-        await this.installModules(projectPath);
-        await this.formatApp(projectPath);
+        const { projectName, language } = await this.validateFlags();
+        const projectPath = path.join(this.CURR_DIR, projectName);
+        // Validate the resolved path is within current directory (prevent path traversal)
+        const resolvedPath = path.resolve(projectPath);
+        if (!resolvedPath.startsWith(path.resolve(this.CURR_DIR))) {
+            this.error("Invalid project name: path traversal detected");
+        }
+        await this.cloneTemplate(projectPath, language);
+        // Language-specific setup
+        switch (language) {
+            case "typescript": {
+                if (shelljs_1.default.which("npm")) {
+                    await this.installModules(projectPath);
+                    await this.formatApp(projectPath);
+                }
+                else {
+                    this.log("Warning: npm not found. Skipping module installation.");
+                }
+                break;
+            }
+            case "python": {
+                this.log("Python project created. Run 'pip install -e .[dev]' to install dependencies.");
+                break;
+            }
+            case "go": {
+                this.log("Go project created. Run 'go mod tidy' to install dependencies.");
+                break;
+            }
+            // No default
+        }
+        this.log(`\nProject created at ${projectPath}`);
+        this.log(`Language: ${language}`);
     }
 }
 New.description = "Initialize your server project";
-New.examples = [`$ apso server new --name TestProject`];
+New.examples = [
+    `$ apso server new --name TestProject`,
+    `$ apso server new --name TestProject --language python`,
+    `$ apso server new --name TestProject --language go`,
+];
 New.flags = {
     name: core_1.Flags.string({
         char: "n",
@@ -103,6 +191,11 @@ New.flags = {
         char: "t",
         description: "api type (rest or graphql)",
     }),
+    language: core_1.Flags.string({
+        char: "l",
+        description: "target language (typescript, python, go)",
+        options: ["typescript", "python", "go"],
+    }),
 };
 New.args = { name: core_1.Args.string() };
 exports.default = New;

package/dist/commands/server/scaffold.d.ts

@@ -6,6 +6,7 @@ export default class Scaffold extends BaseCommand {
     static flags: {
         help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
         "skip-format": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        language: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };
     static args: {};
     scaffoldServer(options: {
@@ -18,4 +19,13 @@ export default class Scaffold extends BaseCommand {
     setupRestFiles(dir: string, entity: Entity, relationshipMap: RelationshipMap, apiType: string, allEntities: Entity[]): Promise<void>;
     setupGraphqlFiles(dir: string, entity: Entity, relationshipMap: RelationshipMap): Promise<void>;
     run(): Promise<void>;
+    /**
+     * Scaffolds TypeScript code using the existing code path (for backward compatibility)
+     */
+    private scaffoldTypeScript;
+    /**
+     * Scaffolds code using the new generator system (for Python, Go, and future languages)
+     * Note: Sequential file operations are intentional to provide progress feedback
+     */
+    private scaffoldWithGenerator;
 }

package/dist/commands/server/scaffold.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const path = tslib_1.__importStar(require("path"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
 const lib_1 = require("../../lib");
 const base_command_1 = tslib_1.__importDefault(require("../../lib/base-command"));
 const apsorc_parser_1 = require("../../lib/apsorc-parser");
 const perf_hooks_1 = require("perf_hooks");
 const Eta = tslib_1.__importStar(require("eta"));
+const file_system_1 = require("../../lib/utils/file-system");
 Eta.configure({
     views: path.join(__dirname, "../../lib/templates"),
     cache: false,
@@ -80,18 +82,83 @@ class Scaffold extends base_command_1.default {
         const { flags } = await this.parse(Scaffold);
         const skipFormat = flags["skip-format"];
         const totalBuildStart = perf_hooks_1.performance.now();
-        const { rootFolder, entities, relationshipMap, apiType, auth } = (0, lib_1.parseApsorc)();
+        const { rootFolder, entities, relationshipMap, apiType, auth, language: configLanguage } = (0, lib_1.parseApsorc)();
+        // Resolve language: flag > .apsorc > prompt
+        let language;
+        if (flags.language) {
+            language = flags.language;
+        }
+        else if (configLanguage && (0, lib_1.isLanguageSupported)(configLanguage)) {
+            language = configLanguage;
+            console.log(`[apso] Using language from .apsorc: ${language}`);
+        }
+        else {
+            // Prompt the user
+            const implementedLanguages = (0, lib_1.getImplementedLanguages)();
+            const { selectedLanguage } = await inquirer_1.default.prompt([
+                {
+                    type: "list",
+                    name: "selectedLanguage",
+                    message: "Select target language for code generation:",
+                    choices: implementedLanguages.map((lang) => ({
+                        name: lang === "typescript" ? "TypeScript (NestJS + TypeORM)" :
+                            lang === "python" ? "Python (FastAPI + SQLAlchemy)" :
+                                "Go (Gin + GORM)",
+                        value: lang,
+                    })),
+                    default: "typescript",
+                },
+            ]);
+            language = selectedLanguage;
+        }
+        // Validate language support
+        if (!(0, lib_1.isLanguageSupported)(language)) {
+            this.error(`Unsupported language: ${language}. Supported: typescript, python, go`);
+        }
+        const implementedLanguages = (0, lib_1.getImplementedLanguages)();
+        if (!implementedLanguages.includes(language)) {
+            this.error(`Language '${language}' is not yet implemented. Currently available: ${implementedLanguages.join(", ")}`);
+        }
         const rootPath = path.join(process.cwd(), rootFolder);
         const autogenPath = path.join(rootPath, "autogen");
         const lowerCaseApiType = apiType.toLowerCase();
-        await (0, lib_1.createEnums)(autogenPath, entities, lowerCaseApiType);
+        console.log(`[apso] Generating ${language} code for ${entities.length} entities...`);
+        // For TypeScript, use the existing code path (for backward compatibility)
+        // For other languages, use the new generator system
+        await (language === "typescript" ? this.scaffoldTypeScript({
+            autogenPath,
+            rootPath,
+            entities,
+            relationshipMap,
+            apiType: lowerCaseApiType,
+            auth,
+            skipFormat,
+        }) : this.scaffoldWithGenerator({
+            language,
+            rootFolder,
+            autogenPath,
+            entities,
+            relationshipMap,
+            apiType: lowerCaseApiType,
+            auth,
+            skipFormat,
+        }));
+        const totalBuildTime = perf_hooks_1.performance.now() - totalBuildStart;
+        console.log(`[apso] Finished building all entities in ${totalBuildTime.toFixed(2)} ms`);
+    }
+    /**
+     * Scaffolds TypeScript code using the existing code path (for backward compatibility)
+     */
+    async scaffoldTypeScript(options) {
+        const { autogenPath, rootPath, entities, relationshipMap, apiType, auth, skipFormat } = options;
+        await (0, lib_1.createEnums)(autogenPath, entities, apiType);
         await Promise.all(entities.map(async (entity) => {
             const scaffoldModel = this.scaffoldServer.bind(this);
             await scaffoldModel({
                 dir: autogenPath,
                 entity,
                 relationshipMap,
-                apiType: lowerCaseApiType,
+                apiType,
                 allEntities: entities,
             });
             if (process.env.DEBUG) {
@@ -103,29 +170,152 @@ class Scaffold extends base_command_1.default {
         }));
         // Generate guards (auth and/or scope) based on .apsorc configuration
         await (0, lib_1.createGuards)(rootPath, entities, auth);
-        await (0, lib_1.createIndexAppModule)(autogenPath, entities, lowerCaseApiType);
-        const totalBuildTime = perf_hooks_1.performance.now() - totalBuildStart;
-        console.log(`[apso] Finished building all entities in ${totalBuildTime.toFixed(2)} ms`);
-        if (!skipFormat) {
+        await (0, lib_1.createIndexAppModule)(autogenPath, entities, apiType);
+        if (skipFormat) {
+            console.log("[apso] Skipping formatting (--skip-format flag set)");
+        }
+        else {
             const formatStart = perf_hooks_1.performance.now();
             console.log("[apso] Formatting files...");
             await this.runNpmCommand(["run", "format", "src/autogen/**/*.ts", "src/guards/**/*.ts"], true);
             const formatTime = perf_hooks_1.performance.now() - formatStart;
             console.log(`[apso] Finished formatting in ${formatTime.toFixed(2)} ms`);
         }
-        else {
-            console.log("[apso] Skipping formatting (--skip-format flag set)");
+    }
+    /**
+     * Scaffolds code using the new generator system (for Python, Go, and future languages)
+     * Note: Sequential file operations are intentional to provide progress feedback
+     */
+    /* eslint-disable no-await-in-loop */
+    async scaffoldWithGenerator(options) {
+        const { language, rootFolder, autogenPath, entities, relationshipMap, apiType, auth } = options;
+        // Create generator configuration
+        const generatorConfig = {
+            language,
+            rootFolder,
+            apiType,
+            entities,
+            relationshipMap,
+            auth,
+        };
+        // Create the appropriate generator
+        const generator = (0, lib_1.createGenerator)(generatorConfig);
+        // Validate configuration
+        const validationResult = generator.validateConfig(generatorConfig);
+        if (!validationResult.valid) {
+            this.error(`Configuration validation failed:\n${validationResult.errors.join("\n")}`);
+        }
+        if (validationResult.warnings.length > 0) {
+            console.log(`[apso] Warnings:\n${validationResult.warnings.join("\n")}`);
+        }
+        // Generate enums
+        const enumFiles = await generator.generateEnums(entities, apiType);
+        for (const file of enumFiles) {
+            const fullPath = path.join(autogenPath, file.path);
+            await (0, file_system_1.createFile)(fullPath, file.content);
+            console.log(`[apso] Generated ${fullPath}`);
+        }
+        // Generate files for each entity
+        for (const entity of entities) {
+            console.log(`[apso] Building... ${entity.name}`);
+            const entityBuildStart = perf_hooks_1.performance.now();
+            const entityRelationships = relationshipMap[entity.name] || [];
+            // Generate entity files
+            const entityFiles = await generator.generateEntity({
+                entity,
+                relationships: entityRelationships,
+                allEntities: entities,
+                apiType,
+            });
+            for (const file of entityFiles) {
+                const fullPath = path.join(autogenPath, file.path);
+                await (0, file_system_1.createFile)(fullPath, file.content);
+            }
+            // Generate DTO files
+            const dtoFiles = await generator.generateDto({
+                entity,
+                relationships: entityRelationships,
+                allEntities: entities,
+                apiType,
+            });
+            for (const file of dtoFiles) {
+                const fullPath = path.join(autogenPath, file.path);
+                await (0, file_system_1.createFile)(fullPath, file.content);
+            }
+            // Generate service files
+            const serviceFiles = await generator.generateService({
+                entity,
+                relationships: entityRelationships,
+                allEntities: entities,
+                apiType,
+                relationshipMap,
+            });
+            for (const file of serviceFiles) {
+                const fullPath = path.join(autogenPath, file.path);
+                await (0, file_system_1.createFile)(fullPath, file.content);
+            }
+            // Generate controller files
+            const controllerFiles = await generator.generateController({
+                entity,
+                relationships: entityRelationships,
+                allEntities: entities,
+                apiType,
+                relationshipMap,
+            });
+            for (const file of controllerFiles) {
+                const fullPath = path.join(autogenPath, file.path);
+                await (0, file_system_1.createFile)(fullPath, file.content);
+            }
+            // Generate module files
+            const moduleFiles = await generator.generateModule({
+                entity,
+                relationships: entityRelationships,
+                allEntities: entities,
+                apiType,
+            });
+            for (const file of moduleFiles) {
+                const fullPath = path.join(autogenPath, file.path);
+                await (0, file_system_1.createFile)(fullPath, file.content);
+            }
+            const entityBuildTime = perf_hooks_1.performance.now() - entityBuildStart;
+            console.log(`[apso] Finished building entity '${entity.name}' in ${entityBuildTime.toFixed(2)} ms`);
+        }
+        // Generate guards
+        const guardFiles = await generator.generateGuards(entities, auth);
+        const rootPath = path.dirname(autogenPath);
+        for (const file of guardFiles) {
+            const fullPath = path.join(rootPath, "autogen", file.path);
+            await (0, file_system_1.createFile)(fullPath, file.content);
+            console.log(`[apso] Generated ${fullPath}`);
+        }
+        // Generate index module
+        const indexFiles = await generator.generateIndexModule(entities, apiType);
+        for (const file of indexFiles) {
+            const fullPath = path.join(autogenPath, file.path);
+            await (0, file_system_1.createFile)(fullPath, file.content);
+            console.log(`[apso] Generated ${fullPath}`);
         }
     }
 }
 Scaffold.description = "Setup new entities and interfaces for an Apso Server";
-Scaffold.examples = [`$ apso server scaffold`, `$ apso server scaffold --skip-format`];
+Scaffold.examples = [
+    `$ apso server scaffold`,
+    `$ apso server scaffold --skip-format`,
+    `$ apso server scaffold --language typescript`,
+    `$ apso server scaffold --language python`,
+    `$ apso server scaffold --language go`,
+];
 Scaffold.flags = {
     help: core_1.Flags.help({ char: "h" }),
     "skip-format": core_1.Flags.boolean({
         description: "Skip the formatting step (useful when prettier is not available)",
         default: false,
     }),
+    language: core_1.Flags.string({
+        char: "l",
+        description: "Target language for code generation (typescript, python, go). If not specified, uses .apsorc config or prompts.",
+        options: ["typescript", "python", "go"],
+    }),
 };
 Scaffold.args = {};
 exports.default = Scaffold;

package/dist/lib/api/client.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Platform API Client
+ *
+ * HTTP client for making authenticated requests to the Apso platform.
+ * Features:
+ * - Automatic token refresh
+ * - Request/response interceptors
+ * - Retry with exponential backoff
+ * - Timeout handling
+ */
+import { ApiRequestOptions } from "./types";
+/**
+ * Custom error class for API errors
+ */
+export declare class ApiClientError extends Error {
+    statusCode: number;
+    details?: Record<string, unknown> | undefined;
+    constructor(message: string, statusCode: number, details?: Record<string, unknown> | undefined);
+    /**
+     * Check if error is due to authentication failure
+     */
+    isAuthError(): boolean;
+    /**
+     * Check if error is a rate limit error
+     */
+    isRateLimitError(): boolean;
+    /**
+     * Check if error is a server error (5xx)
+     */
+    isServerError(): boolean;
+}
+/**
+ * Check if we're running in an environment with network access
+ */
+export declare function checkNetworkConnectivity(): Promise<boolean>;
+/**
+ * Make an authenticated request to the platform API
+ * Note: Sequential retries are intentional for proper backoff behavior
+ */
+export declare function apiRequest<T>(path: string, options?: ApiRequestOptions): Promise<T>;
+/**
+ * Platform API client with typed methods
+ */
+export declare const api: {
+    /**
+     * Make a GET request
+     */
+    get<T>(path: string, options?: Omit<ApiRequestOptions, "method" | "body">): Promise<T>;
+    /**
+     * Make a POST request
+     */
+    post<T_1>(path: string, body?: unknown, options?: Omit<ApiRequestOptions, "method" | "body">): Promise<T_1>;
+    /**
+     * Make a PUT request
+     */
+    put<T_2>(path: string, body?: unknown, options?: Omit<ApiRequestOptions, "method" | "body">): Promise<T_2>;
+    /**
+     * Make a PATCH request
+     */
+    patch<T_3>(path: string, body?: unknown, options?: Omit<ApiRequestOptions, "method" | "body">): Promise<T_3>;
+    /**
+     * Make a DELETE request
+     */
+    delete<T_4>(path: string, options?: Omit<ApiRequestOptions, "method">): Promise<T_4>;
+};