@travetto/schema 8.0.0-alpha.20 → 8.0.0-alpha.22

package/README.md

@@ -13,7 +13,7 @@ npm install @travetto/schema
 yarn add @travetto/schema
 ```
 
-This module's purpose is to allow for proper declaration and validation of data types, in the course of running a program.  The framework defined here, is leveraged in the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support"), [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework"), [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications"), [OpenAPI Specification](https://github.com/travetto/travetto/tree/main/module/openapi#readme "OpenAPI integration support for the Travetto framework") and [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") modules.  The schema is the backbone of all data transfer, as it helps to provide validation on correctness of input, whether it is a web request, command line inputs, or a configuration file. 
+This module's purpose is to allow for proper declaration and validation of data types, in the course of running a program. The framework defined here, is leveraged in the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support"), [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework"), [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications"), [OpenAPI Specification](https://github.com/travetto/travetto/tree/main/module/openapi#readme "OpenAPI integration support for the Travetto framework") and [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") modules. The schema is the backbone of all data transfer, as it helps to provide validation on correctness of input, whether it is a web request, command line inputs, or a configuration file. 
 
 This module provides a mechanism for registering classes and field level information as well the ability to apply that information at runtime.
 
@@ -63,29 +63,29 @@ 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#L24) defines a field that will be serialized.
-   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L55) defines a that field should be required
-   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L64) defines the allowable values that a field can have
-   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L90) defines a regular expression that the field value should match
-   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L99) enforces min length of a string
-   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L110) enforces max length of a string
-   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L99) enforces min value for a date or a number
-   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L110) enforces max value for a date or a number
-   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L140) ensures string field matches basic email regex
-   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L148) ensures string field matches basic telephone regex
-   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L156) ensures string field matches basic url regex
+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#L26) defines a field that will be serialized.
+   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L67) defines a that field should be required
+   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L78) defines the allowable values that a field can have
+   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L108) defines a regular expression that the field value should match
+   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L119) enforces min length of a string
+   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L130) enforces max length of a string
+   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L119) enforces min value for a date or a number
+   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L130) enforces max value for a date or a number
+   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L162) ensures string field matches basic email regex
+   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L172) ensures string field matches basic telephone regex
+   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L182) 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#L172) ensures number passed in is only a whole number
-   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L179) ensures number passed in allows fractional values
-   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L193) provides support for standard currency
-   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L74) 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#L81) same as text, but expects longer form content
-   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L40) 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#L33) 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#L48) 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#L201) 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#L208) 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#L202) ensures number passed in is only a whole number
+   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L211) ensures number passed in allows fractional values
+   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L229) provides support for standard currency
+   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L88) 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#L97) same as text, but expects longer form content
+   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L44) 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#L35) 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#L54) 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#L239) 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#L248) 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. 
 
@@ -96,7 +96,7 @@ Just like the class, all fields can be defined with
 And similarly, the `description` will be picked up from the [JSDoc](http://usejsdoc.org/about-getting-started.html) comments, and additionally all fields can be set using the [@Describe](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/common.ts#L12) decorator.
 
 ### Parameters
-Parameters are available in certain scenarios (e.g. [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") endpoints and [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") main methods).  In these scenarios, all of the field decorators are valid, but need to be called slightly differently to pass the typechecker. The simple solution is to use the `Arg` field of the decorator to convince Typescript its the correct type.
+Parameters are available in certain scenarios (e.g. [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") endpoints and [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") main methods). In these scenarios, all of the field decorators are valid, but need to be called slightly differently to pass the typechecker. The simple solution is to use the `Arg` field of the decorator to convince Typescript its the correct type.
 
 **Code: Sample Parameter Usage**
 ```typescript
