@apso/cli 0.8.6 → 0.10.2

package/dist/commands/config.d.ts

@@ -0,0 +1,13 @@
+import BaseCommand from "../lib/base-command";
+export default class Config extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        action: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        key: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private showAll;
+}

package/dist/commands/config.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
+const config_1 = require("../lib/config");
+const types_1 = require("../lib/config/types");
+const VALID_KEYS = [
+    "apiUrl",
+    "webUrl",
+    "verbose",
+    "noColor",
+    "telemetryDisabled",
+    "defaultWorkspace",
+];
+const BOOLEAN_KEYS = [
+    "verbose",
+    "noColor",
+    "telemetryDisabled",
+];
+function parseBoolean(value) {
+    const lower = value.toLowerCase();
+    if (lower === "true" || lower === "1")
+        return true;
+    if (lower === "false" || lower === "0")
+        return false;
+    return null;
+}
+class Config extends base_command_1.default {
+    async run() {
+        const { args, argv } = await this.parse(Config);
+        const action = args.action;
+        const rawArgv = argv;
+        // No action: show all config
+        if (!action) {
+            this.showAll();
+            return;
+        }
+        if (action === "reset") {
+            config_1.globalConfig.reset();
+            this.log("Configuration reset to defaults.");
+            return;
+        }
+        if (action === "get") {
+            const key = args.key;
+            if (!key) {
+                this.error("Usage: apso config get <key>");
+            }
+            if (!VALID_KEYS.includes(key)) {
+                this.error(`Unknown key: ${key}\nValid keys: ${VALID_KEYS.join(", ")}`);
+            }
+            const value = config_1.globalConfig.get(key);
+            this.log(String(value !== null && value !== void 0 ? value : ""));
+            return;
+        }
+        if (action === "set") {
+            const key = args.key || rawArgv[1];
+            const value = args.value || rawArgv[2];
+            if (!key || value === undefined) {
+                this.error("Usage: apso config set <key> <value>");
+            }
+            if (!VALID_KEYS.includes(key)) {
+                this.error(`Unknown key: ${key}\nValid keys: ${VALID_KEYS.join(", ")}`);
+            }
+            if (BOOLEAN_KEYS.includes(key)) {
+                const boolVal = parseBoolean(value);
+                if (boolVal === null) {
+                    this.error(`Invalid boolean value: ${value}. Use true/false or 1/0.`);
+                }
+                config_1.globalConfig.set(key, boolVal);
+            }
+            else {
+                config_1.globalConfig.set(key, value);
+            }
+            this.log(`${key} = ${value}`);
+            return;
+        }
+        this.error(`Unknown action: ${action}\nUsage: apso config [get|set|reset]`);
+    }
+    showAll() {
+        const config = config_1.globalConfig.read();
+        this.log("Current configuration:\n");
+        for (const key of VALID_KEYS) {
+            const value = config[key];
+            const defaultVal = types_1.DEFAULT_GLOBAL_CONFIG[key];
+            const isDefault = value === defaultVal;
+            const suffix = isDefault ? " (default)" : "";
+            this.log(`  ${key} = ${value !== null && value !== void 0 ? value : "(not set)"}${suffix}`);
+        }
+    }
+}
+Config.description = "View or modify CLI configuration";
+Config.examples = [
+    `$ apso config`,
+    `$ apso config get apiUrl`,
+    `$ apso config set verbose true`,
+    `$ apso config reset`,
+];
+Config.strict = false;
+Config.args = {
+    action: core_1.Args.string({
+        description: "Action: get, set, or reset",
+        required: false,
+    }),
+    key: core_1.Args.string({
+        description: "Configuration key",
+        required: false,
+    }),
+    value: core_1.Args.string({
+        description: "Value to set",
+        required: false,
+    }),
+};
+exports.default = Config;

package/dist/commands/deploy.d.ts

