@travetto/model-query 6.0.1 → 7.0.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "6.0.1",
+  "version": "7.0.0-rc.0",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",
@@ -26,12 +26,12 @@
     "directory": "module/model-query"
   },
   "dependencies": {
-    "@travetto/di": "^6.0.1",
-    "@travetto/model": "^6.0.1",
-    "@travetto/schema": "^6.0.1"
+    "@travetto/di": "^7.0.0-rc.0",
+    "@travetto/model": "^7.0.0-rc.0",
+    "@travetto/schema": "^7.0.0-rc.0"
   },
   "peerDependencies": {
-    "@travetto/test": "^6.0.2"
+    "@travetto/test": "^7.0.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/internal/types.ts

@@ -1,4 +1,4 @@
-import { FieldConfig, Point } from '@travetto/schema';
+import { SchemaFieldConfig, Point } from '@travetto/schema';
 import { Class, toConcrete } from '@travetto/runtime';
 
 const st = (t: string | string[], isArr: boolean = false): Set<string> =>
@@ -36,7 +36,7 @@ export class TypeUtil {
   /**
    * Get declared type of a given field, only for primitive types
    */
-  static getDeclaredType(f: FieldConfig | Class): keyof typeof TypeUtil.OPERATORS | undefined {
+  static getDeclaredType(f: SchemaFieldConfig | Class): keyof typeof TypeUtil.OPERATORS | undefined {
     const type = 'type' in f ? f.type : f;
     switch (type) {
       case String: return 'string';

package/src/model/query.ts

@@ -1,17 +1,17 @@
-import { WhereClauseRaw, RetainFields } from './where-clause.ts';
+import { WhereClauseRaw, RetainQueryPrimitiveFields } from './where-clause.ts';
 
 type SelectClauseRaw<T> = {
   [P in keyof T]?:
-  T[P] extends object ? SelectClauseRaw<RetainFields<T[P]>> : (1 | 0 | boolean);
+  T[P] extends object ? SelectClauseRaw<RetainQueryPrimitiveFields<T[P]>> : (1 | 0 | boolean);
 };
 
 type GroupClauseRaw<T> = {
-  [P in keyof T]?: T[P] extends object ? GroupClauseRaw<RetainFields<T[P]>> : (1 | 0 | boolean);
+  [P in keyof T]?: T[P] extends object ? GroupClauseRaw<RetainQueryPrimitiveFields<T[P]>> : (1 | 0 | boolean);
 };
 
 type SortClauseRaw<T> = {
   [P in keyof T]?:
-  T[P] extends object ? SortClauseRaw<RetainFields<T[P]>> : 1 | -1;
+  T[P] extends object ? SortClauseRaw<RetainQueryPrimitiveFields<T[P]>> : 1 | -1;
 };
 
 type QueryOptionsRaw<T> = {
@@ -34,28 +34,28 @@ type PageableModelQueryRaw<T> = ModelQueryRaw<T> & QueryOptionsRaw<T>;
 /**
  * Type of a full query
  */
-export type Query<T> = QueryRaw<RetainFields<T>>;
+export type Query<T> = QueryRaw<RetainQueryPrimitiveFields<T>>;
 /**
  * Query with support for pagination (limit, offset)
  */
-export type PageableModelQuery<T> = PageableModelQueryRaw<RetainFields<T>>;
+export type PageableModelQuery<T> = PageableModelQueryRaw<RetainQueryPrimitiveFields<T>>;
 /**
  * Standard query options (limit, offset)
  */
-export type QueryOptions<T> = QueryOptionsRaw<RetainFields<T>>;
+export type QueryOptions<T> = QueryOptionsRaw<RetainQueryPrimitiveFields<T>>;
 /**
  * Select clause
  */
-export type SelectClause<T> = SelectClauseRaw<RetainFields<T>>;
+export type SelectClause<T> = SelectClauseRaw<RetainQueryPrimitiveFields<T>>;
 /**
  * Sort clause
  */
-export type SortClause<T> = SortClauseRaw<RetainFields<T>>;
+export type SortClause<T> = SortClauseRaw<RetainQueryPrimitiveFields<T>>;
 /**
  * Group clause
  */
-export type GroupClause<T> = GroupClauseRaw<RetainFields<T>>;
+export type GroupClause<T> = GroupClauseRaw<RetainQueryPrimitiveFields<T>>;
 /**
  * Model query, requiring a model object
  */
-export type ModelQuery<T> = ModelQueryRaw<RetainFields<T>>;
+export type ModelQuery<T> = ModelQueryRaw<RetainQueryPrimitiveFields<T>>;

package/src/model/where-clause.ts

@@ -1,18 +1,10 @@
-import type { Primitive, TimeSpan } from '@travetto/runtime';
+import type { Primitive, RetainPrimitiveFields, TimeSpan } from '@travetto/runtime';
 import { Point } from '@travetto/schema';
 
 export type QueryPrimitive = Primitive | Point;
 export type QueryPrimitiveArray = QueryPrimitive[];
 export type DistanceUnit = 'mi' | 'm' | 'km' | 'ft' | 'rad';
-
-export type ValidFieldNames<T> = {
-  [K in keyof T]:
-  (T[K] extends (QueryPrimitive | undefined) ? K :
-    (T[K] extends (Function | undefined) ? never :
-      K))
-}[keyof T];
-
-export type RetainFields<T> = Pick<T, ValidFieldNames<T>>;
+export type RetainQueryPrimitiveFields<T> = RetainPrimitiveFields<T, Point>;
 
 type General<T> = {
   $eq?: T;
@@ -38,7 +30,7 @@ type ArrayField<T> =
   { $ne?: T | T[] } |
   { $all?: T[] } |
   { $in?: T[] } |
-  PropWhereClause<RetainFields<T>> |
+  PropWhereClause<RetainQueryPrimitiveFields<T>> |
   T | T[];
 
 type StringField = { $regex?: RegExp | string };
@@ -58,7 +50,7 @@ export type PropWhereClause<T> = {
         (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<RetainFields<T[P]>> : never)))))));
+              (T[P] extends (object | undefined) ? PropWhereClause<RetainQueryPrimitiveFields<T[P]>> : never)))))));
 };
 
 /**
@@ -73,7 +65,7 @@ export type WhereClauseRaw<T> =
 /**
  * Full where clause, typed against the input type T
  */
