@apso/cli 0.39.1 → 0.40.0

package/dist/commands/migrate/generate.d.ts

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

package/dist/commands/migrate/generate.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const core_1 = require("@oclif/core");
+const base_command_1 = tslib_1.__importDefault(require("../../lib/base-command"));
+const verify_1 = require("../../lib/verify");
+class MigrateGenerate extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(MigrateGenerate);
+        const result = await (0, verify_1.generateMigration)(process.cwd(), path.resolve(flags.baseline), flags.name, (0, verify_1.cliBinPath)(this.config.root));
+        const summary = result.needed
+            ? `Created ${result.file}`
+            : "The database already matches; no migration needed.";
+        (0, verify_1.report)((s) => this.log(s), result, flags.json, result.ok ? summary : undefined);
+        if (!result.ok)
+            this.exit(1);
+    }
+}
+MigrateGenerate.description = "Generate a TypeORM migration from the deployed schema to this project's entities, using a local PGlite database (TypeScript services)";
+MigrateGenerate.examples = [`$ apso migrate generate --baseline deployed.apsorc`];
+MigrateGenerate.flags = {
+    baseline: core_1.Flags.string({
+        description: "The deployed .apsorc to migrate from",
+        required: true,
+    }),
+    name: core_1.Flags.string({
+        description: "Migration name",
+        default: "SchemaUpdate",
+    }),
+    json: core_1.Flags.boolean({
+        description: "Print the result as JSON",
+        default: false,
+    }),
+};
+exports.default = MigrateGenerate;

package/dist/commands/migrate/verify.d.ts

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

package/dist/commands/migrate/verify.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const core_1 = require("@oclif/core");
+const base_command_1 = tslib_1.__importDefault(require("../../lib/base-command"));
+const verify_1 = require("../../lib/verify");
+class MigrateVerify extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(MigrateVerify);
+        const result = await (0, verify_1.verifyMigration)(process.cwd(), path.resolve(flags.baseline), flags.migration, (0, verify_1.cliBinPath)(this.config.root));
+        (0, verify_1.report)((s) => this.log(s), result, flags.json, result.ok ? "Migration verified." : undefined);
+        if (!result.ok)
+            this.exit(1);
+    }
+}
+MigrateVerify.description = "Run a migration on a local PGlite copy of the deployed schema, then check the database matches this project's entities (TypeScript services)";
+MigrateVerify.examples = [
+    `$ apso migrate verify --baseline deployed.apsorc --migration src/migrations/1700000000000-SchemaUpdate-migration.ts`,
+];
+MigrateVerify.flags = {
+    baseline: core_1.Flags.string({
+        description: "The deployed .apsorc the migration starts from",
+        required: true,
+    }),
+    migration: core_1.Flags.string({
+        description: "The migration file to run",
+        required: true,
+    }),
+    json: core_1.Flags.boolean({
+        description: "Print the result as JSON",
+        default: false,
+    }),
+};
+exports.default = MigrateVerify;

package/dist/commands/test/smoke.d.ts

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

package/dist/commands/test/smoke.js

@@ -0,0 +1,28 @@
+"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 verify_1 = require("../../lib/verify");
+class TestSmoke extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(TestSmoke);
+        const { entities, auth } = (0, apsorc_parser_1.parseApsorc)();
+        // With auth configured every entity route needs a session, so only /health is checked.
+        const names = auth ? [] : entities.map((e) => e.name);
+        const result = await (0, verify_1.smokeTest)(process.cwd(), names);
+        (0, verify_1.report)((s) => this.log(s), result, flags.json, result.ok ? "Smoke test passed." : undefined);
+        if (!result.ok)
+            this.exit(1);
+    }
+}
+TestSmoke.description = "Start the service on a local PGlite database and call /health and every entity's list endpoint (TypeScript services)";
+TestSmoke.examples = [`$ apso test smoke`];
+TestSmoke.flags = {
+    json: core_1.Flags.boolean({
+        description: "Print the result as JSON",
+        default: false,
+    }),
+};
+exports.default = TestSmoke;

package/dist/lib/apsorc-parser.d.ts

@@ -60,6 +60,8 @@ export declare class ApsorcNamingError extends Error {
     code: string;
     entity: string;
     field?: string | undefined;
+    /** A problem in the user's .apsorc, not a CLI bug: PostHog only, never Sentry. */
+    readonly userError = true;
     constructor(message: string, code: string, entity: string, field?: string | undefined);
 }
 /**

package/dist/lib/apsorc-parser.js

@@ -34,6 +34,8 @@ class ApsorcNamingError extends Error {
         this.code = code;
         this.entity = entity;
         this.field = field;
+        /** A problem in the user's .apsorc, not a CLI bug: PostHog only, never Sentry. */
+        this.userError = true;
         this.name = "ApsorcNamingError";
     }
 }

