@giveitsmaller/sdk 0.2.2 → 0.2.3

package/dist/client.d.ts

@@ -19,6 +19,17 @@ export declare class GislClient {
      */
     uploadFile(file: string | Blob, options?: UploadOptions): Promise<UploadResponse>;
     private singleUpload;
+    /**
+     * Direct-to-S3 multipart upload for files above the threshold.
+     *
+     * The /multipart/complete response (MultipartCompleteResponse) only carries
+     * { upload_id, status }. The server's upload_id is the same UUID callers
+     * pass as file_id to POST /api/workflows — so fileId is synthesised from
+     * upload_id and a full UploadResponse is returned to keep the public
+     * uploadFile() API uniform across single and multipart paths. The mimeType
+     * comes from the initiate response's first-chunk detection; for authoritative
+     * post-upload metadata callers should use getMetadata(fileId).
+     */
     private multipartUpload;
     /**
      * Create a new workflow.

package/dist/client.js

@@ -1,6 +1,6 @@
 import { readFileSync, statSync } from 'node:fs';
 import { basename } from 'node:path';
-import { UploadResponseFromJSON, MultipartInitiateResponseFromJSON, WorkflowCreateResponseFromJSON, WorkflowStatusResponseFromJSON, WorkflowDownloadResponseFromJSON, MetadataResponseFromJSON, OperationsSchemaResponseFromJSON, RetryResponseFromJSON, WorkflowStatus, } from '@giveitsmaller/contracts/openapi';
+import { UploadResponseFromJSON, MultipartInitiateResponseFromJSON, MultipartCompleteResponseFromJSON, WorkflowCreateResponseFromJSON, WorkflowStatusResponseFromJSON, WorkflowDownloadResponseFromJSON, MetadataResponseFromJSON, OperationsSchemaResponseFromJSON, RetryResponseFromJSON, WorkflowStatus, } from '@giveitsmaller/contracts/openapi';
 import { GislApiError, GislError, GislTimeoutError, GislValidationError } from './errors.js';
 import { parseSseStream } from './sse.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -19,6 +19,13 @@ const TERMINAL_STATUSES = new Set([
     WorkflowStatus.failed,
     WorkflowStatus.partially_failed,
 ]);
+function isValidationDetails(value) {
+    return (Array.isArray(value) &&
+        value.every((el) => typeof el === 'object' &&
+            el !== null &&
+            typeof el.field === 'string' &&
+            typeof el.message === 'string'));
+}
 export class GislClient {
     baseUrl;
     headers;
@@ -78,27 +85,34 @@ export class GislClient {
         return this.handleResponse(response, path, opts.deserialize);
     }
     async handleResponse(response, path, deserialize) {
-        const contentType = response.headers.get('content-type') ?? '';
-        if (!contentType.includes('application/json')) {
+        const contentType = (response.headers.get('content-type') ?? '').toLowerCase();
+        const isJsonContent = contentType.includes('application/json') || contentType.includes('+json');
+        if (!isJsonContent) {
             if (!response.ok) {
-                throw new GislApiError(response.status, `Non-JSON error from ${path}`);
+                throw new GislApiError(response.status, 'Non-JSON response', path);
             }
             return undefined;
         }
-        const json = await response.json();
+        let json;
+        try {
+            json = await response.json();
+        }
+        catch {
+            throw new GislApiError(response.status, 'Invalid JSON response', path);
+        }
         // Schema endpoint returns raw JSON (no envelope)
         if (path === '/api/operations/schema') {
             if (!response.ok) {
-                throw new GislApiError(response.status, json.error ?? 'Unknown error');
+                throw new GislApiError(response.status, json.error ?? 'Unknown error', path);
             }
             return deserialize ? deserialize(json) : json;
         }
         // Standard envelope: { success, data } or { success, error, details }
         if (!response.ok || json.success === false) {
-            if (json.details && Array.isArray(json.details)) {
-                throw new GislValidationError(response.status, json.error ?? 'Validation error', json.details);
+            if (isValidationDetails(json.details)) {
+                throw new GislValidationError(response.status, json.error ?? 'Validation error', json.details, path);
             }
-            throw new GislApiError(response.status, json.error ?? 'Unknown error');
+            throw new GislApiError(response.status, json.error ?? 'Unknown error', path, json.details);
         }
         const data = json.data ?? json;
         return deserialize ? deserialize(data) : data;
@@ -143,6 +157,17 @@ export class GislClient {
             deserialize: UploadResponseFromJSON,
         });
     }
+    /**
+     * Direct-to-S3 multipart upload for files above the threshold.
+     *
+     * The /multipart/complete response (MultipartCompleteResponse) only carries
+     * { upload_id, status }. The server's upload_id is the same UUID callers
+     * pass as file_id to POST /api/workflows — so fileId is synthesised from
+     * upload_id and a full UploadResponse is returned to keep the public
+     * uploadFile() API uniform across single and multipart paths. The mimeType
+     * comes from the initiate response's first-chunk detection; for authoritative
+     * post-upload metadata callers should use getMetadata(fileId).
+     */
     async multipartUpload(blob, fileName, totalSize, options) {
         // Step 1: Initiate with first chunk
         const firstChunkSize = Math.min(totalSize, DEFAULT_MULTIPART_FIRST_CHUNK_SIZE);
@@ -192,15 +217,27 @@ export class GislClient {
             }
         });
         await Promise.all(workers);
