nexabase-console 1.1.4 → 2.0.0

package/dist/firestore/transaction.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTransaction = void 0;
+const SnapshotManager_1 = require("./SnapshotManager");
+const ConflictResolver_1 = require("../sync/ConflictResolver");
+const NexaError_1 = require("../errors/NexaError");
+const helpers_1 = require("../utils/helpers");
+const runTransaction = async (db, updateFunction, options) => {
+    if (db._initPromise)
+        await db._initPromise;
+    return ConflictResolver_1.ConflictResolver.resolveWithRetry(async () => {
+        const reads = [];
+        const operations = [];
+        const idempotencyKey = (0, helpers_1.generateIdempotencyKey)();
+        const transaction = {
+            get: async (docRef) => {
+                let res;
+                try {
+                    if (typeof navigator !== 'undefined' && !navigator.onLine) {
+                        throw new Error('offline');
+                    }
+                    res = await db.client.get(`/api/firestore/${db.projectId}/documentWithMetadata?docPath=${encodeURIComponent(docRef.path)}`);
+                }
+                catch (err) {
+                    throw (0, NexaError_1.toNexaError)(new Error('Transaction failed: Perangkat sedang offline atau jaringan terputus. Transaksi memerlukan koneksi aktif.'));
+                }
+                const { data, updatedAt } = res.data;
+                reads.push({ path: docRef.path, readUpdatedAt: updatedAt });
+                return SnapshotManager_1.SnapshotManager.createDocumentSnapshot(docRef, data, false, db.hasPendingWrites(docRef.path));
+            },
+            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;
+            },
+            patch: (docRef, data) => {
+                operations.push({ type: 'update', path: docRef.path, data });
+                return transaction;
+            },
+            delete: (docRef) => {
+                operations.push({ type: 'delete', path: docRef.path });
+                return transaction;
+            }
+        };
+        const result = await updateFunction(transaction);
+        if (operations.length > 0 || reads.length > 0) {
+            if (typeof navigator !== 'undefined' && !navigator.onLine) {
+                throw (0, NexaError_1.toNexaError)(new Error('Transaction failed: Perangkat sedang offline atau jaringan terputus. Transaksi memerlukan koneksi aktif.'));
+            }
+            await db.client.post(`/api/firestore/${db.projectId}/transaction`, { reads, operations, idempotencyKey }, { headers: { 'X-Idempotency-Key': idempotencyKey } });
+        }
+        for (const op of operations) {
+            if (op.type === 'set' || op.type === 'update') {
+                const newData = (0, helpers_1.applyDataTransforms)(db._firestoreCache[op.path] || {}, op.data);
+                await db._setCache(op.path, newData);
+                db._broadcastLocalMutation(op.path, op.type === 'set' ? 'set' : 'patch', op.data);
+                db._notifySnapshotCallbacks(op.path, 'document_written', db._firestoreCache[op.path]);
+            }
+            else if (op.type === 'delete') {
+                await db._deleteCache(op.path);
+                db._broadcastLocalMutation(op.path, 'delete');
+                db._notifySnapshotCallbacks(op.path, 'document_deleted', null);
+            }
+        }
+        return result;
+    }, options?.maxAttempts ?? 5);
+};
+exports.runTransaction = runTransaction;

package/dist/firestore/writes.d.ts

@@ -0,0 +1,15 @@
+import { DocumentReference } from '../types/index';
+export { FieldValue } from './FieldValue';
+export declare const setDoc: (docRef: DocumentReference, data: any, options?: {
+    merge?: boolean;
+    idempotencyKey?: string;
+}) => Promise<any>;
+export declare const patchDoc: (docRef: DocumentReference, data: any, options?: {
+    idempotencyKey?: string;
+}) => Promise<any>;
+export declare const updateDoc: (docRef: DocumentReference, data: any, options?: {
+    idempotencyKey?: string;
+}) => Promise<any>;
+export declare const deleteDoc: (docRef: DocumentReference, options?: {
+    idempotencyKey?: string;
+}) => Promise<any>;

