nexabase-console 2.0.1 → 2.0.3

package/dist/facade/nexaSDK.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nexaSDK = exports.NexaSDKFacade = void 0;
+exports.createNexaSDK = createNexaSDK;
+const initializeApp_1 = require("../app/initializeApp");
+/**
+ * Universal NexaBase Client SDK Facade (Domain & Server-Authoritative Logic)
+ * Decouples client components & stores from raw primitives like getDocs/runTransaction.
+ */
+class NexaSDKFacade {
+    constructor(options) {
+        this.appInstance = null;
+        this.customBaseURL = '';
+        /* =========================================================================
+         * 1. PRODUCTS & INVENTORY DOMAIN
+         * ========================================================================= */
+        this.products = {
+            /**
+             * Atomically adjust product stock in server with audit log trail
+             */
+            adjustStock: async (params) => {
+                return this.call('adjustProductStock', params);
+            },
+            /**
+             * Quick stock deduction helper
+             */
+            deductStock: async (productId, qty, reason = 'sale') => {
+                return this.call('adjustProductStock', { productId, delta: -Math.abs(qty), reason });
+            },
+            /**
+             * Quick stock addition helper
+             */
+            addStock: async (productId, qty, reason = 'restock') => {
+                return this.call('adjustProductStock', { productId, delta: Math.abs(qty), reason });
+            }
+        };
+        /* =========================================================================
+         * 2. ORDERS & WAREHOUSE DOMAIN
+         * ========================================================================= */
+        this.orders = {
+            /**
+             * Scan tracking number (resi), update shipping status & auto-deduct stock atomically
+             */
+            scanResi: async (params) => {
+                return this.call('scanResiOrder', params);
+            },
+            /**
+             * Cancel an order & automatically return deducted stock to inventory
+             */
+            cancelOrder: async (params) => {
+                return this.call('cancelOrder', params);
+            }
+        };
+        /* =========================================================================
+         * 3. FINANCIAL & TRANSACTION DOMAIN
+         * ========================================================================= */
+        this.finance = {
+            /**
+             * Atomic balance transfer between users with ledger record
+             */
+            transferBalance: async (params) => {
+                return this.call('transferBalance', params);
+            }
+        };
+        /* =========================================================================
+         * 4. GENERAL PURPOSE UTILITIES
+         * ========================================================================= */
+        this.utils = {
+            /**
+             * Atomic field incrementer on any Firestore document
+             */
+            increment: async (params) => {
+                return this.call('incrementCounter', params);
+            }
+        };
+        if (options?.app)
+            this.appInstance = options.app;
+        if (options?.baseURL)
+            this.customBaseURL = options.baseURL;
+    }
+    getApp() {
+        if (this.appInstance)
+            return this.appInstance;
+        return (0, initializeApp_1.getApp)();
+    }
+    getBaseURL() {
+        if (this.customBaseURL)
+            return this.customBaseURL;
+        if (typeof window !== 'undefined')
+            return window.location.origin;
+        return 'http://localhost:3000';
+    }
+    /**
+     * Universal Server-Authoritative Cloud Function Caller
+     */
+    async call(functionName, data = {}) {
+        const app = this.getApp();
+        const projectId = app.options.projectId;
+        const apiKey = app.options.apiKey;
+        const url = `${this.getBaseURL()}/api/functions/${projectId}/${functionName}`;
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (apiKey) {
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(data)
+        });
+        const result = await response.json();
+        if (!response.ok || result.success === false) {
+            throw new Error(result.error || result.message || `Failed to execute function "${functionName}"`);
+        }
+        return result;
+    }
+}
+exports.NexaSDKFacade = NexaSDKFacade;
+/**
+ * Singleton Default Facade Export
+ */
+exports.nexaSDK = new NexaSDKFacade();
+/**
+ * Factory function to create custom facade instance with specific NexaApp
+ */
+function createNexaSDK(app, options) {
+    return new NexaSDKFacade({ app, baseURL: options?.baseURL });
+}

package/dist/firestore/Query.d.ts

@@ -1,4 +1,12 @@
-import { CollectionReference, Query, QueryConstraint, QuerySnapshot } from '../types/index';
+import { FieldPath } from './FieldPath';
+import { CollectionReference, Query, QueryConstraint, QuerySnapshot, AggregateField, AggregateSpec, AggregateSpecData, AggregateQuerySnapshot } 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>>;
+export declare const count: () => AggregateField<number>;
+export declare const sum: (field: string | FieldPath) => AggregateField<number>;
+export declare const average: (field: string | FieldPath) => AggregateField<number | null>;
+export declare const getAggregateFromServer: <T extends AggregateSpec>(queryOrCollection: Query<any> | CollectionReference<any>, aggregateSpec: T) => Promise<AggregateQuerySnapshot<AggregateSpecData<T>>>;
+export declare const getCountFromServer: <T = any>(queryOrCollection: Query<T> | CollectionReference<T>) => Promise<AggregateQuerySnapshot<{
+    count: number;
+}>>;

