@travetto/schema 2.1.3 → 2.2.0

package/src/validate/validator.ts

@@ -2,18 +2,19 @@ import { Class, ClassInstance, Util } from '@travetto/base';
 
 import { FieldConfig, SchemaConfig } from '../service/types';
 import { SchemaRegistry } from '../service/registry';
-import { ValidationError, ValidationKind, ValidationResult } from './types';
+import { ValidationError, ValidationKindCore, ValidationResult } from './types';
 import { Messages } from './messages';
-import { TypeMismatchError, ValidationResultError } from './error';
+import { isValidationError, TypeMismatchError, ValidationResultError } from './error';
 
 /**
  * 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
  */
-function resolveSchema<T>(base: Class<T>, o: T, view?: string) {
+function resolveSchema<T>(base: Class<T>, o: T, view?: string): SchemaConfig {
   return SchemaRegistry.getViewSchema(
-    SchemaRegistry.resolveSubTypeForInstance(base, o), view).schema;
+    SchemaRegistry.resolveSubTypeForInstance(base, o), view
+  ).schema;
 }
 
 declare global {
@@ -34,11 +35,13 @@ export class SchemaValidator {
    * @param o The object to validate
    * @param relative The relative path as the validation recurses
    */
-  static #validateSchema<T>(schema: SchemaConfig, o: T, relative: string) {
+  static #validateSchema<T>(schema: SchemaConfig, o: T, relative: string): ValidationError[] {
     let errors: ValidationError[] = [];
 
-    for (const field of Object.keys(schema)) {
+    const fields: (keyof SchemaConfig)[] = Object.keys(schema);
+    for (const field of fields) {
       if (schema[field].access !== 'readonly') { // Do not validate readonly fields
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         errors = errors.concat(this.#validateFieldSchema(schema[field], o[field as keyof T], relative));
       }
     }
@@ -52,7 +55,7 @@ export class SchemaValidator {
    * @param val The raw value, could be an array or not
    * @param relative The relative path of object traversal
    */
-  static #validateFieldSchema(fieldSchema: FieldConfig, val: unknown, relative: string = '') {
+  static #validateFieldSchema(fieldSchema: FieldConfig, val: unknown, relative: string = ''): ValidationError[] {
     const path = `${relative}${relative && '.'}${fieldSchema.name}`;
 
     const hasValue = !(val === undefined || val === null || (typeof val === 'string' && val === '') || (Array.isArray(val) && val.length === 0));
@@ -101,11 +104,15 @@ export class SchemaValidator {
    * @param key The bounds to check
    * @param value The value to validate
    */
-  static #validateRange(field: FieldConfig, key: 'min' | 'max', value: string | number | Date) {
+  static #validateRange(field: FieldConfig, key: 'min' | 'max', rawValue: string | number | Date | unknown): boolean {
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    let value = rawValue as string | number | Date;
+
     const f = field[key]!;
     if (typeof f.n === 'number') {
-      if (typeof value !== 'number') {
-        value = parseInt(value as string, 10);
+      if (typeof value === 'string') {
+        value = parseInt(value, 10);
       }
       if (field.type === Date) {
         value = new Date(value);
@@ -132,7 +139,7 @@ export class SchemaValidator {
    * @param value The actual value
    */
   static #validateField(field: FieldConfig, value: unknown): ValidationResult[] {
-    const criteria: ValidationKind[] = [];
+    const criteria: ([string, FieldConfig[ValidationKindCore]] | [string])[] = [];
 
     if (
       (field.type === String && (typeof value !== 'string')) ||
@@ -140,7 +147,7 @@ export class SchemaValidator {
       (field.type === Date && (!(value instanceof Date) || Number.isNaN(value.getTime()))) ||
       (field.type === Boolean && typeof value !== 'boolean')
     ) {
-      criteria.push('type');
+      criteria.push(['type']);
       return [{ kind: 'type', type: field.type.name.toLowerCase() }];
     }
 
@@ -150,38 +157,37 @@ export class SchemaValidator {
         case undefined: break;
         case 'type': return [{ kind, type: field.type.name }];
         default:
-          criteria.push(kind as 'type');
+          criteria.push([kind]);
       }
     }
 
     if (field.match && !field.match.re.test(`${value}`)) {
-      criteria.push('match');
+      criteria.push(['match', field.match]);
     }
 
     if (field.minlength && `${value}`.length < field.minlength.n) {
-      criteria.push('minlength');
+      criteria.push(['minlength', field.minlength]);
     }
 
     if (field.maxlength && `${value}`.length > field.maxlength.n) {
-      criteria.push('maxlength');
+      criteria.push(['maxlength', field.maxlength]);
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     if (field.enum && !field.enum.values.includes(value as string)) {
-      criteria.push('enum');
+      criteria.push(['enum', field.enum]);
     }
 
-    if (field.min && this.#validateRange(field, 'min', value as number)) {
-      criteria.push('min');
+    if (field.min && this.#validateRange(field, 'min', value)) {
+      criteria.push(['min', field.min]);
     }
 
-    if (field.max && this.#validateRange(field, 'max', value as number)) {
-      criteria.push('max');
+    if (field.max && this.#validateRange(field, 'max', value)) {
+      criteria.push(['max', field.max]);
     }
 
     const errors: ValidationResult[] = [];
-    for (const key of criteria) {
-      const block = field[key as keyof FieldConfig];
-      // @ts-expect-error
+    for (const [key, block] of criteria) {
       errors.push({ ...block, kind: key, value });
     }
 
@@ -196,24 +202,29 @@ export class SchemaValidator {
   static #prepareErrors(path: string, results: ValidationResult[]): ValidationError[] {
     const out: ValidationError[] = [];
     for (const res of results) {
-      const err: Partial<ValidationError> = {
-        ...(res as ValidationError),
-        path
+      const err: ValidationError = {
+        kind: res.kind,
+        value: res.value,
+        message: '',
+        re: res.re?.name ?? res.re?.source ?? '',
+        path,
+        type: (typeof res.type === 'function' ? res.type.name : res.type)
       };
 
-      const msg = res.message ??
-        Messages.get(res.re?.name ?? res.re?.source ?? '') ??
-        Messages.get(res.kind) ??
-        Messages.get('default')!;
-
-      if (res.re) {
-        err.re = res.re?.name ?? res.re?.source ?? '';
+      if (!err.re) {
+        delete err.re;
       }
 
+      const msg = res.message ?? (
+        Messages.get(err.re ?? '') ??
+        Messages.get(err.kind) ??
+        Messages.get('default')!
+      );
+
       err.message = msg
-        .replace(/\{([^}]+)\}/g, (a: string, k: string) => `${err[k as (keyof ValidationError)]}`);
+        .replace(/\{([^}]+)\}/g, (_, k: (keyof ValidationError)) => `${err[k]}`);
 
-      out.push(err as ValidationError);
+      out.push(err);
     }
     return out;
   }
@@ -225,8 +236,10 @@ export class SchemaValidator {
    * @param view The optional view to limit the scope to
    */
   static async validate<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     if (!Util.isPlainObject(o) && !(o instanceof cls || cls.ᚕid === (o as ClassInstance<T>).constructor.ᚕid)) {
-      throw new TypeMismatchError(cls.name, (o as unknown as ClassInstance).constructor.name);
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      throw new TypeMismatchError(cls.name, (o as ClassInstance).constructor.name);
     }
     cls = SchemaRegistry.resolveSubTypeForInstance(cls, o);
 
@@ -243,8 +256,12 @@ export class SchemaValidator {
         if (res) {
           errors.push(res);
         }
-      } catch (err) {
-        errors.push(err);
+      } catch (err: unknown) {
+        if (isValidationError(err)) {
+          errors.push(err);
+        } else {
+          throw err;
+        }
       }
     }
 
@@ -276,12 +293,12 @@ export class SchemaValidator {
   static async validatePartial<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
     try {
       await this.validate(cls, o, view);
-    } catch (e) {
-      if (e instanceof ValidationResultError) { // Don't check required fields
-        const errs = e.errors.filter(x => x.kind !== 'required');
+    } catch (err) {
+      if (err instanceof ValidationResultError) { // Don't check required fields
+        const errs = err.errors.filter(x => x.kind !== 'required');
         if (errs.length) {
-          e.errors = errs;
-          throw e;
+          err.errors = errs;
+          throw err;
         }
       }
     }
@@ -295,7 +312,7 @@ export class SchemaValidator {
    * @param method The method being invoked
    * @param params The params to validate
    */
-  static validateMethod<T>(cls: Class<T>, method: string, params: unknown[]) {
+  static validateMethod<T>(cls: Class<T>, method: string, params: unknown[]): void {
     const errors: ValidationError[] = [];
     for (const field of SchemaRegistry.getMethodSchema(cls, method)) {
       errors.push(...this.#validateFieldSchema(field, params[field.index!]));

package/support/phase.init.ts

@@ -4,7 +4,7 @@
 export const init = {
   key: '@trv:schema/init',
   after: ['@trv:registry/init'], // Should be global
-  action: async () => {
+  action: async (): Promise<void> => {
     const { BindUtil } = await import('../src/bind-util');
     BindUtil.register();
   }

package/support/transform-util.ts

@@ -48,7 +48,7 @@ export class SchemaTransformUtil {
               ), { type: v, root })
             )
           );
-          cls.getText = () => '';
+          cls.getText = (): string => '';
           state.addStatement(cls, root || node);
         }
         return id;
@@ -57,6 +57,11 @@ export class SchemaTransformUtil {
         if (type.commonType) {
           return this.toConcreteType(state, type.commonType, node, root);
         }
+        break;
+      }
+      case 'unknown':
+      default: {
+        // Object
       }
     }
     return state.createIdentifier('Object');
@@ -115,7 +120,7 @@ export class SchemaTransformUtil {
 
     if (ts.isParameter(node)) {
       const comments = DocUtil.describeDocs(node.parent);
-      const commentConfig = (comments.params ?? []).find(x => x.name === node.name.getText()) || {} as Partial<ParamDocumentation>;
+      const commentConfig: Partial<ParamDocumentation> = (comments.params ?? []).find(x => x.name === node.name.getText()) || {};
       if (commentConfig.description) {
         attrs.push(state.factory.createPropertyAssignment('description', state.fromLiteral(commentConfig.description)));
       }
@@ -148,15 +153,19 @@ export class SchemaTransformUtil {
         })));
       }
 
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return state.factory.updatePropertyDeclaration(node as Exclude<typeof node, T>,
         newDecs, node.modifiers, node.name, node.questionToken, node.type, node.initializer) as T;
     } else if (ts.isParameter(node)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return state.factory.updateParameterDeclaration(node as Exclude<typeof node, T>,
         newDecs, node.modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) as T;
     } else if (ts.isGetAccessorDeclaration(node)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return state.factory.updateGetAccessorDeclaration(node as Exclude<typeof node, T>,
         newDecs, node.modifiers, node.name, node.parameters, node.type, node.body) as T;
     } else {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return state.factory.updateSetAccessorDeclaration(node as Exclude<typeof node, T>,
         newDecs, node.modifiers, node.name, node.parameters, node.body) as T;
     }
@@ -165,7 +174,7 @@ export class SchemaTransformUtil {
   /**
    * Unwrap type
    */
-  static unwrapType(type: AnyType) {
+  static unwrapType(type: AnyType): { out: Record<string, unknown>, type: AnyType } {
     const out: Record<string, unknown> = {};
 
     while (type?.key === 'literal' && type.typeArguments?.length) {
@@ -205,7 +214,7 @@ export class SchemaTransformUtil {
    * @param methodName
    * @returns
    */
-  static findInnerReturnMethod(state: TransformerState, node: ts.MethodDeclaration, methodName: string) {
+  static findInnerReturnMethod(state: TransformerState, node: ts.MethodDeclaration, methodName: string): ts.MethodDeclaration | undefined {
     // Process returnType
     const { type } = this.unwrapType(state.resolveReturnType(node));
     let cls;

package/support/transformer.schema.ts

@@ -28,7 +28,7 @@ export class SchemaTransformer {
    * Track schema on start
    */
   @OnClass('Schema')
-  static startSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration, dec?: DecoratorMeta) {
+  static startSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration, dec?: DecoratorMeta): ts.ClassDeclaration {
     state[inSchema] = true;
     state[accessors] = new Set();
     return node;
@@ -38,7 +38,7 @@ export class SchemaTransformer {
    * Mark the end of the schema, document
    */
   @AfterClass('Schema')
-  static finalizeSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration) {
+  static finalizeSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
     const decls = [...(node.decorators ?? [])];
 
     const comments = DocUtil.describeDocs(node);
@@ -71,7 +71,7 @@ export class SchemaTransformer {
    * Handle all properties, while in schema
    */
   @OnProperty()
-  static processSchemaField(state: TransformerState & AutoState, node: ts.PropertyDeclaration) {
+  static processSchemaField(state: TransformerState & AutoState, node: ts.PropertyDeclaration): ts.PropertyDeclaration {
     const ignore = state.findDecorator(this, node, 'Ignore');
     return state[inSchema] && !ignore && DeclarationUtil.isPublic(node) ?
       SchemaTransformUtil.computeField(state, node) : node;
@@ -81,7 +81,7 @@ export class SchemaTransformer {
    * Handle getters
    */
   @OnGetter()
-  static processSchemaGetter(state: TransformerState & AutoState, node: ts.GetAccessorDeclaration) {
+  static processSchemaGetter(state: TransformerState & AutoState, node: ts.GetAccessorDeclaration): ts.GetAccessorDeclaration {
     const ignore = state.findDecorator(this, node, 'Ignore');
     if (state[inSchema] && !ignore && DeclarationUtil.isPublic(node) && !state[accessors]?.has(node.name.getText())) {
       state[accessors]?.add(node.name.getText());
@@ -94,7 +94,7 @@ export class SchemaTransformer {
    * Handle setters
    */
   @OnSetter()
-  static processSchemaSetter(state: TransformerState & AutoState, node: ts.SetAccessorDeclaration) {
+  static processSchemaSetter(state: TransformerState & AutoState, node: ts.SetAccessorDeclaration): ts.SetAccessorDeclaration {
     const ignore = state.findDecorator(this, node, 'Ignore');
     if (state[inSchema] && !ignore && DeclarationUtil.isPublic(node) && !state[accessors]?.has(node.name.getText())) {
       state[accessors]?.add(node.name.getText());