nexabase-console 2.0.2 → 2.0.3

package/README.md

@@ -142,6 +142,40 @@ const listenLiveChats = () => {
 };
 ```
 
+#### Agregasi Data & Hitung Dokumen (`getCountFromServer` / `getAggregateFromServer`)
+Mendukung fungsi agregasi server 1:1 seperti Firebase SDK: `getCountFromServer()`, `getAggregateFromServer()`, `count()`, `sum()`, dan `average()`.
+
+```javascript
+import { 
+  collection, 
+  query, 
+  where, 
+  getCountFromServer, 
+  getAggregateFromServer, 
+  count, 
+  sum, 
+  average 
+} from 'nexabase-console';
+
+// 1. Menghitung total dokumen (getCountFromServer)
+const productsRef = collection(db, 'products');
+const qAvailable = query(productsRef, where('status', '==', 'active'));
+
+const countSnapshot = await getCountFromServer(qAvailable);
+console.log("Total produk aktif:", countSnapshot.data().count);
+
+// 2. Agregasi multi-field (getAggregateFromServer)
+const orderStats = await getAggregateFromServer(collection(db, 'orders'), {
+  totalOrders: count(),
+  totalRevenue: sum('totalAmount'),
+  avgOrderValue: average('totalAmount')
+});
+
+console.log("Jumlah order:", orderStats.data().totalOrders);
+console.log("Total pendapatan:", orderStats.data().totalRevenue);
+console.log("Rata-rata transaksi:", orderStats.data().avgOrderValue);
+```
+
 #### Menggunakan Atomic Write Batch (Untuk Upload File / Excel Massal)
 Jika Anda mengunggah data sekaligus dalam jumlah besar dari file (misal: import 500 resi dari Excel), hindari memanggil `setDoc` satu per satu di dalam _looping_. Gunakan fitur `writeBatch` yang membundel seluruh operasi Anda dalam satu pengiriman jaringan (hingga 500 operasi per eksekusi).
 

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/types/index.d.ts

@@ -77,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.2",
+  "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",