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

package/README.md

@@ -64,28 +64,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#L21) defines a field that will be serialized.
-   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L47) defines a that field should be required
-   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L56) defines the allowable values that a field can have
-   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L82) defines a regular expression that the field value should match
-   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L91) enforces min length of a string
-   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L102) enforces max length of a string
-   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L91) enforces min value for a date or a number
-   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L102) enforces max value for a date or a number
-   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L132) ensures string field matches basic email regex
-   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L140) ensures string field matches basic telephone regex
-   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L148) ensures string field matches basic url regex
+   *  [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L23) defines a field that will be serialized.
+   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L49) defines a that field should be required
+   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L58) defines the allowable values that a field can have
+   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L84) defines a regular expression that the field value should match
+   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L93) enforces min length of a string
+   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L104) enforces max length of a string
+   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L93) enforces min value for a date or a number
+   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L104) enforces max value for a date or a number
+   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L134) ensures string field matches basic email regex
+   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L142) ensures string field matches basic telephone regex
+   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L150) ensures string field matches basic url regex
    *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/common.ts#L41) exclude from auto schema registration
-   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L164) ensures number passed in is only a whole number
-   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L171) ensures number passed in allows fractional values
-   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L185) provides support for standard currency
-   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L66) 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/input.ts#L73) same as text, but expects longer form content
-   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L37) 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#L30) 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#L45) 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/input.ts#L193) attributes additional specifiers to a field, allowing for more specification beyond just the field's type.
-   *  [@DiscriminatorField](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L200) allows for promoting a given field as the owner of the sub type discriminator.
+   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L166) ensures number passed in is only a whole number
+   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L173) ensures number passed in allows fractional values
+   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L187) provides support for standard currency
+   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L68) 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/input.ts#L75) same as text, but expects longer form content
+   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L39) 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#L32) 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#L47) 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/input.ts#L195) attributes additional specifiers to a field, allowing for more specification beyond just the field's type.
+   *  [@DiscriminatorField](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L202) allows for promoting a given field as the owner of the sub type discriminator.
 
 Additionally, schemas can be nested to form more complex data structures that are able to bound and validated. 
 
