@travetto/model-query 8.0.0-alpha.9 → 8.0.0

package/support/test/query.ts

@@ -1,34 +1,34 @@
 import assert from 'node:assert';
 
-import { Suite, Test } from '@travetto/test';
+import { type ModelCrudSupport, NotFoundError } from '@travetto/model';
 import { TimeUtil } from '@travetto/runtime';
-import { NotFoundError, type ModelCrudSupport } from '@travetto/model';
+import { Suite, Test } from '@travetto/test';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { Aged, Location, Names, Note, Person, SimpleList, WithNestedLists, WithNestedNestedLists } from './model.ts';
-
 import type { ModelQuerySupport } from '../../src/types/query.ts';
+import { Aged, Location, Names, Note, Person, PersonFamily, Recipe, SimpleList, WithNestedLists, WithNestedNestedLists } from './model.ts';
 
 @Suite()
 export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport & ModelCrudSupport> {
-
   supportsGeo = true;
 
   @Test()
   async testIds() {
     const svc = await this.service;
 
-    const people = [1, 2, 3, 8].map(x => Person.from({
-      id: svc.idSource.create(),
-      name: 'Bob Omber',
-      age: 20 + x,
-      gender: 'm',
-      address: {
-        street1: 'a',
-        ...(x === 1 ? { street2: 'b' } : {})
-      }
-    }));
+    const people = [1, 2, 3, 8].map(x =>
+      Person.from({
+        id: svc.idSource.create(),
+        name: 'Bob Omber',
+        age: 20 + x,
+        gender: 'm',
+        address: {
+          street1: 'a',
+          ...(x === 1 ? { street2: 'b' } : {})
+        }
+      })
+    );
 
     await this.saveAll(Person, people);
 
@@ -48,20 +48,25 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   @Test('verify word boundary')
   async testWordBoundary() {
     const service = await this.service;
-    await this.saveAll(Person, [1, 2, 3, 8].map(x => Person.from({
-      name: 'Bob Omber',
-      age: 20 + x,
-      gender: 'm',
-      address: {
-        street1: 'a',
-        ...(x === 1 ? { street2: 'b' } : {})
-      }
-    })));
+    await this.saveAll(
+      Person,
+      [1, 2, 3, 8].map(x =>
+        Person.from({
+          name: 'Bob Omber',
+          age: 20 + x,
+          gender: 'm',
+          address: {
+            street1: 'a',
+            ...(x === 1 ? { street2: 'b' } : {})
+          }
+        })
+      )
+    );
 
     const results = await service.query(Person, { where: { name: { $regex: /\bomb.*/i } } });
     assert(results.length === 4);
 
-    const results2 = await service.query(Person, { where: { name: { $regex: /\bmbo.*/i } } });
+    const results2 = await service.query(Person, { where: { name: { $regex: /\b.?mbo.*/i } } });
     assert(results2.length === 0);
 
     const results3 = await service.query(Person, { where: { name: { $regex: /\bomb.*/ } } });
@@ -71,15 +76,20 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   @Test('verify query one behavior')
   async testQueryOne() {
     const service = await this.service;
-    await this.saveAll(Person, [1, 2, 3, 8].map(x => Person.from({
-      name: 'Bob Omber',
-      age: 20 + x,
-      gender: 'm',
-      address: {
-        street1: 'a',
-        ...(x === 1 ? { street2: 'b' } : {})
-      }
-    })));
+    await this.saveAll(
+      Person,
+      [1, 2, 3, 8].map(x =>
+        Person.from({
+          name: 'Bob Omber',
+          age: 20 + x,
+          gender: 'm',
+          address: {
+            street1: 'a',
+            ...(x === 1 ? { street2: 'b' } : {})
+          }
+        })
+      )
+    );
 
     await assert.rejects(() => service.queryOne(Person, { where: { gender: 'm' } }), /Invalid number of results/);
     await assert.rejects(() => service.queryOne(Person, { where: { gender: 'z' } }), NotFoundError);
@@ -91,13 +101,19 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   @Test('Verify array $in queries work properly')
   async testArrayContains() {
     const svc = await this.service;
-    const first = await svc.create(SimpleList, SimpleList.from({
-      names: ['a', 'b', 'c']
-    }));
-
-    const second = await svc.create(SimpleList, SimpleList.from({
-      names: ['b', 'c', 'd']
-    }));
+    const first = await svc.create(
+      SimpleList,
+      SimpleList.from({
+        names: ['a', 'b', 'c']
+      })
+    );
+
+    const second = await svc.create(
+      SimpleList,
+      SimpleList.from({
+        names: ['b', 'c', 'd']
+      })
+    );
 
     const single = await svc.query(SimpleList, {
       where: {
@@ -154,6 +170,62 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     assert(idNin.length === 2);
   }
 
+  @Test('Verify list intersection queries')
+  async testListIntersection() {
+    const service = await this.service;
+
+    await this.saveAll(SimpleList, [
+      SimpleList.from({
+        names: ['apple', 'banana']
+      }),
+      SimpleList.from({
+        names: ['banana', 'cherry']
+      }),
+      SimpleList.from({
+        names: ['cherry', 'date']
+      }),
+      SimpleList.from({
+        names: ['elderberry']
+      })
+    ]);
+
+    const singleMatch = await service.query(SimpleList, {
+      where: {
+        names: {
+          $in: ['apple']
+        }
+      }
+    });
+    assert(singleMatch.length === 1);
+
+    const intersectionMatch = await service.query(SimpleList, {
+      where: {
+        names: {
+          $in: ['banana', 'cherry']
+        }
+      }
+    });
+    assert(intersectionMatch.length === 3);
+
+    const disjointIntersectionMatch = await service.query(SimpleList, {
+      where: {
+        names: {
+          $in: ['apple', 'date']
+        }
+      }
+    });
+    assert(disjointIntersectionMatch.length === 2);
+
+    const noIntersectionMatch = await service.query(SimpleList, {
+      where: {
+        names: {
+          $in: ['fig', 'grape']
+        }
+      }
+    });
+    assert(noIntersectionMatch.length === 0);
+  }
+
   @Test('verify all operators')
   async testArrayAll() {
     const service = await this.service;
@@ -161,7 +233,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     await this.saveAll(Names, [
       Names.from({ values: ['a', 'b', 'c'] }),
       Names.from({ values: ['a', 'b'] }),
-      Names.from({ values: ['b', 'c'] }),
+      Names.from({ values: ['b', 'c'] })
     ]);
 
     const results = await service.query(Names, {});
@@ -212,23 +284,27 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   async testSorting() {
     const service = await this.service;
 
-    const people = [1, 2, 3, 8].map(x => Person.from({
-      id: service.idSource.create(),
-      name: 'Bob',
-      age: 20 + x,
-      gender: 'm',
-      address: {
-        street1: 'a',
-        ...(x === 1 ? { street2: 'b' } : {})
-      }
-    }));
+    const people = [1, 2, 3, 8].map(x =>
+      Person.from({
+        id: service.idSource.create(),
+        name: 'Bob',
+        age: 20 + x,
+        gender: 'm',
+        address: {
+          street1: 'a',
+          ...(x === 1 ? { street2: 'b' } : {})
+        }
+      })
+    );
 
     await this.saveAll(Person, people);
 
     const all = await service.query(Person, {
-      sort: [{
-        age: -1
-      }]
+      sort: [
+        {
+          age: -1
+        }
+      ]
     });
     assert(all[0].age >= all[1].age);
   }
@@ -243,23 +319,30 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     const toAdd = [];
 
-    for (let i = 0; i < 5; i++) {
-      for (let j = 0; j < 5; j++) {
-        toAdd.push(Location.from({
-          point: [i, j],
-        }));
+    for (let i = 0; i < 5; i += 1) {
+      for (let j = 0; j < 5; j += 1) {
+        toAdd.push(
+          Location.from({
+            point: [i, j]
+          })
+        );
       }
     }
 
     await this.saveAll(Location, toAdd);
 
-    assert(await svc.queryCount(Location, {}) === 25);
+    assert((await svc.queryCount(Location, {})) === 25);
 
     const result = await svc.query(Location, {
       limit: 100,
       where: {
         point: {
-          $geoWithin: [[-1, -1], [-1, 6], [6, 6], [6, -1]]
+          $geoWithin: [
+            [-1, -1],
+            [-1, 6],
+            [6, 6],
+            [6, -1]
+          ]
         }
       }
     });
@@ -286,15 +369,18 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     const id = service.idSource.create();
 
-    await service.create(Note, Note.from({
-      id,
-      entities: [
-        {
-          label: 'hi',
-          id
-        }
-      ]
-    }));
+    await service.create(
+      Note,
+      Note.from({
+        id,
+        entities: [
+          {
+            label: 'hi',
+            id
+          }
+        ]
+      })
+    );
 
     const out = await service.queryCount(Note, {
       where: {
@@ -320,9 +406,12 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   @Test()
   async verifyDateRange() {
     const service = await this.service;
-    await this.saveAll(Aged, (['-5d', '-4d', '-3d', '-2d', '-1d', '0d', '1d', '2d', '3d', '4d', '5d'] as const).map(delta =>
-      Aged.from({ createdAt: TimeUtil.fromNow(delta) })
-    ));
+    await this.saveAll(
+      Aged,
+      (['-5d', '-4d', '-3d', '-2d', '-1d', '0d', '1d', '2d', '3d', '4d', '5d'] as const).map(delta =>
+        Aged.from({ createdAt: TimeUtil.fromNow(delta) })
+      )
+    );
 
     const simple = await service.queryCount(Aged, {
       where: {
@@ -366,28 +455,13 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   @Test()
   async verifyArrayEmptyVsNot() {
     const service = await this.service;
-    await service.create(WithNestedLists, {
-      tags: ['a', 'b']
-    });
-
-    await service.create(WithNestedLists, {
-      names: ['c', 'd'],
-    });
-
-    await service.create(WithNestedLists, {
-      names: ['c', 'd'],
-      tags: ['e', 'f']
-    });
-
-    await service.create(WithNestedLists, {
-      names: ['g', 'h'],
-      tags: []
-    });
-
-    await service.create(WithNestedLists, {
-      names: [],
-      tags: []
-    });
+    await this.saveAll(WithNestedLists, [
+      WithNestedLists.from({ tags: ['a', 'b'] }),
+      WithNestedLists.from({ names: ['c', 'd'] }),
+      WithNestedLists.from({ names: ['c', 'd'], tags: ['e', 'f'] }),
+      WithNestedLists.from({ names: ['g', 'h'], tags: [] }),
+      WithNestedLists.from({ names: [], tags: [] })
+    ]);
 
     let total = await service.queryCount(WithNestedLists, {
       where: {
@@ -395,6 +469,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       }
     });
     assert(total === 3);
+
     total = await service.queryCount(WithNestedLists, {
       where: {
         names: { $exists: false }
@@ -430,35 +505,20 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
         names: { $exists: true }
       }
     });
-
     assert(total === 1);
   }
 
   @Test()
   async verifyNestedArrayEmptyVsNot() {
     const service = await this.service;
-    await service.create(WithNestedNestedLists, {
-      tags: ['a', 'b']
-    });
-
-    await service.create(WithNestedNestedLists, {
-      sub: { names: ['c', 'd'] },
-    });
 
-    await service.create(WithNestedNestedLists, {
-      sub: { names: ['c', 'd'] },
-      tags: ['e', 'f']
-    });
-
-    await service.create(WithNestedNestedLists, {
-      sub: { names: ['g', 'h'] },
-      tags: []
-    });
-
-    await service.create(WithNestedNestedLists, {
-      sub: {},
-      tags: []
-    });
+    await this.saveAll(WithNestedNestedLists, [
+      WithNestedNestedLists.from({ tags: ['a', 'b'] }),
+      WithNestedNestedLists.from({ sub: { names: ['c', 'd'] } }),
+      WithNestedNestedLists.from({ sub: { names: ['c', 'd'] }, tags: ['e', 'f'] }),
+      WithNestedNestedLists.from({ sub: { names: ['g', 'h'] }, tags: [] }),
+      WithNestedNestedLists.from({ sub: {}, tags: [] })
+    ]);
 
     let total = await service.queryCount(WithNestedNestedLists, {
       where: {
@@ -466,6 +526,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       }
     });
     assert(total === 3);
+
     total = await service.queryCount(WithNestedNestedLists, {
       where: {
         sub: { names: { $exists: false } }
@@ -504,5 +565,178 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     assert(total === 1);
   }
-}
 
+  @Test('Verify queries on nested arrays of schemas')
+  async verifyNestedArraySchemaQuery() {
+    const service = await this.service;
+
+    await this.saveAll(Recipe, [
+      Recipe.from({
+        sections: [{ ingredients: [{ name: 'garlic' }, { name: 'onion' }] }]
+      }),
+      Recipe.from({
+        sections: [{ ingredients: [{ name: 'paprika' }, { name: 'salt' }] }]
+      }),
+      Recipe.from({
+        sections: [{ ingredients: [{ name: 'garlic' }, { name: 'thyme' }] }]
+      })
+    ]);
+
+    const matchSingle = await service.query(Recipe, {
+      where: {
+        sections: { ingredients: { name: 'garlic' } }
+      }
+    });
+    assert(matchSingle.length === 2);
+
+    const matchIn = await service.query(Recipe, {
+      where: {
+        sections: { ingredients: { name: { $in: ['onion', 'salt'] } } }
+      }
+    });
+    assert(matchIn.length === 2);
+
+    const matchNotEqual = await service.query(Recipe, {
+      where: {
+        sections: { ingredients: { name: { $ne: 'garlic' } } }
+      }
+    });
+    assert(matchNotEqual.length === 1);
+  }
+
+  @Test('Verify array of objects property queries')
+  async verifyArrayOfObjectsProperty() {
+    const service = await this.service;
+
+    await this.saveAll(Note, [
+      Note.from({
+        entities: [
+          { id: '1', label: 'one' },
+          { id: '2', label: 'two' }
+        ]
+      }),
+      Note.from({
+        entities: [
+          { id: '3', label: 'three' },
+          { id: '4', label: 'four' }
+        ]
+      }),
+      Note.from({
+        entities: [{ id: '5', label: 'five' }]
+      })
+    ]);
+
+    const inResults = await service.query(Note, {
+      where: {
+        entities: {
+          label: {
+            $in: ['one', 'four', 'missing']
+          }
+        }
+      }
+    });
+    assert(inResults.length === 2);
+
+    const eqResults = await service.query(Note, {
+      where: {
+        entities: {
+          label: 'five'
+        }
+      }
+    });
+    assert(eqResults.length === 1);
+  }
+
+  @Test('Verify nested object array property queries')
+  async verifyNestedObjectArrayProperty() {
+    const service = await this.service;
+
+    await this.saveAll(PersonFamily, [
+      PersonFamily.from({
+        family: { children: [{ name: 'one' }, { name: 'two' }] }
+      }),
+      PersonFamily.from({
+        family: { children: [{ name: 'three' }, { name: 'four' }] }
+      }),
+      PersonFamily.from({
+        family: { children: [{ name: 'five' }] }
+      })
+    ]);
+
+    const inResults = await service.query(PersonFamily, {
+      where: {
+        family: {
+          children: {
+            name: {
+              $in: ['one', 'two', 'three']
+            }
+          }
+        }
+      }
+    });
+    assert(inResults.length === 2);
+
+    const eqResults = await service.query(PersonFamily, {
+      where: {
+        family: {
+          children: {
+            name: 'five'
+          }
+        }
+      }
+    });
+    assert(eqResults.length === 1);
+
+    const neResults = await service.query(PersonFamily, {
+      where: {
+        family: {
+          children: {
+            name: {
+              $ne: 'five'
+            }
+          }
+        }
+      }
+    });
+    assert(neResults.length === 2);
+
+    const ninResults = await service.query(PersonFamily, {
+      where: {
+        family: {
+          children: {
+            name: {
+              $nin: ['one', 'two']
+            }
+          }
+        }
+      }
+    });
+    assert(ninResults.length === 2);
+
+    const allResults = await service.query(PersonFamily, {
+      where: {
+        family: {
+          children: {
+            name: {
+              $all: ['one', 'two']
+            }
+          }
+        }
+      }
+    });
+    assert(allResults.length === 1);
+
+    const existsResults = await service.query(PersonFamily, {
+      where: {
+        family: {
+          children: {
+            name: {
+              $exists: true
+            }
+          }
+        }
+      }
+    });
+    assert(existsResults.length === 3);
+  }
+}