@travetto/model-query 8.0.0-alpha.24 → 8.0.0-alpha.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "8.0.0-alpha.24",
+  "version": "8.0.0-alpha.26",
   "type": "module",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
@@ -27,12 +27,12 @@
     "directory": "module/model-query"
   },
   "dependencies": {
-    "@travetto/di": "^8.0.0-alpha.20",
-    "@travetto/model": "^8.0.0-alpha.23",
-    "@travetto/schema": "^8.0.0-alpha.22"
+    "@travetto/di": "^8.0.0-alpha.21",
+    "@travetto/model": "^8.0.0-alpha.24",
+    "@travetto/schema": "^8.0.0-alpha.23"
   },
   "peerDependencies": {
-    "@travetto/test": "^8.0.0-alpha.21"
+    "@travetto/test": "^8.0.0-alpha.22"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/model/where-clause.ts

@@ -45,7 +45,7 @@ type GeoField = {
 };
 
 export type PropWhereClause<T> = {
-  [P in keyof T]?: T[P] extends number | undefined
+  -readonly [P in keyof T]?: T[P] extends number | undefined
     ? General<number> | ScalarField<number> | ComparableField<number> | number
     : T[P] extends bigint | undefined
       ? General<bigint> | ScalarField<bigint> | ComparableField<bigint> | bigint

package/src/util/suggest.ts

@@ -86,7 +86,7 @@ export class ModelQuerySuggestUtil {
 
     for (const result of results) {
       let resultValue = result[castKey<T>(parts[0])];
-      for (let i = 1; i < parts.length; i++) {
+      for (let i = 1; i < parts.length; i += 1) {
         resultValue = resultValue[castKey(parts[i])];
       }
       if (Array.isArray(resultValue)) {

package/support/test/crud.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 
-import { ExistsError, Model, type ModelCrudSupport, NotFoundError } from '@travetto/model';
+import { Model, type ModelCrudSupport, NotFoundError, UniqueError } from '@travetto/model';
 import { castTo } from '@travetto/runtime';
 import { Suite, Test } from '@travetto/test';
 
@@ -29,7 +29,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
   async testUnique() {
     const svc = await this.service;
     await svc.create(UniqueUser2, UniqueUser2.from({ name: 'bob' }));
-    await assert.rejects(() => svc.create(UniqueUser2, UniqueUser2.from({ name: 'bob' })), ExistsError);
+    await assert.rejects(() => svc.create(UniqueUser2, UniqueUser2.from({ name: 'bob' })), UniqueError);
   }
 
   @Test()

package/support/test/model.ts

@@ -99,3 +99,35 @@ export class BigIntModel {
   largeNumber: bigint;
   optionalBigInt?: bigint;
 }
+
+@Schema()
+export class Child {
+  name: string;
+}
+
+@Schema()
+export class Family {
+  children?: Child[];
+}
+
+@Model()
+export class PersonFamily implements ModelType {
+  id: string;
+  family?: Family;
+}
+
+@Schema()
+export class RecipeIngredient {
+  name: string;
+}
+
+@Schema()
+export class RecipeSection {
+  ingredients: RecipeIngredient[] = [];
+}
+
+@Model()
+export class Recipe implements ModelType {
+  id: string;
+  sections: RecipeSection[] = [];
+}

package/support/test/query.ts

@@ -7,7 +7,7 @@ import { Suite, Test } from '@travetto/test';
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
 import type { ModelQuerySupport } from '../../src/types/query.ts';
-import { Aged, Location, Names, Note, Person, SimpleList, WithNestedLists, WithNestedNestedLists } from './model.ts';
+import { Aged, Location, Names, Note, Person, PersonFamily, Recipe, SimpleList, WithNestedLists, WithNestedNestedLists } from './model.ts';
 
 @Suite()
 export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport & ModelCrudSupport> {
@@ -263,8 +263,8 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     const toAdd = [];
 
-    for (let i = 0; i < 5; i++) {
-      for (let j = 0; j < 5; j++) {
+    for (let i = 0; i < 5; i += 1) {
+      for (let j = 0; j < 5; j += 1) {
         toAdd.push(
           Location.from({
             point: [i, j]
@@ -537,4 +537,235 @@ 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 service.create(
+      Recipe,
+      Recipe.from({
+        sections: [
+          {
+            ingredients: [{ name: 'garlic' }, { name: 'onion' }]
+          }
+        ]
+      })
+    );
+
+    await service.create(
+      Recipe,
+      Recipe.from({
+        sections: [
+          {
+            ingredients: [{ name: 'paprika' }, { name: 'salt' }]
+          }
+        ]
+      })
+    );
+
+    await service.create(
+      Recipe,
+      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 service.create(
+      Note,
+      Note.from({
+        entities: [
+          { id: '1', label: 'one' },
+          { id: '2', label: 'two' }
+        ]
+      })
+    );
+
+    await service.create(
+      Note,
+      Note.from({
+        entities: [
+          { id: '3', label: 'three' },
+          { id: '4', label: 'four' }
+        ]
+      })
+    );
+
+    await service.create(
+      Note,
+      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 service.create(
+      PersonFamily,
+      PersonFamily.from({
+        family: {
+          children: [{ name: 'one' }, { name: 'two' }]
+        }
+      })
+    );
+
+    await service.create(
+      PersonFamily,
+      PersonFamily.from({
+        family: {
+          children: [{ name: 'three' }, { name: 'four' }]
+        }
+      })
+    );
+
+    await service.create(
+      PersonFamily,
+      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);
+  }
 }