primitive-admin 1.0.53 → 1.0.55

package/dist/src/commands/databases.js

@@ -1,10 +1,13 @@
 import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, readdirSync } from "fs";
 import * as path from "path";
-import * as TOML from "@iarna/toml";
+import { parseConfigToml } from "../lib/config-toml.js";
 import { ApiClient } from "../lib/api-client.js";
 import { getCurrentAppId } from "../lib/config.js";
-import { parseCsv, applyColumnMap, buildRows, chunk } from "../lib/csv.js";
+import { resolveCodegenSourceDir } from "../lib/codegen-shared/resolveCodegenSourceDir.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 { confirmPrompt } from "../lib/confirm-prompt.js";
 function resolveAppId(appId, options) {
@@ -128,6 +131,7 @@ the 'database-types' group:
         .requiredOption("--type <database-type>", "Database type (required)")
         .option("--cel-context <json>", "Initial CEL context as JSON (referenced from access rules as database.celContext.*)")
         .option("--metadata <json>", "Initial CEL context as JSON (legacy alias for --cel-context)")
+        .option("--initial-metadata <json>", "Create-time resource metadata as JSON, keyed by category name (issue #1420; distinct from --cel-context)")
         .option("--json", "Output as JSON")
         .action(async (title, options) => {
         const resolvedAppId = resolveAppId(undefined, options);
@@ -147,6 +151,17 @@ the 'database-types' group:
                     process.exit(1);
                 }
             }
+            // `--initial-metadata` is a separate concept: create-time per-category
+            // ResourceMetadata rows (issue #1420), not the database CEL context.
+            if (options.initialMetadata) {
+                try {
+                    params.initialMetadata = JSON.parse(options.initialMetadata);
+                }
+                catch {
+                    error("Invalid --initial-metadata JSON.");
+                    process.exit(1);
+                }
+            }
             const result = await client.createDatabase(resolvedAppId, params);
             if (options.json) {
                 json(result);
@@ -474,7 +489,7 @@ the 'database-types' group:
             try {
                 const content = readFileSync(options.filterFile, "utf-8");
                 if (options.filterFile.endsWith(".toml")) {
-                    const parsed = TOML.parse(content);
+                    const parsed = parseConfigToml(content);
                     filter = parsed.filter || parsed;
                 }
                 else {
@@ -1059,6 +1074,8 @@ the 'database-types' group:
         .option("--app <app-id>", "App ID")
         .option("--overwrite", "Replace existing database if ID collides")
         .option("--dry-run", "Show what would be imported without making changes")
+        .option("--batch-size <n>", "Records per batch write request (default: 5000)", "5000")
+        .option("--stop-on-error", "Abort the whole run on the first failing chunk (default: continue and report)")
         .option("--json", "Output as JSON")
         .action(async (first, second, options) => {
         let resolvedAppId;
@@ -1075,6 +1092,21 @@ the 'database-types' group:
             error("Import path is required.");
             process.exit(1);
         }
+        // Validate --batch-size up front so a bad value fails before any write.
+        // Unlike `import-csv` (registered-batch path, hard 100k server cap),
+        // `admin-data/batch` has no fixed server item cap — bound it with a
+        // conservative client-side ceiling to keep each request within
+        // Cloudflare body-size and Durable Object memory limits.
+        const parsedBatchSize = parseBatchSize(options.batchSize, {
+            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);
+            process.exit(1);
+            return;
+        }
+        const batchSize = parsedBatchSize.value;
         const client = new ApiClient();
         try {
             // Determine if this is a manifest-based export or a single database
@@ -1109,12 +1141,32 @@ the 'database-types' group:
                 info("No databases to import.");
                 return;
             }
-            const summary = { created: 0, updated: 0, skipped: 0, recordsImported: 0, indexesRegistered: 0 };
+            const summary = {
+                created: 0,
+                updated: 0,
+                skipped: 0,
+                recordsImported: 0,
+                recordsFailed: 0,
+                batches: 0,
+                aborted: false,
+                indexesRegistered: 0,
+                batchErrors: [],
+            };
             for (const dbDir of dbDirs) {
-                await importSingleDatabase(client, resolvedAppId, dbDir, options.overwrite || false, options.dryRun || false, summary);
+                await importSingleDatabase(client, resolvedAppId, dbDir, {
+                    overwrite: options.overwrite || false,
+                    dryRun: options.dryRun || false,
+                    batchSize,
+                    stopOnError: options.stopOnError || false,
+                    json: options.json || false,
+                    summary,
+                });
+                // Fork 3: --stop-on-error stops the whole run across a multi-DB dir.
+                if (summary.aborted)
+                    break;
             }
             if (options.json) {
-                json(summary);
+                json({ ...summary, dryRun: options.dryRun || false });
             }
             else {
                 success("Database import complete:");
@@ -1124,8 +1176,24 @@ the 'database-types' group:
                 if (summary.skipped > 0)
                     keyValue("  Databases skipped", String(summary.skipped));
                 keyValue("  Records imported", String(summary.recordsImported));
+                if (summary.recordsFailed > 0)
+                    keyValue("  Records failed", String(summary.recordsFailed));
+                keyValue("  Batches", String(summary.batches));
                 if (summary.indexesRegistered > 0)
                     keyValue("  Indexes registered", String(summary.indexesRegistered));
+                if (summary.aborted)
+                    warn("Aborted after a failing chunk (--stop-on-error).");
+                if (summary.batchErrors.length > 0) {
+                    error(`${summary.batchErrors.length} chunk(s) errored:`);
+                    for (const e of summary.batchErrors) {
+                        error(`  ${e.database} batch ${e.batch + 1}: ${e.error}`);
+                    }
+                }
+            }
+            // Non-zero exit if any chunk errored (default continue-and-report or
+            // --stop-on-error both surface failures this way).
+            if (summary.batchErrors.length > 0) {
+                process.exit(1);
             }
         }
         catch (err) {
@@ -1178,18 +1246,18 @@ the 'database-types' group:
                 return;
             }
         }
-        const batchSize = parseInt(options.batchSize, 10);
-        if (!Number.isInteger(batchSize) || batchSize < 1) {
-            error("--batch-size must be a positive integer.");
-            process.exit(1);
-            return;
-        }
-        // The server rejects batch requests over 100000 items; keep chunks under it.
-        if (batchSize > 100000) {
-            error("--batch-size cannot exceed 100000 (the server's per-request cap).");
+        // The registered-batch (`executeBatch`) path rejects requests over
+        // 100000 items server-side; keep chunks under it.
+        const parsedBatchSize = parseBatchSize(options.batchSize, {
+            max: 100000,
+            overMaxMessage: "--batch-size cannot exceed 100000 (the server's per-request cap).",
+        });
+        if ("error" in parsedBatchSize) {
+            error(parsedBatchSize.error);
             process.exit(1);
             return;
         }
+        const batchSize = parsedBatchSize.value;
         if (!existsSync(file)) {
             error(`CSV file not found: ${file}`);
             process.exit(1);
@@ -1356,7 +1424,7 @@ the 'database-types' group:
             }
             // 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 — `@iarna/toml`
+            // 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");
@@ -1401,67 +1469,47 @@ the 'database-types' group:
     // ============================================
     databases
         .command("codegen")
-        .description("Generate TypeScript record + operation types from the local database-types/*.toml schema. Emits a <type>.generated.ts per database type (record interfaces, per-op input-params interfaces, and per-op result aliases).")
+        .description("Generate record + operation types from the local database-types/*.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).")
         .argument("[database-type]", "Generate for a single database type (defaults to every database-types/*.toml found)")
         .option("--app <app-id>", "App ID")
         .option("--sync-dir <path>", "Override path to the sync directory (defaults to ./.primitive/sync/<env>/<appId>/)")
-        .option("-o, --output <dir>", "Output directory for *.generated.ts files (defaults to <sync-dir>/database-types/generated/)")
+        .option("-o, --output <dir>", "Output directory for the generated files (defaults to <sync-dir>/database-types/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.")
         .option("--json", "Output the result summary as JSON")
         .action(async (databaseType, options) => {
         try {
-            // 1. Locate the database-types directory. Mirrors `schema generate`'s
-            //    sync-dir resolution: honor --sync-dir, else search any
-            //    env/appId subtree under ./.primitive/sync that has a
-            //    database-types/ directory.
-            const dbTypesDirs = [];
-            if (options.syncDir) {
-                dbTypesDirs.push(path.join(options.syncDir, "database-types"));
-            }
-            else {
-                const root = path.join(process.cwd(), ".primitive", "sync");
-                if (existsSync(root)) {
-                    for (const env of readdirSync(root)) {
-                        const envDir = path.join(root, env);
-                        try {
-                            for (const app of readdirSync(envDir)) {
-                                const candidate = path.join(envDir, app, "database-types");
-                                if (existsSync(candidate)) {
-                                    dbTypesDirs.push(candidate);
-                                }
-                            }
-                        }
-                        catch {
-                            // skip non-dirs
-                        }
-                    }
-                }
-            }
-            if (dbTypesDirs.length === 0) {
-                error("No database-types/ directory found. Pass --sync-dir or run `primitive sync pull` first.");
+            // 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. Resolve the single source database-types/ directory via the
+            //    shared active-environment resolver (issue #1510). Honors
+            //    --sync-dir / --app overrides and resolves the active env
+            //    (--env → PRIMITIVE_ENV → defaultEnvironment → single-env) instead
+            //    of silently merging types across every synced env.
+            const dbTypesSourceDir = resolveCodegenSourceDir({
+                subdir: "database-types",
+                options: { app: options.app, syncDir: options.syncDir },
+            });
             // 2. Collect the source .toml files (one per database type), filtered
             //    to a single type when an argument is given.
             const inputs = [];
-            const seenTypes = new Set();
-            for (const dir of dbTypesDirs) {
-                for (const fileName of readdirSync(dir)) {
-                    if (!fileName.endsWith(".toml"))
-                        continue;
-                    const typeName = fileName.slice(0, -".toml".length);
-                    if (databaseType && typeName !== databaseType)
-                        continue;
-                    if (seenTypes.has(typeName))
-                        continue;
-                    seenTypes.add(typeName);
-                    const tomlPath = path.join(dir, fileName);
-                    inputs.push({
-                        databaseType: typeName,
-                        tomlPath,
-                        tomlContent: readFileSync(tomlPath, "utf-8"),
-                    });
-                }
+            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
@@ -1474,16 +1522,26 @@ the 'database-types' group:
             const outputDir = options.output
                 ? path.resolve(options.output)
                 : path.join(path.dirname(inputs[0].tomlPath), "generated");
-            // 4. Run codegen (or --check). When a single database-type filter
+            // 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 = await generateDbTypes({
-                inputs,
-                outputDir,
-                check: !!options.check,
-                singleType: !!databaseType,
-            });
+            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) {
@@ -1494,7 +1552,9 @@ the 'database-types' group:
                         for (const m of codegenResult.mismatches) {
                             error(`  ${m.reason}: ${path.relative(process.cwd(), m.filePath)}`);
                         }
-                        info("Run `primitive databases codegen` to regenerate.");
+                        info(lang === "swift"
+                            ? "Run `primitive databases codegen --lang swift` to regenerate."
+                            : "Run `primitive databases codegen` to regenerate.");
                     }
                     process.exit(1);
                 }
@@ -1570,8 +1630,12 @@ async function exportSingleDatabase(client, appId, databaseId, outputDir, jsonOu
         metadata: dbMeta.metadata || null,
     };
     writeFileSync(path.join(dbDir, "metadata.json"), JSON.stringify(metadata, null, 2));
-    // 3. Export records: list models, then query each
-    const models = await client.listDatabaseModels(appId, databaseId);
+    // 3. Export records: list models, then query each.
+    // listDatabaseModels() resolves to `{ models: string[] }`, not a bare array,
+    // so unwrap it before iterating (mirrors the `databases records models`
+    // consumer above). Without this, `for (const modelName of models)` throws
+    // "models is not iterable" and records.jsonl is left empty (#1396).
+    const models = (await client.listDatabaseModels(appId, databaseId)).models || [];
     let totalRecords = 0;
     const recordsFile = path.join(dbDir, "records.jsonl");
     // Clear file
@@ -1619,7 +1683,15 @@ async function exportSingleDatabase(client, appId, databaseId, outputDir, jsonOu
         keyValue("  Indexes", String(indexes.length));
     }
 }
-async function importSingleDatabase(client, appId, dbDir, overwrite, dryRun, summary) {
+/**
+ * Conservative client-side ceiling for `databases import --batch-size`.
+ * `admin-data/batch` has no fixed server-side item cap (unlike the
+ * registered-batch path used by `import-csv`), so this bounds each request to
+ * keep it within Cloudflare body-size and Durable Object memory limits.
+ */
+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)) {
         warn(`Skipping ${dbDir}: no metadata.json found`);
@@ -1629,8 +1701,14 @@ async function importSingleDatabase(client, appId, dbDir, overwrite, dryRun, sum
     const metadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
     const databaseId = metadata.databaseId;
     if (dryRun) {
-        info(`[dry-run] Would import database ${databaseId} (${metadata.title || "untitled"})`);
+        // Report record/batch counts without writing anything (no DB creation,
+        // no index registration, no batch write).
+        const recordCount = countRecordLines(dbDir);
+        const batchCount = chunk(new Array(recordCount), batchSize).length;
         summary.created++;
+        summary.recordsImported += recordCount;
+        summary.batches += batchCount;
+        info(`[dry-run] Would import database ${databaseId} (${metadata.title || "untitled"}) — ${recordCount} record(s), ${batchCount} batch(es)`);
         return;
     }
     // Check if database type exists — warn if not
@@ -1707,19 +1785,79 @@ async function importSingleDatabase(client, appId, dbDir, overwrite, dryRun, sum
             }
         }
     }
-    // Import records
+    // 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);
-        for (const line of lines) {
+        // 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;
-            // Remove 'id' and 'type' from _data to avoid duplication
             const { id: _ignoredId, type: _ignoredType, ...data } = _data;
-            await client.saveDatabaseRecord(appId, targetDatabaseId, _type, _id, data);
-            summary.recordsImported++;
+            return { op: "save", modelName: _type, id: _id, data };
+        });
+        const chunks = chunk(ops, batchSize);
+        summary.batches += chunks.length;
+        for (let i = 0; i < chunks.length; i++) {
+            const piece = chunks[i];
+            let chunkFailed = false;
+            try {
+                const res = await client.batchDatabaseRecords(appId, targetDatabaseId, piece);
+                const results = res?.results ?? [];
+                let imported = 0;
+                let failed = 0;
+                const firstErrors = [];
+                for (let j = 0; j < piece.length; j++) {
+                    const r = results[j];
+                    if (r && r.success) {
+                        imported++;
+                    }
+                    else {
+                        failed++;
+                        if (r?.error && firstErrors.length < 3)
+                            firstErrors.push(r.error);
+                    }
+                }
+                summary.recordsImported += imported;
+                summary.recordsFailed += failed;
+                if (failed > 0) {
+                    chunkFailed = true;
+                    summary.batchErrors.push({
+                        database: databaseId,
+                        batch: i,
+                        error: `${failed} record(s) failed${firstErrors.length ? `: ${firstErrors.join("; ")}` : ""}`,
+                    });
+                }
+                if (!jsonOutput) {
+                    info(`  ${databaseId} batch ${i + 1}/${chunks.length}: imported ${imported}, failed ${failed}`);
+                }
+            }
+            catch (err) {
+                // Chunk-level failure (e.g. a 400 for a malformed op): the whole chunk
+                // is rejected, so every item in it counts as failed.
+                const msg = err?.message || String(err);
+                chunkFailed = true;
+                summary.recordsFailed += piece.length;
+                summary.batchErrors.push({ database: databaseId, batch: i, error: msg });
+                if (!jsonOutput) {
+                    warn(`  ${databaseId} batch ${i + 1}/${chunks.length} failed: ${msg}`);
+                }
+            }
+            if (chunkFailed && stopOnError) {
+                summary.aborted = true;
+                return;
+            }
         }
     }
     info(`Imported database ${databaseId} (${metadata.title || "untitled"})`);
 }
+/** Count non-empty lines in a database export's records.jsonl (0 if absent). */
+function countRecordLines(dbDir) {
+    const recordsPath = path.join(dbDir, "records.jsonl");
+    if (!existsSync(recordsPath))
+        return 0;
+    return readFileSync(recordsPath, "utf-8").split("\n").filter(Boolean).length;
+}
 //# sourceMappingURL=databases.js.map