package/dist/firestore/writes.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteDoc = exports.updateDoc = exports.patchDoc = exports.setDoc = exports.FieldValue = void 0;
+const helpers_1 = require("../utils/helpers");
+var FieldValue_1 = require("./FieldValue");
+Object.defineProperty(exports, "FieldValue", { enumerable: true, get: function () { return FieldValue_1.FieldValue; } });
+const setDoc = async (docRef, data, options) => {
+    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);
+    await db._setCache(docRef.path, finalData);
+    db._broadcastLocalMutation(docRef.path, 'set', finalData);
+    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
+    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;
+    if (!isOnline) {
+        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' };
+    }
+    else {
+        db.markInflight(docRef.path);
+        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) {
+            await db._addOfflineJob({
+                id: jobId,
+                type: 'set',
+                path: docRef.path,
+                data,
+                idempotencyKey: key,
+                merge: options?.merge,
+                state: 'pending'
+            });
+            return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline' };
+        }
+        finally {
+            db.unmarkInflight(docRef.path);
+        }
+    }
+};
+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);
+    await db._setCache(docRef.path, finalData);
+    db._broadcastLocalMutation(docRef.path, 'patch', finalData);
+    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
+    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;
+    if (!isOnline) {
+        await db._addOfflineJob({
+            id: jobId,
+            type: 'patch',
+            path: docRef.path,
+            data,
+            idempotencyKey: key,
+            state: 'pending'
+        });
+        return { success: true, message: 'Offline: Tersimpan di cache lokal' };
+    }
+    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;
+        }
+        catch (error) {
+            await db._addOfflineJob({
+                id: jobId,
+                type: 'patch',
+                path: docRef.path,
+                data,
+                idempotencyKey: key,
+                state: 'pending'
+            });
+            return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline' };
+        }
+        finally {
+            db.unmarkInflight(docRef.path);
+        }
+    }
+};
+exports.patchDoc = patchDoc;
+const updateDoc = async (docRef, data, options) => {
+    return (0, exports.patchDoc)(docRef, data, options);
+};
+exports.updateDoc = updateDoc;
+const deleteDoc = async (docRef, options) => {
+    const db = docRef.db;
+    if (db._initPromise)
+        await db._initPromise;
+    await db._deleteCache(docRef.path);
+    db._broadcastLocalMutation(docRef.path, 'delete');
+    db._notifySnapshotCallbacks(docRef.path, 'document_deleted', null);
+    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;
+    if (!isOnline) {
+        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) {
+            await db._addOfflineJob({
+                id: jobId,
+                type: 'delete',
+                path: docRef.path,
+                idempotencyKey: key,
+                state: 'pending'
+            });
+            return { success: true };
+        }
+        finally {
+            db.unmarkInflight(docRef.path);
+        }
+    }
+};
+exports.deleteDoc = deleteDoc;

package/dist/index.d.ts

