@vertesia/client 1.0.0-dev.20260203.130115Z → 1.0.0-dev.20260225.024852Z

package/src/store/ObjectsApi.ts

@@ -1,10 +1,10 @@
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
 import {
     canGenerateRendition,
-    ContentObjectApiHeaders,
     ComplexSearchPayload,
     ComputeObjectFacetPayload,
     ContentObject,
+    ContentObjectApiHeaders,
     ContentObjectItem,
     ContentObjectProcessingPriority,
     ContentSource,
@@ -23,7 +23,7 @@ import {
     ObjectSearchPayload,
     ObjectSearchQuery,
     SupportedEmbeddingTypes,
-    supportsVisualRendition,
+    supportsVisualRendition
 } from "@vertesia/common";
 
 // Re-export rendition utilities for consumers
@@ -151,6 +151,7 @@ export class ObjectsApi extends ApiTopic {
             name: source.name,
             mime_type: source.type,
         });
+        const sourceMimeType = source.type || mime_type;
 
         // upload the file content to the signed URL
         /*const res = await this.fetch(url, {
@@ -175,9 +176,7 @@ export class ObjectsApi extends ApiTopic {
             body: isStream ? source.stream : source,
             //@ts-ignore: duplex is not in the types. See https://github.com/node-fetch/node-fetch/issues/1769
             duplex: isStream ? "half" : undefined,
-            headers: {
-                "Content-Type": mime_type || "application/octet-stream",
-            },
+            headers: sourceMimeType ? { "Content-Type": sourceMimeType } : undefined,
         })
             .then((res: Response) => {
                 if (res.ok) {
@@ -201,7 +200,7 @@ export class ObjectsApi extends ApiTopic {
         return {
             source: id,
             name: source.name,
-            type: mime_type,
+            type: sourceMimeType,
             etag,
         };
     }
@@ -226,7 +225,7 @@ export class ObjectsApi extends ApiTopic {
         const headers: Record<string, string> = {};
         if (options?.processing_priority) {
             headers[ContentObjectApiHeaders.PROCESSING_PRIORITY] = options.processing_priority;
-        } 
+        }
         if (options?.collection_id) {
             headers[ContentObjectApiHeaders.COLLECTION_ID] = options.collection_id;
         }
@@ -270,7 +269,7 @@ export class ObjectsApi extends ApiTopic {
         const headers: Record<string, string> = {};
         if (options?.processing_priority) {
             headers[ContentObjectApiHeaders.PROCESSING_PRIORITY] = options.processing_priority;
-        } 
+        }
         if (options?.collection_id) {
             headers[ContentObjectApiHeaders.COLLECTION_ID] = options.collection_id;
         }
@@ -301,6 +300,8 @@ export class ObjectsApi extends ApiTopic {
             revisionLabel?: string;
             processing_priority?: ContentObjectProcessingPriority;
             suppressWorkflows?: boolean;
+            /** If provided, the server will reject the update with 412 if the document's content etag no longer matches. */
+            ifMatch?: string;
         },
     ): Promise<ContentObject> {
         const updatePayload: Partial<CreateContentObjectPayload> = {
@@ -316,6 +317,9 @@ export class ObjectsApi extends ApiTopic {
         }
 
         const headers: Record<string, string> = {};
+        if (options?.ifMatch) {
+            headers['if-match'] = options.ifMatch;
+        }
         if (options?.processing_priority) {
             headers[ContentObjectApiHeaders.PROCESSING_PRIORITY] = options.processing_priority;
         }

package/src/store/RenderingApi.ts

@@ -0,0 +1,105 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    isWorkflowTerminalStatus,
+    RenderMarkdownPollOptions,
+    RenderMarkdownPayload,
+    RenderMarkdownStartResponse,
+    RenderMarkdownStatusResponse,
+    RenderMarkdownResponse,
+    WorkflowExecutionStatus,
+} from "@vertesia/common";
+
+/**
+ * API for rendering markdown documents to PDF or DOCX.
+ * Rendering is performed on workflow workers (not on the API server).
+ */
+export class RenderingApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/rendering");
+    }
+
+    /**
+     * Render markdown content to PDF or DOCX.
+     *
+     * @param payload - Rendering options including format and either object_id or inline content
+     * @returns Rendering result with download URL
+     *
+     * @example
+     * // Render an existing markdown document
+     * const result = await client.rendering.render({
+     *     format: MarkdownRenditionFormat.pdf,
+     *     object_id: "doc-123"
+     * });
+     * // Download from result.download_url
+     *
+     * @example
+     * // Render inline markdown content
+     * const result = await client.rendering.render({
+     *     format: MarkdownRenditionFormat.docx,
+     *     content: "# My Report\n\nContent here...",
+     *     title: "My Report"
+     * });
+     */
+    start(payload: RenderMarkdownPayload): Promise<RenderMarkdownStartResponse> {
+        return this.post("/jobs", { payload });
+    }
+
+    getStatus(
+        workflowId: string,
+        workflowRunId: string,
+    ): Promise<RenderMarkdownStatusResponse> {
+        return this.get("/jobs/status", {
+            query: {
+                workflow_id: workflowId,
+                workflow_run_id: workflowRunId,
+            },
+        });
+    }
+
+    async render(
+        payload: RenderMarkdownPayload,
+        options: RenderMarkdownPollOptions = {},
+    ): Promise<RenderMarkdownResponse> {
+        const pollIntervalMs = options.pollIntervalMs ?? 1500;
+        const timeoutMs = options.timeoutMs ?? 10 * 60 * 1000;
+
+        const started = await this.start(payload);
+        if (!started.workflow_id || !started.workflow_run_id) {
+            throw new Error("Failed to start rendering workflow");
+        }
+
+        const startTime = Date.now();
+
+        // Poll until workflow reaches terminal state.
+        while (true) {
+            const status = await this.getStatus(started.workflow_id, started.workflow_run_id);
+
+            if (status.status === WorkflowExecutionStatus.COMPLETED) {
+                if (!status.download_url && !status.file_uri) {
+                    throw new Error(status.error || "Rendering completed but no output file was produced");
+                }
+                return {
+                    status: "success",
+                    format: payload.format,
+                    download_url: status.download_url,
+                    file_uri: status.file_uri,
+                };
+            }
+
+            if (isWorkflowTerminalStatus(status.status)) {
+                const statusLabel = WorkflowExecutionStatus[status.status] || String(status.status);
+                throw new Error(status.error || `Rendering failed with status: ${statusLabel}`);
+            }
+
+            if (Date.now() - startTime >= timeoutMs) {
+                throw new Error(`Rendering timed out after ${timeoutMs}ms`);
+            }
+
+            await sleep(pollIntervalMs);
+        }
+    }
+}
+
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/store/TypeCatalogApi.ts