@@ -0,0 +1,11 @@
+import BaseCommand from "../lib/base-command";
+export default class Deploy extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "no-wait": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        "skip-migrate": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/deploy.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
+const config_1 = require("../lib/config");
+const services_1 = require("../lib/api/services");
+const apsorc_parser_1 = require("../lib/apsorc-parser");
+const sandbox_1 = require("../lib/migrate/sandbox");
+const spinner_1 = require("../lib/utils/spinner");
+class Deploy extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(Deploy);
+        // Auth guard
+        if (!config_1.credentials.isValid()) {
+            this.error("Not logged in. Run 'apso login' first.");
+        }
+        // Link guard
+        const link = config_1.projectLink.read();
+        if (!link) {
+            this.error("Project not linked. Run 'apso link' first.");
+        }
+        // Fetch service
+        const service = await services_1.servicesApi.get(link.workspaceSlug, link.serviceSlug);
+        // Run migration sandbox (unless skipped)
+        let migrationCount = 0;
+        if (!flags["skip-migrate"]) {
+            let parsed;
+            try {
+                parsed = (0, apsorc_parser_1.parseApsorc)();
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.error(`Failed to parse .apsorc: ${msg}`);
+            }
+            this.log("Running migration check...");
+            const result = await (0, sandbox_1.runMigrationSandbox)({
+                entities: parsed.entities,
+                relationshipMap: parsed.relationshipMap,
+            });
+            if (result.needed) {
+                if (!result.success) {
+                    this.log("");
+                    this.log("Migration FAILED locally. Deploy aborted.");
+                    if (result.error) {
+                        this.log(`Error: ${result.error}`);
+                    }
+                    this.log("Fix the schema issue before deploying.");
+                    this.log("Run 'apso migrate' for details.");
+                    this.exit(1);
+                }
+                migrationCount = result.upSql.length;
+                this.log(`Migration validated: ${migrationCount} statement(s).`);
+                // Show SQL preview
+                this.log("");
+                for (const sql of result.upSql) {
+                    this.log(`  ${sql};`);
+                }
+                this.log("");
+            }
+            else {
+                this.log("No schema changes detected.");
+            }
+        }
+        // Determine source
+        if (service.githubRepo) {
+            this.log(`Deploying "${service.name}" from ${service.githubRepo}#${service.githubBranch || "main"}...`);
+        }
+        else {
+            this.log(`Deploying "${service.name}" via Apso Platform...`);
+        }
+        // Confirmation
+        if (!flags.yes && migrationCount > 0) {
+            const inquirer = await Promise.resolve().then(() => tslib_1.__importStar(require("inquirer")));
+            const { confirm } = await inquirer.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Deploy with ${migrationCount} migration statement(s)?`,
+                    default: true,
+                },
+            ]);
+            if (!confirm) {
+                this.log("Deploy cancelled.");
+                return;
+            }
+        }
+        // Trigger build
+        const build = await services_1.buildApi.trigger(link.workspaceSlug, link.serviceSlug);
+        this.log(`Build started: ${build.id}`);
+        if (flags["no-wait"]) {
+            this.log("Deploy triggered. Run 'apso status' to check progress.");
+            return;
+        }
+        // Poll with spinner
+        const spinner = await (0, spinner_1.createSpinner)("Deploying...");
+        spinner.start();
+        const finalStatus = await services_1.buildApi.waitForCompletion(build.id, {
+            onProgress: (status) => {
+                spinner.text = `Deploy status: ${status.status}...`;
+            },
+        });
+        if (finalStatus.status === "success") {
+            spinner.succeed("Deploy succeeded.");
+            if (service.endpoint) {
+                this.log(`Endpoint: ${service.endpoint}`);
+            }
+        }
+        else {
+            spinner.fail("Deploy failed.");
+            if (finalStatus.error) {
+                this.log(`Error: ${finalStatus.error}`);
+            }
+            this.log("Run 'apso logs' to view build logs.");
+            this.exit(1);
+        }
+    }
+}
+Deploy.description = "Deploy the linked service";
+Deploy.examples = [
+    `$ apso deploy`,
+    `$ apso deploy --yes`,
+    `$ apso deploy --skip-migrate`,
+    `$ apso deploy --no-wait`,
+];
+Deploy.flags = {
+    "no-wait": core_1.Flags.boolean({
+        description: "Trigger deploy without waiting for completion",
+        default: false,
+    }),
+    yes: core_1.Flags.boolean({
+        char: "y",
+        description: "Skip confirmation prompt",
+        default: false,
+    }),
+    "skip-migrate": core_1.Flags.boolean({
+        description: "Skip local migration validation",
+        default: false,
+    }),
+};
+exports.default = Deploy;

package/dist/commands/dev.d.ts

@@ -0,0 +1,15 @@
+import BaseCommand from "../lib/base-command";
+export default class Dev extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        detach: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        build: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Detect whether to use `docker compose` (v2 plugin) or `docker-compose` (v1).
+     * Returns the command parts as an array.
+     */
+    private detectComposeVariant;
+}

package/dist/commands/dev.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+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 base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
+class Dev extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(Dev);
+        // Check Docker is installed
+        if (!shelljs_1.default.which("docker")) {
+            this.error("Docker is required but not found. Please install Docker and try again.\nhttps://docs.docker.com/get-docker/");
+        }
+        // Detect compose variant (v2 plugin vs v1 standalone)
+        const composeCmd = this.detectComposeVariant();
+        // Verify docker-compose.yml exists
+        if (!fs.existsSync("docker-compose.yml")) {
+            this.error("No docker-compose.yml found in the current directory.\nMake sure you are in an Apso project root.");
+        }
+        // Build the command args
+        const args = [...composeCmd, "up"];
+        if (flags.build) {
+            args.push("--build");
+        }
+        if (flags.detach) {
+            args.push("-d");
+        }
+        this.log(`Running: ${args.join(" ")}`);
+        const child = (0, child_process_1.spawn)(args[0], args.slice(1), {
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                AUTH_DISABLED: "true",
+            },
+        });
+        // Forward signals for clean shutdown
+        const forwardSignal = (signal) => {
+            child.kill(signal);
+        };
+        process.on("SIGINT", forwardSignal);
+        process.on("SIGTERM", forwardSignal);
+        return new Promise((resolve, reject) => {
+            child.on("close", (code) => {
+                process.removeListener("SIGINT", forwardSignal);
+                process.removeListener("SIGTERM", forwardSignal);
+                if (code !== 0 && code !== null) {
+                    reject(new Error(`docker compose exited with code ${code}`));
+                    return;
+                }
+                resolve();
+            });
+            child.on("error", (err) => {
+                this.error(`Failed to start Docker Compose: ${err.message}`);
+            });
+        });
+    }
+    /**
+     * Detect whether to use `docker compose` (v2 plugin) or `docker-compose` (v1).
+     * Returns the command parts as an array.
+     */
+    detectComposeVariant() {
+        try {
+            (0, child_process_1.execSync)("docker compose version", { stdio: "ignore" });
+            return ["docker", "compose"];
+        }
+        catch {
+            // Fall back to v1
+            if (shelljs_1.default.which("docker-compose")) {
+                return ["docker-compose"];
+            }
+            this.error("Docker Compose is required but not found.\nInstall the Docker Compose plugin or standalone docker-compose.\nhttps://docs.docker.com/compose/install/");
+        }
+    }
+}
+Dev.description = "Start the local development server using Docker Compose";
+Dev.examples = [
+    `$ apso dev`,
+    `$ apso dev --build`,
+    `$ apso dev --detach`,
+    `$ apso dev --build --detach`,
+];
+Dev.flags = {
+    detach: core_1.Flags.boolean({
+        char: "d",
+        description: "Run containers in the background",
+        default: false,
+    }),
+    build: core_1.Flags.boolean({
+        description: "Rebuild images before starting",
+        default: false,
+    }),
+};
+exports.default = Dev;

package/dist/commands/generate.d.ts

@@ -0,0 +1,12 @@
+import BaseCommand from "../lib/base-command";
+export default class Generate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    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: {};
+    run(): Promise<void>;
+}

package/dist/commands/generate.js

@@ -0,0 +1,179 @@
+"use strict";
+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 perf_hooks_1 = require("perf_hooks");
+const file_system_1 = require("../lib/utils/file-system");
+class Generate extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(Generate);
+        const skipFormat = flags["skip-format"];
+        const totalBuildStart = perf_hooks_1.performance.now();
+        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 {
+            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;
+        }
+        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();
+        console.log(`[apso] Generating ${language} code for ${entities.length} entities...`);
+        const generatorConfig = {
+            language,
+            rootFolder,
+            apiType: lowerCaseApiType,
+            entities,
+            relationshipMap,
+            auth,
+        };
+        const generator = (0, lib_1.createGenerator)(generatorConfig);
+        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, lowerCaseApiType);
+        for (const file of enumFiles) {
+            const fullPath = path.join(autogenPath, file.path);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, file_system_1.createFile)(fullPath, file.content);
+        }
+        // Generate per-entity files
+        for (const entity of entities) {
+            console.log(`[apso] Building... ${entity.name}`);
+            const entityBuildStart = perf_hooks_1.performance.now();
+            const entityRelationships = relationshipMap[entity.name] || [];
+            // eslint-disable-next-line no-await-in-loop
+            const allFiles = await Promise.all([
+                generator.generateEntity({
+                    entity,
+                    relationships: entityRelationships,
+                    allEntities: entities,
+                    apiType: lowerCaseApiType,
+                }),
+                generator.generateDto({
+                    entity,
+                    relationships: entityRelationships,
+                    allEntities: entities,
+                    apiType: lowerCaseApiType,
+                }),
+                generator.generateService({
+                    entity,
+                    relationships: entityRelationships,
+                    allEntities: entities,
+                    apiType: lowerCaseApiType,
+                    relationshipMap,
+                }),
+                generator.generateController({
+                    entity,
+                    relationships: entityRelationships,
+                    allEntities: entities,
+                    apiType: lowerCaseApiType,
+                    relationshipMap,
+                }),
+                generator.generateModule({
+                    entity,
+                    relationships: entityRelationships,
+                    allEntities: entities,
+                    apiType: lowerCaseApiType,
+                }),
+            ]);
+            // eslint-disable-next-line no-await-in-loop
+            for (const files of allFiles) {
+                for (const file of files) {
+                    const fullPath = path.join(autogenPath, file.path);
+                    // eslint-disable-next-line no-await-in-loop
+                    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);
+        for (const file of guardFiles) {
+            const fullPath = path.join(autogenPath, file.path);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, file_system_1.createFile)(fullPath, file.content);
+        }
+        // Generate index module
+        const indexFiles = await generator.generateIndexModule(entities, lowerCaseApiType);
+        for (const file of indexFiles) {
+            const fullPath = path.join(autogenPath, file.path);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, file_system_1.createFile)(fullPath, file.content);
+        }
+        // Format generated files (TypeScript only)
+        if (language === "typescript" && !skipFormat) {
+            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 if (skipFormat) {
+            console.log("[apso] Skipping formatting (--skip-format flag set)");
+        }
+        const totalBuildTime = perf_hooks_1.performance.now() - totalBuildStart;
+        console.log(`[apso] Finished building all entities in ${totalBuildTime.toFixed(2)} ms`);
+    }
+}
+Generate.description = "Generate code from .apsorc schema";
+Generate.examples = [
+    `$ apso generate`,
+    `$ apso generate --skip-format`,
+    `$ apso generate --language typescript`,
+    `$ apso generate --language python`,
+    `$ apso generate --language go`,
+];
+Generate.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"],
+    }),
+};
+Generate.args = {};
+exports.default = Generate;

package/dist/commands/init.d.ts

@@ -0,0 +1,16 @@
+import BaseCommand from "../lib/base-command";
+export default class Init extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: 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>;
+        "skip-platform": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private runAuthenticated;
+    private cloneExisting;
+    private createNew;
+    private runOffline;
+    private postSetup;
+}