db: add support for has and !has set operators

.changeset/mighty-llamas-serve.md

@@ -0,0 +1,5 @@
+---
+'@triplit/db': patch
+---
+
+Ensure that schemas passed in to the DB constructor have id and collection triples

.changeset/sour-fireants-live.md

@@ -0,0 +1,5 @@
+---
+'@triplit/db': patch
+---
+
+Add support for 'has' and '!has' set operators

packages/db/src/collection-query.ts

@@ -445,14 +445,15 @@ function* generateQueryChains<
 
 const REVERSE_OPERATOR_MAPPINGS = {
  '=': '=',
+ '!=': '!=',
  '<': '>',
  '>': '<',
  '<=': '>=',
  '>=': '<=',
- in: '=', // we need the inverse for sets
- // TODO support Set operators
- // the issue is that we use '=' for set membership so we can't just reverse the operator
- // naively to "in"
+ in: 'has',
+ nin: '!has',
+ has: 'in',
+ '!has': 'nin',
 };
 function reverseRelationFilter(filter: FilterStatement<any, any>) {
  const [path, op, value] = filter;
@@ -873,13 +874,18 @@ function satisfiesSetFilter(
  return false;
  }
  }
+
  const setData = timestampedObjectToPlainObject(value);
- return (
- setData &&
- Object.entries(setData)
- .filter(([_v, inSet]) => inSet)
- .some(([v]) => isOperatorSatisfied(op, v, filterValue))
- );
+ if (!setData) return false;
+ const filteredSet = Object.entries(setData).filter(([_v, inSet]) => inSet);
+ if (op === 'has') {
+ return filteredSet.some(([v]) => v === filterValue);
+ }
+ if (op === '!has') {
+ return filteredSet.every(([v]) => v !== filterValue);
+ }
+
+ return filteredSet.some(([v]) => isOperatorSatisfied(op, v, filterValue));
 }
 
 function satisfiesRegisterFilter(

packages/db/src/data-types/base.ts

@@ -30,7 +30,9 @@ export type Operator =
  | 'like'
  | 'nlike'
  | 'in'
- | 'nin';
+ | 'nin'
+ | 'has'
+ | '!has';
 
 export type Optional<T extends DataType> = T & { context: { optional: true } };
 

packages/db/src/data-types/set.ts

@@ -18,7 +18,7 @@ import { ExtractJSType } from './type.js';
 import { ChangeTracker } from '../db-transaction.js';
 import { TypeWithOptions } from './value.js';
 
-const SET_OPERATORS = ['=', '!='] as const;
+const SET_OPERATORS = ['=', '!=', 'has', '!has'] as const;
 type SetOperators = typeof SET_OPERATORS;
 
 export type SetType<

packages/db/test/db.spec.ts

@@ -283,6 +283,60 @@ describe('Database API', () => {
  { name: "Travis 'LaFlame' Scott", id: '6', rank: 6 },
  ];
 
+ it.only('supports basic queries with the has and !has operators', async () => {
+ const db = new DB({
+ schema: {
+ collections: {
+ Classes: {
+ schema: S.Schema({
+ id: S.Id(),
+ name: S.String(),
+ level: S.Number(),
+ department: S.String(),
+ enrolled_students: S.Set(S.String()),
+ }),
+ },
+ },
+ },
+ });
+ await Promise.all(
+ classes.map((cls) =>
+ db.insert('Classes', {
+ ...cls,
+ enrolled_students: new Set(cls.enrolled_students),
+ })
+ )
+ );
+ const results = await db.fetch(
+ CollectionQueryBuilder('Classes')
+ .where([['enrolled_students', 'has', 'student-1']])
+ .build()
+ );
+ expect([...results.keys()]).toStrictEqual(['class-2', 'class-3']);
+ const results2 = await db.fetch(
+ CollectionQueryBuilder('Classes')
+ .where([['enrolled_students', 'has', 'bad-id']])
+ .build()
+ );
+ expect(results2.size).toBe(0);
+ const results3 = await db.fetch(
+ CollectionQueryBuilder('Classes')
+ .where([['enrolled_students', '!has', 'student-1']])
+ .build()
+ );
+ expect([...results3.keys()]).toStrictEqual([
+ 'class-1',
+ 'class-4',
+ 'class-5',
+ ]);
+ const results4 = await db.fetch(
+ CollectionQueryBuilder('Classes')
+ .where([['enrolled_students', '!has', 'bad-id']])
+ .build()
+ );
+ expect(results4.size).toBe(5);
+ });
+
  it('supports basic queries without filters', async () => {
  const results = await db.fetch(CollectionQueryBuilder('Student').build());
  expect(results.size).toBe(students.length);

packages/docs/src/pages/schemas.mdx

@@ -256,7 +256,7 @@ import { Schema as S } from '@triplit/db';
 const stringSet = S.Set(S.String());
 ```
 
-Sets support `=`, `!=` operators in `where` statements, which check if the set contains the value.
+Sets support `has` and `!has` operators in `where` statements, which check if the set does or does not contain the value.
 
 ### Record