Add eq filter support

Author: habdelra

packages/host/tests/unit/query-test.ts

@@ -1,4 +1,4 @@
-import { module, test } from 'qunit';
+import { module, test, skip } from 'qunit';
 
 import {
   Loader,
@@ -118,4 +118,34 @@ module('Unit | query', function (hooks) {
       'results are correct',
     );
   });
+
+  test(`can filter using 'eq'`, async function (assert) {
+    let { mango, vangogh, paper } = testCards;
+    await setupIndex(client, [
+      { card: mango, data: { search_doc: { name: 'Mango' } } },
+      { card: vangogh, data: { search_doc: { name: 'Van Gogh' } } },
+      // this card's "name" field doesn't match our filter since our filter
+      // specified "name" fields of Person cards
+      { card: paper, data: { search_doc: { name: 'Mango' } } },
+    ]);
+
+    let { cards, meta } = await client.search(
+      {
+        filter: {
+          eq: { name: 'Mango' },
+          on: { module: `${testRealmURL}person`, name: 'Person' },
+        },
+      },
+      loader,
+    );
+
+    assert.strictEqual(meta.page.total, 1, 'the total results meta is correct');
+    assert.deepEqual(
+      cards,
+      [await serializeCard(mango)],
+      'results are correct',
+    );
+  });
+
+  skip(`can filter using 'eq' thru nested fields`);
 });

packages/runtime-common/indexer/client.ts

@@ -1,3 +1,4 @@
+import * as JSONTypes from 'json-typescript';
 import flatten from 'lodash/flatten';
 import {
   type LooseCardResource,
@@ -22,8 +23,10 @@ import {
   addExplicitParens,
   asExpressions,
   every,
+  fieldQuery,
+  fieldValue,
 } from './expression';
-import { type Query, type Filter } from '../query';
+import { type Query, type Filter, type EqFilter } from '../query';
 import { type SerializedError } from '../error';
 import { type DBAdapter } from '../db';
 import { type SearchEntryWithErrors } from '../search-index';
@@ -249,6 +252,10 @@ export class IndexerDBClient {
 
     // TODO: any, every, not, eq, contains, range
 
+    if ('eq' in filter) {
+      return this.eqCondition(filter, on);
+    }
+
     throw new Error(`Unknown filter: ${JSON.stringify(filter)}`);
   }
 
@@ -262,6 +269,32 @@ export class IndexerDBClient {
     ];
   }
 
+  private eqCondition(filter: EqFilter, on: CodeRef): CardExpression {
+    on = filter.on ?? on;
+    return every([
+      this.typeCondition(on),
+      ...Object.entries(filter.eq).map(([key, value]) => {
+        return this.fieldFilter(key, value, on);
+      }),
+    ]);
+  }
+
+  // TODO handle containsMany fields. Take a look at how FieldArity works in hub
+  // v2 for an example which let's us use a different card expression for
+  // singular fields vs plural fields. Also plural fields will really push
+  // SQLite to the extreme in terms of the query that we need--this is
+  // challenging because the original hub v2 implementation leveraged array
+  // operators for this query which SQLite does not have.
+  private fieldFilter(
+    key: string,
+    value: JSONTypes.Value,
+    onRef: CodeRef,
+  ): CardExpression {
+    let query = fieldQuery(key, onRef, 'filter');
+    let v = fieldValue(key, [param(value)], onRef, 'filter');
+    return [query, '=', v];
+  }
+
   private async cardQueryToSQL(query: CardExpression, loader: Loader) {
     return this.expressionToSql(await this.makeExpression(query, loader));
   }

packages/runtime-common/indexer/expression.ts

@@ -93,6 +93,33 @@ export function tableValuedFunction(
   };
 }
 
+export function fieldQuery(
+  path: string,
+  type: CodeRef,
+  errorHint: string,
+): FieldQuery {
+  return {
+    type,
+    path,
+    errorHint,
+    kind: 'field-query',
+  };
+}
+
+export function fieldValue(
+  path: string,
+  value: CardExpression,
+  type: CodeRef,
+  errorHint: string,
+): FieldValue {
+  return {
+    type,
+    path,
+    value,
+    errorHint,
+    kind: 'field-value',
+  };
+}
 export function every(expressions: CardExpression[]): CardExpression;
 export function every(expressions: Expression[]): Expression;
 export function every(expressions: unknown[][]): unknown {