@@ -1,206 +1,34 @@
-import { AxiosInstance } from 'axios';
-export interface NexaConfig {
-    projectId: string;
-    apiKey?: string;
-    endpoint?: string;
-    enablePersistence?: boolean;
-    cacheStrategy?: 'network-first' | 'cache-first';
-}
-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<T = any> {
-    type: 'document';
-    path: string;
-    db: NexaApp;
-    patch?: (data: Partial<T>) => Promise<any>;
-}
-export interface CollectionReference<T = any> {
-    type: 'collection';
-    path: string;
-    db: NexaApp;
-}
-export interface Query<T = any> {
-    type: 'query' | 'collection';
-    path: string;
-    db: NexaApp;
-    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> {
-    docs: QueryDocumentSnapshot<T>[];
-    forEach: (callback: (doc: QueryDocumentSnapshot<T>) => void) => void;
-    empty: boolean;
-    size: number;
-    docChanges: () => any[];
-}
-export interface DatabaseReference {
-    path: string;
-    get: () => Promise<any>;
-    set: (data: any) => Promise<any>;
-    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, 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;
-        message?: string;
-    }>;
-}
-export interface WriteBatch {
-    set: (docRef: DocumentReference, data: any) => WriteBatch;
-    update: (docRef: DocumentReference, data: any) => WriteBatch;
-    patch: (docRef: DocumentReference, data: any) => WriteBatch;
-    delete: (docRef: DocumentReference) => WriteBatch;
-    commit: () => Promise<any>;
-}
-interface OfflineJob {
-    id: string;
-    type: 'set' | 'update' | 'patch' | 'delete';
-    path: string;
-    data?: any;
-    idempotencyKey?: string;
-    timestamp?: number;
-}
-export declare function generateIdempotencyKey(): string;
-export declare class NexaApp {
-    projectId: string;
-    token: string | null;
-    endpoint: string;
-    client: AxiosInstance;
-    sse: EventSource | null;
-    enablePersistence: boolean;
-    cacheStrategy: 'network-first' | 'cache-first';
-    _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;
-    _broadcastChannel: any;
-    _reconnectAttempts: number;
-    _reconnectTimer: any;
-    constructor(config: NexaConfig);
-    _initCrossTabSync(): void;
-    _broadcastLocalMutation(docPath: string, action: 'set' | 'update' | 'patch' | 'delete' | 'bulk_update', data?: any): void;
-    connectRealtime(): EventSource;
-    _notifySnapshotCallbacks(docPath: string, eventType: string, data?: any): void;
-    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;
-        refFromURL: (url: 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 NexaBase: {
-    init: (config: NexaConfig) => NexaApp;
-    initializeApp: (config: NexaConfig) => NexaApp;
-};
-export declare const initializeApp: (config: NexaConfig) => NexaApp;
-export declare const getFirestore: (app: NexaApp) => NexaApp;
-export declare const collection: <T = any>(db: NexaApp, collectionPath: string) => CollectionReference<T>;
-export declare const doc: <T = any>(dbOrCollection: NexaApp | CollectionReference<any>, ...pathSegments: string[]) => DocumentReference<T>;
-export declare const query: <T = any>(queryObject: Query<T> | CollectionReference<T>, ...queryConstraints: QueryConstraint[]) => Query<T>;
-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, options?: {
-    idempotencyKey?: string;
-}) => Promise<any>;
-export declare const patchDoc: (docRef: DocumentReference, data: any, options?: {
-    idempotencyKey?: string;
-}) => Promise<any>;
-export declare const updateDoc: (docRef: DocumentReference, data: any, options?: {
-    idempotencyKey?: string;
-}) => Promise<any>;
-export declare const deleteDoc: (docRef: DocumentReference, options?: {
-    idempotencyKey?: string;
-}) => 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 interface Transaction {
-    get: <T = any>(docRef: DocumentReference<T>) => Promise<DocumentSnapshot<T>>;
-    set: (docRef: DocumentReference, data: any) => Transaction;
-    update: (docRef: DocumentReference, data: any) => Transaction;
-    patch: (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 {};
+export * from './app/initializeApp';
+export * from './app/NexaApp';
+export * from './auth/Auth';
+export * from './auth/authTypes';
+export * from './auth/persistence';
+export * from './firestore/Firestore';
+export * from './firestore/DocumentReference';
+export * from './firestore/CollectionReference';
+export * from './firestore/Query';
+export * from './firestore/Snapshot';
+export * from './firestore/queryConstraints';
+export * from './firestore/writes';
+export * from './firestore/batch';
+export * from './firestore/transaction';
+export * from './firestore/Timestamp';
+export * from './firestore/GeoPoint';
+export * from './firestore/FieldPath';
+export * from './firestore/FieldValue';
+export * from './firestore/SnapshotManager';
+export * from './realtime/RealtimeDatabase';
+export * from './realtime/RealtimeConnection';
+export * from './storage/Storage';
+export * from './storage/StorageReference';
+export * from './storage/UploadTask';
+export * from './persistence/IndexedDB';
+export * from './persistence/LocalStore';
+export * from './persistence/MutationQueue';
+export * from './sync/SyncEngine';
+export * from './sync/ConflictResolver';
+export * from './transport/HttpClient';
+export * from './transport/SSEClient';
+export * from './errors/NexaError';
+export * from './types/index';
+export * from './utils/helpers';