nexabase-console 1.0.0

package/README.md

@@ -0,0 +1,237 @@
+# NexaBase JavaScript SDK (`nexabase`)
+
+SDK Client Resmi untuk **NexaBase**: Platform sinkronisasi database modern yang menyatukan fungsionalitas Firestore NoSQL, Real-Time Database, File Storage, dan Edge Authentication dengan dukungan **Offline-First (IndexedDB)** serta **Passwordless OTP**.
+
+---
+
+## 🚀 Fitur Utama
+
+-   **⚡ Real-Time Synchronization**: Sinkronisasi data real-time dengan latency rendah menggunakan Server-Sent Events (SSE).
+-   **📦 Offline-First & Auto-Sync**: Sinkronisasi state lokal secara otomatis menggunakan **IndexedDB**. Data tetap tersimpan di browser jika koneksi terputus dan akan disinkronkan ke server secara otomatis saat kembali online.
+-   **🔥 Modular Firestore API**: Desain API modular modern mirip Firebase SDK (v9+) sehingga sangat mudah dipelajari.
+-   **🔑 Secure Auth & Passwordless OTP**: Dukungan penuh registrasi, login email/sandi, serta OTP instan via SMTP yang aman.
+-   **📂 File Storage Integration**: Unggah aset media dan file blob ke cloud storage dengan satu perintah.
+
+---
+
+## 📦 Instalasi
+
+Instal package melalui npm atau yarn:
+
+```bash
+npm install nexabase
+# atau
+yarn add nexabase
+```
+
+---
+
+## ⚡ Panduan Rilis (Publishing)
+
+Jika Anda ingin mengunggah SDK ini ke repositori **GitHub** Anda sendiri atau merilisnya ke registry **NPM**, ikuti langkah mudah berikut:
+
+### 1. Inisialisasi Repositori Git & GitHub
+```bash
+# Masuk ke direktori SDK
+cd nexabase-sdk
+
+# Inisialisasi Git
+git init
+git add .
+git commit -m "Inisialisasi rilis perdana NexaBase SDK v1.0.0"
+
+# Tambahkan remote repositori GitHub Anda
+git remote add origin https://github.com/USERNAME/REPOS_NAME.git
+git branch -M main
+git push -u origin main
+```
+
+### 2. Publikasi ke NPM Registry
+Pastikan Anda sudah memiliki akun di [npmjs.com](https://www.npmjs.com/).
+
+```bash
+# Login ke akun NPM Anda melalui terminal
+npm login
+
+# Jalankan build compiler TypeScript
+npm run build
+
+# Publikasikan ke registry NPM secara publik
+npm publish --access public
+```
+
+---
+
+## 🛠️ Cara Penggunaan & Contoh Kode
+
+### 1. Inisialisasi Aplikasi
+
+```javascript
+import { initializeApp, getFirestore } from 'nexabase';
+
+const app = initializeApp({
+  projectId: 'PROYEK_NEXABASE_ID_ANDA',
+  apiKey: 'NEXABASE_API_KEY_ANDA', // Opsional, tergantung aturan keamanan
+  endpoint: 'https://nexabase-server.yourdomain.com' // Alamat URL server backend
+});
+
+const db = getFirestore(app);
+```
+
+---
+
+### 2. Firestore-like Modular API (NoSQL)
+
+#### Menulis Data Baru (Set Doc)
+```javascript
+import { doc, setDoc } from 'nexabase';
+
+const main = async () => {
+  const profileRef = doc(db, 'users', 'budi_santoso');
+  const res = await setDoc(profileRef, {
+    name: 'Budi Santoso',
+    email: 'budi@example.com',
+    age: 28,
+    hobbies: ['Coding', 'Cycling']
+  });
+  
+  console.log("Data berhasil disimpan:", res);
+};
+
+main();
+```
+
+#### Memperbarui Sebagian Data (Update Doc)
+```javascript
+import { doc, updateDoc } from 'nexabase';
+
+const editData = async () => {
+  const profileRef = doc(db, 'users', 'budi_santoso');
+  await updateDoc(profileRef, {
+    age: 29 // Hanya memperbarui field age
+  });
+};
+```
+
+#### Membaca Satu Dokumen (Get Doc)
+```javascript
+import { doc, getDoc } from 'nexabase';
+
+const readData = async () => {
+  const profileRef = doc(db, 'users', 'budi_santoso');
+  const snapshot = await getDoc(profileRef);
+  
+  if (snapshot.exists()) {
+    console.log("Isi data:", snapshot.data());
+  } else {
+    console.log("Dokumen tidak ditemukan.");
+  }
+};
+```
+
+#### Mendengarkan Perubahan Data secara Real-Time (onSnapshot)
+```javascript
+import { doc, onSnapshot } from 'nexabase';
+
+const listenLive = () => {
+  const docRef = doc(db, 'chats', 'global_room');
+  
+  // onSnapshot akan terpanggil seketika jika ada perubahan data baik di lokal maupun di server
+  const unsubscribe = onSnapshot(docRef, (snapshot) => {
+    console.log("⚡ Perubahan Terdeteksi! Data Terbaru:", snapshot.data());
+  });
+  
+  // Panggil unsubscribe() untuk menghentikan pemantauan realtime
+  // unsubscribe();
+};
+```
+
+#### Menggunakan Atomic Write Batch
+```javascript
+import { doc, writeBatch } from 'nexabase';
+
+const executeBatch = async () => {
+  const batch = writeBatch(db);
+  
+  const ref1 = doc(db, 'products', 'prod_a');
+  const ref2 = doc(db, 'products', 'prod_b');
+  
+  batch.set(ref1, { name: 'Sandal Kulit', price: 75000 });
+  batch.set(ref2, { name: 'Sepatu Kulit', price: 250000 });
+  
+  const result = await batch.commit();
+  console.log("Semua operasi batch berhasil di-commit secara atomik.");
+};
+```
+
+---
+
+### 3. Autentikasi Pengguna & OTP Tanpa Sandi
+
+#### Pendaftaran & Login Tradisional
+```javascript
+// Registrasi User Baru
+const register = async () => {
+  const user = await app.auth().createUserWithEmailAndPassword(
+    'test@example.com', 
+    'password123', 
+    'Andi Wijaya'
+  );
+  console.log("Registrasi Berhasil:", user);
+};
+
+// Login User
+const login = async () => {
+  const authSession = await app.auth().signInWithEmailAndPassword(
+    'test@example.com', 
+    'password123'
+  );
+  console.log("Token Sesi JWT:", authSession.token);
+  console.log("Data Akun Pengguna:", authSession.user);
+};
+```
+
+#### Login Passwordless dengan OTP (Email)
+```javascript
+// 1. Kirim OTP Ke Email Pengguna
+const sendMyOtp = async () => {
+  const res = await app.auth().sendOtp('test@example.com');
+  console.log("Kode OTP berhasil terkirim ke email Anda.");
+};
+
+// 2. Verifikasi OTP dari Input Pengguna
+const verifyMyOtp = async () => {
+  const otpCode = '123456'; // Kode 6 digit yang dikirim ke email
+  const authSession = await app.auth().signInWithOtp('test@example.com', otpCode, 'Andi Wijaya');
+  console.log("Login OTP Berhasil! Sesi JWT Aktif:", authSession.token);
+};
+```
+
+---
+
+### 4. File Storage API
+
+```javascript
+const uploadImage = async (fileBlob) => {
+  const storageRef = app.storage().ref('avatars/andi.jpg');
+  const result = await storageRef.put(fileBlob);
+  
+  console.log("Akses File URL Publik Anda:", result.url);
+};
+```
+
+---
+
+## 🗄️ Dukungan Sinkronisasi Offline (IndexedDB)
+
+NexaBase JS SDK dikembangkan dengan arsitektur **Offline-First**. 
+
+1.  **Optimistic Rendering**: Jika perangkat offline, SDK akan langsung mengupdate cache IndexedDB lokal dan men-trigger callback subscriber `onSnapshot` agar UI pengguna langsung merespons secara instan.
+2.  **Background Queue**: Setiap perubahan mutasi (`setDoc`, `updateDoc`, `deleteDoc`, `writeBatch`) saat offline disimpan secara aman di IndexedDB.
+3.  **Automatic Resync**: Saat koneksi internet mendeteksi status `online`, antrean modifikasi akan dikirimkan kembali secara beruntun ke Server cloud NexaBase secara otomatis tanpa intervensi pengguna.
+
+---
+
+## 📄 Lisensi
+
+Proyek ini dilisensikan di bawah Lisensi MIT. Bebas digunakan untuk keperluan pribadi, komersial, maupun edukasi.

package/dist/index.d.ts

@@ -0,0 +1,139 @@
+import { AxiosInstance } from 'axios';
+export interface NexaConfig {
+    projectId: string;
+    apiKey?: string;
+    endpoint?: string;
+}
+export interface User {
+    id: string;
+    email: string;
+    name: string;
+    role: string;
+}
+export interface AuthResponse {
+    token: string;
+    user: User;
+}
+export interface QueryConstraint {
+    type: 'where' | 'orderBy' | 'limit';
+    fieldPath?: string;
+    opStr?: string;
+    value?: any;
+    directionStr?: 'asc' | 'desc';
+    limitValue?: number;
+}
+export interface DocumentReference {
+    type: 'document';
+    path: string;
+    db: NexaApp;
+}
+export interface CollectionReference {
+    type: 'collection';
+    path: string;
+    db: NexaApp;
+}
+export interface Query {
+    type: 'query' | 'collection';
+    path: string;
+    db: NexaApp;
+    constraints?: QueryConstraint[];
+}
+export interface DocumentSnapshot {
+    exists: () => boolean;
+    data: () => any | null;
+}
+export interface QueryDocumentSnapshot {
+    id: string;
+    data: () => any;
+}
+export interface QuerySnapshot {
+    docs: QueryDocumentSnapshot[];
+    forEach: (callback: (doc: QueryDocumentSnapshot) => void) => void;
+    empty: boolean;
+    size: number;
+}
+export interface DatabaseReference {
+    get: () => Promise<any>;
+    set: (data: any) => Promise<any>;
+    onDataChanged: (callback: (data: any) => void) => void;
+}
+export interface StorageReference {
+    put: (file: File | Blob) => Promise<{
+        url: string;
+        success: boolean;
+    }>;
+}
+export interface WriteBatch {
+    set: (docRef: DocumentReference, data: any) => WriteBatch;
+    update: (docRef: DocumentReference, data: any) => WriteBatch;
+    delete: (docRef: DocumentReference) => WriteBatch;
+    commit: () => Promise<any>;
+}
+interface OfflineJob {
+    id: string;
+    type: 'set' | 'update' | 'delete';
+    path: string;
+    data?: any;
+}
+export declare class NexaApp {
+    projectId: string;
+    token: string | null;
+    endpoint: string;
+    client: AxiosInstance;
+    sse: EventSource | null;
+    _firestoreCache: Record<string, any>;
+    _snapshotCallbacks: Record<string, (payload?: any) => void>;
+    _sseCallbacks: {
+        data_changed: ((payload: any) => void)[];
+        firestore_changed: ((payload: any) => void)[];
+    };
+    _offlineQueueInitialized: boolean;
+    _isSyncing: boolean;
+    _idb: any;
+    _firestoreListening: boolean;
+    _initPromise: Promise<void> | null;
+    constructor(config: NexaConfig);
+    connectRealtime(): EventSource;
+    database(): {
+        ref: (path?: string) => DatabaseReference;
+    };
+    auth(): {
+        signInWithEmailAndPassword: (email: string, password: string) => Promise<AuthResponse>;
+        createUserWithEmailAndPassword: (email: string, password: string, name: string) => Promise<User>;
+        sendOtp: (email: string) => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        signInWithOtp: (email: string, otp: string, name?: string) => Promise<AuthResponse>;
+        signOut: () => void;
+        getCurrentUser: () => User | null;
+    };
+    storage(): {
+        ref: (path?: string) => StorageReference;
+    };
+    _initFirestoreState(): Promise<void>;
+    _getOfflineQueue(): Promise<OfflineJob[]>;
+    _saveOfflineQueue(queue: OfflineJob[]): Promise<void>;
+    _addOfflineJob(job: OfflineJob): Promise<void>;
+    _setCache(path: string, data: any): Promise<void>;
+    _deleteCache(path: string): Promise<void>;
+    _loadCache(): Promise<void>;
+    _syncOfflineQueue(): Promise<void>;
+    _ensureFirestoreSSE(): void;
+}
+export declare const initializeApp: (config: NexaConfig) => NexaApp;
+export declare const getFirestore: (app: NexaApp) => NexaApp;
+export declare const collection: (db: NexaApp, collectionPath: string) => CollectionReference;
+export declare const doc: (dbOrCollection: NexaApp | CollectionReference, ...pathSegments: string[]) => DocumentReference;
+export declare const query: (queryObject: Query | CollectionReference, ...queryConstraints: QueryConstraint[]) => Query;
+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 getDocs: (queryOrCollection: Query | CollectionReference) => Promise<QuerySnapshot>;
+export declare const getDoc: (docRef: DocumentReference) => Promise<DocumentSnapshot>;
+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, callback: (snapshot: any) => void) => (() => void);
+export declare const writeBatch: (db: NexaApp) => WriteBatch;
+export {};

