@e-techsolutions/e-baas-sdk 1.2.2 → 1.2.3

package/dist/index.cjs

@@ -852,246 +852,344 @@ class DatabaseClient {
     }
 }
 
+const STORAGE_BASE_PATH$1 = '/storage/v1';
 class StorageBucket {
-    constructor(httpClient, bucketId) {
+    constructor(httpClient, bucketId, workspaceId) {
         this.httpClient = httpClient;
         this.bucketId = bucketId;
+        this.workspaceId = workspaceId;
+    }
+    setWorkspaceId(workspaceId) {
+        this.workspaceId = workspaceId;
+    }
+    getWorkspaceHeaders() {
+        if (!this.workspaceId) {
+            throw new EBaaSError('Workspace ID is required for storage operations', 400);
+        }
+        return {
+            'x-workspace-id': this.workspaceId,
+        };
+    }
+    normalizePath(path) {
+        return path
+            .trim()
+            .replace(/^\/+/, '')
+            .replace(/\/+$/, '')
+            .replace(/\/+/g, '/');
+    }
+    encodePath(path) {
+        const normalized = this.normalizePath(path);
+        return normalized
+            .split('/')
+            .filter(Boolean)
+            .map((segment) => encodeURIComponent(segment))
+            .join('/');
+    }
+    extractPathParts(path) {
+        const normalized = this.normalizePath(path);
+        if (!normalized) {
+            throw new EBaaSError('Path must include the file name', 400);
+        }
+        const segments = normalized.split('/').filter(Boolean);
+        if (segments.length === 0) {
+            throw new EBaaSError('Path must include the file name', 400);
+        }
+        const fileName = segments.pop();
+        const directory = segments.length ? segments.join('/') : undefined;
+        return { fileName, directory };
+    }
+    serializeTransform(transform) {
+        if (!transform) {
+            return undefined;
+        }
+        const parts = Object.entries(transform)
+            .filter(([, value]) => value !== undefined && value !== null)
+            .map(([key, value]) => `${key}=${value}`);
+        return parts.length ? parts.join(',') : undefined;
+    }
+    appendFileToFormData(formData, file, fileName, contentType) {
+        if (file instanceof File) {
+            if (file.name !== fileName) {
+                formData.append('file', file, fileName);
+            }
+            else {
+                formData.append('file', file);
+            }
+            return;
+        }
+        if (file instanceof Blob) {
+            formData.append('file', file, fileName);
+            return;
+        }
+        if (file instanceof ArrayBuffer) {
+            formData.append('file', new Blob([file], { type: contentType ?? 'application/octet-stream' }), fileName);
+            return;
+        }
+        if (typeof file === 'string') {
+            formData.append('file', new Blob([file], { type: contentType ?? 'text/plain' }), fileName);
+            return;
+        }
+        throw new EBaaSError('Unsupported file type for upload', 400);
     }
     async upload(path, file, options) {
         try {
+            const headers = this.getWorkspaceHeaders();
+            const normalizedPath = this.normalizePath(path);
+            const { fileName, directory } = this.extractPathParts(normalizedPath);
             const formData = new FormData();
-            if (file instanceof File) {
-                formData.append('file', file);
-            }
-            else if (file instanceof Blob) {
-                formData.append('file', file, path);
-            }
-            else if (file instanceof ArrayBuffer) {
-                formData.append('file', new Blob([file]), path);
+            this.appendFileToFormData(formData, file, fileName, options?.contentType);
+            if (directory) {
+                formData.append('path', directory);
             }
-            else if (typeof file === 'string') {
-                formData.append('file', new Blob([file], { type: 'text/plain' }), path);
-            }
-            formData.append('path', path);
             if (options?.cacheControl) {
                 formData.append('cacheControl', options.cacheControl);
             }
+            if (options?.metadata) {
+                formData.append('metadata', JSON.stringify(options.metadata));
+            }
             if (options?.contentType) {
                 formData.append('contentType', options.contentType);
             }
-            if (options?.metadata) {
-                formData.append('metadata', JSON.stringify(options.metadata));
+            if (options?.expiresIn) {
+                formData.append('expiresIn', String(options.expiresIn));
             }
-            const url = `/storage/buckets/${this.bucketId}/files${options?.upsert ? '?upsert=true' : ''}`;
-            const response = await this.httpClient.post(url, formData, {
-                headers: {
-                    'Content-Type': 'multipart/form-data'
-                }
+            if (options?.upsert) {
+                formData.append('overwrite', 'true');
+            }
+            const encodedPath = this.encodePath(normalizedPath);
+            const response = await this.httpClient.post(`${STORAGE_BASE_PATH$1}/object/${this.bucketId}/${encodedPath}`, formData, {
+                headers,
             });
             return {
                 data: response.data,
-                error: null
+                error: null,
             };
         }
         catch (error) {
             return {
                 data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to upload file', 0, error)
+                error: error instanceof EBaaSError
+                    ? error
+                    : new EBaaSError(error instanceof Error ? error.message : 'Failed to upload file', 0, error),
             };
         }
     }
     async download(path, options) {
         try {
-            const params = new URLSearchParams();
-            if (options?.transform) {
-                Object.entries(options.transform).forEach(([key, value]) => {
-                    if (value !== undefined) {
-                        params.append(key, String(value));
-                    }
-                });
-            }
-            const url = `/storage/buckets/${this.bucketId}/files/${path}${params.toString() ? `?${params.toString()}` : ''}`;
-            const response = await this.httpClient.get(url, {
-                responseType: 'blob'
+            const headers = this.getWorkspaceHeaders();
+            const normalizedPath = this.normalizePath(path);
+            const encodedPath = this.encodePath(normalizedPath);
+            const transformString = this.serializeTransform(options?.transform);
+            const query = transformString ? `?transform=${encodeURIComponent(transformString)}` : '';
+            const response = await this.httpClient.get(`${STORAGE_BASE_PATH$1}/object/authenticated/${this.bucketId}/${encodedPath}${query}`, {
+                responseType: 'blob',
+                headers,
             });
             return {
                 data: response.data,
-                error: null
+                error: null,
             };
         }
         catch (error) {
             return {
                 data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to download file', 0, error)
+                error: error instanceof EBaaSError
+                    ? error
+                    : new EBaaSError(error instanceof Error ? error.message : 'Failed to download file', 0, error),
             };
         }
     }
     async list(prefix, options) {
         try {
+            const headers = this.getWorkspaceHeaders();
             const params = new URLSearchParams();
             if (prefix) {
-                params.append('prefix', prefix);
+                const normalizedPrefix = prefix.replace(/^\/+/, '');
+                if (normalizedPrefix) {
+                    params.append('prefix', normalizedPrefix);
+                }
             }
             if (options?.limit) {
                 params.append('limit', String(options.limit));
             }
             if (options?.offset) {
-                params.append('offset', String(options.offset));
-            }
-            if (options?.sortBy) {
-                params.append('sortBy', JSON.stringify(options.sortBy));
+                params.append('offset', options.offset);
             }
             if (options?.search) {
                 params.append('search', options.search);
             }
-            const url = `/storage/buckets/${this.bucketId}/files${params.toString() ? `?${params.toString()}` : ''}`;
-            const response = await this.httpClient.get(url);
+            if (options?.sortBy && options.sortBy.length > 0) {
+                const sortValue = options.sortBy
+                    .map((item) => {
+                    const order = item.order ?? 'asc';
+                    return `${item.column}:${order}`;
+                })
+                    .join(',');
+                params.append('sortBy', sortValue);
+            }
+            const query = params.toString();
+            const response = await this.httpClient.get(`${STORAGE_BASE_PATH$1}/object/list/${this.bucketId}${query ? `?${query}` : ''}`, {
+                headers,
+            });
             return {
                 data: response.data,
-                error: null
+                error: null,
             };
         }
         catch (error) {
             return {
                 data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to list files', 0, error)
+                error: error instanceof EBaaSError
+                    ? error
+                    : new EBaaSError(error instanceof Error ? error.message : 'Failed to list files', 0, error),
             };
         }
     }
     async remove(paths) {
         try {
-            const response = await this.httpClient.delete(`/storage/buckets/${this.bucketId}/files`, {
-                data: { paths }
-            });
+            const headers = this.getWorkspaceHeaders();
+            for (const path of paths) {
+                const normalizedPath = this.normalizePath(path);
+                const encodedPath = this.encodePath(normalizedPath);
+                await this.httpClient.delete(`${STORAGE_BASE_PATH$1}/object/${this.bucketId}/${encodedPath}`, {
+                    headers,
+                });
+            }
             return {
-                data: response.data,
-                error: null
+                data: { message: 'Files removed successfully' },
+                error: null,
             };
         }
         catch (error) {
             return {
                 data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to remove files', 0, error)
+                error: error instanceof EBaaSError
+                    ? error
+                    : new EBaaSError(error instanceof Error ? error.message : 'Failed to remove files', 0, error),
             };
         }
     }
-    async move(fromPath, toPath) {
-        try {
-            const response = await this.httpClient.post(`/storage/buckets/${this.bucketId}/files/move`, {
-                sourceKey: fromPath,
-                destinationKey: toPath
-            });
-            return {
-                data: response.data,
-                error: null
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to move file', 0, error)
-            };
-        }
+    async move(_fromPath, _toPath) {
+        return {
+            data: null,
+            error: new EBaaSError('Move operation is not supported by the current E-BaaS backend', 501),
+        };
     }
-    async copy(fromPath, toPath) {
-        try {
-            const response = await this.httpClient.post(`/storage/buckets/${this.bucketId}/files/copy`, {
-                sourceKey: fromPath,
-                destinationKey: toPath
-            });
-            return {
-                data: response.data,
-                error: null
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to copy file', 0, error)
-            };
-        }
+    async copy(_fromPath, _toPath) {
+        return {
+            data: null,
+            error: new EBaaSError('Copy operation is not supported by the current E-BaaS backend', 501),
+        };
     }
     async createSignedUrl(path, expiresIn, options) {
         try {
-            const response = await this.httpClient.post(`/storage/buckets/${this.bucketId}/files/${path}/sign`, {
-                expiresIn,
-                ...options
+            const headers = this.getWorkspaceHeaders();
+            const normalizedPath = this.normalizePath(path);
+            const response = await this.httpClient.post(`${STORAGE_BASE_PATH$1}/object/sign`, {
+                bucketName: this.bucketId,
+                filePath: normalizedPath,
+                operation: options?.operation ?? 'download',
+                expiresIn: options?.expiresIn ?? expiresIn,
+            }, {
+                headers,
             });
             return {
                 data: response.data,
-                error: null
+                error: null,
             };
         }
         catch (error) {
             return {
                 data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to create signed URL', 0, error)
+                error: error instanceof EBaaSError
+                    ? error
+                    : new EBaaSError(error instanceof Error ? error.message : 'Failed to create signed URL', 0, error),
             };
         }
     }
     getPublicUrl(path, options) {
+        const baseUrl = this.httpClient.baseURL;
+        if (!baseUrl) {
+            throw new EBaaSError('HTTP client base URL is not configured', 400);
+        }
+        if (!this.workspaceId) {
+            throw new EBaaSError('Workspace ID is required to generate public URLs', 400);
+        }
+        const normalizedPath = this.normalizePath(path);
+        const encodedPath = this.encodePath(normalizedPath);
         const params = new URLSearchParams();
-        if (options?.transform) {
-            Object.entries(options.transform).forEach(([key, value]) => {
-                if (value !== undefined) {
-                    params.append(key, String(value));
-                }
-            });
+        params.append('workspaceId', this.workspaceId);
+        const transformString = this.serializeTransform(options?.transform);
+        if (transformString) {
+            params.append('transform', transformString);
         }
-        const baseUrl = this.httpClient['baseURL'] || '';
-        const publicUrl = `${baseUrl}/storage/buckets/${this.bucketId}/files/${path}${params.toString() ? `?${params.toString()}` : ''}`;
+        const publicUrl = `${baseUrl.replace(/\/+$/, '')}${STORAGE_BASE_PATH$1}/object/public/${this.bucketId}/${encodedPath}`;
+        const query = params.toString();
         return {
             data: {
-                publicUrl
-            }
+                publicUrl: query ? `${publicUrl}?${query}` : publicUrl,
+            },
         };
     }
-    async getFileInfo(path) {
-        try {
-            const response = await this.httpClient.get(`/storage/buckets/${this.bucketId}/files/${path}/info`);
-            return {
-                data: response.data,
-                error: null
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to get file info', 0, error)
-            };
-        }
+    async getFileInfo(_path) {
+        return {
+            data: null,
+            error: new EBaaSError('File info retrieval is not supported by the current E-BaaS backend', 501),
+        };
     }
-    async updateFileMetadata(path, metadata) {
-        try {
-            const response = await this.httpClient.put(`/storage/buckets/${this.bucketId}/files/${path}/metadata`, {
-                metadata
-            });
-            return {
-                data: response.data,
-                error: null
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'Failed to update file metadata', 0, error)
-            };
-        }
+    async updateFileMetadata(_path, _metadata) {
+        return {
+            data: null,
+            error: new EBaaSError('Updating file metadata is not supported by the current E-BaaS backend', 501),
+        };
     }
 }
 
+const STORAGE_BASE_PATH = '/storage/v1';
 class StorageClient {
-    constructor(httpClient) {
+    constructor(httpClient, workspaceId) {
         this.httpClient = httpClient;
+        this.workspaceId = workspaceId;
     }
     from(bucketId) {
-        return new StorageBucket(this.httpClient, bucketId);
+        return new StorageBucket(this.httpClient, bucketId, this.workspaceId);
+    }
+    setWorkspaceId(workspaceId) {
+        this.workspaceId = workspaceId;
+    }
+    getWorkspaceHeaders() {
+        if (!this.workspaceId) {
+            throw new EBaaSError('Workspace ID is required for storage operations', 400);
+        }
+        return {
+            'x-workspace-id': this.workspaceId,
+        };
+    }
+    mapBucketOptions(options) {
+        if (!options) {
+            return {};
+        }
+        const visibility = options.visibility ?? (options.public ? 'public' : undefined);
+        const maxFileSize = options.maxFileSize ?? options.fileSizeLimit;
+        const enableVersioning = options.enableVersioning ?? options.versioningEnabled;
+        return {
+            visibility,
+            description: options.description,
+            allowedMimeTypes: options.allowedMimeTypes,
+            maxFileSize,
+            enableVersioning,
+            enableCors: options.enableCors,
+            corsOrigins: options.corsOrigins,
+        };
     }
     async createBucket(id, options) {
         try {
-            const response = await this.httpClient.post('/storage/buckets', {
-                id,
-                ...options
+            const payload = {
+                name: id,
+                ...this.mapBucketOptions(options),
+            };
+            const response = await this.httpClient.post(`${STORAGE_BASE_PATH}/buckets`, payload, {
+                headers: this.getWorkspaceHeaders(),
             });
             return {
                 data: response.data,
@@ -1107,7 +1205,9 @@ class StorageClient {
     }
     async getBucket(id) {
         try {
-            const response = await this.httpClient.get(`/storage/buckets/${id}`);
+            const response = await this.httpClient.get(`${STORAGE_BASE_PATH}/buckets/${id}`, {
+                headers: this.getWorkspaceHeaders(),
+            });
             return {
                 data: response.data,
                 error: null
@@ -1122,7 +1222,9 @@ class StorageClient {
     }
     async listBuckets() {
         try {
-            const response = await this.httpClient.get('/storage/buckets');
+            const response = await this.httpClient.get(`${STORAGE_BASE_PATH}/buckets`, {
+                headers: this.getWorkspaceHeaders(),
+            });
             return {
                 data: response.data,
                 error: null
@@ -1137,7 +1239,10 @@ class StorageClient {
     }
     async updateBucket(id, options) {
         try {
-            const response = await this.httpClient.put(`/storage/buckets/${id}`, options);
+            const payload = this.mapBucketOptions(options);
+            const response = await this.httpClient.put(`${STORAGE_BASE_PATH}/buckets/${id}`, payload, {
+                headers: this.getWorkspaceHeaders(),
+            });
             return {
                 data: response.data,
                 error: null
@@ -1152,7 +1257,9 @@ class StorageClient {
     }
     async deleteBucket(id) {
         try {
-            const response = await this.httpClient.delete(`/storage/buckets/${id}`);
+            const response = await this.httpClient.delete(`${STORAGE_BASE_PATH}/buckets/${id}`, {
+                headers: this.getWorkspaceHeaders(),
+            });
             return {
                 data: response.data,
                 error: null
@@ -1167,7 +1274,9 @@ class StorageClient {
     }
     async getUsage() {
         try {
-            const response = await this.httpClient.get('/storage/usage');
+            const response = await this.httpClient.get(`${STORAGE_BASE_PATH}/usage`, {
+                headers: this.getWorkspaceHeaders(),
+            });
             return {
                 data: response.data,
                 error: null
@@ -1998,7 +2107,7 @@ class EBaaSClient {
         // Initialize all modules
         this.auth = new AuthClient(this.httpClient, options?.database?.workspaceId);
         this.database = new DatabaseClient(this.httpClient, options?.database?.workspaceId, options?.rest?.url);
-        this.storage = new StorageClient(this.httpClient);
+        this.storage = new StorageClient(this.httpClient, options?.database?.workspaceId);
         this.realtime = new RealtimeClient(supabaseUrl, supabaseKey, options?.realtime);
         this.functions = new FunctionsClient(this.httpClient);
         // Initialize custom database detection if enabled
@@ -2043,6 +2152,7 @@ class EBaaSClient {
     async setWorkspaceId(workspaceId) {
         this.auth.setWorkspaceId(workspaceId);
         this.database.setWorkspaceId(workspaceId);
+        this.storage.setWorkspaceId(workspaceId);
         // Se auto-detecção estiver habilitada, re-detecta configuração para o novo workspace
         if (this.options?.database?.autoDetectCustomDatabase) {
             await this.database.initialize();