nexabase-console 2.0.7 → 2.0.9

package/dist/firestore/writes.js

@@ -2,154 +2,208 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteDoc = exports.updateDoc = exports.patchDoc = exports.setDoc = exports.FieldValue = void 0;
 const helpers_1 = require("../utils/helpers");
-const NexaError_1 = require("../errors/NexaError");
 var FieldValue_1 = require("./FieldValue");
 Object.defineProperty(exports, "FieldValue", { enumerable: true, get: function () { return FieldValue_1.FieldValue; } });
-const setDoc = async (docRef, data, options) => {
+const normalizeError = (error) => {
+    const status = error?.response?.status;
+    let code = error?.code || 'internal';
+    let retryable = false;
+    if (code === 'ERR_NETWORK')
+        code = 'network-error';
+    if (code === 'ECONNABORTED' || code === 'ETIMEDOUT')
+        code = 'timeout';
+    if (code === 'ERR_CANCELED')
+        code = 'aborted';
+    if (status) {
+        if ([408, 425, 429, 500, 502, 503, 504].includes(status))
+            retryable = true;
+    }
+    else if (['network-error', 'timeout', 'unavailable', 'aborted', 'resource-exhausted'].includes(code)) {
+        retryable = true;
+    }
+    if (['invalid-argument', 'permission-denied', 'unauthenticated', 'not-found', 'failed-precondition', 'already-exists'].includes(code)) {
+        retryable = false;
+    }
+    return {
+        code,
+        status,
+        message: error?.message || 'Unknown error',
+        retryable,
+        source: error?.isAxiosError ? 'http' : (error?.source || 'internal')
+    };
+};
+const safelyNotifyMutation = (db, path, action, data, metadata) => {
+    try {
+        db._broadcastLocalMutation(path, action, data, metadata);
+    }
+    catch (e) {
+        console.error('[NexaBase] Listener error:', e);
+    }
+    try {
+        db._notifySnapshotCallbacks(path, action === 'delete' ? 'document_deleted' : 'document_written', data, metadata);
+    }
+    catch (e) {
+        console.error('[NexaBase] Listener error:', e);
+    }
+};
+const executeWriteMutation = async (docRef, action, data, options) => {
+    if (!docRef || !docRef.path || !docRef.db || typeof docRef.path !== 'string' || docRef.path.split('/').length % 2 !== 0) {
+        throw Object.assign(new Error('Invalid DocumentReference'), { code: 'invalid-argument' });
+    }
+    if (action !== 'delete' && (!data || typeof data !== 'object' || Array.isArray(data))) {
+        throw Object.assign(new Error('Data must be a valid plain object'), { code: 'invalid-argument' });
+    }
     const db = docRef.db;
     if (db._initPromise)
         await db._initPromise;
-    const existingData = options?.merge ? db._firestoreCache[docRef.path] || {} : {};
-    const finalData = (0, helpers_1.applyDataTransforms)(existingData, data);
     const key = options?.idempotencyKey || (0, helpers_1.generateIdempotencyKey)();
-    const jobId = Math.random().toString(36).substring(2, 9);
+    const mutationId = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+        ? crypto.randomUUID()
+        : (0, helpers_1.generateIdempotencyKey)();
+    const job = {
+        id: mutationId,
+        type: action,
+        path: docRef.path,
+        data: data,
+        idempotencyKey: key,
+        merge: options?.merge,
+        state: 'pending',
+        timestamp: Date.now(),
+        sequenceNumber: await db.localStore.nextMutationSequence(),
+        leaseOwner: 'foreground',
+        leaseExpiresAt: Date.now() + 30000
+    };
+    if (options?.preconditionExists) {
+        job.precondition = { exists: true };
+    }
+    db.markInflight(docRef.path, mutationId);
+    // Phase 1: Local Commit
+    let localView;
+    try {
+        localView = await db._commitAtomicMutation(docRef.path, action, job);
+    }
+    catch (error) {
+        db.unmarkInflight(docRef.path, mutationId);
+        throw Object.assign(new Error('Local persistence failed'), { code: 'internal', cause: error });
+    }
+    safelyNotifyMutation(db, docRef.path, action, localView.data, {
+        mutationId,
+        source: 'local',
+        state: 'pending',
+        hasPendingWrites: localView.hasPendingWrites
+    });
     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'
-        });
-        return { success: true, message: 'Offline: Tersimpan di cache lokal' };
+        db.unmarkInflight(docRef.path, mutationId);
+        return { status: 'pending', committed: false, writtenLocally: true, mutationId };
     }
