@madewithremy/admin 0.1.32 → 0.1.33

package/dist/index.d.ts

@@ -1326,6 +1326,13 @@ type DataSourceJobSource = {
     unread: boolean;
     /** Only documents matching this metadata filter. */
     filter: Record<string, unknown> | null;
+} | {
+    /**
+     * The rest of one file a `datasources add` (or an app's `add()`) took
+     * that maps to more than a thousand documents; `ref` is its filename.
+     */
+    type: 'object';
+    ref: string;
 };
 /**
  * planning → planned → running ⇄ paused → done | failed | cancelled.
@@ -1941,7 +1948,24 @@ interface DataSourceMapTestDocument {
 }
 type DataSourceMapTestOutcome = {
     kind: 'documents';
+    /** The first twenty of them. */
     documents: DataSourceMapTestDocument[];
+    /** Every valid document the object produced. */
+    count: number;
+    /**
+     * Its documents that failed validation, by their index in the mapper's
+     * output: a job leaves them out and quarantines the object for them.
+     * Null when every one passed.
+     */
+    invalid: {
+        count: number;
+        examples: {
+            document: number;
+            reason: string;
+        }[];
+    } | null;
+    /** Parts of the frame's documents that storage did not have. */
+    missingParts?: number;
 } | {
     kind: 'passthrough';
     metadata: Record<string, string | number | boolean> | null;
@@ -2311,8 +2335,10 @@ interface DataSourcesDocumentsResult {
 type DataSourcesUploadTokenResult = {
     alreadyCurrent: true;
     document: DataSourcesDocument;
-    /** Mapped sources: every document this mapper version produced from the bytes. */
+    /** Mapped sources: what this mapper version produced from the bytes, the first thousand at most. */
     documents?: DataSourcesDocument[];
+    /** Mapped sources: how many it produced in all. */
+    documentCount?: number;
 } | {
     alreadyCurrent: false;
     contentType: string;
@@ -2326,16 +2352,30 @@ type DataSourcesUploadTokenResult = {
  * POST /datasources/documents — confirm an uploaded object and queue its
  * builds. On a mapped source the object is a raw copy and the mapper decides
  * what it becomes: `documents` holds everything produced, `document` the first
- * of them (null only for a `deletes` outcome).
+ * of them (null only for a `deletes` outcome). An object that maps to more
+ * than a thousand documents returns the first thousand and `job`, which
+ * registers and builds the rest.
  */
 interface DataSourcesDocumentConfirmResult {
     document: DataSourcesDocument | null;
     documents: DataSourcesDocument[];
+    /** Every document the object maps to; `documents.length` unless `job` is set. */
+    documentCount: number;
     /** Whether any document was queued for a build. */
     queued: boolean;
     outcome: 'unmapped' | 'documents' | 'passthrough' | 'deletes';
     /** Documents removed or superseded as a result. */
     removed: number;
+    /** Documents that failed validation and were not registered; null when none did. */
+    invalid: {
+        count: number;
+        examples: {
+            document: number;
+            reason: string;
+        }[];
+    } | null;
+    /** The job taking the rest of an object larger than a thousand documents. */
+    job: DataSourceJob | null;
 }
 /** Build progress counts used in several list and status shapes. */
 interface DataSourcesBuildProgress {
@@ -2770,6 +2810,11 @@ interface AddDocumentParams {
      * no whitespace or commas). Every passage carries them; `[]` clears them.
      */
     entities?: string[];
+    /**
+     * The budget in dollars of the job that takes the rest of a file mapping
+     * to more than a thousand documents (`AddDocumentResult.job`).
+     */
+    budgetDollars?: number;
     /**
      * Receives the exact progress strings the CLI prints today:
      * - `${filename}: unchanged, skipped`
@@ -2786,10 +2831,28 @@ interface AddDocumentResult {
      * source's mapper answered `deletes` for the file.
      */
     document: DataSourcesDocument | null;
-    /** Every document the file became — one on an unmapped source. */
+    /**
+     * Every document the file became — one on an unmapped source — or the
+     * first thousand of a file that maps to more.
+     */
     documents: DataSourcesDocument[];
+    /** How many documents the file maps to in all. */
+    documentCount: number;
     /** How the source took the file; absent when it was already current. */
     outcome?: 'unmapped' | 'documents' | 'passthrough' | 'deletes';
+    /** Documents the mapper produced that failed validation and were not registered. */
+    invalid?: {
+        count: number;
+        examples: {
+            document: number;
+            reason: string;
+        }[];
+    } | null;
+    /**
+     * The job registering and building the rest of a file that maps to more
+     * than a thousand documents; it plans and starts on its own.
+     */
+    job?: DataSourceJob | null;
 }
 /**
  * Add one document to a data source.

package/dist/index.js

@@ -552,6 +552,7 @@ var summarize = (d) => ({
 });
 async function addDocument(ctx, params) {
   const { slug, filename, content, metadata, entities: entities2, onProgress } = params;
+  const { budgetDollars } = params;
   const contentHash = createHash("sha256").update(content).digest("hex");
   const token = await call(
     ctx,
@@ -567,11 +568,13 @@ async function addDocument(ctx, params) {
   );
   if (token.alreadyCurrent) {
     onProgress?.(`${filename}: unchanged, skipped`);
+    const documents3 = token.documents ?? [token.document];
     return {
       filename,
       skipped: true,
       document: token.document,
-      documents: token.documents ?? [token.document]
+      documents: documents3,
+      documentCount: token.documentCount ?? documents3.length
     };
   }
   onProgress?.(
@@ -589,16 +592,21 @@ async function addDocument(ctx, params) {
       contentType: token.contentType,
       size: content.length,
       ...metadata ? { metadata } : {},
-      ...entities2 ? { entities: entities2 } : {}
+      ...entities2 ? { entities: entities2 } : {},
+      ...budgetDollars !== void 0 ? { budgetDollars } : {}
     }
   );
+  const documents2 = confirmed.documents ?? (confirmed.document ? [confirmed.document] : []);
   return {
     filename,
     skipped: false,
     queued: confirmed.queued,
     document: confirmed.document,
-    documents: confirmed.documents ?? (confirmed.document ? [confirmed.document] : []),
-    outcome: confirmed.outcome
+    documents: documents2,
+    documentCount: confirmed.documentCount ?? documents2.length,
+    outcome: confirmed.outcome,
+    invalid: confirmed.invalid ?? null,
+    job: confirmed.job ?? null
   };
 }
 async function waitForIngest(ctx, params) {
@@ -1649,13 +1657,6 @@ async function dashboardLive(ctx) {
   );
   return dashboard.liveRelease;
 }
-function buildFailureReason(release) {
-  const log = Array.isArray(release.buildLog) ? release.buildLog : [];
-  const errors = log.filter(
-    (entry) => entry?.phase === "error" && typeof entry.message === "string"
-  );
-  return errors.length ? errors[errors.length - 1].message : null;
-}
 function summarizeRelease(release) {
   const summary2 = {
     releaseId: release.id,
@@ -1678,7 +1679,7 @@ function summarizeRelease(release) {
   }
   return {
     ...summary2,
-    error: release.failureReason ?? buildFailureReason(release) ?? "Build failed (no error entry in the build log)",
+    error: release.failureReason ?? "Build failed (no error entry in the build log)",
     ...release.failureKind ? { failureKind: release.failureKind } : {},
     ...release.failurePhase ? { failurePhase: release.failurePhase } : {}
   };