@travetto/schema 7.1.4 → 8.0.0-alpha.0

package/README.md

@@ -65,27 +65,27 @@ 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#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
+   *  [@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
    *  [@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#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
+   *  [@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#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.
+   *  [@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.
 
 Additionally, schemas can be nested to form more complex data structures that are able to bound and validated. 
 
@@ -218,6 +218,7 @@ would produce an exception similar to following structure
 $ trv main doc/person-invalid-output.ts
 
 Validation Failed {
+  "$trv": "runtime",
   "message": "Validation errors have occurred",
   "category": "data",
   "type": "ValidationResultError",
@@ -297,7 +298,7 @@ export interface ValidationError {
   /**
    * Number to compare against
    */
-  limit?: number | Date;
+  limit?: NumericLikeIntrinsic;
   /**
    * The type of the field
    */
@@ -330,35 +331,39 @@ export type Point = [number, number];
 **Code: Point Implementation**
 ```typescript
 import { DataUtil } from '../data.ts';
+import { SchemaTypeUtil } from '../type-config.ts';
 
 const InvalidSymbol = Symbol();
 
 /**
- * Point Contract
+ * Convert to tuple of two numbers
  */
-export class PointContract {
-
-  /**
-   * Validate we have an actual point
-   */
-  static validateSchema(input: unknown): 'type' | undefined {
-    const bound = this.bindSchema(input);
-    return bound !== InvalidSymbol && bound && !isNaN(bound[0]) && !isNaN(bound[1]) ? undefined : 'type';
+function bindPoint(input: unknown): [number, number] | typeof InvalidSymbol | undefined {
+  if (Array.isArray(input) && input.length === 2) {
+    const [a, b] = input.map(value => DataUtil.coerceType(value, Number, false));
+    return [a, b];
+  } else {
+    return InvalidSymbol;
   }
+}
 
-  /**
-   * Convert to tuple of two numbers
-   */
-  static bindSchema(input: unknown): [number, number] | typeof InvalidSymbol | undefined {
-    if (Array.isArray(input) && input.length === 2) {
-      const [a, b] = input.map(value => DataUtil.coerceType(value, Number, false));
-      return [a, b];
-    } else {
-      return InvalidSymbol;
-    }
-  }
+/**
+ * Validate we have an actual point
+ */
+function validatePoint(input: unknown): 'type' | undefined {
+  const bound = bindPoint(input);
+  return bound !== InvalidSymbol && bound && !isNaN(bound[0]) && !isNaN(bound[1]) ? undefined : 'type';
 }
 
+/**
+ * Point Contract
+ */
+export class PointContract { }
+
+SchemaTypeUtil.setSchemaTypeConfig(PointContract, {
+  validate: validatePoint,
+  bind: bindPoint,
+});
 Object.defineProperty(PointContract, 'name', { value: 'Point' });
 ```
 
@@ -384,6 +389,7 @@ All that happens now, is the type is exported, and the class above is able to pr
 $ trv main doc/custom-type-output.ts
 
 Validation Failed {
+  "$trv": "runtime",
   "message": "Validation errors have occurred",
   "category": "data",
   "type": "ValidationResultError",

package/__index__.ts

@@ -14,5 +14,6 @@ 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';

package/package.json

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

package/src/bind-util.ts

@@ -3,6 +3,7 @@ import { castTo, type Class, classConstruct, asFull, TypedObject, castKey } from
 import { DataUtil } from './data.ts';
 import type { SchemaInputConfig, SchemaParameterConfig, SchemaFieldMap } from './service/types.ts';
 import { SchemaRegistryIndex } from './service/registry-index.ts';
+import { SchemaTypeUtil } from './type-config.ts';
 
 type BindConfig = {
   view?: string;
@@ -25,8 +26,9 @@ export class BindUtil {
    * @param value The provided value
    */
   static #coerceType<T>(config: SchemaInputConfig, value: unknown): T | null | undefined {
-    if (config.type?.bindSchema) {
-      value = config.type.bindSchema(value);
+    const typeConfig = SchemaTypeUtil.getSchemaTypeConfig(config.type);
+    if (typeConfig?.bind) {
+      value = typeConfig.bind(value);
     } else {
       value = DataUtil.coerceType(value, config.type, false);
 

package/src/data.ts

@@ -152,9 +152,11 @@ export class DataUtil {
             input :
             typeof input === 'number' ?
               new Date(input) :
-              (typeof input === 'string' && /^[-]?\d+$/.test(input)) ?
-                new Date(parseInt(input, 10)) :
-                new Date(input.toString());
+              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}`);
@@ -162,6 +164,9 @@ export class DataUtil {
         return value;
       }
       case Number: {
+        if (typeof input === 'bigint') {
+          return Number(input);
+        }
         const value = `${input}`.includes('.') ? parseFloat(`${input}`) : parseInt(`${input}`, 10);
         if (strict && Number.isNaN(value)) {
           throw new Error(`Invalid numeric value: ${input}`);

package/src/decorator/input.ts

@@ -1,9 +1,15 @@
-import { type Any, type Class, type ClassInstance, getClass } 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';
 
+type StringType = string | string[];
+type LengthType = string | unknown[] | Uint8Array | Uint16Array | Uint32Array;
+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);
@@ -55,7 +61,7 @@ export function Required(active = true, message?: string): PropType<unknown> { r
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Enum(values: string[], message?: string): PropType<string | number> {
+export function Enum(values: string[], message?: string): PropType<EnumType> {
   message = message || `{path} is only allowed to be "${values.join('" or "')}"`;
   return input({ enum: { values, message } });
 }
@@ -65,14 +71,14 @@ export function Enum(values: string[], message?: string): PropType<string | numb
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Text(): PropType<string | string[]> { 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<string | string[]> { return input({ specifiers: ['text', 'long'] }); }
+export function LongText(): PropType<StringType> { return input({ specifiers: ['text', 'long'] }); }
 
 /**
  * Require the input to match a specific RegExp
@@ -81,7 +87,7 @@ export function LongText(): PropType<string | string[]> { return input({ specifi
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Match(regex: RegExp, message?: string): PropType<string | string[]> { 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
@@ -90,7 +96,7 @@ export function Match(regex: RegExp, message?: string): PropType<string | string
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function MinLength(limit: number, message?: string): PropType<string | unknown[]> {
+export function MinLength(limit: number, message?: string): PropType<LengthType> {
   return input({ minlength: { limit, message }, ...(limit === 0 ? { required: { active: false } } : {}) });
 }
 
@@ -101,7 +107,7 @@ export function MinLength(limit: number, message?: string): PropType<string | un
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function MaxLength(limit: number, message?: string): PropType<string | unknown[]> { return input({ maxlength: { limit, message } }); }
+export function MaxLength(limit: number, message?: string): PropType<LengthType> { return input({ maxlength: { limit, message } }); }
 
 /**
  * The minimum value
@@ -110,8 +116,8 @@ export function MaxLength(limit: number, message?: string): PropType<string | un
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Min<T extends number | Date>(limit: T, message?: string): PropType<Date | number> {
-  return input({ min: { limit, message } });
+export function Min(limit: NumericLikeIntrinsic, message?: string): PropType<NumberLikeType> {
+  return input<NumberLikeType>({ min: { limit, message } });
 }
 
 /**
@@ -121,8 +127,8 @@ export function Min<T extends number | Date>(limit: T, message?: string): PropTy
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Max<T extends number | Date>(limit: T, message?: string): PropType<Date | number> {
-  return input({ max: { limit, message } });
+export function Max(limit: NumericLikeIntrinsic, message?: string): PropType<NumberLikeType> {
+  return input<NumberLikeType>({ max: { limit, message } });
 }
 
 /**
@@ -131,7 +137,7 @@ export function Max<T extends number | Date>(limit: T, message?: string): PropTy
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Email(message?: string): PropType<string | string[]> { return Match(CommonRegex.email, message); }
+export function Email(message?: string): PropType<StringType> { return Match(CommonRegex.email, message); }
 
 /**
  * Mark an input as an telephone number
@@ -139,7 +145,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(CommonRegex.telephone, message); }
+export function Telephone(message?: string): PropType<StringType> { return Match(CommonRegex.telephone, message); }
 
 /**
  * Mark an input as a url
@@ -147,7 +153,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(CommonRegex.url, message); }
+export function Url(message?: string): PropType<StringType> { return Match(CommonRegex.url, message); }
 
 /**
  * Determine the numeric precision of the value
@@ -163,7 +169,7 @@ export function Precision(digits: number, decimals?: number): PropType<number> {
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Integer(): PropType<number> { return Precision(0); }
+export function Integer(): PropType<NumberType> { return Precision(0); }
 
 /**
  * Mark a number as a float
@@ -177,14 +183,14 @@ export function Float(): PropType<number> { return Precision(10, 7); }
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Long(): PropType<number> { 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<number> { return Precision(13, 2); }
+export function Currency(): PropType<NumberType> { return Precision(13, 2); }
 
 /**
  * Specifier for the input

package/src/internal/types.ts

@@ -1,31 +1,35 @@
 import { DataUtil } from '../data.ts';
+import { SchemaTypeUtil } from '../type-config.ts';
 
 const InvalidSymbol = Symbol();
 
 /**
- * Point Contract
+ * Convert to tuple of two numbers
  */
-export class PointContract {
-
-  /**
-   * Validate we have an actual point
-   */
-  static validateSchema(input: unknown): 'type' | undefined {
-    const bound = this.bindSchema(input);
-    return bound !== InvalidSymbol && bound && !isNaN(bound[0]) && !isNaN(bound[1]) ? undefined : 'type';
+function bindPoint(input: unknown): [number, number] | typeof InvalidSymbol | undefined {
+  if (Array.isArray(input) && input.length === 2) {
+    const [a, b] = input.map(value => DataUtil.coerceType(value, Number, false));
+    return [a, b];
+  } else {
+    return InvalidSymbol;
   }
+}
 
-  /**
-   * Convert to tuple of two numbers
-   */
-  static bindSchema(input: unknown): [number, number] | typeof InvalidSymbol | undefined {
-    if (Array.isArray(input) && input.length === 2) {
-      const [a, b] = input.map(value => DataUtil.coerceType(value, Number, false));
-      return [a, b];
-    } else {
-      return InvalidSymbol;
-    }
-  }
+/**
+ * Validate we have an actual point
+ */
+function validatePoint(input: unknown): 'type' | undefined {
+  const bound = bindPoint(input);
+  return bound !== InvalidSymbol && bound && !isNaN(bound[0]) && !isNaN(bound[1]) ? undefined : 'type';
 }
 
-Object.defineProperty(PointContract, 'name', { value: 'Point' });
+/**
+ * Point Contract
+ */
+export class PointContract { }
+
+SchemaTypeUtil.setSchemaTypeConfig(PointContract, {
+  validate: validatePoint,
+  bind: bindPoint,
+});
+Object.defineProperty(PointContract, 'name', { value: 'Point' });

package/src/service/registry-adapter.ts

@@ -1,10 +1,10 @@
 import type { RegistryAdapter } from '@travetto/registry';
-import { AppError, castKey, castTo, type Class, describeFunction, safeAssign } from '@travetto/runtime';
+import { RuntimeError, BinaryUtil, castKey, castTo, type Class, describeFunction, safeAssign } from '@travetto/runtime';
 
 import {
   type SchemaClassConfig, type SchemaMethodConfig, type SchemaFieldConfig,
   type SchemaParameterConfig, type SchemaInputConfig, type SchemaFieldMap, type SchemaCoreConfig,
-  CONSTRUCTOR_PROPERTY
+  type SchemaBasicType, CONSTRUCTOR_PROPERTY
 } from './types.ts';
 
 export type SchemaDiscriminatedInfo = Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>>;
@@ -32,6 +32,12 @@ function combineCore<T extends SchemaCoreConfig>(base: T, config: Partial<T>): T
   });
 }
 
+function ensureBinary<T extends SchemaBasicType>(config?: T): void {
+  if (config?.type) {
+    config.binary = BinaryUtil.isBinaryTypeReference(config.type);
+  }
+}
+
 function combineInputs<T extends SchemaInputConfig>(base: T, configs: Partial<T>[]): T {
   for (const config of configs) {
     if (config) {
@@ -48,6 +54,7 @@ function combineInputs<T extends SchemaInputConfig>(base: T, configs: Partial<T>
       });
     }
     combineCore(base, config);
+    ensureBinary(base);
   }
   return base;
 }
@@ -65,6 +72,7 @@ function combineMethods<T extends SchemaMethodConfig>(base: T, configs: Partial<
         safeAssign(base.parameters[param.index], param);
       }
     }
+    ensureBinary(config.returnType);
   }
   return base;
 }
@@ -290,7 +298,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
   getMethod(method: string): SchemaMethodConfig {
     const methodConfig = this.#config.methods[method];
     if (!methodConfig) {
-      throw new AppError(`Unknown method ${String(method)} on class ${this.#cls.Ⲑid}`);
+      throw new RuntimeError(`Unknown method ${String(method)} on class ${this.#cls.Ⲑid}`);
     }
     return methodConfig;
   }
@@ -304,7 +312,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
       return this.#config.fields;
     }
     if (!this.#views.has(view)) {
-      throw new AppError(`Unknown view ${view} for class ${this.#cls.Ⲑid}`);
+      throw new RuntimeError(`Unknown view ${view} for class ${this.#cls.Ⲑid}`);
     }
     return this.#views.get(view)!;
   }
@@ -313,14 +321,13 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
    * Provides the prototype-derived descriptor for a property
    */
   getAccessorDescriptor(field: string): PropertyDescriptor {
-    if (!this.#accessorDescriptors.has(field)) {
+    return this.#accessorDescriptors.getOrInsertComputed(field, () => {
       let proto = this.#cls.prototype;
       while (proto && !Object.hasOwn(proto, field)) {
         proto = proto.prototype;
       }
-      this.#accessorDescriptors.set(field, Object.getOwnPropertyDescriptor(proto, field)!);
-    }
-    return this.#accessorDescriptors.get(field)!;
+      return Object.getOwnPropertyDescriptor(proto, field)!;
+    });
   }
 
   /**

package/src/service/registry-index.ts

@@ -1,5 +1,5 @@
 import { type RegistrationMethods, type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { AppError, castKey, castTo, type Class, classConstruct, getParentClass } from '@travetto/runtime';
+import { RuntimeError, castKey, castTo, type Class, classConstruct, getParentClass } from '@travetto/runtime';
 
 import type { SchemaFieldConfig, SchemaClassConfig } from './types.ts';
 import { type SchemaDiscriminatedInfo, SchemaRegistryAdapter } from './registry-adapter.ts';
@@ -75,10 +75,7 @@ export class SchemaRegistryIndex implements RegistryIndex {
       return;
     }
     const base = this.getBaseClass(cls);
-    if (!this.#byDiscriminatedTypes.has(base)) {
-      this.#byDiscriminatedTypes.set(base, new Map());
-    }
-    this.#byDiscriminatedTypes.get(base)!.set(config.discriminatedType, cls);
+    this.#byDiscriminatedTypes.getOrInsert(base, new Map()).set(config.discriminatedType, cls);
   }
 
   beforeChangeSetComplete(): void {
@@ -97,7 +94,7 @@ export class SchemaRegistryIndex implements RegistryIndex {
    * Find base schema class for a given class
    */
   getBaseClass(cls: Class): Class {
-    if (!this.#baseSchema.has(cls)) {
+    return this.#baseSchema.getOrInsertComputed(cls, () => {
       let config = this.getClassConfig(cls);
       let parent: Class | undefined = cls;
       while (parent && config.discriminatedType && !config.discriminatedBase) {
@@ -106,9 +103,8 @@ export class SchemaRegistryIndex implements RegistryIndex {
           config = this.store.getOptional(parent)?.get() ?? config;
         }
       }
-      this.#baseSchema.set(cls, config.class);
-    }
-    return this.#baseSchema.get(cls)!;
+      return config.class;
+    });
   }
 
   /**
@@ -125,14 +121,14 @@ export class SchemaRegistryIndex implements RegistryIndex {
       const map = this.#byDiscriminatedTypes.get(base);
       const type = castTo<string>(item[castKey<T>(discriminatedField)]) ?? discriminatedType;
       if (!type) {
-        throw new AppError(`Unable to resolve discriminated type for class ${base.name} without a type`);
+        throw new RuntimeError(`Unable to resolve discriminated type for class ${base.name} without a type`);
       }
       if (!map?.has(type)) {
-        throw new AppError(`Unable to resolve discriminated type '${type}' for class ${base.name}`);
+        throw new RuntimeError(`Unable to resolve discriminated type '${type}' for class ${base.name}`);
       }
       const requested = map.get(type)!;
       if (!(classConstruct(requested) instanceof targetClass)) {
-        throw new AppError(`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;
     }

package/src/service/types.ts

@@ -1,4 +1,4 @@
-import type { Any, Class, Primitive } from '@travetto/runtime';
+import type { Any, Class, IntrinsicType, NumericLikeIntrinsic, Primitive } from '@travetto/runtime';
 
 import type { MethodValidatorFn, ValidatorFn } from '../validate/types.ts';
 
@@ -19,13 +19,14 @@ export type SchemaBasicType = {
    * Is the type an array
    */
   array?: boolean;
+  /**
+   * Is the type a binary type
+   */
+  binary?: boolean;
   /**
    * The class tied to the type
    */
-  type: Class & {
-    bindSchema?(input: unknown): undefined | unknown;
-    validateSchema?(input: unknown): string | undefined;
-  };
+  type: Class;
   /**
    * Is the field a foreign type
    */
@@ -167,11 +168,11 @@ export interface SchemaInputConfig extends SchemaCoreConfig, SchemaBasicType {
   /**
    * Minimum value configuration
    */
-  min?: { limit: number | Date, message?: string };
+  min?: { limit: NumericLikeIntrinsic, message?: string };
   /**
    * Maximum value configuration
    */
-  max?: { limit: number | Date, message?: string };
+  max?: { limit: NumericLikeIntrinsic, message?: string };
   /**
    * Minimum length configuration
    */
@@ -183,11 +184,11 @@ export interface SchemaInputConfig extends SchemaCoreConfig, SchemaBasicType {
   /**
    * Enumerated values
    */
-  enum?: { values: (string | number | boolean)[], message: string };
+  enum?: { values: Primitive[], message: string };
   /**
    * Default value
    */
-  default?: Primitive | [];
+  default?: IntrinsicType | [];
 }
 
 /**

package/src/type-config.ts

@@ -0,0 +1,54 @@
+import { isUint8Array, isUint16Array, isUint32Array, isArrayBuffer } from 'node:util/types';
+import { Readable } from 'node:stream';
+
+import { type Class, type BinaryArray, type BinaryType, type BinaryStream, BinaryUtil, toConcrete } from '@travetto/runtime';
+
+type SchemaTypeConfig = {
+  /**
+   * Controls how inbound data is typed
+   */
+  bind?(input: unknown): undefined | unknown;
+  /**
+   * Controls how provided data is validated
+   */
+  validate?(input: unknown): string | undefined;
+};
+
+/**
+ * Utility for managing schema type configuration
+ */
+export class SchemaTypeUtil {
+  static cache = new Map<Function, SchemaTypeConfig>();
+
+  static {
+    // Primitive Types
+    this.register(Date, value => value instanceof Date && !Number.isNaN(value.getTime()));
+    // Binary Types
+    this.register(Buffer, Buffer.isBuffer);
+    this.register(Uint8Array, isUint8Array);
+    this.register(Uint16Array, isUint16Array);
+    this.register(Uint32Array, isUint32Array);
+    this.register(ArrayBuffer, isArrayBuffer);
+    this.register(ReadableStream, value => value instanceof ReadableStream);
+    this.register(Readable, value => value instanceof Readable);
+    this.register(toConcrete<BinaryType>(), BinaryUtil.isBinaryType);
+    this.register(toConcrete<BinaryArray>(), BinaryUtil.isBinaryArray);
+    this.register(toConcrete<BinaryStream>(), BinaryUtil.isBinaryStream);
+    this.register(Blob, value => value instanceof Blob);
+    this.register(File, value => value instanceof File);
+  }
+
+  static register(type: Class | Function, fn: (value: unknown) => boolean): void {
+    SchemaTypeUtil.setSchemaTypeConfig(type, {
+      validate: (item: unknown) => fn(item) ? undefined : 'type'
+    });
+  }
+
+  static getSchemaTypeConfig(type: Function): SchemaTypeConfig | undefined {
+    return this.cache.get(type);
+  }
+
+  static setSchemaTypeConfig(type: Function, config: SchemaTypeConfig): void {
+    this.cache.set(type, config);
+  }
+}

package/src/validate/error.ts

@@ -1,4 +1,4 @@
-import { type Class, AppError } from '@travetto/runtime';
+import { type Class, RuntimeError } from '@travetto/runtime';
 import type { ValidationError } from './types.ts';
 
 /**
@@ -6,7 +6,7 @@ import type { ValidationError } from './types.ts';
  *
  * Hold all the validation errors for a given schema validation
  */
-export class ValidationResultError extends AppError<{ errors: ValidationError[] }> {
+export class ValidationResultError extends RuntimeError<{ errors: ValidationError[] }> {
   constructor(errors: ValidationError[]) {
     super('Validation errors have occurred', { category: 'data', details: { errors } });
   }
@@ -16,7 +16,7 @@ export class ValidationResultError extends AppError<{ errors: ValidationError[]
  * Represents when a requested objects's type doesn't match the class being used to request.
  * Primarily applies to polymorphic types
  */
-export class TypeMismatchError extends AppError {
+export class TypeMismatchError extends RuntimeError {
   constructor(cls: Class | string, type: string) {
     super(`Expected ${typeof cls === 'string' ? cls : cls.name} but found ${type}`, { category: 'data' });
   }

package/src/validate/types.ts

@@ -1,3 +1,5 @@
+import type { NumericLikeIntrinsic } from '@travetto/runtime';
+
 export type ValidationKindCore = 'required' | 'match' | 'min' | 'max' | 'minlength' | 'maxlength' | 'enum' | 'type';
 export type ValidationKind = ValidationKindCore | string;
 
@@ -29,7 +31,7 @@ export interface ValidationError {
   /**
    * Number to compare against
    */
-  limit?: number | Date;
+  limit?: NumericLikeIntrinsic;
   /**
    * The type of the field
    */
@@ -67,7 +69,7 @@ export interface ValidationResult {
   /**
    * Number to compare against
    */
-  limit?: number | Date;
+  limit?: NumericLikeIntrinsic;
 }
 
 type OrPromise<T> = T | Promise<T>;

package/src/validate/validator.ts

@@ -7,6 +7,11 @@ import { isValidationError, TypeMismatchError, ValidationResultError } from './e
 import { DataUtil } from '../data.ts';
 import { CommonRegexToName } from './regex.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
+import { SchemaTypeUtil } from '../type-config.ts';
+import { UnknownType } from '../types.ts';
+
+const PrimitiveTypes = new Set<Function>([String, Number, BigInt, Boolean]);
+type NumericComparable = number | bigint | Date;
 
 /**
  * Get the schema config for Class/Schema config, including support for polymorphism
@@ -22,8 +27,12 @@ function isClassInstance<T>(value: unknown): value is ClassInstance<T> {
   return !DataUtil.isPlainObject(value) && value !== null && typeof value === 'object' && !!value.constructor;
 }
 
-function isRangeValue(value: unknown): value is number | string | Date {
-  return typeof value === 'string' || typeof value === 'number' || value instanceof Date;
+function isRangeValue(value: unknown): value is NumericComparable {
+  return typeof value === 'number' || typeof value === 'bigint' || value instanceof Date;
+}
+
+function isLengthValue(value: unknown): value is { length: number } {
+  return (typeof value === 'string' || (typeof value === 'object' && !!value && 'length' in value && typeof value.length === 'number'));
 }
 
 /**
@@ -72,7 +81,7 @@ export class SchemaValidator {
     const { type, array } = input;
     const complex = SchemaRegistryIndex.has(type);
 
-    if (type === Object) {
+    if (type === Object || type === UnknownType) {
       return [];
     } else if (array) {
       if (!Array.isArray(value)) {
@@ -105,13 +114,10 @@ export class SchemaValidator {
    * @param key The bounds to check
    * @param value The value to validate
    */
-  static #validateRange(input: SchemaInputConfig, key: 'min' | 'max', value: string | number | Date): boolean {
+  static #validateRange(input: SchemaInputConfig, key: 'min' | 'max', value: NumericComparable): boolean {
     const config = input[key]!;
-    const parsed = (typeof value === 'string') ?
-      (input.type === Date ? Date.parse(value) : parseInt(value, 10)) :
-      (value instanceof Date ? value.getTime() : value);
-
-    const boundary = (typeof config.limit === 'number' ? config.limit : config.limit.getTime());
+    const parsed = (value instanceof Date ? value.getTime() : value);
+    const boundary = (config.limit instanceof Date) ? config.limit.getTime() : config.limit;
     return key === 'min' ? parsed < boundary : parsed > boundary;
   }
 
@@ -122,37 +128,37 @@ export class SchemaValidator {
    * @param value The actual value
    */
   static #validateInput(input: SchemaInputConfig, value: unknown): ValidationResult[] {
-    const criteria: ([string, SchemaInputConfig[ValidationKindCore]] | [string])[] = [];
-
-    if (
-      (input.type === String && (typeof value !== 'string')) ||
-      (input.type === Number && ((typeof value !== 'number') || Number.isNaN(value))) ||
-      (input.type === Date && (!(value instanceof Date) || Number.isNaN(value.getTime()))) ||
-      (input.type === Boolean && typeof value !== 'boolean')
-    ) {
-      criteria.push(['type']);
-      return [{ kind: 'type', type: input.type.name.toLowerCase() }];
-    }
+    const criteria: [string, SchemaInputConfig[ValidationKindCore]][] = [];
+    const config = SchemaTypeUtil.getSchemaTypeConfig(input.type);
 
-    if (input.type?.validateSchema) {
-      const kind = input.type.validateSchema(value);
+    if (config?.validate) {
+      const kind = config.validate(value);
       switch (kind) {
         case undefined: break;
         case 'type': return [{ kind, type: input.type.name }];
-        default:
-          criteria.push([kind]);
+        default: return [{ kind, value }];
+      }
+    } else if (PrimitiveTypes.has(input.type)) {
+      if (typeof value !== input.type.name.toLowerCase()) {
+        return [{ kind: 'type', type: input.type.name.toLowerCase() }];
+      } else if (Number.isNaN(value)) {
+        return [{ kind: 'type', type: 'number' }];
+      }
+    } else if (SchemaRegistryIndex.has(input.type)) {
+      if (!(value instanceof input.type)) { // If not an instance of the type
+        return [{ kind: 'type', type: input.type.name }];
       }
     }
 
-    if (input.match && !input.match.regex.test(`${value}`)) {
+    if (input.match && (typeof value !== 'string' || !input.match.regex.test(value))) {
       criteria.push(['match', input.match]);
     }
 
-    if (input.minlength && `${value}`.length < input.minlength.limit) {
+    if (input.minlength && (!isLengthValue(value) || value.length < input.minlength.limit)) {
       criteria.push(['minlength', input.minlength]);
     }
 
-    if (input.maxlength && `${value}`.length > input.maxlength.limit) {
+    if (input.maxlength && (!isLengthValue(value) || value.length > input.maxlength.limit)) {
       criteria.push(['maxlength', input.maxlength]);
     }
 
@@ -168,12 +174,7 @@ export class SchemaValidator {
       criteria.push(['max', input.max]);
     }
 
-    const errors: ValidationResult[] = [];
-    for (const [key, block] of criteria) {
-      errors.push({ ...block, kind: key, value });
-    }
-
-    return errors;
+    return criteria.map(([key, block]) => ({ ...block, kind: key, value }));
   }
 
   /**

package/support/transformer/util.ts

@@ -215,7 +215,7 @@ class ${uniqueId} extends ${type.mappedClassName} {
     }
 
     const resolved = this.toConcreteType(state, typeExpr, node, config?.root ?? node);
-    const type = typeExpr.key === 'foreign' ? state.getConcreteType(node) :
+    const type = typeExpr.key === 'foreign' ? state.getConcreteType(node, state.factory.createIdentifier('Object')) :
       ts.isArrayLiteralExpression(resolved) ? resolved.elements[0] : resolved;
 
     params.unshift(LiteralUtil.fromLiteral(state.factory, {