nexabase-console 1.1.4 → 2.0.0

package/dist/firestore/FieldValue.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteField = exports.arrayRemove = exports.arrayUnion = exports.increment = exports.serverTimestamp = exports.FieldValue = void 0;
+class FieldValue {
+    constructor(method, value) {
+        this.method = method;
+        this.value = value;
+        this._isFieldValue = true;
+    }
+}
+exports.FieldValue = FieldValue;
+const serverTimestamp = () => new FieldValue('serverTimestamp');
+exports.serverTimestamp = serverTimestamp;
+const increment = (n) => new FieldValue('increment', n);
+exports.increment = increment;
+const arrayUnion = (...elements) => new FieldValue('arrayUnion', elements);
+exports.arrayUnion = arrayUnion;
+const arrayRemove = (...elements) => new FieldValue('arrayRemove', elements);
+exports.arrayRemove = arrayRemove;
+const deleteField = () => new FieldValue('deleteField');
+exports.deleteField = deleteField;

package/dist/firestore/Firestore.d.ts

@@ -0,0 +1,8 @@
+import { NexaApp } from '../app/NexaApp';
+export declare class Firestore {
+    private app;
+    constructor(app: NexaApp);
+    getApp(): NexaApp;
+}
+export declare const enableIndexedDbPersistence: (db: NexaApp) => Promise<void>;
+export declare const enableOfflinePersistence: (db: NexaApp) => Promise<void>;

package/dist/firestore/Firestore.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableOfflinePersistence = exports.enableIndexedDbPersistence = exports.Firestore = void 0;
+class Firestore {
+    constructor(app) {
+        this.app = app;
+    }
+    getApp() {
+        return this.app;
+    }
+}
+exports.Firestore = Firestore;
+const enableIndexedDbPersistence = async (db) => {
+    db.enablePersistence = true;
+    if (db._initPromise)
+        await db._initPromise;
+};
+exports.enableIndexedDbPersistence = enableIndexedDbPersistence;
+const enableOfflinePersistence = async (db) => {
+    db.enablePersistence = true;
+    if (db._initPromise)
+        await db._initPromise;
+};
+exports.enableOfflinePersistence = enableOfflinePersistence;

package/dist/firestore/GeoPoint.d.ts

@@ -0,0 +1,10 @@
+export declare class GeoPoint {
+    readonly latitude: number;
+    readonly longitude: number;
+    constructor(latitude: number, longitude: number);
+    isEqual(other: GeoPoint): boolean;
+    toJSON(): {
+        latitude: number;
+        longitude: number;
+    };
+}

package/dist/firestore/GeoPoint.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoPoint = void 0;
+class GeoPoint {
+    constructor(latitude, longitude) {
+        this.latitude = latitude;
+        this.longitude = longitude;
+        if (isNaN(latitude) || latitude < -90 || latitude > 90) {
+            throw new Error(`Latitude must be a number between -90 and 90, but got ${latitude}`);
+        }
+        if (isNaN(longitude) || longitude < -180 || longitude > 180) {
+            throw new Error(`Longitude must be a number between -180 and 180, but got ${longitude}`);
+        }
+    }
+    isEqual(other) {
+        return this.latitude === other.latitude && this.longitude === other.longitude;
+    }
+    toJSON() {
+        return { latitude: this.latitude, longitude: this.longitude };
+    }
+}
+exports.GeoPoint = GeoPoint;

package/dist/firestore/Query.d.ts

@@ -0,0 +1,4 @@
+import { CollectionReference, Query, QueryConstraint, QuerySnapshot } from '../types/index';
+export declare const query: <T = any>(queryObject: Query<T> | CollectionReference<T>, ...queryConstraints: QueryConstraint[]) => Query<T>;
+export declare const getCachedDocs: <T = any>(queryOrCollection: Query<T> | CollectionReference<T>) => QuerySnapshot<T>;
+export declare const getDocs: <T = any>(queryOrCollection: Query<T> | CollectionReference<T>) => Promise<QuerySnapshot<T>>;

