@travetto/schema 5.0.0-rc.8 → 5.0.0

package/README.md

@@ -63,28 +63,28 @@ User:
 
 ### Fields
 This schema provides a powerful base for data binding and validation at runtime.  Additionally there may be types that cannot be detected, or some information that the programmer would like to override. Below are the supported field decorators:
-   *  [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L31) defines a field that will be serialized.
-   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L71) defines a that field should be required
-   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L78) defines the allowable values that a field can have
-   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) defines a regular expression that the field value should match
-   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107) enforces min length of a string
-   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117) enforces max length of a string
-   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107) enforces min value for a date or a number
-   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117) enforces max value for a date or a number
-   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L144) ensures string field matches basic email regex
-   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L151) ensures string field matches basic telephone regex
-   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L158) ensures string field matches basic url regex
-   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L197) exclude from auto schema registration
-   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L172) ensures number passed in is only a whole number
-   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L178) ensures number passed in allows fractional values
-   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L190) provides support for standard currency
-   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L86) indicates that a field is expecting natural language input, not just discrete values
-   *  [@LongText](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L91) same as text, but expects longer form content
-   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L58) defines a that field should not be bindable external to the class
-   *  [@Writeonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L52) defines a that field should not be exported in serialization, but that it can be bound to
-   *  [@Secret](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L64) marks a field as being sensitive.  This is used by certain logging activities to ensure sensitive information is not logged out.
-   *  [@Specifier](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L206) attributes additional specifiers to a field, allowing for more specification beyond just the field's type.
-   *  [@SubTypeField](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L212) allows for promoting a given field as the owner of the sub type discriminator (defaults to `type`).
+   *  [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L30) defines a field that will be serialized.
+   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L70) defines a that field should be required
+   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L77) defines the allowable values that a field can have
+   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L98) defines a regular expression that the field value should match
+   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L106) enforces min length of a string
+   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116) enforces max length of a string
+   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L106) enforces min value for a date or a number
+   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116) enforces max value for a date or a number
+   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L143) ensures string field matches basic email regex
+   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L150) ensures string field matches basic telephone regex
+   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L157) ensures string field matches basic url regex
+   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L196) exclude from auto schema registration
+   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L171) ensures number passed in is only a whole number
+   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L177) ensures number passed in allows fractional values
+   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L189) provides support for standard currency
+   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L85) indicates that a field is expecting natural language input, not just discrete values
+   *  [@LongText](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L90) same as text, but expects longer form content
+   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L57) defines a that field should not be bindable external to the class
+   *  [@Writeonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L51) defines a that field should not be exported in serialization, but that it can be bound to
+   *  [@Secret](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L63) marks a field as being sensitive.  This is used by certain logging activities to ensure sensitive information is not logged out.
+   *  [@Specifier](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L205) attributes additional specifiers to a field, allowing for more specification beyond just the field's type.
+   *  [@SubTypeField](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L211) allows for promoting a given field as the owner of the sub type discriminator (defaults to `type`).
 Additionally, schemas can be nested to form more complex data structures that are able to bound and validated. 
 
 Just like the class, all fields can be defined with
@@ -312,7 +312,7 @@ This feature is meant to allow for simple Typescript types to be able to be back
 
 **Code: Simple Custom Type**
 ```typescript
-import { DataUtil } from '@travetto/runtime';
+import { DataUtil } from '@travetto/schema';
 
 /**
  * @concrete #PointImpl
@@ -329,7 +329,8 @@ export class PointImpl {
 
   static bindSchema(input: unknown): [number, number] | typeof INVALID | undefined {
     if (Array.isArray(input) && input.length === 2) {
-      return input.map(x => DataUtil.coerceType(x, Number, false)) as [number, number];
+      const [a, b] = input.map(x => DataUtil.coerceType(x, Number, false));
+      return [a, b];
     } else {
       return INVALID;
     }
@@ -378,7 +379,7 @@ Validation Failed {
 ```
 
 ## Data Utilities