@@ -0,0 +1,53 @@
+import { ApiTopic, ClientBase } from '@vertesia/api-fetch-client';
+import { ContentObjectTypeItem, ContentObjectTypeRef } from '@vertesia/common';
+
+
+export class TypeCatalogApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, '/api/v1/types/catalog');
+    }
+
+    /**
+     * List all content types (system + app + stored)
+     */
+    list(query: { tag?: string, limit?: number, offset?: number, layout?: boolean, schema?: boolean } = {}): Promise<ContentObjectTypeItem[]> {
+        return this.get('/', { query });
+    }
+
+    /**
+     * List system types only
+     */
+    listSysTypes(tag?: string): Promise<ContentObjectTypeItem[]> {
+        return this.get('/sys', {
+            query: { tag }
+        });
+    }
+
+    /**
+     * List all app types from all installed apps
+     */
+    listAppTypes(tag?: string): Promise<ContentObjectTypeItem[]> {
+        return this.get('/apps', {
+            query: { tag }
+        });
+    }
+
+    /**
+     * List stored types only
+     */
+    listStoredTypes(query: { tag?: string, limit?: number, offset?: number, layout?: boolean, schema?: boolean } = {}): Promise<ContentObjectTypeItem[]> {
+        return this.get('/stored', {
+            query
+        });
+    }
+
+    /**
+     * Resolve a type to its full definition.
+     * Accepts a string (type ID or code) or a ContentObjectTypeRef (extracts code or id automatically).
+     * @param typeOrRef Type identifier string, or a ContentObjectTypeRef from a content object
+     */
+    resolve(typeOrRef: string | ContentObjectTypeRef): Promise<ContentObjectTypeItem> {
+        const typeId = typeof typeOrRef === 'string' ? typeOrRef : (typeOrRef.code || typeOrRef.id!);
+        return this.get(`/resolve/${typeId}`);
+    }
+}

