nexabase-console 1.1.4 → 2.0.0

package/dist/persistence/IndexedDB.d.ts

@@ -0,0 +1,8 @@
+export declare class IndexedDB {
+    private dbName;
+    private idb;
+    constructor(dbName: string);
+    init(): Promise<void>;
+    getRawDB(): IDBDatabase | null;
+}
+export { IndexedDB as IndexedDBStore };

package/dist/persistence/IndexedDB.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDBStore = exports.IndexedDB = void 0;
+class IndexedDB {
+    constructor(dbName) {
+        this.idb = null;
+        this.dbName = dbName;
+    }
+    async init() {
+        if (typeof window === 'undefined' || !window.indexedDB)
+            return;
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, 1);
+            request.onupgradeneeded = (e) => {
+                const db = e.target.result;
+                if (!db.objectStoreNames.contains('offline_cache')) {
+                    db.createObjectStore('offline_cache', { keyPath: 'path' });
+                }
+                if (!db.objectStoreNames.contains('offline_queue')) {
+                    db.createObjectStore('offline_queue', { keyPath: 'id' });
+                }
+            };
+            request.onsuccess = (e) => {
+                this.idb = e.target.result;
+                resolve();
+            };
+            request.onerror = (e) => {
+                reject(e.target.error);
+            };
+        });
+    }
+    getRawDB() {
+        return this.idb;
+    }
+}
+exports.IndexedDB = IndexedDB;
+exports.IndexedDBStore = IndexedDB;

package/dist/persistence/LocalStore.d.ts

@@ -0,0 +1,12 @@
+import { IndexedDB } from './IndexedDB';
+export declare class LocalStore {
+    private indexedDB;
+    private inMemoryCache;
+    constructor(indexedDB: IndexedDB);
+    set(path: string, data: any): Promise<void>;
+    getInMemory(path: string): any;
+    getMemoryCache(): Record<string, any>;
+    get(path: string): Promise<any>;
+    delete(path: string): Promise<void>;
+    loadAll(): Promise<Record<string, any>>;
+}

