@apso/cli 0.43.4 → 0.45.0

package/dist/lib/plan/index.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planWithAnswers = exports.planMigration = exports.openQuestions = exports.isAnswered = exports.hashSchema = void 0;
+/**
+ * The migration plan: compare the deployed .apsorc with the new one and list
+ * every change whose intent the schema alone can't settle (a removed field
+ * might be renamed, split, moved or dropped). Each becomes a question; the
+ * user's own agent answers it, and the answers are kept in the plan file so
+ * the same plan always renders the same migration.
+ *
+ * Question ids come from the change itself, so re-planning after another
+ * .apsorc edit keeps every answer whose question still exists.
+ */
+const crypto_1 = require("crypto");
+const field_1 = require("../utils/field");
+const hashSchema = (s) => {
+    var _a;
+    return "sha256:" +
+        (0, crypto_1.createHash)("sha256")
+            .update(JSON.stringify({
+            entities: s.entities,
+            relationships: (_a = s.relationships) !== null && _a !== void 0 ? _a : [],
+        }))
+            .digest("hex");
+};
+exports.hashSchema = hashSchema;
+const STRING_TYPES = new Set(["text", "varchar", "char", "string"]);
+const sameType = (a, b) => {
+    const ta = (0, field_1.normalizeFieldType)(a.type);
+    const tb = (0, field_1.normalizeFieldType)(b.type);
+    return ta === tb || (STRING_TYPES.has(ta) && STRING_TYPES.has(tb));
+};
+const fieldsOf = (e) => { var _a; return (_a = e === null || e === void 0 ? void 0 : e.fields) !== null && _a !== void 0 ? _a : []; };
+const byName = (list, name) => list.find((x) => x.name === name);
+const fieldSignature = (e) => fieldsOf(e)
+    .map((f) => `${f.name}:${(0, field_1.normalizeFieldType)(f.type)}`)
+    .sort()
+    .join(",");
+const relates = (rels, a, b) => rels.some((r) => (r.from === a && r.to === b) || (r.from === b && r.to === a));
+/** Every answer this question will accept is valid; anything else stays open. */
+function isAnswered(q) {
+    if (!q.answer || !q.options.includes(q.answer))
+        return false;
+    if (q.answer === "sql")
+        return typeof q.sql === "string" && q.sql.trim() !== "";
+    if (q.answer.startsWith("split:")) {
+        const targets = q.answer.slice("split:".length).split(",");
+        const sql = q.sql;
+        return (typeof sql === "object" &&
+            sql !== null &&
+            targets.every((t) => typeof sql[t] === "string" && sql[t].trim() !== ""));
+    }
+    return true;
+}
+exports.isAnswered = isAnswered;
+const openQuestions = (plan) => plan.questions.filter((q) => !isAnswered(q));
+exports.openQuestions = openQuestions;
+/** Added fields an answer already accounts for (a rename, split or move target). */
+function claimedTargets(questions) {
+    const claimed = new Set();
+    for (const q of questions) {
+        if (!q.answer)
+            continue;
+        const entity = q.id.slice(q.id.indexOf(":") + 1).split(".")[0];
+        if (q.answer.startsWith("rename:"))
+            claimed.add(`${entity}.${q.answer.slice(7)}`);
+        if (q.answer.startsWith("split:"))
+            for (const t of q.answer.slice(6).split(","))
+                claimed.add(`${entity}.${t}`);
+        if (q.answer.startsWith("move:"))
+            claimed.add(q.answer.slice(5));
+    }
+    return claimed;
+}
+/** Added fields some still-open question may yet claim. */
+function pendingTargets(questions) {
+    const pending = new Set();
+    for (const q of questions) {
+        if (q.answer || q.kind !== "removedField")
+            continue;
+        const entity = q.id.slice(q.id.indexOf(":") + 1).split(".")[0];
+        for (const o of q.options) {
+            if (o.startsWith("rename:"))
+                pending.add(`${entity}.${o.slice(7)}`);
+            if (o.startsWith("split:"))
+                for (const t of o.slice(6).split(","))
+                    pending.add(`${entity}.${t}`);
+            if (o.startsWith("move:"))
+                pending.add(o.slice(5));
+        }
+    }
+    return pending;
+}
+function planMigration(before, after, previous) {
+    var _a, _b, _c;
+    const questions = [];
+    const beforeRels = (_a = before.relationships) !== null && _a !== void 0 ? _a : [];
+    const afterRels = (_b = after.relationships) !== null && _b !== void 0 ? _b : [];
+    const added = after.entities.filter((e) => !byName(before.entities, e.name));
+    // Removed entities: rename to an added entity with the same fields, or drop.
+    for (const old of before.entities.filter((e) => !byName(after.entities, e.name))) {
+        const matches = added.filter((e) => fieldSignature(e) === fieldSignature(old));
+        questions.push({
+            id: `entity:${old.name}`,
+            kind: "removedEntity",
+            subject: `Entity ${old.name} is gone`,
+            options: [...matches.map((e) => `rename:${e.name}`), "drop"],
+            ...(matches.length === 1
+                ? { suggested: `rename:${matches[0].name}` }
+                : {}),
+        });
+    }
+    for (const now of after.entities) {
+        const was = byName(before.entities, now.name);
+        if (!was)
+            continue;
+        const addedFields = fieldsOf(now).filter((f) => !byName(fieldsOf(was), f.name));
+        for (const old of fieldsOf(was)) {
+            const cur = byName(fieldsOf(now), old.name);
+            if (!cur) {
+                // Removed field: rename, split, move to a new related entity, or drop.
+                const same = addedFields.filter((f) => sameType(f, old));
+                const moves = added
+                    .filter((e) => relates(afterRels, e.name, now.name))
+                    .flatMap((e) => fieldsOf(e)
+                    .filter((f) => sameType(f, old))
+                    .map((f) => `move:${e.name}.${f.name}`));
+                const options = [
+                    ...same.map((f) => `rename:${f.name}`),
+                    ...(same.length > 1
+                        ? [`split:${same.map((f) => f.name).join(",")}`]
+                        : []),
+                    ...moves,
+                    "drop",
+                ];
+                const readings = options.length - 1;
+                questions.push({
+                    id: `field:${now.name}.${old.name}`,
+                    kind: "removedField",
+                    subject: `Field ${now.name}.${old.name} (${old.type}) is gone`,
+                    options,
+                    ...(readings === 1 && same.length === 1
+                        ? { suggested: options[0] }
+                        : {}),
+                });
+                continue;
+            }
+            if (!sameType(cur, old)) {
+                questions.push({
+                    id: `cast:${now.name}.${old.name}`,
+                    kind: "cast",
+                    subject: `Field ${now.name}.${old.name} changes type from ${old.type} to ${cur.type}`,
+                    options: ["cast", "sql"],
+                });
+            }
+            else if (old.values && cur.values) {
+                for (const v of old.values.filter((v) => !cur.values.includes(v))) {
+                    questions.push({
+                        id: `enum:${now.name}.${old.name}:${v}`,
+                        kind: "enumValue",
+                        subject: `Enum value '${v}' is removed from ${now.name}.${old.name}`,
+                        options: [...cur.values],
+                    });
+                }
+            }
+            if (old.nullable && !cur.nullable && cur.default === undefined) {
+                questions.push({
+                    id: `backfill:${now.name}.${old.name}`,
+                    kind: "backfill",
+                    subject: `Field ${now.name}.${old.name} becomes required; rows where it is null need a value`,
+                    options: cur.values ? [...cur.values, "sql"] : ["sql"],
+                });
+            }
+        }
+    }
+    // Relationships between the same two entities that change kind or vanish.
+    for (const r of beforeRels.filter((r) => r.type === "ManyToOne")) {
+        if (!byName(after.entities, r.from) || !byName(after.entities, r.to))
+            continue;
+        const kept = afterRels.some((x) => x.type === "ManyToOne" && x.from === r.from && x.to === r.to);
+        if (kept)
+            continue;
+        const toMany = afterRels.some((x) => x.type === "ManyToMany" &&
+            ((x.from === r.from && x.to === r.to) ||
+                (x.from === r.to && x.to === r.from)));
+        questions.push({
+            id: `relation:${r.from}.${r.to}`,
+            kind: "relation",
+            subject: toMany
+                ? `${r.from} ManyToOne ${r.to} becomes ManyToMany`
+                : `${r.from} ManyToOne ${r.to} is removed`,
+            options: toMany ? ["copy-links", "drop-links"] : ["drop-links"],
+        });
+    }
+    // Carry answers over from the previous plan before deciding on backfills,
+    // which depend on what the removed-field answers claimed.
+    const prev = new Map(((_c = previous === null || previous === void 0 ? void 0 : previous.questions) !== null && _c !== void 0 ? _c : []).map((q) => [q.id, q]));
+    const carry = (q) => {
+        const p = prev.get(q.id);
+        if (!(p === null || p === void 0 ? void 0 : p.answer) || !q.options.includes(p.answer))
+            return q;
+        return {
+            ...q,
+            answer: p.answer,
+            ...(p.sql === undefined ? {} : { sql: p.sql }),
+        };
+    };
+    const answeredSoFar = questions.map((q) => carry(q));
+    // New required fields on existing tables need a value for existing rows,
+    // unless a rename, split or move fills them, or an open question still might.
+    const claimed = claimedTargets(answeredSoFar);
+    const pending = pendingTargets(answeredSoFar);
+    for (const now of after.entities) {
+        const was = byName(before.entities, now.name);
+        if (!was)
+            continue;
+        for (const f of fieldsOf(now)) {
+            if (byName(fieldsOf(was), f.name) ||
+                f.nullable ||
+                f.default !== undefined)
+                continue;
+            const key = `${now.name}.${f.name}`;
+            if (claimed.has(key) || pending.has(key))
+                continue;
+            answeredSoFar.push(carry({
+                id: `backfill:${key}`,
+                kind: "backfill",
+                subject: `New required field ${key} needs a value for existing rows`,
+                options: f.values ? [...f.values, "sql"] : ["sql"],
+            }));
+        }
+    }
+    return {
+        version: 1,
+        from: (0, exports.hashSchema)(before),
+        to: (0, exports.hashSchema)(after),
+        questions: answeredSoFar,
+    };
+}
+exports.planMigration = planMigration;
+/**
+ * Plan with --answer values (<question id>=<option>) applied on top of the
+ * plan in progress. Throws a message for the user when an answer is malformed,
+ * names no question, or is not one of its options.
+ */
+function planWithAnswers(before, after, previous, answers) {
+    const given = new Map();
+    for (const a of answers) {
+        const eq = a.indexOf("=");
+        if (eq < 1)
+            throw new Error(`--answer must be <question id>=<option>, got "${a}"`);
+        given.set(a.slice(0, eq), a.slice(eq + 1));
+    }
+    const seed = previous !== null && previous !== void 0 ? previous : { version: 1, from: "", to: "", questions: [] };
+    for (const [id, answer] of given) {
+        const q = seed.questions.find((x) => x.id === id);
+        if (q)
+            q.answer = answer;
+        else
+            seed.questions.push({ id, kind: "removedField", subject: "", options: [], answer });
+    }
+    const plan = planMigration(before, after, seed);
+    for (const [id, answer] of given) {
+        const q = plan.questions.find((x) => x.id === id);
+        if (!q)
+            throw new Error(`No question "${id}" in this plan.`);
+        if (!q.options.includes(answer))
+            throw new Error(`"${answer}" is not an option for ${id}. Options: ${q.options.join(", ")}`);
+    }
+    return plan;
+}
+exports.planWithAnswers = planWithAnswers;