package/src/store/TypesApi.ts

@@ -1,11 +1,14 @@
 import { ContentObjectType, ContentObjectTypeItem, CreateContentObjectTypePayload, FindPayload, ObjectTypeSearchQuery, ObjectTypeSearchPayload } from "@vertesia/common";
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { TypeCatalogApi } from "./TypeCatalogApi.js";
 
 
 export class TypesApi extends ApiTopic {
+    catalog: TypeCatalogApi;
 
     constructor(parent: ClientBase) {
         super(parent, "/api/v1/types");
+        this.catalog = new TypeCatalogApi(parent);
     }
 
     /**

package/src/store/client.ts

@@ -4,21 +4,21 @@ import { CollectionsApi } from "./CollectionsApi.js";
 import { CommandsApi } from "./CommandsApi.js";
 import { DataApi } from "./DataApi.js";
 import { EmailApi } from "./EmailApi.js";
-import { IndexingAdminApi } from "./IndexingAdminApi.js";
 import { IndexingApi } from "./IndexingApi.js";
 import { EmbeddingsApi } from "./EmbeddingsApi.js";
 import { ZenoClientNotFoundError } from "./errors.js";
 import { FilesApi } from "./FilesApi.js";
+import { HiveMemoryApi } from "./HiveMemoryApi.js";
 import { ObjectsApi } from "./ObjectsApi.js";
 import { PendingAsksApi } from "./PendingAsksApi.js";
 import { QueryApi } from "./QueryApi.js";
+import { RenderingApi } from "./RenderingApi.js";
 import { SchedulesApi } from "./SchedulesApi.js";
 import { ToolsApi } from "./ToolsApi.js";
 import { TypesApi } from "./TypesApi.js";
 import { VERSION, VERSION_HEADER } from "./version.js";
 import { WorkersApi } from "./WorkersApi.js";
 import { WorkflowsApi } from "./WorkflowsApi.js";
-import { HiveMemoryApi } from "./HiveMemoryApi.js";
 
 export interface ZenoClientProps {
     serverUrl?: string;
@@ -98,6 +98,6 @@ export class ZenoClient extends AbstractFetchClient<ZenoClient> {
     tools = new ToolsApi(this);
     indexing = new IndexingApi(this);
     query = new QueryApi(this);
-    indexingAdmin = new IndexingAdminApi(this);
     hiveMemory = new HiveMemoryApi(this);
+    rendering = new RenderingApi(this);
 }

package/src/store/index.ts

@@ -5,12 +5,13 @@ export * from "./EmailApi.js";
 export * from "./errors.js";
 export * from "./FilesApi.js";
 export * from "./HiveMemoryApi.js";
-export * from "./IndexingAdminApi.js";
 export * from "./IndexingApi.js";
 export * from "./ObjectsApi.js";
 export * from "./PendingAsksApi.js";
 export * from "./QueryApi.js";
+export * from "./RenderingApi.js";
 export * from "./SchedulesApi.js";
+export * from "./TypeCatalogApi.js";
 export * from "./TypesApi.js";
 export * from "./WorkflowsApi.js";
 

package/src/store/version.ts

@@ -1,2 +1,2 @@
-export const VERSION = '20250925' // YYYYMMDD, client versioning for API endpoints. Increment manually for breaking changes
+export const VERSION = '20260210' // YYYYMMDD, client versioning for API endpoints. Increment manually for breaking changes
 export const VERSION_HEADER = 'x-api-version';

package/src/store/IndexingAdminApi.ts

@@ -1,336 +0,0 @@
-import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
-
-/**
- * Document data structure for Elasticsearch indexing
- */
-export interface ElasticsearchDocumentData {
-    name?: string;
-    text?: string;
-    properties?: Record<string, unknown>;
-    status?: string;
-    type?: {
-        id?: string;
-        name?: string;
-    };
-    security?: {
-        'content:read'?: string[];
-        'content:write'?: string[];
-        'content:delete'?: string[];
-    };
-    revision?: {
-        head?: boolean;
-        root?: string;
-    };
-    embeddings_text?: number[];
-    embeddings_image?: number[];
-    embeddings_properties?: number[];
-    created_at?: Date | string;
-    updated_at?: Date | string;
-}
-
-/**
- * Result from bulk indexing
- */
-export interface BulkIndexResult {
-    successful: number;
-    failed: number;
-}
-
-/**
- * Result from creating a reindex target
- */
-export interface CreateReindexTargetResult {
-    created: boolean;
-    indexName: string;
-    aliasName: string;
-    version: number;
-}
-
-/**
- * Result from getting reindex range
- */
-export interface ReindexRangeResult {
-    first: string | null;
-    last: string | null;
-    count: number;
-}
-
-/**
- * Result from fetching a batch
- */
-export interface FetchBatchResult {
-    documents: Array<{
-        id: string;
-        document: ElasticsearchDocumentData;
-    }>;
-    nextCursor: string | null;
-    done: boolean;
-}
-
-/**
- * Result from indexing a batch
- */
-export interface IndexBatchResult {
-    successful: number;
-    failed: number;
-    processed: number;
-    nextCursor: string | null;
-    done: boolean;
-}
-
-/**
- * Result from triggering a reindex
- */
-export interface TriggerReindexResult {
-    status: string;
-    workflow?: string;
-    workflowId?: string;
-    runId?: string;
-    objectCount?: number;
-    reason?: string;
-    enabled?: boolean;
-}
-
-/**
- * Elasticsearch index statistics
- */
-export interface ElasticsearchIndexStats {
-    enabled: boolean;
-    exists?: boolean;
-    documentCount?: number;
-    sizeInBytes?: number;
-    indexName?: string;
-    aliasName?: string;
-}
-
-/**
- * Embedding configuration for a single type
- */
-export interface EmbeddingTypeConfig {
-    environment?: string;
-    dimensions?: number;
-    model?: string;
-    provider?: string;
-    enabled?: boolean;
-}
-
-/**
- * Detailed index configuration
- */
-export interface IndexConfiguration {
-    enabled: boolean;
-    exists?: boolean;
-    indexName?: string;
-    aliasName?: string;
-    version?: number;
-    documentCount?: number;
-    sizeInBytes?: number;
-    embeddingDimensions?: {
-        text?: number;
-        image?: number;
-        properties?: number;
-    };
-    fieldMappings?: Record<string, unknown>;
-    projectEmbeddingsConfig?: {
-        text?: EmbeddingTypeConfig;
-        image?: EmbeddingTypeConfig;
-        properties?: EmbeddingTypeConfig;
-    };
-    createdAt?: Date | null;
-}
-
-/**
- * Result from fetching documents by IDs
- */
-export interface FetchDocumentsByIdsResult {
-    documents: Array<{
-        id: string;
-        document: ElasticsearchDocumentData;
-    }>;
-    notFound: string[];
-}
-
-/**
- * Result from bulk delete
- */
-export interface BulkDeleteResult {
-    successful: number;
-    failed: number;
-}
-
-/**
- * Admin API for Elasticsearch operations
- *
- * These methods are called by Temporal workflow activities to perform
- * Elasticsearch operations. They require content admin permissions.
- */
-export class IndexingAdminApi extends ApiTopic {
-
-    constructor(parent: ClientBase, basePath: string = "/admin/elasticsearch") {
-        super(parent, basePath);
-    }
-
-    /**
-     * Index a single document to Elasticsearch
-     */
-    index(objectId: string, document: ElasticsearchDocumentData): Promise<{ status: string; objectId: string }> {
-        return this.post("/index", {
-            payload: { objectId, document },
-        });
-    }
-
-    /**
-     * Delete a document from Elasticsearch
-     */
-    delete(objectId: string): Promise<{ status: string; objectId: string }> {
-        return this.post("/delete", {
-            payload: { objectId },
-        });
-    }
-
-    /**
-     * Bulk index multiple documents to Elasticsearch
-     *
-     * @param documents Array of documents to index
-     * @param targetIndex Optional explicit index name for zero-downtime reindexing
-     */
-    bulkIndex(
-        documents: Array<{ id: string; document: ElasticsearchDocumentData }>,
-        targetIndex?: string
-    ): Promise<BulkIndexResult> {
-        return this.post("/bulk-index", {
-            payload: { documents, targetIndex },
-        });
-    }
-
-    /**
-     * Ensure Elasticsearch index exists for the project
-     *
-     * @param recreate If true, drops and recreates the index
-     */
-    ensureIndex(recreate?: boolean): Promise<{ created: boolean; recreated?: boolean; existed?: boolean }> {
-        return this.post("/ensure-index", {
-            payload: { recreate },
-        });
-    }
-
-    /**
-     * Create a new versioned index for reindexing (without alias)
-     * The alias will be swapped after reindexing completes via swapAlias
-     */
-    createReindexTarget(): Promise<CreateReindexTargetResult> {
-        return this.post("/create-reindex-target", {
-            payload: {},
-        });
-    }
-
-    /**
-     * Atomically swap the alias from old index to new index
-     *
-     * @param newIndexName The new index to point the alias to
-     * @param deleteOld If true, deletes the old index after swapping
-     */
-    swapAlias(newIndexName: string, deleteOld?: boolean): Promise<{ swapped: boolean; aliasName?: string; newIndexName?: string }> {
-        return this.post("/swap-alias", {
-            payload: { newIndexName, deleteOld },
-        });
-    }
-
-    /**
-     * Get Elasticsearch index statistics for the project
-     */
-    getStats(): Promise<ElasticsearchIndexStats> {
-        return this.post("/stats", {
-            payload: {},
-        });
-    }
-
-    /**
-     * Get the _id range for reindexing (first, last, count)
-     * Used by workflow to set up cursor-based pagination
-     */
-    getReindexRange(): Promise<ReindexRangeResult> {
-        return this.post("/reindex-range", {
-            payload: {},
-        });
-    }
-
-    /**
-     * Fetch a batch of documents from MongoDB (without indexing)
-     * Used by pipeline approach: fetch next batch while indexing current
-     *
-     * @param cursor Cursor from previous batch (null for first batch)
-     * @param limit Maximum documents to fetch (default: 500)
-     */
-    fetchBatch(cursor?: string | null, limit?: number): Promise<FetchBatchResult> {
-        return this.post("/fetch-batch", {
-            payload: { cursor, limit },
-        });
-    }
-
-    /**
-     * Fetch and index a batch of documents (server-side)
-     * Uses cursor-based pagination for reliability
-     *
-     * @param cursor Cursor from previous batch (null for first batch)
-     * @param limit Maximum documents to process (default: 500)
-     * @param targetIndex Optional explicit index name for zero-downtime reindexing
-     */
-    indexBatch(cursor?: string | null, limit?: number, targetIndex?: string): Promise<IndexBatchResult> {
-        return this.post("/index-batch", {
-            payload: { cursor, limit, targetIndex },
-        });
-    }
-
-    /**
-     * Trigger a reindex operation via Temporal workflow
-     *
-     * @param fullReindex If true, reindexes all documents in the project
-     * @param objectIds Specific object IDs to reindex (if not fullReindex)
-     * @param recreateIndex If true, recreates the index before reindexing
-     */
-    triggerReindex(options?: {
-        fullReindex?: boolean;
-        objectIds?: string[];
-        recreateIndex?: boolean;
-    }): Promise<TriggerReindexResult> {
-        return this.post("/reindex", {
-            payload: options ?? {},
-        });
-    }
-
-    /**
-     * Fetch documents by their IDs from MongoDB (for retry workflow)
-     * Returns documents ready for bulk indexing
-     *
-     * @param objectIds Array of object IDs to fetch
-     */
-    fetchDocumentsByIds(objectIds: string[]): Promise<FetchDocumentsByIdsResult> {
-        return this.post("/fetch-by-ids", {
-            payload: { objectIds },
-        });
-    }
-
-    /**
-     * Bulk delete documents from Elasticsearch
-     *
-     * @param objectIds Array of object IDs to delete
-     */
-    bulkDelete(objectIds: string[]): Promise<BulkDeleteResult> {
-        return this.post("/bulk-delete", {
-            payload: { objectIds },
-        });
-    }
-
-    /**
-     * Get detailed index configuration for the project
-     *
-     * Returns comprehensive information about the Elasticsearch index including
-     * status, embedding dimensions, field mappings, and project configuration.
-     */
-    getConfiguration(): Promise<IndexConfiguration> {
-        return this.post("/configuration", {
-            payload: {},
-        });
-    }
-}