@tspvivek/baasix-sdk 0.1.0-alpha.2 → 0.1.0-alpha.4

package/README.md

@@ -507,27 +507,111 @@ await baasix.schemas.createIndex('products', {
 
 ## Reports & Analytics
 
+### Generate Report (POST)
+
+Use `generate()` to create a report with a POST request, sending the query in the request body:
+
 ```typescript
-// Generate report
 const report = await baasix.reports.generate('orders', {
   aggregate: {
     revenue: { function: 'sum', field: 'total' },
     orders: { function: 'count', field: 'id' },
   },
-  groupBy: 'category',
+  groupBy: ['category'],
   filter: { status: { eq: 'completed' } },
   dateRange: {
     start: '2025-01-01',
     end: '2025-12-31',
   },
 });
+```
 
-// Quick count
+### Query Report (GET)
+
+Use `query()` to fetch a report with a GET request, sending parameters as query strings:
+
+```typescript
+const report = await baasix.reports.query('orders', {
+  aggregate: {
+    total: { function: 'sum', field: 'amount' },
+  },
+  groupBy: ['status'],
+  filter: { createdAt: { gte: '$NOW-DAYS_30' } },
+});
+```
+
+### Multi-Collection Stats
+
+Get statistics for multiple collections in a single request:
+
+```typescript
+const stats = await baasix.reports.getStats([
+  {
+    name: 'total_products',
+    collection: 'products',
+    query: {
+      aggregate: { count: { function: 'count', field: '*' } },
+    },
+  },
+  {
+    name: 'total_orders',
+    collection: 'orders',
+    query: {
+      aggregate: {
+        count: { function: 'count', field: '*' },
+        total_amount: { function: 'sum', field: 'amount' },
+      },
+    },
+  },
+  {
+    name: 'products_by_category',
+    collection: 'products',
+    query: {
+      groupBy: ['categoryId'],
+      aggregate: {
+        count: { function: 'count', field: 'id' },
+        avg_price: { function: 'avg', field: 'price' },
+      },
+      fields: ['categoryId', 'category.name'],
+    },
+  },
+]);
+// Returns: [{ name: 'total_products', collection: 'products', data: [...] }, ...]
+```
+
+### Aggregation Query
+
+Run aggregation queries directly on a collection (uses items endpoint):
+
+```typescript
+const results = await baasix.reports.aggregate('orders', {
+  aggregate: {
+    total: { function: 'sum', field: 'amount' },
+    count: { function: 'count', field: 'id' },
+    min: { function: 'min', field: 'amount' },
+    max: { function: 'max', field: 'amount' },
+    avg: { function: 'avg', field: 'amount' },
+  },
+  groupBy: ['status', 'paymentMethod'],
+  filter: { createdAt: { gte: '$NOW-DAYS_30' } },
+});
+```
+
+### Quick Count
+
+```typescript
 const activeUsers = await baasix.reports.count('users', {
   status: { eq: 'active' },
 });
 ```
 
+### Distinct Values
+
+```typescript
+const categories = await baasix.reports.distinct('products', 'category');
+// Returns: ['Electronics', 'Clothing', 'Books', ...]
+```
+
 ## Workflows
 
 ```typescript

package/dist/index.cjs

@@ -1976,6 +1976,35 @@ var FilesModule = class {
   }
 };
 
+// src/utils/sort.ts
+function normalizeSort(sort) {
+  if (!sort) return void 0;
+  if (typeof sort === "string") {
+    return sort;
+  }
+  if (Array.isArray(sort)) {
+    if (sort.length === 0) return void 0;
+    if (typeof sort[0] === "object" && "column" in sort[0]) {
+      return sort.map((s) => `${s.column}:${s.order.toLowerCase()}`).join(",");
+    }
+    return sort.map((s) => {
+      if (s.startsWith("-")) {
+        return `${s.substring(1)}:desc`;
+      }
+      if (s.includes(":")) {
+        return s;
+      }
+      return `${s}:asc`;
+    }).join(",");
+  }
+  if (typeof sort === "object") {
+    const entries = Object.entries(sort);
+    if (entries.length === 0) return void 0;
+    return entries.map(([field, direction]) => `${field}:${direction.toLowerCase()}`).join(",");
+  }
+  return void 0;
+}
+
 // src/modules/schemas.ts
 var SchemasModule = class {
   client;
@@ -1995,7 +2024,11 @@ var SchemasModule = class {
    * ```
    */
   async find(params) {
-    return this.client.get("/schemas", { params });
+    const normalizedParams = params ? {
+      ...params,
+      sort: normalizeSort(params.sort)
+    } : void 0;
+    return this.client.get("/schemas", { params: normalizedParams });
   }
   /**
    * Get schema for a specific collection
@@ -2617,7 +2650,7 @@ var ReportsModule = class {
     this.client = config.client;
   }
   /**
-   * Generate a report for a collection
+   * Generate a report for a collection using POST method
    *
    * @example
    * ```typescript
@@ -2627,7 +2660,7 @@ var ReportsModule = class {
    *     revenue: { function: 'sum', field: 'total' },
    *     orders: { function: 'count', field: 'id' }
    *   },
-   *   groupBy: 'month',
+   *   groupBy: ['month'],
    *   dateRange: {
    *     start: '2025-01-01',
    *     end: '2025-12-31'
@@ -2643,19 +2676,56 @@ var ReportsModule = class {
     return response;
   }
   /**
-   * Get collection statistics
+   * Query a report for a collection using GET method with query params
    *
    * @example
    * ```typescript
-   * const stats = await baasix.reports.getStats('products');
-   * console.log(stats.totalCount, stats.recentCount);
+   * const report = await baasix.reports.query('orders', {
+   *   aggregate: {
+   *     total: { function: 'sum', field: 'amount' }
+   *   },
+   *   groupBy: ['status']
+   * });
    * ```
    */
-  async getStats(collection, options) {
-    const response = await this.client.get(`/reports/${collection}/stats`, {
-      params: options
+  async query(collection, params) {
+    const response = await this.client.get(
+      `/reports/${collection}`,
+      { params }
+    );
+    return response;
+  }
+  /**
+   * Get statistics for multiple collections in a single request
+   *
+   * @example
+   * ```typescript
+   * const stats = await baasix.reports.getStats([
+   *   {
+   *     name: 'total_products',
+   *     collection: 'products',
+   *     query: {
+   *       aggregate: { count: { function: 'count', field: '*' } }
+   *     }
+   *   },
+   *   {
+   *     name: 'total_orders',
+   *     collection: 'orders',
+   *     query: {
+   *       aggregate: {
+   *         count: { function: 'count', field: '*' },
+   *         total_amount: { function: 'sum', field: 'amount' }
+   *       }
+   *     }
+   *   }
+   * ]);
+   * ```
+   */
+  async getStats(stats) {
+    const response = await this.client.post(`/reports/stats`, {
+      stats
     });
-    return response.data;
+    return response;
   }
   /**
    * Generate an aggregation query