nexabase-console 1.1.4 → 2.0.0

package/dist/transport/HttpClient.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class HttpClient {
+    constructor(endpoint, getTokenFn) {
+        this.getToken = getTokenFn;
+        this.client = axios_1.default.create({
+            baseURL: endpoint,
+            timeout: 6000
+        });
+        this.client.interceptors.request.use((req) => {
+            const activeToken = this.getToken();
+            if (activeToken) {
+                req.headers.Authorization = `Bearer ${activeToken}`;
+                req.headers['x-api-key'] = activeToken;
+            }
+            if (typeof FormData !== 'undefined' && req.data instanceof FormData) {
+                if (req.headers) {
+                    delete req.headers['Content-Type'];
+                    delete req.headers['content-type'];
+                }
+            }
+            else {
+                if (req.data && req.headers && !req.headers['Content-Type'] && !req.headers['content-type']) {
+                    req.headers['Content-Type'] = 'application/json';
+                }
+            }
+            return req;
+        });
+    }
+    getAxiosInstance() {
+        return this.client;
+    }
+    setBaseURL(url) {
+        this.client.defaults.baseURL = url;
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/transport/SSEClient.d.ts

@@ -0,0 +1,15 @@
+export declare class SSEClient {
+    private projectId;
+    private sseUrl;
+    private sse;
+    private isListening;
+    private listeners;
+    constructor(projectId: string, sseUrl: string);
+    addListener(event: string, callback: (data: any) => void): () => void;
+    ensureConnected(): void;
+    checkCloseConnection(): void;
+    hasListeners(): boolean;
+    dispatch(event: string, data: any): void;
+    close(): void;
+}
+export { SSEClient as SSEManager };

package/dist/transport/SSEClient.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEManager = exports.SSEClient = void 0;
+class SSEClient {
+    constructor(projectId, sseUrl) {
+        this.sse = null;
+        this.isListening = false;
+        this.listeners = new Map();
+        this.projectId = projectId;
+        this.sseUrl = sseUrl;
+    }
+    addListener(event, callback) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(callback);
+        this.ensureConnected();
+        return () => {
+            const callbacks = this.listeners.get(event);
+            if (callbacks) {
+                callbacks.delete(callback);
+                if (callbacks.size === 0) {
+                    this.listeners.delete(event);
+                }
+            }
+            this.checkCloseConnection();
+        };
+    }
+    ensureConnected() {
+        if (this.isListening || typeof window === 'undefined')
+            return;
+        this.isListening = true;
+        this.sse = new EventSource(`${this.sseUrl}/api/firestore/${this.projectId}/sse`);
+        this.sse.onopen = () => {
+            this.dispatch('open', null);
+        };
+        this.sse.onmessage = (event) => {
+            try {
+                const payload = JSON.parse(event.data);
+                this.dispatch(payload.event || 'message', payload.data || payload);
+                this.dispatch('all', payload);
+            }
+            catch (e) {
+                console.error('[SSEClient] Error parsing SSE payload:', e);
+            }
+        };
+        this.sse.onerror = (err) => {
+            this.dispatch('error', err);
+            if (this.sse) {
+                this.sse.close();
+                this.sse = null;
+            }
+            this.isListening = false;
+            if (this.hasListeners()) {
+                setTimeout(() => this.ensureConnected(), 3000);
+            }
+        };
+    }
+    checkCloseConnection() {
+        if (!this.hasListeners() && this.sse) {
+            this.sse.close();
+            this.sse = null;
+            this.isListening = false;
+        }
+    }
+    hasListeners() {
+        let count = 0;
+        this.listeners.forEach((set) => {
+            count += set.size;
+        });
+        return count > 0;
+    }
+    dispatch(event, data) {
+        const callbacks = this.listeners.get(event);
+        if (callbacks) {
+            callbacks.forEach((cb) => {
+                try {
+                    cb(data);
+                }
+                catch (e) {
+                    console.error(`[SSEClient] Error in listener for event ${event}:`, e);
+                }
+            });
+        }
+    }
+    close() {
+        if (this.sse) {
+            this.sse.close();
+            this.sse = null;
+        }
+        this.isListening = false;
+        this.listeners.clear();
+    }
+}
+exports.SSEClient = SSEClient;
+exports.SSEManager = SSEClient;

package/dist/types/index.d.ts

@@ -0,0 +1,150 @@
+import type { NexaApp } from '../app/NexaApp';
+import type { FieldPath } from '../firestore/FieldPath';
+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;
+    createdAt?: string;
+    [key: string]: any;
+}
+export interface AuthResponse {
+    token: string;
+    user: User;
+    expiresIn?: number;
+}
+export type WhereFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'array-contains' | 'array-contains-any' | 'in' | 'not-in';
+export interface QueryConstraint {
+    type: 'where' | 'orderBy' | 'limit' | 'startAt' | 'startAfter' | 'endAt' | 'endBefore';
+    fieldPath?: string | FieldPath;
+    opStr?: WhereFilterOp | string;
+    value?: any;
+    directionStr?: 'asc' | 'desc';
+    limitValue?: number;
+    docSnapshot?: any;
+}
+export interface SnapshotMetadata {
+    readonly hasPendingWrites: boolean;
+    readonly fromCache: boolean;
+}
+export interface DocumentChange<T = any> {
+    type: 'added' | 'modified' | 'removed';
+    doc: QueryDocumentSnapshot<T>;
+    oldIndex: number;
+    newIndex: 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 SnapshotOptions {
+    serverTimestamps?: 'estimate' | 'previous' | 'none';
+}
+export interface DocumentSnapshot<T = any> {
+    id: string;
+    ref: DocumentReference<T>;
+    metadata: SnapshotMetadata;
+    exists: () => boolean;
+    data: (options?: SnapshotOptions) => T | null;
+    get: (fieldPath: string | FieldPath) => any;
+}
+export interface QueryDocumentSnapshot<T = any> {
+    id: string;
+    ref: DocumentReference<T>;
+    metadata: SnapshotMetadata;
+    exists: () => boolean;
+    data: (options?: SnapshotOptions) => T;
+    get: (fieldPath: string | FieldPath) => any;
+}
+export interface QuerySnapshot<T = any> {
+    docs: QueryDocumentSnapshot<T>[];
+    forEach: (callback: (doc: QueryDocumentSnapshot<T>) => void) => void;
+    empty: boolean;
+    size: number;
+    metadata: SnapshotMetadata;
+    docChanges: () => DocumentChange<T>[];
+}
+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;
+    onValue?: (callback: (data: any) => void) => () => void;
+}
+export interface UploadOptions {
+    contextType?: 'chat' | 'public_post';
+    contextId?: string;
+    fileId?: string;
+    onProgress?: (percent: number) => void;
+}
+export interface StorageReference {
+    path?: string;
+    name?: string;
+    fullPath?: string;
+    upload?: (file: File | Blob, options?: UploadOptions) => Promise<{
+        url: string;
+        path: string;
+    }>;
+    getDownloadURL?: () => Promise<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>;
+}
+export interface OfflineJob {
+    id: string;
+    type: 'set' | 'update' | 'patch' | 'delete';
+    path: string;
+    data?: any;
+    idempotencyKey?: string;
+    timestamp?: number;
+    merge?: boolean;
+    state?: 'pending' | 'acknowledged' | 'rejected';
+    retryCount?: number;
+    lastError?: string;
+}
+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;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/helpers.d.ts