-    else {
-        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;
-        }
-        catch (error) {
-            if (error && error.response && error.response.status >= 400 && error.response.status < 500) {
-                throw (0, NexaError_1.toNexaError)(error);
-            }
-            await db._addOfflineJob({
-                id: jobId,
-                type: 'set',
-                path: docRef.path,
+    // Phase 2: Network Send
+    let res;
+    let networkError = null;
+    try {
+        if (db.wsClient && db.wsClient.isConnected) {
+            res = await db.wsClient.send('firestore_write', {
+                action: action === 'patch' ? 'update' : action,
+                docPath: docRef.path,
+                projectId: db.projectId,
                 data,
-                idempotencyKey: key,
                 merge: options?.merge,
-                state: 'pending'
+                idempotencyKey: key,
+                preconditionExists: options?.preconditionExists
             });
-            return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline' };
         }
-        finally {
-            db.unmarkInflight(docRef.path);
+        else {
+            const headers = { 'X-Idempotency-Key': key };
+            if (action === 'set') {
+                res = (await db.client.post(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data, idempotencyKey: key, merge: options?.merge }, { headers })).data;
+            }
+            else if (action === 'patch') {
+                res = (await db.client.patch(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data, idempotencyKey: key, preconditionExists: options?.preconditionExists }, { headers })).data;
+            }
+            else {
+                res = (await db.client.delete(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`, { headers })).data;
+            }
         }
     }
-};
-exports.setDoc = setDoc;
-const patchDoc = async (docRef, data, options) => {
-    const db = docRef.db;
-    if (db._initPromise)
-        await db._initPromise;
-    const existingData = db._firestoreCache[docRef.path] || {};
-    const finalData = (0, helpers_1.applyDataTransforms)(existingData, data);
-    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',
-            path: docRef.path,
-            data,
-            idempotencyKey: key,
-            state: 'pending'
-        });
-        return { success: true, message: 'Offline: Tersimpan di cache lokal' };
+    catch (err) {
+        networkError = err;
     }
-    else {
-        db.markInflight(docRef.path);
-        try {
-            const res = (await db.client.patch(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data, idempotencyKey: key }, { headers: { 'X-Idempotency-Key': key } })).data;
-            return res;
+    // Phase 3: Server Error Handling
+    if (networkError) {
+        const normErr = normalizeError(networkError);
+        if (normErr.retryable) {
+            db.unmarkInflight(docRef.path, mutationId);
+            return { status: 'pending', committed: false, writtenLocally: true, mutationId };
         }
-        catch (error) {
-            if (error && error.response && error.response.status >= 400 && error.response.status < 500) {
-                throw (0, NexaError_1.toNexaError)(error);
+        else {
+            let rebasedView;
+            try {
+                rebasedView = await db._rejectMutationAtomically({
+                    mutationId,
+                    path: docRef.path,
+                    error: normErr
+                });
             }
-            await db._addOfflineJob({
-                id: jobId,
-                type: 'patch',
-                path: docRef.path,
-                data,
-                idempotencyKey: key,
-                state: 'pending'
+            catch (rejectionError) {
+                db.unmarkInflight(docRef.path, mutationId);
+                throw Object.assign(new Error('Server rejected mutation, but local rollback failed'), { code: normErr.code, cause: rejectionError, originalError: networkError });
+            }
+            db.unmarkInflight(docRef.path, mutationId);
+            safelyNotifyMutation(db, docRef.path, rebasedView.data ? (action === 'delete' ? 'set' : action) : 'delete', rebasedView.data, {
+                mutationId,
+                source: 'local',
+                state: 'rejected',
+                hasPendingWrites: rebasedView.hasPendingWrites
             });
-            return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline' };
-        }
-        finally {
-            db.unmarkInflight(docRef.path);
+            throw Object.assign(new Error(normErr.message), { code: normErr.code, cause: networkError });
         }
     }
+    // Phase 4: ACK Validation
+    const isValidAck = res && res.success;
+    if (!isValidAck) {
+        console.error('[NexaBase] Protocol error: Invalid server ACK:', res);
+        db.unmarkInflight(docRef.path, mutationId);
+        return { status: 'pending', committed: false, writtenLocally: true, mutationId };
+    }
+    // Phase 5: Atomic Local ACK
+    let ackView;
+    try {
+        ackView = await db._commitMutationAck({
+            mutationId,
+            path: docRef.path,
+            action,
+            serverDocument: res.document,
+            updateTime: res.document?.updateTime
+        });
+    }
+    catch (ackError) {
+        console.error('[NexaBase] Failed to persist ACK locally, mutation remains pending:', ackError);
+        db.unmarkInflight(docRef.path, mutationId);
+        return { status: 'pending', committed: false, writtenLocally: true, mutationId };
+    }
+    // Phase 6: Notification
+    db.unmarkInflight(docRef.path, mutationId);
+    safelyNotifyMutation(db, docRef.path, action, ackView.data, {
+        mutationId,
+        source: 'server',
+        state: 'acknowledged',
+        hasPendingWrites: ackView.hasPendingWrites
+    });
+    return { status: 'committed', committed: true, writtenLocally: true, mutationId, data: ackView.data };
+};
+const setDoc = async (docRef, data, options) => {
+    return executeWriteMutation(docRef, 'set', data, options);
+};
+exports.setDoc = setDoc;
+const patchDoc = async (docRef, data, options) => {
+    return executeWriteMutation(docRef, 'patch', data, options);
 };
 exports.patchDoc = patchDoc;
 const updateDoc = async (docRef, data, options) => {
-    return (0, exports.patchDoc)(docRef, data, options);
+    return (0, exports.patchDoc)(docRef, data, { ...options, preconditionExists: true });
 };
 exports.updateDoc = updateDoc;
 const deleteDoc = async (docRef, options) => {
-    const db = docRef.db;
-    if (db._initPromise)
-        await db._initPromise;
-    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',
-            path: docRef.path,
-            idempotencyKey: key,
-            state: 'pending'
-        });
-        return { success: true };
-    }
-    else {
-        db.markInflight(docRef.path);
-        try {
-            const res = (await db.client.delete(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`, { headers: { 'X-Idempotency-Key': key } })).data;
-            return res;
-        }
-        catch (error) {
-            if (error && error.response && error.response.status >= 400 && error.response.status < 500) {
-                throw (0, NexaError_1.toNexaError)(error);
-            }
-            await db._addOfflineJob({
-                id: jobId,
-                type: 'delete',
-                path: docRef.path,
-                idempotencyKey: key,
-                state: 'pending'
-            });
-            return { success: true };
-        }
-        finally {
-            db.unmarkInflight(docRef.path);
-        }
-    }
+    return executeWriteMutation(docRef, 'delete', null, options);
 };
 exports.deleteDoc = deleteDoc;

package/dist/persistence/LocalStore.d.ts

@@ -2,7 +2,11 @@ import { IndexedDB } from './IndexedDB';
 export declare class LocalStore {
     private indexedDB;
     private inMemoryCache;
+    private inMemoryServerBase;
+    private currentSequence;
     constructor(indexedDB: IndexedDB);
+    nextMutationSequence(): Promise<number>;
+    getServerBaseCache(): Record<string, any>;
     set(path: string, data: any): Promise<void>;
     getInMemory(path: string): any;
     getMemoryCache(): Record<string, any>;

package/dist/persistence/LocalStore.js

@@ -4,8 +4,17 @@ exports.LocalStore = void 0;
 class LocalStore {
     constructor(indexedDB) {
         this.inMemoryCache = {};
+        this.inMemoryServerBase = {};
+        this.currentSequence = 0;
         this.indexedDB = indexedDB;
     }
+    async nextMutationSequence() {
+        this.currentSequence++;
+        return this.currentSequence;
+    }
+    getServerBaseCache() {
+        return this.inMemoryServerBase;
+    }
     async set(path, data) {
         this.inMemoryCache[path] = data;
         const db = this.indexedDB.getRawDB();
@@ -14,7 +23,7 @@ class LocalStore {
         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() });
+            const req = store.put({ path, data, timestamp: Date.now(), serverBase: this.inMemoryServerBase[path] !== undefined ? this.inMemoryServerBase[path] : null });
             req.onsuccess = () => resolve();
             req.onerror = () => reject(req.error);
         });
@@ -39,6 +48,8 @@ class LocalStore {
                 const data = req.result ? req.result.data : null;
                 if (data)
                     this.inMemoryCache[path] = data;
+                if (req.result && req.result.serverBase !== undefined)
+                    this.inMemoryServerBase[path] = req.result.serverBase;
                 resolve(data);
             };
             req.onerror = () => reject(req.error);
@@ -46,6 +57,7 @@ class LocalStore {
     }
     async delete(path) {
         delete this.inMemoryCache[path];
+        delete this.inMemoryServerBase[path];
         const db = this.indexedDB.getRawDB();
         if (!db)
             return;
@@ -68,13 +80,14 @@ class LocalStore {
             req.onsuccess = () => {
                 req.result.forEach((item) => {
                     this.inMemoryCache[item.path] = item.data;
+                    if (item.serverBase !== undefined)
+                        this.inMemoryServerBase[item.path] = item.serverBase;
                 });
                 resolve(this.inMemoryCache);
             };
             req.onerror = () => reject(req.error);
         });
     }
-    // LRU Cache Garbage Collection (Max size 5000 items)
     async garbageCollect(maxItems = 5000) {
         const db = this.indexedDB.getRawDB();
         if (!db)
@@ -86,7 +99,6 @@ class LocalStore {
             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) {
@@ -97,6 +109,7 @@ class LocalStore {
                         const delReq = store.delete(item.path);
                         delReq.onsuccess = () => {
                             delete this.inMemoryCache[item.path];
+                            delete this.inMemoryServerBase[item.path];
                             removedCount++;
                             if (removedCount === itemsToRemove.length) {
                                 resolve();

package/dist/persistence/MutationQueue.d.ts

@@ -13,9 +13,10 @@ export declare class MutationQueue {
     loadQueue(): Promise<OfflineJob[]>;
     addJob(job: OfflineJob): Promise<void>;
     saveQueue(queue: OfflineJob[]): Promise<void>;
+    claimJob(mutationId: string, ownerId: string, leaseDurationMs: number): Promise<OfflineJob | null>;
     removeJob(jobId: string): Promise<void>;
-    markInflight(path: string): void;
-    unmarkInflight(path: string): void;
+    markInflight(path: string, mutationId?: string): void;
+    unmarkInflight(path: string, mutationId?: string): void;
     hasPendingWrites(path: string): boolean;
     getQueue(): OfflineJob[];
     syncQueue(): Promise<void>;

package/dist/persistence/MutationQueue.js

@@ -4,7 +4,7 @@ exports.MutationQueue = void 0;
 class MutationQueue {
     constructor(projectId, indexedDB, client) {
         this.inMemoryQueue = [];
-        this.inflightWrites = new Set();
+        this.inflightWrites = new Map();
         this.isSyncing = false;
         this.projectId = projectId;
         this.indexedDB = indexedDB;
@@ -71,20 +71,45 @@ class MutationQueue {
             clearReq.onerror = () => reject(clearReq.error);
         });
     }
+    async claimJob(mutationId, ownerId, leaseDurationMs) {
+        const job = this.inMemoryQueue.find(j => j.id === mutationId);
+        if (!job)
+            return null;
+        const now = Date.now();
+        if (job.leaseOwner && job.leaseOwner !== ownerId && job.leaseExpiresAt && job.leaseExpiresAt > now) {
+            return null;
+        }
+        job.leaseOwner = ownerId;
+        job.leaseExpiresAt = now + leaseDurationMs;
+        await this.saveQueue(this.inMemoryQueue);
+        return job;
+    }
     async removeJob(jobId) {
         const updated = this.inMemoryQueue.filter((j) => j.id !== jobId);
         await this.saveQueue(updated);
     }
-    markInflight(path) {
-        this.inflightWrites.add(path);
+    markInflight(path, mutationId) {
+        if (!mutationId)
+            return;
+        if (!this.inflightWrites.has(path))
+            this.inflightWrites.set(path, new Set());
+        this.inflightWrites.get(path).add(mutationId);
     }
-    unmarkInflight(path) {
-        this.inflightWrites.delete(path);
+    unmarkInflight(path, mutationId) {
+        if (!mutationId)
+            return;
+        const set = this.inflightWrites.get(path);
+        if (set) {
+            set.delete(mutationId);
+            if (set.size === 0) {
+                this.inflightWrites.delete(path);
+            }
+        }
     }
     hasPendingWrites(path) {
         if (this.inflightWrites.has(path))
             return true;
-        for (const p of this.inflightWrites) {
+        for (const p of Array.from(this.inflightWrites.keys())) {
             if (p.startsWith(path + '/'))
                 return true;
         }
@@ -112,7 +137,7 @@ class MutationQueue {
                         merge: job.merge
                     }, { headers });
                 }
-                else if (job.type === 'patch' || job.type === 'update') {
+                else if (job.type === 'patch') {
                     await this.client.patch(`/api/firestore/${this.projectId}/document`, {
                         docPath: job.path,
                         data: job.data,

package/dist/types/index.d.ts

@@ -140,14 +140,21 @@ export interface WriteBatch {
 }
 export interface OfflineJob {
     id: string;
-    type: 'set' | 'update' | 'patch' | 'delete';
+    type: 'set' | 'patch' | 'delete';
     path: string;
     data?: any;
     idempotencyKey?: string;
+    precondition?: {
+        exists?: boolean;
+        updateTime?: string;
+    };
     timestamp?: number;
     merge?: boolean;
     state?: 'pending' | 'acknowledged' | 'rejected';
     retryCount?: number;
+    leaseOwner?: string;
+    leaseExpiresAt?: number;
+    sequenceNumber?: number;
     lastError?: string;
 }
 export interface Transaction {

package/package.json

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