-Data utilities for binding values, and type conversion. Currently [DataUtil](https://github.com/travetto/travetto/tree/main/module/schema/src/data.ts#L10) includes:
+Data utilities for binding values, and type conversion. Currently [DataUtil](https://github.com/travetto/travetto/tree/main/module/schema/src/data.ts#L11) includes:
    *  `deepAssign(a, b, mode ?)` which allows for deep assignment of `b` onto `a`, the `mode` determines how aggressive the assignment is, and how flexible it is.  `mode` can have any of the following values:
       *  `loose`, which is the default is the most lenient. It will not error out, and overwrites will always happen
       *  `coerce`, will attempt to force values from `b` to fit the types of `a`, and if it can't it will error out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "5.0.0-rc.8",
+  "version": "5.0.0",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
     "schema",
@@ -27,10 +27,10 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^5.0.0-rc.8"
+    "@travetto/registry": "^5.0.0"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^5.0.0-rc.5"
+    "@travetto/transformer": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/bind-util.ts

@@ -1,4 +1,4 @@
-import { Class, ConcreteClass, TypedObject } from '@travetto/runtime';
+import { castTo, Class, classConstruct, asFull, TypedObject, castKey } from '@travetto/runtime';
 
 import { DataUtil } from './data';
 import { AllViewⲐ } from './internal/types';
@@ -11,6 +11,10 @@ type BindConfig = {
   filterValue?: (value: unknown, field: FieldConfig) => boolean;
 };
 
+function isInstance<T>(o: unknown): o is T {
+  return !!o && !DataUtil.isPrimitive(o);
+}
+
 /**
  * Utilities for binding objects to schemas
  */
@@ -35,8 +39,7 @@ export class BindUtil {
         }
       }
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return val as T;
+    return castTo(val);
   }
 
   /**
@@ -64,13 +67,11 @@ export class BindUtil {
         if (!(name in sub)) {
           sub[name] = typeof key === 'number' ? [] : {};
         }
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        sub = sub[name] as Record<string, unknown>;
+        sub = castTo(sub[name]);
 
         if (idx && key !== undefined) {
           sub[key] ??= {};
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          sub = sub[key] as Record<string, unknown>;
+          sub = castTo(sub[key]);
         }
       }
 
@@ -89,11 +90,9 @@ export class BindUtil {
         let key = (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined));
         sub[name] ??= (typeof key === 'string') ? {} : [];
 
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const arrSub = sub[name] as Record<string, unknown>;
+        const arrSub: Record<string, unknown> & { length: number } = castTo(sub[name]);
         if (key === undefined) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          key = arrSub.length as number;
+          key = arrSub.length;
         }
         if (arrSub[key] && DataUtil.isPlainObject(val) && DataUtil.isPlainObject(arrSub[key])) {
           arrSub[key] = DataUtil.deepAssign(arrSub[key], val, 'coerce');
@@ -127,8 +126,7 @@ export class BindUtil {
           }
         }
       } else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        out[pre] = (value ?? '') as V;
+        out[pre] = castTo(value ?? '');
       }
     }
     return out;
@@ -147,24 +145,19 @@ export class BindUtil {
     if (data === null || data === undefined) {
       return data;
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const cls = SchemaRegistry.resolveInstanceType<T>(cons, data as T);
+    const cls = SchemaRegistry.resolveInstanceType<T>(cons, asFull<T>(data));
     if (data instanceof cls) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return data as T;
+      return castTo(data);
     } else {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const tgt = new (cls as ConcreteClass<T>)() as T;
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      SchemaRegistry.ensureInstanceTypeField(cls, tgt as T & { type?: string });
+      const tgt = classConstruct<T & { type?: string }>(cls);
+      SchemaRegistry.ensureInstanceTypeField(cls, tgt);
 
       for (const k of TypedObject.keys(tgt)) { // Do not retain undefined fields
         if (tgt[k] === undefined) {
           delete tgt[k];
         }
       }
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return this.bindSchemaToObject(cls, tgt, data as object, cfg);
+      return this.bindSchemaToObject(cls, tgt, data, cfg);
     }
   }
 
@@ -179,14 +172,13 @@ export class BindUtil {
     const view = cfg.view ?? AllViewⲐ; // Does not convey
     delete cfg.view;
 
-    if (!!data && !DataUtil.isPrimitive(data)) {
+    if (!!data && isInstance<T>(data)) {
       const conf = SchemaRegistry.get(cons);
 
       // If no configuration
       if (!conf) {
         for (const k of TypedObject.keys(data)) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          obj[k] = data[k as keyof typeof data];
+          obj[k] = data[k];
         }
       } else {
 
@@ -217,8 +209,7 @@ export class BindUtil {
             continue;
           }
 
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          let v: unknown = data[inboundField as keyof typeof data];
+          let v: unknown = data[castKey<T>(inboundField)];
 
           // Filtering values
           if (cfg.filterValue && !cfg.filterValue(v, field)) {
@@ -248,8 +239,7 @@ export class BindUtil {
             }
           }
 
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          obj[schemaFieldName as keyof typeof obj] = v as (typeof obj)[keyof typeof obj];
+          obj[castKey<T>(schemaFieldName)] = castTo(v);
 
           if (field.accessor) {
             Object.defineProperty(obj, schemaFieldName, {

package/src/data.ts

@@ -1,6 +1,7 @@
 import { isNumberObject as isNum, isBooleanObject as isBool, isStringObject as isStr } from 'node:util/types';
 
-import { Class, ClassInstance, TypedObject } from '@travetto/runtime';
+import { asConstructable, castTo, Class, asFull, TypedObject } from '@travetto/runtime';
+import { UnknownType } from './internal/types';
 
 const REGEX_PAT = /[\/](.*)[\/](i|g|m|s)?/;
 
@@ -62,15 +63,13 @@ export class DataUtil {
       if (isArrA !== isArrB || isSimpA !== isSimpB) {
         throw new Error(`Cannot merge differing types ${a} and ${b}`);
       }
-      if (isArrB) { // Arrays
+      if (Array.isArray(b)) { // Arrays
         ret = a; // Write onto A
         if (mode === 'replace') {
           ret = b;
         } else {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          const retArr = ret as unknown[];
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          const bArr = b as unknown[];
+          const retArr: unknown[] = castTo(ret);
+          const bArr = b;
           for (let i = 0; i < bArr.length; i++) {
             retArr[i] = this.#deepAssignRaw(retArr[i], bArr[i], mode);
           }
@@ -83,16 +82,13 @@ export class DataUtil {
           if (mode === 'strict') { // Bail on strict
             throw new Error(`Cannot merge ${a} [${typeof a}] with ${b} [${typeof b}]`);
           } else if (mode === 'coerce') { // Force on coerce
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            ret = this.coerceType(b, (a as ClassInstance).constructor, false);
+            ret = this.coerceType(b, asConstructable(a).constructor, false);
           }
         }
       } else { // Object merge
         ret = a;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const bObj = b as Record<string, unknown>;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const retObj = ret as Record<string, unknown>;
+        const bObj: Record<string, unknown> = castTo(b);
+        const retObj: Record<string, unknown> = castTo(ret);
 
         for (const key of Object.keys(bObj)) {
           retObj[key] = this.#deepAssignRaw(retObj[key], bObj[key], mode);
@@ -125,11 +121,13 @@ export class DataUtil {
    */
   static coerceType(input: unknown, type: typeof String, strict?: boolean): string;
   static coerceType(input: unknown, type: typeof Number, strict?: boolean): number;
