@vertesia/client 1.0.0-dev.20260227.112605Z → 1.0.0

package/src/store/FilesApi.ts

@@ -1,5 +1,7 @@
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
 import {
+    BulkUploadUrlsPayload,
+    BulkUploadUrlsResponse,
     GetFileUrlPayload,
     GetFileUrlResponse,
     GetUploadUrlPayload,
@@ -92,6 +94,64 @@ export class FilesApi extends ApiTopic {
         return this.post("/download-url", { payload });
     }
 
+    /**
+     * Get presigned upload URLs for multiple files in a single request.
+     * Each file gets its own presigned URL for direct upload to cloud storage.
+     * @param payload - Array of file descriptors (name, optional mime_type, optional id)
+     * @returns Array of upload URL responses
+     */
+    bulkGetUploadUrls(payload: BulkUploadUrlsPayload): Promise<BulkUploadUrlsResponse> {
+        return this.post("/bulk-upload-urls", { payload });
+    }
+
+    /**
+     * Upload multiple files in parallel. Gets presigned URLs in bulk, then PUTs all files concurrently.
+     * @param sources - Array of file sources to upload
+     * @param concurrency - Maximum number of concurrent uploads (default: 10)
+     * @returns Array of upload results with source URI, name, type, and etag
+     */
+    async bulkUpload(sources: (StreamSource | File)[], concurrency = 10): Promise<{ source: string; name: string; type?: string; etag?: string }[]> {
+        const fileDescriptors = sources.map(s => ({
+            name: s.name,
+            mime_type: s.type,
+            id: s instanceof StreamSource ? s.id : undefined,
+        }));
+
+        const { files } = await this.bulkGetUploadUrls({ files: fileDescriptors });
+
+        // Upload with concurrency limit using chunked Promise.all
+        const results: { source: string; name: string; type?: string; etag?: string }[] = new Array(sources.length);
+
+        for (let i = 0; i < sources.length; i += concurrency) {
+            const batch = sources.slice(i, i + concurrency);
+            await Promise.all(
+                batch.map(async (source, j) => {
+                    const idx = i + j;
+                    const { url, id, mime_type } = files[idx];
+                    const isStream = source instanceof StreamSource;
+                    const sourceMimeType = source.type || mime_type;
+
+                    const res = await fetch(url, {
+                        method: 'PUT',
+                        body: isStream ? source.stream : source,
+                        //@ts-expect-error: duplex is not in the types
+                        duplex: isStream ? 'half' : undefined,
+                        headers: sourceMimeType ? { 'Content-Type': sourceMimeType } : undefined,
+                    });
+
+                    if (!res.ok) {
+                        throw new Error(`Failed to upload file ${source.name}: ${res.statusText}`);
+                    }
+
+                    const etag = res.headers.get('etag')?.replace(/^"(.*)"$/, '$1');
+                    results[idx] = { source: id, name: source.name, type: sourceMimeType, etag };
+                })
+            );
+        }
+
+        return results;
+    }
+
     /**
      * Upload content to a file and return the full path (including bucket name) of the uploaded file
      * @param source
@@ -104,7 +164,7 @@ export class FilesApi extends ApiTopic {
         await fetch(url, {
             method: "PUT",
             body: isStream ? source.stream : source,
-            //@ts-ignore: duplex is not in the types. See https://github.com/node-fetch/node-fetch/issues/1769
+            //@ts-expect-error: duplex is not in the types. See https://github.com/node-fetch/node-fetch/issues/1769
             duplex: isStream ? "half" : undefined,
             headers: {
                 "Content-Type": source.type || "application/gzip",
@@ -188,7 +248,7 @@ export class FilesApi extends ApiTopic {
             ? source.name
             : source.name + ".tar.gz";
         if (source instanceof File) {
-            let file = source as File;
+            const file = source as File;
             return this.uploadFile(
                 new StreamSource(file.stream(), nameWithExt, file.type, fileId),
             );

package/src/store/IndexingApi.ts

@@ -8,6 +8,7 @@ import {
     ReindexRangeResult,
     FetchBatchResult,
     IndexBatchResult,
+    NextIndexCursorResult,
     TriggerReindexResult,
     ElasticsearchIndexStats,
     IndexConfiguration,
@@ -15,6 +16,8 @@ import {
     BulkDeleteResult,
     EnsureIndexResult,
     SwapAliasResult,
+    AnalyzeDriftBatchResult,
+    DriftAnalysisStatusResponse,
 } from "@vertesia/common";
 
 /**
@@ -46,7 +49,21 @@ export class IndexingApi extends ApiTopic {
      * @param recreateIndex If true, drops and recreates the index before reindexing
      */
     async reindex(recreateIndex?: boolean): Promise<GenericCommandResponse> {
-        return this.post("/reindex", { payload: { recreateIndex } });
+        return this.post("/reindex", { payload: { recreate_index: recreateIndex } });
+    }
+
+    /**
+     * Trigger an on-demand drift analysis between MongoDB and Elasticsearch
+     */
+    async analyzeDrift(): Promise<DriftAnalysisStatusResponse> {
+        return this.post("/analyze-drift", { payload: {} });
+    }
+
+    /**
+     * Get the latest drift analysis status/result for this project
+     */
+    async getDriftAnalysis(): Promise<DriftAnalysisStatusResponse> {
+        return this.get("/drift-analysis");
     }
 
     /**
@@ -86,18 +103,18 @@ export class IndexingApi extends ApiTopic {
     /**
      * Index a single document to Elasticsearch
      */
-    index(objectId: string, document: ElasticsearchDocumentData): Promise<{ status: string; objectId: string }> {
+    index(objectId: string, document: ElasticsearchDocumentData): Promise<{ status: string; object_id: string }> {
         return this.post("/internal/index", {
-            payload: { objectId, document },
+            payload: { object_id: objectId, document },
         });
     }
 
     /**
      * Delete a document from Elasticsearch
      */
-    delete(objectId: string): Promise<{ status: string; objectId: string }> {
+    delete(objectId: string): Promise<{ status: string; object_id: string }> {
         return this.post("/internal/delete", {
-            payload: { objectId },
+            payload: { object_id: objectId },
         });
     }
 
@@ -112,7 +129,7 @@ export class IndexingApi extends ApiTopic {
         targetIndex?: string
     ): Promise<BulkIndexResult> {
         return this.post("/internal/bulk-index", {
-            payload: { documents, targetIndex },
+            payload: { documents, target_index: targetIndex },
         });
     }
 
@@ -145,7 +162,7 @@ export class IndexingApi extends ApiTopic {
      */
     swapAlias(newIndexName: string, deleteOld?: boolean): Promise<SwapAliasResult> {
         return this.post("/internal/swap-alias", {
-            payload: { newIndexName, deleteOld },
+            payload: { new_index_name: newIndexName, delete_old: deleteOld },
         });
     }
 
@@ -189,10 +206,33 @@ export class IndexingApi extends ApiTopic {
      * @param limit Maximum documents to process (default: 500)
      * @param targetIndex Optional explicit index name for zero-downtime reindexing
      * @param since Only index docs with updated_at >= this ISO timestamp (for catch-up after reindex)
+     * @param endCursor End cursor (inclusive) for partitioned reindexing
      */
-    indexBatch(cursor?: string | null, limit?: number, targetIndex?: string, since?: string): Promise<IndexBatchResult> {
+    indexBatch(cursor?: string | null, limit?: number, targetIndex?: string, since?: string, endCursor?: string | null): Promise<IndexBatchResult> {
         return this.post("/internal/index-batch", {
-            payload: { cursor, limit, targetIndex, since },
+            payload: { cursor, limit, target_index: targetIndex, since, end_cursor: endCursor },
+        });
+    }
+
+    /**
+     * Discover one or more cursor boundaries for partitioned reindexing
+     *
+     * @param cursor Start cursor (exclusive)
+     * @param limit Maximum documents in the partition
+     * @param count Maximum number of boundaries to return
+     */
+    getNextIndexCursor(cursor?: string | null, limit?: number, count?: number): Promise<NextIndexCursorResult> {
+        return this.post("/internal/next-cursor", {
+            payload: { cursor, limit, count },
+        });
+    }
+
+    /**
+     * Analyze one batch of MongoDB documents against Elasticsearch by _id and updated_at
+     */
+    analyzeDriftBatch(cursor?: string | null, limit?: number): Promise<AnalyzeDriftBatchResult> {
+        return this.post("/internal/analyze-drift-batch", {
+            payload: { cursor, limit },
         });
     }
 
@@ -209,7 +249,11 @@ export class IndexingApi extends ApiTopic {
         recreateIndex?: boolean;
     }): Promise<TriggerReindexResult> {
         return this.post("/internal/trigger-reindex", {
-            payload: options ?? {},
+            payload: options ? {
+                full_reindex: options.fullReindex,
+                object_ids: options.objectIds,
+                recreate_index: options.recreateIndex,
+            } : {},
         });
     }
 
@@ -221,7 +265,7 @@ export class IndexingApi extends ApiTopic {
      */
     fetchDocumentsByIds(objectIds: string[]): Promise<FetchDocumentsByIdsResult> {
         return this.post("/internal/fetch-by-ids", {
-            payload: { objectIds },
+            payload: { object_ids: objectIds },
         });
     }
 
@@ -232,7 +276,7 @@ export class IndexingApi extends ApiTopic {
      */
     bulkDelete(objectIds: string[]): Promise<BulkDeleteResult> {
         return this.post("/internal/bulk-delete", {
-            payload: { objectIds },
+            payload: { object_ids: objectIds },
         });
     }
 

package/src/store/ObjectsApi.ts

@@ -1,5 +1,8 @@
-import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { ApiTopic } from "@vertesia/api-fetch-client";
 import {
+    BulkObjectCreateResult,
+    BulkObjectDeleteResult,
+    BulkObjectUpdateResult,
     canGenerateRendition,
     ComplexSearchPayload,
     ComputeObjectFacetPayload,
@@ -43,10 +46,14 @@ export interface ComputeFacetsResponse {
 export interface SearchResponse {
     results: ContentObjectItem[];
     facets: ComputeFacetsResponse;
+    /** Raw ES aggregation results. Only present when aggs were requested and ES backend was used. */
+    aggregations?: Record<string, unknown>;
 }
 
 export class ObjectsApi extends ApiTopic {
-    constructor(parent: ClientBase) {
+    declare client: ZenoClient;
+
+    constructor(parent: ZenoClient) {
         super(parent, "/api/v1/objects");
     }
 
@@ -91,6 +98,7 @@ export class ObjectsApi extends ApiTopic {
             query: {
                 limit,
                 offset,
+                select: payload.select,
                 ...query,
                 all_revisions: payload.all_revisions,
                 from_root: payload.from_root || undefined,
@@ -106,8 +114,8 @@ export class ObjectsApi extends ApiTopic {
         });
     }
 
-    listFolders(path: string = "/") {
-        path; //TODO
+    listFolders(_path: string = "/") {
+        throw new Error("Not implemented yet");
     }
 
     /** Find object based on query */
@@ -174,7 +182,7 @@ export class ObjectsApi extends ApiTopic {
         const res = await fetch(url, {
             method: "PUT",
             body: isStream ? source.stream : source,
-            //@ts-ignore: duplex is not in the types. See https://github.com/node-fetch/node-fetch/issues/1769
+            //@ts-expect-error: duplex is not in the types. See https://github.com/node-fetch/node-fetch/issues/1769
             duplex: isStream ? "half" : undefined,
             headers: sourceMimeType ? { "Content-Type": sourceMimeType } : undefined,
         })
@@ -253,7 +261,7 @@ export class ObjectsApi extends ApiTopic {
             processing_priority?: ContentObjectProcessingPriority;
         },
     ): Promise<ContentObject> {
-        const metadata = await (this.client as ZenoClient).files.getMetadata(
+        const metadata = await this.client.files.getMetadata(
             uri,
         );
         const createPayload: CreateContentObjectPayload = {
@@ -359,8 +367,37 @@ export class ObjectsApi extends ApiTopic {
         return this.get(`/${id}/collections`);
     }
 
-    delete(id: string): Promise<{ id: string }> {
-        return this.del(`/${id}`);
+    delete(id: string): Promise<{ id: string }>;
+    delete(ids: string[]): Promise<BulkObjectDeleteResult>;
+    delete(idOrIds: string | string[]): Promise<{ id: string } | BulkObjectDeleteResult> {
+        if (Array.isArray(idOrIds)) {
+            return this.client.runOperation({
+                name: 'delete',
+                ids: idOrIds,
+                params: {}
+            }) as Promise<BulkObjectDeleteResult>;
+        }
+        return this.del(`/${idOrIds}`);
+    }
+
+    bulkUpdate(updates: Record<string, Record<string, any>>): Promise<BulkObjectUpdateResult> {
+        const ids = Object.keys(updates);
+        return this.client.runOperation({
+            name: 'update',
+            ids,
+            params: updates,
+        }) as Promise<BulkObjectUpdateResult>;
+    }
+
+    bulkCreate(objects: CreateContentObjectPayload[], options?: {
+        collection_id?: string;
+        skip_workflows?: boolean;
+    }): Promise<BulkObjectCreateResult> {
+        return this.client.runOperation({
+            name: 'create',
+            ids: [],
+            params: { objects, ...options },
+        }) as Promise<BulkObjectCreateResult>;
     }
 
     listWorkflowRuns(documentId: string): Promise<ListWorkflowRunsResponse> {