@@ -119,7 +119,7 @@ Binding is a very simple operation, as it takes in a class registered as as [@Sc
 
 **Code: Sub Schemas via Address**
 ```typescript
-import { Schema, Integer } from '@travetto/schema';
+import { Integer, Schema } from '@travetto/schema';
 
 @Schema()
 export class Address {
@@ -173,7 +173,7 @@ Validation is very similar to binding, but instead of attempting to assign value
 
 **Code: Sub Schemas via Address**
 ```typescript
-import { Schema, Integer } from '@travetto/schema';
+import { Integer, Schema } from '@travetto/schema';
 
 @Schema()
 export class Address {
@@ -198,7 +198,6 @@ import { SchemaValidator } from '@travetto/schema';
 import { Person } from './person.ts';
 
 export async function validate(): Promise<void> {
-
   const person = Person.from({
     name: 'Test',
     age: 'abc',
@@ -243,11 +242,11 @@ Validation Failed {
 ```
 
 ### Custom Validators
-Within the schema framework, it is possible to add custom validators class level.  This allows for more flexibility when dealing with specific situations (e.g. password requirements or ensuring two fields match)
+Within the schema framework, it is possible to add custom validators class level. This allows for more flexibility when dealing with specific situations (e.g. password requirements or ensuring two fields match)
 
 **Code: Password Validator**
 ```typescript
-import { Schema, Validator, type ValidationError } from '@travetto/schema';
+import { Schema, type ValidationError, Validator } from '@travetto/schema';
 
 const passwordValidator = (user: User): ValidationError | undefined => {
   const password = user.password;
@@ -270,7 +269,7 @@ class User {
 }
 ```
 
-When the validator is executed, it has access to the entire object, and you can check any of the values.  The validator expects an object of a specific structure if you are looking to indicate an error has occurred.
+When the validator is executed, it has access to the entire object, and you can check any of the values. The validator expects an object of a specific structure if you are looking to indicate an error has occurred.
 
 **Code: Validation Error Structure**
 ```typescript
@@ -316,7 +315,7 @@ When working with the schema, the basic types are easily understood, but some of
 To that end, the module supports two concepts:
 
 ### Type Adapters
-This feature is meant to allow for simple Typescript types to be able to be backed by a proper class.  This is because all of the typescript type information disappears at runtime, and so only concrete types (like classes) remain.  An example of this, can be found with how the [Data Model Querying](https://github.com/travetto/travetto/tree/main/module/model-query#readme "Datastore abstraction for advanced query support.") module handles geo data.
+This feature is meant to allow for simple Typescript types to be able to be backed by a proper class. This is because all of the typescript type information disappears at runtime, and so only concrete types (like classes) remain. An example of this, can be found with how the [Data Model Querying](https://github.com/travetto/travetto/tree/main/module/model-query#readme "Datastore abstraction for advanced query support.") module handles geo data.
 
 **Code: Point Contract**
 ```typescript
@@ -352,17 +351,17 @@ function bindPoint(input: unknown): [number, number] | typeof InvalidSymbol | un
  */
 function validatePoint(input: unknown): 'type' | undefined {
   const bound = bindPoint(input);
-  return bound !== InvalidSymbol && bound && !isNaN(bound[0]) && !isNaN(bound[1]) ? undefined : 'type';
+  return bound !== InvalidSymbol && bound && !Number.isNaN(bound[0]) && !Number.isNaN(bound[1]) ? undefined : 'type';
 }
 
 /**
  * Point Contract
  */
-export class PointContract { }
+export class PointContract {}
 
 SchemaTypeUtil.setSchemaTypeConfig(PointContract, {
   validate: validatePoint,
-  bind: bindPoint,
+  bind: bindPoint
 });
 Object.defineProperty(PointContract, 'name', { value: 'Point' });
 ```
@@ -373,7 +372,7 @@ What you can see here is that the `Point` type is now backed by a class that sup
 
 **Code: Simple Custom Type Usage**
 ```typescript
-import { Schema, type Point } from '@travetto/schema';
+import { type Point, Schema } from '@travetto/schema';
 
 @Schema()
 export class LocationAware {
@@ -382,7 +381,7 @@ export class LocationAware {
 }
 ```
 
-All that happens now, is the type is exported, and the class above is able to properly handle point as an `[x, y]` tuple.  All standard binding and validation patterns are supported, and type enforcement will work as expected.
+All that happens now, is the type is exported, and the class above is able to properly handle point as an `[x, y]` tuple. All standard binding and validation patterns are supported, and type enforcement will work as expected.
 
 **Terminal: Custom Type Validation**
 ```bash
@@ -408,8 +407,8 @@ 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#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:
+Data utilities for binding values, and type conversion. Currently [DataUtil](https://github.com/travetto/travetto/tree/main/module/schema/src/data.ts#L12) 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
       *  `strict`, will error out if the types do not match

package/__index__.ts

@@ -1,19 +1,20 @@
-import type { } from './src/global.d.ts';
+import type {} from './src/global.d.ts';
+
+export * from './src/bind-util.ts';
+export * from './src/data.ts';
+export * from './src/decorator/common.ts';
 export * from './src/decorator/field.ts';
 export * from './src/decorator/input.ts';
-export * from './src/decorator/schema.ts';
 export * from './src/decorator/method.ts';
-export * from './src/decorator/common.ts';
+export * from './src/decorator/schema.ts';
+export * from './src/name.ts';
+export * from './src/service/registry-adapter.ts';
+export * from './src/service/registry-index.ts';
 export * from './src/service/types.ts';
+export * from './src/type-config.ts';
+export * from './src/types.ts';
+export * from './src/validate/error.ts';
 export * from './src/validate/messages.ts';
 export * from './src/validate/regex.ts';
-export * from './src/validate/validator.ts';
-export * from './src/validate/error.ts';
 export * from './src/validate/types.ts';
-export * from './src/bind-util.ts';
-export * from './src/data.ts';
-export * from './src/name.ts';
-export * from './src/types.ts';
-export * from './src/type-config.ts';
-export * from './src/service/registry-index.ts';
-export * from './src/service/registry-adapter.ts';
+export * from './src/validate/validator.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "8.0.0-alpha.20",
+  "version": "8.0.0-alpha.22",
   "type": "module",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
@@ -28,10 +28,10 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^8.0.0-alpha.19"
+    "@travetto/registry": "^8.0.0-alpha.20"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^8.0.0-alpha.13"
+    "@travetto/transformer": "^8.0.0-alpha.14"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/bind-util.ts

@@ -1,8 +1,8 @@
-import { castTo, type Class, classConstruct, asFull, TypedObject, castKey } from '@travetto/runtime';
+import { asFull, type Class, castKey, castTo, classConstruct, TypedObject } from '@travetto/runtime';
 
 import { DataUtil } from './data.ts';
-import type { SchemaInputConfig, SchemaParameterConfig, SchemaFieldMap } from './service/types.ts';
 import { SchemaRegistryIndex } from './service/registry-index.ts';
+import type { SchemaFieldMap, SchemaInputConfig, SchemaParameterConfig } from './service/types.ts';
 import { SchemaTypeUtil } from './type-config.ts';
 
 type BindConfig = {
@@ -19,11 +19,10 @@ function isInstance<T>(value: unknown): value is T {
  * Utilities for binding objects to schemas
  */
 export class BindUtil {
-
   /**
    * Utility to make a property accessor enumerable at runtime
    */
-  static registerAccessor(instance: any, property: string): void {
+  static registerAccessor(instance: unknown, property: string): void {
     Object.defineProperty(instance, property, {
       ...Object.getOwnPropertyDescriptor(Object.getPrototypeOf(instance), property),
       enumerable: true
@@ -43,9 +42,11 @@ export class BindUtil {
       value = DataUtil.coerceType(value, config.type, false);
 
       if (config.type === Number && config.precision && typeof value === 'number') {
-        if (config.precision[1]) { // Supports decimal
+        if (config.precision[1]) {
+          // Supports decimal
           value = +value.toFixed(config.precision[1]);
-        } else { // 0 digits
+        } else {
+          // 0 digits
           value = Math.trunc(value);
         }
       }
@@ -72,8 +73,9 @@ export class BindUtil {
         const part = parts.shift()!;
         const partArrayIndex = part.indexOf('[') > 0;
         const name = part.split(/[^A-Za-z_0-9]/)[0];
+        // biome-ignore lint/complexity/noUselessEscapeInRegex: Consistent escaping for open and close
         const idx = partArrayIndex ? part.split(/[\[\]]/)[1] : '';
-        const key = partArrayIndex ? (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined)) : undefined;
+        const key = partArrayIndex ? (/^\d+$/.test(idx) ? parseInt(idx, 10) : idx.trim() || undefined) : undefined;
 
         if (!(name in sub)) {
           sub[name] = typeof key === 'number' ? [] : {};
@@ -96,10 +98,11 @@ export class BindUtil {
         }
       } else {
         const name = last.split(/[^A-Za-z_0-9]/)[0];
+        // biome-ignore lint/complexity/noUselessEscapeInRegex: Consistent escaping for open and close
         const idx = last.split(/[\[\]]/)[1];
 
-        let key = (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined));
-        sub[name] ??= (typeof key === 'string') ? {} : [];
+        let key = /^\d+$/.test(idx) ? parseInt(idx, 10) : idx.trim() || undefined;
+        sub[name] ??= typeof key === 'string' ? {} : [];
 
         const arrSub: Record<string, unknown> & { length: number } = castTo(sub[name]);
         if (key === undefined) {
@@ -125,8 +128,7 @@ export class BindUtil {
     for (const [key, value] of Object.entries(data)) {
       const pre = `${prefix}${key}`;
       if (DataUtil.isPlainObject(value)) {
-        Object.assign(out, this.flattenPaths(value, `${pre}.`)
-        );
+        Object.assign(out, this.flattenPaths(value, `${pre}.`));
       } else if (Array.isArray(value)) {
         for (let i = 0; i < value.length; i++) {
           const element = value[i];
@@ -162,9 +164,10 @@ export class BindUtil {
       const resolvedCls = SchemaRegistryIndex.resolveInstanceType<T>(cls, asFull<T>(data));
       const instance = classConstruct<T & { type?: string }>(resolvedCls);
 
-      for (const key of TypedObject.keys(instance)) { // Do not retain undefined fields
+      for (const key of TypedObject.keys(instance)) {
+        // Do not retain undefined fields
         const descriptor = Object.getOwnPropertyDescriptor(instance, key);
-        if (descriptor?.get) {
+        if (descriptor?.writable === false || descriptor?.get) {
           continue;
         }
         if (instance[key] === undefined) {
@@ -189,7 +192,7 @@ export class BindUtil {
     const view = config.view; // Does not convey
     delete config.view;
 
-    if (!!data && isInstance<T>(data)) {
+    if (data && isInstance<T>(data)) {
       const adapter = SchemaRegistryIndex.get(cls);
       const schemaConfig = adapter.get();
 
@@ -208,14 +211,14 @@ export class BindUtil {
         }
 
         for (const [schemaFieldName, field] of Object.entries(schema)) {
-          let inboundField: string | undefined = undefined;
+          let inboundField: string | undefined;
           if (field.access === 'readonly' || config.filterInput?.(field) === false) {
             continue; // Skip trying to write readonly fields
           }
           if (schemaFieldName in data) {
             inboundField = schemaFieldName;
           } else if (field.aliases) {
-            for (const aliasedField of (field.aliases ?? [])) {
+            for (const aliasedField of field.aliases ?? []) {
               if (aliasedField in data) {
                 inboundField = aliasedField;
                 break;
@@ -280,7 +283,8 @@ export class BindUtil {
       return value;
     }
     const complex = SchemaRegistryIndex.has(config.type);
-    const bindConfig: BindConfig | undefined = (complex && 'view' in config && typeof config.view === 'string') ? { view: config.view } : undefined;
+    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) {
@@ -324,4 +328,4 @@ export class BindUtil {
     const paramConfigs = SchemaRegistryIndex.get(cls).getMethod(method).parameters;
     return this.coerceParameters(paramConfigs, params, applyDefaults);
   }
-}
+}

package/src/data.ts

@@ -1,38 +1,47 @@
-import { isNumberObject, isBooleanObject, isStringObject } from 'node:util/types';
+import { isBooleanObject, isNumberObject, isStringObject } from 'node:util/types';
+
+import { asConstructable, asFull, type Class, castTo, TypedObject } from '@travetto/runtime';
 
-import { asConstructable, castTo, type Class, asFull, TypedObject } from '@travetto/runtime';
 import { UnknownType } from './types.ts';
 
-const REGEX_PATTERN = /[\/](.*)[\/](i|g|m|s)?/;
+const REGEX_PATTERN = /[/](.*)[/](i|g|m|s)?/;
 
 /**
  * Utilities for data conversion and binding
  */
 export class DataUtil {
-
   /**
    * Is a value a plain JS object, created using {}
    * @param value Object to check
    */
   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
+    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 value Value to check
    */
-  static isPrimitive(value: unknown): value is (string | boolean | number | RegExp) {
+  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 !!value && (
-        value instanceof RegExp || value instanceof Date || isStringObject(value) || isNumberObject(value) || isBooleanObject(value)
-      );
-      default: return false;
+      case 'string':
+      case 'boolean':
+      case 'number':
+      case 'bigint':
+        return true;
+      case 'object':
+        return (
+          !!value &&
+          (value instanceof RegExp || value instanceof Date || isStringObject(value) || isNumberObject(value) || isBooleanObject(value))
+        );
+      default:
+        return false;
     }
   }
 
@@ -53,7 +62,8 @@ export class DataUtil {
 
     let value: unknown;
 
-    if (isEmptyA || isEmptyB) { // If no `a`, `b` always wins
+    if (isEmptyA || isEmptyB) {
+      // If no `a`, `b` always wins
       if (mode === 'replace' || b === null || !isEmptyB) {
         value = isEmptyB ? b : this.shallowClone(b);
       } else if (!isEmptyA) {
@@ -65,7 +75,8 @@ export class DataUtil {
       if (isArrA !== isArrB || isSimpA !== isSimpB) {
         throw new Error(`Cannot merge differing types ${a} and ${b}`);
       }
-      if (Array.isArray(b)) { // Arrays
+      if (Array.isArray(b)) {
+        // Arrays
         value = a; // Write onto A
         if (mode === 'replace') {
           value = b;
@@ -76,18 +87,23 @@ export class DataUtil {
             valueArray[i] = this.#deepAssignRaw(valueArray[i], bArray[i], mode);
           }
         }
-      } else if (isSimpB) { // Scalars
+      } else if (isSimpB) {
+        // Scalars
         const match = typeof a === typeof b;
         value = b;
 
-        if (!match) { // If types do not match
-          if (mode === 'strict') { // Bail on strict
+        if (!match) {
+          // If types do not match
+          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
+          } else if (mode === 'coerce') {
+            // Force on coerce
             value = this.coerceType(b, asConstructable(a).constructor, false);
           }
         }
-      } else { // Object merge
+      } else {
+        // Object merge
         value = a;
         const bObject: Record<string, unknown> = castTo(b);
         const valueObject: Record<string, unknown> = castTo(value);
@@ -148,15 +164,16 @@ export class DataUtil {
         if (typeof input === 'object' && 'toDate' in input && typeof input.toDate === 'function') {
           value = castTo(input.toDate());
         } else {
-          value = input instanceof Date ?
-            input :
-            typeof input === 'number' ?
-              new Date(input) :
-              typeof input === 'bigint' ?
-                new Date(Number(input)) :
-                (typeof input === 'string' && /^[-]?\d+$/.test(input)) ?
-                  new Date(parseInt(input, 10)) :
-                  new Date(input.toString());
+          value =
+            input instanceof Date
+              ? input
+              : typeof input === 'number'
+                ? new Date(input)
+                : typeof input === 'bigint'
+                  ? new Date(Number(input))
+                  : typeof input === 'string' && /^[-]?\d+$/.test(input)
+                    ? new Date(parseInt(input, 10))
+                    : new Date(input.toString());
         }
         if (strict && value && Number.isNaN(value.getTime())) {
           throw new Error(`Invalid date value: ${input}`);
@@ -178,8 +195,7 @@ export class DataUtil {
           return input;
         }
         try {
-          return BigInt((typeof input === 'boolean' || typeof input === 'number') ?
-            input : `${input}`.replace(/n$/i, ''));
+          return BigInt(typeof input === 'boolean' || typeof input === 'number' ? input : `${input}`.replace(/n$/i, ''));
         } catch {
           if (strict) {
             throw new Error(`Invalid numeric value: ${input}`);
@@ -222,7 +238,8 @@ export class DataUtil {
         }
       }
       case undefined:
-      case String: return `${input}`;
+      case String:
+        return `${input}`;
     }
     if (!strict || this.isPlainObject(input)) {
       return input;
@@ -236,7 +253,7 @@ export class DataUtil {
    * @param value Object to clone
    */
   static shallowClone<T>(value: T): T {
-    return castTo(Array.isArray(value) ? value.slice(0) : (this.isSimpleValue(value) ? value : { ...castTo<object>(value) }));
+    return castTo(Array.isArray(value) ? value.slice(0) : this.isSimpleValue(value) ? value : { ...castTo<object>(value) });
   }
 
   /**
@@ -245,7 +262,7 @@ export class DataUtil {
    * @param b The source
    * @param mode How the assignment should be handled
    */
-  static deepAssign<T, U>(a: T, b: U, mode: | 'replace' | 'loose' | 'strict' | 'coerce' = 'loose'): T & U {
+  static deepAssign<T, U>(a: T, b: U, mode: 'replace' | 'loose' | 'strict' | 'coerce' = 'loose'): T & U {
     if (!a || this.isSimpleValue(a)) {
       throw new Error(`Cannot merge onto a simple value, ${a}`);
     }
@@ -278,4 +295,4 @@ export class DataUtil {
       return input;
     }
   }
-}
+}

package/src/decorator/common.ts

@@ -1,7 +1,7 @@
 import { type Class, type ClassInstance, getClass } from '@travetto/runtime';
 
-import type { SchemaCoreConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
+import type { SchemaCoreConfig } from '../service/types.ts';
 
 /**
  * Describe a model or a field
@@ -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) => void => Describe({ private: true });
+export const IsPrivate = (): ((instanceOrCls: Class | ClassInstance, property?: string) => void) => Describe({ private: true });
 
 /**
  * Mark a field/method as ignored
@@ -39,5 +39,5 @@ export const IsPrivate = (): (instanceOrCls: Class | ClassInstance, property?: s
  * @kind decorator
  */
 export function Ignore(): PropertyDecorator {
-  return () => { };
+  return () => {};
 }

package/src/decorator/field.ts

@@ -1,11 +1,13 @@
 import { type Any, type ClassInstance, getClass } from '@travetto/runtime';
 
-import type { SchemaFieldConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
+import type { SchemaFieldConfig } from '../service/types.ts';
 
-type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(
-  instance: T, property: 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>(...configs: Partial<SchemaFieldConfig>[]): PropType<V> {
   return (instance: ClassInstance, property: string): void => {
@@ -30,14 +32,18 @@ export function Field(type?: Pick<SchemaFieldConfig, 'type' | 'array'>, ...confi
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Writeonly(): PropType<unknown> { return field({ access: 'writeonly' }); }
+export function Writeonly(): PropType<unknown> {
+  return field({ access: 'writeonly' });
+}
 
 /**
  * Mark a field as readonly
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Readonly(): PropType<unknown> { return field({ access: 'readonly' }); }
+export function Readonly(): PropType<unknown> {
+  return field({ access: 'readonly' });
+}
 
 /**
  * Mark a field as sensitive
@@ -45,4 +51,6 @@ export function Readonly(): PropType<unknown> { return field({ access: 'readonly
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Secret(active = true): PropType<unknown> { return field({ secret: active }); }
+export function Secret(active = true): PropType<unknown> {
+  return field({ secret: active });
+}