@apso/cli 0.42.1 → 0.43.0

package/dist/commands/migrate/generate.js

@@ -4,10 +4,14 @@ 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 apsorc_parser_1 = require("../../lib/apsorc-parser");
 const verify_1 = require("../../lib/verify");
 class MigrateGenerate extends base_command_1.default {
     async run() {
         const { flags } = await this.parse(MigrateGenerate);
+        const unsupported = (0, verify_1.migrateUnsupported)((0, apsorc_parser_1.parseApsorc)().language);
+        if (unsupported)
+            this.error(unsupported);
         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}`

package/dist/commands/migrate/verify.js

@@ -4,10 +4,14 @@ 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 apsorc_parser_1 = require("../../lib/apsorc-parser");
 const verify_1 = require("../../lib/verify");
 class MigrateVerify extends base_command_1.default {
     async run() {
         const { flags } = await this.parse(MigrateVerify);
+        const unsupported = (0, verify_1.migrateUnsupported)((0, apsorc_parser_1.parseApsorc)().language);
+        if (unsupported)
+            this.error(unsupported);
         const result = await (0, verify_1.verifyMigration)(process.cwd(), path.resolve(flags.baseline), flags.migration, (0, verify_1.cliBinPath)(this.config.root), flags["skip-build"]);
         (0, verify_1.report)((s) => this.log(s), result, flags.json, result.ok ? "Migration verified." : undefined);
         if (!result.ok)

package/dist/commands/test/smoke.js

@@ -7,23 +7,24 @@ const apsorc_parser_1 = require("../../lib/apsorc-parser");
 const verify_1 = require("../../lib/verify");
 class TestSmoke extends base_command_1.default {
     async run() {
+        var _a;
         const { flags } = await this.parse(TestSmoke);
-        const { entities, auth } = (0, apsorc_parser_1.parseApsorc)();
+        const { entities, relationshipMap, auth, language } = (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, {
-            skipBuild: flags["skip-build"],
-        });
-        (0, verify_1.report)((s) => this.log(s), result, flags.json, result.ok ? "Smoke test passed." : undefined);
+        const result = await (0, verify_1.smokeTest)(process.cwd(), auth ? [] : entities, relationshipMap, { skipBuild: flags["skip-build"], language });
+        const summary = ((_a = result.steps[0]) === null || _a === void 0 ? void 0 : _a.name) === "skipped"
+            ? "Smoke test skipped."
+            : "Smoke test passed.";
+        (0, verify_1.report)((s) => this.log(s), result, flags.json, result.ok ? summary : 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.description = "Start the service and call /health, every entity's list endpoint, and a create/read/delete of one row per entity. TypeScript services run on a local PGlite database; Python and Go services run on the database in DATABASE_URL (rows are created and deleted there, tables are not created) and the check is skipped when none answers";
 TestSmoke.examples = [`$ apso test smoke`];
 TestSmoke.flags = {
     "skip-build": core_1.Flags.boolean({
-        description: "Use the existing dist/ build instead of building first",
+        description: "Use the existing dist/ build instead of building first (TypeScript)",
         default: false,
     }),
     json: core_1.Flags.boolean({

package/dist/lib/generators/go.js

@@ -156,6 +156,9 @@ class GoGenerator extends base_1.BaseGenerator {
             createPrimaryKey,
             primaryKeyType,
             snakeCasedName: (0, casing_1.snakeCase)(name),
+            // Honor an explicit per-entity `table` override; otherwise derive from
+            // the entity name. See apsoai/cli#107 (Python/Go parity with #98).
+            tableName: entity.table || (0, casing_1.snakeCase)(name),
             createdAt,
             updatedAt,
             pluralizedName: (0, casing_1.camelCase)((0, pluralize_1.default)(name)),

package/dist/lib/generators/python.js

@@ -99,6 +99,11 @@ class PythonGenerator extends base_1.BaseGenerator {
             createPrimaryKey,
             primaryKeyType,
             snakeCasedName: (0, casing_1.snakeCase)(name),
+            // Honor an explicit per-entity `table` override; otherwise derive from
+            // the entity name. See apsoai/cli#107 (Python/Go parity with #98).
+            tableName: entity.table || (0, casing_1.snakeCase)(name),
+            // Foreign keys name the referenced entity's real table, override included.
+            tableNames: Object.fromEntries(allEntities.map((e) => [e.name, e.table || (0, casing_1.snakeCase)(e.name)])),
             createdAt,
             updatedAt,
             pluralizedName: (0, casing_1.camelCase)((0, pluralize_1.default)(name)),

package/dist/lib/templates/go/models/model.eta

@@ -9,7 +9,7 @@ import (
 <% } %>
 )
 
-// <%= it.name %> represents the <%= it.snakeCasedName %> table
+// <%= it.name %> represents the <%= it.tableName %> table
 type <%= it.name %> struct {
 <% if (it.createPrimaryKey) { %>
 <% if (it.primaryKeyType === 'uuid') { %>
@@ -48,5 +48,5 @@ type <%= it.name %> struct {
 
 // TableName overrides the table name
 func (<%= it.name %>) TableName() string {
-	return "<%= it.snakeCasedName %>"
+	return "<%= it.tableName %>"
 }

package/dist/lib/templates/python/models/model.eta

@@ -25,11 +25,11 @@ if TYPE_CHECKING:
 
 <% /* Generate ManyToMany junction tables */ %>
 <% it.associations.filter(a => a.type === 'ManyToMany' && a.joinTable).forEach((assoc) => { %>
-<%= assoc.joinTableName || `${it.snakeCasedName}_${assoc.name.toLowerCase()}` %> = Table(
-    "<%= assoc.joinTableName || `${it.snakeCasedName}_${assoc.name.toLowerCase()}` %>",
+<%= assoc.joinTableName || `${it.tableName}_${assoc.name.toLowerCase()}` %> = Table(
+    "<%= assoc.joinTableName || `${it.tableName}_${assoc.name.toLowerCase()}` %>",
     Base.metadata,
-    Column("<%= assoc.joinColumnName || `${it.snakeCasedName}_id` %>", <% if (it.primaryKeyType === 'uuid') { %>PGUUID(as_uuid=True)<% } else { %>Integer<% } %>, ForeignKey("<%= it.snakeCasedName %>.id"), primary_key=True),
-    Column("<%= assoc.inverseJoinColumnName || `${assoc.name.toLowerCase()}_id` %>", <% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>PGUUID(as_uuid=True)<% } else { %>Integer<% } %>, ForeignKey("<%= assoc.name.toLowerCase() %>.id"), primary_key=True),
+    Column("<%= assoc.joinColumnName || `${it.tableName}_id` %>", <% if (it.primaryKeyType === 'uuid') { %>PGUUID(as_uuid=True)<% } else { %>Integer<% } %>, ForeignKey("<%= it.tableName %>.id"), primary_key=True),
+    Column("<%= assoc.inverseJoinColumnName || `${assoc.name.toLowerCase()}_id` %>", <% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>PGUUID(as_uuid=True)<% } else { %>Integer<% } %>, ForeignKey("<%= it.tableNames[assoc.name] || assoc.name.toLowerCase() %>.id"), primary_key=True),
 )
 <% }) %>
 
@@ -37,13 +37,13 @@ class <%= it.name %>(Base):
     """
     SQLAlchemy model for <%= it.name %>
     """
-    __tablename__ = "<%= it.snakeCasedName %>"
+    __tablename__ = "<%= it.tableName %>"
 
 <% /* Generate table arguments for indexes and unique constraints */ %>
 <% if ((it.indexes && it.indexes.length > 0) || (it.uniques && it.uniques.length > 0)) { %>
     __table_args__ = (
 <% it.indexes.forEach((index) => { %>
-        Index("<%= index.name || `idx_${it.snakeCasedName}_${index.fields.join('_')}` %>", <%~ index.fields.map(f => `"${f}"`).join(', ') %><% if (index.unique) { %>, unique=True<% } %>),
+        Index("<%= index.name || `idx_${it.tableName}_${index.fields.join('_')}` %>", <%~ index.fields.map(f => `"${f}"`).join(', ') %><% if (index.unique) { %>, unique=True<% } %>),
 <% }) %>
 <% it.uniques.forEach((unique) => { %>
         UniqueConstraint(<%~ unique.fields.map(f => `"${f}"`).join(', ') %><% if (unique.name) { %>, name="<%= unique.name %>"<% } %>),
@@ -93,7 +93,7 @@ columnsToProcess.forEach((field) => { -%>
     # Foreign key for <%= assoc.name %>
     <%= assoc.camelCasedId %>: Mapped[<% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>Optional[UUID]<% } else { %>Optional[int]<% } %>] = mapped_column(
         <% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>PGUUID(as_uuid=True)<% } else { %>Integer<% } %>,
-        ForeignKey("<%= assoc.name.toLowerCase() %>.id"<% if (assoc.cascadeDelete) { %>, ondelete="CASCADE"<% } %>),
+        ForeignKey("<%= it.tableNames[assoc.name] || assoc.name.toLowerCase() %>.id"<% if (assoc.cascadeDelete) { %>, ondelete="CASCADE"<% } %>),
         nullable=<%= assoc.nullable ? 'True' : 'False' %><% if (assoc.index) { %>,
         index=True<% } %>
     )
@@ -105,7 +105,7 @@ columnsToProcess.forEach((field) => { -%>
 <% } else if (assoc.type === 'ManyToMany') { %>
     <%= assoc.pluralizedRelationshipName %>: Mapped[List["<%= assoc.name %>"]] = relationship(
         "<%= assoc.name %>",
-        secondary=<%= assoc.joinTableName || `${it.snakeCasedName}_${assoc.name.toLowerCase()}` %>,
+        secondary=<%= assoc.joinTableName || `${it.tableName}_${assoc.name.toLowerCase()}` %>,
         <% if (assoc.biDirectional) { %>back_populates="<%= assoc.inverseSidePropertyName %>",<% } %>
         lazy="selectin"
     )

package/dist/lib/verify/crud-plan.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What the smoke test creates, reads and deletes: one row per entity, built
+ * from the .apsorc, in an order where every required parent exists first.
+ */
+import { Entity } from "../types/entity";
+import { Field } from "../types/field";
+import { RelationshipMap } from "../types/relationship";
+/** A value for a required field, or undefined when its type can't be filled. */
+export declare function sampleValue(field: Field): unknown;
+export interface PlannedEntity {
+    name: string;
+    payload: Record<string, unknown>;
+    /** Foreign keys to fill from parents created earlier: property -> parent entity. */
+    parents: {
+        property: string;
+        entity: string;
+    }[];
+}
+export interface CrudPlan {
+    /** Parents before children. */
+    order: PlannedEntity[];
+    skipped: {
+        name: string;
+        reason: string;
+    }[];
+}
+export declare function planCrud(entities: Entity[], relationships: RelationshipMap): CrudPlan;

package/dist/lib/verify/crud-plan.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * What the smoke test creates, reads and deletes: one row per entity, built
+ * from the .apsorc, in an order where every required parent exists first.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCrud = exports.sampleValue = void 0;
+const crypto_1 = require("crypto");
+const relationships_1 = require("../utils/relationships");
+const DATE = "2024-01-01T00:00:00.000Z";
+/** A value for a required field, or undefined when its type can't be filled. */
+function sampleValue(field) {
+    var _a, _b;
+    if (field.is_email)
+        return "smoke@example.com";
+    switch (field.type) {
+        case "text":
+        case "string":
+        case "varchar":
+            return "smoke".slice(0, Math.min(5, (_a = field.length) !== null && _a !== void 0 ? _a : 5));
+        case "integer":
+        case "int":
+        case "bigint":
+            return 1;
+        case "decimal":
+        case "numeric":
+        case "float":
+            return 1.5;
+        case "boolean":
+            return true;
+        case "date":
+        case "timestamp":
+        case "timestamptz":
+        case "datetime":
+            return DATE;
+        case "enum":
+            return (_b = field.values) === null || _b === void 0 ? void 0 : _b[0];
+        case "uuid":
+            return (0, crypto_1.randomUUID)();
+        case "json":
+        case "jsonb":
+        case "json-plain":
+            return {};
+        default:
+            return undefined;
+    }
+}
+exports.sampleValue = sampleValue;
+/** Required = not nullable, no default, and not a user-declared primary key. */
+const required = (field) => !field.nullable &&
+    (field.default === undefined || field.default === null) &&
+    !field.primary;
+function planCrud(entities, relationships) {
+    const pending = [];
+    const skipped = [];
+    for (const entity of entities) {
+        const payload = {};
+        const bad = (entity.fields || [])
+            .filter((field) => required(field))
+            .find((field) => {
+            payload[field.name] = sampleValue(field);
+            return payload[field.name] === undefined;
+        });
+        if (bad) {
+            skipped.push({
+                name: entity.name,
+                reason: `required field "${bad.name}" has type "${bad.type}", which the smoke test can't fill`,
+            });
+            continue;
+        }
+        const parents = (relationships[entity.name] || [])
+            .filter((r) => r.type === "ManyToOne" && !r.nullable)
+            .map((r) => ({ property: (0, relationships_1.getRelationshipIdField)(r), entity: r.name }));
+        pending.push({ name: entity.name, payload, parents });
+    }
+    // Topological order: take entities whose required parents are all planned.
+    const order = [];
+    const planned = new Set();
+    let progress = true;
+    while (progress) {
+        progress = false;
+        for (const p of pending) {
+            if (planned.has(p.name))
+                continue;
+            if (p.parents.every((parent) => planned.has(parent.entity))) {
+                order.push(p);
+                planned.add(p.name);
+                progress = true;
+            }
+        }
+    }
+    for (const p of pending) {
+        if (planned.has(p.name))
+            continue;
+        const missing = p.parents
+            .map((parent) => parent.entity)
+            .filter((name) => !planned.has(name));
+        skipped.push({
+            name: p.name,
+            reason: `needs a ${missing.join(", ")} row first, which can't be created (a cycle of required relationships or a skipped entity)`,
+        });
+    }
+    return { order, skipped };
+}
+exports.planCrud = planCrud;

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