@@ -0,0 +1,7 @@
+import { FieldPath } from '../firestore/FieldPath';
+import { DocumentChange } from '../types/index';
+export declare function getNestedValue(obj: any, path: string | FieldPath, docId?: string): any;
+export declare function deepEqual(a: any, b: any): boolean;
+export declare function applyDataTransforms(existingData: any, updateData: any): any;
+export declare function calculateDocChanges(oldDocs: any[], newDocs: any[]): DocumentChange[];
+export declare function generateIdempotencyKey(): string;

package/dist/utils/helpers.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNestedValue = getNestedValue;
+exports.deepEqual = deepEqual;
+exports.applyDataTransforms = applyDataTransforms;
+exports.calculateDocChanges = calculateDocChanges;
+exports.generateIdempotencyKey = generateIdempotencyKey;
+const Timestamp_1 = require("../firestore/Timestamp");
+function getNestedValue(obj, path, docId) {
+    if (!obj || !path)
+        return undefined;
+    const pathStr = typeof path === 'string' ? path : path.getPathString();
+    if (pathStr === '__name__') {
+        return docId || obj.id || obj.__name__;
+    }
+    return pathStr.split('.').reduce((prev, curr) => (prev ? prev[curr] : undefined), obj);
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null)
+        return false;
+    if (typeof a.isEqual === 'function') {
+        return a.isEqual(b);
+    }
+    if (typeof b.isEqual === 'function') {
+        return b.isEqual(a);
+    }
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(b, key) || !deepEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+function applyDataTransforms(existingData, updateData) {
+    const result = { ...existingData };
+    const processNode = (obj, keyPath, value) => {
+        const current = keyPath[0];
+        if (keyPath.length === 1) {
+            if (value && typeof value === 'object' && value._isFieldValue) {
+                const fv = value;
+                if (fv.method === 'serverTimestamp') {
+                    obj[current] = Timestamp_1.Timestamp.now();
+                }
+                else if (fv.method === 'increment') {
+                    obj[current] = (typeof obj[current] === 'number' ? obj[current] : 0) + (fv.value || 1);
+                }
+                else if (fv.method === 'arrayUnion') {
+                    const arr = Array.isArray(obj[current]) ? obj[current] : [];
+                    obj[current] = [...new Set([...arr, ...(fv.value || [])])];
+                }
+                else if (fv.method === 'arrayRemove') {
+                    const arr = Array.isArray(obj[current]) ? obj[current] : [];
+                    const toRemove = new Set(fv.value || []);
+                    obj[current] = arr.filter((x) => !toRemove.has(x));
+                }
+                else if (fv.method === 'deleteField') {
+                    delete obj[current];
+                }
+            }
+            else if (value && typeof value === 'object' && !Array.isArray(value) && typeof value.isEqual !== 'function') {
+                if (!obj[current] || typeof obj[current] !== 'object')
+                    obj[current] = {};
+                for (const [k, v] of Object.entries(value)) {
+                    processNode(obj[current], [k], v);
+                }
+            }
+            else {
+                obj[current] = value;
+            }
+        }
+        else {
+            if (!obj[current] || typeof obj[current] !== 'object')
+                obj[current] = {};
+            processNode(obj[current], keyPath.slice(1), value);
+        }
+    };
+    for (const [key, val] of Object.entries(updateData)) {
+        processNode(result, key.split('.'), val);
+    }
+    return result;
+}
+function calculateDocChanges(oldDocs, newDocs) {
+    const changes = [];
+    const oldMap = new Map(oldDocs.map(d => [d.id, d]));
+    const newMap = new Map(newDocs.map(d => [d.id, d]));
+    oldDocs.forEach((oldDoc, oldIndex) => {
+        if (!newMap.has(oldDoc.id)) {
+            changes.push({ type: 'removed', doc: oldDoc.doc, oldIndex, newIndex: -1 });
+        }
+    });
+    newDocs.forEach((newDoc, newIndex) => {
+        const oldDoc = oldMap.get(newDoc.id);
+        if (!oldDoc) {
+            changes.push({ type: 'added', doc: newDoc.doc, oldIndex: -1, newIndex });
+        }
+        else {
+            if (!deepEqual(oldDoc.data, newDoc.data)) {
+                const oldIndex = oldDocs.findIndex(d => d.id === oldDoc.id);
+                changes.push({ type: 'modified', doc: newDoc.doc, oldIndex, newIndex });
+            }
+        }
+    });
+    return changes;
+}
+function generateIdempotencyKey() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return `nexa_idemp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}_${Math.floor(Math.random() * 1000000)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "1.1.4",
+  "version": "2.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",