feat: support measure aliases in analytics (field_type pattern)

Author: hotlong

packages/objectql/src/engine.ts

@@ -1564,6 +1564,14 @@ export class ObjectQL implements IDataEngine {
             aggregations: query.aggregations,
         };
 
+        // Prefer driver.aggregate() when available — driver.find() in many
+        // drivers (e.g. driver-sql) does not honor `groupBy` / `aggregations`
+        // and would silently return ungrouped raw rows. Fall back to find()
+        // for drivers that handle aggregations through their query AST.
+        const drv = driver as any;
+        if (typeof drv.aggregate === 'function') {
+            return drv.aggregate(object, ast);
+        }
         return driver.find(object, ast);
       });
 

packages/plugins/driver-memory/src/memory-analytics.test.ts

@@ -264,6 +264,35 @@ describe('MemoryAnalyticsService', () => {
       expect(result.rows[1]['orders.customer']).toBe('Charlie');
     });
 
+    it('should resolve `${field}_${type}` aliases to canonical measures', async () => {
+      // Cubes commonly define measures keyed by field name (e.g. measure
+      // 'amount' of type 'sum'). Clients that build measure names from
+      // (field, function) pairs send 'amount_sum' — the resolver should
+      // accept that alias and produce the same aggregate value.
+      const aliasCube: Cube = {
+        name: 'opps',
+        title: 'Opps',
+        sql: 'orders',
+        measures: {
+          amount: { name: 'amount', label: 'Amount', type: 'sum', sql: 'amount' },
+        },
+        dimensions: {
+          status: { name: 'status', label: 'Status', type: 'string', sql: 'status' },
+        },
+      };
+      const aliasService = new MemoryAnalyticsService({ driver, cubes: [aliasCube] });
+
+      const aliased = await aliasService.query({
+        cube: 'opps',
+        measures: ['amount_sum'],
+        dimensions: ['status'],
+      });
+
+      const completed = aliased.rows.find(r => r.status === 'completed');
+      expect(completed).toBeDefined();
+      expect(completed!['amount_sum']).toBe(600); // 100 + 200 + 300
+    });
+
     it('should throw error for unknown cube', async () => {
       await expect(async () => {
         await service.query({

packages/plugins/driver-memory/src/memory-analytics.ts

@@ -363,7 +363,25 @@ export class MemoryAnalyticsService implements IAnalyticsService {
   private resolveMeasure(cube: Cube, measureName: string) {
     const parts = measureName.split('.');
     const fieldName = parts.length > 1 ? parts[1] : parts[0];
-    return cube.measures[fieldName];
+    const direct = cube.measures[fieldName];
+    if (direct) return direct;
+
+    // Accept `${field}_${type}` aliases (e.g. 'amount_sum') for measures whose
+    // canonical name is just `${field}` (e.g. measure 'amount' of type 'sum').
+    // This matches the convention used by the data-objectstack adapter and
+    // other clients that build measure names from (field, function) pairs.
+    const aggTypes = ['count', 'sum', 'avg', 'min', 'max', 'count_distinct'];
+    for (const type of aggTypes) {
+      const suffix = `_${type}`;
+      if (fieldName.endsWith(suffix)) {
+        const baseField = fieldName.slice(0, -suffix.length);
+        const candidate = cube.measures[baseField];
+        if (candidate && candidate.type === type) {
+          return candidate;
+        }
+      }
+    }
+    return undefined;
   }
 
   private resolveDimension(cube: Cube, dimensionName: string) {

packages/services/service-analytics/src/strategies/objectql-strategy.ts

@@ -130,12 +130,32 @@ export class ObjectQLStrategy implements AnalyticsStrategy {
 
   private resolveMeasureAggregation(cube: Cube, measureName: string): { field: string; method: string } {
     const fieldName = measureName.includes('.') ? measureName.split('.')[1] : measureName;
-    const measure = cube.measures[fieldName];
-    if (!measure) return { field: '*', method: 'count' };
-    return {
-      field: measure.sql.replace(/^\$/, ''),
-      method: measure.type === 'count_distinct' ? 'count_distinct' : measure.type,
-    };
+    const direct = cube.measures[fieldName];
+    if (direct) {
+      return {
+        field: direct.sql.replace(/^\$/, ''),
+        method: direct.type === 'count_distinct' ? 'count_distinct' : direct.type,
+      };
+    }
+    // Accept `${field}_${type}` aliases (e.g. 'amount_sum') for measures whose
+    // canonical name is just `${field}` (e.g. measure 'amount' of type 'sum').
+    // This matches the convention used by clients that build measure names
+    // from (field, function) pairs (e.g. the data-objectstack adapter).
+    const aggTypes = ['count', 'sum', 'avg', 'min', 'max', 'count_distinct'];
+    for (const type of aggTypes) {
+      const suffix = `_${type}`;
+      if (fieldName.endsWith(suffix)) {
+        const baseField = fieldName.slice(0, -suffix.length);
+        const candidate = cube.measures[baseField];
+        if (candidate && candidate.type === type) {
+          return {
+            field: candidate.sql.replace(/^\$/, ''),
+            method: candidate.type === 'count_distinct' ? 'count_distinct' : candidate.type,
+          };
+        }
+      }
+    }
+    return { field: '*', method: 'count' };
   }
 
   private convertFilter(operator: string, values?: string[]): unknown {