@@ -1,6 +1,6 @@
 /**
- * Pre-deploy checks for a generated TypeScript service, run against PGlite:
- * generate the migration from the deployed schema, run it and check for drift,
+ * Pre-deploy checks for a generated service: generate the migration from the
+ * deployed schema, run it and check for drift (TypeScript only, on PGlite),
  * and smoke test the endpoints. The CLI and the in-browser editor (which runs
  * the CLI in a WebContainer) share these steps.
  */
@@ -13,6 +13,9 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+import { Entity } from "../types/entity";
+import { TargetLanguage } from "../types/generator";
+import { RelationshipMap } from "../types/relationship";
 export interface Step {
     name: string;
     ok: boolean;
@@ -30,6 +33,12 @@ export declare const pgliteEnv: (dataDir: string) => NodeJS.ProcessEnv;
  * it, and schema:sync.
  */
 export declare function buildBaseline(projectDir: string, baselineApsorc: string, dataDir: string, cliBin: string): Promise<Step>;
+/**
+ * Why `apso migrate` can't run for this project's language, or undefined.
+ * ponytail: Python (Alembic) and Go (goose) have no local scratch database to
+ * build the baseline on; add when they get one like PGlite for TypeScript.
+ */
+export declare const migrateUnsupported: (language?: TargetLanguage) => string | undefined;
 export interface GenerateResult {
     ok: boolean;
     needed: boolean;
@@ -48,16 +57,22 @@ export declare function supportsPglite(projectDir: string): boolean;
  * database matches the project's entities (a second generate finds nothing).
  */
 export declare function verifyMigration(projectDir: string, baselineApsorc: string, migrationFile: string, cliBin: string, skipBuild?: boolean): Promise<CheckResult>;
+/** The route each language's generated controller serves an entity on. */
+export declare const entityRoute: (language: TargetLanguage, name: string) => string;
+export interface SmokeOptions {
+    skipBuild?: boolean;
+    timeoutMs?: number;
+    language?: TargetLanguage;
+}
 /**
- * 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.
+ * Start the service and call GET /health, every entity's list endpoint, and a
+ * create/read/delete of one row per entity. TypeScript services run on a
+ * PGlite database synced to their entities; Python and Go services run on the
+ * database in DATABASE_URL.
  */
-export declare function smokeTest(projectDir: string, entityNames: string[], { skipBuild, timeoutMs }?: {
-    skipBuild?: boolean | undefined;
-    timeoutMs?: number | undefined;
-}): Promise<CheckResult>;
+export declare function smokeTest(projectDir: string, entities: Entity[], relationships?: RelationshipMap, { skipBuild, timeoutMs, language, }?: SmokeOptions): Promise<CheckResult>;
+/** KEY=value lines of the project's .env; no interpolation. */
+export declare function readDotEnv(projectDir: string): Record<string, string>;
 /** 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. */

package/dist/lib/verify/index.js

@@ -1,12 +1,12 @@
 "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,
+ * Pre-deploy checks for a generated service: generate the migration from the
+ * deployed schema, run it and check for drift (TypeScript only, on PGlite),
  * 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.supportsPglite = exports.generateMigration = exports.buildBaseline = exports.pgliteEnv = exports.run = void 0;
+exports.report = exports.cliBinPath = exports.readDotEnv = exports.smokeTest = exports.entityRoute = exports.verifyMigration = exports.supportsPglite = exports.generateMigration = exports.migrateUnsupported = 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"));
@@ -15,6 +15,8 @@ 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"));
+const casing_1 = require("../utils/casing");
+const crud_plan_1 = require("./crud-plan");
 // eslint-disable-next-line no-control-regex
 const plain = (s) => s.replace(/\u001B\[[\d;]*m/g, "");
 const tail = (s, n = 4000) => {
@@ -83,6 +85,19 @@ async function buildBaseline(projectDir, baselineApsorc, dataDir, cliBin) {
     }
 }
 exports.buildBaseline = buildBaseline;
+/**
+ * Why `apso migrate` can't run for this project's language, or undefined.
+ * ponytail: Python (Alembic) and Go (goose) have no local scratch database to
+ * build the baseline on; add when they get one like PGlite for TypeScript.
+ */
+const migrateUnsupported = (language = "typescript") => {
+    if (language === "python")
+        return "apso migrate supports TypeScript services only for now. This is a Python service: use Alembic directly (alembic revision --autogenerate, alembic upgrade head, alembic check).";
+    if (language === "go")
+        return "apso migrate supports TypeScript services only for now. This is a Go service: write goose migrations in migrations/ and run them with `go run cmd/migrate/main.go up`.";
+    return undefined;
+};
+exports.migrateUnsupported = migrateUnsupported;
 /** 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-"));
@@ -199,93 +214,279 @@ const freePort = () => new Promise((resolve, reject) => {
     });
     s.on("error", reject);
 });
-const get = (url) => new Promise((resolve) => {
+const request = (method, url, body) => new Promise((resolve) => {
+    const data = body === undefined ? undefined : JSON.stringify(body);
+    const headers = data
+        ? {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(data),
+        }
+        : {};
     http
-        .get(url, { timeout: 15000 }, (res) => {
-        let body = "";
+        .request(url, { method, headers, timeout: 15000 }, (res) => {
+        let text = "";
         res.on("data", (d) => {
-            body += d;
+            text += d;
         });
-        res.on("end", () => { var _a; return resolve({ status: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0, body }); });
+        res.on("end", () => { var _a; return resolve({ status: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0, body: text }); });
     })
         .on("timeout", function () {
         this.destroy(new Error("No response within 15s"));
     })
-        .on("error", (e) => resolve({ status: 0, body: e.message }));
+        .on("error", (e) => resolve({ status: 0, body: e.message }))
+        .end(data);
 });
+const get = (url) => request("GET", url);
+const expectStatus = (res, ...ok) => ({
+    ok: ok.includes(res.status),
+    output: ok.includes(res.status)
+        ? undefined
+        : `${res.status} ${tail(res.body, 500)}`,
+});
+const idOf = (body) => {
+    var _a;
+    try {
+        return (_a = JSON.parse(body).id) !== null && _a !== void 0 ? _a : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** The route each language's generated controller serves an entity on. */
+const entityRoute = (language, name) => {
+    const plural = (0, pluralize_1.default)(name);
+    if (language === "python")
+        return `/api/${plural.toLowerCase()}`;
+    if (language === "go")
+        return `/api/${(0, casing_1.kebabCase)(plural)}`;
+    return `/${plural}`;
+};
+exports.entityRoute = entityRoute;
+/* eslint-disable no-await-in-loop */
 /**
- * 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.
+ * List every entity, then create, read and delete one row of each: parents
+ * before children on the way in, children before parents on the way out.
  */
-async function smokeTest(projectDir, entityNames, { skipBuild = false, timeoutMs = 60000 } = {}) {
-    var _a, _b;
-    if (!supportsPglite(projectDir))
-        return NO_PGLITE;
-    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 (!skipBuild && !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) },
+async function checkEndpoints(base, language, entities, relationships, done) {
+    const route = (name) => (0, exports.entityRoute)(language, name);
+    for (const { name } of entities) {
+        done({
+            name: `GET ${route(name)}`,
+            ...expectStatus(await get(base + route(name)), 200),
         });
-        (_a = server.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (d) => {
-            log += d;
+    }
+    const plan = (0, crud_plan_1.planCrud)(entities, relationships);
+    for (const s of plan.skipped)
+        done({ name: `skip ${s.name}`, ok: true, output: s.reason });
+    const ids = new Map();
+    for (const p of plan.order) {
+        const r = route(p.name);
+        const failed = p.parents.find((parent) => !ids.has(parent.entity));
+        if (failed) {
+            done({
+                name: `skip ${p.name}`,
+                ok: true,
+                output: `needs a ${failed.entity} row, which failed to create`,
+            });
+            continue;
+        }
+        const body = { ...p.payload };
+        for (const parent of p.parents)
+            body[parent.property] = ids.get(parent.entity);
+        const created = await request("POST", base + r, body);
+        const id = [200, 201].includes(created.status)
+            ? idOf(created.body)
+            : undefined;
+        if (!done({
+            name: `POST ${r}`,
+            ok: id !== undefined,
+            output: id === undefined
+                ? `${created.status} ${tail(created.body, 500)}`
+                : undefined,
+        }))
+            continue;
+        ids.set(p.name, id);
+        done({
+            name: `GET ${r}/${id}`,
+            ...expectStatus(await get(`${base}${r}/${id}`), 200),
         });
-        (_b = server.stderr) === null || _b === void 0 ? void 0 : _b.on("data", (d) => {
-            log += d;
+    }
+    for (const p of [...plan.order].reverse()) {
+        if (!ids.has(p.name))
+            continue;
+        const url = `${route(p.name)}/${ids.get(p.name)}`;
+        done({
+            name: `DELETE ${url}`,
+            ...expectStatus(await request("DELETE", base + url), 200, 204),
         });
+    }
+}
+/** Wait for the server's /health, run check against it, and stop the server. */
+async function serve(server, port, timeoutMs, done, check) {
+    var _a, _b;
+    let log = "";
+    (_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;
+    });
+    // A command that can't start (e.g. no python3) has no pid; keep its error.
+    server.on("error", (e) => {
+        log += e.message;
+    });
+    try {
         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
+            server.exitCode === null &&
+            server.pid !== undefined) {
             await new Promise((r) => {
                 setTimeout(r, 500);
             });
-            // eslint-disable-next-line no-await-in-loop
             health = await get(`${base}/health`);
         }
-        if (!done({
+        if (done({
             name: "start",
             ok: health.status === 200,
             output: health.status === 200 ? undefined : tail(log),
         }))
+            await check(base);
+    }
+    finally {
+        server.kill();
+    }
+}
+/**
+ * Start the service and call GET /health, every entity's list endpoint, and a
+ * create/read/delete of one row per entity. TypeScript services run on a
+ * PGlite database synced to their entities; Python and Go services run on the
+ * database in DATABASE_URL.
+ */
+async function smokeTest(projectDir, entities, relationships = {}, { skipBuild = false, timeoutMs = 60000, language = "typescript", } = {}) {
+    if (language !== "typescript")
+        return smokeTestOnDatabaseUrl(projectDir, entities, relationships, language, timeoutMs);
+    if (!supportsPglite(projectDir))
+        return NO_PGLITE;
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-pglite-"));
+    const steps = [];
+    const done = (s) => {
+        steps.push(s);
+        return s.ok;
+    };
+    try {
+        if (!skipBuild && !done(step("build", await build(projectDir))))
             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)}`,
-            });
-        }
+        if (!done(step("schema", await typeorm(projectDir, ["schema:sync"], (0, exports.pgliteEnv)(dataDir)))))
+            return { ok: false, steps };
+        const port = await freePort();
+        const server = (0, child_process_1.spawn)(process.execPath, ["dist/main"], {
+            cwd: projectDir,
+            env: { ...process.env, ...(0, exports.pgliteEnv)(dataDir), APP_PORT: String(port) },
+        });
+        await serve(server, port, timeoutMs, done, (base) => checkEndpoints(base, language, entities, relationships, done));
         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;
+/** KEY=value lines of the project's .env; no interpolation. */
+function readDotEnv(projectDir) {
+    let text = "";
+    try {
+        text = fs.readFileSync(path.join(projectDir, ".env"), "utf8");
+    }
+    catch {
+        return {};
+    }
+    const env = {};
+    for (const line of text.split(/\r?\n/)) {
+        const m = line.match(/^\s*(?:export\s+)?([\w.]+)\s*=\s*(.*?)\s*$/);
+        if (m)
+            env[m[1]] = m[2].replace(/^(["'])(.*)\1$/, "$2");
+    }
+    return env;
+}
+exports.readDotEnv = readDotEnv;
+const canConnect = (host, port) => new Promise((resolve) => {
+    const s = net.connect({ host, port, timeout: 3000 });
+    const end = (ok) => {
+        s.destroy();
+        resolve(ok);
+    };
+    s.on("connect", () => end(true));
+    s.on("timeout", () => end(false));
+    s.on("error", () => end(false));
+});
+const skipped = (output) => ({
+    ok: true,
+    steps: [{ name: "skipped", ok: true, output }],
+});
+/**
+ * Python and Go services have no embedded database, so they run against the
+ * one in DATABASE_URL (environment first, then .env), as configured: the
+ * smoke test never creates tables, and it skips when no database answers.
+ */
+async function smokeTestOnDatabaseUrl(projectDir, entities, relationships, language, timeoutMs) {
+    const env = { ...readDotEnv(projectDir), ...process.env };
+    if (!env.DATABASE_URL)
+        return skipped("No DATABASE_URL in the environment or .env, so there is no database to run the service against. Set it and rerun.");
+    let db;
+    try {
+        db = new URL(env.DATABASE_URL);
+    }
+    catch {
+        return {
+            ok: false,
+            steps: [
+                { name: "database", ok: false, output: "DATABASE_URL is not a URL." },
+            ],
+        };
+    }
+    const dbPort = Number(db.port) || 5432;
+    if (!(await canConnect(db.hostname, dbPort)))
+        return skipped(`No database is listening at ${db.hostname}:${dbPort} (DATABASE_URL), so the service can't start. Start the database and rerun.`);
+    const steps = [];
+    const done = (s) => {
+        steps.push(s);
+        return s.ok;
+    };
+    const port = await freePort();
+    const serverEnv = { ...env, PORT: String(port) };
+    const binDir = fs.mkdtempSync(path.join(os.tmpdir(), "apso-smoke-"));
+    try {
+        let server;
+        if (language === "go") {
+            // A built binary, not `go run`: killing `go run` can leave the server running.
+            const bin = path.join(binDir, "server");
+            if (!done(step("build", await run("go", ["build", "-o", bin, "./cmd"], projectDir))))
+                return { ok: false, steps };
+            server = (0, child_process_1.spawn)(bin, [], { cwd: projectDir, env: serverEnv });
+        }
+        else {
+            const venv = path.join(projectDir, ".venv", "bin", "python");
+            const python = fs.existsSync(venv) ? venv : "python3";
+            server = (0, child_process_1.spawn)(python, [
+                "-m",
+                "uvicorn",
+                "app.main:app",
+                "--host",
+                "127.0.0.1",
+                "--port",
+                String(port),
+            ], { cwd: projectDir, env: serverEnv });
+        }
+        await serve(server, port, timeoutMs, done, (base) => checkEndpoints(base, language, entities, relationships, done));
+        return { ok: steps.every((s) => s.ok), steps };
+    }
+    finally {
+        fs.rmSync(binDir, { recursive: true, force: true });
+    }
+}
 /** The CLI's own entry point, for running `generate` in the baseline copy. */
 const cliBinPath = (root) => path.join(root, "bin", "run");
 exports.cliBinPath = cliBinPath;

package/npm-shrinkwrap.json

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

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.42.1",
+  "version": "0.43.0",
   "commands": {
     "config": {
       "id": "config",
@@ -997,7 +997,7 @@
     },
     "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)",
+      "description": "Start the service and call /health, every entity's list endpoint, and a create/read/delete of one row per entity. TypeScript services run on a local PGlite database; Python and Go services run on the database in DATABASE_URL (rows are created and deleted there, tables are not created) and the check is skipped when none answers",
       "strict": true,
       "pluginName": "@apso/cli",
       "pluginAlias": "@apso/cli",
@@ -1011,7 +1011,7 @@
         "skip-build": {
           "name": "skip-build",
           "type": "boolean",
-          "description": "Use the existing dist/ build instead of building first",
+          "description": "Use the existing dist/ build instead of building first (TypeScript)",
           "allowNo": false
         },
         "json": {

package/package.json

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