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

package/src/decorator/input.ts

@@ -1,8 +1,16 @@
-import { type Any, type Class, type ClassInstance, getClass, type NumericLikeIntrinsic, type NumericPrimitive, type Primitive } from '@travetto/runtime';
+import {
+  type Any,
+  type Class,
+  type ClassInstance,
+  getClass,
+  type NumericLikeIntrinsic,
+  type NumericPrimitive,
+  type Primitive
+} from '@travetto/runtime';
 
-import { CommonRegex } from '../validate/regex.ts';
-import { CONSTRUCTOR_PROPERTY, type SchemaInputConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
+import { CONSTRUCTOR_PROPERTY, type SchemaInputConfig } from '../service/types.ts';
+import { CommonRegex } from '../validate/regex.ts';
 
 type StringType = string | string[];
 type LengthType = string | unknown[] | Uint8Array | Uint16Array | Uint32Array;
@@ -10,9 +18,11 @@ type NumberType = NumericPrimitive | NumericPrimitive[];
 type NumberLikeType = NumericLikeIntrinsic | NumericLikeIntrinsic[];
 type EnumType = Exclude<Primitive, 'boolean'> | Exclude<Primitive, 'boolean'>[];
 
-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 input<V>(...configs: Partial<SchemaInputConfig>[]): PropType<V> {
   return (instanceOrCls: ClassInstance | Class, property: string, idx?: number | TypedPropertyDescriptor<Any>): void => {
@@ -43,7 +53,9 @@ export function Input(type: Pick<SchemaInputConfig, 'type' | 'array'>, ...config
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Alias(...aliases: string[]): PropType<unknown> { return input({ aliases }); }
+export function Alias(...aliases: string[]): PropType<unknown> {
+  return input({ aliases });
+}
 
 /**
  * Mark an input as required
@@ -52,7 +64,9 @@ export function Alias(...aliases: string[]): PropType<unknown> { return input({
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Required(active = true, message?: string): PropType<unknown> { return input({ required: { active, message } }); }
+export function Required(active = true, message?: string): PropType<unknown> {
+  return input({ required: { active, message } });
+}
 
 /**
  * Define an input as a set of enumerated values
@@ -71,14 +85,18 @@ export function Enum(values: string[], message?: string): PropType<EnumType> {
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Text(): PropType<StringType> { return input({ specifiers: ['text'] }); }
+export function Text(): PropType<StringType> {
+  return input({ specifiers: ['text'] });
+}
 
 /**
  * Mark the input to indicate it's for long form text
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function LongText(): PropType<StringType> { return input({ specifiers: ['text', 'long'] }); }
+export function LongText(): PropType<StringType> {
+  return input({ specifiers: ['text', 'long'] });
+}
 
 /**
  * Require the input to match a specific RegExp
@@ -87,7 +105,9 @@ export function LongText(): PropType<StringType> { return input({ specifiers: ['
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Match(regex: RegExp, message?: string): PropType<StringType> { return input({ match: { regex, message } }); }
+export function Match(regex: RegExp, message?: string): PropType<StringType> {
+  return input({ match: { regex, message } });
+}
 
 /**
  * The minimum length for the string or array
@@ -107,7 +127,9 @@ export function MinLength(limit: number, message?: string): PropType<LengthType>
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function MaxLength(limit: number, message?: string): PropType<LengthType> { return input({ maxlength: { limit, message } }); }
+export function MaxLength(limit: number, message?: string): PropType<LengthType> {
+  return input({ maxlength: { limit, message } });
+}
 
 /**
  * The minimum value
@@ -137,7 +159,9 @@ export function Max(limit: NumericLikeIntrinsic, message?: string): PropType<Num
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Email(message?: string): PropType<StringType> { return Match(CommonRegex.email, message); }
+export function Email(message?: string): PropType<StringType> {
+  return Match(CommonRegex.email, message);
+}
 
 /**
  * Mark an input as an telephone number
@@ -145,7 +169,9 @@ export function Email(message?: string): PropType<StringType> { return Match(Com
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Telephone(message?: string): PropType<StringType> { return Match(CommonRegex.telephone, message); }
+export function Telephone(message?: string): PropType<StringType> {
+  return Match(CommonRegex.telephone, message);
+}
 
 /**
  * Mark an input as a url
@@ -153,7 +179,9 @@ export function Telephone(message?: string): PropType<StringType> { return Match
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Url(message?: string): PropType<StringType> { return Match(CommonRegex.url, message); }
+export function Url(message?: string): PropType<StringType> {
+  return Match(CommonRegex.url, message);
+}
 
 /**
  * Determine the numeric precision of the value
@@ -162,35 +190,45 @@ export function Url(message?: string): PropType<StringType> { return Match(Commo
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Precision(digits: number, decimals?: number): PropType<number> { return input({ precision: [digits, decimals] }); }
+export function Precision(digits: number, decimals?: number): PropType<number> {
+  return input({ precision: [digits, decimals] });
+}
 
 /**
  * Mark a number as an integer
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Integer(): PropType<NumberType> { return Precision(0); }
+export function Integer(): PropType<NumberType> {
+  return Precision(0);
+}
 
 /**
  * Mark a number as a float
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Float(): PropType<number> { return Precision(10, 7); }
+export function Float(): PropType<number> {
+  return Precision(10, 7);
+}
 
 /**
  * Mark a number as a long value
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Long(): PropType<NumberType> { return Precision(19, 0); }
+export function Long(): PropType<NumberType> {
+  return Precision(19, 0);
+}
 
 /**
  * Mark a number as a currency
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Currency(): PropType<NumberType> { return Precision(13, 2); }
+export function Currency(): PropType<NumberType> {
+  return Precision(13, 2);
+}
 
 /**
  * Specifier for the input
@@ -198,18 +236,20 @@ export function Currency(): PropType<NumberType> { return Precision(13, 2); }
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Specifier(...specifiers: string[]): PropType<unknown> { return input({ specifiers }); }
+export function Specifier(...specifiers: string[]): PropType<unknown> {
+  return input({ specifiers });
+}
 
 /**
  * Sets the discriminator field via a property decorator
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function DiscriminatorField(): ((instance: ClassInstance, property: string) => void) {
+export function DiscriminatorField(): (instance: ClassInstance, property: string) => void {
   return (instance: ClassInstance, property: string): void => {
     SchemaRegistryIndex.getForRegister(getClass(instance)).register({
       discriminatedBase: true,
       discriminatedField: property
     });
   };
-}
+}

package/src/decorator/method.ts

@@ -1,7 +1,7 @@
-import { type Any, castTo, type ClassInstance, getClass } from '@travetto/runtime';
+import { type Any, type ClassInstance, castTo, getClass } from '@travetto/runtime';
 
-import type { SchemaMethodConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
+import type { SchemaMethodConfig } from '../service/types.ts';
 import type { MethodValidatorFn } from '../validate/types.ts';
 
 type MethodDecorator = (instance: ClassInstance, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor | void;

package/src/decorator/schema.ts

@@ -1,9 +1,9 @@
-import { castTo, type Class, type DeepPartial } from '@travetto/runtime';
+import { type Class, castTo, type DeepPartial } from '@travetto/runtime';
 
 import { BindUtil } from '../bind-util.ts';
+import { SchemaRegistryIndex } from '../service/registry-index.ts';
 import type { SchemaClassConfig, ViewFieldsConfig } from '../service/types.ts';
 import type { ValidatorFn } from '../validate/types.ts';
-import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
 /**
  * Provides all the valid string type fields from a given type T
@@ -31,7 +31,8 @@ export function Schema(config?: Partial<Pick<SchemaClassConfig, 'validators' | '
  * @param fn The validator function
  * @kind decorator
  */
-export const Validator = <T>(fn: ValidatorFn<T, string>) =>
+export const Validator =
+  <T>(fn: ValidatorFn<T, string>) =>
   (cls: Class<T>): void => {
     SchemaRegistryIndex.getForRegister(cls).register({ validators: [castTo(fn)] });
   };
@@ -68,4 +69,4 @@ export function Discriminated<T>(field: ValidStringField<T>) {
   return (cls: Class<Partial<T>>): void => {
     SchemaRegistryIndex.getForRegister(cls).register({ discriminatedField: field, discriminatedBase: true });
   };
-}
+}

package/src/internal/types.ts

@@ -20,16 +20,16 @@ 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' });

package/src/name.ts

@@ -6,7 +6,6 @@ const ID_REGEX = /(\d{1,100})Δ$/;
  * Name resolver, specifically for synthetic types
  */
 export class SchemaNameResolver {
-
   #schemaIdToName = new Map<string, string>();
   #digits: number;
 
@@ -27,4 +26,4 @@ export class SchemaNameResolver {
       return cls.name;
     }
   }
-}
+}

package/src/service/registry-adapter.ts

@@ -1,34 +1,43 @@
 import type { RegistryAdapter } from '@travetto/registry';
-import { RuntimeError, BinaryUtil, castKey, castTo, type Class, describeFunction, safeAssign } from '@travetto/runtime';
+import { BinaryUtil, type Class, castKey, castTo, describeFunction, RuntimeError, safeAssign } from '@travetto/runtime';
 
 import {
-  type SchemaClassConfig, type SchemaMethodConfig, type SchemaFieldConfig,
-  type SchemaParameterConfig, type SchemaInputConfig, type SchemaFieldMap, type SchemaCoreConfig,
-  CONSTRUCTOR_PROPERTY
+  CONSTRUCTOR_PROPERTY,
+  type SchemaClassConfig,
+  type SchemaCoreConfig,
+  type SchemaFieldConfig,
+  type SchemaFieldMap,
+  type SchemaInputConfig,
+  type SchemaMethodConfig,
+  type SchemaParameterConfig
 } from './types.ts';
 
 export type SchemaDiscriminatedInfo = Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>>;
 
-const classToDiscriminatedType = (cls: Class): string => cls.name
-  .replace(/([A-Z])([A-Z][a-z])/g, (all, left, right) => `${left}_${right.toLowerCase()}`)
-  .replace(/([a-z]|\b)([A-Z])/g, (all, left, right) => left ? `${left}_${right.toLowerCase()}` : right.toLowerCase())
-  .toLowerCase();
+const classToDiscriminatedType = (cls: Class): string =>
+  cls.name
+    .replace(/([A-Z])([A-Z][a-z])/g, (all, left, right) => `${left}_${right.toLowerCase()}`)
+    .replace(/([a-z]|\b)([A-Z])/g, (all, left, right) => (left ? `${left}_${right.toLowerCase()}` : right.toLowerCase()))
+    .toLowerCase();
 
 function assignMetadata<T>(key: symbol, base: SchemaCoreConfig, data: Partial<T>[]): T {
-  const metadata = base.metadata ??= {};
-  const out = metadata[key] ??= {};
+  const metadata = (base.metadata ??= {});
+  const out = (metadata[key] ??= {});
   for (const d of data) {
     safeAssign(out, d);
   }
   return castTo(out);
 }
 
-function combineCore<T extends SchemaCoreConfig>(base: T, config: Partial<T>): Pick<Partial<T>, 'metadata' | 'private' | 'description' | 'examples'> {
+function combineCore<T extends SchemaCoreConfig>(
+  base: T,
+  config: Partial<T>
+): Pick<Partial<T>, 'metadata' | 'private' | 'description' | 'examples'> {
   return {
-    ...config.metadata ? { metadata: { ...base.metadata, ...config.metadata } } : {},
-    ...config.private ? { private: config.private ?? base.private } : {},
-    ...config.description ? { description: config.description || base.description } : {},
-    ...config.examples ? { examples: [...(base.examples ?? []), ...(config.examples ?? [])] } : {},
+    ...(config.metadata ? { metadata: { ...base.metadata, ...config.metadata } } : {}),
+    ...(config.private ? { private: config.private ?? base.private } : {}),
+    ...(config.description ? { description: config.description || base.description } : {}),
+    ...(config.examples ? { examples: [...(base.examples ?? []), ...(config.examples ?? [])] } : {})
   };
 }
 
@@ -37,14 +46,16 @@ function combineInputs<T extends SchemaInputConfig>(base: T, configs: Partial<T>
     if (config) {
       safeAssign(base, {
         ...config,
-        ...config.aliases ? { aliases: [...base.aliases ?? [], ...config.aliases ?? []] } : {},
-        ...config.specifiers ? { specifiers: [...base.specifiers ?? [], ...config.specifiers ?? []] } : {},
-        ...config.enum ? {
-          enum: {
-            message: config.enum?.message ?? base.enum?.message,
-            values: (config.enum?.values ?? base.enum?.values ?? []).toSorted()
-          }
-        } : {},
+        ...(config.aliases ? { aliases: [...(base.aliases ?? []), ...(config.aliases ?? [])] } : {}),
+        ...(config.specifiers ? { specifiers: [...(base.specifiers ?? []), ...(config.specifiers ?? [])] } : {}),
+        ...(config.enum
+          ? {
+              enum: {
+                message: config.enum?.message ?? base.enum?.message,
+                values: (config.enum?.values ?? base.enum?.values ?? []).toSorted()
+              }
+            }
+          : {}),
         ...combineCore(base, config)
       });
     }
@@ -58,7 +69,7 @@ function combineMethods<T extends SchemaMethodConfig>(base: T, configs: Partial<
       ...config,
       ...combineCore(base, config),
       parameters: config.parameters ?? base.parameters,
-      validators: [...base.validators, ...(config.validators ?? [])],
+      validators: [...base.validators, ...(config.validators ?? [])]
     });
     if (config.parameters) {
       for (const param of config.parameters) {
@@ -84,25 +95,28 @@ function getConstructorConfig<T extends SchemaClassConfig>(base: Partial<T>, par
 
 function combineClassWithParent<T extends SchemaClassConfig>(base: T, parent: T): T {
   safeAssign(base, {
-    ...base.views ? { views: { ...parent.views, ...base.views } } : {},
-    ...base.validators ? { validators: [...parent.validators, ...base.validators] } : {},
-    ...base.metadata ? { metadata: { ...parent.metadata, ...base.metadata } } : {},
+    ...(base.views ? { views: { ...parent.views, ...base.views } } : {}),
+    ...(base.validators ? { validators: [...parent.validators, ...base.validators] } : {}),
+    ...(base.metadata ? { metadata: { ...parent.metadata, ...base.metadata } } : {}),
     interfaces: [...parent.interfaces, ...base.interfaces],
     methods: { ...parent.methods, ...base.methods },
     description: base.description || parent.description,
     examples: [...(parent.examples ?? []), ...(base.examples ?? [])],
-    discriminatedField: base.discriminatedField ?? parent.discriminatedField,
+    discriminatedField: base.discriminatedField ?? parent.discriminatedField
   });
   switch (base.mappedOperation) {
     case 'Required':
     case 'Partial': {
       base.fields = Object.fromEntries(
-        Object.entries(parent.fields).map(([key, value]) => [key, {
-          ...value,
-          required: {
-            active: base.mappedOperation === 'Required'
+        Object.entries(parent.fields).map(([key, value]) => [
+          key,
+          {
+            ...value,
+            required: {
+              active: base.mappedOperation === 'Required'
+            }
           }
-        }])
+        ])
       );
       break;
     }
@@ -110,9 +124,7 @@ function combineClassWithParent<T extends SchemaClassConfig>(base: T, parent: T)
     case 'Omit': {
       const keys = new Set<string>(base.mappedFields ?? []);
       base.fields = Object.fromEntries(
-        Object.entries(parent.fields).filter(([key]) =>
-          base.mappedOperation === 'Pick' ? keys.has(key) : !keys.has(key)
-        )
+        Object.entries(parent.fields).filter(([key]) => (base.mappedOperation === 'Pick' ? keys.has(key) : !keys.has(key)))
       );
       break;
     }
@@ -127,19 +139,18 @@ function combineClasses<T extends SchemaClassConfig>(base: T, configs: Partial<T
   for (const config of configs) {
     Object.assign(base, {
       ...config,
-      ...config.views ? { views: { ...base.views, ...config.views } } : {},
-      ...config.validators ? { validators: [...base.validators, ...config.validators] } : {},
+      ...(config.views ? { views: { ...base.views, ...config.views } } : {}),
+      ...(config.validators ? { validators: [...base.validators, ...config.validators] } : {}),
       ...combineCore(base, config),
       interfaces: [...base.interfaces, ...(config.interfaces ?? [])],
       methods: { ...base.methods, ...config.methods },
-      fields: { ...base.fields, ...config.fields },
+      fields: { ...base.fields, ...config.fields }
     });
   }
   return base;
 }
 
 export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig> {
-
   #cls: Class;
   #config: SchemaClassConfig;
   #views: Map<string, SchemaFieldMap> = new Map();
@@ -150,14 +161,14 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
   }
 
   register(...data: Partial<SchemaClassConfig>[]): SchemaClassConfig {
-    const config = this.#config ??= {
+    const config = (this.#config ??= {
       methods: {},
       class: this.#cls,
       views: {},
       validators: [],
       interfaces: [],
-      fields: {},
-    };
+      fields: {}
+    });
     return combineClasses(config, data);
   }
 
@@ -173,7 +184,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
 
   registerField(field: string, ...data: Partial<SchemaFieldConfig>[]): SchemaFieldConfig {
     const classConfig = this.register({});
-    const config = classConfig.fields[field] ??= { name: field, class: this.#cls, type: null! };
+    const config = (classConfig.fields[field] ??= { name: field, class: this.#cls, type: null! });
     const combined = combineInputs(config, data);
     return combined;
   }
@@ -202,7 +213,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
 
   registerMethod(method: string, ...data: Partial<SchemaMethodConfig>[]): SchemaMethodConfig {
     const classConfig = this.register();
-    const config = classConfig.methods[method] ??= { class: this.#cls, parameters: [], validators: [] };
+    const config = (classConfig.methods[method] ??= { class: this.#cls, parameters: [], validators: [] });
     return combineMethods(config, data);
   }
 
@@ -218,7 +229,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
 
   registerParameter(method: string, idx: number, ...data: Partial<SchemaParameterConfig>[]): SchemaParameterConfig {
     const params = this.registerMethod(method, {}).parameters;
-    const config = params[idx] ??= { method, index: idx, class: this.#cls, array: false, type: null! };
+    const config = (params[idx] ??= { method, index: idx, class: this.#cls, array: false, type: null! });
     return combineInputs(config, data);
   }
 
@@ -251,8 +262,8 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
         },
         enum: {
           values: [config.discriminatedType],
-          message: `${config.discriminatedField} can only be '${config.discriminatedType}'`,
-        },
+          message: `${config.discriminatedField} can only be '${config.discriminatedType}'`
+        }
       };
     }
 
@@ -260,11 +271,14 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     for (const view of Object.keys(config.views)) {
       const fields = config.views[view];
       const withoutSet = 'without' in fields ? new Set<string>(fields.without) : undefined;
-      const fieldList = withoutSet ?
-        Object.keys(config.fields).filter(field => !withoutSet.has(field)) :
-        ('with' in fields ? fields.with : []);
-
-      this.#views.set(view,
+      const fieldList = withoutSet
+        ? Object.keys(config.fields).filter(field => !withoutSet.has(field))
+        : 'with' in fields
+          ? fields.with
+          : [];
+
+      this.#views.set(
+        view,
         fieldList.reduce<SchemaFieldMap>((map, value) => {
           map[value] = config.fields[value];
           return map;
@@ -275,7 +289,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     config.methods[CONSTRUCTOR_PROPERTY] = getConstructorConfig(config, parent);
 
     for (const method of Object.values(config.methods)) {
-      method.parameters = method.parameters.toSorted((a, b) => (a.index! - b.index!));
+      method.parameters = method.parameters.toSorted((a, b) => a.index! - b.index!);
       if (method.returnType?.type) {
         method.returnType.binary = BinaryUtil.isBinaryTypeReference(method.returnType.type);
       }
@@ -373,4 +387,4 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     }
     return undefined;
   }
-}
+}

package/src/service/registry-index.ts

@@ -1,14 +1,13 @@
-import { type RegistrationMethods, type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { RuntimeError, castKey, castTo, type Class, classConstruct, getParentClass } from '@travetto/runtime';
+import { type RegistrationMethods, Registry, type RegistryIndex, RegistryIndexStore } from '@travetto/registry';
+import { type Class, castKey, castTo, classConstruct, getParentClass, RuntimeError } from '@travetto/runtime';
 
-import type { SchemaFieldConfig, SchemaClassConfig } from './types.ts';
 import { type SchemaDiscriminatedInfo, SchemaRegistryAdapter } from './registry-adapter.ts';
+import type { SchemaClassConfig, SchemaFieldConfig } from './types.ts';
 
 /**
  * Schema registry index for managing schema configurations across classes
  */
 export class SchemaRegistryIndex implements RegistryIndex {
-
   static #instance = Registry.registerIndex(SchemaRegistryIndex);
 
   static getForRegister(cls: Class): SchemaRegistryAdapter {
@@ -36,7 +35,7 @@ export class SchemaRegistryIndex implements RegistryIndex {
   }
 
   static visitFields<T>(cls: Class<T>, onField: (field: SchemaFieldConfig, path: SchemaFieldConfig[]) => void): void {
-    return this.#instance.visitFields(cls, onField);
+    this.#instance.visitFields(cls, onField);
   }
 
   static getDiscriminatedClasses(cls: Class): Class[] {
@@ -63,7 +62,9 @@ export class SchemaRegistryIndex implements RegistryIndex {
   #baseSchema = new Map<Class, Class>();
   #byDiscriminatedTypes = new Map<Class, Map<string, Class>>();
 
-  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+  /** @private */ constructor(source: unknown) {
+    Registry.validateConstructor(source);
+  }
 
   /**
    * Register discriminated types for a class
@@ -128,7 +129,9 @@ export class SchemaRegistryIndex implements RegistryIndex {
       }
       const requested = map.get(type)!;
       if (!(classConstruct(requested) instanceof targetClass)) {
-        throw new RuntimeError(`Resolved discriminated type '${type}' for class ${base.name} is not an instance of requested type ${targetClass.name}`);
+        throw new RuntimeError(
+          `Resolved discriminated type '${type}' for class ${base.name} is not an instance of requested type ${targetClass.name}`
+        );
       }
       return requested;
     }
@@ -137,10 +140,13 @@ export class SchemaRegistryIndex implements RegistryIndex {
   /**
    * Visit fields recursively
    */
-  visitFields<T>(cls: Class<T>, onField: (field: SchemaFieldConfig, path: SchemaFieldConfig[]) => void, _path: SchemaFieldConfig[] = [], root = cls): void {
-    const fields = SchemaRegistryIndex.has(cls) ?
-      Object.values(this.getClassConfig(cls).fields) :
-      [];
+  visitFields<T>(
+    cls: Class<T>,
+    onField: (field: SchemaFieldConfig, path: SchemaFieldConfig[]) => void,
+    _path: SchemaFieldConfig[] = [],
+    root = cls
+  ): void {
+    const fields = SchemaRegistryIndex.has(cls) ? Object.values(this.getClassConfig(cls).fields) : [];
     for (const field of fields) {
       if (SchemaRegistryIndex.has(field.type)) {
         this.visitFields(field.type, onField, [..._path, field], root);
@@ -155,7 +161,7 @@ export class SchemaRegistryIndex implements RegistryIndex {
    * @param cls The base class to resolve from
    */
   getDiscriminatedClasses(cls: Class): Class[] {
-    return [...this.#byDiscriminatedTypes.get(cls)?.values() ?? []];
+    return [...(this.#byDiscriminatedTypes.get(cls)?.values() ?? [])];
   }
 
   /**
@@ -168,4 +174,4 @@ export class SchemaRegistryIndex implements RegistryIndex {
     }
     return undefined;
   }
-}
+}

package/src/service/types.ts

@@ -3,7 +3,7 @@ import type { Any, Class, IntrinsicType, NumericLikeIntrinsic, Primitive } from
 import type { MethodValidatorFn, ValidatorFn } from '../validate/types.ts';
 
 type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
-export type TemplateLiteral = { operation: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
+export type TemplateLiteral = { operation: 'and' | 'or'; values: (TemplateLiteralPart | TemplateLiteral)[] };
 
 export const CONSTRUCTOR_PROPERTY = 'CONSTRUCTOR';
 
@@ -160,31 +160,31 @@ export interface SchemaInputConfig extends SchemaCoreConfig, SchemaBasicType {
   /**
    * Is the field required
    */
-  required?: { active: boolean, message?: string };
+  required?: { active: boolean; message?: string };
   /**
    * Does the field expect a match
    */
-  match?: { regex: RegExp, message?: string, template?: TemplateLiteral };
+  match?: { regex: RegExp; message?: string; template?: TemplateLiteral };
   /**
    * Minimum value configuration
    */
-  min?: { limit: NumericLikeIntrinsic, message?: string };
+  min?: { limit: NumericLikeIntrinsic; message?: string };
   /**
    * Maximum value configuration
    */
-  max?: { limit: NumericLikeIntrinsic, message?: string };
+  max?: { limit: NumericLikeIntrinsic; message?: string };
   /**
    * Minimum length configuration
    */
-  minlength?: { limit: number, message?: string };
+  minlength?: { limit: number; message?: string };
   /**
    * Maximum length configuration
    */
-  maxlength?: { limit: number, message?: string };
+  maxlength?: { limit: number; message?: string };
   /**
    * Enumerated values
    */
-  enum?: { values: Primitive[], message: string };
+  enum?: { values: Primitive[]; message: string };
   /**
    * Default value
    */
@@ -235,4 +235,4 @@ export interface SchemaFieldConfig extends SchemaInputConfig {
   accessor?: boolean;
 }
 
-export type ViewFieldsConfig<T> = { with: Extract<(keyof T), string>[] } | { without: Extract<(keyof T), string>[] };
+export type ViewFieldsConfig<T> = { with: Extract<keyof T, string>[] } | { without: Extract<keyof T, string>[] };