primitive-admin 1.2.0-alpha.3 → 1.2.0-alpha.4

package/dist/src/commands/documents.js

@@ -4,6 +4,7 @@ import { ingestClientRows, ingestSessionRows, } from "../lib/document-ingest-row
 import { ApiClient } from "../lib/api-client.js";
 import { resolveAppId } from "../lib/config.js";
 import { success, error, info, formatTable, formatId, formatDate, json, keyValue, result as printResult, warn, flushOutput, } from "../lib/output.js";
+import { renderAggregateResult } from "../lib/aggregate-output.js";
 import { confirmPrompt } from "../lib/confirm-prompt.js";
 import { resolveOwnerUserId } from "../lib/resolve-owner.js";
 import { pageCursorOption, pageLimitOption, parsePageLimit, printEmptyPage, printPageHint, } from "../lib/list-options.js";
@@ -57,7 +58,8 @@ export function describeRecordsFailure(err) {
     return `${message}${code ? ` [${code}]` : ""}${status !== undefined ? ` (${status})` : ""}`;
 }
 /**
- * Report a document's format (#2816) — but only when it is a large document.
+ * Report a document's format (#2816) — but only when it is a large (2) or a
+ * record-log (3, #4306) document.
  *
  * The format is chosen at creation and never migrated, so an operator has to
  * be able to read it back: `--large` that the server ignored would otherwise
@@ -66,9 +68,13 @@ export function describeRecordsFailure(err) {
  * stored row spells the format (absent, null or 1).
  */
 function printDocumentFormat(doc) {
-    if (Number(doc?.documentFormat) === 2) {
+    const format = Number(doc?.documentFormat);
+    if (format === 2) {
         keyValue("Format", "2 (large document)");
     }
+    else if (format === 3) {
+        keyValue("Format", "3 (record log)");
+    }
 }
 /**
  * The `--document-format` an operator stated, or the refusal (#3764, E10).
@@ -86,12 +92,14 @@ export function parseDocumentFormatOption(value) {
         return 1;
     if (text === "2")
         return 2;
+    if (text === "3")
+        return 3;
     throw new Error(`Invalid --document-format "${String(value)}". Expected 1 (an ordinary ` +
-        `document) or 2 (a large document).`);
+        `document), 2 (a large document) or 3 (a record-log document).`);
 }
-/** The `--document-format <1|2>` flag, said once for every records verb. */
-const DOCUMENT_FORMAT_FLAG = "--document-format <1|2>";
-const DOCUMENT_FORMAT_HELP = "The document format you expect: 1 (ordinary) or 2 (large). A disagreement " +
+/** The `--document-format <1|2|3>` flag, said once for every records verb. */
+const DOCUMENT_FORMAT_FLAG = "--document-format <1|2|3>";
+const DOCUMENT_FORMAT_HELP = "The document format you expect: 1 (ordinary), 2 (large) or 3 (record log). A disagreement " +
     "with the platform's own answer is refused with DOCUMENT_FORMAT_MISMATCH " +
     "rather than answered out of the wrong tables";
 /**
@@ -882,35 +890,18 @@ Permissions (enforced by the server, not the CLI):
                 json(response);
                 return;
             }
-            const aggregated = response?.result;
-            // Same labelling rule as the databases twin: the field name is
-            // reproduced verbatim, never case-folded (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) {
-                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)) {
-                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(response?.result, {
+                groupBy,
+                op: options.op,
+                field: options.field,
+            });
+            if (rendered.kind === "scalar") {
+                keyValue(rendered.label, rendered.value);
             }
             else {
-                console.log(JSON.stringify(aggregated ?? {}, null, 2));
+                console.log(rendered.text);
             }
         }
         catch (err) {
@@ -1189,6 +1180,52 @@ Permissions (enforced by the server, not the CLI):
             process.exit(1);
         }
     });
+    // #4306 — a record-log document's room: the inspection route's payload.
+    documents
+        .command("inspect")
+        .description("Show a record-log document's room: epochs, log number, floors, writers and checkpoint")
+        .argument("<document-id>", "Document ID")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (documentId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.getDocumentRoom(resolvedAppId, documentId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            keyValue("Document ID", result.documentId);
+            printDocumentFormat(result);
+            const room = result.room;
+            if (!room) {
+                keyValue("Room", `no record room (format ${result.documentFormat ?? 1})`);
+                return;
+            }
+            keyValue("Log number", room.lsn);
+            keyValue("Epochs", `current ${room.epochs.current}, next ${room.epochs.next}, high ${room.epochs.high}`);
+            keyValue("Epoch floor", room.epochs.floor);
+            keyValue("Cursor floor", room.cursorFloor);
+            keyValue("Entries since rotation", room.epochs.entriesSinceRotation);
+            keyValue("Rotated", room.epochs.rotatedAt ? formatDate(room.epochs.rotatedAt) : "—");
+            keyValue("Writers", `${room.writers.count} (${room.writers.connected} connected)`);
+            keyValue("Subscribers", room.subscribers);
+            keyValue("Held entries", room.held.entries);
+            keyValue("Load", room.load ? JSON.stringify(room.load) : "none");
+            keyValue("Last checkpoint", room.checkpoint
+                ? `${formatDate(room.checkpoint.at)} (${room.checkpoint.durationMs} ms, ` +
+                    `${room.checkpoint.pruned} pruned, ${room.checkpoint.dropped} dropped, ` +
+                    `${room.checkpoint.writersDropped} writers dropped)`
+                : "none yet");
+            keyValue("Next alarm", room.nextAlarmAt ? formatDate(room.nextAlarmAt) : "—");
+            keyValue("Storage (bytes)", room.storage?.databaseSize ?? "—");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
     // The action verb (#3435, criterion 9): a directory of records becomes a
     // chunked, digested, uploaded artifact and one atomic swap of the
     // document's tables. `documents ingests list|get` below is how an operator