package/dist/lib/plan/prompts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Words for asking a plan question in a terminal: what each option does to
+ * the data, a hint for SQL answers, and a starting rule for a two-way split.
+ */
+import { Question } from ".";
+export declare function optionLabel(q: Question, o: string): string;
+export declare function sqlHint(q: Question): string;
+/** A two-way split on the first space: "Ada Lovelace" -> Ada / Lovelace, "Cher" -> Cher / null. */
+export declare function splitDefaults(q: Question, targets: string[]): Record<string, string>;
+/**
+ * A question as an app or agent shows it: each option's words, a hint when an
+ * option needs SQL, and a starting rule for each two-way split option.
+ */
+export declare function describeQuestion(q: Question): Question & {
+    labels: Record<string, string>;
+    sqlHint?: string;
+    splitDefaults?: Record<string, Record<string, string>>;
+};

package/dist/lib/plan/prompts.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeQuestion = exports.splitDefaults = exports.sqlHint = exports.optionLabel = void 0;
+const after = (o, prefix) => o.slice(prefix.length);
+function optionLabel(q, o) {
+    let label = o;
+    switch (q.kind) {
+        case "removedField":
+            if (o.startsWith("rename:"))
+                label = `Renamed to ${after(o, "rename:")} (keeps the data)`;
+            else if (o.startsWith("split:"))
+                label = `Split into ${after(o, "split:").split(",").join(" and ")} (you give the rule)`;
+            else if (o.startsWith("move:"))
+                label = `Moved to ${after(o, "move:")} (copies the existing values)`;
+            else if (o === "drop")
+                label = "Dropped (deletes its data)";
+            break;
+        case "removedEntity":
+            if (o.startsWith("rename:"))
+                label = `Renamed to ${after(o, "rename:")} (keeps its rows)`;
+            else if (o === "drop")
+                label = "Dropped (deletes its rows)";
+            break;
+        case "enumValue":
+            label = `Change those rows to '${o}'`;
+            break;
+        case "backfill":
+            label = o === "sql" ? "Use a SQL expression" : `Set existing rows to '${o}'`;
+            break;
+        case "cast":
+            label = o === "sql" ? "Use a SQL expression to convert" : "Convert each value as it is (fails on values that don't convert)";
+            break;
+        case "relation":
+            label = o === "copy-links" ? "Copy each existing link into the new join table" : "Start with no links (deletes them)";
+            break;
+        default:
+            break;
+    }
+    return o === q.suggested ? `${label} (suggested)` : label;
+}
+exports.optionLabel = optionLabel;
+const fieldOf = (q) => { var _a, _b; return (_b = (_a = q.id.slice(q.id.indexOf(":") + 1).split(".")[1]) === null || _a === void 0 ? void 0 : _a.split(":")[0]) !== null && _b !== void 0 ? _b : ""; };
+function sqlHint(q) {
+    const f = fieldOf(q);
+    return q.kind === "cast"
+        ? `SQL that converts "${f}", e.g. NULLIF("${f}", '')::integer`
+        : `SQL for "${f}" on existing rows, e.g. 'unknown' or another column`;
+}
+exports.sqlHint = sqlHint;
+/** A two-way split on the first space: "Ada Lovelace" -> Ada / Lovelace, "Cher" -> Cher / null. */
+function splitDefaults(q, targets) {
+    if (targets.length !== 2)
+        return {};
+    const src = `"${fieldOf(q)}"`;
+    const first = `split_part(btrim(${src}), ' ', 1)`;
+    return {
+        [targets[0]]: first,
+        [targets[1]]: `NULLIF(btrim(substr(btrim(${src}), length(${first}) + 1)), '')`,
+    };
+}
+exports.splitDefaults = splitDefaults;
+/**
+ * A question as an app or agent shows it: each option's words, a hint when an
+ * option needs SQL, and a starting rule for each two-way split option.
+ */
+function describeQuestion(q) {
+    const splits = q.options.filter((o) => o.startsWith("split:"));
+    return {
+        ...q,
+        labels: Object.fromEntries(q.options.map((o) => [o, optionLabel(q, o)])),
+        ...(q.options.includes("sql") && { sqlHint: sqlHint(q) }),
+        ...(splits.length > 0 && {
+            splitDefaults: Object.fromEntries(splits.map((o) => [o, splitDefaults(q, after(o, "split:").split(","))])),
+        }),
+    };
+}
+exports.describeQuestion = describeQuestion;

package/dist/lib/templates/go/index-module.eta

@@ -4,6 +4,7 @@ package routes
 
 import (
 <% if (httpEntities.length > 0) { %>	"app/autogen/handlers"
+<% } %><% if (it.hasAuth) { %>	"app/autogen/middleware"
 <% } %>	"app/autogen/services"
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
@@ -11,6 +12,11 @@ import (
 
 // RegisterAllRoutes registers all entity routes
 func RegisterAllRoutes(r *gin.RouterGroup, db *gorm.DB) {
+<% if (it.hasAuth) { %>
+	// Every route in this group requires authentication (.apsorc auth).
+	r.Use(middleware.AuthMiddleware(db))
+
+<% } %>
 <% httpEntities.forEach((entity) => { %>
 	// <%= entity.name %> routes
 	<%= entity.camelName %>Service := services.New<%= entity.name %>Service(db)