nexabase-console 2.0.4 → 2.0.6

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, SettableMetadata, ListOptions, ListResult } 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: 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: SettableMetadata): Promise<StorageMetadata>;
+    list(path: string, options?: ListOptions): Promise<ListResult>;
 }
-export declare const getStorage: (app: any) => Storage;
+export declare const getStorage: (app?: any) => Storage;
+export declare const connectStorageEmulator: (storage: Storage, host: string, port: number) => void;

package/dist/storage/Storage.js

@@ -1,49 +1,114 @@
 "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;
     }
+    ref(path = '') {
+        return new StorageReference_1.StorageReferenceImpl(path, this);
+    }
+    refFromURL(url) {
+        // Handle both NexaBase and standard URL paths
+        const match = url.match(/[?&]path=([^&]+)/) || url.match(/storage\/file\/([^?]+)/) || url.match(/storage\/([^?]+)/);
+        if (match && match[1]) {
+            return this.ref(decodeURIComponent(match[1]));
+        }
+        throw new NexaStorageError_1.NexaStorageError('storage/invalid-path', 'Invalid storage URL format');
+    }
+    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 {
-            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);
-                    }
+            const res = await this.client.get(`/api/project/${this.projectId}/storage/url?path=${encodeURIComponent(path)}`);
+            let url = res.data.downloadUrl || res.data.url;
+            // If the backend returns a relative URL, build full absolute URL using client baseURL or window.location.origin
+            if (url && !url.startsWith('http://') && !url.startsWith('https://')) {
+                let baseUrl = this.client.defaults.baseURL || '';
+                if (!baseUrl && typeof window !== 'undefined' && window.location) {
+                    baseUrl = window.location.origin;
+                }
+                if (baseUrl) {
+                    const cleanBase = baseUrl.replace(/\/+$/, '');
+                    const cleanPath = url.startsWith('/') ? url : `/${url}`;
+                    url = `${cleanBase}${cleanPath}`;
                 }
-            });
+            }
+            return url;
+        }
+        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, err.response.status);
+            }
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
+        }
+    }
+    async deleteFile(path) {
+        try {
+            const res = await this.client.delete(`/api/project/${this.projectId}/storage/file?path=${encodeURIComponent(path)}`);
             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, err.response.status);
+            }
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
     }
-    async getDownloadURL(path) {
+    async getMetadata(path) {
         try {
-            const res = await this.client.get(`/api/project/${this.projectId}/storage/url?path=${encodeURIComponent(path)}`);
-            return res.data.url;
+            const res = await this.client.get(`/api/project/${this.projectId}/storage/metadata?path=${encodeURIComponent(path)}`);
+            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, err.response.status);
+            }
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
     }
-    async deleteFile(path) {
+    async updateMetadata(path, metadata) {
         try {
-            const res = await this.client.delete(`/api/project/${this.projectId}/storage/file?path=${encodeURIComponent(path)}`);
+            const res = await this.client.put(`/api/project/${this.projectId}/storage/metadata?path=${encodeURIComponent(path)}`, metadata);
             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, err.response.status);
+            }
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
+        }
+    }
+    async list(path, options) {
+        try {
+            const params = new URLSearchParams();
+            if (path)
+                params.append('path', path);
+            if (options?.maxResults)
+                params.append('maxResults', options.maxResults.toString());
+            const res = await this.client.get(`/api/project/${this.projectId}/storage/list?${params.toString()}`);
+            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, err.response.status);
+            }
+            throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
     }
 }
@@ -52,6 +117,23 @@ const getStorage = (app) => {
     if (app && typeof app.storage === 'function') {
         return app.storage();
     }
-    throw new Error('Invalid NexaApp instance provided to getStorage()');
+    if (app && app.storageService) {
+        return app.storageService;
+    }
+    if (app instanceof Storage) {
+        return app;
+    }
+    throw new Error('NexaApp instance is required for getStorage(app)');
 };
 exports.getStorage = getStorage;
