@travetto/model-query 3.1.6 → 3.1.8

package/README.md

@@ -158,6 +158,7 @@ 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
 
@@ -166,7 +167,7 @@ One of the complexities of abstracting multiple storage mechanisms, is providing
 ### Geo Point Fields
 
    *  `field: { $geoWithin: Point[] }` determines if the value is within the bounding region of the points
-   *  `field: {$near: Point, $maxDistance: number, $unit: 'km' | 'm' | 'mi' | 'ft' }` searches at a point, and looks out radially
+   *  `field: { $near: Point, $maxDistance: number, $unit: 'km' | 'm' | 'mi' | 'ft' }` searches at a point, and looks out radially
 
 ### Groupings
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "3.1.6",
+  "version": "3.1.8",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",

package/src/internal/util/types.ts

@@ -3,10 +3,10 @@ import { Class } from '@travetto/base';
 
 import { PointImpl } from '../model/point';
 
-const st = (t: string | string[], arr: boolean = false): Set<string> =>
-  new Set((Array.isArray(t) ? t : [t]).map(v => arr ? `${v}[]` : v));
+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') });
+const basic = (types: Set<string>): Record<string, Set<string>> => ({ $ne: types, $eq: types, $exists: st('boolean'), $empty: 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,6 +44,7 @@ type ArrayField<T> =
   { $ne?: T | T[] } |
   { $all?: T[] } |
   { $in?: T[] } |
+  { $empty?: boolean } |
   PropWhereClause<RetainFields<T>> |
   T | T[];
 

package/support/test/query.ts

@@ -5,7 +5,7 @@ import { BaseModelSuite } from '@travetto/model/support/test/base';
 import { ModelCrudSupport } from '@travetto/model/src/service/crud';
 import { TimeUtil } from '@travetto/base';
 
-import { Aged, Location, Names, Note, Person, SimpleList } from './types';
+import { Aged, Location, Names, Note, Person, SimpleList, WithNestedLists, WithNestedNestedLists } from './types';
 
 import { ModelQuerySupport } from '../../src/service/query';
 
@@ -296,8 +296,148 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       }
     });
     assert(simple4 === 3);
+  }
+
+  @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: []
+    });
+
+    let total = await service.queryCount(WithNestedLists, {
+      where: {
+        names: { $empty: false }
+      }
+    });
+    assert(total === 3);
+    total = await service.queryCount(WithNestedLists, {
+      where: {
+        names: { $empty: true }
+      }
+    });
+    assert(total === 2);
+
+    total = await service.queryCount(WithNestedLists, {
+      where: {
+        tags: { $empty: true }
+      }
+    });
+    assert(total === 3);
+
+    total = await service.queryCount(WithNestedLists, {
+      where: {
+        tags: { $empty: false }
+      }
+    });
+    assert(total === 2);
+
+    total = await service.queryCount(WithNestedLists, {
+      where: {
+        tags: { $empty: true },
+        names: { $empty: true }
+      }
+    });
+    assert(total === 1);
+
+    total = await service.queryCount(WithNestedLists, {
+      where: {
+        tags: { $empty: false },
+        names: { $empty: false }
+      }
+    });
 
+    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: []
+    });
+
+    let total = await service.queryCount(WithNestedNestedLists, {
+      where: {
+        sub: { names: { $empty: false } }
+      }
+    });
+    assert(total === 3);
+    total = await service.queryCount(WithNestedNestedLists, {
+      where: {
+        sub: { names: { $empty: true } }
+      }
+    });
+    assert(total === 2);
+
+    total = await service.queryCount(WithNestedNestedLists, {
+      where: {
+        tags: { $empty: true }
+      }
+    });
+    assert(total === 3);
+
+    total = await service.queryCount(WithNestedNestedLists, {
+      where: {
+        tags: { $empty: false }
+      }
+    });
+    assert(total === 2);
+
+    total = await service.queryCount(WithNestedNestedLists, {
+      where: {
+        tags: { $empty: true },
+        sub: { names: { $empty: true } }
+      }
+    });
+    assert(total === 1);
+
+    total = await service.queryCount(WithNestedNestedLists, {
+      where: {
+        tags: { $empty: false },
+        sub: { names: { $empty: false } }
+      }
+    });
 
+    assert(total === 1);
   }
 }
 

package/support/test/types.ts

@@ -74,4 +74,23 @@ export class Region {
 export class Aged {
   id: string;
   createdAt: Date;
+}
+
+@Model()
+export class WithNestedLists {
+  id: string;
+  tags?: string[] = [];
+  names?: string[] = [];
+}
+
+@Schema()
+class NamedSubNested {
+  names?: string[] = [];
+}
+
+@Model()
+export class WithNestedNestedLists {
+  id: string;
+  tags?: string[] = [];
+  sub?: NamedSubNested;
 }