@apso/cli 0.8.6 → 0.10.1

package/dist/commands/migrate.d.ts

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

package/dist/commands/migrate.js

@@ -0,0 +1,137 @@
+"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 apsorc_parser_1 = require("../lib/apsorc-parser");
+const snapshot_1 = require("../lib/migrate/snapshot");
+const sandbox_1 = require("../lib/migrate/sandbox");
+class Migrate extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(Migrate);
+        // Handle reset
+        if (flags.reset) {
+            (0, sandbox_1.resetSandbox)();
+            this.log("Sandbox reset. Snapshot and PGlite data cleared.");
+            return;
+        }
+        // Parse .apsorc
+        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}`);
+        }
+        // Quick check against snapshot
+        const snapshot = (0, snapshot_1.readSnapshot)();
+        const currentComparable = {
+            entities: parsed.entities.map((e) => {
+                var _a;
+                return ({
+                    name: e.name,
+                    fields: (_a = e.fields) === null || _a === void 0 ? void 0 : _a.map((f) => {
+                        var _a;
+                        return ({
+                            name: f.name,
+                            type: f.type,
+                            nullable: f.nullable,
+                            unique: f.unique,
+                            default: (_a = f.default) !== null && _a !== void 0 ? _a : undefined,
+                            index: f.index,
+                        });
+                    }),
+                    primaryKeyType: e.primaryKeyType,
+                    created_at: e.created_at,
+                    updated_at: e.updated_at,
+                    scopeBy: e.scopeBy,
+                });
+            }),
+        };
+        if (!(0, snapshot_1.hasChanges)(currentComparable, snapshot)) {
+            if (!flags.sql) {
+                this.log("Schema unchanged. No migration needed.");
+            }
+            return;
+        }
+        if (!flags.sql) {
+            this.log("Schema changes detected. Running migration sandbox...");
+        }
+        // Run the sandbox
+        const result = await (0, sandbox_1.runMigrationSandbox)({ entities: parsed.entities, relationshipMap: parsed.relationshipMap });
+        if (!result.needed) {
+            if (!flags.sql) {
+                this.log("No database-level changes detected.");
+            }
+            return;
+        }
+        // Output results
+        if (flags.sql) {
+            // Raw SQL output mode
+            for (const sql of result.upSql) {
+                this.log(sql + ";");
+            }
+            return;
+        }
+        if (result.success) {
+            this.log("");
+            this.log("Migration SQL (up):");
+            this.log("---");
+            for (const sql of result.upSql) {
+                this.log(`  ${sql};`);
+            }
+            this.log("---");
+            this.log("");
+            this.log(`${result.upSql.length} statement(s) generated and tested.`);
+            this.log("Migration validated against local PGlite.");
+            if (flags.apply) {
+                (0, sandbox_1.applyMigration)({
+                    entities: parsed.entities,
+                    relationshipMap: parsed.relationshipMap,
+                });
+                this.log("Snapshot updated.");
+            }
+            else {
+                this.log("Run with --apply to update the snapshot.");
+            }
+        }
+        else {
+            this.log("");
+            this.log("Migration FAILED.");
+            if (result.error) {
+                this.log(`Error: ${result.error}`);
+            }
+            if (result.upSql.length > 0) {
+                this.log("");
+                this.log("Attempted SQL:");
+                for (const sql of result.upSql) {
+                    this.log(`  ${sql};`);
+                }
+            }
+            this.exit(1);
+        }
+    }
+}
+Migrate.description = "Detect schema changes, generate migration SQL, and test against a local PGlite sandbox";
+Migrate.examples = [
+    `$ apso migrate`,
+    `$ apso migrate --apply`,
+    `$ apso migrate --reset`,
+    `$ apso migrate --sql`,
+];
+Migrate.flags = {
+    apply: core_1.Flags.boolean({
+        description: "Apply the migration: update the local snapshot after a successful test",
+        default: false,
+    }),
+    reset: core_1.Flags.boolean({
+        description: "Reset the sandbox (clear snapshot and PGlite data)",
+        default: false,
+    }),
+    sql: core_1.Flags.boolean({
+        description: "Output raw SQL only (for piping to files)",
+        default: false,
+    }),
+};
+exports.default = Migrate;

package/dist/commands/open.d.ts

@@ -0,0 +1,10 @@
+import BaseCommand from "../lib/base-command";
+export default class Open extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        endpoint: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        dashboard: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/open.js

@@ -0,0 +1,79 @@
+"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 os = tslib_1.__importStar(require("os"));
+const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
+const config_1 = require("../lib/config");
+const config_2 = require("../lib/config");
+const services_1 = require("../lib/api/services");
+class Open extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(Open);
+        // 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.");
+        }
+        const config = config_2.globalConfig.read();
+        if (flags.endpoint) {
+            // Open the live API endpoint
+            const service = await services_1.servicesApi.get(link.workspaceSlug, link.serviceSlug);
+            if (!service.endpoint) {
+                this.error("Service has no endpoint. Deploy first with 'apso deploy'.");
+            }
+            this.log(`Opening endpoint: ${service.endpoint}`);
+            openUrl(service.endpoint);
+        }
+        else {
+            // Open the dashboard (default)
+            const dashboardUrl = `${config.webUrl}/workspaces/${link.workspaceSlug}/services/${link.serviceSlug}`;
+            this.log(`Opening dashboard: ${dashboardUrl}`);
+            openUrl(dashboardUrl);
+        }
+    }
+}
+Open.description = "Open the service dashboard or endpoint in browser";
+Open.examples = [
+    `$ apso open`,
+    `$ apso open --endpoint`,
+    `$ apso open --dashboard`,
+];
+Open.flags = {
+    endpoint: core_1.Flags.boolean({
+        char: "e",
+        description: "Open the service API endpoint",
+        default: false,
+    }),
+    dashboard: core_1.Flags.boolean({
+        char: "d",
+        description: "Open the service dashboard (default)",
+        default: false,
+    }),
+};
+exports.default = Open;
+function openUrl(url) {
+    const platform = os.platform();
+    let command;
+    switch (platform) {
+        case "darwin":
+            command = `open "${url}"`;
+            break;
+        case "win32":
+            command = `start "" "${url}"`;
+            break;
+        default:
+            command = `xdg-open "${url}"`;
+            break;
+    }
+    (0, child_process_1.exec)(command, (error) => {
+        if (error) {
+            // Fail silently -- the URL was already printed
+        }
+    });
+}

package/dist/commands/projects.d.ts

@@ -0,0 +1,10 @@
+import BaseCommand from "../lib/base-command";
+export default class Projects extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        workspace: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/projects.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
+const config_1 = require("../lib/config");
+const services_1 = require("../lib/api/services");
+class Projects extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(Projects);
+        // Auth guard
+        if (!config_1.credentials.isValid()) {
+            this.error("Not logged in. Run 'apso login' first.");
+        }
+        // Determine workspace
+        let workspaceSlug;
+        if (flags.workspace) {
+            workspaceSlug = flags.workspace;
+        }
+        else {
+            // Try from existing link
+            const link = config_1.projectLink.read();
+            if (link) {
+                workspaceSlug = link.workspaceSlug;
+            }
+            else {
+                // Prompt
+                const workspaces = await services_1.workspacesApi.list();
+                if (workspaces.length === 0) {
+                    this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+                }
+                const response = await inquirer_1.default.prompt([
+                    {
+                        type: "list",
+                        name: "workspace",
+                        message: "Select a workspace:",
+                        choices: workspaces.map((ws) => ({
+                            name: `${ws.name} (${ws.slug})`,
+                            value: ws,
+                        })),
+                    },
+                ]);
+                workspaceSlug = response.workspace.slug;
+            }
+        }
+        // Fetch services
+        const servicesResponse = await services_1.servicesApi.list(workspaceSlug);
+        const services = servicesResponse.data;
+        if (services.length === 0) {
+            this.log(`No services found in workspace "${workspaceSlug}".`);
+            return;
+        }
+        // Get currently-linked service for highlighting
+        const link = config_1.projectLink.read();
+        const linkedServiceId = link === null || link === void 0 ? void 0 : link.serviceId;
+        if (flags.json) {
+            this.log(JSON.stringify(services, null, 2));
+            return;
+        }
+        // Table output
+        this.log(`Services in workspace "${workspaceSlug}":\n`);
+        this.log(padRight("NAME", 24) +
+            padRight("SLUG", 20) +
+            padRight("STATUS", 12) +
+            padRight("LAST DEPLOYED", 22) +
+            "REPO");
+        this.log("-".repeat(90));
+        for (const svc of services) {
+            const isLinked = svc.id === linkedServiceId;
+            const marker = isLinked ? " *" : "";
+            const deployed = svc.lastDeployedAt
+                ? new Date(svc.lastDeployedAt).toLocaleDateString()
+                : "-";
+            const repo = svc.githubRepo || "-";
+            this.log(padRight(`${svc.name}${marker}`, 24) +
+                padRight(svc.slug, 20) +
+                padRight(svc.status, 12) +
+                padRight(deployed, 22) +
+                repo);
+        }
+        if (linkedServiceId) {
+            this.log("\n* = currently linked");
+        }
+    }
+}
+Projects.description = "List projects (services) in a workspace";
+Projects.examples = [
+    `$ apso projects`,
+    `$ apso projects --workspace my-team`,
+    `$ apso projects --json`,
+];
+Projects.flags = {
+    workspace: core_1.Flags.string({
+        char: "w",
+        description: "Workspace slug",
+    }),
+    json: core_1.Flags.boolean({
+        description: "Output as JSON",
+        default: false,
+    }),
+};
+exports.default = Projects;
+function padRight(str, len) {
+    return str.length >= len ? str + " " : str + " ".repeat(len - str.length);
+}

package/dist/commands/schema/diff.d.ts

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

package/dist/commands/schema/diff.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+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 schema_convert_1 = require("../../lib/utils/schema-convert");
+// Inline ANSI color helpers (no dependency needed)
+const useColor = () => !config_1.globalConfig.read().noColor;
+const green = (s) => useColor() ? `\x1b[32m${s}\x1b[0m` : s;
+const red = (s) => useColor() ? `\x1b[31m${s}\x1b[0m` : s;
+const yellow = (s) => useColor() ? `\x1b[33m${s}\x1b[0m` : s;
+class SchemaDiff extends base_command_1.default {
+    async run() {
+        // 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.");
+        }
+        // Parse local schema
+        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}`);
+        }
+        const localSchema = (0, schema_convert_1.apsorcToServiceSchema)(parsed);
+        // Get diff from platform
+        const diff = await services_1.schemaApi.diff(link.workspaceSlug, link.serviceSlug, localSchema);
+        if (!diff.hasChanges) {
+            this.log("Local and remote schemas are in sync.");
+            return;
+        }
+        this.log("Schema differences:\n");
+        if (diff.added.length > 0) {
+            for (const item of diff.added) {
+                this.log(green(`  + ${item}`));
+            }
+        }
+        if (diff.removed.length > 0) {
+            for (const item of diff.removed) {
+                this.log(red(`  - ${item}`));
+            }
+        }
+        if (diff.modified.length > 0) {
+            for (const item of diff.modified) {
+                this.log(yellow(`  ~ ${item}`));
+            }
+        }
+        this.log(`\n${green(String(diff.added.length) + " added")}, ${red(String(diff.removed.length) + " removed")}, ${yellow(String(diff.modified.length) + " modified")}`);
+    }
+}
+SchemaDiff.description = "Show diff between local and remote schema";
+SchemaDiff.examples = [`$ apso schema diff`];
+SchemaDiff.flags = {};
+exports.default = SchemaDiff;

package/dist/commands/schema/pull.d.ts

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

package/dist/commands/schema/pull.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const fs = tslib_1.__importStar(require("fs"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+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 schema_convert_1 = require("../../lib/utils/schema-convert");
+class SchemaPull extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(SchemaPull);
+        // 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 remote schema
+        const remoteSchema = await services_1.schemaApi.get(link.workspaceSlug, link.serviceSlug);
+        // Convert to .apsorc format
+        const apsorcData = (0, schema_convert_1.serviceSchemaToApsorc)(remoteSchema);
+        // Find local .apsorc path
+        const configPath = (0, apsorc_parser_1.findConfigPath)();
+        if (!configPath) {
+            this.error("No .apsorc file found. Run 'apso init' first.");
+        }
+        // Show what will change
+        const entityNames = apsorcData.entities.map((e) => e.name).join(", ");
+        this.log(`Remote schema: ${apsorcData.entities.length} entities (${entityNames})`);
+        this.log(`Relationships: ${apsorcData.relationships.length}`);
+        this.log(`Target file: ${configPath}`);
+        // Confirm
+        if (!flags.yes) {
+            const { confirm } = await inquirer_1.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: "Overwrite local .apsorc with remote schema?",
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                this.log("Pull cancelled.");
+                return;
+            }
+        }
+        // Backup existing .apsorc
+        const backupPath = (0, config_1.createBackup)(configPath);
+        this.log(`Backup created: ${backupPath}`);
+        // Write updated .apsorc
+        fs.writeFileSync(configPath, JSON.stringify(apsorcData, null, 2), "utf-8");
+        // Update sync metadata
+        const remoteHash = (0, schema_convert_1.computeSchemaHash)(remoteSchema.entities);
+        const localHash = (0, schema_convert_1.computeSchemaHash)(apsorcData);
+        config_1.projectLink.updateSyncMetadata({
+            lastSyncedAt: new Date().toISOString(),
+            localSchemaHash: localHash,
+            remoteSchemaHash: remoteHash,
+        });
+        this.log("Schema pulled successfully.");
+    }
+}
+SchemaPull.description = "Pull remote schema to local .apsorc";
+SchemaPull.examples = [
+    `$ apso schema pull`,
+    `$ apso schema pull --yes`,
+];
+SchemaPull.flags = {
+    yes: core_1.Flags.boolean({
+        char: "y",
+        description: "Skip confirmation prompt",
+        default: false,
+    }),
+};
+exports.default = SchemaPull;

package/dist/commands/schema/push.d.ts

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

package/dist/commands/schema/push.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+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 schema_convert_1 = require("../../lib/utils/schema-convert");
+class SchemaPush extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(SchemaPush);
+        // 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.");
+        }
+        // Parse local schema
+        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}`);
+        }
+        const localSchema = (0, schema_convert_1.apsorcToServiceSchema)(parsed);
+        // Check diff first
+        const diff = await services_1.schemaApi.diff(link.workspaceSlug, link.serviceSlug, localSchema);
+        if (!diff.hasChanges) {
+            this.log("Already in sync. Nothing to push.");
+            return;
+        }
+        // Show changes
+        this.log("Changes to push:\n");
+        if (diff.added.length > 0) {
+            for (const item of diff.added) {
+                this.log(`  + ${item}`);
+            }
+        }
+        if (diff.removed.length > 0) {
+            for (const item of diff.removed) {
+                this.log(`  - ${item}`);
+            }
+        }
+        if (diff.modified.length > 0) {
+            for (const item of diff.modified) {
+                this.log(`  ~ ${item}`);
+            }
+        }
+        this.log(`\n${diff.added.length} added, ${diff.removed.length} removed, ${diff.modified.length} modified`);
+        // Confirm
+        if (!flags.yes) {
+            const { confirm } = await inquirer_1.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: "Push these changes to the platform?",
+                    default: true,
+                },
+            ]);
+            if (!confirm) {
+                this.log("Push cancelled.");
+                return;
+            }
+        }
+        // Push
+        const updatedSchema = await services_1.schemaApi.update(link.workspaceSlug, link.serviceSlug, localSchema);
+        // Update sync metadata
+        const localHash = (0, schema_convert_1.computeSchemaHash)(localSchema);
+        const remoteHash = (0, schema_convert_1.computeSchemaHash)(updatedSchema.entities);
+        config_1.projectLink.updateSyncMetadata({
+            lastSyncedAt: new Date().toISOString(),
+            localSchemaHash: localHash,
+            remoteSchemaHash: remoteHash,
+        });
+        this.log("Schema pushed successfully.");
+    }
+}
+SchemaPush.description = "Push local schema to the platform";
+SchemaPush.examples = [
+    `$ apso schema push`,
+    `$ apso schema push --yes`,
+];
+SchemaPush.flags = {
+    yes: core_1.Flags.boolean({
+        char: "y",
+        description: "Skip confirmation prompt",
+        default: false,
+    }),
+};
+exports.default = SchemaPush;

package/dist/commands/schema/validate.d.ts

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