nexabase-console 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -58,16 +58,29 @@ export interface QuerySnapshot<T = any> {
     docChanges: () => any[];
 }
 export interface DatabaseReference {
+    path: string;
     get: () => Promise<any>;
     set: (data: any) => Promise<any>;
-    onDataChanged: (callback: (data: any) => void) => void;
+    update: (data: any) => Promise<any>;
+    delete: () => Promise<any>;
+    remove: () => Promise<any>;
+    onDataChanged: (callback: (data: any) => void) => () => void;
+}
+export interface UploadOptions {
+    contextType?: 'chat' | 'public_post';
+    contextId?: string;
+    fileId?: string;
 }
 export interface StorageReference {
     name: string;
     fullPath: string;
-    put: (file: File | Blob, onProgress?: (percent: number) => void) => Promise<{
+    put: (file: File | Blob, options?: UploadOptions | ((percent: number) => void), onProgress?: (percent: number) => void) => Promise<{
         url: string;
         success: boolean;
+        fileId?: string;
+        proxyViewUrl?: string;
+        proxyDownloadUrl?: string;
+        metadata?: any;
     }>;
     delete: () => Promise<{
         success: boolean;
@@ -152,4 +165,13 @@ export declare const onSnapshot: (ref: CollectionReference | DocumentReference |
 export declare const enableIndexedDbPersistence: (db: NexaApp) => Promise<void>;
 export declare const enableOfflinePersistence: (db: NexaApp) => Promise<void>;
 export declare const writeBatch: (db: NexaApp) => WriteBatch;
+export interface Transaction {
+    get: <T = any>(docRef: DocumentReference<T>) => Promise<DocumentSnapshot<T>>;
+    set: (docRef: DocumentReference, data: any) => Transaction;
+    update: (docRef: DocumentReference, data: any) => Transaction;
+    delete: (docRef: DocumentReference) => Transaction;
+}
+export declare const runTransaction: <T = any>(db: NexaApp, updateFunction: (transaction: Transaction) => Promise<T>, options?: {
+    maxAttempts?: number;
+}) => Promise<T>;
 export {};

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeBatch = exports.enableOfflinePersistence = exports.enableIndexedDbPersistence = exports.onSnapshot = exports.deleteDoc = exports.updateDoc = 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.NexaApp = void 0;
+exports.runTransaction = exports.writeBatch = exports.enableOfflinePersistence = exports.enableIndexedDbPersistence = exports.onSnapshot = exports.deleteDoc = exports.updateDoc = 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.NexaApp = void 0;
 const axios_1 = __importDefault(require("axios"));
 // -----------------------------------------------------------------
 // Main NexaApp SDK Class
@@ -85,25 +85,50 @@ class NexaApp {
     // -----------------------------------------------------------------
     database() {
         return {
-            ref: (path = '') => ({
-                get: async () => {
-                    const response = await this.client.get(`/api/db/${this.projectId}/${path}`);
-                    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}/${path}`, payload);
-                    return response.data;
-                },
-                onDataChanged: (callback) => {
-                    this.connectRealtime();
-                    this._sseCallbacks.data_changed.push((payload) => {
-                        if (payload.path === path || payload.path === '/' + path) {
-                            callback(payload.data);
-                        }
-                    });
-                }
-            })
+            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);
+                        };
+                    }
+                };
+            }
         };
     }
     // -----------------------------------------------------------------
@@ -167,19 +192,43 @@ class NexaApp {
                 return {
                     name,
                     fullPath: path,
-                    put: async (file, onProgress) => {
+                    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, {
                             // We omit Content-Type headers here (interceptor strips it anyway) so the browser naturally generates the boundary
                             onUploadProgress: (progressEvent) => {
-                                if (onProgress && progressEvent.total) {
+                                if (actualOnProgress && progressEvent.total) {
                                     const percent = Math.round((progressEvent.loaded * 100) / progressEvent.total);
-                                    onProgress(percent);
+                                    actualOnProgress(percent);
                                 }
                             }
                         });
-                        return response.data;
+                        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)}`);
@@ -762,3 +811,86 @@ const writeBatch = (db) => {
     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 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;
+            },
+            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
+                });
+            }
+            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);
+                    Object.keys(db._snapshotCallbacks).forEach((key) => {
+                        const cb = db._snapshotCallbacks[key];
+                        const parts = key.split('_');
+                        const pathKey = parts.slice(2).join('_');
+                        if (pathKey === op.path || op.path.startsWith(pathKey + '/')) {
+                            cb({ type: 'document_written', docPath: op.path, data: db._firestoreCache[op.path] });
+                        }
+                    });
+                }
+                else if (op.type === 'delete') {
+                    await db._deleteCache(op.path);
+                    Object.keys(db._snapshotCallbacks).forEach((key) => {
+                        const cb = db._snapshotCallbacks[key];
+                        const parts = key.split('_');
+                        const pathKey = parts.slice(2).join('_');
+                        if (pathKey === op.path || op.path.startsWith(pathKey + '/')) {
+                            cb({ type: 'document_deleted', docPath: op.path });
+                        }
+                    });
+                }
+            }
+            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;

package/package.json

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