+const connectStorageEmulator = (storage, host, port) => {
+    if (storage.emulatorUrl) {
+        throw new Error('Emulator already connected.');
+    }
+    storage.emulatorUrl = `http://${host}:${port}`;
+    const client = storage.client;
+    if (client) {
+        client.defaults.baseURL = storage.emulatorUrl;
+    }
+};
+exports.connectStorageEmulator = connectStorageEmulator;

package/dist/storage/StorageReference.d.ts

@@ -1,31 +1,66 @@
-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, SettableMetadata, StringFormat, UploadResult, ListOptions, ListResult } from './types';
+import { UploadOptions } from '../types/index';
+export interface IStorageReference {
+    name: string;
+    bucket: string;
+    fullPath: string;
     path: string;
-    private storage;
-    constructor(path: string, storage: Storage);
-    upload(file: File | Blob, options?: UploadOptions): Promise<{
+    root: IStorageReference;
+    parent: IStorageReference | null;
+    storage: Storage;
+    put(file: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata): UploadTask;
+    putString(data: string, format?: StringFormat, metadata?: UploadMetadata): UploadTask;
+    getDownloadURL(): Promise<string>;
+    getMetadata(): Promise<StorageMetadata>;
+    updateMetadata(metadata: SettableMetadata): Promise<StorageMetadata>;
+    delete(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    listAll(): Promise<ListResult>;
+    list(options?: ListOptions): Promise<ListResult>;
+    upload?: (file: File | Blob, options?: UploadOptions) => Promise<{
         url: string;
         path: string;
     }>;
+}
+export declare class StorageReferenceImpl implements IStorageReference {
+    path: string;
+    fullPath: string;
+    name: string;
+    bucket: string;
+    storage: Storage;
+    constructor(path: string, storage: Storage);
+    get root(): IStorageReference;
+    get parent(): IStorageReference | null;
+    put(data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata): UploadTask;
+    putString(data: string, format?: StringFormat, metadata?: UploadMetadata): UploadTask;
     getDownloadURL(): Promise<string>;
+    getMetadata(): Promise<StorageMetadata>;
+    updateMetadata(metadata: SettableMetadata): Promise<StorageMetadata>;
     delete(): Promise<{
         success: boolean;
         message?: string;
     }>;
+    listAll(): Promise<ListResult>;
+    list(options?: ListOptions): Promise<ListResult>;
+    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;
-}>;
+/**
+ * 1:1 Modular Firebase Storage API functions
+ */
+export declare const ref: (storageOrRef: Storage | IStorageReference, path?: string) => IStorageReference;
+export declare const uploadBytes: (storageRef: IStorageReference, data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata) => Promise<UploadResult>;
+export declare const uploadBytesResumable: (storageRef: IStorageReference, data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata) => UploadTask;
+export declare const uploadString: (storageRef: IStorageReference, value: string, format?: StringFormat, metadata?: UploadMetadata) => Promise<UploadResult>;
 export declare const getDownloadURL: (storageRef: IStorageReference) => Promise<string>;
-export declare const deleteObject: (storageRef: IStorageReference) => Promise<{
-    success: boolean;
-    message?: string;
-}>;
+export declare const getMetadata: (storageRef: IStorageReference) => Promise<StorageMetadata>;
+export declare const updateMetadata: (storageRef: IStorageReference, metadata: SettableMetadata) => Promise<StorageMetadata>;
+export declare const deleteObject: (storageRef: IStorageReference) => Promise<void>;
+export declare const listAll: (storageRef: IStorageReference) => Promise<ListResult>;
+export declare const list: (storageRef: IStorageReference, options?: ListOptions) => Promise<ListResult>;

package/dist/storage/StorageReference.js

@@ -1,52 +1,177 @@
 "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.list = exports.listAll = exports.deleteObject = exports.updateMetadata = exports.getMetadata = exports.getDownloadURL = exports.uploadString = exports.uploadBytesResumable = exports.uploadBytes = exports.ref = exports.StorageReferenceImpl = void 0;
+const NexaStorageError_1 = require("./NexaStorageError");
 class StorageReferenceImpl {
     constructor(path, storage) {
-        this.path = path;
+        // Normalize path by stripping leading slashes
+        this.path = (path || '').replace(/^\/+/, '');
+        this.fullPath = this.path;
+        this.name = this.path.split('/').filter(Boolean).pop() || '';
+        this.bucket = storage.projectId || '';
         this.storage = storage;
     }
-    async upload(file, options) {
-        return this.storage.uploadFile(this.path, file, options);
+    get root() {
+        return new StorageReferenceImpl('', this.storage);
+    }
+    get parent() {
+        const parts = this.path.split('/').filter(Boolean);
+        if (parts.length <= 1)
+            return null;
+        parts.pop();
+        return new StorageReferenceImpl(parts.join('/'), this.storage);
+    }
+    put(data, metadata) {
+        let blob;
+        if (data instanceof Blob) {
+            blob = data;
+        }
+        else if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+            blob = new Blob([data], { type: metadata?.contentType || 'application/octet-stream' });
+        }
+        else {
+            blob = new Blob([data]);
+        }
+        return this.storage.createUploadTask(this.path, blob, metadata);
     }
-    async getDownloadURL() {
+    putString(data, format = 'raw', metadata) {
+        let blob;
+        try {
+            if (format === 'base64') {
+                const byteCharacters = atob(data);
+                const byteNumbers = new Uint8Array(byteCharacters.length);
+                for (let i = 0; i < byteCharacters.length; i++) {
+                    byteNumbers[i] = byteCharacters.charCodeAt(i);
+                }
+                blob = new Blob([byteNumbers], { type: metadata?.contentType || 'application/octet-stream' });
+            }
+            else if (format === 'base64url') {
+                let base64 = data.replace(/-/g, '+').replace(/_/g, '/');
+                while (base64.length % 4) {
+                    base64 += '=';
+                }
+                const byteCharacters = atob(base64);
+                const byteNumbers = new Uint8Array(byteCharacters.length);
+                for (let i = 0; i < byteCharacters.length; i++) {
+                    byteNumbers[i] = byteCharacters.charCodeAt(i);
+                }
+                blob = new Blob([byteNumbers], { type: metadata?.contentType || 'application/octet-stream' });
+            }
+            else if (format === 'data_url') {
+                const parts = data.split(',');
+                const mimeMatch = parts[0]?.match(/:(.*?);/);
+                const detectedMime = mimeMatch ? mimeMatch[1] : 'application/octet-stream';
+                const b64Data = parts[1] || '';
+                const byteCharacters = atob(b64Data);
+                const byteNumbers = new Uint8Array(byteCharacters.length);
+                for (let i = 0; i < byteCharacters.length; i++) {
+                    byteNumbers[i] = byteCharacters.charCodeAt(i);
+                }
+                blob = new Blob([byteNumbers], { type: metadata?.contentType || detectedMime });
+            }
+            else {
+                blob = new Blob([data], { type: metadata?.contentType || 'text/plain;charset=utf-8' });
+            }
+        }
+        catch (err) {
+            throw new NexaStorageError_1.NexaStorageError('storage/invalid-format', `Failed to parse data as ${format}: ${err.message}`);
+        }
+        return this.put(blob, metadata);
+    }
+    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;
+        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);
+/**
+ * 1:1 Modular Firebase Storage API functions
+ */
+const ref = (storageOrRef, path) => {
+    if (!storageOrRef) {
+        throw new NexaStorageError_1.NexaStorageError('storage/invalid-path', 'No storage instance or reference provided');
+    }
+    if ('storage' in storageOrRef && typeof storageOrRef.storage?.ref === 'function') {
+        // First argument is a StorageReference, child path is appended
+        const parent = storageOrRef;
+        const combinedPath = path ? `${parent.path.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}` : parent.path;
+        return new StorageReferenceImpl(combinedPath, parent.storage);
+    }
+    const storage = storageOrRef;
+    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, data, metadata) => {
+    const task = storageRef.put(data, metadata);
+    const snapshot = await task;
+    return {
+        bytesTransferred: snapshot.bytesTransferred,
+        totalBytes: snapshot.totalBytes,
+        state: snapshot.state,
+        metadata: snapshot.metadata,
+        ref: storageRef
+    };
 };
 exports.uploadBytes = uploadBytes;
-const uploadBytesResumable = (storageRef, file, options) => {
-    return (0, exports.uploadBytes)(storageRef, file, options);
+const uploadBytesResumable = (storageRef, data, metadata) => {
+    return storageRef.put(data, metadata);
 };
 exports.uploadBytesResumable = uploadBytesResumable;
+const uploadString = async (storageRef, value, format = 'raw', metadata) => {
+    const task = storageRef.putString(value, format, metadata);
+    const snapshot = await task;
+    return {
+        bytesTransferred: snapshot.bytesTransferred,
+        totalBytes: snapshot.totalBytes,
+        state: snapshot.state,
+        metadata: snapshot.metadata,
+        ref: storageRef
+    };
+};
+exports.uploadString = uploadString;
 const getDownloadURL = async (storageRef) => {
-    if (storageRef.getDownloadURL) {
-        return storageRef.getDownloadURL();
-    }
-    throw new Error('Invalid storage reference');
+    return storageRef.getDownloadURL();
 };
 exports.getDownloadURL = getDownloadURL;
+const getMetadata = async (storageRef) => {
+    return storageRef.getMetadata();
+};
+exports.getMetadata = getMetadata;
+const updateMetadata = async (storageRef, metadata) => {
+    return storageRef.updateMetadata(metadata);
+};
+exports.updateMetadata = updateMetadata;
 const deleteObject = async (storageRef) => {
-    if (storageRef.delete) {
-        return storageRef.delete();
-    }
-    throw new Error('Invalid storage reference');
+    await storageRef.delete();
 };
 exports.deleteObject = deleteObject;
+const listAll = async (storageRef) => {
+    return storageRef.listAll();
+};
+exports.listAll = listAll;
+const list = async (storageRef, options) => {
+    return storageRef.list(options);
+};
+exports.list = list;

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,55 @@
+export type StorageErrorCode = 'storage/unauthenticated' | 'storage/unauthorized' | 'storage/object-not-found' | 'storage/object-already-exists' | 'storage/invalid-path' | 'storage/invalid-file' | 'storage/invalid-format' | '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>;
+    downloadTokens?: string;
+}
+export interface UploadMetadata {
+    md5Hash?: string;
+    cacheControl?: string;
+    contentDisposition?: string;
+    contentEncoding?: string;
+    contentLanguage?: string;
+    contentType?: string;
+    customMetadata?: Record<string, string>;
+}
+export type SettableMetadata = UploadMetadata;
+export type StringFormat = 'raw' | 'base64' | 'base64url' | 'data_url';
+export type TaskState = 'running' | 'paused' | 'success' | 'canceled' | 'error';
+export interface UploadTaskSnapshot {
+    bytesTransferred: number;
+    totalBytes: number;
+    state: TaskState;
+    metadata?: StorageMetadata;
+    task: any;
+    ref: any;
+}
+export interface UploadResult {
+    bytesTransferred: number;
+    totalBytes: number;
+    state: TaskState;
+    metadata?: StorageMetadata;
+    ref: any;
+}
+export interface ListOptions {
+    maxResults?: number;
+    pageToken?: string;
+}
+export interface ListResult {
+    items: any[];
+    prefixes: any[];
+    nextPageToken?: string;
+}

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.6",
   "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",