package/dist/firestore/Query.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDocs = exports.getCachedDocs = exports.query = void 0;
+exports.getCountFromServer = exports.getAggregateFromServer = exports.average = exports.sum = exports.count = exports.getDocs = exports.getCachedDocs = exports.query = void 0;
 const SnapshotManager_1 = require("./SnapshotManager");
 const DocumentReference_1 = require("./DocumentReference");
 const NexaError_1 = require("../errors/NexaError");
@@ -174,3 +174,64 @@ const getDocs = async (queryOrCollection) => {
     }
 };
 exports.getDocs = getDocs;
+const count = () => {
+    return { type: 'count' };
+};
+exports.count = count;
+const sum = (field) => {
+    return { type: 'sum', fieldPath: field };
+};
+exports.sum = sum;
+const average = (field) => {
+    return { type: 'average', fieldPath: field };
+};
+exports.average = average;
+const getAggregateFromServer = async (queryOrCollection, aggregateSpec) => {
+    const querySnapshot = await (0, exports.getDocs)(queryOrCollection);
+    const docs = querySnapshot.docs;
+    const resultData = {};
+    for (const [key, spec] of Object.entries(aggregateSpec)) {
+        if (spec.type === 'count') {
+            resultData[key] = docs.length;
+        }
+        else if (spec.type === 'sum') {
+            const field = spec.fieldPath || '';
+            let sumVal = 0;
+            for (const d of docs) {
+                const val = (0, helpers_1.getNestedValue)(d.data(), field, d.id);
+                if (typeof val === 'number' && !isNaN(val)) {
+                    sumVal += val;
+                }
+            }
+            resultData[key] = sumVal;
+        }
+        else if (spec.type === 'average') {
+            const field = spec.fieldPath || '';
+            let sumVal = 0;
+            let countVal = 0;
+            for (const d of docs) {
+                const val = (0, helpers_1.getNestedValue)(d.data(), field, d.id);
+                if (typeof val === 'number' && !isNaN(val)) {
+                    sumVal += val;
+                    countVal++;
+                }
+            }
+            resultData[key] = countVal > 0 ? sumVal / countVal : null;
+        }
+    }
+    return {
+        type: 'AggregateQuerySnapshot',
+        query: queryOrCollection,
+        data: () => resultData
+    };
+};
+exports.getAggregateFromServer = getAggregateFromServer;
+const getCountFromServer = async (queryOrCollection) => {
+    const querySnapshot = await (0, exports.getDocs)(queryOrCollection);
+    return {
+        type: 'AggregateQuerySnapshot',
+        query: queryOrCollection,
+        data: () => ({ count: querySnapshot.docs.length })
+    };
+};
+exports.getCountFromServer = getCountFromServer;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './app/NexaApp';
 export * from './auth/Auth';
 export * from './auth/authTypes';
 export * from './auth/persistence';
+export * from './auth/NexaAuthError';
 export * from './firestore/Firestore';
 export * from './firestore/DocumentReference';
 export * from './firestore/CollectionReference';

package/dist/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./app/NexaApp"), exports);
 __exportStar(require("./auth/Auth"), exports);
 __exportStar(require("./auth/authTypes"), exports);
 __exportStar(require("./auth/persistence"), exports);
+__exportStar(require("./auth/NexaAuthError"), exports);
 // Firestore
 __exportStar(require("./firestore/Firestore"), exports);
 __exportStar(require("./firestore/DocumentReference"), exports);

package/dist/storage/Storage.d.ts

@@ -9,4 +9,9 @@ export declare class Storage {
         path: string;
     }>;
     getDownloadURL(path: string): Promise<string>;
+    deleteFile(path: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
 }
+export declare const getStorage: (app: any) => Storage;

package/dist/storage/Storage.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Storage = void 0;
+exports.getStorage = exports.Storage = void 0;
 const UploadTask_1 = require("./UploadTask");
 const NexaError_1 = require("../errors/NexaError");
 class Storage {
@@ -37,5 +37,21 @@ class Storage {
             throw (0, NexaError_1.toNexaError)(err);
         }
     }
