@vertesia/client 1.5.0-dev.20260725.083715Z → 1.5.0-dev.20260806.125520Z

package/src/store/FilesApi.ts

@@ -28,6 +28,44 @@ const FILE_SIGNING_RETRY_POLICY: IRequestRetryPolicy = {
     statuses: [502, 503, 504],
 };
 
+function fileLocationForError(location: string): string {
+    try {
+        const url = new URL(location);
+        return `${url.protocol}//${url.host}${url.pathname}`;
+    } catch {
+        return location.split(/[?#]/, 1)[0] || 'unknown file';
+    }
+}
+
+function sanitizedErrorCause(error: unknown): Error | undefined {
+    if (!(error instanceof Error)) {
+        return undefined;
+    }
+    const message = error.message.replace(/https?:\/\/[^\s)\]}>"']+/g, (url) => fileLocationForError(url));
+    const cause = new Error(message);
+    cause.name = error.name;
+    return cause;
+}
+
+function fileDownloadFailureReason(status?: number, statusText?: string): string {
+    if (status === 404) return 'not found';
+    if (status === 403) return 'forbidden';
+    if (status) return `failed with status ${status}${statusText ? ` ${statusText}` : ''}`;
+    return 'failed';
+}
+
+export class FileDownloadError extends Error {
+    readonly status?: number;
+
+    constructor(location: string, status?: number, statusText?: string, cause?: unknown) {
+        const safeLocation = fileLocationForError(location);
+        const reason = fileDownloadFailureReason(status, statusText);
+        super(`File download ${reason}: ${safeLocation}`, { cause: sanitizedErrorCause(cause) });
+        this.name = 'FileDownloadError';
+        this.status = status;
+    }
+}
+
 export function getMemoryFilePath(name: string) {
     const nameWithExt = name.endsWith('.tar.gz') ? name : `${name}.tar.gz`;
     return `${MEMORIES_PREFIX}/${nameWithExt}`;
@@ -229,28 +267,19 @@ export class FilesApi extends ApiTopic {
         const needSign = !location.startsWith('https:');
         const { url } = needSign ? await this.getDownloadUrl(location) : { url: location };
 
-        const res = await fetchSignedUrl(url, {
-            method: 'GET',
-        })
-            .then((res: Response) => {
-                if (res.ok) {
-                    return res;
-                } else if (res.status === 404) {
-                    throw new Error(`File at ${url} not found`); //TODO: type fetch error better with a fetch error class
-                } else if (res.status === 403) {
-                    throw new Error(`File at ${url} is forbidden`);
-                } else {
-                    console.log(res);
-                    throw new Error(`Failed to download file ${location}: ${res.statusText}`);
-                }
-            })
-            .catch((err) => {
-                console.error(`Failed to download file ${location}.`, err);
-                throw err;
-            });
+        let res: Response;
+        try {
+            res = await fetchSignedUrl(url, { method: 'GET' });
+        } catch (error: unknown) {
+            throw new FileDownloadError(location, undefined, undefined, error);
+        }
+
+        if (!res.ok) {
+            throw new FileDownloadError(location, res.status, res.statusText);
+        }
 
         if (!res.body) {
-            throw new Error(`No body in response while downloading file ${location}`);
+            throw new FileDownloadError(location);
         }
 
         return res.body;

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,
@@ -458,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/version.ts

@@ -1,3 +1,7 @@
-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';
+// Preserve the public client export while sourcing its value from the same module as the servers
+// and OpenAPI generator.
+export {
+    APP_VERSION_HEADER,
+    CURRENT_API_VERSION_HEADER_VALUE as VERSION,
+    VERSION_HEADER,
+} from '@vertesia/common';