@travetto/schema 7.0.0-rc.1 → 7.0.0-rc.2

package/src/service/types.ts

@@ -3,7 +3,7 @@ import { Any, Class, Primitive } from '@travetto/runtime';
 import { MethodValidatorFn, ValidatorFn } from '../validate/types.ts';
 
 type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
-export type TemplateLiteral = { op: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
+export type TemplateLiteral = { operation: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
 
 export const CONSTRUCTOR_PROPERTY = 'CONSTRUCTOR';
 
@@ -83,7 +83,7 @@ export interface SchemaFieldMap {
   /**
    * List of all fields
    */
-  [key: string | symbol]: SchemaFieldConfig;
+  [key: string]: SchemaFieldConfig;
 }
 
 /**
@@ -121,7 +121,7 @@ export interface SchemaClassConfig extends SchemaCoreConfig {
   /**
    * Method configs
    */
-  methods: Record<string | symbol, SchemaMethodConfig>;
+  methods: Record<string, SchemaMethodConfig>;
   /**
    * Interfaces that the class implements
    */
@@ -209,7 +209,7 @@ export interface SchemaParameterConfig extends SchemaInputConfig {
   /**
    * Method the parameter belongs to
    */
-  method: string | symbol;
+  method: string;
   /**
    * Source text for the parameter
    */
@@ -223,7 +223,7 @@ export interface SchemaFieldConfig extends SchemaInputConfig {
   /**
    * Field name
    */
-  name: string | symbol;
+  name: string;
   /**
    * Is the field readonly, or write only?, defaults to no restrictions
    */

package/src/types.ts

@@ -3,6 +3,6 @@ export class UnknownType { }
 /**
  * Geometric Point as [number,number] with validation and binding support
  *
- * @concrete ./internal/types.ts#PointImpl
+ * @concrete ./internal/types.ts#PointImplementation
  */
 export type Point = [number, number];

package/src/validate/error.ts

@@ -22,6 +22,6 @@ export class TypeMismatchError extends AppError {
   }
 }
 
-export function isValidationError(err: unknown): err is ValidationError {
-  return !!err && err instanceof Error && 'path' in err;
+export function isValidationError(error: unknown): error is ValidationError {
+  return !!error && error instanceof Error && 'path' in error;
 }

package/src/validate/regexp.ts

@@ -15,8 +15,8 @@ export const CommonRegExp = {
 export const CommonRegExpToName = new Map<RegExp, string>();
 
 // Rebind regexes
-for (const k of TypedObject.keys(CommonRegExp)) {
-  const name = `[[:${k}:]]`;
-  CommonRegExpToName.set(CommonRegExp[k], name);
-  Messages.set(name, Messages.get(k)!);
+for (const key of TypedObject.keys(CommonRegExp)) {
+  const name = `[[:${key}:]]`;
+  CommonRegExpToName.set(CommonRegExp[key], name);
+  Messages.set(name, Messages.get(key)!);
 }

package/src/validate/validator.ts

@@ -11,19 +11,19 @@ import { SchemaRegistryIndex } from '../service/registry-index.ts';
 /**
  * Get the schema config for Class/Schema config, including support for polymorphism
  * @param base The starting type or config
- * @param o The value to use for the polymorphic check
+ * @param item The item to use for the polymorphic check
  */
-function resolveFieldMap<T>(base: Class<T>, o: T): SchemaFieldMap {
-  const target = SchemaRegistryIndex.resolveInstanceType(base, o);
+function resolveFieldMap<T>(base: Class<T>, item: T): SchemaFieldMap {
+  const target = SchemaRegistryIndex.resolveInstanceType(base, item);
   return SchemaRegistryIndex.get(target).getFields();
 }
 
-function isClassInstance<T>(o: unknown): o is ClassInstance<T> {
-  return !DataUtil.isPlainObject(o) && o !== null && typeof o === 'object' && !!o.constructor;
+function isClassInstance<T>(value: unknown): value is ClassInstance<T> {
+  return !DataUtil.isPlainObject(value) && value !== null && typeof value === 'object' && !!value.constructor;
 }
 
-function isRangeValue(o: unknown): o is number | string | Date {
-  return typeof o === 'string' || typeof o === 'number' || o instanceof Date;
+function isRangeValue(value: unknown): value is number | string | Date {
+  return typeof value === 'string' || typeof value === 'number' || value instanceof Date;
 }
 
 /**
@@ -35,15 +35,15 @@ export class SchemaValidator {
   /**
    * Validate the schema for a given object
    * @param fields The config to validate against
-   * @param o The object to validate
+   * @param item The object to validate
    * @param relative The relative path as the validation recurses
    */
-  static #validateFields<T>(fields: SchemaFieldMap, o: T, relative: string): ValidationError[] {
+  static #validateFields<T>(fields: SchemaFieldMap, item: T, relative: string): ValidationError[] {
     let errors: ValidationError[] = [];
 
     for (const [field, fieldConfig] of TypedObject.entries(fields)) {
       if (fieldConfig.access !== 'readonly') { // Do not validate readonly fields
-        errors = errors.concat(this.#validateInputSchema(fieldConfig, o[castKey<T>(field)], relative));
+        errors = errors.concat(this.#validateInputSchema(fieldConfig, item[castKey<T>(field)], relative));
       }
     }
 
@@ -53,13 +53,13 @@ export class SchemaValidator {
   /**
    * Validate a single input config against a passed in value
    * @param input The input schema configuration
-   * @param val The raw value, could be an array or not
+   * @param value The raw value, could be an array or not
    * @param relative The relative path of object traversal
    */
-  static #validateInputSchema(input: SchemaInputConfig, val: unknown, relative: string = ''): ValidationError[] {
+  static #validateInputSchema(input: SchemaInputConfig, value: unknown, relative: string = ''): ValidationError[] {
     const key = 'name' in input ? input.name : ('index' in input ? input.index : 'unknown');
     const path = `${relative}${relative ? '.' : ''}${key}`;
-    const hasValue = !(val === undefined || val === null || (typeof val === 'string' && val === '') || (Array.isArray(val) && val.length === 0));
+    const hasValue = !(value === undefined || value === null || (typeof value === 'string' && value === '') || (Array.isArray(value) && value.length === 0));
 
     if (!hasValue) {
       if (input.required?.active !== false) {
@@ -75,26 +75,26 @@ export class SchemaValidator {
     if (type === Object) {
       return [];
     } else if (array) {
-      if (!Array.isArray(val)) {
-        return this.#prepareErrors(path, [{ kind: 'type', type: Array, value: val }]);
+      if (!Array.isArray(value)) {
+        return this.#prepareErrors(path, [{ kind: 'type', type: Array, value }]);
       }
       let errors: ValidationError[] = [];
       if (complex) {
-        for (let i = 0; i < val.length; i++) {
-          const subErrors = this.#validateFields(resolveFieldMap(type, val[i]), val[i], `${path}[${i}]`);
+        for (let i = 0; i < value.length; i++) {
+          const subErrors = this.#validateFields(resolveFieldMap(type, value[i]), value[i], `${path}[${i}]`);
           errors = errors.concat(subErrors);
         }
       } else {
-        for (let i = 0; i < val.length; i++) {
-          const subErrors = this.#validateInput(input, val[i]);
+        for (let i = 0; i < value.length; i++) {
+          const subErrors = this.#validateInput(input, value[i]);
           errors.push(...this.#prepareErrors(`${path}[${i}]`, subErrors));
         }
       }
       return errors;
     } else if (complex) {
-      return this.#validateFields(resolveFieldMap(type, val), val, path);
+      return this.#validateFields(resolveFieldMap(type, value), value, path);
     } else {
-      const fieldErrors = this.#validateInput(input, val);
+      const fieldErrors = this.#validateInput(input, value);
       return this.#prepareErrors(path, fieldErrors);
     }
   }
@@ -106,13 +106,13 @@ export class SchemaValidator {
    * @param value The value to validate
    */
   static #validateRange(input: SchemaInputConfig, key: 'min' | 'max', value: string | number | Date): boolean {
-    const f = input[key]!;
-    const valueNum = (typeof value === 'string') ?
+    const config = input[key]!;
+    const parsed = (typeof value === 'string') ?
       (input.type === Date ? Date.parse(value) : parseInt(value, 10)) :
       (value instanceof Date ? value.getTime() : value);
 
-    const boundary = (typeof f.n === 'number' ? f.n : f.n.getTime());
-    return key === 'min' ? valueNum < boundary : valueNum > boundary;
+    const boundary = (typeof config.n === 'number' ? config.n : config.n.getTime());
+    return key === 'min' ? parsed < boundary : parsed > boundary;
   }
 
   /**
@@ -184,7 +184,7 @@ export class SchemaValidator {
   static #prepareErrors(path: string, results: ValidationResult[]): ValidationError[] {
     const out: ValidationError[] = [];
     for (const result of results) {
-      const err: ValidationError = {
+      const error: ValidationError = {
         ...result,
         kind: result.kind,
         value: result.value,
@@ -194,20 +194,20 @@ export class SchemaValidator {
         type: (typeof result.type === 'function' ? result.type.name : result.type)
       };
 
-      if (!err.re) {
-        delete err.re;
+      if (!error.re) {
+        delete error.re;
       }
 
       const msg = result.message ?? (
-        Messages.get(err.re ?? '') ??
-        Messages.get(err.kind) ??
+        Messages.get(error.re ?? '') ??
+        Messages.get(error.kind) ??
         Messages.get('default')!
       );
 
-      err.message = msg
-        .replace(/\{([^}]+)\}/g, (_, k: (keyof ValidationError)) => `${err[k]}`);
+      error.message = msg
+        .replace(/\{([^}]+)\}/g, (_, key: (keyof ValidationError)) => `${error[key]}`);
 
-      out.push(err);
+      out.push(error);
     }
     return out;
   }
@@ -215,7 +215,7 @@ export class SchemaValidator {
   /**
    * Validate the class level validations
    */
-  static async #validateClassLevel<T>(cls: Class<T>, o: T, view?: string): Promise<ValidationError[]> {
+  static async #validateClassLevel<T>(cls: Class<T>, item: T, view?: string): Promise<ValidationError[]> {
     if (!SchemaRegistryIndex.has(cls)) {
       return [];
     }
@@ -226,19 +226,19 @@ export class SchemaValidator {
     // Handle class level validators
     for (const fn of classConfig.validators) {
       try {
-        const res = await fn(o, view);
-        if (res) {
-          if (Array.isArray(res)) {
-            errors.push(...res);
+        const error = await fn(item, view);
+        if (error) {
+          if (Array.isArray(error)) {
+            errors.push(...error);
           } else {
-            errors.push(res);
+            errors.push(error);
           }
         }
-      } catch (err: unknown) {
-        if (isValidationError(err)) {
-          errors.push(err);
+      } catch (error: unknown) {
+        if (isValidationError(error)) {
+          errors.push(error);
         } else {
-          throw err;
+          throw error;
         }
       }
     }
@@ -248,60 +248,60 @@ export class SchemaValidator {
   /**
    * Validate an object against it's constructor's schema
    * @param cls The class to validate the objects against
-   * @param o The object to validate
+   * @param item The object to validate
    * @param view The optional view to limit the scope to
    */
-  static async validate<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
-    if (isClassInstance(o) && !(o instanceof cls || cls.Ⲑid === o.constructor.Ⲑid)) {
-      throw new TypeMismatchError(cls.name, o.constructor.name);
+  static async validate<T>(cls: Class<T>, item: T, view?: string): Promise<T> {
+    if (isClassInstance(item) && !(item instanceof cls || cls.Ⲑid === item.constructor.Ⲑid)) {
+      throw new TypeMismatchError(cls.name, item.constructor.name);
     }
-    cls = SchemaRegistryIndex.resolveInstanceType(cls, o);
+    cls = SchemaRegistryIndex.resolveInstanceType(cls, item);
 
     const fields = SchemaRegistryIndex.get(cls).getFields(view);
 
     // Validate using standard behaviors
     const errors = [
-      ...this.#validateFields(fields, o, ''),
-      ... await this.#validateClassLevel(cls, o, view)
+      ...this.#validateFields(fields, item, ''),
+      ... await this.#validateClassLevel(cls, item, view)
     ];
     if (errors.length) {
       throw new ValidationResultError(errors);
     }
 
-    return o;
+    return item;
   }
 
   /**
    * Validate an entire array of values
    * @param cls The class to validate the objects against
-   * @param obj The values to validate
+   * @param items The values to validate
    * @param view The view to limit by
    */
-  static async validateAll<T>(cls: Class<T>, obj: T[], view?: string): Promise<T[]> {
-    return await Promise.all<T>((obj ?? [])
-      .map(o => this.validate(cls, o, view)));
+  static async validateAll<T>(cls: Class<T>, items: T[], view?: string): Promise<T[]> {
+    return await Promise.all<T>((items ?? [])
+      .map(item => this.validate(cls, item, view)));
   }
 
   /**
    * Validate partial, ignoring required fields as they are partial
    *
    * @param cls The class to validate against
-   * @param o The value to validate
+   * @param item The value to validate
    * @param view The view to limit by
    */
-  static async validatePartial<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
+  static async validatePartial<T>(cls: Class<T>, item: T, view?: string): Promise<T> {
     try {
-      await this.validate(cls, o, view);
-    } catch (err) {
-      if (err instanceof ValidationResultError) { // Don't check required fields
-        const errs = err.details.errors.filter(x => x.kind !== 'required');
+      await this.validate(cls, item, view);
+    } catch (error) {
+      if (error instanceof ValidationResultError) { // Don't check required fields
+        const errs = error.details.errors.filter(validationError => validationError.kind !== 'required');
         if (errs.length) {
-          err.details.errors = errs;
-          throw err;
+          error.details.errors = errs;
+          throw error;
         }
       }
     }
-    return o;
+    return item;
   }
 
   /**
@@ -311,7 +311,7 @@ export class SchemaValidator {
    * @param method The method being invoked
    * @param params The params to validate
    */
-  static async validateMethod<T>(cls: Class<T>, method: string | symbol, params: unknown[], prefixes: (string | symbol | undefined)[] = []): Promise<void> {
+  static async validateMethod<T>(cls: Class<T>, method: string, params: unknown[], prefixes: (string | undefined)[] = []): Promise<void> {
     const errors: ValidationError[] = [];
     const config = SchemaRegistryIndex.get(cls).getMethod(method);
 
@@ -320,22 +320,22 @@ export class SchemaValidator {
       errors.push(...[
         ... this.#validateInputSchema(param, params[i]),
         ... await this.#validateClassLevel(param.type, params[i])
-      ].map(x => {
+      ].map(error => {
         if (param.name && typeof param.name === 'string') {
-          x.path = !prefixes[i] ?
-            x.path.replace(`${param.name}.`, '') :
-            x.path.replace(param.name, prefixes[i]!.toString());
+          error.path = !prefixes[i] ?
+            error.path.replace(`${param.name}.`, '') :
+            error.path.replace(param.name, prefixes[i]!);
         }
-        return x;
+        return error;
       }));
     }
     for (const validator of config.validators) {
-      const res = await validator(...params);
-      if (res) {
-        if (Array.isArray(res)) {
-          errors.push(...res);
+      const error = await validator(...params);
+      if (error) {
+        if (Array.isArray(error)) {
+          errors.push(...error);
         } else {
-          errors.push(res);
+          errors.push(error);
         }
       }
     }

package/support/transformer/util.ts

@@ -22,7 +22,7 @@ export class SchemaTransformUtil {
     switch (type.key) {
       case 'pointer': return this.toConcreteType(state, type.target, node, root);
       case 'managed': return state.getOrImport(type);
-      case 'tuple': return state.fromLiteral(type.subTypes.map(x => this.toConcreteType(state, x, node, root)!));
+      case 'tuple': return state.fromLiteral(type.subTypes.map(subType => this.toConcreteType(state, subType, node, root)!));
       case 'template': return state.createIdentifier(type.ctor.name);
       case 'literal': {
         if ((type.ctor === Array) && type.typeArguments?.length) {
@@ -60,7 +60,7 @@ class ${uniqueId} extends ${type.mappedClassName} {
       }
       case 'unknown': {
         const imp = state.importFile(this.TYPES_IMPORT);
-        return state.createAccess(imp.ident, 'UnknownType');
+        return state.createAccess(imp.identifier, 'UnknownType');
       }
       case 'shape': {
         const uniqueId = state.generateUniqueIdentifier(node, type, 'Δ');
@@ -76,18 +76,18 @@ class ${uniqueId} extends ${type.mappedClassName} {
             ],
             id, [], [],
             Object.entries(type.fieldTypes)
-              .map(([k, v]) =>
+              .map(([key, value]) =>
                 this.computeInput(state, state.factory.createPropertyDeclaration(
-                  [], /\W/.test(k) ? state.factory.createComputedPropertyName(state.fromLiteral(k)) : k,
-                  v.undefinable || v.nullable ? state.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-                  v.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined, undefined
-                ), { type: v, root })
+                  [], /\W/.test(key) ? state.factory.createComputedPropertyName(state.fromLiteral(key)) : key,
+                  value.undefinable || value.nullable ? state.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+                  value.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined, undefined
+                ), { type: value, root })
               )
           );
           cls.getText = (): string => [
             `class ${uniqueId} {`,
             ...Object.entries(type.fieldTypes)
-              .map(([k, v]) => `  ${k}${v.nullable ? '?' : ''}: ${v.name};`),
+              .map(([key, value]) => `  ${key}${value.nullable ? '?' : ''}: ${value.name};`),
             '}'
           ].join('\n');
           state.addStatements([cls], root || node);
@@ -135,12 +135,12 @@ class ${uniqueId} extends ${type.mappedClassName} {
         attrs.default = node.initializer;
       }
     } else {
-      const acc = DeclarationUtil.getAccessorPair(node);
+      const pair = DeclarationUtil.getAccessorPair(node);
       attrs.accessor = true;
-      if (!acc.setter) {
+      if (!pair.setter) {
         attrs.access = 'readonly';
       }
-      if (!acc.getter) {
+      if (!pair.getter) {
         attrs.access = 'writeonly';
       } else if (!!typeExpr.undefinable) {
         attrs.required = { active: false };
@@ -160,8 +160,9 @@ class ${uniqueId} extends ${type.mappedClassName} {
     // We need to ensure we aren't being tripped up by the wrapper for arrays, sets, etc.
     // If we have a composition type
     if (primaryExpr.key === 'composition') {
-      const values = primaryExpr.subTypes.map(x => x.key === 'literal' ? x.value : undefined)
-        .filter(x => x !== undefined && x !== null);
+      const values = primaryExpr.subTypes
+        .map(subType => subType.key === 'literal' ? subType.value : undefined)
+        .filter(value => value !== undefined && value !== null);
 
       if (values.length === primaryExpr.subTypes.length) {
         attrs.enum = {
@@ -180,7 +181,9 @@ class ${uniqueId} extends ${type.mappedClassName} {
 
     if (ts.isParameter(node)) {
       const parentComments = DocUtil.describeDocs(node.parent);
-      const paramComments: Partial<ParamDocumentation> = (parentComments.params ?? []).find(x => x.name === node.name.getText()) || {};
+      const paramComments: Partial<ParamDocumentation> = (parentComments.params ?? [])
+        .find(param => param.name === node.name.getText()) || {};
+
       if (paramComments.description) {
         attrs.description = paramComments.description;
       }
@@ -192,9 +195,9 @@ class ${uniqueId} extends ${type.mappedClassName} {
     }
 
     const tags = ts.getJSDocTags(node);
-    const aliases = tags.filter(x => x.tagName.getText() === 'alias');
+    const aliases = tags.filter(tag => tag.tagName.getText() === 'alias');
     if (aliases.length) {
-      attrs.aliases = aliases.map(x => x.comment).filter(x => !!x);
+      attrs.aliases = aliases.map(alias => alias.comment).filter(alias => !!alias);
     }
 
     const params: ts.Expression[] = [];
@@ -241,15 +244,15 @@ class ${uniqueId} extends ${type.mappedClassName} {
   ): T {
     const existingField = state.findDecorator('@travetto/schema', node, 'Field', this.FIELD_IMPORT);
     const existingInput = state.findDecorator('@travetto/schema', node, 'Input', this.INPUT_IMPORT);
-    const decParams = this.computeInputDecoratorParams(state, node, config);
+    const params = this.computeInputDecoratorParams(state, node, config);
 
     let modifiers: ts.ModifierLike[];
     if (existingField) {
-      const dec = state.createDecorator(this.FIELD_IMPORT, 'Field', ...decParams);
-      modifiers = DecoratorUtil.spliceDecorators(node, existingField, [dec]);
+      const decorator = state.createDecorator(this.FIELD_IMPORT, 'Field', ...params);
+      modifiers = DecoratorUtil.spliceDecorators(node, existingField, [decorator]);
     } else {
-      const dec = state.createDecorator(this.INPUT_IMPORT, 'Input', ...decParams);
-      modifiers = DecoratorUtil.spliceDecorators(node, existingInput, [dec]);
+      const decorator = state.createDecorator(this.INPUT_IMPORT, 'Input', ...params);
+      modifiers = DecoratorUtil.spliceDecorators(node, existingInput, [decorator]);
     }
 
     let result: unknown;
@@ -324,8 +327,8 @@ class ${uniqueId} extends ${type.mappedClassName} {
     let cls;
     switch (type?.key) {
       case 'managed': {
-        const [dec] = DeclarationUtil.getDeclarations(type.original!);
-        cls = dec && ts.isClassDeclaration(dec) ? dec : undefined;
+        const [decorator] = DeclarationUtil.getDeclarations(type.original!);
+        cls = decorator && ts.isClassDeclaration(decorator) ? decorator : undefined;
         break;
       }
       case 'shape': cls = type.original; break;

package/support/transformer.schema.ts

@@ -59,8 +59,8 @@ export class SchemaTransformer {
     // Determine auto enrol methods
     for (const item of state.getDecoratorList(node)) {
       if (item.targets?.includes('@travetto/schema:Schema')) {
-        for (const opt of item.options ?? []) {
-          state[AutoEnrollMethods].add(opt);
+        for (const option of item.options ?? []) {
+          state[AutoEnrollMethods].add(option);
         }
       }
     }
@@ -76,7 +76,7 @@ export class SchemaTransformer {
     const comments = DocUtil.describeDocs(node);
 
     const existing = state.findDecorator(this, node, 'Schema', SchemaTransformUtil.SCHEMA_IMPORT);
-    const cons = node.members.find(x => ts.isConstructorDeclaration(x));
+    const cons = node.members.find(member => ts.isConstructorDeclaration(member));
 
     const attrs: Record<string, string | boolean | ts.Expression | number | object | unknown[]> = {};
 
@@ -105,9 +105,9 @@ export class SchemaTransformer {
     if (cons) {
       attrs.methods = {
         [CONSTRUCTOR_PROPERTY]: {
-          parameters: cons.parameters.map((p, i) => SchemaTransformUtil.computeInputDecoratorParams(state, p, { index: i })).map(x =>
-            state.extendObjectLiteral({}, ...x)
-          ),
+          parameters: cons.parameters
+            .map((parameter, i) => SchemaTransformUtil.computeInputDecoratorParams(state, parameter, { index: i }))
+            .map(expr => state.extendObjectLiteral({}, ...expr)),
         }
       };
     }
@@ -163,7 +163,7 @@ export class SchemaTransformer {
       node.name,
       node.questionToken,
       node.typeParameters,
-      node.parameters.map((y, i) => SchemaTransformUtil.computeInput(state, y, { index: i })),
+      node.parameters.map((parameter, i) => SchemaTransformUtil.computeInput(state, parameter, { index: i })),
       node.type,
       node.body
     );