feat(js-api-client): allow upload for file and mass op from the client

Author: Plopix

README.md

@@ -366,10 +366,14 @@ Upload files (like images) to your tenant via pre-signed requests. Server-side o
 import { createBinaryFileManager } from '@crystallize/js-api-client';
 
 const files = createBinaryFileManager(api);
-const key = await files.uploadImage('/absolute/path/to/picture.jpg');
-// Use `key` in subsequent PIM mutations
+const mediaKey = await files.uploadImage('/absolute/path/to/picture.jpg');
+const staticKey = await files.uploadFile('/absolute/path/to/static/file.pdf');
+const bulkKey = await files.uploadMassOperationFile('/absolute/path/to/import.zip');
+// Use the returned keys in subsequent PIM mutations
 ```
 
+`uploadImage` validates that the file is an image before creating a `MEDIA` upload. Use `uploadFile` for assets that should live in the tenant's static file storage, and `uploadMassOperationFile` for imports handled by the mass operations pipeline. Call `uploadToTenant` directly if you need lower-level control (e.g., custom buffers or upload types).
+
 [crystallizeobject]: crystallize_marketing|folder|625619f6615e162541535959
 
 ## Mass Call Client

UPGRADE.md

@@ -176,10 +176,14 @@ After (v5): `createBinaryFileManager(api)`
 ```ts
 import { createBinaryFileManager } from '@crystallize/js-api-client';
 const files = createBinaryFileManager(api);
-const key = await files.uploadImage('/path/to/picture.jpg');
-// Use `key` in subsequent PIM mutations
+const mediaKey = await files.uploadImage('/path/to/picture.jpg');
+const staticKey = await files.uploadFile('/path/to/static/file.pdf');
+const bulkKey = await files.uploadMassOperationFile('/path/to/import.json');
+// Use the returned keys in subsequent PIM mutations
 ```
 
+`uploadImage` enforces image uploads and targets the `MEDIA` storage bucket. `uploadFile` routes other assets to the static file storage, while `uploadMassOperationFile` prepares files for ingestion by the mass operations pipeline. Use `uploadToTenant` if you need to provide your own buffer or specify the upload type manually.
+
 ### Signature verification
 
 Before (v4): `createAsyncSignatureVerifier` (and an older sync variant)

package.json

@@ -1,7 +1,7 @@
 {
     "name": "@crystallize/js-api-client",
     "license": "MIT",
-    "version": "5.0.0",
+    "version": "5.1.0",
     "type": "module",
     "author": "Crystallize <[email protected]> (https://crystallize.com)",
     "contributors": [

src/core/pim/create-binary-file-manager.ts

@@ -2,47 +2,50 @@ import * as fs from 'fs';
 import * as mime from 'mime-lite';
 import { ClientInterface } from '../client/create-client.js';
 
-type ImageInputWithReferenceId = {
+type BinaryInputWithReferenceId = {
     filename: string;
     mimeType: string;
 };
 
-type UploadHandler = ImageInputWithReferenceId & {
+type BinaryHandler = BinaryInputWithReferenceId & {
     buffer: NonSharedBuffer;
+    type: 'MEDIA' | 'STATIC' | 'MASS_OPERATIONS';
 };
 
-const MUTATION_UPLOAD_FILE = `#graphql
-mutation UPLOAD_FILE ($filename: String!, $mimeType: String!) {
+const generatePresignedUploadRequest = `#graphql
+    mutation GET_URL($file: String!, $contentType: String!, $type: FileUploadType!) {
     generatePresignedUploadRequest(
-        filename: $filename
-        contentType: $mimeType
-        type: MEDIA
+        filename: $file
+        contentType: $contentType
+        type: $type
     ) {
         ... on PresignedUploadRequest {
-            url
-            fields {
-                name
-                value
-            }
+          url
+          fields {
+            name
+            value
+          }
+          maxSize
+          lifetime
         }
         ... on BasicError {
-            errorName
-            message
+          error: message
         }
     }
 }`;
 
 export const createBinaryFileManager = (apiClient: ClientInterface) => {
     // this function returns the key of the uploaded file
-    const uploadToTenant = async ({ mimeType, filename, buffer }: UploadHandler): Promise<string> => {
+    const uploadToTenant = async ({ type = 'MEDIA', mimeType, filename, buffer }: BinaryHandler): Promise<string> => {
         const signedRequestResult = await apiClient.nextPimApi<{
             generatePresignedUploadRequest: {
                 url: string;
                 fields: Array<{ name: string; value: string }>;
             };
-        }>(MUTATION_UPLOAD_FILE, {
-            filename,
-            mimeType,
+        }>(generatePresignedUploadRequest, {
+            file: filename,
+            contentType: mimeType,
+            type: type || 'MEDIA',
         });
 
         const payload = signedRequestResult.generatePresignedUploadRequest;
@@ -67,28 +70,68 @@ export const createBinaryFileManager = (apiClient: ClientInterface) => {
         return formData.get('key') as string;
     };
 
-    const uploadImage = async (imagePath: string): Promise<string> => {
-        const extension = imagePath.split('.').pop() as string;
+    const uploadImage = async (path: string): Promise<string> => {
+        const extension = path.split('.').pop() as string;
         const mimeType = mime.getType(extension);
-        const filename = imagePath.split('T/').pop() as string;
+        const filename = path.split('/').pop() as string;
         if (!mimeType) {
-            throw new Error(`Could not determine mime type for file: ${imagePath}`);
+            throw new Error(`Could not determine mime type for file: ${path}`);
         }
         if (!mimeType.includes('image')) {
-            throw new Error(`File is not an image: ${imagePath}`);
+            throw new Error(`File is not an image: ${path}`);
         }
-        const buffer = fs.readFileSync(imagePath);
-        const imageKey = await uploadToTenant({
+        const buffer = fs.readFileSync(path);
+        const key = await uploadToTenant({
+            mimeType,
+            filename,
+            buffer,
+            type: 'MEDIA',
+        });
+        const registerImage = `#graphql
+            mutation REGISTER_IMAGE($key: String!, $tenantId: ID!) {
+            image {
+                registerImage(key: $key, tenantId: $tenantId) {
+                key
+                }
+            }
+        }`;
+        await apiClient.pimApi(registerImage, {
+            key,
+            tenantId: apiClient.config.tenantId,
+        });
+        return key;
+    };
+
+    const uploadFile = async (path: string): Promise<string> => {
+        const extension = path.split('.').pop() as string;
+        const mimeType = mime.getType(extension);
+        const filename = path.split('/').pop() as string;
+        const buffer = fs.readFileSync(path);
+        return await uploadToTenant({
             mimeType,
             filename,
             buffer,
+            type: 'STATIC',
         });
+    };
 
-        return imageKey;
+    const uploadMassOperationFile = async (path: string): Promise<string> => {
+        const extension = path.split('.').pop() as string;
+        const mimeType = mime.getType(extension);
+        const filename = path.split('/').pop() as string;
+        const buffer = fs.readFileSync(path);
+        return await uploadToTenant({
+            mimeType,
+            filename,
+            buffer,
+            type: 'MASS_OPERATIONS',
+        });
     };
 
     return {
         uploadToTenant,
         uploadImage,
+        uploadFile,
+        uploadMassOperationFile,
     };
 };