nexabase-console 2.0.5 → 2.0.7

package/dist/app/NexaApp.d.ts

@@ -1,7 +1,7 @@
 import { AxiosInstance } from 'axios';
 import { NexaConfig, DatabaseReference, StorageReference, UploadOptions, OfflineJob } from '../types/index';
 import { HttpClient } from '../transport/HttpClient';
-import { SSEClient } from '../transport/SSEClient';
+import { SSEClient, WebSocketClient } from '../transport/SSEClient';
 import { Auth } from '../auth/Auth';
 import { User as AuthUser, AuthSession } from '../auth/authTypes';
 import { IndexedDB } from '../persistence/IndexedDB';
@@ -18,6 +18,7 @@ export declare class NexaApp {
     cacheStrategy: 'network-first' | 'cache-first';
     httpClient: HttpClient;
     client: AxiosInstance;
+    wsClient: WebSocketClient;
     sseClient: SSEClient;
     authService: Auth;
     indexedDB: IndexedDB;
@@ -43,7 +44,9 @@ export declare class NexaApp {
     _addOfflineJob(job: OfflineJob): Promise<void>;
     _syncOfflineQueue(): Promise<void>;
     _ensureFirestoreSSE(): void;
+    _ensureFirestoreWebSocket(): void;
     _closeFirestoreSSEIfIdle(): void;
+    _closeFirestoreWebSocketIfIdle(): void;
     _notifySnapshotCallbacks(path: string, actionType: string, payload: any): void;
     signInWithEmailAndPassword(email: string, password: string): Promise<AuthSession>;
     createUserWithEmailAndPassword(email: string, password: string, name?: string): Promise<AuthSession>;
@@ -61,4 +64,6 @@ export declare class NexaApp {
         path: string;
     }>;
     getDownloadURL(path: string): Promise<string>;
+    isConnected(): boolean;
+    onConnectionStateChanged(callback: (isConnected: boolean) => void): () => void;
 }

package/dist/app/NexaApp.js

@@ -31,6 +31,7 @@ class NexaApp {
         // Transport
         this.httpClient = new HttpClient_1.HttpClient(this.endpoint, () => (this.authService ? this.authService.getToken() : this.token), this.projectId, this.token);
         this.client = this.httpClient.getAxiosInstance();
+        this.wsClient = new SSEClient_1.WebSocketClient(this.projectId, this.endpoint);
         this.sseClient = new SSEClient_1.SSEClient(this.projectId, this.endpoint);
         // Auth & Persistence
         this.authService = new Auth_1.Auth(this.projectId, this.client, this.token);
@@ -77,6 +78,7 @@ class NexaApp {
         try {
             await this.indexedDB.init();
             await this.localStore.loadAll();
+            await this.localStore.garbageCollect(1000); // 1000 docs limit
             await this.mutationQueue.init();
             if (typeof window !== 'undefined') {
                 window.addEventListener('online', () => this._syncOfflineQueue());
@@ -103,7 +105,7 @@ class NexaApp {
         if (this._firestoreListening)
             return;
         this._firestoreListening = true;
-        const unsub1 = this.sseClient.addListener('data_changed', (payload) => {
+        const unsub1 = this.wsClient.addListener('data_changed', (payload) => {
             if (payload && payload.path) {
                 if (payload.action === 'delete') {
                     this._deleteCache(payload.path);
@@ -114,11 +116,14 @@ class NexaApp {
                 this._notifySnapshotCallbacks(payload.path, payload.action === 'delete' ? 'document_deleted' : 'document_written', payload.data);
             }
         });
-        const unsub2 = this.sseClient.addListener('firestore_changed', (payload) => {
+        const unsub2 = this.wsClient.addListener('firestore_changed', (payload) => {
             this._notifySnapshotCallbacks(payload.collectionPath || payload.docPath, 'server_update', payload.data);
         });
         this._firestoreUnsubscribes.push(unsub1, unsub2);
     }
+    _ensureFirestoreWebSocket() {
+        this._ensureFirestoreSSE();
+    }
     _closeFirestoreSSEIfIdle() {
         if (Object.keys(this._snapshotCallbacks).length === 0) {
             this._firestoreUnsubscribes.forEach((unsub) => unsub());
@@ -126,6 +131,9 @@ class NexaApp {
             this._firestoreListening = false;
         }
     }
+    _closeFirestoreWebSocketIfIdle() {
+        this._closeFirestoreSSEIfIdle();
+    }
     _notifySnapshotCallbacks(path, actionType, payload) {
         Object.keys(this._snapshotCallbacks).forEach((cbKey) => {
             const parts = cbKey.split('_');
@@ -180,5 +188,37 @@ class NexaApp {
     async getDownloadURL(path) {
         return this.storage.getDownloadURL(path);
     }
+    isConnected() {
+        return this.wsClient.isConnected;
+    }
+    onConnectionStateChanged(callback) {
+        let lastState = this.isConnected();
+        callback(lastState);
+        // Make sure socket is created and connected if it isn't already
+        this.wsClient.ensureConnected();
+        const unsubOpen = this.wsClient.addListener('open', () => {
+            if (!lastState) {
+                lastState = true;
+                callback(true);
+            }
+        });
+        const unsubClose = this.wsClient.addListener('close', () => {
+            if (lastState) {
+                lastState = false;
+                callback(false);
+            }
+        });
+        const unsubError = this.wsClient.addListener('error', () => {
+            if (lastState) {
+                lastState = false;
+                callback(false);
+            }
+        });
+        return () => {
+            unsubOpen();
+            unsubClose();
+            unsubError();
+        };
+    }
 }
 exports.NexaApp = NexaApp;

package/dist/firestore/writes.js

@@ -11,26 +11,21 @@ const setDoc = async (docRef, data, options) => {
         await db._initPromise;
     const existingData = options?.merge ? db._firestoreCache[docRef.path] || {} : {};
     const finalData = (0, helpers_1.applyDataTransforms)(existingData, data);
-    await db._setCache(docRef.path, finalData);
-    db._broadcastLocalMutation(docRef.path, 'set', finalData);
-    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
     const key = options?.idempotencyKey || (0, helpers_1.generateIdempotencyKey)();
     const jobId = Math.random().toString(36).substring(2, 9);
     const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+    db.markInflight(docRef.path);
+    await db._setCache(docRef.path, finalData);
+    db._broadcastLocalMutation(docRef.path, 'set', finalData);
+    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
     if (!isOnline) {
+        db.unmarkInflight(docRef.path);
         await db._addOfflineJob({
-            id: jobId,
-            type: 'set',
-            path: docRef.path,
-            data,
-            idempotencyKey: key,
-            merge: options?.merge,
-            state: 'pending'
+            id: jobId, type: 'set', path: docRef.path, data, idempotencyKey: key, merge: options?.merge, state: 'pending'
         });
         return { success: true, message: 'Offline: Tersimpan di cache lokal' };
     }
     else {
-        db.markInflight(docRef.path);
         try {
             const res = (await db.client.post(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data, idempotencyKey: key, merge: options?.merge }, { headers: { 'X-Idempotency-Key': key } })).data;
             return res;
@@ -62,13 +57,15 @@ const patchDoc = async (docRef, data, options) => {
         await db._initPromise;
     const existingData = db._firestoreCache[docRef.path] || {};
     const finalData = (0, helpers_1.applyDataTransforms)(existingData, data);
-    await db._setCache(docRef.path, finalData);
-    db._broadcastLocalMutation(docRef.path, 'patch', finalData);
-    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
     const key = options?.idempotencyKey || (0, helpers_1.generateIdempotencyKey)();
     const jobId = Math.random().toString(36).substring(2, 9);
     const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+    db.markInflight(docRef.path);
+    await db._setCache(docRef.path, finalData);
+    db._broadcastLocalMutation(docRef.path, 'patch', finalData);
+    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
     if (!isOnline) {
+        db.unmarkInflight(docRef.path);
         await db._addOfflineJob({
             id: jobId,
             type: 'patch',
@@ -113,13 +110,15 @@ const deleteDoc = async (docRef, options) => {
     const db = docRef.db;
     if (db._initPromise)
         await db._initPromise;
-    await db._deleteCache(docRef.path);
-    db._broadcastLocalMutation(docRef.path, 'delete');
-    db._notifySnapshotCallbacks(docRef.path, 'document_deleted', null);
     const key = options?.idempotencyKey || (0, helpers_1.generateIdempotencyKey)();
     const jobId = Math.random().toString(36).substring(2, 9);
     const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+    db.markInflight(docRef.path);
+    await db._deleteCache(docRef.path);
+    db._broadcastLocalMutation(docRef.path, 'delete');
+    db._notifySnapshotCallbacks(docRef.path, 'document_deleted', null);
     if (!isOnline) {
+        db.unmarkInflight(docRef.path);
         await db._addOfflineJob({
             id: jobId,
             type: 'delete',

package/dist/index.d.ts

@@ -30,6 +30,10 @@ export * from './sync/SyncEngine';
 export * from './sync/ConflictResolver';
 export * from './transport/HttpClient';
 export * from './transport/SSEClient';
+export * from './transport/WebSocketClient';
 export * from './errors/NexaError';
 export * from './types/index';
 export * from './utils/helpers';
+export * from './storage/types';
+export * from './storage/NexaStorageError';
+export { connectStorageEmulator } from './storage/Storage';

package/dist/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectStorageEmulator = void 0;
 // App
 __exportStar(require("./app/initializeApp"), exports);
 __exportStar(require("./app/NexaApp"), exports);
@@ -54,7 +55,12 @@ __exportStar(require("./sync/ConflictResolver"), exports);
 // Transport
 __exportStar(require("./transport/HttpClient"), exports);
 __exportStar(require("./transport/SSEClient"), exports);
+__exportStar(require("./transport/WebSocketClient"), exports);
 // Errors & Types
 __exportStar(require("./errors/NexaError"), exports);
 __exportStar(require("./types/index"), exports);
 __exportStar(require("./utils/helpers"), exports);
+__exportStar(require("./storage/types"), exports);
+__exportStar(require("./storage/NexaStorageError"), exports);
+var Storage_1 = require("./storage/Storage");
+Object.defineProperty(exports, "connectStorageEmulator", { enumerable: true, get: function () { return Storage_1.connectStorageEmulator; } });

package/dist/persistence/LocalStore.d.ts

@@ -9,4 +9,5 @@ export declare class LocalStore {
     get(path: string): Promise<any>;
     delete(path: string): Promise<void>;
     loadAll(): Promise<Record<string, any>>;
+    garbageCollect(maxItems?: number): Promise<void>;
 }

package/dist/persistence/LocalStore.js

@@ -74,5 +74,48 @@ class LocalStore {
             req.onerror = () => reject(req.error);
         });
     }
+    // LRU Cache Garbage Collection (Max size 5000 items)
+    async garbageCollect(maxItems = 5000) {
+        const db = this.indexedDB.getRawDB();
+        if (!db)
+            return;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('offline_cache', 'readwrite');
+            const store = tx.objectStore('offline_cache');
+            const req = store.getAll();
+            req.onsuccess = () => {
+                const items = req.result;
+                if (items.length > maxItems) {
+                    // Sort by timestamp (oldest first)
+                    items.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+                    const itemsToRemove = items.slice(0, items.length - maxItems);
+                    if (itemsToRemove.length === 0) {
+                        return resolve();
+                    }
+                    let removedCount = 0;
+                    itemsToRemove.forEach((item) => {
+                        const delReq = store.delete(item.path);
+                        delReq.onsuccess = () => {
+                            delete this.inMemoryCache[item.path];
+                            removedCount++;
+                            if (removedCount === itemsToRemove.length) {
+                                resolve();
+                            }
+                        };
+                        delReq.onerror = () => {
+                            removedCount++;
+                            if (removedCount === itemsToRemove.length) {
+                                resolve();
+                            }
+                        };
+                    });
+                }
+                else {
+                    resolve();
+                }
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
 }
 exports.LocalStore = LocalStore;

package/dist/storage/Storage.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { UploadMetadata, StorageMetadata } from './types';
+import { UploadMetadata, StorageMetadata, SettableMetadata, ListOptions, ListResult } from './types';
 import { UploadOptions } from '../types/index';
 import { UploadTask } from './UploadTask';
 import { IStorageReference } from './StorageReference';
@@ -8,9 +8,9 @@ export declare class Storage {
     private client;
     emulatorUrl?: string;
     constructor(projectId: string, client: AxiosInstance);
-    ref(path: string): IStorageReference;
+    ref(path?: string): IStorageReference;
     refFromURL(url: string): IStorageReference;
-    createUploadTask(path: string, file: File | Blob, metadata?: UploadMetadata): UploadTask;
+    createUploadTask(path: string, file: Blob, metadata?: UploadMetadata): UploadTask;
     uploadFile(path: string, file: File | Blob, options?: UploadOptions): Promise<{
         url: string;
         path: string;
@@ -21,8 +21,8 @@ export declare class Storage {
         message?: string;
     }>;
     getMetadata(path: string): Promise<StorageMetadata>;
-    updateMetadata(path: string, metadata: Partial<StorageMetadata>): Promise<StorageMetadata>;
-    list(path: string, options?: any): Promise<any>;
+    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

@@ -9,15 +9,16 @@ class Storage {
         this.projectId = projectId;
         this.client = client;
     }
-    ref(path) {
+    ref(path = '') {
         return new StorageReference_1.StorageReferenceImpl(path, this);
     }
     refFromURL(url) {
-        const match = url.match(/storage\/([^?]*)/);
+        // 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');
+        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);
@@ -35,11 +36,24 @@ class Storage {
     async getDownloadURL(path) {
         try {
             const res = await this.client.get(`/api/project/${this.projectId}/storage/url?path=${encodeURIComponent(path)}`);
-            return res.data.url;
+            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);
+                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);
         }
@@ -51,7 +65,7 @@ class Storage {
         }
         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(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);
         }
@@ -62,8 +76,9 @@ class Storage {
             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);
+            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);
         }
     }
@@ -73,19 +88,26 @@ class Storage {
             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);
+            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 res = await this.client.get(`/api/project/${this.projectId}/storage/list?path=${encodeURIComponent(path)}`);
+            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);
+            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);
         }
     }
@@ -95,7 +117,13 @@ 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) => {
@@ -103,7 +131,6 @@ const connectStorageEmulator = (storage, host, port) => {
         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;

package/dist/storage/StorageReference.d.ts

@@ -1,20 +1,26 @@
 import { Storage } from './Storage';
 import { UploadTask } from './UploadTask';
-import { UploadMetadata, StorageMetadata } from './types';
+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;
-    put(file: File | Blob, metadata?: UploadMetadata): UploadTask;
-    putString(data: string, format?: string, metadata?: UploadMetadata): UploadTask;
+    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: Partial<StorageMetadata>): Promise<StorageMetadata>;
+    updateMetadata(metadata: SettableMetadata): Promise<StorageMetadata>;
     delete(): Promise<{
         success: boolean;
         message?: string;
     }>;
-    listAll(): Promise<any>;
-    list(options?: any): Promise<any>;
+    listAll(): Promise<ListResult>;
+    list(options?: ListOptions): Promise<ListResult>;
     upload?: (file: File | Blob, options?: UploadOptions) => Promise<{
         url: string;
         path: string;
@@ -22,28 +28,39 @@ export interface IStorageReference {
 }
 export declare class StorageReferenceImpl implements IStorageReference {
     path: string;
-    private storage;
+    fullPath: string;
+    name: string;
+    bucket: string;
+    storage: Storage;
     constructor(path: string, storage: Storage);
-    put(file: File | Blob, metadata?: UploadMetadata): UploadTask;
-    putString(data: string, format?: string, metadata?: UploadMetadata): UploadTask;
+    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: Partial<StorageMetadata>): Promise<StorageMetadata>;
+    updateMetadata(metadata: SettableMetadata): Promise<StorageMetadata>;
     delete(): Promise<{
         success: boolean;
         message?: string;
     }>;
-    listAll(): Promise<any>;
-    list(options?: any): Promise<any>;
+    listAll(): Promise<ListResult>;
+    list(options?: ListOptions): Promise<ListResult>;
     upload(file: File | Blob, options?: UploadOptions): Promise<{
         url: string;
         path: string;
     }>;
 }
-export declare const ref: (storage: Storage, path: string) => IStorageReference;
-export declare const uploadBytes: (storageRef: IStorageReference, file: File | Blob, metadata?: UploadMetadata) => Promise<any>;
+/**
+ * 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,28 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteObject = exports.getDownloadURL = exports.uploadBytes = exports.ref = 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;
     }
-    put(file, metadata) {
-        return this.storage.createUploadTask(this.path, file, metadata);
+    get root() {
+        return new StorageReferenceImpl('', this.storage);
     }
-    putString(data, format = 'raw', metadata) {
+    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 (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]);
+        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);
+    }
+    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() {
@@ -46,27 +99,79 @@ class StorageReferenceImpl {
     // Legacy for backward compatibility
     async upload(file, options) {
         const task = this.put(file, options);
-        task.options = options; // Inject legacy options
+        task.options = options;
         await task;
         const url = await this.getDownloadURL();
         return { url, path: this.path };
     }
 }
 exports.StorageReferenceImpl = StorageReferenceImpl;
-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, metadata) => {
-    const task = storageRef.put(file, metadata);
-    return await task;
+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, 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) => {
     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) => {
-    return storageRef.delete();
+    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/types.d.ts

@@ -1,4 +1,4 @@
-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 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;
@@ -15,6 +15,7 @@ export interface StorageMetadata {
     contentLanguage?: string;
     contentType?: string;
     customMetadata?: Record<string, string>;
+    downloadTokens?: string;
 }
 export interface UploadMetadata {
     md5Hash?: string;
@@ -25,6 +26,8 @@ export interface UploadMetadata {
     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;
@@ -34,3 +37,19 @@ export interface UploadTaskSnapshot {
     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/transport/SSEClient.d.ts

@@ -1,15 +1,16 @@
+import { WebSocketClient } from './WebSocketClient';
 export declare class SSEClient {
-    private projectId;
-    private sseUrl;
-    private sse;
-    private isListening;
-    private listeners;
+    private wsClient;
     constructor(projectId: string, sseUrl: string);
     addListener(event: string, callback: (data: any) => void): () => void;
+    subscribe(path: string): void;
+    unsubscribe(path: string): void;
     ensureConnected(): void;
     checkCloseConnection(): void;
     hasListeners(): boolean;
     dispatch(event: string, data: any): void;
+    send(event: string, data: any): Promise<any>;
     close(): void;
 }
 export { SSEClient as SSEManager };
+export { WebSocketClient };

package/dist/transport/SSEClient.js

@@ -1,95 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SSEManager = exports.SSEClient = void 0;
+exports.WebSocketClient = exports.SSEManager = exports.SSEClient = void 0;
+const WebSocketClient_1 = require("./WebSocketClient");
+Object.defineProperty(exports, "WebSocketClient", { enumerable: true, get: function () { return WebSocketClient_1.WebSocketClient; } });
 class SSEClient {
     constructor(projectId, sseUrl) {
-        this.sse = null;
-        this.isListening = false;
-        this.listeners = new Map();
-        this.projectId = projectId;
-        this.sseUrl = sseUrl;
+        this.wsClient = new WebSocketClient_1.WebSocketClient(projectId, sseUrl);
     }
     addListener(event, callback) {
-        if (!this.listeners.has(event)) {
-            this.listeners.set(event, new Set());
-        }
-        this.listeners.get(event).add(callback);
-        this.ensureConnected();
-        return () => {
-            const callbacks = this.listeners.get(event);
-            if (callbacks) {
-                callbacks.delete(callback);
-                if (callbacks.size === 0) {
-                    this.listeners.delete(event);
-                }
-            }
-            this.checkCloseConnection();
-        };
+        return this.wsClient.addListener(event, callback);
+    }
+    subscribe(path) {
+        this.wsClient.subscribe(path);
+    }
+    unsubscribe(path) {
+        this.wsClient.unsubscribe(path);
     }
     ensureConnected() {
-        if (this.isListening || typeof window === 'undefined')
-            return;
-        this.isListening = true;
-        this.sse = new EventSource(`${this.sseUrl}/api/firestore/${this.projectId}/sse`);
-        this.sse.onopen = () => {
-            this.dispatch('open', null);
-        };
-        this.sse.onmessage = (event) => {
-            try {
-                const payload = JSON.parse(event.data);
-                this.dispatch(payload.event || 'message', payload.data || payload);
-                this.dispatch('all', payload);
-            }
-            catch (e) {
-                console.error('[SSEClient] Error parsing SSE payload:', e);
-            }
-        };
-        this.sse.onerror = (err) => {
-            this.dispatch('error', err);
-            if (this.sse) {
-                this.sse.close();
-                this.sse = null;
-            }
-            this.isListening = false;
-            if (this.hasListeners()) {
-                setTimeout(() => this.ensureConnected(), 3000);
-            }
-        };
+        this.wsClient.ensureConnected();
     }
     checkCloseConnection() {
-        if (!this.hasListeners() && this.sse) {
-            this.sse.close();
-            this.sse = null;
-            this.isListening = false;
-        }
+        this.wsClient.checkCloseConnection();
     }
     hasListeners() {
-        let count = 0;
-        this.listeners.forEach((set) => {
-            count += set.size;
-        });
-        return count > 0;
+        return this.wsClient.hasListeners();
     }
     dispatch(event, data) {
-        const callbacks = this.listeners.get(event);
-        if (callbacks) {
-            callbacks.forEach((cb) => {
-                try {
-                    cb(data);
-                }
-                catch (e) {
-                    console.error(`[SSEClient] Error in listener for event ${event}:`, e);
-                }
-            });
-        }
+        this.wsClient.dispatch(event, data);
+    }
+    send(event, data) {
+        return this.wsClient.send(event, data);
     }
     close() {
-        if (this.sse) {
-            this.sse.close();
-            this.sse = null;
-        }
-        this.isListening = false;
-        this.listeners.clear();
+        this.wsClient.close();
     }
 }
 exports.SSEClient = SSEClient;

package/dist/transport/WebSocketClient.d.ts

@@ -0,0 +1,24 @@
+export declare class WebSocketClient {
+    private projectId;
+    private serverUrl;
+    private socket;
+    isConnected: boolean;
+    private listeners;
+    private subscribedPaths;
+    private broadcastChannel;
+    private isLeader;
+    private hasInitialized;
+    constructor(projectId: string, serverUrl: string);
+    private handleBroadcastMessage;
+    addListener(event: string, callback: (data: any) => void): () => void;
+    subscribe(path: string): void;
+    unsubscribe(path: string): void;
+    private broadcastToFollowers;
+    ensureConnected(): void;
+    private startSocketConnection;
+    send(event: string, data: any): Promise<any>;
+    checkCloseConnection(): void;
+    hasListeners(): boolean;
+    dispatch(event: string, data: any): void;
+    close(): void;
+}

package/dist/transport/WebSocketClient.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const socket_io_client_1 = require("socket.io-client");
+class WebSocketClient {
+    constructor(projectId, serverUrl) {
+        this.socket = null;
+        this.isConnected = false;
+        this.listeners = new Map();
+        this.subscribedPaths = new Set();
+        // Cross-tab sync properties
+        this.broadcastChannel = null;
+        this.isLeader = false;
+        this.hasInitialized = false;
+        this.projectId = projectId;
+        this.serverUrl = serverUrl;
+        if (typeof window !== 'undefined' && 'BroadcastChannel' in window) {
+            this.broadcastChannel = new BroadcastChannel(`nexabase_ws_${projectId}`);
+            this.broadcastChannel.onmessage = this.handleBroadcastMessage.bind(this);
+        }
+    }
+    handleBroadcastMessage(event) {
+        const { type, payload } = event.data;
+        if (this.isLeader) {
+            if (type === 'follower_subscribe') {
+                this.socket?.emit('subscribe', this.projectId, payload.path);
+            }
+            else if (type === 'follower_unsubscribe') {
+                this.socket?.emit('unsubscribe', this.projectId, payload.path);
+            }
+            else if (type === 'follower_sync_request') {
+                this.broadcastChannel?.postMessage({ type: 'leader_state', payload: { isConnected: this.isConnected } });
+            }
+        }
+        else {
+            if (type === 'leader_event') {
+                const { event: socketEvent, data } = payload;
+                if (socketEvent === 'connect') {
+                    this.isConnected = true;
+                    this.dispatch('open', data);
+                }
+                else if (socketEvent === 'disconnect') {
+                    this.isConnected = false;
+                    this.dispatch('close', data);
+                }
+                else {
+                    this.dispatch(socketEvent, data);
+                    if (socketEvent === 'data_changed' || socketEvent === 'firestore_changed') {
+                        this.dispatch('message', data);
+                        this.dispatch('all', data);
+                    }
+                }
+            }
+            else if (type === 'leader_state') {
+                this.isConnected = payload.isConnected;
+                if (this.isConnected) {
+                    this.dispatch('open', {});
+                }
+            }
+        }
+    }
+    addListener(event, callback) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(callback);
+        this.ensureConnected();
+        return () => {
+            const callbacks = this.listeners.get(event);
+            if (callbacks) {
+                callbacks.delete(callback);
+                if (callbacks.size === 0) {
+                    this.listeners.delete(event);
+                }
+            }
+            this.checkCloseConnection();
+        };
+    }
+    subscribe(path) {
+        const cleanPath = (path || '').replace(/^\/+|\/+$/g, '');
+        this.subscribedPaths.add(cleanPath);
+        if (this.isLeader && this.socket && this.isConnected) {
+            this.socket.emit('subscribe', this.projectId, cleanPath);
+        }
+        else if (!this.isLeader && this.broadcastChannel) {
+            this.broadcastChannel.postMessage({ type: 'follower_subscribe', payload: { path: cleanPath } });
+        }
+    }
+    unsubscribe(path) {
+        const cleanPath = (path || '').replace(/^\/+|\/+$/g, '');
+        this.subscribedPaths.delete(cleanPath);
+        if (this.isLeader && this.socket && this.isConnected) {
+            this.socket.emit('unsubscribe', this.projectId, cleanPath);
+        }
+        else if (!this.isLeader && this.broadcastChannel) {
+            this.broadcastChannel.postMessage({ type: 'follower_unsubscribe', payload: { path: cleanPath } });
+        }
+    }
+    broadcastToFollowers(event, data) {
+        if (this.isLeader && this.broadcastChannel) {
+            this.broadcastChannel.postMessage({ type: 'leader_event', payload: { event, data } });
+        }
+    }
+    ensureConnected() {
+        if (this.hasInitialized || typeof window === 'undefined')
+            return;
+        this.hasInitialized = true;
+        if (navigator.locks) {
+            navigator.locks.request(`nexabase_ws_leader_${this.projectId}`, { mode: 'exclusive', ifAvailable: false }, async (lock) => {
+                // This promise won't resolve until we explicitly return from it (which we only do on close)
+                return new Promise((resolve) => {
+                    this.isLeader = true;
+                    this.startSocketConnection();
+                    // If we are closed intentionally, resolve the lock
+                    const originalClose = this.close.bind(this);
+                    this.close = () => {
+                        originalClose();
+                        resolve();
+                    };
+                });
+            }).catch(() => {
+                // We are a follower
+                this.isLeader = false;
+                this.broadcastChannel?.postMessage({ type: 'follower_sync_request' });
+            });
+        }
+        else {
+            // Fallback if no Web Locks API
+            this.isLeader = true;
+            this.startSocketConnection();
+        }
+    }
+    startSocketConnection() {
+        this.socket = (0, socket_io_client_1.io)(this.serverUrl, {
+            transports: ['websocket', 'polling'],
+            autoConnect: true,
+            reconnection: true,
+            reconnectionDelay: 1000,
+        });
+        this.socket.on('connect', () => {
+            this.isConnected = true;
+            this.dispatch('open', { socketId: this.socket?.id });
+            this.broadcastToFollowers('connect', { socketId: this.socket?.id });
+            // Always join project room
+            this.socket?.emit('subscribe', this.projectId, '');
+            // Resubscribe to all paths
+            this.subscribedPaths.forEach((path) => {
+                this.socket?.emit('subscribe', this.projectId, path);
+            });
+        });
+        this.socket.on('data_changed', (payload) => {
+            this.dispatch('data_changed', payload);
+            this.dispatch('message', payload);
+            this.dispatch('all', payload);
+            this.broadcastToFollowers('data_changed', payload);
+        });
+        this.socket.on('firestore_changed', (payload) => {
+            this.dispatch('firestore_changed', payload);
+            this.dispatch('message', payload);
+            this.dispatch('all', payload);
+            this.broadcastToFollowers('firestore_changed', payload);
+        });
+        this.socket.on('activity_logged', (payload) => {
+            this.dispatch('activity_logged', payload);
+            this.broadcastToFollowers('activity_logged', payload);
+        });
+        this.socket.on('stats_update', (payload) => {
+            this.dispatch('stats_update', payload);
+            this.broadcastToFollowers('stats_update', payload);
+        });
+        this.socket.on('connect_error', (err) => {
+            this.dispatch('error', err);
+            this.broadcastToFollowers('connect_error', err);
+        });
+        this.socket.on('disconnect', (reason) => {
+            this.isConnected = false;
+            this.dispatch('close', { reason });
+            this.broadcastToFollowers('disconnect', { reason });
+        });
+    }
+    send(event, data) {
+        return new Promise((resolve, reject) => {
+            this.ensureConnected();
+            if (!this.socket && this.isLeader) {
+                return reject(new Error('WebSocket client unavailable'));
+            }
+            if (!this.isLeader) {
+                // Followers can't send via websocket directly in this design without more plumbing.
+                // We fallback to standard HTTP API for writes anyway.
+                return reject(new Error('Cannot send WebSocket message from follower tab'));
+            }
+            this.socket.emit(event, data, (response) => {
+                if (response && response.error) {
+                    reject(new Error(response.error));
+                }
+                else {
+                    resolve(response);
+                }
+            });
+        });
+    }
+    checkCloseConnection() {
+        if (!this.hasListeners() && this.subscribedPaths.size === 0 && this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+            this.isConnected = false;
+            this.hasInitialized = false;
+        }
+    }
+    hasListeners() {
+        let count = 0;
+        this.listeners.forEach((set) => {
+            count += set.size;
+        });
+        return count > 0;
+    }
+    dispatch(event, data) {
+        const callbacks = this.listeners.get(event);
+        if (callbacks) {
+            callbacks.forEach((cb) => {
+                try {
+                    cb(data);
+                }
+                catch (e) {
+                    console.error(`[WebSocketClient] Error in listener for event ${event}:`, e);
+                }
+            });
+        }
+    }
+    close() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+        this.isConnected = false;
+        this.hasInitialized = false;
+        this.listeners.clear();
+        this.subscribedPaths.clear();
+        if (this.broadcastChannel) {
+            this.broadcastChannel.close();
+            this.broadcastChannel = null;
+        }
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -26,7 +26,8 @@
   "author": "NexaBase Team",
   "license": "MIT",
   "dependencies": {
-    "axios": "^1.7.9"
+    "axios": "^1.7.9",
+    "socket.io-client": "^4.8.3"
   },
   "devDependencies": {
     "typescript": "^5.0.0"