primitive-admin 1.2.0-alpha.1 → 1.2.0-alpha.11

package/dist/src/commands/databases.js

@@ -2,13 +2,11 @@ import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, rea
 import * as path from "path";
 import { ApiClient } from "../lib/api-client.js";
 import { getCurrentAppId, resolveAppId } from "../lib/config.js";
-import { resolveCodegenSourceDir } from "../lib/codegen-shared/resolveCodegenSourceDir.js";
 import { resolveSyncDir } from "../lib/sync-paths.js";
 import { parseCsv, applyColumnMap, buildRows } from "../lib/csv.js";
 import { chunk, parseBatchSize } from "../lib/batch.js";
-import { generateDbTypes, } from "../lib/db-codegen/dbGenerator.js";
-import { generateDbSwiftTypes } from "../lib/swift-codegen/dbGenerator.js";
 import { success, error, info, warn, keyValue, result as printResult, formatTable, formatId, formatDate, json, } from "../lib/output.js";
+import { renderAggregateResult } from "../lib/aggregate-output.js";
 import { confirmPrompt } from "../lib/confirm-prompt.js";
 import { parseFilterOptions } from "../lib/record-filter.js";
 import { parseDataOption } from "../lib/data-input.js";
@@ -52,49 +50,6 @@ function assertDataIdMatches(data, recordId, writtenId, commandPath) {
         : `Pass the record id as the argument, not inside --data: ${commandPath} ${dataId} --data ...`);
     process.exit(1);
 }