package/dist/firestore/Query.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocs = exports.getCachedDocs = exports.query = void 0;
+const SnapshotManager_1 = require("./SnapshotManager");
+const DocumentReference_1 = require("./DocumentReference");
+const NexaError_1 = require("../errors/NexaError");
+const helpers_1 = require("../utils/helpers");
+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 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, DocumentReference_1.doc)(db, `${collectionPath}/${docId}`);
+            const cachedData = db._firestoreCache[p];
+            results.push({
+                id: docId,
+                ref: docRef,
+                metadata: { fromCache: true, hasPendingWrites: db.hasPendingWrites(docRef.path) },
+                exists: () => true,
+                data: () => cachedData,
+                get: (fieldPath) => (0, helpers_1.getNestedValue)(cachedData, fieldPath, docId)
+            });
+        }
+    });
+    let filtered = results;
+    let limitCount = undefined;
+    for (const c of constraints) {
+        if (c.type === 'where' && c.fieldPath && c.opStr) {
+            filtered = filtered.filter((docItem) => {
+                const val = (0, helpers_1.getNestedValue)(docItem.data(), c.fieldPath, docItem.id);
+                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) && c.value.some((v) => val.includes(v));
+                return true;
+            });
+        }
+        else if (c.type === 'orderBy' && c.fieldPath) {
+            filtered = [...filtered].sort((a, b) => {
+                const valA = (0, helpers_1.getNestedValue)(a.data(), c.fieldPath, a.id);
+                const valB = (0, helpers_1.getNestedValue)(b.data(), c.fieldPath, b.id);
+                if (valA < valB)
+                    return c.directionStr === 'desc' ? 1 : -1;
+                if (valA > valB)
+                    return c.directionStr === 'desc' ? -1 : 1;
+                return 0;
+            });
+        }
+    }
+    for (const c of constraints) {
+        if (['startAt', 'startAfter', 'endAt', 'endBefore'].includes(c.type)) {
+            const isSnapshot = c.docSnapshot && typeof c.docSnapshot === 'object' && 'id' in c.docSnapshot;
+            const cursorIndex = filtered.findIndex((d) => (isSnapshot ? d.id === c.docSnapshot.id : d.id === c.docSnapshot));
+            if (cursorIndex !== -1) {
+                if (c.type === 'startAt')
+                    filtered = filtered.slice(cursorIndex);
+                if (c.type === 'startAfter')
+                    filtered = filtered.slice(cursorIndex + 1);
+                if (c.type === 'endAt')
+                    filtered = filtered.slice(0, cursorIndex + 1);
+                if (c.type === 'endBefore')
+                    filtered = filtered.slice(0, cursorIndex);
+            }
+        }
+        else if (c.type === 'limit' && typeof c.limitValue === 'number') {
+            limitCount = c.limitValue;
+        }
+    }
+    if (limitCount !== undefined) {
+        filtered = filtered.slice(0, limitCount);
+    }
+    return SnapshotManager_1.SnapshotManager.createQuerySnapshot(filtered, true, db.hasPendingWrites(collectionPath));
+};
+exports.getCachedDocs = getCachedDocs;
+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 || [] : [];
+    if (db.cacheStrategy === 'cache-first') {
+        const cached = (0, exports.getCachedDocs)(queryOrCollection);
+        if (cached && !cached.empty) {
+            db.client
+                .post(`/api/firestore/${db.projectId}/query`, { collectionPath, constraints })
+                .then(async (res) => {
+                const docs = res.data.documents || [];
+                const serverIds = new Set(docs.map((d) => d.id));
+                for (const d of docs) {
+                    await db._setCache(`${collectionPath}/${d.id}`, d.fields);
+                }
+                for (const cachePath of Object.keys(db._firestoreCache)) {
+                    if (cachePath.startsWith(collectionPath + '/')) {
+                        const docId = cachePath.split('/').pop();
+                        if (docId && !serverIds.has(docId)) {
+                            await db._deleteCache(cachePath);
+                        }
+                    }
+                }
+                db._notifySnapshotCallbacks(collectionPath, 'bulk_update', null);
+            })
+                .catch(() => { });
+            return cached;
+        }
+    }
+    try {
+        const res = await db.client.post(`/api/firestore/${db.projectId}/query`, { collectionPath, constraints });
+        const docs = res.data.documents || [];
+        const serverIds = new Set(docs.map((d) => d.id));
+        for (const d of docs) {
+            await db._setCache(`${collectionPath}/${d.id}`, d.fields);
+        }
+        for (const cachePath of Object.keys(db._firestoreCache)) {
+            if (cachePath.startsWith(collectionPath + '/')) {
+                const docId = cachePath.split('/').pop();
+                if (docId && !serverIds.has(docId)) {
+                    await db._deleteCache(cachePath);
+                }
+            }
+        }
+        const docsArray = docs.map((d) => {
+            const docRef = (0, DocumentReference_1.doc)(db, `${collectionPath}/${d.id}`);
+            return {
+                id: d.id,
+                ref: docRef,
+                metadata: { fromCache: false, hasPendingWrites: db.hasPendingWrites(docRef.path) },
+                exists: () => true,
+                data: () => d.fields,
+                get: (fieldPath) => (0, helpers_1.getNestedValue)(d.fields, fieldPath, d.id)
+            };
+        });
+        return SnapshotManager_1.SnapshotManager.createQuerySnapshot(docsArray, false, db.hasPendingWrites(collectionPath));
+    }
+    catch (err) {
+        if (err && err.response && err.response.status < 500) {
+            throw (0, NexaError_1.toNexaError)(err);
+        }
+        return (0, exports.getCachedDocs)(queryOrCollection);
+    }
+};
+exports.getDocs = getDocs;

