primitive-admin 1.1.0-alpha.53 → 1.1.0-alpha.55

package/dist/src/commands/databases.js

@@ -1,6 +1,5 @@
 import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, readdirSync } from "fs";
 import * as path from "path";
-import { parseConfigToml } from "../lib/config-toml.js";
 import { ApiClient } from "../lib/api-client.js";
 import { getCurrentAppId } from "../lib/config.js";
 import { resolveCodegenSourceDir } from "../lib/codegen-shared/resolveCodegenSourceDir.js";
@@ -10,6 +9,9 @@ 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";
+import { parseFilterOptions } from "../lib/record-filter.js";
+import { parseDataOption } from "../lib/data-input.js";
+import { ulid } from "ulid";
 function resolveAppId(appId, options) {
     const resolved = appId || options.app || getCurrentAppId();
     if (!resolved) {
@@ -18,6 +20,43 @@ function resolveAppId(appId, options) {
     }
     return resolved;
 }
+/**
+ * Render the flat `{ success, id, appliedFields }` response that
+ * `records/save` and `records/patch` return — these endpoints answer with a
+ * write receipt, not the stored record, so the human view shows the resolved id
+ * plus any server-applied fields (autoStamps / trigger-computed values).
+ */
+function renderRecordWriteResult(result, fallbackId, message) {
+    success(message);
+    keyValue("id", String(result?.id ?? fallbackId));
+    const applied = result?.appliedFields;
+    if (applied && typeof applied === "object" && Object.keys(applied).length > 0) {
+        for (const [key, value] of Object.entries(applied)) {
+            keyValue(`applied.${key}`, value === null || value === undefined ? "—" : String(value));
+        }
+    }
+}
+/**
+ * Refuse a write whose `--data` carries an `id` that is not the record being
+ * written. The server strips `id` from the record body on both the save and the
+ * patch path, so such an `id` would be dropped silently and the write would
+ * land on the id from the argument — somewhere the caller did not intend.
+ *
+ * `recordId` is the id the caller passed as an argument (absent on a `save`
+ * that mints one); `writtenId` is the id actually being written. Exits non-zero
+ * when they disagree with `--data` (#1965 review).
+ */
+function assertDataIdMatches(data, recordId, writtenId, commandPath) {
+    if (!data || typeof data !== "object")
+        return;
+    const dataId = data.id;
+    if (dataId === undefined || dataId === writtenId)
+        return;
+    error(recordId
+        ? `The "id" in --data ("${dataId}") does not match the record id "${recordId}". Remove it, or pass the id you mean as the argument.`
+        : `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)).
@@ -68,11 +107,17 @@ export function registerDatabasesCommands(program) {
         .addHelpText("after", `
 Examples:
   $ primitive databases list
+  $ primitive databases list --owner <user-id>
   $ primitive databases create "My Database"
   $ primitive databases get <database-id>
   $ primitive databases records models <database-id>
   $ primitive databases records describe <database-id> <model-name>
   $ primitive databases records query <database-id> <model-name> --filter '{"name":"Alice"}'
+  $ primitive databases records get <database-id> <model-name> <record-id>
+  $ primitive databases records count <database-id> <model-name> --filter '{"status":"open"}'
+  $ primitive databases records aggregate <database-id> <model-name> --op avg --field price
+  $ primitive databases records save <database-id> <model-name> [record-id] --data '{"name":"Alice"}'
+  $ primitive databases records patch <database-id> <model-name> <record-id> --data '{"name":"Alice"}'
   $ primitive databases operations list <database-id>
   $ primitive databases operations execute <database-id> <operation-name> --params '{"key":"value"}'
   $ primitive databases indexes list <database-id>
@@ -94,12 +139,15 @@ the 'database-types' group:
         .description("List databases in an app")
         .argument("[app-id]", "App ID (uses current app if not specified)")
         .option("--app <app-id>", "App ID")
+        .option("--owner <user-id>", "Only list databases created by this user")
         .option("--json", "Output as JSON")
         .action(async (appId, options) => {
         const resolvedAppId = resolveAppId(appId, options);
         const client = new ApiClient();
         try {
-            const result = await client.listDatabases(resolvedAppId);
+            const result = await client.listDatabases(resolvedAppId, {
+                owner: options.owner,
+            });
             const list = Array.isArray(result) ? result : result?.databases ?? [];
             if (options.json) {
                 json(list);
@@ -114,6 +162,18 @@ the 'database-types' group:
                 { header: "TITLE", key: "title" },
                 { header: "TYPE", key: "databaseType", format: (v) => v || "—" },
                 { header: "PERMISSION", key: "permission" },
+                // `permission` reads "owner" on every row for an app admin, so it
+                // cannot confirm --owner narrowed anything. Show who created each
+                // database when the filter is in play.
+                ...(options.owner
+                    ? [
+                        {
+                            header: "CREATED BY",
+                            key: "createdBy",
+                            format: (v) => (v ? formatId(v) : "—"),
+                        },
+                    ]
+                    : []),
                 { header: "CREATED", key: "createdAt", format: formatDate },
             ]));
         }
@@ -465,7 +525,7 @@ the 'database-types' group:
             process.exit(1);
         }
     });