-/**
- * Validate that the named operation is an import-compatible, save-like
- * mutation before importing (issue #145, Codex finding (a)).
- *
- * The importer always builds `params: { modelName, id, data }`, and the batch
- * endpoint rejects undeclared params per item. So we require the op to be a
- * `mutation` whose declared `params` cover `modelName`, `id`, and `data`. This
- * surfaces a clear up-front error instead of letting every row fail
- * server-side. Exits non-zero on any mismatch.
- */
-async function validateImportOperation(client, appId, databaseId, operationName) {
-    let ops;
-    try {
-        ops = await client.listDatabaseOperations(appId, databaseId);
-    }
-    catch (err) {
-        error(`Could not list operations for this database: ${err?.message || err}`);
-        process.exit(1);
-        return;
-    }
-    const op = (ops || []).find((o) => o?.name === operationName);
-    if (!op) {
-        error(`Operation "${operationName}" not found — create a mutation op (e.g. ` +
-            `\`seed_save\`) on this database type first.`);
-        process.exit(1);
-        return;
-    }
-    if (op.type !== "mutation") {
-        error(`Operation "${operationName}" is a "${op.type}" op, not an import-compatible ` +
-            `mutation. CSV import needs a save-like mutation taking {modelName, id, data}.`);
-        process.exit(1);
-        return;
-    }
-    const params = op.params || {};
-    const missing = ["modelName", "id", "data"].filter((p) => !(p in params));
-    if (missing.length > 0) {
-        error(`Operation "${operationName}" is not import-compatible: its params are missing ` +
-            `${missing.join(", ")}. CSV import builds {modelName, id, data} per item, so the ` +
-            `op must declare those params (like \`seed_save\`).`);
-        process.exit(1);
-        return;
-    }
-}
 /**
  * The full `databases records bulk` precondition value space, audited in one
  * pass (issue #2437, Codex cycle 3). A precondition is field-equality only, so
@@ -760,43 +715,18 @@ database-type-config' and the 'database-type-configs' group for inspection:
                 json(result);
                 return;
             }
-            const aggregated = result?.result;
-            // Label the value column after the operation, including the field it
-            // ran over: `SUM` alone does not say what was summed. The field name is
-            // reproduced verbatim in both labels — it is a user-supplied
-            // identifier, and case-folding it produced `avg(lastvalue)` for
-            // `--field lastValue` (issue #2357).
-            const valueLabel = options.op === "count"
-                ? "COUNT"
-                : `${options.op.toUpperCase()}(${options.field})`;
-            const scalarLabel = options.op === "count"
-                ? "count"
-                : `${options.op.toLowerCase()}(${options.field})`;
-            if (groupBy.length === 0) {
-                // Ungrouped: one scalar per operation, keyed by the endpoint's
-                // operation name (`count`, `sum_<field>`, …). Render it as a
-                // key/value line — there is no group column to table.
-                const value = (aggregated ?? {})[options.op === "count" ? "count" : `${options.op}_${options.field}`];
-                keyValue(scalarLabel, value === null || value === undefined ? "—" : String(value));
-                return;
-            }
-            if (aggregated &&
-                typeof aggregated === "object" &&
-                !Array.isArray(aggregated) &&
-                Object.values(aggregated).every((v) => typeof v !== "object" || v === null)) {
-                // Flat { group -> value } shape (single operation, single group-by): render a table.
-                const rows = Object.entries(aggregated).map(([group, value]) => ({
-                    group,
-                    value: value === null || value === undefined ? "—" : String(value),
-                }));
-                console.log(formatTable(rows, [
-                    { header: "GROUP", key: "group" },
-                    { header: valueLabel, key: "value" },
-                ]));
+            // The route answers rows (#4265): one key/value line when
+            // ungrouped, a table with one column per group key when grouped.
+            const rendered = renderAggregateResult(result?.result, {
+                groupBy,
+                op: options.op,
+                field: options.field,
+            });
+            if (rendered.kind === "scalar") {
+                keyValue(rendered.label, rendered.value);
             }
             else {
-                // Grouped/nested or multi-operation shape: print the structured result.
-                console.log(JSON.stringify(aggregated ?? {}, null, 2));
+                console.log(rendered.text);
             }
         }
         catch (err) {
@@ -1182,145 +1112,6 @@ database-type-config' and the 'database-type-configs' group for inspection:
             process.exit(1);
         }
     });
-    // ---- Operations subcommand group ----
-    const operations = databases
-        .command("operations")
-        .description("List and execute registered operations on a database");
-    // List operations
-    operations
-        .command("list")
-        .description("List registered operations available on a database")
-        .argument("<database-id>", "Database ID")
-        .option("--app <app-id>", "App ID")
-        .option("--json", "Output as JSON")
-        .action(async (databaseId, options) => {
-        const resolvedAppId = resolveAppId(undefined, options);
-        const client = new ApiClient();
-        try {
-            const result = await client.listDatabaseOperations(resolvedAppId, databaseId);
-            const list = Array.isArray(result) ? result : [];
-            if (options.json) {
-                json(wholeListEnvelope(list));
-                return;
-            }
-            if (list.length === 0) {
-                info("No operations found.");
-                return;
-            }
-            console.log(formatTable(list, [
-                { header: "NAME", key: "name" },
-                { header: "TYPE", key: "type" },
-                { header: "MODEL", key: "modelName" },
-                { header: "ACCESS", key: "access" },
-            ]));
-        }
-        catch (err) {
-            error(err.message);
-            process.exit(1);
-        }
-    });
-    // Execute operation
-    operations
-        .command("execute")
-        .description("Execute a registered operation on a database")
-        .argument("<database-id>", "Database ID")
-        .argument("<operation-name>", "Operation name")
-        .option("--params <json>", "Operation parameters as JSON")
-        .option("--limit <n>", "Max records to return (for queries)")
-        .option("--cursor <cursor>", "Pagination cursor")
-        .option("--token <jwt>", "Execute as a specific user (dev/test — JWT visible in process args)")
-        .option("--app <app-id>", "App ID")
-        .option("--json", "Output as JSON")
-        .option("--timing", "Show server-side timing breakdown")
-        .action(async (databaseId, operationName, options) => {
-        const resolvedAppId = resolveAppId(undefined, options);
-        const client = new ApiClient();
-        let params;
-        if (options.params) {
-            try {
-                params = JSON.parse(options.params);
-            }
-            catch {
-                error("Invalid --params JSON.");
-                process.exit(1);
-                return;
-            }
-        }
-        const body = {};
-        if (params)
-            body.params = params;
-        if (options.limit)
-            body.limit = parseInt(options.limit, 10);
-        if (options.cursor)
-            body.cursor = options.cursor;
-        try {
-            const result = await client.executeDatabaseOperation(resolvedAppId, databaseId, operationName, body, options.token, { timing: !!options.timing });
-            if (options.json) {
-                json(result);
-                return;
-            }
-            // Smart display based on result shape. `executeDatabaseOperation()`
-            // has already normalized a query page to `{ items, hasMore,
-            // nextCursor? }` (#2440), so `items` is exactly "this result was a
-            // list" — the two branches cannot disagree about it.
-            if (Array.isArray(result.items)) {
-                if (result.items.length === 0) {
-                    info("No records found.");
-                }
-                else {
-                    const cols = Object.keys(result.items[0]).filter((k) => k !== "type");
-                    console.log(formatTable(result.items, cols.map((c) => ({
-                        header: c.toUpperCase(),
-                        key: c,
-                        format: (v) => {
-                            if (v === null || v === undefined)
-                                return "—";
-                            if (typeof v === "object") {
-                                const s = JSON.stringify(v);
-                                return s.length > 50 ? s.slice(0, 47) + "..." : s;
-                            }
-                            const s = String(v);
-                            return s.length > 50 ? s.slice(0, 47) + "..." : s;
-                        },
-                    }))));
-                }
-                // Gate on the cursor itself, the way `records query` does: `hasMore`
-                // without a cursor used to print the literal `undefined` (#2440).
-                if (result.nextCursor) {
-                    info(`More records available. Use --cursor ${result.nextCursor} to continue.`);
-                }
-            }
-            else if (result.count !== undefined) {
-                console.log(`Count: ${result.count}`);
-            }
-            else if (result.result !== undefined) {
-                // Aggregate result
-                json(result);
-            }
-            else if (result.results && Array.isArray(result.results)) {
-                // Batch/mutation results
-                success(`Operation executed (${result.results.length} result${result.results.length === 1 ? "" : "s"}).`);
-            }
-            else if (result.success !== undefined) {
-                success("Operation executed.");
-            }
-            else {
-                json(result);
-            }
-            // Display timing if present
-            if (result._timing) {
-                console.log("");
-                console.log("Timing:");
-                for (const [key, value] of Object.entries(result._timing)) {
-                    console.log(`  ${key}: ${value}ms`);
-                }
-            }
-        }
-        catch (err) {
-            error(err.message);
-            process.exit(1);
-        }
-    });
     // ---- Indexes subcommand group ----
     const indexes = databases
         .command("indexes")
@@ -1576,6 +1367,11 @@ database-type-config' and the 'database-type-configs' group for inspection:
                 info("No databases to import.");
                 return;
             }
+            // Check every database's files before writing anything, so a malformed
+            // export fails without leaving a database behind. Each one is read
+            // again as it is imported rather than holding every export's records.
+            for (const dbDir of dbDirs)
+                readDatabaseExport(dbDir);
             const summary = {
                 created: 0,
                 updated: 0,
@@ -1586,6 +1382,7 @@ database-type-config' and the 'database-type-configs' group for inspection:
                 aborted: false,
                 indexesRegistered: 0,
                 batchErrors: [],
+                databases: [],
             };
             for (const dbDir of dbDirs) {
                 await importSingleDatabase(client, resolvedAppId, dbDir, {
@@ -1641,11 +1438,10 @@ database-type-config' and the 'database-type-configs' group for inspection:
     // ============================================
     databases
         .command("import-csv")
-        .description("Import rows from a CSV file into a database via a registered batch (bulk) save operation")
+        .description("Import rows from a CSV file into a database: one save per row through records/batch, best-effort (a row the database refuses is counted as failed and the rest are written)")
         .argument("<database-id>", "Database ID")
         .argument("<file>", "Path to the CSV file")
-        .requiredOption("--model <name>", "Model name passed in each item's params")
-        .option("--operation <op>", "Registered mutation operation to use (must be a {modelName,id,data} save-like op)", "seed_save")
+        .requiredOption("--model <name>", "Model every row is saved into")
         .option("--column-map <json>", 'Map CSV headers to field names, e.g. \'{"CSV Header":"fieldName"}\'')
         .option("--types <json>", 'Coerce fields by type, e.g. \'{"price":"number","active":"boolean"}\'')
         .option("--id-column <col>", "Use this CSV column for record ids (else a ULID is generated)")
@@ -1681,11 +1477,11 @@ database-type-config' and the 'database-type-configs' group for inspection:
                 return;
             }
         }
-        // The registered-batch (`executeBatch`) path rejects requests over
-        // 100000 items server-side; keep chunks under it.
+        // `records/batch` has no fixed server item cap — bound it with the same
+        // conservative client-side ceiling `databases import` uses.
         const parsedBatchSize = parseBatchSize(options.batchSize, {
-            max: 100000,
-            overMaxMessage: "--batch-size cannot exceed 100000 (the server's per-request cap).",
+            max: IMPORT_BATCH_SIZE_CEILING,
+            overMaxMessage: `--batch-size cannot exceed ${IMPORT_BATCH_SIZE_CEILING} (a conservative client-side limit for batch write requests).`,
         });
         if ("error" in parsedBatchSize) {
             error(parsedBatchSize.error);
@@ -1704,21 +1500,14 @@ database-type-config' and the 'database-type-configs' group for inspection:
             let rows = parseCsv(raw, options.delimiter);
             // 2. Apply column map.
             rows = applyColumnMap(rows, columnMap);
-            // 3. Coerce types, assign ids, shape into batch items.
+            // 3. Coerce types, assign ids, shape into records/batch saves.
             const { batch, rowCount } = buildRows(rows, {
                 modelName: options.model,
                 types,
                 idColumn: options.idColumn,
             });
             const chunks = chunk(batch, batchSize);
-            // 4. Validate the chosen op is an import-compatible save-like mutation
-            //    BEFORE writing (op-not-found / incompatible → clear up-front error
-            //    rather than per-row server-side failure). Skip the round-trip only
-            //    when there is genuinely nothing to import in a dry run.
-            if (!options.dryRun || rowCount > 0) {
-                await validateImportOperation(client, resolvedAppId, databaseId, options.operation);
-            }
-            // 5. Empty / headers-only CSV: no request, report 0/0.
+            // 4. Empty / headers-only CSV: no request, report 0/0.
             if (rowCount === 0) {
                 if (options.json) {
                     json({ imported: 0, failed: 0, rows: 0, batches: 0, errors: [], dryRun: !!options.dryRun });
@@ -1729,7 +1518,7 @@ database-type-config' and the 'database-type-configs' group for inspection:
                 }
                 return;
             }
-            // 6. Dry run: report counts, no writes.
+            // 5. Dry run: report counts, no writes.
             if (options.dryRun) {
                 if (options.json) {
                     json({ dryRun: true, rows: rowCount, batches: chunks.length, batchSize });
@@ -1742,32 +1531,60 @@ database-type-config' and the 'database-type-configs' group for inspection:
                 }
                 return;
             }
-            // 7. Import chunk by chunk; accumulate imported/failed + per-chunk errors.
+            // 6. Import chunk by chunk through records/batch, non-atomic (the
+            //    route's default): each row's outcome is its own, so a refused row
+            //    is counted failed and its siblings commit.
             let imported = 0;
             let failed = 0;
             const errors = [];
             let aborted = false;
             for (let i = 0; i < chunks.length; i++) {
                 const piece = chunks[i];
+                let chunkFailed = false;
                 try {
-                    const res = await client.executeBatch(resolvedAppId, databaseId, options.operation, piece);
-                    imported += res.imported ?? 0;
-                    failed += res.failed ?? 0;
+                    const res = await client.batchDatabaseRecords(resolvedAppId, databaseId, piece);
+                    const results = res?.results ?? [];
+                    let chunkImported = 0;
+                    let chunkRefused = 0;
+                    const firstErrors = [];
+                    for (let j = 0; j < piece.length; j++) {
+                        const r = results[j];
+                        if (r && r.success) {
+                            chunkImported++;
+                        }
+                        else {
+                            chunkRefused++;
+                            if (r?.error && firstErrors.length < 3)
+                                firstErrors.push(r.error);
+                        }
+                    }
+                    imported += chunkImported;
+                    failed += chunkRefused;
+                    if (chunkRefused > 0) {
+                        chunkFailed = true;
+                        errors.push({
+                            batch: i,
+                            error: `${chunkRefused} row(s) failed${firstErrors.length ? `: ${firstErrors.join("; ")}` : ""}`,
+                        });
+                    }
                     if (!options.json) {
-                        info(`Batch ${i + 1}/${chunks.length}: imported ${res.imported ?? 0}, failed ${res.failed ?? 0}`);
+                        info(`Batch ${i + 1}/${chunks.length}: imported ${chunkImported}, failed ${chunkRefused}`);
                     }
                 }
                 catch (err) {
+                    // A chunk-level failure (a 400 for a malformed op): the whole
+                    // chunk was refused, so every row in it counts as failed.
                     const msg = err?.message || String(err);
+                    chunkFailed = true;
                     errors.push({ batch: i, error: msg });
                     failed += piece.length;
                     if (!options.json) {
                         warn(`Batch ${i + 1}/${chunks.length} failed: ${msg}`);
                     }
-                    if (options.stopOnError) {
-                        aborted = true;
-                        break;
-                    }
+                }
+                if (chunkFailed && options.stopOnError) {
+                    aborted = true;
+                    break;
                 }
             }
             if (options.json) {
@@ -1785,7 +1602,7 @@ database-type-config' and the 'database-type-configs' group for inspection:
                     }
                 }
             }
-            // Non-zero exit if any chunk errored.
+            // Non-zero exit if any row or chunk failed.
             if (errors.length > 0) {
                 process.exit(1);
             }
@@ -1803,7 +1620,7 @@ database-type-config' and the 'database-type-configs' group for inspection:
         .description("Manage the TOML schema attached to a database type");
     schema
         .command("generate")
-        .description("Scaffold a starting TOML schema for <database-type> from existing operations + DO introspection, and insert it into the local database-type-configs/<type>.toml file.")
+        .description("Scaffold a starting TOML schema for <database-type> from the models and fields its databases hold, and append it to the local database-type-configs/<type>.toml file.")
         .argument("<database-type>", "Database type name")
         .option("-f, --force", "Overwrite an existing [models.*] block in the local file")
         .option("--json", "Output the generated TOML as JSON")
@@ -1842,10 +1659,10 @@ database-type-config' and the 'database-type-configs' group for inspection:
                 console.log(scaffoldedToml);
                 return;
             }
-            // 3. For each candidate, splice the scaffolded TOML at a stable
-            // anchor (before the first `[[operations]]` block, or at EOF). Per
-            // the plan-of-record, textual insertion is deliberate — smol-toml
-            // parse/stringify drops comments, so we splice as a raw string.
+            // 3. For each candidate, append the scaffolded TOML at the end of the
+            // file. Per the plan-of-record, textual insertion is deliberate —
+            // smol-toml parse/stringify drops comments, so we splice as a raw
+            // string.
             for (const targetPath of candidateFiles) {
                 const original = readFileSync(targetPath, "utf-8");
                 // Detect existing [models.*] block. If present, refuse unless --force.
@@ -1854,26 +1671,9 @@ database-type-config' and the 'database-type-configs' group for inspection:
                     error(`${targetPath} already has [models.*] blocks. Re-run with --force to overwrite.`);
                     process.exit(1);
                 }
-                // Strip existing [models.*] blocks if --force.
-                let cleaned = original;
-                if (hasModelsBlock && options.force) {
-                    cleaned = stripModelsBlocks(original);
-                }
-                // Splice: insert before the first [[operations]] block, otherwise
-                // at the end of file.
-                let merged;
-                const opsAnchor = cleaned.indexOf("\n[[operations]]");
-                if (opsAnchor >= 0) {
-                    merged =
-                        cleaned.slice(0, opsAnchor + 1) +
-                            scaffoldedToml +
-                            "\n" +
-                            cleaned.slice(opsAnchor + 1);
-                }
-                else {
-                    const sep = cleaned.endsWith("\n") ? "" : "\n";
-                    merged = cleaned + sep + scaffoldedToml + "\n";
-                }
+                const merged = spliceScaffoldedSchema(original, scaffoldedToml, {
+                    force: !!options.force,
+                });
                 writeFileSync(targetPath, merged);
                 success(`Inserted schema into ${targetPath}`);
             }
@@ -1884,137 +1684,18 @@ database-type-config' and the 'database-type-configs' group for inspection:
             process.exit(1);
         }
     });
-    // ============================================
-    // Codegen command (issue #814)
-    // ============================================
-    databases
-        .command("codegen")
-        .description("Generate record + operation types from the local database-type-configs/*.toml schema. TypeScript (default): a <type>.generated.ts per database type (record interfaces, per-op input-params interfaces, per-op result aliases, and a typed <type>Ops factory). Swift (--lang swift): a <type>.generated.swift per database type (record structs, per-op params structs, per-op result typealiases, and a typed <Type>Ops factory).\n\nFormatting: the emitted TypeScript is already formatted the way Prettier's DEFAULT config formats it, so a `codegen` -> `prettier --write` -> `codegen --check` pipeline stays green. If your project uses a NON-default Prettier config (a different printWidth, trailingComma, or quote style), Prettier will reformat the generated files and `--check` will then fail: add the generated directory to `.prettierignore` and commit the raw emission instead.")
-        .argument("[database-type]", "Generate for a single database type (defaults to every database-type-configs/*.toml found)")
-        .option("-o, --output <dir>", "Output directory for the generated files (defaults to <config-dir>/database-type-configs/generated/)")
-        .option("--lang <lang>", "Target language for the generated types: 'ts' (default) or 'swift'.", "ts")
-        .option("--check", "Exit non-zero if generated output is out of date (CI guard); does not write. Compares byte-for-byte, so the file on disk must match the emission exactly.")
-        .option("--json", "Output the result summary as JSON")
-        .action(async (databaseType, options) => {
-        try {
-            // 0. Validate --lang up front so an unknown value fails clearly rather
-            //    than silently defaulting to the TS emitter.
-            const lang = String(options.lang ?? "ts").toLowerCase();
-            if (lang !== "ts" && lang !== "swift") {
-                error(`Unknown --lang "${options.lang}". Use "ts" or "swift".`);
-                process.exit(1);
-            }
-            // 1. The single source database-type-configs/ directory: the
-            //    environment's, and only ever the environment's (#1510, #3154).
-            const dbTypesSourceDir = resolveCodegenSourceDir({
-                subdir: "database-type-configs",
-            });
-            // 2. Collect the source .toml files (one per database type), filtered
-            //    to a single type when an argument is given.
-            const inputs = [];
-            for (const fileName of readdirSync(dbTypesSourceDir)) {
-                if (!fileName.endsWith(".toml"))
-                    continue;
-                const typeName = fileName.slice(0, -".toml".length);
-                if (databaseType && typeName !== databaseType)
-                    continue;
-                const tomlPath = path.join(dbTypesSourceDir, fileName);
-                inputs.push({
-                    databaseType: typeName,
-                    tomlPath,
-                    tomlContent: readFileSync(tomlPath, "utf-8"),
-                });
-            }
-            if (inputs.length === 0) {
-                error(databaseType
-                    ? `No database-type-configs/${databaseType}.toml found under primitive/<env>/.`
-                    : "No database-type-configs/*.toml files found to generate from.");
-                process.exit(1);
-            }
-            // 3. Resolve the output directory. Default: a `generated/` subdir of
-            //    the first source dir (keeps generated output beside the schema).
-            const outputDir = options.output
-                ? path.resolve(options.output)
-                : path.join(path.dirname(inputs[0].tomlPath), "generated");
-            // 4. Run codegen (or --check) with the selected emitter. Both the TS
-            //    and Swift generators return the same WriteOrCheckResult shape, so
-            //    the reporting below is emitter-agnostic; only the emitter (and the
-            //    regenerate hint) differs. When a single database-type filter
-            //    argument is given, the input set is partial — flag it so stale
-            //    cleanup is scoped to that type and sibling types' generated files
-            //    are left intact.
-            const codegenResult = lang === "swift"
-                ? await generateDbSwiftTypes({
-                    inputs,
-                    outputDir,
-                    check: !!options.check,
-                    singleType: !!databaseType,
-                })
-                : await generateDbTypes({
-                    inputs,
-                    outputDir,
-                    check: !!options.check,
-                    singleType: !!databaseType,
-                });
-            if (options.check) {
-                if (codegenResult.mismatches.length > 0) {
-                    if (options.json) {
-                        json({ ok: false, mismatches: codegenResult.mismatches });
-                    }
-                    else {
-                        error(`Check failed: ${codegenResult.mismatches.length} file(s) out of date.`);
-                        for (const m of codegenResult.mismatches) {
-                            error(`  ${m.reason}: ${path.relative(process.cwd(), m.filePath)}`);
-                        }
-                        // Echo back the options that decide WHERE and WHAT was
-                        // checked, the way `workflows codegen` does (#2895). Suggesting
-                        // a bare `databases codegen` after a `--check -o <dir>` sent
-                        // people to regenerate into the default
-                        // <config-dir>/database-type-configs/generated/ instead of the
-                        // directory that is actually out of date, so the files stayed
-                        // stale and the next check failed the same way (#2911).
-                        const regenerate = ["primitive databases codegen"];
-                        if (databaseType)
-                            regenerate.push(databaseType);
-                        if (lang === "swift")
-                            regenerate.push("--lang swift");
-                        if (options.output)
-                            regenerate.push(`-o ${options.output}`);
-                        info(`Run \`${regenerate.join(" ")}\` to regenerate.`);
-                    }
-                    process.exit(1);
-                }
-                if (options.json) {
-                    json({ ok: true, checked: codegenResult.writtenFiles.length });
-                }
-                else {
-                    success(`Check passed: ${codegenResult.writtenFiles.length} file(s) up to date.`);
-                }
-                return;
-            }
-            if (options.json) {
-                json({
-                    written: codegenResult.writtenFiles,
-                    deleted: codegenResult.deletedFiles,
-                });
-                return;
-            }
-            success(`Generated ${codegenResult.writtenFiles.length} file(s)` +
-                (codegenResult.deletedFiles.length > 0
-                    ? `, deleted ${codegenResult.deletedFiles.length} stale file(s).`
-                    : "."));
-            for (const f of codegenResult.writtenFiles) {
-                keyValue("  wrote", path.relative(process.cwd(), f));
-            }
-            for (const f of codegenResult.deletedFiles) {
-                keyValue("  deleted", path.relative(process.cwd(), f));
-            }
-        }
-        catch (err) {
-            error(err.message);
-            process.exit(1);
-        }
-    });
+}
+/**
+ * Append a scaffolded `[models.*]` schema to a database type file's text,
+ * first stripping the file's existing `[models.*]` blocks when `force` is set.
+ * Appended at the end of the file: #3189 retired the `[[operations]]` blocks
+ * the scaffold used to be inserted ahead of.
+ */
+export function spliceScaffoldedSchema(original, scaffoldedToml, options = {}) {
+    const hasModelsBlock = /\n\[models\./.test("\n" + original);
+    const cleaned = hasModelsBlock && options.force ? stripModelsBlocks(original) : original;
+    const sep = cleaned.endsWith("\n") ? "" : "\n";
+    return cleaned + sep + scaffoldedToml + "\n";
 }
 /** Remove every existing `[models.*]` block from a TOML file body. */
 function stripModelsBlocks(text) {
@@ -2083,8 +1764,9 @@ async function exportSingleDatabase(client, appId, databaseId, outputDir, jsonOu
             hasMore = !!cursor && records.length > 0;
         }
     }
-    // 4. Export indexes
-    const indexes = await client.listDatabaseIndexes(appId, databaseId);
+    // 4. Export indexes. The route answers `{ indexes: [...] }`; the file holds
+    // the bare list, which every version of `databases import` reads.
+    const indexes = indexList(await client.listDatabaseIndexes(appId, databaseId), "the index listing");
     writeFileSync(path.join(dbDir, "indexes.json"), JSON.stringify(indexes, null, 2));
     // 5. Export unique constraints
     const constraints = await client.listDatabaseUniqueConstraints(appId, databaseId);
@@ -2117,20 +1799,27 @@ async function exportSingleDatabase(client, appId, databaseId, outputDir, jsonOu
 const IMPORT_BATCH_SIZE_CEILING = 25000;
 async function importSingleDatabase(client, appId, dbDir, options) {
     const { overwrite, dryRun, batchSize, stopOnError, json: jsonOutput, summary } = options;
-    const metadataPath = path.join(dbDir, "metadata.json");
-    if (!existsSync(metadataPath)) {
+    const exported = readDatabaseExport(dbDir);
+    if (!exported) {
         warn(`Skipping ${dbDir}: no metadata.json found`);
         summary.skipped++;
+        summary.databases.push({ sourceDatabaseId: path.basename(dbDir), action: "skipped", reason: "no metadata.json" });
         return;
     }
-    const metadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+    const { metadata, indexes, constraints, ops } = exported;
     const databaseId = metadata.databaseId;
+    const entry = (fields) => ({
+        sourceDatabaseId: databaseId,
+        ...(isNonEmptyString(metadata.title) ? { title: metadata.title } : {}),
+        ...fields,
+    });
     if (dryRun) {
         // Report record/batch counts without writing anything (no DB creation,
         // no index registration, no batch write).
-        const recordCount = countRecordLines(dbDir);
+        const recordCount = ops.length;
         const batchCount = chunk(new Array(recordCount), batchSize).length;
         summary.created++;
+        summary.databases.push(entry({ action: "created" }));
         summary.recordsImported += recordCount;
         summary.batches += batchCount;
         info(`[dry-run] Would import database ${databaseId} (${metadata.title || "untitled"}) — ${recordCount} record(s), ${batchCount} batch(es)`);
@@ -2153,6 +1842,7 @@ async function importSingleDatabase(client, appId, dbDir, options) {
     if (exists && !overwrite) {
         warn(`Skipping ${databaseId}: already exists (use --overwrite to replace)`);
         summary.skipped++;
+        summary.databases.push(entry({ action: "skipped", reason: "exists" }));
         return;
     }
     // Create database if it doesn't exist
@@ -2173,59 +1863,38 @@ async function importSingleDatabase(client, appId, dbDir, options) {
         const created = await client.createDatabase(appId, createData);
         targetDatabaseId = created.databaseId || created.id || databaseId;
         summary.created++;
+        summary.databases.push(entry({ action: "created", targetDatabaseId }));
     }
     else {
         summary.updated++;
+        summary.databases.push(entry({ action: "updated", targetDatabaseId }));
     }
     // Register indexes
-    const indexesPath = path.join(dbDir, "indexes.json");
-    if (existsSync(indexesPath)) {
-        const indexes = JSON.parse(readFileSync(indexesPath, "utf-8"));
-        for (const idx of indexes) {
-            try {
-                await client.registerDatabaseIndex(appId, targetDatabaseId, {
-                    modelName: idx.modelName || idx.model_name,
-                    fieldName: idx.fieldName || idx.field_name,
-                    fieldType: idx.fieldType || idx.field_type || "string",
-                    unique: idx.isUnique || idx.is_unique || false,
-                });
-                summary.indexesRegistered++;
-            }
-            catch {
-                // Index may already exist
-            }
+    for (const idx of indexes) {
+        try {
+            await client.registerDatabaseIndex(appId, targetDatabaseId, {
+                modelName: idx.modelName || idx.model_name,
+                fieldName: idx.fieldName || idx.field_name,
+                fieldType: idx.fieldType || idx.field_type || "string",
+                unique: Boolean(idx.isUnique || idx.is_unique),
+            });
+            summary.indexesRegistered++;
+        }
+        catch {
+            // Index may already exist
         }
     }
     // Register unique constraints
-    const constraintsPath = path.join(dbDir, "constraints.json");
-    if (existsSync(constraintsPath)) {
-        const constraints = JSON.parse(readFileSync(constraintsPath, "utf-8"));
-        for (const c of constraints) {
-            try {
-                await client.registerDatabaseUniqueConstraint(appId, targetDatabaseId, {
-                    modelName: c.modelName || c.model_name,
-                    constraintName: c.constraintName || c.constraint_name,
-                    fields: c.fields ? (typeof c.fields === "string" ? JSON.parse(c.fields) : c.fields) : [],
-                });
-            }
-            catch {
-                // Constraint may already exist
-            }
+    for (const c of constraints) {
+        try {
+            await client.registerDatabaseUniqueConstraint(appId, targetDatabaseId, c);
+        }
+        catch {
+            // Constraint may already exist
         }
     }
     // Import records via chunked batch writes (was one save per record).
-    const recordsPath = path.join(dbDir, "records.jsonl");
-    if (existsSync(recordsPath)) {
-        const lines = readFileSync(recordsPath, "utf-8").split("\n").filter(Boolean);
-        // Map each records.jsonl line to a batch save op. Preserve the explicit
-        // `_type`/`_id`; strip the redundant id/type keys out of `_data` (the
-        // per-record loop did the same) so they don't duplicate into stored data.
-        const ops = lines.map((line) => {
-            const record = JSON.parse(line);
-            const { _type, _id, _data } = record;
-            const { id: _ignoredId, type: _ignoredType, ...data } = _data;
-            return { op: "save", modelName: _type, id: _id, data };
-        });
+    if (ops.length > 0) {
         const chunks = chunk(ops, batchSize);
         summary.batches += chunks.length;
         for (let i = 0; i < chunks.length; i++) {
@@ -2279,13 +1948,108 @@ async function importSingleDatabase(client, appId, dbDir, options) {
             }
         }
     }
-    info(`Imported database ${databaseId} (${metadata.title || "untitled"})`);
+    const as = targetDatabaseId !== databaseId ? ` as ${targetDatabaseId}` : "";
+    info(`Imported database ${databaseId} (${metadata.title || "untitled"})${as}`);
 }
-/** Count non-empty lines in a database export's records.jsonl (0 if absent). */
-function countRecordLines(dbDir) {
+/**
+ * The index list in the server's `{ indexes: [...] }` answer, or in an
+ * export's indexes.json: exports written before #4490 hold that envelope,
+ * later ones the bare list. `source` names where it came from in the error.
+ */
+function indexList(parsed, source) {
+    const list = Array.isArray(parsed) ? parsed : parsed?.indexes;
+    if (!Array.isArray(list)) {
+        throw new Error(`${source} is not an index list (expected an array, or an object with an "indexes" array).`);
+    }
+    return list;
+}
+/**
+ * Read and check every file in one database's export directory, so an export
+ * that cannot be imported fails before anything is written. Null when the
+ * directory has no metadata.json.
+ */
+function readDatabaseExport(dbDir) {
+    const metadataPath = path.join(dbDir, "metadata.json");
+    if (!existsSync(metadataPath))
+        return null;
+    const metadata = readExportJson(metadataPath);
+    const indexesPath = path.join(dbDir, "indexes.json");
+    const indexes = existsSync(indexesPath) ? indexList(readExportJson(indexesPath), indexesPath) : [];
+    const constraintsPath = path.join(dbDir, "constraints.json");
+    const constraints = [];
+    if (existsSync(constraintsPath)) {
+        const parsed = readExportJson(constraintsPath);
+        const list = Array.isArray(parsed) ? parsed : parsed?.constraints;
+        if (!Array.isArray(list)) {
+            throw new Error(`${constraintsPath} is not a constraint list (expected an array).`);
+        }
+        list.forEach((c, i) => constraints.push(exportedConstraint(c, `${constraintsPath} entry ${i + 1}`)));
+    }
+    // Map each records.jsonl line to a batch save op. Preserve the explicit
+    // `_type`/`_id`; strip the redundant id/type keys out of `_data` (the
+    // per-record loop did the same) so they don't duplicate into stored data.
     const recordsPath = path.join(dbDir, "records.jsonl");
-    if (!existsSync(recordsPath))
-        return 0;
-    return readFileSync(recordsPath, "utf-8").split("\n").filter(Boolean).length;
+    const ops = [];
+    if (existsSync(recordsPath)) {
+        readFileSync(recordsPath, "utf-8")
+            .split("\n")
+            .forEach((line, i) => {
+            if (!line)
+                return;
+            const where = `${recordsPath} line ${i + 1}`;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch (err) {
+                throw new Error(`${where} is not valid JSON: ${err.message}`);
+            }
+            const { _type, _id, _data } = record ?? {};
+            if (!isNonEmptyString(_type) || !isNonEmptyString(_id) || !_data || typeof _data !== "object") {
+                throw new Error(`${where} is not a record (expected "_type", "_id" and "_data").`);
+            }
+            const { id: _ignoredId, type: _ignoredType, ...data } = _data;
+            ops.push({ op: "save", modelName: _type, id: _id, data });
+        });
+    }
+    return { metadata, indexes, constraints, ops };
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+/**
+ * One constraints.json entry as the register route takes it. `fields` is the
+ * list the server answers, or the JSON string older exports carry; the route
+ * refuses fewer than two, so such an entry fails here rather than after the
+ * database is created.
+ */
+function exportedConstraint(c, where) {
+    const modelName = c?.modelName || c?.model_name;
+    const constraintName = c?.constraintName || c?.constraint_name;
+    let fields = c?.fields;
+    if (typeof fields === "string") {
+        try {
+            fields = JSON.parse(fields);
+        }
+        catch (err) {
+            throw new Error(`${where} has fields that are not valid JSON: ${err.message}`);
+        }
+    }
+    if (!isNonEmptyString(modelName) ||
+        !isNonEmptyString(constraintName) ||
+        !Array.isArray(fields) ||
+        fields.length < 2 ||
+        !fields.every(isNonEmptyString)) {
+        throw new Error(`${where} is not a unique constraint (expected "model_name", "constraint_name" and two or more "fields").`);
+    }
+    return { modelName, constraintName, fields };
+}
+function readExportJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch (err) {
+        throw new Error(`${file} is not valid JSON: ${err.message}`);
+    }
 }
 //# sourceMappingURL=databases.js.map