nexabase-console 1.1.5 → 2.0.0

package/dist/index.js

@@ -1,1093 +1,59 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.runTransaction = exports.writeBatch = exports.enableOfflinePersistence = exports.enableIndexedDbPersistence = exports.onSnapshot = exports.deleteDoc = exports.updateDoc = exports.patchDoc = exports.setDoc = exports.getDoc = exports.getDocs = exports.getCachedDoc = exports.getCachedDocs = exports.limit = exports.orderBy = exports.where = exports.query = exports.doc = exports.collection = exports.getFirestore = exports.initializeApp = exports.NexaBase = exports.NexaApp = void 0;
-exports.generateIdempotencyKey = generateIdempotencyKey;
-const axios_1 = __importDefault(require("axios"));
-// -----------------------------------------------------------------
-// Idempotency Utility
-// -----------------------------------------------------------------
-function generateIdempotencyKey() {
-    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
-        return crypto.randomUUID();
-    }
-    return `nexa_idemp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}_${Math.floor(Math.random() * 1000000)}`;
-}
-// -----------------------------------------------------------------
-// Main NexaApp SDK Class
-// -----------------------------------------------------------------
-class NexaApp {
-    constructor(config) {
-        this.token = null;
-        this.sse = null;
-        // Internal Firestore and Realtime caches/states
-        this._firestoreCache = {};
-        this._snapshotCallbacks = {};
-        this._sseCallbacks = { data_changed: [], firestore_changed: [] };
-        this._offlineQueueInitialized = false;
-        this._isSyncing = false;
-        this._idb = null;
-        this._firestoreListening = false;
-        this._initPromise = null;
-        // Real-time Engine Utilities (Cross-Tab & Cross-Device)
-        this._broadcastChannel = null;
-        this._reconnectAttempts = 0;
-        this._reconnectTimer = null;
-        this.projectId = config.projectId;
-        this.token = config.apiKey || null;
-        this.enablePersistence = config.enablePersistence !== false;
-        this.cacheStrategy = config.cacheStrategy || 'network-first';
-        if (typeof window !== 'undefined' && window.localStorage) {
-            const savedToken = localStorage.getItem(`nexa_token_${this.projectId}`);
-            if (savedToken) {
-                this.token = savedToken;
-            }
-        }
-        // Auto-detect endpoint
-        let defaultEndpoint = 'https://db.nexabase.id';
-        if (typeof window !== 'undefined' && window.location) {
-            defaultEndpoint = window.location.origin;
-        }
-        this.endpoint = config.endpoint || defaultEndpoint;
-        // Do not set default Content-Type globally to let Axios auto-detect FormData
-        // Include 6000ms timeout for reliable fast failover fallback to local IndexedDB cache when network is slow
-        this.client = axios_1.default.create({
-            baseURL: this.endpoint,
-            timeout: 6000
-        });
-        // Request interceptor to attach bearer/x-api-key token and boundary fix
-        this.client.interceptors.request.use((req) => {
-            if (this.token) {
-                // Send both Authorization Bearer and x-api-key for full server compatibility
-                req.headers.Authorization = `Bearer ${this.token}`;
-                req.headers['x-api-key'] = this.token;
-            }
-            // If data is FormData, remove Content-Type so Axios/Browser can format multipart boundary dynamically
-            if (typeof FormData !== 'undefined' && req.data instanceof FormData) {
-                if (req.headers) {
-                    delete req.headers['Content-Type'];
-                    delete req.headers['content-type'];
-                }
-            }
-            else {
-                // Otherwise default to application/json for non-FormData payload requests
-                if (req.data && req.headers && !req.headers['Content-Type'] && !req.headers['content-type']) {
-                    req.headers['Content-Type'] = 'application/json';
-                }
-            }
-            return req;
-        });
-        // Initialize Cross-Tab Sync via BroadcastChannel
-        this._initCrossTabSync();
-    }
-    // Cross-Tab Engine via BroadcastChannel API
-    _initCrossTabSync() {
-        if (typeof window !== 'undefined' && 'BroadcastChannel' in window && !this._broadcastChannel) {
-            try {
-                this._broadcastChannel = new BroadcastChannel(`nexabase_sync_${this.projectId}`);
-                this._broadcastChannel.onmessage = (event) => {
-                    const { type, docPath, data, action } = event.data || {};
-                    if (type === 'cross_tab_mutation' && docPath) {
-                        if (action === 'set' || action === 'update' || action === 'patch') {
-                            if (action === 'patch' || action === 'update') {
-                                const existing = this._firestoreCache[docPath] || {};
-                                this._firestoreCache[docPath] = { ...existing, ...data };
-                            }
-                            else {
-                                this._firestoreCache[docPath] = data;
-                            }
-                            if (this.enablePersistence && this._idb) {
-                                this._setCache(docPath, this._firestoreCache[docPath]);
-                            }
-                            this._notifySnapshotCallbacks(docPath, 'document_written', this._firestoreCache[docPath]);
-                        }
-                        else if (action === 'delete') {
-                            delete this._firestoreCache[docPath];
-                            if (this.enablePersistence && this._idb) {
-                                this._deleteCache(docPath);
-                            }
-                            this._notifySnapshotCallbacks(docPath, 'document_deleted', null);
-                        }
-                        else if (action === 'bulk_update') {
-                            this._notifySnapshotCallbacks('*', 'bulk_update', null);
-                        }
-                    }
-                };
-            }
-            catch (e) {
-                // BroadcastChannel fallback silently if disabled by security context
-            }
-        }
-    }
-    _broadcastLocalMutation(docPath, action, data) {
-        if (this._broadcastChannel) {
-            try {
-                this._broadcastChannel.postMessage({
-                    type: 'cross_tab_mutation',
-                    docPath,
-                    action,
-                    data,
-                    timestamp: Date.now()
-                });
-            }
-            catch (e) { }
-        }
-    }
-    // Cross-Device Realtime Connection via SSE with Auto-Reconnect & Heartbeat
-    connectRealtime() {
-        if (this.sse)
-            return this.sse;
-        const url = `${this.endpoint}/api/firestore/${this.projectId}/listen`;
-        const listenUrl = this.token ? `${url}?token=${this.token}` : url;
-        try {
-            this.sse = new EventSource(listenUrl);
-            this.sse.onmessage = async (event) => {
-                try {
-                    const payload = JSON.parse(event.data);
-                    if (payload.type === 'connected') {
-                        this._reconnectAttempts = 0; // Reset backoff on stable connection
-                        return;
-                    }
-                    if (payload.type && (payload.type.includes('document_') || payload.type === 'bulk_update')) {
-                        this._sseCallbacks.firestore_changed.forEach((cb) => cb(payload));
-                    }
-                    else {
-                        this._sseCallbacks.data_changed.forEach((cb) => cb(payload));
-                    }
-                }
-                catch (e) {
-                    // Ignore JSON parse errors on ping
-                }
-            };
-            this.sse.onerror = () => {
-                if (this.sse) {
-                    this.sse.close();
-                    this.sse = null;
-                }
-                if (this._reconnectTimer)
-                    clearTimeout(this._reconnectTimer);
-                // Exponential backoff reconnect: 1s, 2s, 4s, ... max 30s
-                this._reconnectAttempts++;
-                const backoffMs = Math.min(1000 * Math.pow(2, this._reconnectAttempts), 30000);
-                this._reconnectTimer = setTimeout(() => {
-                    this.connectRealtime();
-                }, backoffMs);
-            };
-        }
-        catch (e) {
-            // Return dummy EventSource if SSE fails in environment
-        }
-        return this.sse;
-    }
-    _notifySnapshotCallbacks(docPath, eventType, data) {
-        Object.keys(this._snapshotCallbacks).forEach((key) => {
-            const cb = this._snapshotCallbacks[key];
-            if (docPath === '*') {
-                cb({ type: eventType });
-                return;
-            }
-            const parts = key.split('_');
-            const pathKey = parts.slice(2).join('_');
-            if (pathKey === docPath || docPath.startsWith(pathKey + '/')) {
-                cb({ type: eventType, docPath, data });
-            }
-        });
-    }
-    // -----------------------------------------------------------------
-    // Realtime Key-Value Database API
-    // -----------------------------------------------------------------
-    database() {
-        return {
-            ref: (path = '') => {
-                const cleanPath = (path || '').replace(/^\/+|\/+$/g, '');
-                return {
-                    path: cleanPath,
-                    get: async () => {
-                        const response = await this.client.get(`/api/db/${this.projectId}/${cleanPath}`);
-                        return response.data;
-                    },
-                    set: async (data) => {
-                        const payload = data instanceof Map ? Object.fromEntries(data) : data;
-                        const response = await this.client.put(`/api/db/${this.projectId}/${cleanPath}`, payload);
-                        return response.data;
-                    },
-                    update: async (data) => {
-                        const payload = data instanceof Map ? Object.fromEntries(data) : data;
-                        const response = await this.client.patch(`/api/db/${this.projectId}/${cleanPath}`, payload);
-                        return response.data;
-                    },
-                    delete: async () => {
-                        const response = await this.client.put(`/api/db/${this.projectId}/${cleanPath}`, null);
-                        return response.data;
-                    },
-                    remove: async () => {
-                        const response = await this.client.put(`/api/db/${this.projectId}/${cleanPath}`, null);
-                        return response.data;
-                    },
-                    onDataChanged: (callback) => {
-                        this.connectRealtime();
-                        const handler = (payload) => {
-                            const payloadPath = (payload.path || '').replace(/^\/+|\/+$/g, '');
-                            if (payloadPath === cleanPath ||
-                                payloadPath.startsWith(cleanPath + '/') ||
-                                cleanPath === '' ||
-                                cleanPath.startsWith(payloadPath + '/')) {
-                                callback(payload.data);
-                            }
-                        };
-                        this._sseCallbacks.data_changed.push(handler);
-                        return () => {
-                            this._sseCallbacks.data_changed = this._sseCallbacks.data_changed.filter((cb) => cb !== handler);
-                        };
-                    }
-                };
-            }
-        };
-    }
-    // -----------------------------------------------------------------
-    // User Authentication API
-    // -----------------------------------------------------------------
-    auth() {
-        return {
-            signInWithEmailAndPassword: async (email, password) => {
-                const res = await this.client.post(`/api/project/${this.projectId}/auth/login`, { email, password });
-                if (res.data.token) {
-                    this.token = res.data.token;
-                    if (typeof window !== 'undefined' && window.localStorage) {
-                        localStorage.setItem(`nexa_token_${this.projectId}`, res.data.token);
-                        localStorage.setItem(`nexa_user_${this.projectId}`, JSON.stringify(res.data.user));
-                    }
-                }
-                return res.data;
-            },
-            createUserWithEmailAndPassword: async (email, password, name) => {
-                const res = await this.client.post(`/api/project/${this.projectId}/users`, { email, password, name });
-                return res.data;
-            },
-            sendOtp: async (email) => {
-                const res = await this.client.post(`/api/project/${this.projectId}/auth/otp/send`, { email });
-                return res.data;
-            },
-            signInWithOtp: async (email, otp, name) => {
-                const res = await this.client.post(`/api/project/${this.projectId}/auth/otp/login`, { email, otp, name });
-                if (res.data.token) {
-                    this.token = res.data.token;
-                    if (typeof window !== 'undefined' && window.localStorage) {
-                        localStorage.setItem(`nexa_token_${this.projectId}`, res.data.token);
-                        localStorage.setItem(`nexa_user_${this.projectId}`, JSON.stringify(res.data.user));
-                    }
-                }
-                return res.data;
-            },
-            signOut: () => {
-                this.token = null;
-                if (typeof window !== 'undefined' && window.localStorage) {
-                    localStorage.removeItem(`nexa_token_${this.projectId}`);
-                    localStorage.removeItem(`nexa_user_${this.projectId}`);
-                }
-            },
-            getCurrentUser: () => {
-                if (typeof window !== 'undefined' && window.localStorage) {
-                    const userStr = localStorage.getItem(`nexa_user_${this.projectId}`);
-                    return userStr ? JSON.parse(userStr) : null;
-                }
-                return null;
-            }
-        };
-    }
-    // -----------------------------------------------------------------
-    // Blob File Storage API
-    // -----------------------------------------------------------------
-    storage() {
-        return {
-            ref: (path = '') => {
-                const name = path.substring(path.lastIndexOf('/') + 1) || path;
-                return {
-                    name,
-                    fullPath: path,
-                    put: async (file, options, onProgress) => {
-                        let actualOptions = {};
-                        let actualOnProgress = onProgress;
-                        if (typeof options === 'function') {
-                            actualOnProgress = options;
-                        }
-                        else if (options && typeof options === 'object') {
-                            actualOptions = options;
-                        }
-                        const formData = new FormData();
-                        formData.append('file', file);
-                        if (actualOptions.contextType) {
-                            formData.append('contextType', actualOptions.contextType);
-                        }
-                        if (actualOptions.contextId) {
-                            formData.append('contextId', actualOptions.contextId);
-                        }
-                        if (actualOptions.fileId) {
-                            formData.append('fileId', actualOptions.fileId);
-                        }
-                        const response = await this.client.post(`/api/project/${this.projectId}/storage/upload`, formData, {
-                            onUploadProgress: (progressEvent) => {
-                                if (actualOnProgress && progressEvent.total) {
-                                    const percent = Math.round((progressEvent.loaded * 100) / progressEvent.total);
-                                    actualOnProgress(percent);
-                                }
-                            }
-                        });
-                        return {
-                            url: response.data.url,
-                            success: true,
-                            fileId: response.data.fileId,
-                            proxyViewUrl: response.data.proxyViewUrl,
-                            proxyDownloadUrl: response.data.proxyDownloadUrl,
-                            metadata: response.data.metadata
-                        };
-                    },
-                    delete: async () => {
-                        const response = await this.client.delete(`/api/project/${this.projectId}/storage/${encodeURIComponent(name)}`);
-                        return response.data;
-                    }
-                };
-            },
-            refFromURL: (url) => {
-                const cleanUrl = url.split('?')[0];
-                const filename = decodeURIComponent(cleanUrl.substring(cleanUrl.lastIndexOf('/') + 1));
-                return this.storage().ref(filename);
-            }
-        };
-    }
-    // -----------------------------------------------------------------
-    // Offline Synchronization & Local IndexedDB Cache Engine
-    // -----------------------------------------------------------------
-    async _initFirestoreState() {
-        if (!this.enablePersistence)
-            return; // Respect enablePersistence ON / OFF option
-        if (this._offlineQueueInitialized)
-            return;
-        this._offlineQueueInitialized = true;
-        this._isSyncing = false;
-        if (typeof window === 'undefined' || !window.indexedDB) {
-            return;
-        }
-        const dbName = `nexa_idb_${this.projectId}`;
-        try {
-            this._idb = await new Promise((resolve, reject) => {
-                const req = indexedDB.open(dbName, 1);
-                req.onupgradeneeded = (e) => {
-                    const db = e.target.result;
-                    if (!db.objectStoreNames.contains('offline_queue')) {
-                        db.createObjectStore('offline_queue', { keyPath: 'id' });
-                    }
-                    if (!db.objectStoreNames.contains('offline_cache')) {
-                        db.createObjectStore('offline_cache', { keyPath: 'path' });
-                    }
-                };
-                req.onsuccess = () => resolve(req.result);
-                req.onerror = () => reject(req.error);
-            });
-            await this._loadCache();
-            if (typeof window !== 'undefined') {
-                window.addEventListener('online', () => this._syncOfflineQueue());
-                setTimeout(() => this._syncOfflineQueue(), 1000);
-                // Robust automatic heartbeat polling every 10 seconds to sync any pending queue jobs
-                setInterval(() => {
-                    if (typeof navigator !== 'undefined' && navigator.onLine) {
-                        this._syncOfflineQueue();
-                    }
-                }, 10000);
-            }
-        }
-        catch (err) {
-            console.warn('[NexaBase SDK] IndexedDB persistence unavailable, falling back to memory cache.');
-        }
-    }
-    async _getOfflineQueue() {
-        if (!this._idb || !this.enablePersistence)
-            return [];
-        return new Promise((resolve, reject) => {
-            const tx = this._idb.transaction('offline_queue', 'readonly');
-            const store = tx.objectStore('offline_queue');
-            const req = store.getAll();
-            req.onsuccess = () => resolve(req.result);
-            req.onerror = () => reject(req.error);
-        });
-    }
-    async _saveOfflineQueue(queue) {
-        if (!this._idb || !this.enablePersistence)
-            return;
-        return new Promise((resolve, reject) => {
-            const tx = this._idb.transaction('offline_queue', 'readwrite');
-            const store = tx.objectStore('offline_queue');
-            store.clear();
-            queue.forEach((item) => store.put(item));
-            tx.oncomplete = () => resolve();
-            tx.onerror = () => reject(tx.error);
-        });
-    }
-    async _addOfflineJob(job) {
-        if (!this._idb || !this.enablePersistence)
-            return;
-        return new Promise((resolve, reject) => {
-            const tx = this._idb.transaction('offline_queue', 'readwrite');
-            const store = tx.objectStore('offline_queue');
-            store.put(job);
-            tx.oncomplete = () => {
-                resolve();
-                if (typeof navigator !== 'undefined' && navigator.onLine) {
-                    this._syncOfflineQueue();
-                }
-            };
-            tx.onerror = () => reject(tx.error);
-        });
-    }
-    async _setCache(path, data) {
-        this._firestoreCache[path] = data;
-        if (!this._idb || !this.enablePersistence)
-            return;
-        return new Promise((resolve, reject) => {
-            const tx = this._idb.transaction('offline_cache', 'readwrite');
-            const store = tx.objectStore('offline_cache');
-            store.put({ path, data });
-            tx.oncomplete = () => resolve();
-            tx.onerror = () => reject(tx.error);
-        });
-    }
-    async _deleteCache(path) {
-        delete this._firestoreCache[path];
-        if (!this._idb || !this.enablePersistence)
-            return;
-        return new Promise((resolve, reject) => {
-            const tx = this._idb.transaction('offline_cache', 'readwrite');
-            const store = tx.objectStore('offline_cache');
-            store.delete(path);
-            tx.oncomplete = () => resolve();
-            tx.onerror = () => reject(tx.error);
-        });
-    }
-    async _loadCache() {
-        if (!this._idb || !this.enablePersistence)
-            return;
-        return new Promise((resolve, reject) => {
-            const tx = this._idb.transaction('offline_cache', 'readonly');
-            const store = tx.objectStore('offline_cache');
-            const req = store.getAll();
-            req.onsuccess = () => {
-                req.result.forEach((item) => {
-                    this._firestoreCache[item.path] = item.data;
-                });
-                resolve();
-            };
-            req.onerror = () => reject(req.error);
-        });
-    }
-    // Outbox Pattern Offline Queue Flush with Idempotency Key
-    async _syncOfflineQueue() {
-        if (this._isSyncing || !this.enablePersistence)
-            return;
-        this._isSyncing = true;
-        const queue = await this._getOfflineQueue();
-        if (queue.length === 0) {
-            this._isSyncing = false;
-            return;
-        }
-        for (const job of [...queue]) {
-            try {
-                const headers = job.idempotencyKey ? { 'X-Idempotency-Key': job.idempotencyKey } : {};
-                if (job.type === 'set') {
-                    await this.client.post(`/api/firestore/${this.projectId}/document`, { docPath: job.path, data: job.data, idempotencyKey: job.idempotencyKey }, { headers });
-                }
-                else if (job.type === 'update' || job.type === 'patch') {
-                    await this.client.patch(`/api/firestore/${this.projectId}/document`, { docPath: job.path, data: job.data, idempotencyKey: job.idempotencyKey }, { headers });
-                }
-                else if (job.type === 'delete') {
-                    await this.client.delete(`/api/firestore/${this.projectId}/document?docPath=${encodeURIComponent(job.path)}`, { headers });
-                }
-                const currentQueue = await this._getOfflineQueue();
-                await this._saveOfflineQueue(currentQueue.filter((q) => q.id !== job.id));
-            }
-            catch (err) {
-                // Discard invalid/unauthorized client-side failures (4xx) to prevent clogging the queue
-                if (err && err.response && err.response.status >= 400 && err.response.status < 500) {
-                    console.error(`[NexaBase SDK] Discarding invalid offline job (${job.type} on ${job.path}):`, err.response.data);
-                    const currentQueue = await this._getOfflineQueue();
-                    await this._saveOfflineQueue(currentQueue.filter((q) => q.id !== job.id));
-                    continue; // Move on to next job
-                }
-                break; // Stop syncing on transient network exceptions or server 5xx errors to retry later
-            }
-        }
-        this._isSyncing = false;
-        this._notifySnapshotCallbacks('*', 'bulk_update', null);
-    }
-    _ensureFirestoreSSE() {
-        this.connectRealtime();
-        if (this._firestoreListening)
-            return;
-        this._firestoreListening = true;
-        this._sseCallbacks.firestore_changed.push(async (change) => {
-            if (change.type === 'bulk_update') {
-                this._notifySnapshotCallbacks('*', 'bulk_update', null);
-                return;
-            }
-            if (change.type === 'document_written') {
-                await this._setCache(change.docPath, change.data);
-            }
-            else if (change.type === 'document_deleted') {
-                await this._deleteCache(change.docPath);
-            }
-            this._notifySnapshotCallbacks(change.docPath, change.type, change.data);
-        });
-    }
-}
-exports.NexaApp = NexaApp;
-// -----------------------------------------------------------------
-// Static NexaBase Initialization Helper
-// -----------------------------------------------------------------
-exports.NexaBase = {
-    init: (config) => {
-        const app = new NexaApp(config);
-        if (app.enablePersistence) {
-            app._initPromise = app._initFirestoreState();
-        }
-        return app;
-    },
-    initializeApp: (config) => {
-        return exports.NexaBase.init(config);
-    }
-};
-// -----------------------------------------------------------------
-// Modular Firestore-like APIs (Firebase Modular pattern)
-// -----------------------------------------------------------------
-const initializeApp = (config) => {
-    return exports.NexaBase.init(config);
-};
-exports.initializeApp = initializeApp;
-const getFirestore = (app) => {
-    if (app.enablePersistence) {
-        app._initPromise = app._initFirestoreState();
-    }
-    return app;
-};
-exports.getFirestore = getFirestore;
-const collection = (db, collectionPath) => {
-    return { type: 'collection', path: collectionPath, db };
-};
-exports.collection = collection;
-const doc = (dbOrCollection, ...pathSegments) => {
-    let docRef;
-    if ('type' in dbOrCollection && dbOrCollection.type === 'collection') {
-        docRef = { type: 'document', path: `${dbOrCollection.path}/${pathSegments.join('/')}`, db: dbOrCollection.db };
-    }
-    else {
-        docRef = { type: 'document', path: pathSegments.join('/'), db: dbOrCollection };
-    }
-    docRef.patch = (data) => (0, exports.patchDoc)(docRef, data);
-    return docRef;
-};
-exports.doc = doc;
-const query = (queryObject, ...queryConstraints) => {
-    const q = {
-        type: 'query',
-        path: queryObject.path,
-        db: queryObject.db,
-        constraints: queryObject.type === 'query' ? [...(queryObject.constraints || [])] : []
-    };
-    q.constraints = [...(q.constraints || []), ...queryConstraints];
-    return q;
-};
-exports.query = query;
-const where = (fieldPath, opStr, value) => {
-    return { type: 'where', fieldPath, opStr, value };
-};
-exports.where = where;
-const orderBy = (fieldPath, directionStr = 'asc') => {
-    return { type: 'orderBy', fieldPath, directionStr };
-};
-exports.orderBy = orderBy;
-const limit = (limitValue) => {
-    return { type: 'limit', limitValue };
-};
-exports.limit = limit;
-// Helper to retrieve docs from local cache
-const getCachedDocs = (queryOrCollection) => {
-    const db = queryOrCollection.db;
-    const collectionPath = queryOrCollection.path;
-    const constraints = 'constraints' in queryOrCollection ? queryOrCollection.constraints || [] : [];
-    const results = [];
-    Object.keys(db._firestoreCache).forEach((p) => {
-        if (p.startsWith(collectionPath + '/')) {
-            const parts = p.split('/');
-            const docId = parts[parts.length - 1];
-            const docRef = (0, exports.doc)(db, `${collectionPath}/${docId}`);
-            results.push({
-                id: docId,
-                ref: docRef,
-                exists: () => true,
-                data: () => db._firestoreCache[p]
-            });
-        }
-    });
-    let filtered = results;
-    for (const c of constraints) {
-        if (c.type === 'where' && c.fieldPath && c.opStr) {
-            filtered = filtered.filter((docItem) => {
-                const val = docItem.data()[c.fieldPath];
-                if (c.opStr === '==')
-                    return val === c.value;
-                if (c.opStr === '>')
-                    return val > c.value;
-                if (c.opStr === '<')
-                    return val < c.value;
-                if (c.opStr === '>=')
-                    return val >= c.value;
-                if (c.opStr === '<=')
-                    return val <= c.value;
-                if (c.opStr === '!=')
-                    return val !== c.value;
-                return true;
-            });
-        }
-    }
-    return {
-        docs: filtered,
-        forEach: (cb) => filtered.forEach(cb),
-        empty: filtered.length === 0,
-        size: filtered.length,
-        docChanges: () => filtered.map((d) => ({ type: 'added', doc: d }))
-    };
-};
-exports.getCachedDocs = getCachedDocs;
-const getCachedDoc = (docRef) => {
-    const db = docRef.db;
-    const segments = docRef.path.split('/');
-    const docId = segments[segments.length - 1];
-    const data = db._firestoreCache[docRef.path];
-    return {
-        id: docId,
-        ref: docRef,
-        exists: () => !!data,
-        data: () => (data || null)
-    };
-};
-exports.getCachedDoc = getCachedDoc;
-const getDocs = async (queryOrCollection) => {
-    const db = queryOrCollection.db;
-    if (db._initPromise)
-        await db._initPromise;
-    const collectionPath = queryOrCollection.path;
-    const constraints = 'constraints' in queryOrCollection ? queryOrCollection.constraints || [] : [];
-    // If cache-first strategy, try loading from local cache first
-    if (db.cacheStrategy === 'cache-first') {
-        const cached = (0, exports.getCachedDocs)(queryOrCollection);
-        if (cached && !cached.empty) {
-            // Background-sync silently to update the local cache
-            db.client.post(`/api/firestore/${db.projectId}/query`, {
-                collectionPath,
-                constraints
-            }).then(async (res) => {
-                const docs = res.data.documents || [];
-                for (const d of docs) {
-                    await db._setCache(`${collectionPath}/${d.id}`, d.fields);
-                }
-                db._notifySnapshotCallbacks(collectionPath, 'bulk_update', null);
-            }).catch(() => { });
-            return cached;
-        }
-    }
-    // Network-first (or cache-first with empty cache): Prioritize the remote database
-    try {
-        const res = await db.client.post(`/api/firestore/${db.projectId}/query`, {
-            collectionPath,
-            constraints
-        });
-        const docs = res.data.documents || [];
-        for (const d of docs) {
-            await db._setCache(`${collectionPath}/${d.id}`, d.fields);
-        }
-        const docsArray = docs.map((d) => {
-            const docRef = (0, exports.doc)(db, `${collectionPath}/${d.id}`);
-            return {
-                id: d.id,
-                ref: docRef,
-                exists: () => true,
-                data: () => d.fields
-            };
-        });
-        return {
-            docs: docsArray,
-            forEach: (cb) => docsArray.forEach(cb),
-            empty: docsArray.length === 0,
-            size: docsArray.length,
-            docChanges: () => docsArray.map((d) => ({ type: 'added', doc: d }))
-        };
-    }
-    catch (err) {
-        // If it's a definitive authorization or validation 4xx error, propagate it
-        if (err && err.response && err.response.status < 500) {
-            throw err;
-        }
-        // Failover: Smoothly fallback to the IndexedDB local cache on network/5xx exceptions
-        return (0, exports.getCachedDocs)(queryOrCollection);
-    }
-};
-exports.getDocs = getDocs;
-const getDoc = async (docRef) => {
-    const db = docRef.db;
-    if (db._initPromise)
-        await db._initPromise;
-    const segments = docRef.path.split('/');
-    const docId = segments[segments.length - 1];
-    // If cache-first strategy, try loading from local cache first
-    if (db.cacheStrategy === 'cache-first') {
-        const cached = (0, exports.getCachedDoc)(docRef);
-        if (cached && cached.exists()) {
-            // Background-sync silently to update the local cache
-            db.client.get(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`)
-                .then(async (res) => {
-                const data = res.data.data;
-                await db._setCache(docRef.path, data);
-                db._notifySnapshotCallbacks(docRef.path, 'document_written', data);
-            }).catch(() => { });
-            return cached;
-        }
-    }
-    // Network-first (or cache-first with empty cache): Prioritize the remote database
-    try {
-        const res = await db.client.get(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`);
-        const data = res.data.data;
-        await db._setCache(docRef.path, data);
-        return {
-            id: docId,
-            ref: docRef,
-            exists: () => !!data,
-            data: () => data
-        };
-    }
-    catch (err) {
-        // If it's a definitive authorization or validation 4xx error, propagate it
-        if (err && err.response && err.response.status < 500) {
-            throw err;
-        }
-        // Failover: Smoothly fallback to the IndexedDB local cache on network/5xx exceptions
-        return (0, exports.getCachedDoc)(docRef);
-    }
-};
-exports.getDoc = getDoc;
-// -----------------------------------------------------------------
-// Atomic Document Mutation APIs with Idempotency & Partial Patching
-// -----------------------------------------------------------------
-const setDoc = async (docRef, data, options) => {
-    const db = docRef.db;
-    if (db._initPromise)
-        await db._initPromise;
-    await db._setCache(docRef.path, data);
-    // Broadcast cross-tab and notify snapshot listeners
-    db._broadcastLocalMutation(docRef.path, 'set', data);
-    db._notifySnapshotCallbacks(docRef.path, 'document_written', data);
-    const key = options?.idempotencyKey || generateIdempotencyKey();
-    const jobId = Math.random().toString(36).substring(2, 9);
-    const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
-    if (!isOnline) {
-        await db._addOfflineJob({ id: jobId, type: 'set', path: docRef.path, data, idempotencyKey: key });
-        return { success: true, message: 'Offline: Tersimpan di cache lokal' };
-    }
-    else {
-        try {
-            return (await db.client.post(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data, idempotencyKey: key }, { headers: { 'X-Idempotency-Key': key } })).data;
-        }
-        catch (error) {
-            await db._addOfflineJob({ id: jobId, type: 'set', path: docRef.path, data, idempotencyKey: key });
-            return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline' };
-        }
-    }
-};
-exports.setDoc = setDoc;
-// Partial Update (UpdateDoc) & Atomic Patch (PatchDoc)
-const patchDoc = async (docRef, data, options) => {
-    const db = docRef.db;
-    if (db._initPromise)
-        await db._initPromise;
-    const existingData = db._firestoreCache[docRef.path] || {};
-    const updatedData = { ...existingData, ...data };
-    await db._setCache(docRef.path, updatedData);
-    db._broadcastLocalMutation(docRef.path, 'patch', data);
-    db._notifySnapshotCallbacks(docRef.path, 'document_written', updatedData);
-    const key = options?.idempotencyKey || generateIdempotencyKey();
-    const jobId = Math.random().toString(36).substring(2, 9);
-    const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
-    if (!isOnline) {
-        await db._addOfflineJob({ id: jobId, type: 'patch', path: docRef.path, data, idempotencyKey: key });
-        return { success: true, message: 'Offline: Tersimpan di cache lokal' };
-    }
-    else {
-        try {
-            return (await db.client.patch(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data, idempotencyKey: key }, { headers: { 'X-Idempotency-Key': key } })).data;
-        }
-        catch (error) {
-            await db._addOfflineJob({ id: jobId, type: 'patch', path: docRef.path, data, idempotencyKey: key });
-            return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline' };
-        }
-    }
-};
-exports.patchDoc = patchDoc;
-const updateDoc = async (docRef, data, options) => {
-    return (0, exports.patchDoc)(docRef, data, options);
-};
-exports.updateDoc = updateDoc;
-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 || generateIdempotencyKey();
-    const jobId = Math.random().toString(36).substring(2, 9);
-    const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
-    if (!isOnline) {
-        await db._addOfflineJob({ id: jobId, type: 'delete', path: docRef.path, idempotencyKey: key });
-        return { success: true };
-    }
-    else {
-        try {
-            return (await db.client.delete(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`, { headers: { 'X-Idempotency-Key': key } })).data;
-        }
-        catch (error) {
-            await db._addOfflineJob({ id: jobId, type: 'delete', path: docRef.path, idempotencyKey: key });
-            return { success: true };
-        }
-    }
-};
-exports.deleteDoc = deleteDoc;
-const onSnapshot = (ref, callback) => {
-    const db = ref.db;
-    const initSnapshot = async () => {
-        if (db._initPromise)
-            await db._initPromise;
-        db._ensureFirestoreSSE();
-        const pathKey = ref.path;
-        // Fast cache emit
-        if (ref.type === 'collection' || ref.type === 'query') {
-            const cached = (0, exports.getCachedDocs)(ref);
-            if (cached && cached.docs.length > 0) {
-                callback(cached);
-            }
-        }
-        else {
-            const cached = (0, exports.getCachedDoc)(ref);
-            if (cached && cached.exists()) {
-                callback(cached);
-            }
-        }
-        let isInitial = true;
-        let debounceTimer = null;
-        const triggerCallback = () => {
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-            debounceTimer = setTimeout(async () => {
-                if (ref.type === 'collection' || ref.type === 'query') {
-                    if (isInitial) {
-                        isInitial = false;
-                        callback((0, exports.getCachedDocs)(ref));
-                        try {
-                            const docs = await (0, exports.getDocs)(ref);
-                            callback(docs);
-                        }
-                        catch (e) { }
-                    }
-                    else {
-                        // Real-time updates: emit instantly and synchronously from cache.
-                        // Eliminates redundant HTTP requests and rendering lag/flicker!
-                        callback((0, exports.getCachedDocs)(ref));
-                    }
-                }
-                else {
-                    if (isInitial) {
-                        isInitial = false;
-                        callback((0, exports.getCachedDoc)(ref));
-                        try {
-                            const docData = await (0, exports.getDoc)(ref);
-                            callback(docData);
-                        }
-                        catch (e) { }
-                    }
-                    else {
-                        callback((0, exports.getCachedDoc)(ref));
-                    }
-                }
-            }, 50); // Debounce to batch rapid updates
-        };
-        triggerCallback();
-        const listenerId = Math.random().toString(36).substring(2, 9);
-        db._snapshotCallbacks[`${ref.type}_${listenerId}_${pathKey}`] = triggerCallback;
-        return () => {
-            delete db._snapshotCallbacks[`${ref.type}_${listenerId}_${pathKey}`];
-        };
-    };
-    let unsubscribe = () => { };
-    initSnapshot().then((unsub) => {
-        unsubscribe = unsub;
-    });
-    return () => unsubscribe();
-};
-exports.onSnapshot = onSnapshot;
-const enableIndexedDbPersistence = async (db) => {
-    db.enablePersistence = true;
-    if (db._initPromise)
-        await db._initPromise;
-};
-exports.enableIndexedDbPersistence = enableIndexedDbPersistence;
-const enableOfflinePersistence = async (db) => {
-    db.enablePersistence = true;
-    if (db._initPromise)
-        await db._initPromise;
-};
-exports.enableOfflinePersistence = enableOfflinePersistence;
-const writeBatch = (db) => {
-    const operations = [];
-    const batchObj = {
-        set: (docRef, data) => {
-            operations.push({ type: 'set', path: docRef.path, data });
-            return batchObj;
-        },
-        update: (docRef, data) => {
-            operations.push({ type: 'update', path: docRef.path, data });
-            return batchObj;
-        },
-        patch: (docRef, data) => {
-            operations.push({ type: 'update', path: docRef.path, data });
-            return batchObj;
-        },
-        delete: (docRef) => {
-            operations.push({ type: 'delete', path: docRef.path });
-            return batchObj;
-        },
-        commit: async () => {
-            if (db._initPromise)
-                await db._initPromise;
-            if (operations.length === 0)
-                return;
-            const idempotencyKey = generateIdempotencyKey();
-            const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
-            // Update local cache optimistically
-            for (const op of operations) {
-                if (op.type === 'set' || op.type === 'update') {
-                    const newData = { ...db._firestoreCache[op.path], ...op.data };
-                    await db._setCache(op.path, newData);
-                    db._broadcastLocalMutation(op.path, op.type === 'set' ? 'set' : 'patch', op.data);
-                    db._notifySnapshotCallbacks(op.path, 'document_written', db._firestoreCache[op.path]);
-                }
-                else if (op.type === 'delete') {
-                    await db._deleteCache(op.path);
-                    db._broadcastLocalMutation(op.path, 'delete');
-                    db._notifySnapshotCallbacks(op.path, 'document_deleted', null);
-                }
-            }
-            if (!isOnline) {
-                for (const op of operations) {
-                    await db._addOfflineJob({
-                        id: Math.random().toString(36).substring(2, 9),
-                        type: op.type,
-                        path: op.path,
-                        data: op.data,
-                        idempotencyKey
-                    });
-                }
-                return { success: true, message: 'Offline: Batch operations queued in IndexedDB' };
-            }
-            else {
-                try {
-                    return (await db.client.post(`/api/firestore/${db.projectId}/batch`, { operations, idempotencyKey }, { headers: { 'X-Idempotency-Key': idempotencyKey } })).data;
-                }
-                catch (error) {
-                    for (const op of operations) {
-                        await db._addOfflineJob({
-                            id: Math.random().toString(36).substring(2, 9),
-                            type: op.type,
-                            path: op.path,
-                            data: op.data,
-                            idempotencyKey
-                        });
-                    }
-                    return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline' };
-                }
-            }
-        }
-    };
-    return batchObj;
-};
-exports.writeBatch = writeBatch;
-const runTransaction = async (db, updateFunction, options) => {
-    if (db._initPromise)
-        await db._initPromise;
-    const maxAttempts = options?.maxAttempts ?? 5;
-    let attempt = 0;
-    while (true) {
-        attempt++;
-        const reads = [];
-        const operations = [];
-        const idempotencyKey = generateIdempotencyKey();
-        const transaction = {
-            get: async (docRef) => {
-                const segments = docRef.path.split('/');
-                const docId = segments[segments.length - 1];
-                const res = await db.client.get(`/api/firestore/${db.projectId}/documentWithMetadata?docPath=${encodeURIComponent(docRef.path)}`);
-                const { data, updatedAt } = res.data;
-                reads.push({ path: docRef.path, readUpdatedAt: updatedAt });
-                return {
-                    id: docId,
-                    ref: docRef,
-                    exists: () => !!data,
-                    data: () => data
-                };
-            },
-            set: (docRef, data) => {
-                operations.push({ type: 'set', path: docRef.path, data });
-                return transaction;
-            },
-            update: (docRef, data) => {
-                operations.push({ type: 'update', path: docRef.path, data });
-                return transaction;
-            },
-            patch: (docRef, data) => {
-                operations.push({ type: 'update', path: docRef.path, data });
-                return transaction;
-            },
-            delete: (docRef) => {
-                operations.push({ type: 'delete', path: docRef.path });
-                return transaction;
-            }
-        };
-        try {
-            const result = await updateFunction(transaction);
-            if (operations.length > 0 || reads.length > 0) {
-                await db.client.post(`/api/firestore/${db.projectId}/transaction`, { reads, operations, idempotencyKey }, { headers: { 'X-Idempotency-Key': idempotencyKey } });
-            }
-            for (const op of operations) {
-                if (op.type === 'set' || op.type === 'update') {
-                    const newData = { ...db._firestoreCache[op.path], ...op.data };
-                    await db._setCache(op.path, newData);
-                    db._broadcastLocalMutation(op.path, op.type === 'set' ? 'set' : 'patch', op.data);
-                    db._notifySnapshotCallbacks(op.path, 'document_written', db._firestoreCache[op.path]);
-                }
-                else if (op.type === 'delete') {
-                    await db._deleteCache(op.path);
-                    db._broadcastLocalMutation(op.path, 'delete');
-                    db._notifySnapshotCallbacks(op.path, 'document_deleted', null);
-                }
-            }
-            return result;
-        }
-        catch (err) {
-            const isConflict = err && err.response && err.response.status === 409;
-            if (isConflict && attempt < maxAttempts) {
-                console.warn(`[NexaBase Transaction] Retrying due to concurrency conflict (Attempt ${attempt}/${maxAttempts})`);
-                await new Promise((resolve) => setTimeout(resolve, Math.random() * 100 * attempt));
-                continue;
-            }
-            throw err;
-        }
-    }
-};
-exports.runTransaction = runTransaction;
+// App
+__exportStar(require("./app/initializeApp"), exports);
+__exportStar(require("./app/NexaApp"), exports);
+// Auth
+__exportStar(require("./auth/Auth"), exports);
+__exportStar(require("./auth/authTypes"), exports);
+__exportStar(require("./auth/persistence"), exports);
+// Firestore
+__exportStar(require("./firestore/Firestore"), exports);
+__exportStar(require("./firestore/DocumentReference"), exports);
+__exportStar(require("./firestore/CollectionReference"), exports);
+__exportStar(require("./firestore/Query"), exports);
+__exportStar(require("./firestore/Snapshot"), exports);
+__exportStar(require("./firestore/queryConstraints"), exports);
+__exportStar(require("./firestore/writes"), exports);
+__exportStar(require("./firestore/batch"), exports);
+__exportStar(require("./firestore/transaction"), exports);
+__exportStar(require("./firestore/Timestamp"), exports);
+__exportStar(require("./firestore/GeoPoint"), exports);
+__exportStar(require("./firestore/FieldPath"), exports);
+__exportStar(require("./firestore/FieldValue"), exports);
+__exportStar(require("./firestore/SnapshotManager"), exports);
+// Realtime
+__exportStar(require("./realtime/RealtimeDatabase"), exports);
+__exportStar(require("./realtime/RealtimeConnection"), exports);
+// Storage
+__exportStar(require("./storage/Storage"), exports);
+__exportStar(require("./storage/StorageReference"), exports);
+__exportStar(require("./storage/UploadTask"), exports);
+// Persistence
+__exportStar(require("./persistence/IndexedDB"), exports);
+__exportStar(require("./persistence/LocalStore"), exports);
+__exportStar(require("./persistence/MutationQueue"), exports);
+// Sync
+__exportStar(require("./sync/SyncEngine"), exports);
+__exportStar(require("./sync/ConflictResolver"), exports);
+// Transport
+__exportStar(require("./transport/HttpClient"), exports);
+__exportStar(require("./transport/SSEClient"), exports);
+// Errors & Types
+__exportStar(require("./errors/NexaError"), exports);
+__exportStar(require("./types/index"), exports);
+__exportStar(require("./utils/helpers"), exports);