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

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;
     }
   }
-
 }

package/src/decorator/common.ts

@@ -10,14 +10,14 @@ import { SchemaRegistryIndex } from '../service/registry-index.ts';
  * @kind decorator
  */
 export function Describe(config: Partial<Omit<SchemaCoreConfig, 'metadata'>>) {
-  return (instanceOrCls: Class | ClassInstance, property?: string | symbol, descOrIdx?: PropertyDescriptor | number): void => {
+  return (instanceOrCls: Class | ClassInstance, property?: string, descriptorOrIdx?: PropertyDescriptor | number): void => {
     const adapter = SchemaRegistryIndex.getForRegister(getClass(instanceOrCls));
     if (!property) {
       adapter.register(config);
     } else {
-      if (descOrIdx !== undefined && typeof descOrIdx === 'number') {
-        adapter.registerParameter(property, descOrIdx, config);
-      } else if (typeof descOrIdx === 'object' && typeof descOrIdx.value === 'function') {
+      if (descriptorOrIdx !== undefined && typeof descriptorOrIdx === 'number') {
+        adapter.registerParameter(property, descriptorOrIdx, config);
+      } else if (typeof descriptorOrIdx === 'object' && typeof descriptorOrIdx.value === 'function') {
         adapter.registerMethod(property, config);
       } else {
         adapter.registerField(property, config);
@@ -31,7 +31,7 @@ export function Describe(config: Partial<Omit<SchemaCoreConfig, 'metadata'>>) {
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export const IsPrivate = (): (instanceOrCls: Class | ClassInstance, property?: string | symbol) => void => Describe({ private: true });
+export const IsPrivate = (): (instanceOrCls: Class | ClassInstance, property?: string) => void => Describe({ private: true });
 
 /**
  * Mark a field/method as ignored

package/src/decorator/field.ts

@@ -3,23 +3,25 @@ import { Any, ClassInstance, getClass } from '@travetto/runtime';
 import { SchemaFieldConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
-type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(t: T, k: K, idx?: TypedPropertyDescriptor<Any> | number) => void);
+type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(
+  instance: T, property: K, idx?: TypedPropertyDescriptor<Any> | number
+) => void);
 
-function field<V>(...obj: Partial<SchemaFieldConfig>[]): PropType<V> {
-  return (instance: ClassInstance, property: string | symbol): void => {
-    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, ...obj);
+function field<V>(...configs: Partial<SchemaFieldConfig>[]): PropType<V> {
+  return (instance: ClassInstance, property: string): void => {
+    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, ...configs);
   };
 }
 
 /**
  * Registering a field
  * @param type The type for the field
- * @param config The field configuration
+ * @param configs The field configuration
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Field(type: Pick<SchemaFieldConfig, 'type' | 'array'>, ...config: Partial<SchemaFieldConfig>[]): PropType<unknown> {
-  return field(type, ...config);
+export function Field(type: Pick<SchemaFieldConfig, 'type' | 'array'>, ...configs: Partial<SchemaFieldConfig>[]): PropType<unknown> {
+  return field(type, ...configs);
 }
 
 /**

package/src/decorator/input.ts

@@ -1,19 +1,21 @@
 import { Any, Class, ClassInstance, getClass } from '@travetto/runtime';
 
-import { CommonRegExp } from '../validate/regexp.ts';
+import { CommonRegex } from '../validate/regex.ts';
 import { CONSTRUCTOR_PROPERTY, SchemaInputConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
-type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(t: T, k: K, idx?: TypedPropertyDescriptor<Any> | number) => void);
+type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(
+  instance: T, property: K, idx?: TypedPropertyDescriptor<Any> | number
+) => void);
 
-function input<V>(...obj: Partial<SchemaInputConfig>[]): PropType<V> {
-  return (instanceOrCls: ClassInstance | Class, property: string | symbol, idx?: number | TypedPropertyDescriptor<Any>): void => {
+function input<V>(...configs: Partial<SchemaInputConfig>[]): PropType<V> {
+  return (instanceOrCls: ClassInstance | Class, property: string, idx?: number | TypedPropertyDescriptor<Any>): void => {
     const adapter = SchemaRegistryIndex.getForRegister(getClass(instanceOrCls));
     const propertyKey = property ?? CONSTRUCTOR_PROPERTY;
     if (typeof idx === 'number') {
-      adapter.registerParameter(propertyKey, idx, ...obj);
+      adapter.registerParameter(propertyKey, idx, ...configs);
     } else {
-      adapter.registerField(propertyKey, ...obj);
+      adapter.registerField(propertyKey, ...configs);
     }
   };
 }
@@ -21,12 +23,12 @@ function input<V>(...obj: Partial<SchemaInputConfig>[]): PropType<V> {
 /**
  * Registering an input
  * @param type The type for the input
- * @param config The input configuration
+ * @param configs The input configuration
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Input(type: Pick<SchemaInputConfig, 'type' | 'array'>, ...config: Partial<SchemaInputConfig>[]): PropType<unknown> {
-  return input(type, ...config);
+export function Input(type: Pick<SchemaInputConfig, 'type' | 'array'>, ...configs: Partial<SchemaInputConfig>[]): PropType<unknown> {
+  return input(type, ...configs);
 }
 
 /**
@@ -74,53 +76,53 @@ export function LongText(): PropType<string | string[]> { return input({ specifi
 
 /**
  * Require the input to match a specific RegExp
- * @param re The regular expression to match against
+ * @param regex The regular expression to match against
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Match(re: RegExp, message?: string): PropType<string | string[]> { return input({ match: { re, message } }); }
+export function Match(regex: RegExp, message?: string): PropType<string | string[]> { return input({ match: { regex, message } }); }
 
 /**
  * The minimum length for the string or array
- * @param n The minimum length
+ * @param limit The minimum length
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function MinLength(n: number, message?: string): PropType<string | unknown[]> {
-  return input({ minlength: { n, message }, ...(n === 0 ? { required: { active: false } } : {}) });
+export function MinLength(limit: number, message?: string): PropType<string | unknown[]> {
+  return input({ minlength: { limit, message }, ...(limit === 0 ? { required: { active: false } } : {}) });
 }
 
 /**
  * The maximum length for the string or array
- * @param n The maximum length
+ * @param limit The maximum length
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function MaxLength(n: number, message?: string): PropType<string | unknown[]> { return input({ maxlength: { n, message } }); }
+export function MaxLength(limit: number, message?: string): PropType<string | unknown[]> { return input({ maxlength: { limit, message } }); }
 
 /**
  * The minimum value
- * @param n The minimum value
+ * @param limit The minimum value
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Min<T extends number | Date>(n: T, message?: string): PropType<Date | number> {
-  return input({ min: { n, message } });
+export function Min<T extends number | Date>(limit: T, message?: string): PropType<Date | number> {
+  return input({ min: { limit, message } });
 }
 
 /**
  * The maximum value
- * @param n The maximum value
+ * @param limit The maximum value
  * @param message The message to show when the constraint fails
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Max<T extends number | Date>(n: T, message?: string): PropType<Date | number> {
-  return input({ max: { n, message } });
+export function Max<T extends number | Date>(limit: T, message?: string): PropType<Date | number> {
+  return input({ max: { limit, message } });
 }
 
 /**
@@ -129,7 +131,7 @@ export function Max<T extends number | Date>(n: T, message?: string): PropType<D
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Email(message?: string): PropType<string | string[]> { return Match(CommonRegExp.email, message); }
+export function Email(message?: string): PropType<string | string[]> { return Match(CommonRegex.email, message); }
 
 /**
  * Mark an input as an telephone number
@@ -137,7 +139,7 @@ export function Email(message?: string): PropType<string | string[]> { return Ma
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Telephone(message?: string): PropType<string | string[]> { return Match(CommonRegExp.telephone, message); }
+export function Telephone(message?: string): PropType<string | string[]> { return Match(CommonRegex.telephone, message); }
 
 /**
  * Mark an input as a url
@@ -145,7 +147,7 @@ export function Telephone(message?: string): PropType<string | string[]> { retur
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Url(message?: string): PropType<string | string[]> { return Match(CommonRegExp.url, message); }
+export function Url(message?: string): PropType<string | string[]> { return Match(CommonRegex.url, message); }
 
 /**
  * Determine the numeric precision of the value
@@ -197,7 +199,7 @@ export function Specifier(...specifiers: string[]): PropType<unknown> { return i
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function DiscriminatorField(): ((t: ClassInstance, k: string) => void) {
+export function DiscriminatorField(): ((instance: ClassInstance, property: string) => void) {
   return (instance: ClassInstance, property: string): void => {
     SchemaRegistryIndex.getForRegister(getClass(instance)).register({
       discriminatedBase: true,

package/src/decorator/method.ts

@@ -4,6 +4,8 @@ import { SchemaMethodConfig } from '../service/types';
 import { SchemaRegistryIndex } from '../service/registry-index';
 import { MethodValidatorFn } from '../validate/types';
 
+type MethodDecorator = (instance: ClassInstance, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor | void;
+
 /**
  * Registering a method
  * @param config The method configuration
@@ -11,7 +13,7 @@ import { MethodValidatorFn } from '../validate/types';
  * @kind decorator
  */
 export function Method(...config: Partial<SchemaMethodConfig>[]) {
-  return (instanceOrCls: ClassInstance, property: string | symbol): void => {
+  return (instanceOrCls: ClassInstance, property: string): void => {
     SchemaRegistryIndex.getForRegister(getClass(instanceOrCls)).registerMethod(property, ...config);
   };
 }

package/src/decorator/schema.ts

@@ -16,12 +16,12 @@ type ValidStringField<T> = { [K in Extract<keyof T, string>]: T[K] extends strin
  * @augments `@travetto/schema:Schema`
  * @kind decorator
  */
-export function Schema(cfg?: Partial<Pick<SchemaClassConfig, 'validators' | 'methods'>>) {
+export function Schema(config?: Partial<Pick<SchemaClassConfig, 'validators' | 'methods'>>) {
   return <T, U extends Class<T>>(cls: U): void => {
     cls.from ??= function <V>(this: Class<V>, data: DeepPartial<V>, view?: string): V {
       return BindUtil.bindSchema(this, data, { view });
     };
-    SchemaRegistryIndex.getForRegister(cls).registerClass(cfg);
+    SchemaRegistryIndex.getForRegister(cls).registerClass(config);
   };
 }
 

package/src/internal/types.ts

@@ -3,9 +3,9 @@ import { DataUtil } from '../data.ts';
 const InvalidSymbol = Symbol();
 
 /**
- * Point Implementation
+ * Point Contract
  */
-export class PointImpl {
+export class PointContract {
 
   /**
    * Validate we have an actual point
@@ -20,7 +20,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;
@@ -28,4 +28,4 @@ export class PointImpl {
   }
 }
 
-Object.defineProperty(PointImpl, 'name', { value: 'Point' });
+Object.defineProperty(PointContract, 'name', { value: 'Point' });

package/src/name.ts

@@ -1,6 +1,6 @@
 import { SchemaClassConfig } from './service/types.ts';
 
-const ID_RE = /(\d{1,100})Δ$/;
+const ID_REGEX = /(\d{1,100})Δ$/;
 
 /**
  * Name resolver, specifically for synthetic types
@@ -17,9 +17,9 @@ export class SchemaNameResolver {
   getName(schema: SchemaClassConfig): string {
     const cls = schema.class;
     const id = cls.Ⲑid;
-    if (ID_RE.test(cls.name)) {
+    if (ID_REGEX.test(cls.name)) {
       if (!this.#schemaIdToName.has(id)) {
-        const name = cls.name.replace(ID_RE, (_, uid) => uid.slice(-this.#digits));
+        const name = cls.name.replace(ID_REGEX, (_, uniqueId) => uniqueId.slice(-this.#digits));
         this.#schemaIdToName.set(id, name);
       }
       return this.#schemaIdToName.get(id)!;