+    async deleteFile(path) {
+        try {
+            const res = await this.client.delete(`/api/project/${this.projectId}/storage/file?path=${encodeURIComponent(path)}`);
+            return res.data;
+        }
+        catch (err) {
+            throw (0, NexaError_1.toNexaError)(err);
+        }
+    }
 }
 exports.Storage = Storage;
+const getStorage = (app) => {
+    if (app && typeof app.storage === 'function') {
+        return app.storage();
+    }
+    throw new Error('Invalid NexaApp instance provided to getStorage()');
+};
+exports.getStorage = getStorage;

package/dist/storage/StorageReference.d.ts

@@ -9,5 +9,23 @@ export declare class StorageReferenceImpl implements IStorageReference {
         path: string;
     }>;
     getDownloadURL(): Promise<string>;
+    delete(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
 }
 export declare const storageRef: (storage: Storage, path: string) => IStorageReference;
+export declare const ref: (storage: Storage, path: string) => IStorageReference;
+export declare const uploadBytes: (storageRef: IStorageReference, file: File | Blob, options?: UploadOptions) => Promise<{
+    url: string;
+    path: string;
+}>;
+export declare const uploadBytesResumable: (storageRef: IStorageReference, file: File | Blob, options?: UploadOptions) => Promise<{
+    url: string;
+    path: string;
+}>;
+export declare const getDownloadURL: (storageRef: IStorageReference) => Promise<string>;
+export declare const deleteObject: (storageRef: IStorageReference) => Promise<{
+    success: boolean;
+    message?: string;
+}>;

package/dist/storage/StorageReference.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.storageRef = exports.StorageReferenceImpl = void 0;
+exports.deleteObject = exports.getDownloadURL = exports.uploadBytesResumable = exports.uploadBytes = exports.ref = exports.storageRef = exports.StorageReferenceImpl = void 0;
 class StorageReferenceImpl {
     constructor(path, storage) {
         this.path = path;
@@ -12,9 +12,41 @@ class StorageReferenceImpl {
     async getDownloadURL() {
         return this.storage.getDownloadURL(this.path);
     }
+    async delete() {
+        return this.storage.deleteFile(this.path);
+    }
 }
 exports.StorageReferenceImpl = StorageReferenceImpl;
 const storageRef = (storage, path) => {
     return new StorageReferenceImpl(path, storage);
 };
 exports.storageRef = storageRef;
+const ref = (storage, path) => {
+    return new StorageReferenceImpl(path, storage);
+};
+exports.ref = ref;
+const uploadBytes = async (storageRef, file, options) => {
+    if (storageRef.upload) {
+        return storageRef.upload(file, options);
+    }
+    throw new Error('Invalid storage reference');
+};
+exports.uploadBytes = uploadBytes;
+const uploadBytesResumable = (storageRef, file, options) => {
+    return (0, exports.uploadBytes)(storageRef, file, options);
+};
+exports.uploadBytesResumable = uploadBytesResumable;
+const getDownloadURL = async (storageRef) => {
+    if (storageRef.getDownloadURL) {
+        return storageRef.getDownloadURL();
+    }
+    throw new Error('Invalid storage reference');
+};
+exports.getDownloadURL = getDownloadURL;
+const deleteObject = async (storageRef) => {
+    if (storageRef.delete) {
+        return storageRef.delete();
+    }
+    throw new Error('Invalid storage reference');
+};
+exports.deleteObject = deleteObject;

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import type { NexaApp } from '../app/NexaApp';
 import type { FieldPath } from '../firestore/FieldPath';
+import type { User } from '../auth/authTypes';
 export interface NexaConfig {
     projectId: string;
     apiKey?: string;
@@ -7,14 +8,6 @@ export interface NexaConfig {
     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;
@@ -84,6 +77,22 @@ export interface QuerySnapshot<T = any> {
     metadata: SnapshotMetadata;
     docChanges: () => DocumentChange<T>[];
 }
+export interface AggregateField<T = number> {
+    type: 'count' | 'sum' | 'average';
+    fieldPath?: string | FieldPath;
+    _returnType?: T;
+}
+export type AggregateSpec = Record<string, AggregateField<any>>;
+export type AggregateSpecData<T extends AggregateSpec> = {
+    [K in keyof T]: T[K] extends AggregateField<infer R> ? R : number;
+};
+export interface AggregateQuerySnapshot<T extends Record<string, any> = {
+    count: number;
+}> {
+    type: 'AggregateQuerySnapshot';
+    query: Query<any> | CollectionReference<any>;
+    data: () => T;
+}
 export interface DatabaseReference {
     path: string;
     get: () => Promise<any>;

package/package.json

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