package/dist/firestore/Snapshot.d.ts

@@ -0,0 +1,6 @@
+import { SnapshotManager } from './SnapshotManager';
+import { CollectionReference, DocumentReference, Query, DocumentSnapshot } from '../types/index';
+export declare const getCachedDoc: <T = any>(docRef: DocumentReference<T>) => DocumentSnapshot<T>;
+export declare const getDoc: <T = any>(docRef: DocumentReference<T>) => Promise<DocumentSnapshot<T>>;
+export declare const onSnapshot: (ref: CollectionReference | DocumentReference | Query, callback: (snapshot: any) => void) => (() => void);
+export { SnapshotManager };

package/dist/firestore/Snapshot.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotManager = exports.onSnapshot = exports.getDoc = exports.getCachedDoc = void 0;
+const SnapshotManager_1 = require("./SnapshotManager");
+Object.defineProperty(exports, "SnapshotManager", { enumerable: true, get: function () { return SnapshotManager_1.SnapshotManager; } });
+const Query_1 = require("./Query");
+const NexaError_1 = require("../errors/NexaError");
+const helpers_1 = require("../utils/helpers");
+const getCachedDoc = (docRef) => {
+    const db = docRef.db;
+    const data = (db._firestoreCache[docRef.path] || null);
+    return SnapshotManager_1.SnapshotManager.createDocumentSnapshot(docRef, data, true, db.hasPendingWrites(docRef.path));
+};
+exports.getCachedDoc = getCachedDoc;
+const getDoc = async (docRef) => {
+    const db = docRef.db;
+    if (db._initPromise)
+        await db._initPromise;
+    if (db.cacheStrategy === 'cache-first') {
+        const cached = (0, exports.getCachedDoc)(docRef);
+        if (cached && cached.exists()) {
+            db.client
+                .get(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`)
+                .then(async (res) => {
+                const data = res.data.data;
+                await db._setCache(docRef.path, data);
+                db._notifySnapshotCallbacks(docRef.path, 'document_written', data);
+            })
+                .catch(() => { });
+            return cached;
+        }
+    }
+    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 SnapshotManager_1.SnapshotManager.createDocumentSnapshot(docRef, data, false, db.hasPendingWrites(docRef.path));
+    }
+    catch (err) {
+        if (err && err.response && err.response.status < 500) {
+            throw (0, NexaError_1.toNexaError)(err);
+        }
+        return (0, exports.getCachedDoc)(docRef);
+    }
+};
+exports.getDoc = getDoc;
+const onSnapshot = (ref, callback) => {
+    const db = ref.db;
+    let active = true;
+    const pathKey = ref.path;
+    const listenerId = Math.random().toString(36).substring(2, 9);
+    const keyToClean = `${ref.type}_${listenerId}_${pathKey}`;
+    let isInitial = true;
+    let lastData = undefined;
+    let lastDocsForChanges = [];
+    const triggerCallback = () => {
+        if (!active)
+            return;
+        try {
+            if (ref.type === 'collection' || ref.type === 'query') {
+                const cached = (0, Query_1.getCachedDocs)(ref);
+                const newData = cached.docs.map((d) => ({ id: d.id, data: d.data() }));
+                if (!(0, helpers_1.deepEqual)(newData, lastData)) {
+                    const currentDocsForChanges = cached.docs.map((d) => ({ id: d.id, data: d.data(), doc: d }));
+                    const snapshotWithChanges = SnapshotManager_1.SnapshotManager.createQuerySnapshot(cached.docs, true, db.hasPendingWrites(ref.path), lastDocsForChanges);
+                    lastDocsForChanges = currentDocsForChanges;
+                    callback(snapshotWithChanges);
+                    lastData = newData;
+                }
+            }
+            else {
+                const cached = (0, exports.getCachedDoc)(ref);
+                const newData = cached.exists() ? { id: cached.id, data: cached.data() } : null;
+                if (!(0, helpers_1.deepEqual)(newData, lastData)) {
+                    callback(cached);
+                    lastData = newData;
+                }
+            }
+        }
+        catch (e) { }
+    };
+    db._snapshotCallbacks[keyToClean] = triggerCallback;
+    triggerCallback();
+    db._ensureFirestoreSSE();
+    (async () => {
+        if (db._initPromise)
+            await db._initPromise;
+        if (!active)
+            return;
+        if (isInitial) {
+            isInitial = false;
+            try {
+                if (ref.type === 'collection' || ref.type === 'query') {
+                    const docs = await (0, Query_1.getDocs)(ref);
+                    const newData = docs.docs.map((d) => ({ id: d.id, data: d.data() }));
+                    if (!(0, helpers_1.deepEqual)(newData, lastData) && active) {
+                        const currentDocsForChanges = docs.docs.map((d) => ({ id: d.id, data: d.data(), doc: d }));
+                        const snapshotWithChanges = SnapshotManager_1.SnapshotManager.createQuerySnapshot(docs.docs, false, db.hasPendingWrites(ref.path), lastDocsForChanges);
+                        lastDocsForChanges = currentDocsForChanges;
+                        callback(snapshotWithChanges);
+                        lastData = newData;
+                    }
+                }
+                else {
+                    const docData = await (0, exports.getDoc)(ref);
+                    const newData = docData.exists() ? { id: docData.id, data: docData.data() } : null;
+                    if (!(0, helpers_1.deepEqual)(newData, lastData) && active) {
+                        callback(docData);
+                        lastData = newData;
+                    }
+                }
+            }
+            catch (e) { }
+        }
+    })();
+    return () => {
+        active = false;
+        if (keyToClean) {
+            delete db._snapshotCallbacks[keyToClean];
+            if (Object.keys(db._snapshotCallbacks).length === 0) {
+                db._closeFirestoreSSEIfIdle();
+            }
+        }
+    };
+};
+exports.onSnapshot = onSnapshot;

package/dist/firestore/SnapshotManager.d.ts

@@ -0,0 +1,9 @@
+import { DocumentReference, DocumentSnapshot, QueryDocumentSnapshot, QuerySnapshot } from '../types/index';
+export declare class SnapshotManager {
+    static createDocumentSnapshot<T = any>(docRef: DocumentReference<T>, data: T | null, fromCache: boolean, hasPendingWrites: boolean): DocumentSnapshot<T>;
+    static createQuerySnapshot<T = any>(docs: QueryDocumentSnapshot<T>[], fromCache: boolean, hasPendingWrites: boolean, previousDocs?: {
+        id: string;
+        data: any;
+        doc: QueryDocumentSnapshot<T>;
+    }[]): QuerySnapshot<T>;
+}

package/dist/firestore/SnapshotManager.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotManager = void 0;
+const helpers_1 = require("../utils/helpers");
+class SnapshotManager {
+    static createDocumentSnapshot(docRef, data, fromCache, hasPendingWrites) {
+        const segments = docRef.path.split('/');
+        const docId = segments[segments.length - 1];
+        return {
+            id: docId,
+            ref: docRef,
+            metadata: { fromCache, hasPendingWrites },
+            exists: () => data !== null && data !== undefined,
+            data: () => data,
+            get: (fieldPath) => (0, helpers_1.getNestedValue)(data, fieldPath, docId)
+        };
+    }
+    static createQuerySnapshot(docs, fromCache, hasPendingWrites, previousDocs) {
+        const currentDocsForChanges = docs.map((d) => ({
+            id: d.id,
+            data: d.data(),
+            doc: d
+        }));
+        const changes = previousDocs
+            ? (0, helpers_1.calculateDocChanges)(previousDocs, currentDocsForChanges)
+            : docs.map((d, i) => ({ type: 'added', doc: d, oldIndex: -1, newIndex: i }));
+        return {
+            docs,
+            forEach: (cb) => docs.forEach(cb),
+            empty: docs.length === 0,
+            size: docs.length,
+            metadata: { fromCache, hasPendingWrites },
+            docChanges: () => changes
+        };
+    }
+}
+exports.SnapshotManager = SnapshotManager;

package/dist/firestore/Timestamp.d.ts

@@ -0,0 +1,16 @@
+export declare class Timestamp {
+    readonly seconds: number;
+    readonly nanoseconds: number;
+    constructor(seconds: number, nanoseconds: number);
+    static now(): Timestamp;
+    static fromDate(date: Date): Timestamp;
+    static fromMillis(milliseconds: number): Timestamp;
+    toDate(): Date;
+    toMillis(): number;
+    isEqual(other: Timestamp): boolean;
+    toString(): string;
+    toJSON(): {
+        seconds: number;
+        nanoseconds: number;
+    };
+}

package/dist/firestore/Timestamp.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timestamp = void 0;
+class Timestamp {
+    constructor(seconds, nanoseconds) {
+        this.seconds = seconds;
+        this.nanoseconds = nanoseconds;
+    }
+    static now() {
+        return Timestamp.fromMillis(Date.now());
+    }
+    static fromDate(date) {
+        return Timestamp.fromMillis(date.getTime());
+    }
+    static fromMillis(milliseconds) {
+        const seconds = Math.floor(milliseconds / 1000);
+        const nanoseconds = Math.floor((milliseconds % 1000) * 1e6);
+        return new Timestamp(seconds, nanoseconds);
+    }
+    toDate() {
+        return new Date(this.toMillis());
+    }
+    toMillis() {
+        return this.seconds * 1000 + Math.floor(this.nanoseconds / 1e6);
+    }
+    isEqual(other) {
+        return this.seconds === other.seconds && this.nanoseconds === other.nanoseconds;
+    }
+    toString() {
+        return `Timestamp(seconds=${this.seconds}, nanoseconds=${this.nanoseconds})`;
+    }
+    toJSON() {
+        return { seconds: this.seconds, nanoseconds: this.nanoseconds };
+    }
+}
+exports.Timestamp = Timestamp;

package/dist/firestore/batch.d.ts

@@ -0,0 +1,3 @@
+import { NexaApp } from '../app/NexaApp';
+import { WriteBatch } from '../types/index';
+export declare const writeBatch: (db: NexaApp) => WriteBatch;

package/dist/firestore/batch.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeBatch = void 0;
+const helpers_1 = require("../utils/helpers");
+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;
+        },
+        patch: (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 idempotencyKey = (0, helpers_1.generateIdempotencyKey)();
+            const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+            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);
+                }
+            }
+            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,
+                        idempotencyKey,
+                        state: 'pending'
+                    });
+                }
+                return { success: true, message: 'Offline: Batch operations queued in IndexedDB' };
+            }
+            else {
+                try {
+                    return (await db.client.post(`/api/firestore/${db.projectId}/batch`, { operations, idempotencyKey }, { headers: { 'X-Idempotency-Key': idempotencyKey } })).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,
+                            idempotencyKey,
+                            state: 'pending'
+                        });
+                    }
+                    return { success: true, message: 'Koneksi terganggu: Tersimpan di antrean offline' };
+                }
+            }
+        }
+    };
+    return batchObj;
+};
+exports.writeBatch = writeBatch;

package/dist/firestore/queryConstraints.d.ts

@@ -0,0 +1,9 @@
+import { FieldPath } from './FieldPath';
+import { QueryConstraint, WhereFilterOp } from '../types/index';
+export declare const where: (fieldPath: string | FieldPath, opStr: WhereFilterOp | string, value: any) => QueryConstraint;
+export declare const orderBy: (fieldPath: string | FieldPath, directionStr?: "asc" | "desc") => QueryConstraint;
+export declare const limit: (limitValue: number) => QueryConstraint;
+export declare const startAt: (docSnapshot: any) => QueryConstraint;
+export declare const startAfter: (docSnapshot: any) => QueryConstraint;
+export declare const endAt: (docSnapshot: any) => QueryConstraint;
+export declare const endBefore: (docSnapshot: any) => QueryConstraint;

package/dist/firestore/queryConstraints.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endBefore = exports.endAt = exports.startAfter = exports.startAt = exports.limit = exports.orderBy = exports.where = void 0;
+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 startAt = (docSnapshot) => {
+    return { type: 'startAt', docSnapshot };
+};
+exports.startAt = startAt;
+const startAfter = (docSnapshot) => {
+    return { type: 'startAfter', docSnapshot };
+};
+exports.startAfter = startAfter;
+const endAt = (docSnapshot) => {
+    return { type: 'endAt', docSnapshot };
+};
+exports.endAt = endAt;
+const endBefore = (docSnapshot) => {
+    return { type: 'endBefore', docSnapshot };
+};
+exports.endBefore = endBefore;

package/dist/firestore/transaction.d.ts

@@ -0,0 +1,5 @@
+import { NexaApp } from '../app/NexaApp';
+import { Transaction } from '../types/index';
+export declare const runTransaction: <T = any>(db: NexaApp, updateFunction: (transaction: Transaction) => Promise<T>, options?: {
+    maxAttempts?: number;
+}) => Promise<T>;