nexabase-console 2.0.4 → 2.0.5

package/dist/storage/NexaStorageError.d.ts

@@ -0,0 +1,8 @@
+import { StorageErrorCode } from './types';
+export declare class NexaStorageError extends Error {
+    code: StorageErrorCode;
+    status?: number;
+    retryable: boolean;
+    cause?: any;
+    constructor(code: StorageErrorCode, message: string, status?: number, retryable?: boolean, cause?: any);
+}

package/dist/storage/NexaStorageError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NexaStorageError = void 0;
+class NexaStorageError extends Error {
+    constructor(code, message, status, retryable = false, cause) {
+        super(message);
+        this.name = 'NexaStorageError';
+        this.code = code;
+        this.status = status;
+        this.retryable = retryable;
+        this.cause = cause;
+    }
+}
+exports.NexaStorageError = NexaStorageError;

package/dist/storage/Storage.d.ts

@@ -1,9 +1,16 @@
 import { AxiosInstance } from 'axios';
+import { UploadMetadata, StorageMetadata } from './types';
 import { UploadOptions } from '../types/index';
+import { UploadTask } from './UploadTask';
+import { IStorageReference } from './StorageReference';
 export declare class Storage {
     private projectId;
     private client;
+    emulatorUrl?: string;
     constructor(projectId: string, client: AxiosInstance);
+    ref(path: string): IStorageReference;
+    refFromURL(url: string): IStorageReference;
+    createUploadTask(path: string, file: File | Blob, metadata?: UploadMetadata): UploadTask;
     uploadFile(path: string, file: File | Blob, options?: UploadOptions): Promise<{
         url: string;
         path: string;
@@ -13,5 +20,9 @@ export declare class Storage {
         success: boolean;
         message?: string;
     }>;
+    getMetadata(path: string): Promise<StorageMetadata>;
+    updateMetadata(path: string, metadata: Partial<StorageMetadata>): Promise<StorageMetadata>;
+    list(path: string, options?: any): Promise<any>;
 }
 export declare const getStorage: (app: any) => Storage;
+export declare const connectStorageEmulator: (storage: Storage, host: string, port: number) => void;

package/dist/storage/Storage.js

@@ -1,32 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStorage = exports.Storage = void 0;
+exports.connectStorageEmulator = exports.getStorage = exports.Storage = void 0;
 const UploadTask_1 = require("./UploadTask");
-const NexaError_1 = require("../errors/NexaError");
+const NexaStorageError_1 = require("./NexaStorageError");
+const StorageReference_1 = require("./StorageReference");
 class Storage {
     constructor(projectId, client) {
         this.projectId = projectId;
         this.client = client;
     }
-    async uploadFile(path, file, options) {
-        try {
-            const uploadTask = new UploadTask_1.UploadTask(path, file, options);
-            const formData = new FormData();
-            formData.append('file', file);
-            formData.append('path', path);
-            const res = await this.client.post(`/api/project/${this.projectId}/storage/upload`, formData, {
-                onUploadProgress: (progressEvent) => {
-                    if (progressEvent.total) {
-                        const percent = Math.round((progressEvent.loaded * 100) / progressEvent.total);
-                        uploadTask.notifyProgress(percent);
-                    }
-                }
-            });
-            return res.data;
-        }
-        catch (err) {
-            throw (0, NexaError_1.toNexaError)(err);
+    ref(path) {
+        return new StorageReference_1.StorageReferenceImpl(path, this);
+    }
+    refFromURL(url) {
+        const match = url.match(/storage\/([^?]*)/);
+        if (match && match[1]) {
+            return this.ref(decodeURIComponent(match[1]));
         }
+        throw new NexaStorageError_1.NexaStorageError('storage/invalid-path', 'Invalid storage URL');
+    }
+    createUploadTask(path, file, metadata) {
+        const task = new UploadTask_1.UploadTask(this.projectId, this.client, path, file, metadata);
+        task.ref = this.ref(path);
+        return task;
+    }
+    // Legacy upload logic
+    async uploadFile(path, file, options) {
+        const task = this.createUploadTask(path, file);
+        task.options = options;
+        await task;
+        const url = await this.getDownloadURL(path);
+        return { url, path };
     }
     async getDownloadURL(path) {
         try {
@@ -34,7 +38,10 @@ class Storage {
             return res.data.url;
         }
         catch (err) {
-            throw (0, NexaError_1.toNexaError)(err);
+            if (err.response) {
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+            }
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
     }
     async deleteFile(path) {
@@ -43,7 +50,43 @@ class Storage {
             return res.data;
         }
         catch (err) {
-            throw (0, NexaError_1.toNexaError)(err);
+            if (err.response) {
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+            }
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
+        }
+    }
+    async getMetadata(path) {
+        try {
+            const res = await this.client.get(`/api/project/${this.projectId}/storage/metadata?path=${encodeURIComponent(path)}`);
+            return res.data;
+        }
+        catch (err) {
+            if (err.response)
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
+        }
+    }
+    async updateMetadata(path, metadata) {
+        try {
+            const res = await this.client.put(`/api/project/${this.projectId}/storage/metadata?path=${encodeURIComponent(path)}`, metadata);
+            return res.data;
+        }
+        catch (err) {
+            if (err.response)
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
+        }
+    }
+    async list(path, options) {
+        try {
+            const res = await this.client.get(`/api/project/${this.projectId}/storage/list?path=${encodeURIComponent(path)}`);
+            return res.data;
+        }
+        catch (err) {
+            if (err.response)
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
     }
 }
@@ -55,3 +98,15 @@ const getStorage = (app) => {
     throw new Error('Invalid NexaApp instance provided to getStorage()');
 };
 exports.getStorage = getStorage;
+const connectStorageEmulator = (storage, host, port) => {
+    if (storage.emulatorUrl) {
+        throw new Error('Emulator already connected.');
+    }
+    storage.emulatorUrl = `http://${host}:${port}`;
+    // Modify the axios client inside storage to point to emulator
+    const client = storage.client;
+    if (client) {
+        client.defaults.baseURL = storage.emulatorUrl;
+    }
+};
+exports.connectStorageEmulator = connectStorageEmulator;

package/dist/storage/StorageReference.d.ts

@@ -1,29 +1,47 @@
-import { StorageReference as IStorageReference, UploadOptions } from '../types/index';
 import { Storage } from './Storage';
-export declare class StorageReferenceImpl implements IStorageReference {
+import { UploadTask } from './UploadTask';
+import { UploadMetadata, StorageMetadata } from './types';
+import { UploadOptions } from '../types/index';
+export interface IStorageReference {
     path: string;
-    private storage;
-    constructor(path: string, storage: Storage);
-    upload(file: File | Blob, options?: UploadOptions): Promise<{
+    put(file: File | Blob, metadata?: UploadMetadata): UploadTask;
+    putString(data: string, format?: string, metadata?: UploadMetadata): UploadTask;
+    getDownloadURL(): Promise<string>;
+    getMetadata(): Promise<StorageMetadata>;
+    updateMetadata(metadata: Partial<StorageMetadata>): Promise<StorageMetadata>;
+    delete(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    listAll(): Promise<any>;
+    list(options?: any): Promise<any>;
+    upload?: (file: File | Blob, options?: UploadOptions) => Promise<{
         url: string;
         path: string;
     }>;
+}
+export declare class StorageReferenceImpl implements IStorageReference {
+    path: string;
+    private storage;
+    constructor(path: string, storage: Storage);
+    put(file: File | Blob, metadata?: UploadMetadata): UploadTask;
+    putString(data: string, format?: string, metadata?: UploadMetadata): UploadTask;
     getDownloadURL(): Promise<string>;
+    getMetadata(): Promise<StorageMetadata>;
+    updateMetadata(metadata: Partial<StorageMetadata>): Promise<StorageMetadata>;
     delete(): Promise<{
         success: boolean;
         message?: string;
     }>;
+    listAll(): Promise<any>;
+    list(options?: any): Promise<any>;
+    upload(file: File | Blob, options?: UploadOptions): Promise<{
+        url: string;
+        path: string;
+    }>;
 }
-export declare const storageRef: (storage: Storage, path: string) => IStorageReference;
 export declare const ref: (storage: Storage, path: string) => IStorageReference;
-export declare const uploadBytes: (storageRef: IStorageReference, file: File | Blob, options?: UploadOptions) => Promise<{
-    url: string;
-    path: string;
-}>;
-export declare const uploadBytesResumable: (storageRef: IStorageReference, file: File | Blob, options?: UploadOptions) => Promise<{
-    url: string;
-    path: string;
-}>;
+export declare const uploadBytes: (storageRef: IStorageReference, file: File | Blob, metadata?: UploadMetadata) => Promise<any>;
 export declare const getDownloadURL: (storageRef: IStorageReference) => Promise<string>;
 export declare const deleteObject: (storageRef: IStorageReference) => Promise<{
     success: boolean;

package/dist/storage/StorageReference.js

@@ -1,52 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteObject = exports.getDownloadURL = exports.uploadBytesResumable = exports.uploadBytes = exports.ref = exports.storageRef = exports.StorageReferenceImpl = void 0;
+exports.deleteObject = exports.getDownloadURL = exports.uploadBytes = exports.ref = exports.StorageReferenceImpl = void 0;
 class StorageReferenceImpl {
     constructor(path, storage) {
         this.path = path;
         this.storage = storage;
     }
-    async upload(file, options) {
-        return this.storage.uploadFile(this.path, file, options);
+    put(file, metadata) {
+        return this.storage.createUploadTask(this.path, file, metadata);
+    }
+    putString(data, format = 'raw', metadata) {
+        let blob;
+        if (format === 'base64') {
+            const byteCharacters = atob(data);
+            const byteNumbers = new Array(byteCharacters.length);
+            for (let i = 0; i < byteCharacters.length; i++) {
+                byteNumbers[i] = byteCharacters.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            blob = new Blob([byteArray]);
+        }
+        else {
+            blob = new Blob([data]);
+        }
+        return this.put(blob, metadata);
     }
-    async getDownloadURL() {
+    getDownloadURL() {
         return this.storage.getDownloadURL(this.path);
     }
-    async delete() {
+    getMetadata() {
+        return this.storage.getMetadata(this.path);
+    }
+    updateMetadata(metadata) {
+        return this.storage.updateMetadata(this.path, metadata);
+    }
+    delete() {
         return this.storage.deleteFile(this.path);
     }
+    listAll() {
+        return this.storage.list(this.path);
+    }
+    list(options) {
+        return this.storage.list(this.path, options);
+    }
+    // Legacy for backward compatibility
+    async upload(file, options) {
+        const task = this.put(file, options);
+        task.options = options; // Inject legacy options
+        await task;
+        const url = await this.getDownloadURL();
+        return { url, path: this.path };
+    }
 }
 exports.StorageReferenceImpl = StorageReferenceImpl;
-const storageRef = (storage, path) => {
-    return new StorageReferenceImpl(path, storage);
-};
-exports.storageRef = storageRef;
 const ref = (storage, path) => {
     return new StorageReferenceImpl(path, storage);
 };
 exports.ref = ref;
-const uploadBytes = async (storageRef, file, options) => {
-    if (storageRef.upload) {
-        return storageRef.upload(file, options);
-    }
-    throw new Error('Invalid storage reference');
+const uploadBytes = async (storageRef, file, metadata) => {
+    const task = storageRef.put(file, metadata);
+    return await task;
 };
 exports.uploadBytes = uploadBytes;
-const uploadBytesResumable = (storageRef, file, options) => {
-    return (0, exports.uploadBytes)(storageRef, file, options);
-};
-exports.uploadBytesResumable = uploadBytesResumable;
 const getDownloadURL = async (storageRef) => {
-    if (storageRef.getDownloadURL) {
-        return storageRef.getDownloadURL();
-    }
-    throw new Error('Invalid storage reference');
+    return storageRef.getDownloadURL();
 };
 exports.getDownloadURL = getDownloadURL;
 const deleteObject = async (storageRef) => {
-    if (storageRef.delete) {
-        return storageRef.delete();
-    }
-    throw new Error('Invalid storage reference');
+    return storageRef.delete();
 };
 exports.deleteObject = deleteObject;

package/dist/storage/UploadTask.d.ts

@@ -1,10 +1,37 @@
+import { AxiosInstance } from 'axios';
+import { UploadMetadata, UploadTaskSnapshot } from './types';
 import { UploadOptions } from '../types/index';
-export declare class UploadTask {
+import { NexaStorageError } from './NexaStorageError';
+export declare class UploadTask implements PromiseLike<UploadTaskSnapshot> {
     private file;
     private path;
-    private options?;
-    constructor(path: string, file: File | Blob, options?: UploadOptions);
-    getFile(): File | Blob;
-    getPath(): string;
-    notifyProgress(percent: number): void;
+    options?: UploadOptions;
+    private metadata?;
+    private client;
+    private projectId;
+    private state;
+    private bytesTransferred;
+    private totalBytes;
+    private sessionUrl;
+    private abortController;
+    private listeners;
+    private errorListeners;
+    private completeListeners;
+    private _promise;
+    ref: any;
+    constructor(projectId: string, client: AxiosInstance, path: string, file: File | Blob, metadata?: UploadMetadata, options?: UploadOptions);
+    on(event: 'state_changed', nextOrObserver?: ((snapshot: UploadTaskSnapshot) => void) | {
+        next?: (s: UploadTaskSnapshot) => void;
+        error?: (e: NexaStorageError) => void;
+        complete?: () => void;
+    }, error?: (error: NexaStorageError) => void, complete?: () => void): () => void;
+    private startPromise;
+    then<TResult1 = UploadTaskSnapshot, TResult2 = never>(onfulfilled?: ((value: UploadTaskSnapshot) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<UploadTaskSnapshot | TResult>;
+    private _executeUpload;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    getSnapshot(): UploadTaskSnapshot;
+    private notify;
 }

package/dist/storage/UploadTask.js

@@ -1,21 +1,140 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UploadTask = void 0;
+const NexaStorageError_1 = require("./NexaStorageError");
 class UploadTask {
-    constructor(path, file, options) {
+    constructor(projectId, client, path, file, metadata, options) {
+        this.state = 'running';
+        this.bytesTransferred = 0;
+        this.totalBytes = 0;
+        this.sessionUrl = null;
+        this.listeners = [];
+        this.errorListeners = [];
+        this.completeListeners = [];
+        this._promise = null;
+        this.projectId = projectId;
+        this.client = client;
         this.path = path;
         this.file = file;
+        this.metadata = metadata;
         this.options = options;
+        this.totalBytes = file.size;
+        this.abortController = new AbortController();
     }
-    getFile() {
-        return this.file;
+    on(event, nextOrObserver, error, complete) {
+        if (typeof nextOrObserver === 'function') {
+            this.listeners.push(nextOrObserver);
+            if (error)
+                this.errorListeners.push(error);
+            if (complete)
+                this.completeListeners.push(complete);
+        }
+        else if (nextOrObserver) {
+            if (nextOrObserver.next)
+                this.listeners.push(nextOrObserver.next);
+            if (nextOrObserver.error)
+                this.errorListeners.push(nextOrObserver.error);
+            if (nextOrObserver.complete)
+                this.completeListeners.push(nextOrObserver.complete);
+        }
+        // Auto start if not started
+        this.startPromise();
+        return () => {
+            this.listeners = [];
+            this.errorListeners = [];
+            this.completeListeners = [];
+        };
+    }
+    startPromise() {
+        if (!this._promise) {
+            this._promise = this._executeUpload();
+        }
+        return this._promise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.startPromise().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.startPromise().catch(onrejected);
+    }
+    async _executeUpload() {
+        try {
+            this.state = 'running';
+            this.notify();
+            const sessionRes = await this.client.post(`/api/project/${this.projectId}/storage/upload/session`, {
+                path: this.path,
+                metadata: {
+                    contentType: this.file.type,
+                    ...this.metadata
+                }
+            }, { signal: this.abortController.signal });
+            this.sessionUrl = sessionRes.data.sessionUrl;
+            const uploadRes = await this.client.put(this.sessionUrl, this.file, {
+                headers: {
+                    'Content-Type': 'application/octet-stream',
+                    'x-upload-final': 'true'
+                },
+                signal: this.abortController.signal,
+                onUploadProgress: (progressEvent) => {
+                    if (progressEvent.total) {
+                        this.bytesTransferred = progressEvent.loaded;
+                        this.notify();
+                    }
+                }
+            });
+            this.state = 'success';
+            this.bytesTransferred = this.totalBytes;
+            const finalSnapshot = this.getSnapshot();
+            finalSnapshot.metadata = uploadRes.data.metadata;
+            this.notify();
+            this.completeListeners.forEach(cb => cb());
+            return finalSnapshot;
+        }
+        catch (err) {
+            this.state = 'error';
+            let nexaErr = new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
+            if (err.response) {
+                nexaErr = new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message, err.response.status);
+            }
+            this.errorListeners.forEach(cb => cb(nexaErr));
+            throw nexaErr;
+        }
+    }
+    pause() {
+        if (this.state === 'running') {
+            this.state = 'paused';
+            this.notify();
+        }
+    }
+    resume() {
+        if (this.state === 'paused') {
+            this.state = 'running';
+            this.notify();
+        }
+    }
+    cancel() {
+        if (this.state === 'running' || this.state === 'paused') {
+            this.state = 'canceled';
+            this.abortController.abort();
+            this.notify();
+            const err = new NexaStorageError_1.NexaStorageError('storage/canceled', 'Upload canceled');
+            this.errorListeners.forEach(cb => cb(err));
+        }
     }
-    getPath() {
-        return this.path;
+    getSnapshot() {
+        return {
+            bytesTransferred: this.bytesTransferred,
+            totalBytes: this.totalBytes,
+            state: this.state,
+            task: this,
+            ref: this.ref
+        };
     }
-    notifyProgress(percent) {
-        if (this.options && this.options.onProgress) {
-            this.options.onProgress(percent);
+    notify() {
+        const snap = this.getSnapshot();
+        this.listeners.forEach(cb => cb(snap));
+        if (this.options?.onProgress) {
+            this.options.onProgress(Math.round((snap.bytesTransferred / snap.totalBytes) * 100));
         }
     }
 }

package/dist/storage/types.d.ts

@@ -0,0 +1,36 @@
+export type StorageErrorCode = 'storage/unauthenticated' | 'storage/unauthorized' | 'storage/object-not-found' | 'storage/object-already-exists' | 'storage/invalid-path' | 'storage/invalid-file' | 'storage/invalid-metadata' | 'storage/invalid-checksum' | 'storage/quota-exceeded' | 'storage/upload-session-expired' | 'storage/retry-limit-exceeded' | 'storage/canceled' | 'storage/conflict' | 'storage/network-error' | 'storage/server-error';
+export interface StorageMetadata {
+    name: string;
+    bucket: string;
+    generation: string;
+    metageneration: string;
+    fullPath: string;
+    size: number;
+    timeCreated: string;
+    updated: string;
+    md5Hash?: string;
+    cacheControl?: string;
+    contentDisposition?: string;
+    contentEncoding?: string;
+    contentLanguage?: string;
+    contentType?: string;
+    customMetadata?: Record<string, string>;
+}
+export interface UploadMetadata {
+    md5Hash?: string;
+    cacheControl?: string;
+    contentDisposition?: string;
+    contentEncoding?: string;
+    contentLanguage?: string;
+    contentType?: string;
+    customMetadata?: Record<string, string>;
+}
+export type TaskState = 'running' | 'paused' | 'success' | 'canceled' | 'error';
+export interface UploadTaskSnapshot {
+    bytesTransferred: number;
+    totalBytes: number;
+    state: TaskState;
+    metadata?: StorageMetadata;
+    task: any;
+    ref: any;
+}

package/dist/storage/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",