-        // Step 3: Complete multipart upload
+        // Step 3: Complete multipart upload.
         etags.sort((a, b) => a.part_number - b.part_number);
-        return this.request('POST', '/api/uploads/multipart/complete', {
+        const completeResp = await this.request('POST', '/api/uploads/multipart/complete', {
             body: {
-                file_id: initResponse.fileId,
+                upload_id: initResponse.uploadId,
                 parts: etags,
             },
-            deserialize: UploadResponseFromJSON,
+            deserialize: MultipartCompleteResponseFromJSON,
         });
+        // Defensive: the status enum currently has only 'completed', but guard
+        // against future expansion so an unexpected terminal state doesn't pass
+        // as a successful upload.
+        if (completeResp.status !== 'completed') {
+            throw new GislError(`Multipart upload completed with unexpected status: ${completeResp.status}`);
+        }
+        return {
+            fileId: completeResp.uploadId,
+            originalName: fileName,
+            mimeType: initResponse.mimeType,
+            sizeBytes: blob.size,
+        };
     }
     // -----------------------------------------------------------------------
     // Workflows
@@ -253,9 +290,10 @@ export class GislClient {
      * Stream SSE events for a workflow. Returns an async iterable.
      */
     async streamEvents(workflowId) {
-        const response = await this.request('GET', `/api/workflows/${encodeURIComponent(workflowId)}/events`, { rawResponse: true });
+        const eventsPath = `/api/workflows/${encodeURIComponent(workflowId)}/events`;
+        const response = await this.request('GET', eventsPath, { rawResponse: true });
         if (!response.ok) {
-            await this.handleResponse(response, `/api/workflows/${workflowId}/events`);
+            await this.handleResponse(response, eventsPath);
         }
         return parseSseStream(response);
     }

package/dist/errors.d.ts

@@ -4,7 +4,9 @@ export declare class GislError extends Error {
 export declare class GislApiError extends GislError {
     readonly statusCode: number;
     readonly errorMessage: string;
-    constructor(statusCode: number, errorMessage: string);
+    readonly path?: string;
+    readonly details?: unknown;
+    constructor(statusCode: number, errorMessage: string, path?: string, details?: unknown);
 }
 export declare class GislValidationError extends GislApiError {
     readonly details: Array<{
@@ -14,7 +16,7 @@ export declare class GislValidationError extends GislApiError {
     constructor(statusCode: number, errorMessage: string, details: Array<{
         field: string;
         message: string;
-    }>);
+    }>, path?: string);
 }
 export declare class GislTimeoutError extends GislError {
     constructor(message: string);

package/dist/errors.js

@@ -7,19 +7,24 @@ export class GislError extends Error {
 export class GislApiError extends GislError {
     statusCode;
     errorMessage;
-    constructor(statusCode, errorMessage) {
-        super(`API error ${statusCode}: ${errorMessage}`);
+    path;
+    details;
+    constructor(statusCode, errorMessage, path, details) {
+        const prefix = path
+            ? `API error ${statusCode} at ${path}`
+            : `API error ${statusCode}`;
+        super(`${prefix}: ${errorMessage}`);
         this.name = 'GislApiError';
         this.statusCode = statusCode;
         this.errorMessage = errorMessage;
+        this.path = path;
+        this.details = details;
     }
 }
 export class GislValidationError extends GislApiError {
-    details;
-    constructor(statusCode, errorMessage, details) {
-        super(statusCode, errorMessage);
+    constructor(statusCode, errorMessage, details, path) {
+        super(statusCode, errorMessage, path, details);
         this.name = 'GislValidationError';
-        this.details = details;
     }
 }
 export class GislTimeoutError extends GislError {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giveitsmaller/sdk",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Node.js SDK for the GISL (Give It Smaller) file compression and processing API",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@giveitsmaller/contracts": "^0.1.0"
+    "@giveitsmaller/contracts": "^0.2.3"
   },
   "devDependencies": {
     "@types/node": "^22",