@travetto/model-query 7.0.0-rc.1 → 7.0.0-rc.3

package/README.md

@@ -235,31 +235,31 @@ class CustomModelService extends QueryModelService implements ModelQueryCrudSupp
 }
 
 @Suite()
-export class CustomQuerySuite extends ModelQuerySuite {
+class CustomQuerySuite extends ModelQuerySuite {
   serviceClass = CustomModelService;
   configClass = CustomModelConfig;
 }
 
 @Suite()
-export class CustomQueryCrudSuite extends ModelQueryCrudSuite {
+class CustomQueryCrudSuite extends ModelQueryCrudSuite {
   serviceClass = CustomModelService;
   configClass = CustomModelConfig;
 }
 
 @Suite()
-export class CustomQueryFacetSuite extends ModelQueryFacetSuite {
+class CustomQueryFacetSuite extends ModelQueryFacetSuite {
   serviceClass = CustomModelService;
   configClass = CustomModelConfig;
 }
 
 @Suite()
-export class CustomQueryPolymorphismSuite extends ModelQueryPolymorphismSuite {
+class CustomQueryPolymorphismSuite extends ModelQueryPolymorphismSuite {
   serviceClass = CustomModelService;
   configClass = CustomModelConfig;
 }
 
 @Suite()
-export class CustomQuerySuggestSuite extends ModelQuerySuggestSuite {
+class CustomQuerySuggestSuite extends ModelQuerySuggestSuite {
   serviceClass = CustomModelService;
   configClass = CustomModelConfig;
 }

package/package.json

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

package/src/internal/types.ts

@@ -1,8 +1,8 @@
 import { SchemaFieldConfig, Point } from '@travetto/schema';
 import { Class, toConcrete } from '@travetto/runtime';
 
-const st = (t: string | string[], isArr: boolean = false): Set<string> =>
-  new Set((Array.isArray(t) ? t : [t]).map(v => isArr ? `${v}[]` : v));
+const st = (value: string | string[], isArray: boolean = false): Set<string> =>
+  new Set((Array.isArray(value) ? value : [value]).map(item => isArray ? `${item}[]` : item));
 
 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 });
@@ -16,7 +16,7 @@ const geo = (type: string): Record<string, Set<string>> => ({
   $geoIntersects: st(type, true)
 });
 
-const PointImpl = toConcrete<Point>();
+const PointConcrete = toConcrete<Point>();
 
 /**
  * Basic type support
@@ -36,17 +36,17 @@ export class TypeUtil {
   /**
    * Get declared type of a given field, only for primitive types
    */
-  static getDeclaredType(f: SchemaFieldConfig | Class): keyof typeof TypeUtil.OPERATORS | undefined {
-    const type = 'type' in f ? f.type : f;
+  static getDeclaredType(field: SchemaFieldConfig | 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 Date: return 'Date';
-      case PointImpl: return 'Point';
+      case PointConcrete: return 'Point';
       default: {
-        if ('type' in f && f.array) {
-          return this.getDeclaredType(f.type);
+        if ('type' in field && field.array) {
+          return this.getDeclaredType(field.type);
         }
       }
     }
@@ -55,22 +55,22 @@ export class TypeUtil {
   /**
    * Get the actual type of a given field, only for primitive types
    */
-  static getActualType(v: unknown): string {
-    const type = typeof v;
+  static getActualType(value: unknown): string {
+    const type = typeof value;
     if (['string', 'number', 'boolean'].includes(type)) {
       return type;
-    } else if (v instanceof RegExp) {
+    } else if (value instanceof RegExp) {
       return 'RegExp';
-    } else if (v instanceof Date) {
+    } else if (value instanceof Date) {
       return 'Date';
-    } else if (Array.isArray(v)) {
-      const typeString: string = `${this.getActualType(v[0])}[]`;
-      if (v.length === 2 && typeString === 'number[]') {
+    } else if (Array.isArray(value)) {
+      const typeString: string = `${this.getActualType(value[0])}[]`;
+      if (value.length === 2 && typeString === 'number[]') {
         return 'Point';
       } else {
         return typeString;
       }
     }
-    throw new Error(`Unknown type for ${v}`);
+    throw new Error(`Unknown type for ${value}`);
   }
 }

package/src/util/crud.ts

@@ -12,15 +12,15 @@ export class ModelQueryCrudUtil {
   /**
    * Delete all expired
    */
-  static async deleteExpired<T extends ModelType>(svc: ModelQueryCrudSupport & ModelCrudSupport, cls: Class<T>): Promise<number> {
+  static async deleteExpired<T extends ModelType>(service: ModelQueryCrudSupport & ModelCrudSupport, cls: Class<T>): Promise<number> {
     const expiry = await ModelRegistryIndex.getExpiryFieldName(cls);
-    const res = await svc.deleteByQuery<ModelType>(cls, {
+    const count = await service.deleteByQuery<ModelType>(cls, {
       where: {
         [expiry]: {
           $lt: new Date()
         }
       }
     });
-    return res ?? 0;
+    return count ?? 0;
   }
 }

package/src/util/query.ts

@@ -17,14 +17,14 @@ export class ModelQueryUtil {
 
   /**
    * Resolve comparator
-   * @param val
+   * @param value
    * @returns
    */
-  static resolveComparator(val: unknown): unknown {
-    if (typeof val === 'string' && TimeUtil.isTimeSpan(val)) {
-      return TimeUtil.fromNow(val);
+  static resolveComparator(value: unknown): unknown {
+    if (typeof value === 'string' && TimeUtil.isTimeSpan(value)) {
+      return TimeUtil.fromNow(value);
     } else {
-      return val;
+      return value;
     }
   }
 
@@ -41,9 +41,9 @@ export class ModelQueryUtil {
       if (requestedId) {
         throw new NotFoundError(cls, requestedId);
       } else {
-        const err = new NotFoundError(cls, 'unknown');
-        err.message = 'No results found for query';
-        throw err;
+        const error = new NotFoundError(cls, 'unknown');
+        error.message = 'No results found for query';
+        throw error;
       }
     } else {
       throw new AppError(`Invalid number of results: ${result.length}`, { category: 'data' });
@@ -53,8 +53,8 @@ export class ModelQueryUtil {
   /**
    * Get a where clause with type
    */
-  static getWhereClause<T extends ModelType>(cls: Class<T>, q: WhereClause<T> | undefined, checkExpiry = true): WhereClause<T> {
-    const clauses: WhereClauseRaw<T>[] = (q ? [q] : []);
+  static getWhereClause<T extends ModelType>(cls: Class<T>, where: WhereClause<T> | undefined, checkExpiry = true): WhereClause<T> {
+    const clauses: WhereClauseRaw<T>[] = (where ? [where] : []);
 
     const polymorphicConfig = SchemaRegistryIndex.getDiscriminatedConfig(cls);
     if (polymorphicConfig) {
@@ -66,28 +66,28 @@ export class ModelQueryUtil {
       ));
     }
 
-    const conf = ModelRegistryIndex.getConfig(cls);
-    if (checkExpiry && conf.expiresAt) {
+    const indexConfig = ModelRegistryIndex.getConfig(cls);
+    if (checkExpiry && indexConfig.expiresAt) {
       clauses.push(castTo({
         $or: [
-          { [conf.expiresAt]: { $exists: false } },
-          { [conf.expiresAt]: undefined },
-          { [conf.expiresAt]: { $gte: new Date() } },
+          { [indexConfig.expiresAt]: { $exists: false } },
+          { [indexConfig.expiresAt]: undefined },
+          { [indexConfig.expiresAt]: { $gte: new Date() } },
         ]
       }));
     }
     if (clauses.length > 1) {
-      q = { $and: clauses };
+      where = { $and: clauses };
     } else {
-      q = clauses[0];
+      where = clauses[0];
     }
-    return q!;
+    return where!;
   }
 
-  static has$And = (o: unknown): o is ({ $and: WhereClause<unknown>[] }) =>
-    !!o && typeof o === 'object' && '$and' in o;
-  static has$Or = (o: unknown): o is ({ $or: WhereClause<unknown>[] }) =>
-    !!o && typeof o === 'object' && '$or' in o;
-  static has$Not = (o: unknown): o is ({ $not: WhereClause<unknown> }) =>
-    !!o && typeof o === 'object' && '$not' in o;
+  static has$And = (value: unknown): value is ({ $and: WhereClause<unknown>[] }) =>
+    !!value && typeof value === 'object' && '$and' in value;
+  static has$Or = (value: unknown): value is ({ $or: WhereClause<unknown>[] }) =>
+    !!value && typeof value === 'object' && '$or' in value;
+  static has$Not = (value: unknown): value is ({ $not: WhereClause<unknown> }) =>
+    !!value && typeof value === 'object' && '$not' in value;
 }

package/src/util/suggest.ts

@@ -75,18 +75,18 @@ export class ModelQuerySuggestUtil {
     const pattern = this.getSuggestRegex(prefix);
 
     const out: ([string, U] | readonly [string, U])[] = [];
-    for (const r of results) {
-      const val = r[field];
-      if (Array.isArray(val)) {
-        out.push(...val.filter(f => pattern.test(f)).map((f: string) => [f, transform(f, r)] as const));
-      } else if (typeof val === 'string') {
-        out.push([val, transform(val, r)]);
+    for (const result of results) {
+      const resultValue = result[field];
+      if (Array.isArray(resultValue)) {
+        out.push(...resultValue.filter(item => pattern.test(item)).map((item: string) => [item, transform(item, result)] as const));
+      } else if (typeof resultValue === 'string') {
+        out.push([resultValue, transform(resultValue, result)]);
       }
     }
     return out
       .toSorted((a, b) => a[0].localeCompare(b[0]))
       .map((a) => a[1])
-      .filter((x, i, arr) => x !== arr[i - 1])
+      .filter((result, i, arr) => result !== arr[i - 1])
       .slice(0, limit ?? 10);
   }
 

package/src/verifier.ts

@@ -12,7 +12,7 @@ interface State {
   path: string;
   collect(element: string, message: string): void;
   extend(path: string): State;
-  log(err: string): void;
+  log(error: string): void;
 }
 
 interface ProcessingHandler {
@@ -51,19 +51,19 @@ export class QueryVerifier {
   /**
    * Handle generic clauses
    */
-  static processGenericClause<T>(state: State, cls: Class<T>, val: object, handler: ProcessingHandler): void {
+  static processGenericClause<T>(state: State, cls: Class<T>, clause: object, handler: ProcessingHandler): void {
     const view = SchemaRegistryIndex.getConfig(cls).fields;
 
-    if (val === undefined || val === null) {
+    if (clause === undefined || clause === null) {
       state.log('Value cannot be undefined or null');
       return;
     }
 
-    if (handler.preMember && handler.preMember(state, val)) {
+    if (handler.preMember && handler.preMember(state, clause)) {
       return;
     }
 
-    for (const [key, value] of Object.entries(val)) {
+    for (const [key, value] of Object.entries(clause)) {
 
       // Validate value is correct, and key is valid
       if (value === undefined || value === null) {
@@ -82,19 +82,19 @@ export class QueryVerifier {
 
       // Find field
       const field = view[key];
-      const op = TypeUtil.getDeclaredType(field);
+      const type = TypeUtil.getDeclaredType(field);
 
       // If a simple operation
-      if (op) {
-        handler.onSimpleType(state.extend(key), op, value, field.array ?? false);
+      if (type) {
+        handler.onSimpleType(state.extend(key), type, value, field.array ?? false);
       } else {
         // Otherwise recurse
         const subCls = field.type;
-        const subVal = value;
-        if (handler.onComplexType && handler.onComplexType(state, subCls, subVal, field.array ?? false)) {
+        const subValue = value;
+        if (handler.onComplexType && handler.onComplexType(state, subCls, subValue, field.array ?? false)) {
           continue;
         }
-        this.processGenericClause(state.extend(key), subCls, subVal, handler);
+        this.processGenericClause(state.extend(key), subCls, subValue, handler);
       }
     }
   }
@@ -113,8 +113,8 @@ export class QueryVerifier {
     if (isArray) {
       if (Array.isArray(value)) {
         // Handle array literal
-        for (const el of value) {
-          this.checkOperatorClause(state, declaredType, el, allowed, false);
+        for (const item of value) {
+          this.checkOperatorClause(state, declaredType, item, allowed, false);
         }
         return;
       }
@@ -141,30 +141,30 @@ export class QueryVerifier {
     }
 
     // Should only be one?
-    for (const [k, v] of Object.entries(value)) {
-      if (k === '$all' || k === '$elemMatch' || k === '$in' || k === '$nin') {
-        if (!Array.isArray(v)) {
-          state.log(`${k} operator requires comparison to be an array, not ${typeof v}`);
+    for (const [key, keyValue] of Object.entries(value)) {
+      if (key === '$all' || key === '$elemMatch' || key === '$in' || key === '$nin') {
+        if (!Array.isArray(keyValue)) {
+          state.log(`${key} operator requires comparison to be an array, not ${typeof keyValue}`);
           return;
-        } else if (v.length === 0) {
-          state.log(`${k} operator requires comparison to be a non-empty array`);
+        } else if (keyValue.length === 0) {
+          state.log(`${key} operator requires comparison to be a non-empty array`);
           return;
         }
 
-        for (const el of v) {
-          const elAct = TypeUtil.getActualType(el);
-          if (!this.typesMatch(declaredType, elAct)) {
-            state.log(`${k} operator requires all values to be ${declaredType}, but ${elAct} was found`);
+        for (const item of keyValue) {
+          const itemType = TypeUtil.getActualType(item);
+          if (!this.typesMatch(declaredType, itemType)) {
+            state.log(`${key} operator requires all values to be ${declaredType}, but ${itemType} was found`);
             return;
           }
         }
-      } else if (!(k in allowed)) {
-        state.log(`Operation ${k}, not allowed for field of type ${declaredType}`);
+      } else if (!(key in allowed)) {
+        state.log(`Operation ${key}, not allowed for field of type ${declaredType}`);
       } else {
-        const actualSubType = TypeUtil.getActualType(v)!;
+        const actualSubType = TypeUtil.getActualType(keyValue)!;
 
-        if (!allowed[k].has(actualSubType)) {
-          state.log(`Passed in value ${actualSubType} mismatches with expected type(s) ${Array.from(allowed[k])}`);
+        if (!allowed[key].has(actualSubType)) {
+          state.log(`Passed in value ${actualSubType} mismatches with expected type(s) ${Array.from(allowed[key])}`);
         }
       }
     }
@@ -190,8 +190,8 @@ export class QueryVerifier {
             state.log(`${firstKey} requires the value to be an array`);
           } else {
             // Iterate
-            for (const el of sub) {
-              this.processWhereClause(state, cls, el);
+            for (const item of sub) {
+              this.processWhereClause(state, cls, item);
             }
             return true;
           }
@@ -208,7 +208,7 @@ export class QueryVerifier {
       onSimpleType: (state: State, type: SimpleType, value: unknown, isArray: boolean) => {
         this.checkOperatorClause(state, type, value, TypeUtil.OPERATORS[type], isArray);
       },
-      onComplexType: (state: State, subCls: Class<T>, subVal: T, isArray: boolean): boolean => false
+      onComplexType: (state: State, subCls: Class<T>, subValue: T, isArray: boolean): boolean => false
     });
   }
 
@@ -281,8 +281,8 @@ export class QueryVerifier {
       collect(path: string, message: string): void {
         errors.push({ message: `${path}: ${message}`, path, kind: 'model' });
       },
-      log(err: string): void {
-        this.collect(this.path, err);
+      log(error: string): void {
+        this.collect(this.path, error);
       },
       extend<S extends { path: string }>(this: S, sub: string): S {
         return { ...this, path: !this.path ? sub : `${this.path}.${sub}` };
@@ -302,15 +302,15 @@ export class QueryVerifier {
         continue;
       }
 
-      const val = query[key];
+      const value = query[key];
       const subState = state.extend(key);
 
-      if (Array.isArray(val)) {
-        for (const el of val) {
-          this[fn](subState, cls, el);
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          this[fn](subState, cls, item);
         }
-      } else if (typeof val !== 'string') {
-        this[fn](subState, cls, val);
+      } else if (typeof value !== 'string') {
+        this[fn](subState, cls, value);
       }
     }
 

package/support/doc.support.tsx

@@ -29,5 +29,5 @@ export const ModelQueryTypes = (fn: Function): DocJSXElement[] => {
       found.push(link);
     }
   }
-  return found.map(v => <li>{v}</li>);
+  return found.map(type => <li>{type}</li>);
 };