@vertesia/client 1.5.0-dev.20260722.120446Z → 1.5.0-dev.20260804.124748Z

package/src/store/ObjectsApi.ts

@@ -1,7 +1,9 @@
 import { ApiTopic } from '@vertesia/api-fetch-client';
 import {
+    type BulkObjectCreateOptions,
     type BulkObjectCreateResult,
     type BulkObjectDeleteResult,
+    type BulkObjectUpdateOptions,
     type BulkObjectUpdateResult,
     type Collection,
     type ComplexSearchPayload,
@@ -56,6 +58,7 @@ import { StreamSource } from '../StreamSource.js';
 import { AnalyzeDocApi } from './AnalyzeDocApi.js';
 import type { ZenoClient } from './client.js';
 import { fetchSignedUrl } from './signed-url.js';
+import { getUploadMimeTypeHint, resolveUploadMimeType } from './uploadMimeType.js';
 
 type ContentObjectWritePayload = Omit<CreateContentObjectPayload, 'content'> & {
     content?: ContentSource | File | StreamSource;
@@ -259,9 +262,9 @@ export class ObjectsApi extends ApiTopic {
         const { url, id, mime_type } = await this.getUploadUrl({
             id: isStream ? source.id : undefined,
             name: source.name,
-            mime_type: source.type,
+            mime_type: getUploadMimeTypeHint(source.type),
         });
-        const sourceMimeType = source.type || mime_type;
+        const sourceMimeType = resolveUploadMimeType(source.type, mime_type);
 
         // upload the file content to the signed URL
         const res = await fetchSignedUrl(url, {
@@ -457,23 +460,21 @@ export class ObjectsApi extends ApiTopic {
         return this.del(`/${idOrIds}`);
     }
 
-    bulkUpdate(updates: Record<string, Record<string, unknown>>): Promise<BulkObjectUpdateResult> {
+    bulkUpdate(
+        updates: Record<string, Record<string, unknown>>,
+        options?: BulkObjectUpdateOptions,
+    ): Promise<BulkObjectUpdateResult> {
         const ids = Object.keys(updates);
         return this.client.runOperation({
             name: 'update',
             ids,
-            params: updates,
+            params: options ? { updates, ...options } : updates,
         }) as Promise<BulkObjectUpdateResult>;
     }
 
     bulkCreate(
         objects: CreateContentObjectPayload[],
-        options?: {
-            collection_id?: string;
-            /** @deprecated Events are now always emitted. This suppresses the Temporal-backed delivery targets (workflow, agent, and process) — webhook deliveries still fire. */
-            skip_workflows?: boolean;
-            processing_priority?: ContentObjectProcessingPriority;
-        },
+        options?: BulkObjectCreateOptions,
     ): Promise<BulkObjectCreateResult> {
         return this.client.runOperation({
             name: 'create',

package/src/store/TaskApi.ts

@@ -6,17 +6,17 @@ export class TaskApi extends ApiTopic {
         super(parent, '/api/v1/tasks');
     }
 
-    list(query?: ListTasksQuery): Promise<Task[]> {
-        const params: Record<string, string> = {};
-        if (query?.status) {
-            params.status = Array.isArray(query.status) ? query.status.join(',') : query.status;
-        }
-        if (query?.assignee) params.assignee = query.assignee;
-        if (query?.run_id) params.run_id = query.run_id;
-        if (query?.source_type) params.source_type = query.source_type;
-        if (query?.limit != null) params.limit = String(query.limit);
-        if (query?.offset != null) params.offset = String(query.offset);
-        return this.get('/', { query: params });
+    /**
+     * Lists tasks.
+     *
+     * `status` accepts one value or several, and several go out as a repeated key
+     * (`status=a&status=b`) — which is what the parameter publishes: `style: form`, `explode: true`.
+     * This used to comma-join the array before sending it. Servers still split each occurrence on
+     * commas so SDKs pinned to an older version keep working, but that form was never in the spec,
+     * so newly published clients send the declared one.
+     */
+    list(query: ListTasksQuery = {}): Promise<Task[]> {
+        return this.get('/', { query });
     }
 
     retrieve(id: string): Promise<Task> {

package/src/store/TypeCatalogApi.ts

@@ -1,5 +1,5 @@
 import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
-import type { ContentObjectTypeItem, ContentObjectTypeRef } from '@vertesia/common';
+import type { ContentObjectTypeCatalogEntry, ContentObjectTypeItem, ContentObjectTypeRef } from '@vertesia/common';
 
 export class TypeCatalogApi extends ApiTopic {
     constructor(parent: ClientBase) {
@@ -7,18 +7,22 @@ export class TypeCatalogApi extends ApiTopic {
     }
 
     /**
-     * List all content types (system + app + stored)
+     * List all content types (system + app + stored).
+     *
+     * Returns `ContentObjectTypeCatalogEntry`, not `ContentObjectTypeItem`, for the same reason
+     * {@link resolve} does: the listing includes system and app types, which are declared in code
+     * rather than authored, so they carry none of the four audit fields.
      */
     list(
         query: { tag?: string; limit?: number; offset?: number; layout?: boolean; schema?: boolean } = {},
-    ): Promise<ContentObjectTypeItem[]> {
+    ): Promise<ContentObjectTypeCatalogEntry[]> {
         return this.get('/', { query });
     }
 
     /**
      * List system types only
      */
-    listSysTypes(tag?: string): Promise<ContentObjectTypeItem[]> {
+    listSysTypes(tag?: string): Promise<ContentObjectTypeCatalogEntry[]> {
         return this.get('/sys', {
             query: { tag },
         });
@@ -27,14 +31,17 @@ export class TypeCatalogApi extends ApiTopic {
     /**
      * List all app types from all installed apps
      */
-    listAppTypes(tag?: string): Promise<ContentObjectTypeItem[]> {
+    listAppTypes(tag?: string): Promise<ContentObjectTypeCatalogEntry[]> {
         return this.get('/apps', {
             query: { tag },
         });
     }
 
     /**
-     * List stored types only
+     * List stored types only.
+     *
+     * Stored types are real records, so this one does return `ContentObjectTypeItem` with its audit
+     * fields required.
      */
     listStoredTypes(
         query: { tag?: string; limit?: number; offset?: number; layout?: boolean; schema?: boolean } = {},
@@ -47,9 +54,16 @@ export class TypeCatalogApi extends ApiTopic {
     /**
      * Resolve a type to its full definition.
      * Accepts a string (type ID or code) or a ContentObjectTypeRef.
+     *
+     * Returns a `ContentObjectTypeCatalogEntry`, which is what the endpoint publishes and is NOT
+     * `ContentObjectTypeItem`: the catalog resolves in-code types contributed by plugins, which no
+     * user created and no user has modified, so its four audit fields are optional. Declaring the
+     * stored type here told callers `created_by` was always a string when resolving `sys:Invoice`
+     * hands back a record that has none.
+     *
      * @param typeOrRef Type identifier string, or a ContentObjectTypeRef from a content object
      */
-    resolve(typeOrRef: string | ContentObjectTypeRef): Promise<ContentObjectTypeItem> {
+    resolve(typeOrRef: string | ContentObjectTypeRef): Promise<ContentObjectTypeCatalogEntry> {
         const typeId = typeof typeOrRef === 'string' ? typeOrRef : typeOrRef.id;
         return this.get(`/resolve/${typeId}`);
     }

package/src/store/TypesApi.ts

@@ -6,6 +6,7 @@ import type {
     FindPayload,
     ObjectTypeSearchPayload,
     ObjectTypeSearchQuery,
+    UpdateContentObjectTypePayload,
 } from '@vertesia/common';
 import { TypeCatalogApi } from './TypeCatalogApi.js';
 
@@ -58,7 +59,7 @@ export class TypesApi extends ApiTopic {
         return this.get(`/name/${typeName}`);
     }
 
-    update(typeId: string, payload: Partial<CreateContentObjectTypePayload>): Promise<ContentObjectType> {
+    update(typeId: string, payload: UpdateContentObjectTypePayload): Promise<ContentObjectType> {
         return this.put(`/${typeId}`, {
             payload,
         });

package/src/store/uploadMimeType.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { getUploadMimeTypeHint, resolveUploadMimeType } from './uploadMimeType.js';
+
+describe('upload MIME type resolution', () => {
+    it('keeps a specific browser-provided content type', () => {
+        expect(getUploadMimeTypeHint('text/plain')).toBe('text/plain');
+        expect(resolveUploadMimeType('text/plain', 'text/markdown')).toBe('text/plain');
+    });
+
+    it('uses filename inference when the browser reports generic binary content', () => {
+        expect(getUploadMimeTypeHint('application/octet-stream')).toBeUndefined();
+        expect(resolveUploadMimeType('application/octet-stream', 'text/markdown')).toBe('text/markdown');
+    });
+
+    it('uses filename inference when the browser omits the content type', () => {
+        expect(resolveUploadMimeType('', 'text/markdown')).toBe('text/markdown');
+    });
+
+    it('retains octet-stream when no more specific type can be inferred', () => {
+        expect(resolveUploadMimeType('application/octet-stream', undefined)).toBe('application/octet-stream');
+    });
+});

package/src/store/uploadMimeType.ts

@@ -0,0 +1,16 @@
+const GENERIC_BINARY_CONTENT_TYPE = 'application/octet-stream';
+
+function normalizedContentType(contentType: string | undefined): string | undefined {
+    return contentType?.split(';', 1)[0]?.trim().toLowerCase() || undefined;
+}
+
+export function getUploadMimeTypeHint(contentType: string | undefined): string | undefined {
+    return normalizedContentType(contentType) === GENERIC_BINARY_CONTENT_TYPE ? undefined : contentType || undefined;
+}
+
+export function resolveUploadMimeType(
+    sourceContentType: string | undefined,
+    inferredContentType: string | undefined,
+): string | undefined {
+    return getUploadMimeTypeHint(sourceContentType) || inferredContentType || sourceContentType || undefined;
+}

package/src/store/version.ts

@@ -1,3 +1,4 @@
 export const VERSION = '20260319'; // YYYYMMDD, client versioning for API endpoints. Increment manually for breaking changes
-export const VERSION_HEADER = 'x-api-version';
-export { APP_VERSION_HEADER } from '@vertesia/common';
+// Re-exported, not redeclared: the servers read the same constant when deciding how strictly to
+// hold a request to its schema, so a name only this side knew could not stay a negotiation.
+export { APP_VERSION_HEADER, VERSION_HEADER } from '@vertesia/common';