package/dist/index.js

@@ -0,0 +1,651 @@
+"use strict";
+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;
+const axios_1 = __importDefault(require("axios"));
+// -----------------------------------------------------------------
+// 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;
+        this.projectId = config.projectId;
+        this.token = config.apiKey || null;
+        if (typeof window !== 'undefined' && window.localStorage) {
+            const savedToken = localStorage.getItem(`nexa_token_${this.projectId}`);
+            if (savedToken) {
+                this.token = savedToken;
+            }
+        }
+        this.endpoint = config.endpoint || (typeof window !== 'undefined' ? window.location.origin : '');
+        this.client = axios_1.default.create({
+            baseURL: this.endpoint,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        // Request interceptor to automatically attach authorization Bearer token
+        this.client.interceptors.request.use((req) => {
+            if (this.token) {
+                req.headers.Authorization = `Bearer ${this.token}`;
+            }
+            return req;
+        });
+    }
+    // Real-time listener connection via Server-Sent Events (SSE)
+    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;
+        this.sse = new EventSource(listenUrl);
+        this.sse.onmessage = async (event) => {
+            try {
+                const payload = JSON.parse(event.data);
+                if (payload.type === 'connected')
+                    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) {
+                // Silent catch JSON parsing errors
+            }
+        };
+        return this.sse;
+    }
+    // -----------------------------------------------------------------
+    // Realtime Key-Value Database API
+    // -----------------------------------------------------------------
+    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);
+                        }
+                    });
+                }
+            })
+        };
+    }
+    // -----------------------------------------------------------------
+    // 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 = '') => ({
+                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;
+                }
+            })
+        };
+    }
+    // -----------------------------------------------------------------
+    // Offline Synchronization & Local IndexedDB Cache Engine
+    // -----------------------------------------------------------------
+    async _initFirestoreState() {
+        if (this._offlineQueueInitialized)
+            return;
+        this._offlineQueueInitialized = true;
+        this._isSyncing = false;
+        if (typeof window === 'undefined' || !window.indexedDB) {
+            return;
+        }
+        const dbName = `nexa_idb_${this.projectId}`;
+        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();
+        // Trigger queue sync periodically when browser returns online
+        if (typeof window !== 'undefined') {
+            window.addEventListener('online', () => this._syncOfflineQueue());
+            setTimeout(() => this._syncOfflineQueue(), 1000);
+        }
+    }
+    async _getOfflineQueue() {
+        if (!this._idb)
+            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)
+            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)
+            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)
+            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)
+            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)
+            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);
+        });
+    }
+    async _syncOfflineQueue() {
+        if (this._isSyncing)
+            return;
+        this._isSyncing = true;
+        const queue = await this._getOfflineQueue();
+        if (queue.length === 0) {
+            this._isSyncing = false;
+            return;
+        }
+        for (const job of [...queue]) {
+            try {
+                if (job.type === 'set') {
+                    await this.client.post(`/api/firestore/${this.projectId}/document`, { docPath: job.path, data: job.data });
+                }
+                else if (job.type === 'update') {
+                    await this.client.patch(`/api/firestore/${this.projectId}/document`, { docPath: job.path, data: job.data });
+                }
+                else if (job.type === 'delete') {
+                    await this.client.delete(`/api/firestore/${this.projectId}/document?docPath=${encodeURIComponent(job.path)}`);
+                }
+                const currentQueue = await this._getOfflineQueue();
+                await this._saveOfflineQueue(currentQueue.filter((q) => q.id !== job.id));
+            }
+            catch (err) {
+                break; // Stop syncing on network exceptions
+            }
+        }
+        this._isSyncing = false;
+        if (this._snapshotCallbacks) {
+            Object.values(this._snapshotCallbacks).forEach((cb) => cb());
+        }
+    }
+    _ensureFirestoreSSE() {
+        this.connectRealtime();
+        if (this._firestoreListening)
+            return;
+        this._firestoreListening = true;
+        this._sseCallbacks.firestore_changed.push(async (change) => {
+            if (change.type === 'bulk_update') {
+                Object.values(this._snapshotCallbacks).forEach((cb) => cb());
+                return;
+            }
+            if (change.type === 'document_written') {
+                await this._setCache(change.docPath, change.data);
+            }
+            else if (change.type === 'document_deleted') {
+                await this._deleteCache(change.docPath);
+            }
+            Object.keys(this._snapshotCallbacks).forEach((pathKey) => {
+                const cb = this._snapshotCallbacks[pathKey];
+                if (pathKey === change.docPath || change.docPath.startsWith(pathKey + '/')) {
+                    cb(change);
+                }
+            });
+        });
+    }
+}
+exports.NexaApp = NexaApp;
+// -----------------------------------------------------------------
+// Modular Firestore-like APIs (Firebase Modular pattern match)
+// -----------------------------------------------------------------
+const initializeApp = (config) => {
+    return new NexaApp(config);
+};
+exports.initializeApp = initializeApp;
+const getFirestore = (app) => {
+    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) => {
+    if ('type' in dbOrCollection && dbOrCollection.type === 'collection') {
+        return { type: 'document', path: `${dbOrCollection.path}/${pathSegments.join('/')}`, db: dbOrCollection.db };
+    }
+    return { type: 'document', path: pathSegments.join('/'), db: dbOrCollection };
+};
+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;
+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 || [] : [];
+    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) => ({
+            id: d.id,
+            data: () => d.fields
+        }));
+        return {
+            docs: docsArray,
+            forEach: (cb) => docsArray.forEach(cb),
+            empty: docsArray.length === 0,
+            size: docsArray.length
+        };
+    }
+    catch (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;
+                    return true;
+                });
+            }
+        }
+        return {
+            docs: filtered,
+            forEach: (cb) => filtered.forEach(cb),
+            empty: filtered.length === 0,
+            size: filtered.length
+        };
+    }
+};
+exports.getDocs = getDocs;
+const getDoc = async (docRef) => {
+    const db = docRef.db;
+    if (db._initPromise)
+        await db._initPromise;
+    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 };
+    }
+    catch (err) {
+        const data = db._firestoreCache[docRef.path];
+        return { exists: () => !!data, data: () => data || null };
+    }
+};
+exports.getDoc = getDoc;
+const setDoc = async (docRef, data) => {
+    const db = docRef.db;
+    if (db._initPromise)
+        await db._initPromise;
+    await db._setCache(docRef.path, data);
+    // Trigger snapshot listeners
+    Object.keys(db._snapshotCallbacks).forEach((pathKey) => {
+        const cb = db._snapshotCallbacks[pathKey];
+        if (pathKey === docRef.path || docRef.path.startsWith(pathKey + '/')) {
+            cb({ type: 'document_written', docPath: docRef.path, data });
+        }
+    });
+    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 });
+        return { success: true, message: 'Offline: Tersimpan di cache lokal IndexedDB' };
+    }
+    else {
+        try {
+            return (await db.client.post(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data })).data;
+        }
+        catch (error) {
+            await db._addOfflineJob({ id: jobId, type: 'set', path: docRef.path, data });
+            return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline IndexedDB' };
+        }
+    }
+};
+exports.setDoc = setDoc;
+const updateDoc = async (docRef, data) => {
+    const db = docRef.db;
+    if (db._initPromise)
+        await db._initPromise;
+    const jobId = Math.random().toString(36).substring(2, 9);
+    const existingData = db._firestoreCache[docRef.path] || {};
+    const updatedData = { ...existingData, ...data };
+    await db._setCache(docRef.path, updatedData);
+    const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+    if (!isOnline) {
+        await db._addOfflineJob({ id: jobId, type: 'update', path: docRef.path, data });
+        return { success: true, message: 'Offline: Tersimpan di cache lokal IndexedDB' };
+    }
+    else {
+        try {
+            return (await db.client.patch(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data })).data;
+        }
+        catch (error) {
+            await db._addOfflineJob({ id: jobId, type: 'update', path: docRef.path, data });
+            return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline IndexedDB' };
+        }
+    }
+};
+exports.updateDoc = updateDoc;
+const deleteDoc = async (docRef) => {
+    const db = docRef.db;
+    if (db._initPromise)
+        await db._initPromise;
+    await db._deleteCache(docRef.path);
+    // Trigger snapshot listeners
+    Object.keys(db._snapshotCallbacks).forEach((pathKey) => {
+        const cb = db._snapshotCallbacks[pathKey];
+        if (pathKey === docRef.path || docRef.path.startsWith(pathKey + '/')) {
+            cb({ type: 'document_deleted', docPath: docRef.path });
+        }
+    });
+    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 });
+        return { success: true };
+    }
+    else {
+        try {
+            return (await db.client.delete(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`)).data;
+        }
+        catch (error) {
+            await db._addOfflineJob({ id: jobId, type: 'delete', path: docRef.path });
+            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;
+        const triggerCallback = async () => {
+            if (ref.type === 'collection') {
+                const docs = await (0, exports.getDocs)(ref);
+                callback(docs);
+            }
+            else {
+                const docData = await (0, exports.getDoc)(ref);
+                callback(docData);
+            }
+        };
+        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 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;
+        },
+        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 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);
+                    Object.keys(db._snapshotCallbacks).forEach((pathKey) => {
+                        const cb = db._snapshotCallbacks[pathKey];
+                        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((pathKey) => {
+                        const cb = db._snapshotCallbacks[pathKey];
+                        if (pathKey === op.path || op.path.startsWith(pathKey + '/')) {
+                            cb({ type: 'document_deleted', docPath: op.path });
+                        }
+                    });
+                }
+            }
+            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
+                    });
+                }
+                return { success: true, message: 'Offline: Batch operations queued in IndexedDB' };
+            }
+            else {
+                try {
+                    return (await db.client.post(`/api/firestore/${db.projectId}/batch`, { operations })).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
+                        });
+                    }
+                    return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline IndexedDB' };
+                }
+            }
+        }
+    };
+    return batchObj;
+};
+exports.writeBatch = writeBatch;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "nexabase-console",
+  "version": "1.0.0",
+  "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "nexabase",
+    "firestore",
+    "realtime",
+    "database",
+    "offline-first",
+    "indexeddb",
+    "sync",
+    "otp",
+    "auth",
+    "storage"
+  ],
+  "author": "NexaBase Team",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.7.9"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}