@travetto/model-query 3.1.14 → 3.1.15

package/README.md

@@ -131,7 +131,7 @@ One of the complexities of abstracting multiple storage mechanisms, is providing
 
    *  `field: { $eq: T }` to determine if a field is equal to a value
    *  `field: { $ne: T }` to determine if a field is not equal to a value
-   *  `field: { $exists: boolean }` to determine if a field exists or not
+   *  `field: { $exists: boolean }` to determine if a field exists or not, or for arrays, if its empty or not
    *  `field: T` to see if the field is equal to whatever value is passed in`
 
 ### General Single Valued Fields
@@ -158,7 +158,6 @@ One of the complexities of abstracting multiple storage mechanisms, is providing
 ### Array Fields
 
    *  `field: { $all: T[]] }` checks to see if the records value contains everything within `$all`
-   *  `field: { $empty: boolean }` to determine if an array is missing or is of zero length. 
 
 ### String Fields
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "3.1.14",
+  "version": "3.1.15",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",
@@ -27,12 +27,12 @@
     "directory": "module/model-query"
   },
   "dependencies": {
-    "@travetto/di": "^3.1.4",
-    "@travetto/model": "^3.1.14",
-    "@travetto/schema": "^3.1.8"
+    "@travetto/di": "^3.1.5",
+    "@travetto/model": "^3.1.15",
+    "@travetto/schema": "^3.1.9"
   },
   "peerDependencies": {
-    "@travetto/test": "^3.1.5"
+    "@travetto/test": "^3.1.6"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/internal/util/types.ts

@@ -6,7 +6,7 @@ import { PointImpl } from '../model/point';
 const st = (t: string | string[], isArr: boolean = false): Set<string> =>
   new Set((Array.isArray(t) ? t : [t]).map(v => isArr ? `${v}[]` : v));
 
-const basic = (types: Set<string>): Record<string, Set<string>> => ({ $ne: types, $eq: types, $exists: st('boolean'), $empty: st('boolean') });
+const basic = (types: Set<string>): Record<string, Set<string>> => ({ $ne: types, $eq: types, $exists: st('boolean') });
 const scalar = (types: Set<string>): Record<string, Set<string>> => ({ $in: types, $nin: types });
 const str = (): Record<string, Set<string>> => ({ $regex: st(['RegExp', 'string']) });
 const comp = (types: Set<string>): Record<string, Set<string>> => ({ $lt: types, $lte: types, $gt: types, $gte: types });

package/src/model/where-clause.ts

@@ -44,7 +44,6 @@ type ArrayField<T> =
   { $ne?: T | T[] } |
   { $all?: T[] } |
   { $in?: T[] } |
-  { $empty?: boolean } |
   PropWhereClause<RetainFields<T>> |
   T | T[];
 

package/support/test/query.ts

@@ -326,43 +326,43 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     let total = await service.queryCount(WithNestedLists, {
       where: {
-        names: { $empty: false }
+        names: { $exists: true }
       }
     });
     assert(total === 3);
     total = await service.queryCount(WithNestedLists, {
       where: {
-        names: { $empty: true }
+        names: { $exists: false }
       }
     });
     assert(total === 2);
 
     total = await service.queryCount(WithNestedLists, {
       where: {
-        tags: { $empty: true }
+        tags: { $exists: false }
       }
     });
     assert(total === 3);
 
     total = await service.queryCount(WithNestedLists, {
       where: {
-        tags: { $empty: false }
+        tags: { $exists: true }
       }
     });
     assert(total === 2);
 
     total = await service.queryCount(WithNestedLists, {
       where: {
-        tags: { $empty: true },
-        names: { $empty: true }
+        tags: { $exists: false },
+        names: { $exists: false }
       }
     });
     assert(total === 1);
 
     total = await service.queryCount(WithNestedLists, {
       where: {
-        tags: { $empty: false },
-        names: { $empty: false }
+        tags: { $exists: true },
+        names: { $exists: true }
       }
     });
 
@@ -397,43 +397,43 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     let total = await service.queryCount(WithNestedNestedLists, {
       where: {
-        sub: { names: { $empty: false } }
+        sub: { names: { $exists: true } }
       }
     });
     assert(total === 3);
     total = await service.queryCount(WithNestedNestedLists, {
       where: {
-        sub: { names: { $empty: true } }
+        sub: { names: { $exists: false } }
       }
     });
     assert(total === 2);
 
     total = await service.queryCount(WithNestedNestedLists, {
       where: {
-        tags: { $empty: true }
+        tags: { $exists: false }
       }
     });
     assert(total === 3);
 
     total = await service.queryCount(WithNestedNestedLists, {
       where: {
-        tags: { $empty: false }
+        tags: { $exists: true }
       }
     });
     assert(total === 2);
 
     total = await service.queryCount(WithNestedNestedLists, {
       where: {
-        tags: { $empty: true },
-        sub: { names: { $empty: true } }
+        tags: { $exists: false },
+        sub: { names: { $exists: false } }
       }
     });
     assert(total === 1);
 
     total = await service.queryCount(WithNestedNestedLists, {
       where: {
-        tags: { $empty: false },
-        sub: { names: { $empty: false } }
+        tags: { $exists: true },
+        sub: { names: { $exists: true } }
       }
     });