nexabase-console 1.0.3 → 1.0.5

package/dist/index.d.ts

@@ -39,11 +39,15 @@ export interface Query<T = any> {
     constraints?: QueryConstraint[];
 }
 export interface DocumentSnapshot<T = any> {
+    id: string;
+    ref: DocumentReference<T>;
     exists: () => boolean;
     data: () => T | null;
 }
 export interface QueryDocumentSnapshot<T = any> {
     id: string;
+    ref: DocumentReference<T>;
+    exists: () => boolean;
     data: () => T;
 }
 export interface QuerySnapshot<T = any> {
@@ -51,7 +55,7 @@ export interface QuerySnapshot<T = any> {
     forEach: (callback: (doc: QueryDocumentSnapshot<T>) => void) => void;
     empty: boolean;
     size: number;
-    docChanges?: () => any[];
+    docChanges: () => any[];
 }
 export interface DatabaseReference {
     get: () => Promise<any>;
@@ -59,10 +63,16 @@ export interface DatabaseReference {
     onDataChanged: (callback: (data: any) => void) => void;
 }
 export interface StorageReference {
-    put: (file: File | Blob) => Promise<{
+    name: string;
+    fullPath: string;
+    put: (file: File | Blob, onProgress?: (percent: number) => void) => Promise<{
         url: string;
         success: boolean;
     }>;
+    delete: () => Promise<{
+        success: boolean;
+        message?: string;
+    }>;
 }
 export interface WriteBatch {
     set: (docRef: DocumentReference, data: any) => WriteBatch;
@@ -111,6 +121,7 @@ export declare class NexaApp {
     };
     storage(): {
         ref: (path?: string) => StorageReference;
+        refFromURL: (url: string) => StorageReference;
     };
     _initFirestoreState(): Promise<void>;
     _getOfflineQueue(): Promise<OfflineJob[]>;
@@ -130,11 +141,15 @@ export declare const query: <T = any>(queryObject: Query<T> | CollectionReferenc
 export declare const where: (fieldPath: string, opStr: "==" | ">" | "<" | ">=" | "<=" | "!=", value: any) => QueryConstraint;
 export declare const orderBy: (fieldPath: string, directionStr?: "asc" | "desc") => QueryConstraint;
 export declare const limit: (limitValue: number) => QueryConstraint;
+export declare const getCachedDocs: <T = any>(queryOrCollection: Query<T> | CollectionReference<T>) => QuerySnapshot<T>;
+export declare const getCachedDoc: <T = any>(docRef: DocumentReference<T>) => DocumentSnapshot<T>;
 export declare const getDocs: <T = any>(queryOrCollection: Query<T> | CollectionReference<T>) => Promise<QuerySnapshot<T>>;
 export declare const getDoc: <T = any>(docRef: DocumentReference<T>) => Promise<DocumentSnapshot<T>>;
 export declare const setDoc: (docRef: DocumentReference, data: any) => Promise<any>;
 export declare const updateDoc: (docRef: DocumentReference, data: any) => Promise<any>;
 export declare const deleteDoc: (docRef: DocumentReference) => Promise<any>;
 export declare const onSnapshot: (ref: CollectionReference | DocumentReference | Query, callback: (snapshot: any) => void) => (() => void);
+export declare const enableIndexedDbPersistence: (db: NexaApp) => Promise<void>;
+export declare const enableOfflinePersistence: (db: NexaApp) => Promise<void>;
 export declare const writeBatch: (db: NexaApp) => WriteBatch;
 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.onSnapshot = exports.deleteDoc = exports.updateDoc = exports.setDoc = exports.getDoc = exports.getDocs = exports.limit = exports.orderBy = exports.where = exports.query = exports.doc = exports.collection = exports.getFirestore = exports.initializeApp = exports.NexaApp = void 0;
+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
@@ -29,18 +29,29 @@ class NexaApp {
                 this.token = savedToken;
             }
         }
-        this.endpoint = config.endpoint || 'https://db.nexabase.id';
+        // 3. Smart Endpoint Resolution: Auto-detect domain/host if none is specified
+        let defaultEndpoint = 'https://db.nexabase.id';
+        if (typeof window !== 'undefined' && window.location) {
+            // Default to the current page origin in dev/proxy preview environments so it auto-points to /api/*
+            defaultEndpoint = window.location.origin;
+        }
+        this.endpoint = config.endpoint || defaultEndpoint;
         this.client = axios_1.default.create({
             baseURL: this.endpoint,
             headers: {
                 'Content-Type': 'application/json'
             }
         });
-        // Request interceptor to automatically attach authorization Bearer token
+        // Request interceptor to attach bearer token and automatically resolve the axios boundary issue for file uploads
         this.client.interceptors.request.use((req) => {
             if (this.token) {
                 req.headers.Authorization = `Bearer ${this.token}`;
             }
+            // 2. Fix Axios Multipart Boundary on File Upload
+            // If Content-Type is multipart/form-data, delete it so axios/browser automatically appends the boundary header
+            if (req.headers && req.headers['Content-Type'] === 'multipart/form-data') {
+                delete req.headers['Content-Type'];
+            }
             return req;
         });
     }
@@ -151,14 +162,36 @@ class NexaApp {
     // -----------------------------------------------------------------
     storage() {
         return {
-            ref: (path = '') => ({
-                put: async (file) => {
-                    const formData = new FormData();
-                    formData.append('file', file);
-                    const response = await this.client.post(`/api/project/${this.projectId}/storage/upload`, formData);
-                    return response.data;
-                }
-            })
+            ref: (path = '') => {
+                const name = path.substring(path.lastIndexOf('/') + 1) || path;
+                return {
+                    name,
+                    fullPath: path,
+                    put: async (file, onProgress) => {
+                        const formData = new FormData();
+                        formData.append('file', file);
+                        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) {
+                                    const percent = Math.round((progressEvent.loaded * 100) / progressEvent.total);
+                                    onProgress(percent);
+                                }
+                            }
+                        });
+                        return response.data;
+                    },
+                    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);
+            }
         };
     }
     // -----------------------------------------------------------------