package/dist/lib/base-command.d.ts

@@ -1,5 +1,9 @@
 import { Command } from "@oclif/core";
-/** True for errors oclif raised deliberately (this.error, this.exit, parse errors). */
+/**
+ * True for errors oclif raised deliberately (this.error, this.exit, parse
+ * errors) and for errors that mark themselves `userError` (problems in the
+ * user's input, such as an .apsorc that would not compile).
+ */
 export declare function isUserError(err: unknown): boolean;
 export default abstract class BaseCommand extends Command {
     /**

package/dist/lib/base-command.js

@@ -6,9 +6,15 @@ const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
 const os_1 = tslib_1.__importDefault(require("os"));
 const telemetry_1 = require("./telemetry/telemetry");
-/** True for errors oclif raised deliberately (this.error, this.exit, parse errors). */
+/**
+ * True for errors oclif raised deliberately (this.error, this.exit, parse
+ * errors) and for errors that mark themselves `userError` (problems in the
+ * user's input, such as an .apsorc that would not compile).
+ */
 function isUserError(err) {
-    return Boolean(err && typeof err === "object" && "oclif" in err);
+    if (!err || typeof err !== "object")
+        return false;
+    return "oclif" in err || err.userError === true;
 }
 exports.isUserError = isUserError;
 class BaseCommand extends core_1.Command {

package/dist/lib/verify/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Pre-deploy checks for a generated TypeScript service, run against PGlite:
+ * generate the migration from the deployed schema, run it and check for drift,
+ * and smoke test the endpoints. The CLI and the in-browser editor (which runs
+ * the CLI in a WebContainer) share these steps.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="mocha" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+export interface Step {
+    name: string;
+    ok: boolean;
+    output?: string;
+}
+export declare function run(cmd: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): Promise<{
+    ok: boolean;
+    output: string;
+}>;
+/** Env that points the service's orm.config at a file-backed PGlite database. */
+export declare const pgliteEnv: (dataDir: string) => NodeJS.ProcessEnv;
+/**
+ * Load the deployed schema into a fresh PGlite database at dataDir: scaffold
+ * the baseline .apsorc in a copy of the project (sharing node_modules), build
+ * it, and schema:sync.
+ */
+export declare function buildBaseline(projectDir: string, baselineApsorc: string, dataDir: string, cliBin: string): Promise<Step>;
+export interface GenerateResult {
+    ok: boolean;
+    needed: boolean;
+    file?: string;
+    steps: Step[];
+}
+/** Generate a migration from the deployed schema (baselineApsorc) to the project's entities. */
+export declare function generateMigration(projectDir: string, baselineApsorc: string, name: string, cliBin: string): Promise<GenerateResult>;
+export interface CheckResult {
+    ok: boolean;
+    steps: Step[];
+}
+/**
+ * Run a migration on a fresh copy of the deployed schema, then check that the
+ * database matches the project's entities (a second generate finds nothing).
+ */
+export declare function verifyMigration(projectDir: string, baselineApsorc: string, migrationFile: string, cliBin: string): Promise<CheckResult>;
+/**
+ * Start the built service on a PGlite database synced to its entities and call
+ * GET /health and the list endpoint of every entity.
+ * ponytail: list only, no create/read/delete; add when payloads can be built
+ * from required fields and relationships.
+ */
+export declare function smokeTest(projectDir: string, entityNames: string[], timeoutMs?: number): Promise<CheckResult>;
+/** The CLI's own entry point, for running `generate` in the baseline copy. */
+export declare const cliBinPath: (root: string) => string;
+/** Print a check's steps (or JSON) through the command's logger. */
+export declare function report(log: (s: string) => void, result: CheckResult, json: boolean, summary?: string): void;

package/dist/lib/verify/index.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * Pre-deploy checks for a generated TypeScript service, run against PGlite:
+ * generate the migration from the deployed schema, run it and check for drift,
+ * and smoke test the endpoints. The CLI and the in-browser editor (which runs
+ * the CLI in a WebContainer) share these steps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.report = exports.cliBinPath = exports.smokeTest = exports.verifyMigration = exports.generateMigration = exports.buildBaseline = exports.pgliteEnv = exports.run = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const fs = tslib_1.__importStar(require("fs"));
+const http = tslib_1.__importStar(require("http"));
+const net = tslib_1.__importStar(require("net"));
+const os = tslib_1.__importStar(require("os"));
+const path = tslib_1.__importStar(require("path"));
+const pluralize_1 = tslib_1.__importDefault(require("pluralize"));
+// eslint-disable-next-line no-control-regex
+const plain = (s) => s.replace(/\u001B\[[\d;]*m/g, "");
+const tail = (s, n = 4000) => {
+    const p = plain(s);
+    return p.length > n ? p.slice(-n) : p;
+};
+function run(cmd, args, cwd, env = {}) {
+    return new Promise((resolve) => {
+        const p = (0, child_process_1.spawn)(cmd, args, { cwd, env: { ...process.env, ...env } });
+        let output = "";
+        p.stdout.on("data", (d) => {
+            output += d;
+        });
+        p.stderr.on("data", (d) => {
+            output += d;
+        });
+        p.on("error", (e) => resolve({ ok: false, output: output + e.message }));
+        p.on("close", (code) => resolve({ ok: code === 0, output }));
+    });
+}
+exports.run = run;
+/** Env that points the service's orm.config at a file-backed PGlite database. */
+const pgliteEnv = (dataDir) => ({
+    DATABASE_TYPE: "pglite",
+    DATABASE_SYNC: "false",
+    DATABASE_LOGGING: "false",
+    PGLITE_DATA_DIR: dataDir,
+});
+exports.pgliteEnv = pgliteEnv;
+const typeorm = (cwd, args, env) => run("npm", ["run", "typeorm", "--", ...args, "-d", "./dist/orm.config.js"], cwd, env);
+const build = (cwd) => run("npm", ["run", "build"], cwd);
+const step = (name, r) => ({
+    name,
+    ok: r.ok,
+    output: r.ok ? undefined : tail(r.output),
+});
+/**
+ * Load the deployed schema into a fresh PGlite database at dataDir: scaffold
+ * the baseline .apsorc in a copy of the project (sharing node_modules), build
+ * it, and schema:sync.
+ */
+async function buildBaseline(projectDir, baselineApsorc, dataDir, cliBin) {
+    const copy = fs.mkdtempSync(path.join(os.tmpdir(), "apso-baseline-"));
+    try {
+        fs.cpSync(projectDir, copy, {
+            recursive: true,
+            filter: (src) => !["node_modules", "dist", ".git"].includes(path.relative(projectDir, src).split(path.sep)[0]),
+        });
+        fs.symlinkSync(path.join(projectDir, "node_modules"), path.join(copy, "node_modules"), "dir");
+        fs.copyFileSync(baselineApsorc, path.join(copy, ".apsorc"));
+        // The CLI rebuilds src/autogen from the entities present; a stale one fails the build.
+        fs.rmSync(path.join(copy, "src", "autogen"), {
+            recursive: true,
+            force: true,
+        });
+        const gen = await run(process.execPath, [cliBin, "generate", "--skip-format", "--language", "typescript"], copy);
+        if (!gen.ok)
+            return step("baseline", gen);
+        const built = await build(copy);
+        if (!built.ok)
+            return step("baseline", built);
+        return step("baseline", await typeorm(copy, ["schema:sync"], (0, exports.pgliteEnv)(dataDir)));
+    }
+    finally {
+        fs.rmSync(copy, { recursive: true, force: true });
+    }
+}
+exports.buildBaseline = buildBaseline;
+/** Generate a migration from the deployed schema (baselineApsorc) to the project's entities. */
+async function generateMigration(projectDir, baselineApsorc, name, cliBin) {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
+    const steps = [];
+    try {
+        const baseline = await buildBaseline(projectDir, baselineApsorc, dataDir, cliBin);
+        steps.push(baseline);
+        if (!baseline.ok)
+            return { ok: false, needed: false, steps };
+        const built = await build(projectDir);
+        steps.push(step("build", built));
+        if (!built.ok)
+            return { ok: false, needed: false, steps };
+        const migrationsDir = path.join(projectDir, "src", "migrations");
+        fs.mkdirSync(migrationsDir, { recursive: true });
+        const before = new Set(fs.readdirSync(migrationsDir));
+        const gen = await typeorm(projectDir, ["migration:generate", `./src/migrations/${name}-migration`], (0, exports.pgliteEnv)(dataDir));
+        if (/No changes in database schema were found/.test(gen.output)) {
+            steps.push({ name: "generate", ok: true });
+            return { ok: true, needed: false, steps };
+        }
+        const file = fs
+            .readdirSync(migrationsDir)
+            .find((f) => !before.has(f) && f.endsWith(".ts"));
+        const ok = gen.ok && Boolean(file);
+        steps.push(step("generate", { ok, output: gen.output }));
+        return {
+            ok,
+            needed: true,
+            file: file && path.join("src", "migrations", file),
+            steps,
+        };
+    }
+    finally {
+        fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+}
+exports.generateMigration = generateMigration;
+// Runs only the given compiled migration, so migrations the deployed database
+// already ran are not replayed on the baseline.
+const RUN_ONE_MIGRATION = `
+const path = require("path");
+const mod = require(path.resolve("dist/orm.config.js"));
+const ds = mod.default || mod;
+ds.setOptions({ migrations: [path.resolve(process.argv[1])] });
+ds.initialize()
+  .then(() => ds.runMigrations({ transaction: "all" }))
+  .then((ran) => { console.log("ran " + ran.map((m) => m.name).join(", ")); return ds.destroy(); })
+  .catch((e) => { console.error(e && e.message ? e.message : e); process.exit(1); });
+`;
+/**
+ * Run a migration on a fresh copy of the deployed schema, then check that the
+ * database matches the project's entities (a second generate finds nothing).
+ */
+async function verifyMigration(projectDir, baselineApsorc, migrationFile, cliBin) {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
+    const steps = [];
+    const done = (s) => {
+        steps.push(s);
+        return s.ok;
+    };
+    try {
+        if (!done(await buildBaseline(projectDir, baselineApsorc, dataDir, cliBin)))
+            return { ok: false, steps };
+        if (!done(step("build", await build(projectDir))))
+            return { ok: false, steps };
+        const compiled = path
+            .join("dist", path.relative("src", migrationFile))
+            .replace(/\.ts$/, ".js");
+        const migrate = await run(process.execPath, ["-e", RUN_ONE_MIGRATION, compiled], projectDir, (0, exports.pgliteEnv)(dataDir));
+        if (!done({ ...step("migrate", migrate), output: tail(migrate.output) }))
+            return { ok: false, steps };
+        const drift = await typeorm(projectDir, ["migration:generate", "./src/migrations/drift", "--check"], (0, exports.pgliteEnv)(dataDir));
+        return { ok: done(step("drift", drift)), steps };
+    }
+    finally {
+        fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+}
+exports.verifyMigration = verifyMigration;
+const freePort = () => new Promise((resolve, reject) => {
+    const s = net.createServer();
+    s.listen(0, () => {
+        const { port } = s.address();
+        s.close(() => resolve(port));
+    });
+    s.on("error", reject);
+});
+const get = (url) => new Promise((resolve) => {
+    http
+        .get(url, (res) => {
+        let body = "";
+        res.on("data", (d) => {
+            body += d;
+        });
+        res.on("end", () => { var _a; return resolve({ status: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0, body }); });
+    })
+        .on("error", (e) => resolve({ status: 0, body: e.message }));
+});
+/**
+ * Start the built service on a PGlite database synced to its entities and call
+ * GET /health and the list endpoint of every entity.
+ * ponytail: list only, no create/read/delete; add when payloads can be built
+ * from required fields and relationships.
+ */
+async function smokeTest(projectDir, entityNames, timeoutMs = 60000) {
+    var _a, _b;
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
+    const steps = [];
+    const done = (s) => {
+        steps.push(s);
+        return s.ok;
+    };
+    let server;
+    try {
+        if (!done(step("build", await build(projectDir))))
+            return { ok: false, steps };
+        if (!done(step("schema", await typeorm(projectDir, ["schema:sync"], (0, exports.pgliteEnv)(dataDir)))))
+            return { ok: false, steps };
+        const port = await freePort();
+        let log = "";
+        server = (0, child_process_1.spawn)(process.execPath, ["dist/main"], {
+            cwd: projectDir,
+            env: { ...process.env, ...(0, exports.pgliteEnv)(dataDir), APP_PORT: String(port) },
+        });
+        (_a = server.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (d) => {
+            log += d;
+        });
+        (_b = server.stderr) === null || _b === void 0 ? void 0 : _b.on("data", (d) => {
+            log += d;
+        });
+        const base = `http://127.0.0.1:${port}`;
+        const deadline = Date.now() + timeoutMs;
+        let health = await get(`${base}/health`);
+        while (health.status !== 200 &&
+            Date.now() < deadline &&
+            server.exitCode === null) {
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((r) => {
+                setTimeout(r, 500);
+            });
+            // eslint-disable-next-line no-await-in-loop
+            health = await get(`${base}/health`);
+        }
+        if (!done({
+            name: "start",
+            ok: health.status === 200,
+            output: health.status === 200 ? undefined : tail(log),
+        }))
+            return { ok: false, steps };
+        for (const name of entityNames) {
+            const route = `/${(0, pluralize_1.default)(name)}`;
+            // eslint-disable-next-line no-await-in-loop
+            const res = await get(base + route);
+            done({
+                name: `GET ${route}`,
+                ok: res.status === 200,
+                output: res.status === 200
+                    ? undefined
+                    : `${res.status} ${tail(res.body, 500)}`,
+            });
+        }
+        return { ok: steps.every((s) => s.ok), steps };
+    }
+    finally {
+        server === null || server === void 0 ? void 0 : server.kill();
+        fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+}
+exports.smokeTest = smokeTest;
+/** The CLI's own entry point, for running `generate` in the baseline copy. */
+const cliBinPath = (root) => path.join(root, "bin", "run");
+exports.cliBinPath = cliBinPath;
+/** Print a check's steps (or JSON) through the command's logger. */
+function report(log, result, json, summary) {
+    if (json) {
+        log(JSON.stringify(result));
+        return;
+    }
+    for (const s of result.steps) {
+        log(`${s.ok ? "ok  " : "FAIL"} ${s.name}`);
+        if (s.output)
+            log(s.output.replace(/^/gm, "     "));
+    }
+    if (summary)
+        log(summary);
+}
+exports.report = report;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@apso/cli",
-  "version": "0.39.1",
+  "version": "0.40.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@apso/cli",
-      "version": "0.39.1",
+      "version": "0.40.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@apso/schema-tools": "^0.2.0",

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.39.1",
+  "version": "0.40.0",
   "commands": {
     "config": {
       "id": "config",
@@ -769,6 +769,78 @@
       },
       "args": {}
     },
+    "migrate:generate": {
+      "id": "migrate:generate",
+      "description": "Generate a TypeORM migration from the deployed schema to this project's entities, using a local PGlite database (TypeScript services)",
+      "strict": true,
+      "pluginName": "@apso/cli",
+      "pluginAlias": "@apso/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "hiddenAliases": [],
+      "examples": [
+        "$ apso migrate generate --baseline deployed.apsorc"
+      ],
+      "flags": {
+        "baseline": {
+          "name": "baseline",
+          "type": "option",
+          "description": "The deployed .apsorc to migrate from",
+          "required": true,
+          "multiple": false
+        },
+        "name": {
+          "name": "name",
+          "type": "option",
+          "description": "Migration name",
+          "multiple": false,
+          "default": "SchemaUpdate"
+        },
+        "json": {
+          "name": "json",
+          "type": "boolean",
+          "description": "Print the result as JSON",
+          "allowNo": false
+        }
+      },
+      "args": {}
+    },
+    "migrate:verify": {
+      "id": "migrate:verify",
+      "description": "Run a migration on a local PGlite copy of the deployed schema, then check the database matches this project's entities (TypeScript services)",
+      "strict": true,
+      "pluginName": "@apso/cli",
+      "pluginAlias": "@apso/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "hiddenAliases": [],
+      "examples": [
+        "$ apso migrate verify --baseline deployed.apsorc --migration src/migrations/1700000000000-SchemaUpdate-migration.ts"
+      ],
+      "flags": {
+        "baseline": {
+          "name": "baseline",
+          "type": "option",
+          "description": "The deployed .apsorc the migration starts from",
+          "required": true,
+          "multiple": false
+        },
+        "migration": {
+          "name": "migration",
+          "type": "option",
+          "description": "The migration file to run",
+          "required": true,
+          "multiple": false
+        },
+        "json": {
+          "name": "json",
+          "type": "boolean",
+          "description": "Print the result as JSON",
+          "allowNo": false
+        }
+      },
+      "args": {}
+    },
     "schema:diff": {
       "id": "schema:diff",
       "description": "Show diff between local and remote schema",
@@ -916,6 +988,28 @@
       ],
       "flags": {},
       "args": {}
+    },
+    "test:smoke": {
+      "id": "test:smoke",
+      "description": "Start the service on a local PGlite database and call /health and every entity's list endpoint (TypeScript services)",
+      "strict": true,
+      "pluginName": "@apso/cli",
+      "pluginAlias": "@apso/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "hiddenAliases": [],
+      "examples": [
+        "$ apso test smoke"
+      ],
+      "flags": {
+        "json": {
+          "name": "json",
+          "type": "boolean",
+          "description": "Print the result as JSON",
+          "allowNo": false
+        }
+      },
+      "args": {}
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.39.1",
+  "version": "0.40.0",
   "mcpName": "io.github.apsoai/apso",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",