+  static coerceType(input: unknown, type: typeof BigInt, strict?: boolean): bigint;
   static coerceType(input: unknown, type: typeof Boolean, strict?: boolean): boolean;
   static coerceType(input: unknown, type: typeof Date, strict?: boolean): Date;
   static coerceType(input: unknown, type: typeof RegExp, strict?: boolean): RegExp;
-  static coerceType<T>(input: unknown, type: Class<T>, strict?: boolean): T;
-  static coerceType(input: unknown, type: Class<unknown>, strict = true): unknown {
+  static coerceType(input: unknown, type: typeof UnknownType, strict?: boolean): unknown;
+  static coerceType<T>(input: unknown, type: Class<T> | Function, strict?: boolean): T;
+  static coerceType(input: unknown, type: Class<unknown> | Function, strict = true): unknown {
     // Do nothing
     if (input === null || input === undefined) {
       return input;
@@ -143,14 +141,17 @@ export class DataUtil {
       case Date: {
         let res: Date | undefined;
         if (typeof input === 'object' && 'toDate' in input && typeof input.toDate === 'function') {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          res = input.toDate() as Date;
+          res = castTo(input.toDate());
         } else {
-          res = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            new Date(parseInt(input as string, 10)) : new Date(input as Date);
+          res = input instanceof Date ?
+            input :
+            typeof input === 'number' ?
+              new Date(input) :
+              (typeof input === 'string' && /^[-]?\d+$/.test(input)) ?
+                new Date(parseInt(input, 10)) :
+                new Date(input.toString());
         }
-        if (strict && Number.isNaN(res.getTime())) {
+        if (strict && res && Number.isNaN(res.getTime())) {
           throw new Error(`Invalid date value: ${input}`);
         }
         return res;
@@ -162,6 +163,20 @@ export class DataUtil {
         }
         return res;
       }
+      case BigInt: {
+        if (typeof input === 'bigint') {
+          return input;
+        }
+        try {
+          return BigInt((typeof input === 'boolean' || typeof input === 'number') ?
+            input : `${input}`.replace(/n$/i, ''));
+        } catch {
+          if (strict) {
+            throw new Error(`Invalid numeric value: ${input}`);
+          }
+          return;
+        }
+      }
       case Boolean: {
         const match = `${input}`.match(/^((?<TRUE>true|yes|1|on)|false|no|off|0)$/i);
         if (strict && !match) {
@@ -186,6 +201,9 @@ export class DataUtil {
           return;
         }
       }
+      case UnknownType: {
+        return input;
+      }
       case Object: {
         if (!strict || this.isPlainObject(input)) {
           return input;
@@ -207,9 +225,8 @@ export class DataUtil {
    * Clone top level properties to a new object
    * @param o Object to clone
    */
-  static shallowClone<T = unknown>(a: T): T {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (Array.isArray(a) ? a.slice(0) : (this.isSimpleValue(a) ? a : { ...(a as {}) })) as T;
+  static shallowClone<T>(a: T): T {
+    return castTo(Array.isArray(a) ? a.slice(0) : (this.isSimpleValue(a) ? a : { ...castTo<object>(a) }));
   }
 
   /**
@@ -222,8 +239,7 @@ export class DataUtil {
     if (!a || this.isSimpleValue(a)) {
       throw new Error(`Cannot merge onto a simple value, ${a}`);
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return this.#deepAssignRaw(a, b, mode) as T & U;
+    return castTo(this.#deepAssignRaw(a, b, mode));
   }
 
   /**
@@ -245,8 +261,7 @@ export class DataUtil {
           }
         }
       }
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return out as T;
+      return asFull(out);
     } else {
       return obj;
     }

package/src/decorator/field.ts

@@ -1,15 +1,15 @@
-import { ClassInstance } from '@travetto/runtime';
+import { Any, castTo, ClassInstance } from '@travetto/runtime';
 
 import { SchemaRegistry } from '../service/registry';
 import { CommonRegExp } from '../validate/regexp';
 import { ClassList, FieldConfig } from '../service/types';
 
-type PropType<V> = (<T extends Partial<Record<K, V>>, K extends string>(t: T, k: K, idx?: number) => void) & {
+type PropType<V> = (<T extends Partial<Record<K, V>>, K extends string>(t: T, k: K, idx?: TypedPropertyDescriptor<Any> | number) => void) & {
   Param: (t: unknown, k: string, idx: number) => void;
 };
 
 function prop<V>(obj: Partial<FieldConfig>): PropType<V> {
-  const fn = (t: ClassInstance, k: string, idx?: number): void => {
+  const fn = (t: ClassInstance, k: string, idx?: number | TypedPropertyDescriptor<Any>): void => {
     if (idx !== undefined && typeof idx === 'number') {
       SchemaRegistry.registerPendingParamFacet(t.constructor, k, idx, obj);
     } else {
@@ -18,8 +18,7 @@ function prop<V>(obj: Partial<FieldConfig>): PropType<V> {
   };
   fn.Param = fn;
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return fn as PropType<V>;
+  return castTo(fn);
 }
 
 /**
@@ -29,7 +28,7 @@ function prop<V>(obj: Partial<FieldConfig>): PropType<V> {
  * @augments `@travetto/schema:Field`
  */
 export function Field(type: ClassList, ...config: Partial<FieldConfig>[]) {
-  return (f: ClassInstance, k: string, idx?: number): void => {
+  return (f: ClassInstance, k: string, idx?: number | TypedPropertyDescriptor<Any>): void => {
     if (idx !== undefined && typeof idx === 'number') {
       SchemaRegistry.registerPendingParamConfig(f.constructor, k, idx, type, Object.assign({}, ...config));
     } else {

package/src/decorator/schema.ts

@@ -1,4 +1,4 @@
-import { Class, DeepPartial } from '@travetto/runtime';
+import { castTo, Class, DeepPartial } from '@travetto/runtime';
 
 import { BindUtil } from '../bind-util';
 import { SchemaRegistry } from '../service/registry';
@@ -28,8 +28,7 @@ export function Schema(cfg?: Partial<Pick<ClassConfig, 'subTypeName' | 'subTypeF
  */
 export function Validator<T>(fn: ValidatorFn<T, string>) {
   return (target: Class<T>): void => {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    SchemaRegistry.getOrCreatePending(target).validators!.push(fn as ValidatorFn<unknown, unknown>);
+    SchemaRegistry.getOrCreatePending(target).validators!.push(castTo(fn));
   };
 }
 

package/src/internal/types.ts

@@ -1 +1,2 @@
-export const AllViewⲐ: unique symbol = Symbol.for('@travetto/schema:all');
+export const AllViewⲐ: unique symbol = Symbol.for('@travetto/schema:all');
+export class UnknownType { }

package/src/service/registry.ts

@@ -1,4 +1,4 @@
-import { Class, AppError, describeFunction } from '@travetto/runtime';
+import { Class, AppError, describeFunction, castTo, classConstruct, asFull, castKey } from '@travetto/runtime';
 import { MetadataRegistry, RootRegistry, ChangeEvent } from '@travetto/registry';
 
 import { ClassList, FieldConfig, ClassConfig, SchemaConfig, ViewFieldsConfig, ViewConfig } from './types';
@@ -51,8 +51,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    */
   getMetadata<K>(cls: Class, key: symbol): K | undefined {
     const cfg = this.get(cls);
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return cfg.metadata?.[key] as K;
+    return castTo(cfg.metadata?.[key]);
   }
 
   /**
@@ -64,8 +63,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    */
   getOrCreatePendingMetadata<K>(cls: Class, key: symbol, value: K): K {
     const cfg = this.getOrCreatePending(cls);
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return ((cfg.metadata ??= {})[key] ??= value) as K;
+    return castTo((cfg.metadata ??= {})[key] ??= value);
   }
 
   /**
@@ -73,11 +71,9 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    */
   ensureInstanceTypeField<T>(cls: Class, o: T): void {
     const schema = this.get(cls);
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const typeField = (schema.subTypeField) as keyof T;
+    const typeField = castKey<T>(schema.subTypeField);
     if (schema.subTypeName && typeField in schema.views[AllViewⲐ].schema && !o[typeField]) {  // Do we have a type field defined
-      // @ts-expect-error
-      o[typeField] = schema.subTypeName; // Assign if missing
+      o[typeField] = castTo(schema.subTypeName); // Assign if missing
     }
   }
 
@@ -112,11 +108,9 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     const baseSchema = this.get(base);
 
     if (clsSchema.subTypeName || baseSchema.baseType) { // We have a sub type
-      // @ts-expect-error
-      const type = o[baseSchema.subTypeField] ?? clsSchema.subTypeName ?? baseSchema.subTypeName;
+      const type = castTo<string>(o[castKey<T>(baseSchema.subTypeField)]) ?? clsSchema.subTypeName ?? baseSchema.subTypeName;
       const ret = this.#subTypes.get(base)!.get(type)!;
-      // @ts-expect-error
-      if (ret && !(new ret() instanceof cls)) {
+      if (ret && !(classConstruct(ret) instanceof cls)) {
         throw new AppError(`Resolved class ${ret.name} is not assignable to ${cls.name}`);
       }
       return ret;
@@ -237,8 +231,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     if (!this.#pendingViews.has(target)) {
       this.#pendingViews.set(target, new Map());
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const generalConfig = fields as unknown as ViewFieldsConfig<unknown>;
+    const generalConfig: ViewFieldsConfig<unknown> = castTo(fields);
     this.#pendingViews.get(target)!.set(view, generalConfig);
   }
 
@@ -262,6 +255,9 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     if (config.specifiers) {
       config.specifiers = [...params[idx]?.specifiers ?? [], ...config.specifiers];
     }
+    if (config.enum?.values) {
+      config.enum.values = config.enum.values.slice().sort();
+    }
 
     params[idx] = {
       // @ts-expect-error
@@ -286,8 +282,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     if (!allViewConf.schema[prop]) {
       allViewConf.fields.push(prop);
       // Partial config while building
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      allViewConf.schema[prop] = {} as FieldConfig;
+      allViewConf.schema[prop] = asFull<FieldConfig>({});
     }
     if (config.aliases) {
       config.aliases = [...allViewConf.schema[prop].aliases ?? [], ...config.aliases];
@@ -295,6 +290,9 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     if (config.specifiers) {
       config.specifiers = [...allViewConf.schema[prop].specifiers ?? [], ...config.specifiers];
     }
+    if (config.enum?.values) {
+      config.enum.values = config.enum.values.slice().sort();
+    }
 
     Object.assign(allViewConf.schema[prop], config);
 

package/src/service/types.ts

@@ -1,4 +1,4 @@
-import { Class, Primitive } from '@travetto/runtime';
+import { Any, Class, Primitive } from '@travetto/runtime';
 
 import { AllViewⲐ } from '../internal/types';
 import { ValidatorFn } from '../validate/types';
@@ -65,7 +65,7 @@ export interface ClassConfig extends DescribableConfig {
   /**
    * Global validators
    */
-  validators: ValidatorFn<unknown, unknown>[];
+  validators: ValidatorFn<Any, unknown>[];
   /**
    * Is the class a base type
    */

package/src/validate/validator.ts

@@ -1,4 +1,4 @@
-import { Class, ClassInstance, TypedObject } from '@travetto/runtime';
+import { castKey, castTo, Class, ClassInstance, TypedObject } from '@travetto/runtime';
 
 import { FieldConfig, SchemaConfig } from '../service/types';
 import { SchemaRegistry } from '../service/registry';
@@ -18,6 +18,14 @@ function resolveSchema<T>(base: Class<T>, o: T, view?: string): SchemaConfig {
   ).schema;
 }
 
+function isClassInstance<T>(o: unknown): o is ClassInstance<T> {
+  return !DataUtil.isPlainObject(o) && o !== null && typeof o === 'object' && !!o.constructor;
+}
+
+function isRangeValue(o: unknown): o is number | string | Date {
+  return typeof o === 'string' || typeof o === 'number' || o instanceof Date;
+}
+
 declare global {
   interface RegExp {
     name?: string;
@@ -42,8 +50,7 @@ export class SchemaValidator {
     const fields = TypedObject.keys<SchemaConfig>(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));
+        errors = errors.concat(this.#validateFieldSchema(schema[field], o[castKey<T>(field)], relative));
       }
     }
 
@@ -174,18 +181,15 @@ export class SchemaValidator {
       criteria.push(['maxlength', field.maxlength]);
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    if (field.enum && !field.enum.values.includes(value as string)) {
+    if (field.enum && !field.enum.values.includes(castTo(value))) {
       criteria.push(['enum', field.enum]);
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    if (field.min && this.#validateRange(field, 'min', value as number)) {
+    if (field.min && (!isRangeValue(value) || this.#validateRange(field, 'min', value))) {
       criteria.push(['min', field.min]);
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    if (field.max && this.#validateRange(field, 'max', value as number)) {
+    if (field.max && (!isRangeValue(value) || this.#validateRange(field, 'max', value))) {
       criteria.push(['max', field.max]);
     }
 
@@ -268,10 +272,8 @@ 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 (!DataUtil.isPlainObject(o) && !(o instanceof cls || cls.Ⲑid === (o as ClassInstance<T>).constructor.Ⲑid)) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      throw new TypeMismatchError(cls.name, (o as ClassInstance).constructor.name);
+    if (isClassInstance(o) && !(o instanceof cls || cls.Ⲑid === o.constructor.Ⲑid)) {
+      throw new TypeMismatchError(cls.name, o.constructor.name);
     }
     cls = SchemaRegistry.resolveInstanceType(cls, o);
 

package/support/transformer/util.ts

@@ -1,12 +1,13 @@
 import ts from 'typescript';
 import {
   type AnyType, DeclarationUtil, LiteralUtil,
-  DecoratorUtil, DocUtil, ParamDocumentation, TransformerState
+  DecoratorUtil, DocUtil, ParamDocumentation, TransformerState, transformCast
 } from '@travetto/transformer';
 
 const SCHEMA_MOD = '@travetto/schema/src/decorator/schema';
 const FIELD_MOD = '@travetto/schema/src/decorator/field';
 const COMMON_MOD = '@travetto/schema/src/decorator/common';
+const TYPES_FILE = '@travetto/schema/src/internal/types';
 
 export class SchemaTransformUtil {
 
@@ -27,6 +28,10 @@ export class SchemaTransformUtil {
         }
         break;
       }
+      case 'unknown': {
+        const imp = state.importFile(TYPES_FILE);
+        return state.createAccess(imp.ident, 'UnknownType');
+      }
       case 'shape': {
         const uniqueId = state.generateUniqueIdentifier(node, type);
 
@@ -49,7 +54,7 @@ export class SchemaTransformUtil {
                 this.computeField(state, state.factory.createPropertyDeclaration(
                   [], k,
                   v.undefinable || v.nullable ? state.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-                  undefined, undefined
+                  v.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined, undefined
                 ), { type: v, root })
               )
           );
@@ -70,7 +75,6 @@ export class SchemaTransformUtil {
         break;
       }
       case 'foreign':
-      case 'unknown':
       default: {
         // Object
       }
@@ -126,8 +130,7 @@ export class SchemaTransformUtil {
     // If we have a union type
     if (primaryExpr.key === 'union') {
       const values = primaryExpr.subTypes.map(x => x.key === 'literal' ? x.value : undefined)
-        .filter(x => x !== undefined && x !== null)
-        .sort();
+        .filter(x => x !== undefined && x !== null);
 
       if (values.length === primaryExpr.subTypes.length) {
         attrs.push(state.factory.createPropertyAssignment('enum', state.fromLiteral({
@@ -183,6 +186,7 @@ export class SchemaTransformUtil {
       state.createDecorator(FIELD_MOD, 'Field', ...params)
     ];
 
+    let ret: unknown;
     if (ts.isPropertyDeclaration(node)) {
       const comments = DocUtil.describeDocs(node);
       if (comments.description) {
@@ -191,22 +195,19 @@ export class SchemaTransformUtil {
         })));
       }
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return state.factory.updatePropertyDeclaration(node as Exclude<typeof node, T>,
-        newModifiers, node.name, node.questionToken, node.type, node.initializer) as T;
+      ret = state.factory.updatePropertyDeclaration(node,
+        newModifiers, node.name, node.questionToken, node.type, node.initializer);
     } else if (ts.isParameter(node)) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return state.factory.updateParameterDeclaration(node as Exclude<typeof node, T>,
-        newModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) as T;
+      ret = state.factory.updateParameterDeclaration(node,
+        newModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
     } else if (ts.isGetAccessorDeclaration(node)) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return state.factory.updateGetAccessorDeclaration(node as Exclude<typeof node, T>,
-        newModifiers, node.name, node.parameters, node.type, node.body) as T;
+      ret = state.factory.updateGetAccessorDeclaration(node,
+        newModifiers, node.name, node.parameters, node.type, node.body);
     } else {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return state.factory.updateSetAccessorDeclaration(node as Exclude<typeof node, T>,
-        newModifiers, node.name, node.parameters, node.body) as T;
+      ret = state.factory.updateSetAccessorDeclaration(node,
+        newModifiers, node.name, node.parameters, node.body);
     }
+    return transformCast(ret);
   }
 
   /**