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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "8.0.0-alpha.26",
+  "version": "8.0.0-alpha.27",
   "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.21",
-    "@travetto/model": "^8.0.0-alpha.24",
-    "@travetto/schema": "^8.0.0-alpha.23"
+    "@travetto/di": "^8.0.0-alpha.22",
+    "@travetto/model": "^8.0.0-alpha.25",
+    "@travetto/schema": "^8.0.0-alpha.24"
   },
   "peerDependencies": {
-    "@travetto/test": "^8.0.0-alpha.22"
+    "@travetto/test": "^8.0.0-alpha.23"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

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 += 1) {
+      for (let i = 1; i < parts.length && resultValue !== undefined && resultValue !== null; i += 1) {
         resultValue = resultValue[castKey(parts[i])];
       }
       if (Array.isArray(resultValue)) {

package/support/test/query.ts

@@ -399,28 +399,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: {
@@ -428,6 +413,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       }
     });
     assert(total === 3);
+
     total = await service.queryCount(WithNestedLists, {
       where: {
         names: { $exists: false }
@@ -463,35 +449,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: {
@@ -499,6 +470,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       }
     });
     assert(total === 3);
+
     total = await service.queryCount(WithNestedNestedLists, {
       where: {
         sub: { names: { $exists: false } }
@@ -542,68 +514,35 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   async verifyNestedArraySchemaQuery() {
     const service = await this.service;
 
-    await service.create(
-      Recipe,
+    await this.saveAll(Recipe, [
       Recipe.from({
-        sections: [
-          {
-            ingredients: [{ name: 'garlic' }, { name: 'onion' }]
-          }
-        ]
-      })
-    );
-
-    await service.create(
-      Recipe,
+        sections: [{ ingredients: [{ name: 'garlic' }, { name: 'onion' }] }]
+      }),
       Recipe.from({
-        sections: [
-          {
-            ingredients: [{ name: 'paprika' }, { name: 'salt' }]
-          }
-        ]
-      })
-    );
-
-    await service.create(
-      Recipe,
+        sections: [{ ingredients: [{ name: 'paprika' }, { name: 'salt' }] }]
+      }),
       Recipe.from({
-        sections: [
-          {
-            ingredients: [{ name: 'garlic' }, { name: 'thyme' }]
-          }
-        ]
+        sections: [{ ingredients: [{ name: 'garlic' }, { name: 'thyme' }] }]
       })
-    );
+    ]);
 
     const matchSingle = await service.query(Recipe, {
       where: {
-        sections: {
-          ingredients: {
-            name: 'garlic'
-          }
-        }
+        sections: { ingredients: { name: 'garlic' } }
       }
     });
     assert(matchSingle.length === 2);
 
     const matchIn = await service.query(Recipe, {
       where: {
-        sections: {
-          ingredients: {
-            name: { $in: ['onion', 'salt'] }
-          }
-        }
+        sections: { ingredients: { name: { $in: ['onion', 'salt'] } } }
       }
     });
     assert(matchIn.length === 2);
 
     const matchNotEqual = await service.query(Recipe, {
       where: {
-        sections: {
-          ingredients: {
-            name: { $ne: 'garlic' }
-          }
-        }
+        sections: { ingredients: { name: { $ne: 'garlic' } } }
       }
     });
     assert(matchNotEqual.length === 1);
@@ -613,32 +552,23 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   async verifyArrayOfObjectsProperty() {
     const service = await this.service;
 
-    await service.create(
-      Note,
+    await this.saveAll(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: {
@@ -665,32 +595,17 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
   async verifyNestedObjectArrayProperty() {
     const service = await this.service;
 
-    await service.create(
-      PersonFamily,
+    await this.saveAll(PersonFamily, [
       PersonFamily.from({
-        family: {
-          children: [{ name: 'one' }, { name: 'two' }]
-        }
-      })
-    );
-
-    await service.create(
-      PersonFamily,
+        family: { children: [{ name: 'one' }, { name: 'two' }] }
+      }),
       PersonFamily.from({
-        family: {
-          children: [{ name: 'three' }, { name: 'four' }]
-        }
-      })
-    );
-
-    await service.create(
-      PersonFamily,
+        family: { children: [{ name: 'three' }, { name: 'four' }] }
+      }),
       PersonFamily.from({
-        family: {
-          children: [{ name: 'five' }]
-        }
+        family: { children: [{ name: 'five' }] }
       })
-    );
+    ]);
 
     const inResults = await service.query(PersonFamily, {
       where: {

package/support/test/suggest.ts

@@ -6,7 +6,7 @@ import { Suite, Test } from '@travetto/test';
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
 import type { ModelQuerySuggestSupport } from '../../src/types/suggest.ts';
-import { Person } from './model.ts';
+import { Person, WithNestedLists, WithNestedNestedLists } from './model.ts';
 
 @Suite()
 export abstract class ModelQuerySuggestSuite extends BaseModelSuite<ModelQuerySuggestSupport & ModelCrudSupport> {
@@ -27,6 +27,23 @@ export abstract class ModelQuerySuggestSuite extends BaseModelSuite<ModelQuerySu
     await this.saveAll(Person, people);
   }
 
+  async #loadNestedLists() {
+    await this.saveAll(WithNestedLists, [
+      WithNestedLists.from({ tags: ['apple', 'banana', 'apricot'], names: ['alex', 'amber'] }),
+      WithNestedLists.from({ tags: ['blueberry', 'avocado'], names: ['bob', 'bill'] }),
+      WithNestedLists.from({ tags: ['cherry', 'date'], names: ['charlie'] })
+    ]);
+  }
+
+  async #loadNestedNestedLists() {
+    await this.saveAll(WithNestedNestedLists, [
+      WithNestedNestedLists.from({ tags: ['apple', 'banana'], sub: { names: ['alex', 'amber'] } }),
+      WithNestedNestedLists.from({ tags: ['blueberry'], sub: { names: ['avocado', 'bill'] } }),
+      WithNestedNestedLists.from({ tags: ['cherry'], sub: { names: ['charlie'] } }),
+      WithNestedNestedLists.from({ tags: ['date'] })
+    ]);
+  }
+
   @Test('Verify value suggestion')
   async testSuggestion() {
     const service = await this.service;
@@ -65,4 +82,39 @@ export abstract class ModelQuerySuggestSuite extends BaseModelSuite<ModelQuerySu
     assert(suggestedEntities[0] instanceof Person);
     assert(suggestedEntities[1] instanceof Person);
   }
+
+  @Test('Verify suggestion on string arrays')
+  async verifyStringArraySuggestions() {
+    const service = await this.service;
+
+    await this.#loadNestedLists();
+
+    const suggestedValues = await service.suggestValuesByQuery(WithNestedLists, 'tags', 'ap');
+    assert(suggestedValues.length === 2);
+    assert(suggestedValues[0] === 'apple');
+    assert(suggestedValues[1] === 'apricot');
+
+    const suggestedEntities = await service.suggestByQuery(WithNestedLists, 'tags', 'ap');
+    assert(suggestedEntities.length === 1);
+    assert(suggestedEntities[0] instanceof WithNestedLists);
+    assert(suggestedEntities[0].tags?.includes('apple'));
+  }
+
+  @Test('Verify suggestion on nested string arrays')
+  async verifyNestedStringArraySuggestions() {
+    const service = await this.service;
+
+    await this.#loadNestedNestedLists();
+
+    const suggestedValues = await service.suggestValuesByQuery(WithNestedNestedLists, 'sub.names', 'a');
+    assert(suggestedValues.length === 3);
+    assert(suggestedValues[0] === 'alex');
+    assert(suggestedValues[1] === 'amber');
+    assert(suggestedValues[2] === 'avocado');
+
+    const suggestedEntities = await service.suggestByQuery(WithNestedNestedLists, 'sub.names', 'al');
+    assert(suggestedEntities.length === 1);
+    assert(suggestedEntities[0] instanceof WithNestedNestedLists);
+    assert(suggestedEntities[0].sub?.names?.includes('alex'));
+  }
 }