Merge pull request #497 from psteinroe/feat/aggregates

feat: support aggregates

.changeset/spotty-trains-attend.md

@@ -0,0 +1,7 @@
+---
+"@supabase-cache-helpers/postgrest-react-query": minor
+"@supabase-cache-helpers/postgrest-core": minor
+"@supabase-cache-helpers/postgrest-swr": minor
+---
+
+feat: support for aggregates

packages/postgrest-core/src/lib/parse-select-param.ts

@@ -34,7 +34,7 @@ export const parseSelectParam = (s: string, currentPath?: Path): Path[] => {
   }
 
   const foreignTables = result.reduce((prev, curr, idx, matches) => {
-    if (curr.name === 'selectedColumns') {
+    if (curr.name === 'selectedColumns' && curr.value.length > 0) {
       const name = matches[idx - 1].value.slice(1, -1);
       prev = { ...prev, [name]: curr.value };
     }
@@ -62,6 +62,11 @@ export const parseSelectParam = (s: string, currentPath?: Path): Path[] => {
     .map((c) => {
       const split = c.split(':');
       const hasAlias = split.length > 1;
+
+      const aggregateSplit = split[hasAlias ? 1 : 0].split('.');
+      const hasAggregate =
+        aggregateSplit.length > 1 && aggregateSplit[1].endsWith('()');
+
       return {
         declaration: [currentPath?.declaration, c].filter(Boolean).join('.'),
         alias:
@@ -70,9 +75,13 @@ export const parseSelectParam = (s: string, currentPath?: Path): Path[] => {
                 .filter(Boolean)
                 .join('.')
             : undefined,
-        path: [currentPath?.path, split[hasAlias ? 1 : 0]]
+        path: [
+          currentPath?.path,
+          hasAggregate ? aggregateSplit[0] : split[hasAlias ? 1 : 0],
+        ]
           .filter(Boolean)
           .join('.'),
+        ...(hasAggregate ? { aggregate: aggregateSplit[1].slice(0, -2) } : {}),
       };
     });
 

packages/postgrest-core/src/lib/query-types.ts

@@ -56,6 +56,10 @@ export type Path = {
    * The full declaration of a column that includes alias, hints and inner joins
    */
   declaration: string;
+  /**
+   * The aggregate function applied to the path
+   */
+  aggregate?: string;
 };
 
 /**

packages/postgrest-core/src/mutate-item.ts

@@ -86,6 +86,7 @@ export type MutateItemCache<KeyType, Type extends Record<string, unknown>> = {
     | 'applyFiltersOnPaths'
     | 'apply'
     | 'hasWildcardPath'
+    | 'hasAggregatePath'
   >;
   /**
    * Decode a key. Should return null if not a PostgREST key.
@@ -141,7 +142,11 @@ export const mutateItem = async <KeyType, Type extends Record<string, unknown>>(
         const orderBy = key.orderByKey
           ? parseOrderByKey(key.orderByKey)
           : undefined;
-        if (key.isHead === true || filter.hasWildcardPath) {
+        if (
+          key.isHead === true ||
+          filter.hasWildcardPath ||
+          filter.hasAggregatePath
+        ) {
           // we cannot know whether the new item after mutating still has all paths required for a query if it contains a wildcard,
           // because we do not know what columns a table has. we must always revalidate then.
           mutations.push(revalidate(k));

packages/postgrest-core/src/postgrest-filter.ts

@@ -26,6 +26,7 @@ export class PostgrestFilter<Result extends Record<string, unknown>> {
   private _filtersFn: FilterFn<Result> | undefined;
   private _filterPaths: Path[];
   public hasWildcardPath: boolean | undefined;
+  public hasAggregatePath: boolean | undefined;
 
   constructor(
     public readonly params: { filters: FilterDefinitions; paths: Path[] },
@@ -37,6 +38,7 @@ export class PostgrestFilter<Result extends Record<string, unknown>> {
     this.hasWildcardPath = this.params.paths.some((p) =>
       p.declaration.endsWith('*'),
     );
+    this.hasAggregatePath = this.params.paths.some((p) => Boolean(p.aggregate));
   }
 
   public static fromQuery(query: string, opts?: PostgrestQueryParserOptions) {
@@ -197,7 +199,9 @@ export class PostgrestFilter<Result extends Record<string, unknown>> {
     const filterFn = OPERATOR_MAP[operator];
     if (!filterFn)
       throw new Error(
-        `Unable to build filter function for ${JSON.stringify(def)}. Operator ${operator} is not supported.`,
+        `Unable to build filter function for ${JSON.stringify(
+          def,
+        )}. Operator ${operator} is not supported.`,
       );
 
     return (obj: object) =>

packages/postgrest-core/src/upsert-item.ts

@@ -93,6 +93,7 @@ export type UpsertItemCache<KeyType, Type extends Record<string, unknown>> = {
     | 'applyFiltersOnPaths'
     | 'apply'
     | 'hasWildcardPath'
+    | 'hasAggregatePath'
   >;
   /**
    * Decode a key. Should return null if not a PostgREST key.
@@ -143,7 +144,11 @@ export const upsertItem = async <KeyType, Type extends Record<string, unknown>>(
           ? parseOrderByKey(key.orderByKey)
           : undefined;
 
-        if (key.isHead === true || filter.hasWildcardPath) {
+        if (
+          key.isHead === true ||
+          filter.hasWildcardPath ||
+          filter.hasAggregatePath
+        ) {
           // we cannot know whether the new item after merging still has all paths required for a query if it contains a wildcard,
           // because we do not know what columns a table has. we must always revalidate then.
           mutations.push(revalidate(k));

packages/postgrest-core/tests/lib/parse-select-param.spec.ts

@@ -2,6 +2,84 @@ import { describe, expect, it } from 'vitest';
 import { parseSelectParam } from '../../src/lib/parse-select-param';
 
 describe('parseSelectParam', () => {
+  it('should parse aggregates', () => {
+    expect(parseSelectParam('amount.sum()')).toEqual([
+      {
+        alias: undefined,
+        declaration: 'amount.sum()',
+        path: 'amount',
+        aggregate: 'sum',
+      },
+    ]);
+  });
+
+  it('should parse multiple aggregates with grouping', () => {
+    expect(parseSelectParam('amount.sum(),amount.avg(),order_date')).toEqual([
+      {
+        alias: undefined,
+        declaration: 'amount.sum()',
+        path: 'amount',
+        aggregate: 'sum',
+      },
+      {
+        alias: undefined,
+        declaration: 'amount.avg()',
+        path: 'amount',
+        aggregate: 'avg',
+      },
+      {
+        alias: undefined,
+        declaration: 'order_date',
+        path: 'order_date',
+      },
+    ]);
+  });
+
+  it('should parse aggregates with alias', () => {
+    expect(
+      parseSelectParam('amount.sum(),alias:amount.avg(),order_date'),
+    ).toEqual([
+      {
+        alias: undefined,
+        declaration: 'amount.sum()',
+        path: 'amount',
+        aggregate: 'sum',
+      },
+      {
+        alias: 'alias',
+        declaration: 'alias:amount.avg()',
+        path: 'amount',
+        aggregate: 'avg',
+      },
+      {
+        alias: undefined,
+        declaration: 'order_date',
+        path: 'order_date',
+      },
+    ]);
+  });
+
+  it('should parse aggregates within embedded resources', () => {
+    expect(parseSelectParam('state,orders(amount.sum(),order_date)')).toEqual([
+      {
+        alias: undefined,
+        declaration: 'state',
+        path: 'state',
+      },
+      {
+        alias: undefined,
+        declaration: 'orders.amount.sum()',
+        path: 'orders.amount',
+        aggregate: 'sum',
+      },
+      {
+        alias: undefined,
+        declaration: 'orders.order_date',
+        path: 'orders.order_date',
+      },
+    ]);
+  });
+
   it('should return input if falsy', () => {
     expect(
       parseSelectParam(

packages/postgrest-core/tests/mutate-item.spec.ts

@@ -52,6 +52,11 @@ const mutateFnMock = async (
       },
       getPostgrestFilter() {
         return {
+          get hasAggregatePath(): boolean {
+            return typeof postgrestFilter.hasAggregatePath === 'boolean'
+              ? postgrestFilter.hasAggregatePath
+              : false;
+          },
           get hasWildcardPath(): boolean {
             return typeof postgrestFilter.hasWildcardPath === 'boolean'
               ? postgrestFilter.hasWildcardPath
@@ -137,6 +142,9 @@ const mutateRelationMock = async (
       },
       getPostgrestFilter() {
         return {
+          get hasAggregatePath(): boolean {
+            return false;
+          },
           get hasWildcardPath(): boolean {
             return false;
           },
@@ -205,6 +213,11 @@ const mutateFnResult = async (
         },
         getPostgrestFilter() {
           return {
+            get hasAggregatePath(): boolean {
+              return typeof postgrestFilter.hasAggregatePath === 'boolean'
+                ? postgrestFilter.hasAggregatePath
+                : false;
+            },
             get hasWildcardPath(): boolean {
               return typeof postgrestFilter.hasWildcardPath === 'boolean'
                 ? postgrestFilter.hasWildcardPath
@@ -347,6 +360,25 @@ describe('mutateItem', () => {
     expect(mutate).toHaveBeenCalledTimes(0);
   });
 
+  it('should revalidate aggregate query', async () => {
+    const { mutate, revalidate } = await mutateFnMock(
+      { id_1: '0', id_2: '0' },
+      (c) => c,
+      {},
+      {
+        apply: false,
+        applyFilters: false,
+        hasPaths: false,
+        hasWildcardPath: false,
+        hasAggregatePath: true,
+        hasFiltersOnPaths: true,
+        applyFiltersOnPaths: true,
+      },
+    );
+    expect(revalidate).toHaveBeenCalledTimes(1);
+    expect(mutate).toHaveBeenCalledTimes(0);
+  });
+
   it('should revalidate isHead query', async () => {
     const { mutate, revalidate } = await mutateFnMock(
       { id_1: '0', id_2: '0' },

packages/postgrest-core/tests/postgrest-filter.spec.ts

@@ -55,6 +55,19 @@ describe('PostgrestFilter', () => {
     ).toEqual(true);
   });
 
+  it('should set has aggregate paths', () => {
+    expect(
+      PostgrestFilter.fromQuery(
+        new PostgrestParser(
+          createClient('https://localhost', 'test')
+            .from('contact')
+            .select('name,city,state,orders(amount.sum(),order_date)')
+            .eq('username', 'test'),
+        ).queryKey,
+      ).hasAggregatePath,
+    ).toEqual(true);
+  });
+
   describe('.transform', () => {
     it('should transform nested one-to-many relations', () => {
       expect(

packages/postgrest-core/tests/upsert-item.spec.ts

@@ -55,6 +55,11 @@ const mutateFnMock = async (
               ? postgrestFilter.hasWildcardPath
               : false;
           },
+          get hasAggregatePath(): boolean {
+            return typeof postgrestFilter.hasAggregatePath === 'boolean'
+              ? postgrestFilter.hasAggregatePath
+              : false;
+          },
           denormalize<ItemType>(obj: ItemType): ItemType {
             return obj;
           },
@@ -137,6 +142,9 @@ const mutateRelationMock = async (
           get hasWildcardPath(): boolean {
             return false;
           },
+          get hasAggregatePath(): boolean {
+            return false;
+          },
           denormalize<RelationType>(obj: RelationType): RelationType {
             return obj;
           },
@@ -202,6 +210,11 @@ const mutateFnResult = async (
         },
         getPostgrestFilter() {
           return {
+            get hasAggregatePath(): boolean {
+              return typeof postgrestFilter.hasAggregatePath === 'boolean'
+                ? postgrestFilter.hasAggregatePath
+                : false;
+            },
             get hasWildcardPath(): boolean {
               return typeof postgrestFilter.hasWildcardPath === 'boolean'
                 ? postgrestFilter.hasWildcardPath
@@ -341,6 +354,24 @@ describe('upsertItem', () => {
     expect(revalidate).toHaveBeenCalledTimes(1);
   });
 
+  it('should revalidate aggregate query', async () => {
+    const { mutate, revalidate } = await mutateFnMock(
+      { id_1: '0', id_2: '0', value: 'test' },
+      {},
+      {
+        hasWildcardPath: false,
+        hasAggregatePath: true,
+        apply: false,
+        applyFilters: false,
+        hasPaths: false,
+        hasFiltersOnPaths: true,
+        applyFiltersOnPaths: true,
+      },
+    );
+    expect(mutate).toHaveBeenCalledTimes(0);
+    expect(revalidate).toHaveBeenCalledTimes(1);
+  });
+
   it('should revalidate isHead query', async () => {
     const { mutate, revalidate } = await mutateFnMock(
       { id_1: '0', id_2: '0', value: 'test' },