package/dist/persistence/LocalStore.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStore = void 0;
+class LocalStore {
+    constructor(indexedDB) {
+        this.inMemoryCache = {};
+        this.indexedDB = indexedDB;
+    }
+    async set(path, data) {
+        this.inMemoryCache[path] = data;
+        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.put({ path, data, timestamp: Date.now() });
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    getInMemory(path) {
+        return this.inMemoryCache[path] || null;
+    }
+    getMemoryCache() {
+        return this.inMemoryCache;
+    }
+    async get(path) {
+        if (this.inMemoryCache[path])
+            return this.inMemoryCache[path];
+        const db = this.indexedDB.getRawDB();
+        if (!db)
+            return null;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('offline_cache', 'readonly');
+            const store = tx.objectStore('offline_cache');
+            const req = store.get(path);
+            req.onsuccess = () => {
+                const data = req.result ? req.result.data : null;
+                if (data)
+                    this.inMemoryCache[path] = data;
+                resolve(data);
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async delete(path) {
+        delete this.inMemoryCache[path];
+        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.delete(path);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async loadAll() {
+        const db = this.indexedDB.getRawDB();
+        if (!db)
+            return this.inMemoryCache;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('offline_cache', 'readonly');
+            const store = tx.objectStore('offline_cache');
+            const req = store.getAll();
+            req.onsuccess = () => {
+                req.result.forEach((item) => {
+                    this.inMemoryCache[item.path] = item.data;
+                });
+                resolve(this.inMemoryCache);
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+}
+exports.LocalStore = LocalStore;

package/dist/persistence/MutationQueue.d.ts

@@ -0,0 +1,22 @@
+import { AxiosInstance } from 'axios';
+import { OfflineJob } from '../types/index';
+import { IndexedDB } from './IndexedDB';
+export declare class MutationQueue {
+    private projectId;
+    private indexedDB;
+    private client;
+    private inMemoryQueue;
+    private inflightWrites;
+    private isSyncing;
+    constructor(projectId: string, indexedDB: IndexedDB, client: AxiosInstance);
+    init(): Promise<void>;
+    loadQueue(): Promise<OfflineJob[]>;
+    addJob(job: OfflineJob): Promise<void>;
+    saveQueue(queue: OfflineJob[]): Promise<void>;
+    removeJob(jobId: string): Promise<void>;
+    markInflight(path: string): void;
+    unmarkInflight(path: string): void;
+    hasPendingWrites(path: string): boolean;
+    getQueue(): OfflineJob[];
+    syncQueue(): Promise<void>;
+}

package/dist/persistence/MutationQueue.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutationQueue = void 0;
+class MutationQueue {
+    constructor(projectId, indexedDB, client) {
+        this.inMemoryQueue = [];
+        this.inflightWrites = new Set();
+        this.isSyncing = false;
+        this.projectId = projectId;
+        this.indexedDB = indexedDB;
+        this.client = client;
+    }
+    async init() {
+        await this.loadQueue();
+    }
+    async loadQueue() {
+        const db = this.indexedDB.getRawDB();
+        if (!db)
+            return this.inMemoryQueue;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('offline_queue', 'readonly');
+            const store = tx.objectStore('offline_queue');
+            const req = store.getAll();
+            req.onsuccess = () => {
+                this.inMemoryQueue = req.result || [];
+                resolve(this.inMemoryQueue);
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async addJob(job) {
+        job.state = job.state || 'pending';
+        job.timestamp = job.timestamp || Date.now();
+        this.inMemoryQueue.push(job);
+        const db = this.indexedDB.getRawDB();
+        if (!db)
+            return;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('offline_queue', 'readwrite');
+            const store = tx.objectStore('offline_queue');
+            const req = store.put(job);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async saveQueue(queue) {
+        this.inMemoryQueue = queue;
+        const db = this.indexedDB.getRawDB();
+        if (!db)
+            return;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('offline_queue', 'readwrite');
+            const store = tx.objectStore('offline_queue');
+            const clearReq = store.clear();
+            clearReq.onsuccess = () => {
+                if (queue.length === 0) {
+                    resolve();
+                    return;
+                }
+                let added = 0;
+                queue.forEach((item) => {
+                    const req = store.put(item);
+                    req.onsuccess = () => {
+                        added++;
+                        if (added === queue.length)
+                            resolve();
+                    };
+                    req.onerror = () => reject(req.error);
+                });
+            };
+            clearReq.onerror = () => reject(clearReq.error);
+        });
+    }
+    async removeJob(jobId) {
+        const updated = this.inMemoryQueue.filter((j) => j.id !== jobId);
+        await this.saveQueue(updated);
+    }
+    markInflight(path) {
+        this.inflightWrites.add(path);
+    }
+    unmarkInflight(path) {
+        this.inflightWrites.delete(path);
+    }
+    hasPendingWrites(path) {
+        if (this.inflightWrites.has(path))
+            return true;
+        for (const p of this.inflightWrites) {
+            if (p.startsWith(path + '/'))
+                return true;
+        }
+        return this.inMemoryQueue.some((job) => job.state === 'pending' && (job.path === path || job.path.startsWith(path + '/')));
+    }
+    getQueue() {
+        return [...this.inMemoryQueue];
+    }
+    async syncQueue() {
+        if (this.isSyncing || this.inMemoryQueue.length === 0)
+            return;
+        if (typeof navigator !== 'undefined' && !navigator.onLine)
+            return;
+        this.isSyncing = true;
+        const queue = [...this.inMemoryQueue];
+        for (const job of queue) {
+            try {
+                job.state = 'pending';
+                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,
+                        merge: job.merge
+                    }, { headers });
+                }
+                else if (job.type === 'patch' || job.type === 'update') {
+                    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 });
+                }
+                job.state = 'acknowledged';
+                await this.removeJob(job.id);
+            }
+            catch (err) {
+                if (err.response && err.response.status >= 400 && err.response.status < 500) {
+                    job.state = 'rejected';
+                    job.lastError = err.response?.data?.message || err.message;
+                    console.error(`[MutationQueue] Discarding rejected job (${job.type} on ${job.path}):`, err.response.data);
+                    await this.removeJob(job.id);
+                }
+                else {
+                    job.retryCount = (job.retryCount || 0) + 1;
+                    await this.saveQueue(this.inMemoryQueue);
+                    break;
+                }
+            }
+        }
+        this.isSyncing = false;
+    }
+}
+exports.MutationQueue = MutationQueue;

package/dist/realtime/RealtimeConnection.d.ts

@@ -0,0 +1,7 @@
+import { SSEClient } from '../transport/SSEClient';
+export declare class RealtimeConnection {
+    private sseClient;
+    constructor(sseClient: SSEClient);
+    subscribeToPath(path: string, callback: (value: any) => void): () => void;
+    close(): void;
+}

package/dist/realtime/RealtimeConnection.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeConnection = void 0;
+class RealtimeConnection {
+    constructor(sseClient) {
+        this.sseClient = sseClient;
+    }
+    subscribeToPath(path, callback) {
+        return this.sseClient.addListener('data_changed', (payload) => {
+            if (payload && payload.path === path) {
+                callback(payload.value);
+            }
+        });
+    }
+    close() {
+        this.sseClient.close();
+    }
+}
+exports.RealtimeConnection = RealtimeConnection;

package/dist/realtime/RealtimeDatabase.d.ts

@@ -0,0 +1,10 @@
+import { AxiosInstance } from 'axios';
+import { DatabaseReference } from '../types/index';
+import { RealtimeConnection } from './RealtimeConnection';
+export declare class RealtimeDatabase {
+    private projectId;
+    private client;
+    private connection;
+    constructor(projectId: string, client: AxiosInstance, connection: RealtimeConnection);
+    ref(path: string): DatabaseReference;
+}

package/dist/realtime/RealtimeDatabase.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeDatabase = void 0;
+const NexaError_1 = require("../errors/NexaError");
+class RealtimeDatabase {
+    constructor(projectId, client, connection) {
+        this.projectId = projectId;
+        this.client = client;
+        this.connection = connection;
+    }
+    ref(path) {
+        return {
+            path,
+            set: async (value) => {
+                try {
+                    const res = await this.client.post(`/api/project/${this.projectId}/database/set`, { path, value });
+                    return res.data;
+                }
+                catch (err) {
+                    throw (0, NexaError_1.toNexaError)(err);
+                }
+            },
+            get: async () => {
+                try {
+                    const res = await this.client.get(`/api/project/${this.projectId}/database/get?path=${encodeURIComponent(path)}`);
+                    return res.data;
+                }
+                catch (err) {
+                    throw (0, NexaError_1.toNexaError)(err);
+                }
+            },
+            update: async (value) => {
+                try {
+                    const res = await this.client.patch(`/api/project/${this.projectId}/database/update`, { path, value });
+                    return res.data;
+                }
+                catch (err) {
+                    throw (0, NexaError_1.toNexaError)(err);
+                }
+            },
+            remove: async () => {
+                try {
+                    const res = await this.client.delete(`/api/project/${this.projectId}/database/remove?path=${encodeURIComponent(path)}`);
+                    return res.data;
+                }
+                catch (err) {
+                    throw (0, NexaError_1.toNexaError)(err);
+                }
+            },
+            onValue: (callback) => {
+                const removeListener = this.connection.subscribeToPath(path, callback);
+                // Fetch initial state
+                this.client
+                    .get(`/api/project/${this.projectId}/database/get?path=${encodeURIComponent(path)}`)
+                    .then((res) => callback(res.data.value))
+                    .catch(() => { });
+                return removeListener;
+            }
+        };
+    }
+}
+exports.RealtimeDatabase = RealtimeDatabase;

package/dist/storage/Storage.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from 'axios';
+import { UploadOptions } from '../types/index';
+export declare class Storage {
+    private projectId;
+    private client;
+    constructor(projectId: string, client: AxiosInstance);
+    uploadFile(path: string, file: File | Blob, options?: UploadOptions): Promise<{
+        url: string;
+        path: string;
+    }>;
+    getDownloadURL(path: string): Promise<string>;
+}

package/dist/storage/Storage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+const UploadTask_1 = require("./UploadTask");
+const NexaError_1 = require("../errors/NexaError");
+class Storage {
+    constructor(projectId, client) {
+        this.projectId = projectId;
+        this.client = client;
+    }
+    async uploadFile(path, file, options) {
+        try {
+            const uploadTask = new UploadTask_1.UploadTask(path, file, options);
+            const formData = new FormData();
+            formData.append('file', file);
+            formData.append('path', path);
+            const res = await this.client.post(`/api/project/${this.projectId}/storage/upload`, formData, {
+                onUploadProgress: (progressEvent) => {
+                    if (progressEvent.total) {
+                        const percent = Math.round((progressEvent.loaded * 100) / progressEvent.total);
+                        uploadTask.notifyProgress(percent);
+                    }
+                }
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw (0, NexaError_1.toNexaError)(err);
+        }
+    }
+    async getDownloadURL(path) {
+        try {
+            const res = await this.client.get(`/api/project/${this.projectId}/storage/url?path=${encodeURIComponent(path)}`);
+            return res.data.url;
+        }
+        catch (err) {
+            throw (0, NexaError_1.toNexaError)(err);
+        }
+    }
+}
+exports.Storage = Storage;

package/dist/storage/StorageReference.d.ts

@@ -0,0 +1,13 @@
+import { StorageReference as IStorageReference, UploadOptions } from '../types/index';
+import { Storage } from './Storage';
+export declare class StorageReferenceImpl implements IStorageReference {
+    path: string;
+    private storage;
+    constructor(path: string, storage: Storage);
+    upload(file: File | Blob, options?: UploadOptions): Promise<{
+        url: string;
+        path: string;
+    }>;
+    getDownloadURL(): Promise<string>;
+}
+export declare const storageRef: (storage: Storage, path: string) => IStorageReference;

package/dist/storage/StorageReference.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageRef = exports.StorageReferenceImpl = void 0;
+class StorageReferenceImpl {
+    constructor(path, storage) {
+        this.path = path;
+        this.storage = storage;
+    }
+    async upload(file, options) {
+        return this.storage.uploadFile(this.path, file, options);
+    }
+    async getDownloadURL() {
+        return this.storage.getDownloadURL(this.path);
+    }
+}
+exports.StorageReferenceImpl = StorageReferenceImpl;
+const storageRef = (storage, path) => {
+    return new StorageReferenceImpl(path, storage);
+};
+exports.storageRef = storageRef;

package/dist/storage/UploadTask.d.ts

@@ -0,0 +1,10 @@
+import { UploadOptions } from '../types/index';
+export declare class UploadTask {
+    private file;
+    private path;
+    private options?;
+    constructor(path: string, file: File | Blob, options?: UploadOptions);
+    getFile(): File | Blob;
+    getPath(): string;
+    notifyProgress(percent: number): void;
+}

package/dist/storage/UploadTask.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadTask = void 0;
+class UploadTask {
+    constructor(path, file, options) {
+        this.path = path;
+        this.file = file;
+        this.options = options;
+    }
+    getFile() {
+        return this.file;
+    }
+    getPath() {
+        return this.path;
+    }
+    notifyProgress(percent) {
+        if (this.options && this.options.onProgress) {
+            this.options.onProgress(percent);
+        }
+    }
+}
+exports.UploadTask = UploadTask;

package/dist/sync/ConflictResolver.d.ts

@@ -0,0 +1,3 @@
+export declare class ConflictResolver {
+    static resolveWithRetry<T>(operation: () => Promise<T>, maxAttempts?: number): Promise<T>;
+}

package/dist/sync/ConflictResolver.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictResolver = void 0;
+class ConflictResolver {
+    static async resolveWithRetry(operation, maxAttempts = 5) {
+        let attempt = 0;
+        while (true) {
+            attempt++;
+            try {
+                return await operation();
+            }
+            catch (err) {
+                const isConflict = err && err.response && err.response.status === 409;
+                if (isConflict && attempt < maxAttempts) {
+                    console.warn(`[ConflictResolver] Retrying operation due to concurrency conflict (Attempt ${attempt}/${maxAttempts})`);
+                    await new Promise((resolve) => setTimeout(resolve, Math.random() * 100 * attempt));
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+}
+exports.ConflictResolver = ConflictResolver;

package/dist/sync/SyncEngine.d.ts

@@ -0,0 +1,13 @@
+import { MutationQueue } from '../persistence/MutationQueue';
+import { SSEClient } from '../transport/SSEClient';
+export declare class SyncEngine {
+    private projectId;
+    private mutationQueue;
+    private sseClient;
+    private broadcastChannel;
+    constructor(projectId: string, mutationQueue: MutationQueue, sseClient: SSEClient);
+    private initCrossTabSync;
+    broadcastLocalMutation(path: string, action: string, data?: any): void;
+    listenCrossTab(onMutation: (path: string, action: string, data?: any) => void): () => void;
+    syncOfflineMutations(): Promise<void>;
+}

package/dist/sync/SyncEngine.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncEngine = void 0;
+class SyncEngine {
+    constructor(projectId, mutationQueue, sseClient) {
+        this.broadcastChannel = null;
+        this.projectId = projectId;
+        this.mutationQueue = mutationQueue;
+        this.sseClient = sseClient;
+        this.initCrossTabSync();
+    }
+    initCrossTabSync() {
+        if (typeof window !== 'undefined' && 'BroadcastChannel' in window && !this.broadcastChannel) {
+            try {
+                this.broadcastChannel = new BroadcastChannel(`nexabase_tab_sync_${this.projectId}`);
+            }
+            catch (e) {
+                console.warn('[SyncEngine] BroadcastChannel initialization failed:', e);
+            }
+        }
+    }
+    broadcastLocalMutation(path, action, data) {
+        if (this.broadcastChannel) {
+            try {
+                this.broadcastChannel.postMessage({ type: 'LOCAL_MUTATION', path, action, data });
+            }
+            catch (e) { }
+        }
+    }
+    listenCrossTab(onMutation) {
+        if (!this.broadcastChannel)
+            return () => { };
+        const handler = (event) => {
+            if (event.data && event.data.type === 'LOCAL_MUTATION') {
+                onMutation(event.data.path, event.data.action, event.data.data);
+            }
+        };
+        this.broadcastChannel.addEventListener('message', handler);
+        return () => {
+            this.broadcastChannel.removeEventListener('message', handler);
+        };
+    }
+    async syncOfflineMutations() {
+        await this.mutationQueue.syncQueue();
+    }
+}
+exports.SyncEngine = SyncEngine;

package/dist/transport/HttpClient.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+export declare class HttpClient {
+    private client;
+    private getToken;
+    constructor(endpoint: string, getTokenFn: () => string | null);
+    getAxiosInstance(): AxiosInstance;
+    setBaseURL(url: string): void;
+}