-export type WhereClause<T> = WhereClauseRaw<RetainFields<T>>;
+export type WhereClause<T> = WhereClauseRaw<RetainQueryPrimitiveFields<T>>;
 
 /**
  * Provides all the valid string type fields from a given type T

package/src/util/crud.ts

@@ -1,5 +1,5 @@
 import { Class, hasFunction } from '@travetto/runtime';
-import { ModelType, ModelCrudSupport, ModelRegistry } from '@travetto/model';
+import { ModelType, ModelCrudSupport, ModelRegistryIndex } from '@travetto/model';
 
 import { ModelQueryCrudSupport } from '../types/crud.ts';
 
@@ -13,7 +13,7 @@ export class ModelQueryCrudUtil {
    * Delete all expired
    */
   static async deleteExpired<T extends ModelType>(svc: ModelQueryCrudSupport & ModelCrudSupport, cls: Class<T>): Promise<number> {
-    const expiry = await ModelRegistry.getExpiry(cls);
+    const expiry = await ModelRegistryIndex.getExpiryFieldName(cls);
     const res = await svc.deleteByQuery<ModelType>(cls, {
       where: {
         [expiry]: {

package/src/util/query.ts

@@ -1,6 +1,6 @@
 import { Class, AppError, TimeUtil, castTo, hasFunction } from '@travetto/runtime';
-import { ModelType, ModelRegistry, NotFoundError } from '@travetto/model';
-import { SchemaRegistry } from '@travetto/schema';
+import { ModelType, NotFoundError, ModelRegistryIndex } from '@travetto/model';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { WhereClause, WhereClauseRaw } from '../model/where-clause.ts';
 import { ModelQuerySupport } from '../types/query.ts';
@@ -56,11 +56,17 @@ export class ModelQueryUtil {
   static getWhereClause<T extends ModelType>(cls: Class<T>, q: WhereClause<T> | undefined, checkExpiry = true): WhereClause<T> {
     const clauses: WhereClauseRaw<T>[] = (q ? [q] : []);
 
-    const conf = ModelRegistry.get(cls);
-    if (conf.subType) {
-      const { subTypeField, subTypeName } = SchemaRegistry.get(cls);
-      clauses.push(castTo({ [subTypeField]: subTypeName }));
+    const polymorphicConfig = SchemaRegistryIndex.getDiscriminatedConfig(cls);
+    if (polymorphicConfig) {
+      clauses.push(castTo(polymorphicConfig.discriminatedBase ? {
+        [polymorphicConfig.discriminatedField]: { $in: SchemaRegistryIndex.getDiscriminatedTypes(cls) }
+      } : {
+        [polymorphicConfig.discriminatedField]: polymorphicConfig.discriminatedType
+      }
+      ));
     }
+
+    const conf = ModelRegistryIndex.getConfig(cls);
     if (checkExpiry && conf.expiresAt) {
       clauses.push(castTo({
         $or: [

package/src/util/suggest.ts

@@ -1,6 +1,6 @@
-import { ModelRegistry, ModelType } from '@travetto/model';
+import { ModelRegistryIndex, ModelType } from '@travetto/model';
 import { castTo, Class, hasFunction } from '@travetto/runtime';
-import { SchemaRegistry } from '@travetto/schema';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { PageableModelQuery, Query } from '../model/query.ts';
 import { ValidStringFields, WhereClauseRaw } from '../model/where-clause.ts';
@@ -27,15 +27,25 @@ export class ModelQuerySuggestUtil {
    * Build suggest query on top of query language
    */
   static getSuggestQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: Query<T>): Query<T> {
-    const config = ModelRegistry.get(cls);
     const limit = query?.limit ?? 10;
     const clauses: WhereClauseRaw<ModelType>[] = prefix ? [{ [field]: { $regex: this.getSuggestRegex(prefix) } }] : [];
+    const select: Query<T>['select'] = {
+      ...query?.select
+    };
 
-    if (config.subType) {
-      const { subTypeField, subTypeName } = SchemaRegistry.get(cls);
-      clauses.push({ [subTypeField]: subTypeName });
+    const polymorphicConfig = SchemaRegistryIndex.getDiscriminatedConfig(cls);
+    if (polymorphicConfig) {
+      clauses.push({
+        [polymorphicConfig.discriminatedField]: polymorphicConfig.discriminatedBase ?
+          { $in: SchemaRegistryIndex.getDiscriminatedTypes(cls) } :
+          polymorphicConfig.discriminatedType
+      });
+      if (query?.select) {
+        Object.assign(select, { [polymorphicConfig.discriminatedField]: true });
+      }
     }
 
+    const config = ModelRegistryIndex.getConfig(cls);
     if (config.expiresAt) {
       clauses.push({ [config.expiresAt]: { $gt: new Date() } });
     }
@@ -47,7 +57,7 @@ export class ModelQuerySuggestUtil {
     return {
       where: clauses.length ? (clauses.length > 1 ? { $and: clauses } : clauses[0]) : {},
       limit,
-      select: query?.select
+      select
     };
   }
 
@@ -84,10 +94,6 @@ export class ModelQuerySuggestUtil {
    * Build suggestion query
    */
   static getSuggestFieldQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Query<T> {
-    const config = ModelRegistry.get(cls);
-    return this.getSuggestQuery<T>(cls, castTo(field), prefix, {
-      ...(query ?? {}),
-      select: castTo({ [field]: true, ...(config.subType ? { [SchemaRegistry.get(cls).subTypeField]: true } : {}) })
-    });
+    return this.getSuggestQuery<T>(cls, castTo(field), prefix, query);
   }
 }

package/src/verifier.ts

@@ -1,5 +1,5 @@
 /* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none"} ] */
-import { DataUtil, SchemaRegistry, ValidationResultError, ValidationError } from '@travetto/schema';
+import { DataUtil, ValidationResultError, ValidationError, SchemaRegistryIndex } from '@travetto/schema';
 import { Class } from '@travetto/runtime';
 
 import { ModelQuery, Query, PageableModelQuery } from './model/query.ts';
@@ -52,7 +52,7 @@ export class QueryVerifier {
    * Handle generic clauses
    */
   static processGenericClause<T>(state: State, cls: Class<T>, val: object, handler: ProcessingHandler): void {
-    const view = SchemaRegistry.getViewSchema(cls);
+    const view = SchemaRegistryIndex.getConfig(cls).fields;
 
     if (val === undefined || val === null) {
       state.log('Value cannot be undefined or null');
@@ -75,23 +75,23 @@ export class QueryVerifier {
         continue;
       }
 
-      if (!(key in view.schema)) {
+      if (!(key in view)) {
         state.log(`Unknown member ${key} of ${cls.name}`);
         continue;
       }
 
       // Find field
-      const field = view.schema[key];
+      const field = view[key];
       const op = TypeUtil.getDeclaredType(field);
 
       // If a simple operation
       if (op) {
-        handler.onSimpleType(state.extend(key), op, value, field.array);
+        handler.onSimpleType(state.extend(key), op, value, field.array ?? false);
       } else {
         // Otherwise recurse
         const subCls = field.type;
         const subVal = value;
-        if (handler.onComplexType && handler.onComplexType(state, subCls, subVal, field.array)) {
+        if (handler.onComplexType && handler.onComplexType(state, subCls, subVal, field.array ?? false)) {
           continue;
         }
         this.processGenericClause(state.extend(key), subCls, subVal, handler);