@travetto/model-query 7.1.4 → 8.0.0-alpha.1

package/package.json

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

package/src/internal/types.ts

@@ -1,5 +1,5 @@
 import type { SchemaFieldConfig, Point } from '@travetto/schema';
-import { type Class, toConcrete } from '@travetto/runtime';
+import { castTo, type Class, toConcrete } from '@travetto/runtime';
 
 const st = (value: string | string[], isArray: boolean = false): Set<string> =>
   new Set((Array.isArray(value) ? value : [value]).map(item => isArray ? `${item}[]` : item));
@@ -18,6 +18,8 @@ const geo = (type: string): Record<string, Set<string>> => ({
 
 const PointConcrete = toConcrete<Point>();
 
+const PRIMITIVE_TYPES = new Set(['string', 'number', 'boolean', 'bigint'] as const);
+
 /**
  * Basic type support
  */
@@ -28,6 +30,7 @@ export class TypeUtil {
   static OPERATORS = {
     string: { ...basic(st('string')), ...scalar(st('string', true)), ...str() },
     number: { ...basic(st('number')), ...scalar(st('number', true)), ...comp(st('number')) },
+    bigint: { ...basic(st('bigint')), ...scalar(st('bigint', true)), ...comp(st('bigint')) },
     boolean: { ...basic(st('boolean')), ...scalar(st('boolean', true)) },
     Date: { ...basic(st('Date')), ...scalar(st('Date', true)), ...comp(st(['string', 'Date'])) },
     Point: { ...basic(st('Point')), ...geo('Point') }
@@ -36,12 +39,13 @@ export class TypeUtil {
   /**
    * Get declared type of a given field, only for primitive types
    */
-  static getDeclaredType(field: SchemaFieldConfig | Class): keyof typeof TypeUtil.OPERATORS | undefined {
+  static getDeclaredType(field: SchemaFieldConfig | Function | Class): keyof typeof TypeUtil.OPERATORS | undefined {
     const type = 'type' in field ? field.type : field;
     switch (type) {
       case String: return 'string';
       case Number: return 'number';
       case Boolean: return 'boolean';
+      case BigInt: return 'bigint';
       case Date: return 'Date';
       case PointConcrete: return 'Point';
       default: {
@@ -57,7 +61,7 @@ export class TypeUtil {
    */
   static getActualType(value: unknown): string {
     const type = typeof value;
-    if (['string', 'number', 'boolean'].includes(type)) {
+    if (PRIMITIVE_TYPES.has(castTo(type))) {
       return type;
     } else if (value instanceof RegExp) {
       return 'RegExp';

package/src/model/where-clause.ts

@@ -1,10 +1,10 @@
-import type { Primitive, RetainPrimitiveFields, TimeSpan } from '@travetto/runtime';
+import type { Primitive, ValidFields, TimeSpan } from '@travetto/runtime';
 import type { Point } from '@travetto/schema';
 
-export type QueryPrimitive = Primitive | Point;
+export type QueryPrimitive = Primitive | Date | Point;
 export type QueryPrimitiveArray = QueryPrimitive[];
 export type DistanceUnit = 'mi' | 'm' | 'km' | 'ft' | 'rad';
-export type RetainQueryPrimitiveFields<T> = RetainPrimitiveFields<T, Point>;
+export type RetainQueryPrimitiveFields<T> = Pick<T, ValidFields<T, QueryPrimitive>>;
 
 type General<T> = {
   $eq?: T;
@@ -45,12 +45,13 @@ type GeoField = {
 export type PropWhereClause<T> = {
   [P in keyof T]?:
   (T[P] extends (number | undefined) ? (General<number> | ScalarField<number> | ComparableField<number> | number) :
-    (T[P] extends (string | undefined) ? (General<string> | ScalarField<string> | StringField | string) :
-      (T[P] extends (boolean | undefined) ? (General<boolean> | boolean) :
-        (T[P] extends (Date | undefined) ? (General<Date> | ScalarField<Date> | ComparableField<Date | TimeSpan> | Date) :
-          (T[P] extends (Point | undefined) ? (General<Point> | ScalarField<Point> | GeoField | Point) :
-            (T[P] extends ((infer U)[] | undefined) ? ArrayField<U> :
-              (T[P] extends (object | undefined) ? PropWhereClause<RetainQueryPrimitiveFields<T[P]>> : never)))))));
+    (T[P] extends (bigint | undefined) ? (General<bigint> | ScalarField<bigint> | ComparableField<bigint> | bigint) :
+      (T[P] extends (string | undefined) ? (General<string> | ScalarField<string> | StringField | string) :
+        (T[P] extends (boolean | undefined) ? (General<boolean> | boolean) :
+          (T[P] extends (Date | undefined) ? (General<Date> | ScalarField<Date> | ComparableField<Date | TimeSpan> | Date) :
+            (T[P] extends (Point | undefined) ? (General<Point> | ScalarField<Point> | GeoField | Point) :
+              (T[P] extends ((infer U)[] | undefined) ? ArrayField<U> :
+                (T[P] extends (object | undefined) ? PropWhereClause<RetainQueryPrimitiveFields<T[P]>> : never))))))));
 };
 
 /**

package/src/util/crud.ts

@@ -13,7 +13,7 @@ export class ModelQueryCrudUtil {
    * Delete all expired
    */
   static async deleteExpired<T extends ModelType>(service: ModelQueryCrudSupport & ModelCrudSupport, cls: Class<T>): Promise<number> {
-    const expiry = await ModelRegistryIndex.getExpiryFieldName(cls);
+    const expiry = ModelRegistryIndex.getExpiryFieldName(cls);
     const count = await service.deleteByQuery<ModelType>(cls, {
       where: {
         [expiry]: {

package/src/util/query.ts

@@ -1,4 +1,4 @@
-import { type Class, AppError, TimeUtil, castTo, hasFunction } from '@travetto/runtime';
+import { type Class, RuntimeError, TimeUtil, castTo, hasFunction } from '@travetto/runtime';
 import { type ModelType, NotFoundError, ModelRegistryIndex } from '@travetto/model';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
@@ -46,7 +46,7 @@ export class ModelQueryUtil {
         throw error;
       }
     } else {
-      throw new AppError(`Invalid number of results: ${result.length}`, { category: 'data' });
+      throw new RuntimeError(`Invalid number of results: ${result.length}`, { category: 'data' });
     }
   }
 

package/src/verifier.ts

@@ -1,6 +1,6 @@
 /* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none"} ] */
 import { DataUtil, ValidationResultError, type ValidationError, SchemaRegistryIndex } from '@travetto/schema';
-import type { Class } from '@travetto/runtime';
+import { JSONUtil, type Class } from '@travetto/runtime';
 
 import type { ModelQuery, Query, PageableModelQuery } from './model/query.ts';
 
@@ -29,8 +29,8 @@ const SORT = 'sort';
 // const GROUP_BY = 'groupBy';
 
 const MULTIPLE_KEYS_ALLOWED = new Set([
-  '$maxDistance', '$gt',
-  '$minDistance', '$lt',
+  '$maxDistance', '$gt', '$gte',
+  '$minDistance', '$lt', '$lte',
   '$near'
 ]);
 
@@ -110,14 +110,12 @@ export class QueryVerifier {
    * Check operator clause
    */
   static checkOperatorClause(state: State, declaredType: SimpleType, value: unknown, allowed: Record<string, Set<string>>, isArray: boolean): void {
-    if (isArray) {
-      if (Array.isArray(value)) {
-        // Handle array literal
-        for (const item of value) {
-          this.checkOperatorClause(state, declaredType, item, allowed, false);
-        }
-        return;
+    if (isArray && Array.isArray(value)) {
+      // Handle array literal
+      for (const item of value) {
+        this.checkOperatorClause(state, declaredType, item, allowed, false);
       }
+      return;
     }
 
     if (!DataUtil.isPlainObject(value)) {
@@ -228,7 +226,7 @@ export class QueryVerifier {
         if (value === 1 || value === -1 || typeof value === 'boolean') {
           return;
         }
-        state.log(`Only true, false -1, and 1 are allowed for sorting, not ${JSON.stringify(value)}`);
+        state.log(`Only true, false -1, and 1 are allowed for sorting, not ${JSONUtil.toUTF8(value)}`);
       }
     });
   }
@@ -269,7 +267,7 @@ export class QueryVerifier {
   /**
    * Verify the query
    */
-  static verify<T>(cls: Class<T>, query?: ModelQuery<T> | Query<T> | PageableModelQuery<T>): void {
+  static async verify<T>(cls: Class<T>, query?: ModelQuery<T> | Query<T> | PageableModelQuery<T>): Promise<void> {
     if (!query) {
       return;
     }

package/support/test/crud.ts

@@ -5,7 +5,7 @@ import { type ModelCrudSupport, NotFoundError } from '@travetto/model';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { Address, Person, Todo } from './model.ts';
+import { Address, Person, Todo, BigIntModel } from './model.ts';
 import type { ModelQueryCrudSupport } from '../../src/types/crud.ts';
 
 @Suite()
@@ -151,5 +151,106 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 0);
 
   }
+
+  @Test()
+  async testBigIntQuery() {
+    const svc = await this.service;
+
+    // Create test data with various bigint values
+    const count = await this.saveAll(BigIntModel, [
+      BigIntModel.from({ largeNumber: 100n, optionalBigInt: 1000n }),
+      BigIntModel.from({ largeNumber: 200n, optionalBigInt: 2000n }),
+      BigIntModel.from({ largeNumber: 300n }),
+      BigIntModel.from({ largeNumber: 9007199254740991n, optionalBigInt: 1234567890123456789n }),
+      BigIntModel.from({ largeNumber: 18014398509481982n }),
+    ]);
+
+    assert(count === 5);
+
+    // Test equality
+    const exact = await svc.query(BigIntModel, { where: { largeNumber: 200n } });
+    assert(exact.length === 1);
+    assert(exact[0].largeNumber === 200n);
+    assert(exact[0].optionalBigInt === 2000n);
+
+    // Test greater than
+    const greaterThan = await svc.query(BigIntModel, { where: { largeNumber: { $gt: 200n } } });
+    assert(greaterThan.length === 3);
+    assert(greaterThan.every(x => x.largeNumber > 200n));
+
+    // Test less than or equal
+    const lessThanOrEqual = await svc.query(BigIntModel, { where: { largeNumber: { $lte: 300n } } });
+    assert(lessThanOrEqual.length === 3);
+    assert(lessThanOrEqual.every(x => x.largeNumber <= 300n));
+
+    // Test range query
+    const range = await svc.query(BigIntModel, { where: { largeNumber: { $gte: 100n, $lte: 300n } } });
+    assert(range.length === 3);
+    assert(range.every(x => x.largeNumber >= 100n && x.largeNumber <= 300n));
+
+    // Test with optional field
+    const withOptional = await svc.query(BigIntModel, { where: { optionalBigInt: { $exists: true } } });
+    assert(withOptional.length === 3);
+    assert(withOptional.every(x => x.optionalBigInt !== undefined));
+
+    // Test count with bigint condition
+    const countResult = await svc.queryCount(BigIntModel, { where: { largeNumber: { $gte: 1000n } } });
+    assert(countResult === 2);
+  }
+
+  @Test()
+  async testBigIntUpdateByQuery() {
+    const svc = await this.service;
+
+    const count = await this.saveAll(BigIntModel, [
+      BigIntModel.from({ largeNumber: 100n, optionalBigInt: 1000n }),
+      BigIntModel.from({ largeNumber: 200n, optionalBigInt: 2000n }),
+      BigIntModel.from({ largeNumber: 300n }),
+    ]);
+
+    assert(count === 3);
+
+    // Update records with bigint condition
+    const updated = await svc.updatePartialByQuery(
+      BigIntModel,
+      { where: { largeNumber: { $lte: 200n } } },
+      { optionalBigInt: 5000n }
+    );
+
+    assert(updated === 2);
+
+    // Verify updates
+    const results = await svc.query(BigIntModel, { where: { optionalBigInt: 5000n } });
+    assert(results.length === 2);
+    assert(results.every(x => x.optionalBigInt === 5000n));
+    assert(results.every(x => x.largeNumber <= 200n));
+  }
+
+  @Test()
+  async testBigIntDeleteByQuery() {
+    const svc = await this.service;
+
+    const count = await this.saveAll(BigIntModel, [
+      BigIntModel.from({ largeNumber: 100n }),
+      BigIntModel.from({ largeNumber: 200n }),
+      BigIntModel.from({ largeNumber: 300n }),
+      BigIntModel.from({ largeNumber: 400n }),
+      BigIntModel.from({ largeNumber: 500n }),
+    ]);
+
+    assert(count === 5);
+
+    // Delete records with bigint condition
+    const deleted = await svc.deleteByQuery(BigIntModel, { where: { largeNumber: { $gt: 300n } } });
+
+    assert(deleted === 2);
+
+    // Verify deletions
+    const remaining = await svc.queryCount(BigIntModel, {});
+    assert(remaining === 3);
+
+    const all = await svc.query(BigIntModel, {});
+    assert(all.every(x => x.largeNumber <= 300n));
+  }
 }
 

package/support/test/model.ts

@@ -91,4 +91,11 @@ export class WithNestedNestedLists {
   id: string;
   tags?: string[] = [];
   sub?: NamedSubNested;
+}
+
+@Model('bigint-model-2')
+export class BigIntModel {
+  id: string;
+  largeNumber: bigint;
+  optionalBigInt?: bigint;
 }

package/support/test/query.ts

@@ -345,8 +345,8 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     const simple3 = await service.queryCount(Aged, {
       where: {
         createdAt: {
-          $gt: '-.9d',
-          $lt: '2.9d'
+          $gt: '-1296m', // -1.9d
+          $lt: '4176m' // 2.9d
         }
       }
     });
@@ -355,8 +355,8 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     const simple4 = await service.queryCount(Aged, {
       where: {
         createdAt: {
-          $gt: TimeUtil.fromNow('-0.1d'),
-          $lt: TimeUtil.fromNow('2.9d')
+          $gt: TimeUtil.fromNow('-144m'), // -0.1d
+          $lt: TimeUtil.fromNow('4176m') // 2.9d
         }
       }
     });