-    // Query records (direct introspection via admin-data route)
+    // Query records (direct introspection via the records route)
     records
         .command("query")
         .description("Query records in a database model (admin only)")
@@ -480,36 +540,7 @@ the 'database-types' group:
         .action(async (databaseId, modelName, options) => {
         const resolvedAppId = resolveAppId(undefined, options);
         const client = new ApiClient();
-        if (options.filter && options.filterFile) {
-            error("Cannot use both --filter and --filter-file.");
-            process.exit(1);
-        }
-        let filter;
-        if (options.filterFile) {
-            try {
-                const content = readFileSync(options.filterFile, "utf-8");
-                if (options.filterFile.endsWith(".toml")) {
-                    const parsed = parseConfigToml(content);
-                    filter = parsed.filter || parsed;
-                }
-                else {
-                    filter = JSON.parse(content);
-                }
-            }
-            catch (err) {
-                error(`Failed to read filter file: ${err.message}`);
-                process.exit(1);
-            }
-        }
-        else if (options.filter) {
-            try {
-                filter = JSON.parse(options.filter);
-            }
-            catch {
-                error("Invalid --filter JSON.");
-                process.exit(1);
-            }
-        }
+        const filter = parseFilterOptions(options);
         try {
             const result = await client.queryDatabaseRecords(resolvedAppId, databaseId, modelName, { filter, limit: options.limit, cursor: options.cursor });
             if (options.json) {
@@ -560,6 +591,218 @@ the 'database-types' group:
             process.exit(1);
         }
     });
+    // Get a single record by id
+    records
+        .command("get")
+        .description("Get a single record by id (admin only)")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .argument("<record-id>", "Record ID")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, modelName, recordId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            // A single-record fetch is a query filtered by primary-key id (there is
+            // no dedicated get endpoint — reuse queryDatabaseRecords).
+            const result = await client.queryDatabaseRecords(resolvedAppId, databaseId, modelName, { filter: { id: recordId }, limit: 1 });
+            const record = (result?.data || [])[0];
+            if (options.json) {
+                json(record ?? null);
+                return;
+            }
+            if (!record) {
+                info(`No record found with id ${recordId} in ${modelName}.`);
+                return;
+            }
+            for (const [key, value] of Object.entries(record)) {
+                const rendered = value === null || value === undefined
+                    ? "—"
+                    : typeof value === "object"
+                        ? JSON.stringify(value)
+                        : String(value);
+                keyValue(key, rendered);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Count records
+    records
+        .command("count")
+        .description("Count records in a database model (admin only)")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .option("--app <app-id>", "App ID")
+        .option("--filter <json>", "Filter as JSON (e.g. '{\"name\":\"Alice\"}')")
+        .option("--filter-file <path>", "Read filter from a JSON or TOML file")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, modelName, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const filter = parseFilterOptions(options);
+        const client = new ApiClient();
+        try {
+            const result = await client.countDatabaseRecords(resolvedAppId, databaseId, modelName, filter);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            keyValue("count", String(result?.count ?? 0));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Aggregate records
+    const AGGREGATE_OPS = ["count", "sum", "avg", "min", "max"];
+    records
+        .command("aggregate")
+        .description("Aggregate records in a database model (count/sum/avg/min/max, optional group-by; admin only)")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .option("--app <app-id>", "App ID")
+        .requiredOption("--op <operation>", `Aggregate operation: ${AGGREGATE_OPS.join("|")}`)
+        .option("--field <field>", "Field to aggregate (required for sum/avg/min/max)")
+        .option("--group-by <field>", "Group results by this field (repeatable)", (value, previous = []) => previous.concat(value), [])
+        .option("--filter <json>", "Filter as JSON")
+        .option("--filter-file <path>", "Read filter from a JSON or TOML file")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, modelName, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!AGGREGATE_OPS.includes(options.op)) {
+            error(`Invalid --op "${options.op}". Expected one of: ${AGGREGATE_OPS.join(", ")}.`);
+            process.exit(1);
+        }
+        const operation = { type: options.op };
+        if (options.op === "count") {
+            if (options.field) {
+                error("--field is not valid for --op count.");
+                process.exit(1);
+            }
+        }
+        else {
+            if (!options.field) {
+                error(`--op ${options.op} requires --field.`);
+                process.exit(1);
+            }
+            operation.field = options.field;
+        }
+        const filter = parseFilterOptions(options);
+        const groupBy = options.groupBy || [];
+        const client = new ApiClient();
+        try {
+            const result = await client.aggregateDatabaseRecords(resolvedAppId, databaseId, modelName, { operations: [operation], groupBy, filter });
+            if (options.json) {
+                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.
+            const valueLabel = options.op === "count"
+                ? "COUNT"
+                : `${options.op.toUpperCase()}(${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(valueLabel.toLowerCase(), 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" },
+                ]));
+            }
+            else {
+                // Grouped/nested or multi-operation shape: print the structured result.
+                console.log(JSON.stringify(aggregated ?? {}, null, 2));
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Upsert a record (create, or merge into an existing one)
+    records
+        .command("save")
+        .description("Create a record, or merge fields into an existing one (admin only)")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .argument("[record-id]", "Record ID (generated when omitted)")
+        .option("--app <app-id>", "App ID")
+        .option("--data <json>", "Record fields as inline JSON")
+        .option("--data-file <path>", "Read the record fields from a JSON file")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, modelName, recordId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const data = parseDataOption(options, "record");
+        const client = new ApiClient();
+        // The DatabaseDO requires an id on the plain save path (it only generates
+        // one for `upsertOn` writes). Mint the id client-side for a create so
+        // `save` works without an id, the same way CSV import does
+        // (`lib/csv.ts`).
+        const id = recordId || ulid();
+        assertDataIdMatches(data, recordId, id, "primitive databases records save <database-id> <model-name>");
+        try {
+            const result = await client.saveDatabaseRecord(resolvedAppId, databaseId, modelName, id, data);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            renderRecordWriteResult(result, id, `Record saved to ${modelName}.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Patch a record (partial merge)
+    records
+        .command("patch")
+        .description("Merge fields into an existing record (admin only)")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .argument("<record-id>", "Record ID")
+        .option("--app <app-id>", "App ID")
+        .option("--data <json>", "Fields to merge as inline JSON")
+        .option("--data-file <path>", "Read the fields to merge from a JSON file")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, modelName, recordId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const data = parseDataOption(options, "fields to merge");
+        const client = new ApiClient();
+        // Same guard as `save` — on this path `recordId` is required, so the
+        // "pass it as the argument" branch is unreachable here.
+        assertDataIdMatches(data, recordId, recordId, "primitive databases records patch <database-id> <model-name>");
+        try {
+            const result = await client.patchDatabaseRecord(resolvedAppId, databaseId, modelName, recordId, data);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            renderRecordWriteResult(result, recordId, `Record ${recordId} patched in ${modelName}.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
     // Delete a single record
     records
         .command("delete")
@@ -608,21 +851,13 @@ the 'database-types' group:
         .argument("<model-name>", "Model name")
         .option("--app <app-id>", "App ID")
         .option("--filter <json>", "Filter as JSON to select which records to delete")
+        .option("--filter-file <path>", "Read filter from a JSON or TOML file")
         .option("-y, --yes", "Skip confirmation prompt")
         .option("--json", "Output as JSON")
         .action(async (databaseId, modelName, options) => {
         const resolvedAppId = resolveAppId(undefined, options);
         const client = new ApiClient();
-        let filter;
-        if (options.filter) {
-            try {
-                filter = JSON.parse(options.filter);
-            }
-            catch {
-                error("Invalid --filter JSON.");
-                process.exit(1);
-            }
-        }
+        const filter = parseFilterOptions(options);
         try {
             // First, query to find all matching records
             let allRecords = [];
@@ -1094,7 +1329,7 @@ the 'database-types' group:
         }
         // 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
+        // `records/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, {
@@ -1685,7 +1920,7 @@ async function exportSingleDatabase(client, appId, databaseId, outputDir, jsonOu
 }
 /**
  * Conservative client-side ceiling for `databases import --batch-size`.
- * `admin-data/batch` has no fixed server-side item cap (unlike the
+ * `records/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.
  */