@@ -249,11 +249,11 @@ Within the schema framework, it is possible to add custom validators class level
 import { Schema, Validator, ValidationError } from '@travetto/schema';
 
 const passwordValidator = (user: User): ValidationError | undefined => {
-  const p = user.password;
-  const hasNum = /\d/.test(p);
-  const hasSpecial = /[!@#$%%^&*()<>?/,.;':"']/.test(p);
-  const noRepeat = !/(.)(\1)/.test(p);
-  if (!hasNum || !hasSpecial || !noRepeat) {
+  const password = user.password;
+  const hasNumber = /\d/.test(password);
+  const hasSpecial = /[!@#$%%^&*()<>?/,.;':"']/.test(password);
+  const noRepeat = !/(.)(\1)/.test(password);
+  if (!hasNumber || !hasSpecial || !noRepeat) {
     return {
       kind: 'password-rules',
       path: 'password',
@@ -322,7 +322,7 @@ This feature is meant to allow for simple Typescript types to be able to be back
 /**
  * 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];
 ```
@@ -336,7 +336,7 @@ const InvalidSymbol = Symbol();
 /**
  * Point Implementation
  */
-export class PointImpl {
+export class PointImplementation {
 
   /**
    * Validate we have an actual point
@@ -351,7 +351,7 @@ export class PointImpl {
    */
   static bindSchema(input: unknown): [number, number] | typeof InvalidSymbol | undefined {
     if (Array.isArray(input) && input.length === 2) {
-      const [a, b] = input.map(x => DataUtil.coerceType(x, Number, false));
+      const [a, b] = input.map(value => DataUtil.coerceType(value, Number, false));
       return [a, b];
     } else {
       return InvalidSymbol;
@@ -359,7 +359,7 @@ export class PointImpl {
   }
 }
 
-Object.defineProperty(PointImpl, 'name', { value: 'Point' });
+Object.defineProperty(PointImplementation, 'name', { value: 'Point' });
 ```
 
 What you can see here is that the `Point` type is now backed by a class that supports:
@@ -410,4 +410,4 @@ Data utilities for binding values, and type conversion. Currently [DataUtil](htt
 
    *  `coerceType(input: unknown, type: Class<unknown>, strict = true)` which allows for converting an input type into a specified `type` instance, or throw an error if the types are incompatible.
    *  `shallowClone<T = unknown>(a: T): T` will shallowly clone a field
-   *  `filterByKeys<T>(obj: T, exclude: (string | RegExp)[]): T` will filter a given object, and return a plain object (if applicable) with fields excluded using the values in the `exclude` input
+   *  `filterByKeys<T>(input: T, exclude: (string | RegExp)[]): T` will filter a given object, and return a plain object (if applicable) with fields excluded using the values in the `exclude` input

package/package.json

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

package/src/bind-util.ts

@@ -10,8 +10,8 @@ type BindConfig = {
   filterValue?: (value: unknown, input: SchemaInputConfig) => boolean;
 };
 
-function isInstance<T>(o: unknown): o is T {
-  return !!o && !DataUtil.isPrimitive(o);
+function isInstance<T>(value: unknown): value is T {
+  return !!value && !DataUtil.isPrimitive(value);
 }
 
 /**
@@ -21,24 +21,24 @@ export class BindUtil {
 
   /**
    * Coerce a value to match the field config type
-   * @param conf The field config to coerce to
-   * @param val The provided value
+   * @param config The field config to coerce to
+   * @param value The provided value
    */
-  static #coerceType<T>(conf: SchemaInputConfig, val: unknown): T | null | undefined {
-    if (conf.type?.bindSchema) {
-      val = conf.type.bindSchema(val);
+  static #coerceType<T>(config: SchemaInputConfig, value: unknown): T | null | undefined {
+    if (config.type?.bindSchema) {
+      value = config.type.bindSchema(value);
     } else {
-      val = DataUtil.coerceType(val, conf.type, false);
+      value = DataUtil.coerceType(value, config.type, false);
 
-      if (conf.type === Number && conf.precision && typeof val === 'number') {
-        if (conf.precision[1]) { // Supports decimal
-          val = +val.toFixed(conf.precision[1]);
+      if (config.type === Number && config.precision && typeof value === 'number') {
+        if (config.precision[1]) { // Supports decimal
+          value = +value.toFixed(config.precision[1]);
         } else { // 0 digits
-          val = Math.trunc(val);
+          value = Math.trunc(value);
         }
       }
     }
-    return castTo(val);
+    return castTo(value);
   }
 
   /**
@@ -46,22 +46,22 @@ export class BindUtil {
    *
    * This will convert `{ 'a.b[3].c[age]': 5 }` => `{ a : { b : [,,,{ c: { age: 5 }}]}}`
    *
-   * @param obj The object to convert
+   * @param input The object to convert
    */
-  static expandPaths(obj: Record<string, unknown>): Record<string, unknown> {
+  static expandPaths(input: Record<string, unknown>): Record<string, unknown> {
     const out: Record<string, unknown> = {};
-    for (const k of Object.keys(obj)) {
-      const objK = obj[k];
-      const val = DataUtil.isPlainObject(objK) ? this.expandPaths(objK) : objK;
-      const parts = k.split('.');
+    for (const property of Object.keys(input)) {
+      const valueInput = input[property];
+      const value = DataUtil.isPlainObject(valueInput) ? this.expandPaths(valueInput) : valueInput;
+      const parts = property.split('.');
       const last = parts.pop()!;
       let sub = out;
       while (parts.length > 0) {
         const part = parts.shift()!;
-        const partArr = part.indexOf('[') > 0;
+        const partArrayIndex = part.indexOf('[') > 0;
         const name = part.split(/[^A-Za-z_0-9]/)[0];
-        const idx = partArr ? part.split(/[\[\]]/)[1] : '';
-        const key = partArr ? (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined)) : undefined;
+        const idx = partArrayIndex ? part.split(/[\[\]]/)[1] : '';
+        const key = partArrayIndex ? (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined)) : undefined;
 
         if (!(name in sub)) {
           sub[name] = typeof key === 'number' ? [] : {};
@@ -77,10 +77,10 @@ export class BindUtil {
       const arr = last.indexOf('[') > 0;
 
       if (!arr) {
-        if (sub[last] && DataUtil.isPlainObject(val)) {
-          sub[last] = DataUtil.deepAssign(sub[last], val, 'coerce');
+        if (sub[last] && DataUtil.isPlainObject(value)) {
+          sub[last] = DataUtil.deepAssign(sub[last], value, 'coerce');
         } else {
-          sub[last] = val;
+          sub[last] = value;
         }
       } else {
         const name = last.split(/[^A-Za-z_0-9]/)[0];
@@ -93,10 +93,10 @@ export class BindUtil {
         if (key === undefined) {
           key = arrSub.length;
         }
-        if (arrSub[key] && DataUtil.isPlainObject(val) && DataUtil.isPlainObject(arrSub[key])) {
-          arrSub[key] = DataUtil.deepAssign(arrSub[key], val, 'coerce');
+        if (arrSub[key] && DataUtil.isPlainObject(value) && DataUtil.isPlainObject(arrSub[key])) {
+          arrSub[key] = DataUtil.deepAssign(arrSub[key], value, 'coerce');
         } else {
-          arrSub[key] = val;
+          arrSub[key] = value;
         }
       }
     }
@@ -105,8 +105,8 @@ export class BindUtil {
 
   /**
    * Convert full object with nesting, into flat set of keys
-   * @param conf The object to flatten the paths for
-   * @param val The starting prefix
+   * @param data The object to flatten the paths for
+   * @param prefix The starting prefix
    */
   static flattenPaths<V extends string = string>(data: Record<string, unknown>, prefix: string = ''): Record<string, V> {
     const out: Record<string, V> = {};
@@ -117,11 +117,11 @@ export class BindUtil {
         );
       } else if (Array.isArray(value)) {
         for (let i = 0; i < value.length; i++) {
-          const v = value[i];
-          if (DataUtil.isPlainObject(v)) {
-            Object.assign(out, this.flattenPaths(v, `${pre}[${i}].`));
+          const element = value[i];
+          if (DataUtil.isPlainObject(element)) {
+            Object.assign(out, this.flattenPaths(element, `${pre}[${i}].`));
           } else {
-            out[`${pre}[${i}]`] = v ?? '';
+            out[`${pre}[${i}]`] = element ?? '';
           }
         }
       } else {
@@ -135,12 +135,12 @@ export class BindUtil {
    * Bind data to the schema for a class, with an optional view
    * @param cls The schema class to bind against
    * @param data The provided data to bind
-   * @param cfg The bind configuration
+   * @param config The bind configuration
    */
-  static bindSchema<T>(cls: Class<T>, data?: undefined, cfg?: BindConfig): undefined;
-  static bindSchema<T>(cls: Class<T>, data?: null, cfg?: BindConfig): null;
-  static bindSchema<T>(cls: Class<T>, data?: object | T, cfg?: BindConfig): T;
-  static bindSchema<T>(cls: Class<T>, data?: object | T, cfg?: BindConfig): T | null | undefined {
+  static bindSchema<T>(cls: Class<T>, data?: undefined, config?: BindConfig): undefined;
+  static bindSchema<T>(cls: Class<T>, data?: null, config?: BindConfig): null;
+  static bindSchema<T>(cls: Class<T>, data?: object | T, config?: BindConfig): T;
+  static bindSchema<T>(cls: Class<T>, data?: object | T, config?: BindConfig): T | null | undefined {
     if (data === null || data === undefined) {
       return data;
     }
@@ -150,13 +150,13 @@ export class BindUtil {
       const resolvedCls = SchemaRegistryIndex.resolveInstanceType<T>(cls, asFull<T>(data));
       const instance = classConstruct<T & { type?: string }>(resolvedCls);
 
-      for (const k of TypedObject.keys(instance)) { // Do not retain undefined fields
-        if (instance[k] === undefined) {
-          delete instance[k];
+      for (const key of TypedObject.keys(instance)) { // Do not retain undefined fields
+        if (instance[key] === undefined) {
+          delete instance[key];
         }
       }
 
-      const out = this.bindSchemaToObject(resolvedCls, instance, data, cfg);
+      const out = this.bindSchemaToObject(resolvedCls, instance, data, config);
       SchemaRegistryIndex.get(resolvedCls).ensureInstanceTypeField(out);
       return out;
     }
@@ -165,35 +165,35 @@ export class BindUtil {
   /**
    * Bind the schema to the object
    * @param cls The schema class
-   * @param obj The target object (instance of cls)
+   * @param input The target object (instance of cls)
    * @param data The data to bind
-   * @param cfg The bind configuration
+   * @param config The bind configuration
    */
-  static bindSchemaToObject<T>(cls: Class<T>, obj: T, data?: object, cfg: BindConfig = {}): T {
-    const view = cfg.view; // Does not convey
-    delete cfg.view;
+  static bindSchemaToObject<T>(cls: Class<T>, input: T, data?: object, config: BindConfig = {}): T {
+    const view = config.view; // Does not convey
+    delete config.view;
 
     if (!!data && isInstance<T>(data)) {
       const adapter = SchemaRegistryIndex.get(cls);
-      const conf = adapter.get();
+      const schemaConfig = adapter.get();
 
       // If no configuration
-      if (!conf) {
-        for (const k of TypedObject.keys(data)) {
-          obj[k] = data[k];
+      if (!schemaConfig) {
+        for (const key of TypedObject.keys(data)) {
+          input[key] = data[key];
         }
       } else {
-        let schema: SchemaFieldMap = conf.fields;
+        let schema: SchemaFieldMap = schemaConfig.fields;
         if (view) {
           schema = adapter.getFields(view);
           if (!schema) {
-            throw new Error(`View not found: ${view.toString()}`);
+            throw new Error(`View not found: ${view}`);
           }
         }
 
         for (const [schemaFieldName, field] of Object.entries(schema)) {
           let inboundField: string | undefined = undefined;
-          if (field.access === 'readonly' || cfg.filterInput?.(field) === false) {
+          if (field.access === 'readonly' || config.filterInput?.(field) === false) {
             continue; // Skip trying to write readonly fields
           }
           if (schemaFieldName in data) {
@@ -211,40 +211,40 @@ export class BindUtil {
             continue;
           }
 
-          let v: unknown = data[castKey<T>(inboundField)];
+          let value: unknown = data[castKey<T>(inboundField)];
 
           // Filtering values
-          if (cfg.filterValue && !cfg.filterValue(v, field)) {
+          if (config.filterValue && !config.filterValue(value, field)) {
             continue;
           }
 
-          if (v !== undefined && v !== null) {
+          if (value !== undefined && value !== null) {
             // Ensure its an array
-            if (!Array.isArray(v) && field.array) {
-              if (typeof v === 'string' && v.includes(',')) {
-                v = v.split(/,/).map(x => x.trim());
+            if (!Array.isArray(value) && field.array) {
+              if (typeof value === 'string' && value.includes(',')) {
+                value = value.split(/,/).map(part => part.trim());
               } else {
-                v = [v];
+                value = [value];
               }
             }
 
             if (SchemaRegistryIndex.has(field.type)) {
-              if (field.array && Array.isArray(v)) {
-                v = v.map(el => this.bindSchema(field.type, el, cfg));
+              if (field.array && Array.isArray(value)) {
+                value = value.map(item => this.bindSchema(field.type, item, config));
               } else {
-                v = this.bindSchema(field.type, v, cfg);
+                value = this.bindSchema(field.type, value, config);
               }
-            } else if (field.array && Array.isArray(v)) {
-              v = v.map(el => this.#coerceType(field, el));
+            } else if (field.array && Array.isArray(value)) {
+              value = value.map(item => this.#coerceType(field, item));
             } else {
-              v = this.#coerceType(field, v);
+              value = this.#coerceType(field, value);
             }
           }
 
-          obj[castKey<T>(schemaFieldName)] = castTo(v);
+          input[castKey<T>(schemaFieldName)] = castTo(value);
 
           if (field.accessor) {
-            Object.defineProperty(obj, schemaFieldName, {
+            Object.defineProperty(input, schemaFieldName, {
               ...adapter.getAccessorDescriptor(schemaFieldName),
               enumerable: true
             });
@@ -253,40 +253,40 @@ export class BindUtil {
       }
     }
 
-    return obj;
+    return input;
   }
 
   /**
    * Coerce field to type
-   * @param cfg
-   * @param val
+   * @param config
+   * @param value
    * @param applyDefaults
    * @returns
    */
-  static coerceInput(cfg: SchemaInputConfig, val: unknown, applyDefaults = false): unknown {
-    if ((val === undefined || val === null) && applyDefaults) {
-      val = Array.isArray(cfg.default) ? cfg.default.slice(0) : cfg.default;
+  static coerceInput(config: SchemaInputConfig, value: unknown, applyDefaults = false): unknown {
+    if ((value === undefined || value === null) && applyDefaults) {
+      value = Array.isArray(config.default) ? config.default.slice(0) : config.default;
     }
-    if (cfg.required?.active === false && (val === undefined || val === null)) {
-      return val;
+    if (config.required?.active === false && (value === undefined || value === null)) {
+      return value;
     }
-    const complex = SchemaRegistryIndex.has(cfg.type);
-    const bindCfg: BindConfig | undefined = (complex && 'view' in cfg && typeof cfg.view === 'string') ? { view: cfg.view } : undefined;
-    if (cfg.array) {
-      const valArr = !Array.isArray(val) ? [val] : val;
+    const complex = SchemaRegistryIndex.has(config.type);
+    const bindConfig: BindConfig | undefined = (complex && 'view' in config && typeof config.view === 'string') ? { view: config.view } : undefined;
+    if (config.array) {
+      const subValue = !Array.isArray(value) ? [value] : value;
       if (complex) {
-        val = valArr.map(x => this.bindSchema(cfg.type, x, bindCfg));
+        value = subValue.map(item => this.bindSchema(config.type, item, bindConfig));
       } else {
-        val = valArr.map(x => DataUtil.coerceType(x, cfg.type, false));
+        value = subValue.map(item => DataUtil.coerceType(item, config.type, false));
       }
     } else {
       if (complex) {
-        val = this.bindSchema(cfg.type, val, bindCfg);
+        value = this.bindSchema(config.type, value, bindConfig);
       } else {
-        val = DataUtil.coerceType(val, cfg.type, false);
+        value = DataUtil.coerceType(value, config.type, false);
       }
     }
-    return val;
+    return value;
   }
 
   /**
@@ -298,8 +298,8 @@ export class BindUtil {
   static coerceParameters(fields: SchemaParameterConfig[], params: unknown[], applyDefaults = true): unknown[] {
     params = [...params];
     // Coerce types
-    for (const el of fields) {
-      params[el.index!] = this.coerceInput(el, params[el.index!], applyDefaults);
+    for (const field of fields) {
+      params[field.index!] = this.coerceInput(field, params[field.index!], applyDefaults);
     }
     return params;
   }
@@ -311,7 +311,7 @@ export class BindUtil {
    * @param params
    * @returns
    */
-  static coerceMethodParams<T>(cls: Class<T>, method: string | symbol, params: unknown[], applyDefaults = true): unknown[] {
+  static coerceMethodParams<T>(cls: Class<T>, method: string, params: unknown[], applyDefaults = true): unknown[] {
     const paramConfigs = SchemaRegistryIndex.get(cls).getMethod(method).parameters;
     return this.coerceParameters(paramConfigs, params, applyDefaults);
   }

package/src/data.ts

@@ -1,4 +1,4 @@
-import { isNumberObject as isNum, isBooleanObject as isBool, isStringObject as isStr } from 'node:util/types';
+import { isNumberObject, isBooleanObject, isStringObject } from 'node:util/types';
 
 import { asConstructable, castTo, Class, asFull, TypedObject } from '@travetto/runtime';
 import { UnknownType } from './types.ts';
@@ -12,24 +12,26 @@ export class DataUtil {
 
   /**
    * Is a value a plain JS object, created using {}
-   * @param obj Object to check
+   * @param value Object to check
    */
-  static isPlainObject(obj: unknown): obj is Record<string, unknown> {
-    return typeof obj === 'object' // separate from primitives
-      && obj !== undefined
-      && obj !== null         // is obvious
-      && obj.constructor === Object // separate instances (Array, DOM, ...)
-      && Object.prototype.toString.call(obj) === '[object Object]'; // separate build-in like Math
+  static isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' // separate from primitives
+      && value !== undefined
+      && value !== null         // is obvious
+      && value.constructor === Object // separate instances (Array, DOM, ...)
+      && Object.prototype.toString.call(value) === '[object Object]'; // separate build-in like Math
   }
 
   /**
    * Is a value of primitive type
-   * @param el Value to check
+   * @param value Value to check
    */
-  static isPrimitive(el: unknown): el is (string | boolean | number | RegExp) {
-    switch (typeof el) {
+  static isPrimitive(value: unknown): value is (string | boolean | number | RegExp) {
+    switch (typeof value) {
       case 'string': case 'boolean': case 'number': case 'bigint': return true;
-      case 'object': return !!el && (el instanceof RegExp || el instanceof Date || isStr(el) || isNum(el) || isBool(el));
+      case 'object': return !!value && (
+        value instanceof RegExp || value instanceof Date || isStringObject(value) || isNumberObject(value) || isBooleanObject(value)
+      );
       default: return false;
     }
   }
@@ -37,8 +39,8 @@ export class DataUtil {
   /**
    * Is simple, as a primitive, function or class
    */
-  static isSimpleValue(a: unknown): a is Function | Class | string | number | RegExp | Date {
-    return this.isPrimitive(a) || typeof a === 'function';
+  static isSimpleValue(value: unknown): value is Function | Class | string | number | RegExp | Date {
+    return this.isPrimitive(value) || typeof value === 'function';
   }
 
   static #deepAssignRaw(a: unknown, b: unknown, mode: 'replace' | 'loose' | 'strict' | 'coerce' = 'loose'): unknown {
@@ -68,10 +70,10 @@ export class DataUtil {
         if (mode === 'replace') {
           value = b;
         } else {
-          const retArr: unknown[] = castTo(value);
-          const bArr = b;
-          for (let i = 0; i < bArr.length; i++) {
-            retArr[i] = this.#deepAssignRaw(retArr[i], bArr[i], mode);
+          const valueArray: unknown[] = castTo(value);
+          const bArray = b;
+          for (let i = 0; i < bArray.length; i++) {
+            valueArray[i] = this.#deepAssignRaw(valueArray[i], bArray[i], mode);
           }
         }
       } else if (isSimpB) { // Scalars
@@ -87,14 +89,14 @@ export class DataUtil {
         }
       } else { // Object merge
         value = a;
-        const bObj: Record<string, unknown> = castTo(b);
-        const retObj: Record<string, unknown> = castTo(value);
+        const bObject: Record<string, unknown> = castTo(b);
+        const valueObject: Record<string, unknown> = castTo(value);
 
-        for (const key of Object.keys(bObj)) {
+        for (const key of Object.keys(bObject)) {
           if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
             continue;
           }
-          retObj[key] = this.#deepAssignRaw(retObj[key], bObj[key], mode);
+          valueObject[key] = this.#deepAssignRaw(valueObject[key], bObject[key], mode);
         }
       }
     }
@@ -119,7 +121,7 @@ export class DataUtil {
   /**
    * Coerce an input of any type to the class provided
    * @param input Input value
-   * @param type Class to coerce to (String, Boolean, Number, Date, RegEx, Object)
+   * @param type Class to coerce to (String, Boolean, Number, Date, RegExp, Object)
    * @param strict Should a failure to coerce throw an error?
    */
   static coerceType(input: unknown, type: typeof String, strict?: boolean): string;
@@ -226,10 +228,10 @@ export class DataUtil {
 
   /**
    * Clone top level properties to a new object
-   * @param o Object to clone
+   * @param value Object to clone
    */
-  static shallowClone<T>(a: T): T {
-    return castTo(Array.isArray(a) ? a.slice(0) : (this.isSimpleValue(a) ? a : { ...castTo<object>(a) }));
+  static shallowClone<T>(value: T): T {
+    return castTo(Array.isArray(value) ? value.slice(0) : (this.isSimpleValue(value) ? value : { ...castTo<object>(value) }));
   }
 
   /**
@@ -247,29 +249,28 @@ export class DataUtil {
 
   /**
    * Filter object by excluding specific keys
-   * @param obj A value to filter, primitives will be untouched
+   * @param input A value to filter, primitives will be untouched
    * @param exclude Strings or patterns to exclude against
    * @returns
    */
-  static filterByKeys<T>(obj: T, exclude: (string | RegExp)[]): T {
-    if (Array.isArray(obj)) {
-      return castTo(obj.map(x => this.filterByKeys(x, exclude)));
-    } else if (obj !== null && obj !== undefined && typeof obj === 'object') {
+  static filterByKeys<T>(input: T, exclude: (string | RegExp)[]): T {
+    if (Array.isArray(input)) {
+      return castTo(input.map(value => this.filterByKeys(value, exclude)));
+    } else if (input !== null && input !== undefined && typeof input === 'object') {
       const out: Partial<T> = {};
-      for (const key of TypedObject.keys(obj)) {
-        if (!exclude.some(r => typeof key === 'string' && (typeof r === 'string' ? r === key : r.test(key)))) {
-          const val = obj[key];
-          if (typeof val === 'object') {
-            out[key] = this.filterByKeys(val, exclude);
+      for (const key of TypedObject.keys(input)) {
+        if (!exclude.some(toMatch => typeof key === 'string' && (typeof toMatch === 'string' ? toMatch === key : toMatch.test(key)))) {
+          const value = input[key];
+          if (typeof value === 'object') {
+            out[key] = this.filterByKeys(value, exclude);
           } else {
-            out[key] = val;
+            out[key] = value;
           }
         }
       }
       return asFull(out);
     } else {
-      return obj;
+      return input;
     }
   }
-
 }