@@ -379,6 +412,70 @@ const limit = (limitValue) => {
     return { type: 'limit', limitValue };
 };
 exports.limit = limit;
+// 1. Helper to retrieve docs from the local Offline cache (Cache-First)
+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]
+            });
+        }
+    });
+    // Simple offline filters
+    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(doc => ({ type: 'added', doc }))
+    };
+};
+exports.getCachedDocs = getCachedDocs;
+// 1. Helper to retrieve single doc from the local Offline cache (Cache-First)
+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)
@@ -394,10 +491,15 @@ const getDocs = async (queryOrCollection) => {
         for (const d of docs) {
             await db._setCache(`${collectionPath}/${d.id}`, d.fields);
         }
-        const docsArray = docs.map((d) => ({
-            id: d.id,
-            data: () => 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),
@@ -410,54 +512,7 @@ const getDocs = async (queryOrCollection) => {
         if (err && err.response) {
             throw err;
         }
-        const results = [];
-        Object.keys(db._firestoreCache).forEach((p) => {
-            if (p.startsWith(collectionPath + '/')) {
-                const parts = p.split('/');
-                results.push({
-                    id: parts[parts.length - 1],
-                    data: () => db._firestoreCache[p]
-                });
-            }
-        });
-        // Simple offline filters
-        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;
-                    if (c.opStr === 'in')
-                        return Array.isArray(c.value) && c.value.includes(val);
-                    if (c.opStr === 'not-in')
-                        return Array.isArray(c.value) && !c.value.includes(val);
-                    if (c.opStr === 'array-contains')
-                        return Array.isArray(val) && val.includes(c.value);
-                    if (c.opStr === 'array-contains-any') {
-                        return Array.isArray(val) && Array.isArray(c.value) && val.some((v) => c.value.includes(v));
-                    }
-                    return true;
-                });
-            }
-        }
-        return {
-            docs: filtered,
-            forEach: (cb) => filtered.forEach(cb),
-            empty: filtered.length === 0,
-            size: filtered.length,
-            docChanges: () => filtered.map(doc => ({ type: 'added', doc }))
-        };
+        return (0, exports.getCachedDocs)(queryOrCollection);
     }
 };
 exports.getDocs = getDocs;
@@ -465,18 +520,24 @@ 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];
     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 { exists: () => !!data, data: () => data };
+        return {
+            id: docId,
+            ref: docRef,
+            exists: () => !!data,
+            data: () => data
+        };
     }
     catch (err) {
         if (err && err.response) {
             throw err;
         }
-        const data = db._firestoreCache[docRef.path];
-        return { exists: () => !!data, data: () => (data || null) };
+        return (0, exports.getCachedDoc)(docRef);
     }
 };
 exports.getDoc = getDoc;
@@ -573,6 +634,19 @@ const onSnapshot = (ref, callback) => {
             await db._initPromise;
         db._ensureFirestoreSSE();
         const pathKey = ref.path;
+        // 1. Native Offline Cache/Persistence Priority: Emits cached snapshot IMMEDIATELY to trigger instant optimistic rendering!
+        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);
+            }
+        }
         const triggerCallback = async () => {
             if (ref.type === 'collection' || ref.type === 'query') {
                 const docs = await (0, exports.getDocs)(ref);
@@ -583,6 +657,7 @@ const onSnapshot = (ref, callback) => {
                 callback(docData);
             }
         };
+        // 2. Fetch the latest live server data and update cache + trigger the callback again
         triggerCallback();
         const listenerId = Math.random().toString(36).substring(2, 9);
         db._snapshotCallbacks[`${ref.type}_${listenerId}_${pathKey}`] = triggerCallback;
@@ -597,6 +672,17 @@ const onSnapshot = (ref, callback) => {
     return () => unsubscribe();
 };
 exports.onSnapshot = onSnapshot;
+// Supporting standard Firebase modular options functions
+const enableIndexedDbPersistence = async (db) => {
+    if (db._initPromise)
+        await db._initPromise;
+};
+exports.enableIndexedDbPersistence = enableIndexedDbPersistence;
+const enableOfflinePersistence = async (db) => {
+    if (db._initPromise)
+        await db._initPromise;
+};
+exports.enableOfflinePersistence = enableOfflinePersistence;
 const writeBatch = (db) => {
     const operations = [];
     const batchObj = {

package/package.json

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