@travetto/schema 6.0.0 → 7.0.0-rc.0

package/src/service/types.ts

@@ -2,19 +2,40 @@ import { Any, Class, Primitive } from '@travetto/runtime';
 
 import { MethodValidatorFn, ValidatorFn } from '../validate/types.ts';
 
-export type ClassList = Class | [Class];
-
 type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
 export type TemplateLiteral = { op: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
 
+export const CONSTRUCTOR_PROPERTY = 'CONSTRUCTOR';
+
 /**
- * Basic describable configuration
+ * Represents a typed item in the schema
  */
-export interface DescribableConfig {
+export type SchemaBasicType = {
+  /**
+   * Description of the type
+   */
+  description?: string;
   /**
-   * Title
+   * Is the type an array
    */
-  title?: string;
+  array?: boolean;
+  /**
+   * The class tied to the type
+   */
+  type: Class & {
+    bindSchema?(input: unknown): undefined | unknown;
+    validateSchema?(input: unknown): string | undefined;
+  };
+  /**
+   * Is the field a foreign type
+   */
+  isForeign?: boolean;
+};
+
+/**
+ * Basic schema configuration
+ */
+export interface SchemaCoreConfig {
   /**
    * Description
    */
@@ -23,44 +44,52 @@ export interface DescribableConfig {
    * List of examples
    */
   examples?: string[];
+  /**
+   * Is the field/method/private
+   */
+  private?: boolean;
+  /**
+   * Metadata that is related to the schema structure
+   */
+  metadata?: Record<symbol, unknown>;
 }
 
 /**
  * Basic structure for a method configuration
  */
-export interface SchemaMethodConfig {
-  fields: FieldConfig[];
+export interface SchemaMethodConfig extends SchemaCoreConfig {
+  /**
+   * Is the method static
+   */
+  isStatic?: boolean;
+  /**
+   * The parameters of the method
+   */
+  parameters: SchemaParameterConfig[];
+  /**
+   * Validators to run for th method
+   */
   validators: MethodValidatorFn<unknown[]>[];
-}
-
-/**
- * Schema configuration
- */
-export interface SchemaConfig {
   /**
-   * List of all fields
+   * The return type configuration
    */
-  [key: string]: FieldConfig;
+  returnType?: SchemaBasicType;
 }
 
 /**
- * Specific view configuration for a schema
+ * Schema configuration
  */
-export interface ViewConfig {
-  /**
-   * The schema config
-   */
-  schema: SchemaConfig;
+export interface SchemaFieldMap {
   /**
-   * The list of all fields in the view
+   * List of all fields
    */
-  fields: string[];
+  [key: string | symbol]: SchemaFieldConfig;
 }
 
 /**
  * Class configuration
  */
-export interface ClassConfig extends DescribableConfig {
+export interface SchemaClassConfig extends SchemaCoreConfig {
   /**
    * Target class
    */
@@ -68,72 +97,61 @@ export interface ClassConfig extends DescribableConfig {
   /**
    * List of all views
    */
-  views: Record<string, ViewConfig>;
+  views: Record<string, ViewFieldsConfig<Any>>;
   /**
-   * Composite of all views
+   * Field configurations
    */
-  totalView: ViewConfig;
+  fields: SchemaFieldMap;
   /**
    * Global validators
    */
   validators: ValidatorFn<Any, unknown>[];
   /**
-   * Is the class a base type
+   * Is this a base class for discrimination
    */
-  baseType?: boolean;
+  discriminatedBase?: boolean;
   /**
-   * Sub type name
+   * Do we have a discriminator field
    */
-  subTypeName?: string;
+  discriminatedField?: string;
   /**
-   * The field the subtype is determined by
+   * Discriminated type name
    */
-  subTypeField: string;
+  discriminatedType?: string;
   /**
-   * Metadata that is related to the schema structure
+   * Method configs
    */
-  metadata?: Record<symbol, unknown>;
+  methods: Record<string | symbol, SchemaMethodConfig>;
+  /**
+   * Interfaces that the class implements
+   */
+  interfaces: Class[];
   /**
-   * Method parameter configs
+   * Is this class derived from another via a mapped type
    */
-  methods: Record<string, SchemaMethodConfig>;
+  mappedOperation?: 'Omit' | 'Pick' | 'Partial' | 'Required';
+  /**
+   * Are there any restrictions in the mapped type
+   */
+  mappedFields?: string[];
 }
 
 /**
- * Field configuration
+ * Shared base type for all input-related fields
  */
-export interface FieldConfig extends DescribableConfig {
+export interface SchemaInputConfig extends SchemaCoreConfig, SchemaBasicType {
   /**
-   * Owner class
+   * Key name for validation when dealing with complex types
    */
-  owner?: Class;
+  view?: string;
   /**
-   * Field name
+   * Owner class
    */
-  name: string;
+  owner: Class;
   /**
    * List of aliases
    */
   aliases?: string[];
-  /**
-   * Specific type for the field, with optional binding/validation support
-   */
-  type: Class & {
-    bindSchema?(input: unknown): undefined | unknown;
-    validateSchema?(input: unknown): string | undefined;
-  };
-  /**
-   * View name for validation when dealing with complex types
-   */
-  view?: string;
-  /**
-   * The position of the field if ordered
-   */
-  index?: number;
-  /**
-   * Is the field an array
-   */
-  array: boolean;
   /**
    * Does the field have a specialization
    */
@@ -174,6 +192,38 @@ export interface FieldConfig extends DescribableConfig {
    * Default value
    */
   default?: Primitive | [];
+}
+
+/**
+ * Parameter configuration for methods
+ */
+export interface SchemaParameterConfig extends SchemaInputConfig {
+  /**
+   * Parameter name
+   */
+  name?: string;
+  /**
+   * The position of the field if ordered
+   */
+  index: number;
+  /**
+   * Method the parameter belongs to
+   */
+  method: string | symbol;
+  /**
+   * Source text for the parameter
+   */
+  sourceText?: string;
+}
+
+/**
+ * Field configuration
+ */
+export interface SchemaFieldConfig extends SchemaInputConfig {
+  /**
+   * Field name
+   */
+  name: string | symbol;
   /**
    * Is the field readonly, or write only?, defaults to no restrictions
    */

package/src/validate/types.ts

@@ -34,6 +34,10 @@ export interface ValidationError {
    * The type of the field
    */
   type?: string;
+  /**
+   * Source of the error
+   */
+  source?: string;
 }
 
 /**

package/src/validate/validator.ts

@@ -1,22 +1,21 @@
 import { castKey, castTo, Class, ClassInstance, TypedObject } from '@travetto/runtime';
 
-import { FieldConfig, SchemaConfig } from '../service/types.ts';
-import { SchemaRegistry } from '../service/registry.ts';
+import { SchemaInputConfig, SchemaFieldMap } from '../service/types.ts';
 import { ValidationError, ValidationKindCore, ValidationResult } from './types.ts';
 import { Messages } from './messages.ts';
 import { isValidationError, TypeMismatchError, ValidationResultError } from './error.ts';
 import { DataUtil } from '../data.ts';
 import { CommonRegExpToName } from './regexp.ts';
+import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
 /**
  * Get the schema config for Class/Schema config, including support for polymorphism
  * @param base The starting type or config
  * @param o The value to use for the polymorphic check
  */
-function resolveSchema<T>(base: Class<T>, o: T, view?: string): SchemaConfig {
-  return SchemaRegistry.getViewSchema(
-    SchemaRegistry.resolveInstanceType(base, o), view
-  ).schema;
+function resolveFieldMap<T>(base: Class<T>, o: T): SchemaFieldMap {
+  const target = SchemaRegistryIndex.resolveInstanceType(base, o);
+  return SchemaRegistryIndex.getFieldMap(target);
 }
 
 function isClassInstance<T>(o: unknown): o is ClassInstance<T> {
@@ -35,17 +34,16 @@ export class SchemaValidator {
 
   /**
    * Validate the schema for a given object
-   * @param schema The config to validate against
+   * @param fields The config to validate against
    * @param o The object to validate
    * @param relative The relative path as the validation recurses
    */
-  static #validateSchema<T>(schema: SchemaConfig, o: T, relative: string): ValidationError[] {
+  static #validateFields<T>(fields: SchemaFieldMap, o: T, relative: string): ValidationError[] {
     let errors: ValidationError[] = [];
 
-    const fields = TypedObject.keys<SchemaConfig>(schema);
-    for (const field of fields) {
-      if (schema[field].access !== 'readonly') { // Do not validate readonly fields
-        errors = errors.concat(this.#validateFieldSchema(schema[field], o[castKey<T>(field)], relative));
+    for (const [field, fieldConfig] of TypedObject.entries(fields)) {
+      if (fieldConfig.access !== 'readonly') { // Do not validate readonly fields
+        errors = errors.concat(this.#validateInputSchema(fieldConfig, o[castKey<T>(field)], relative));
       }
     }
 
@@ -53,25 +51,26 @@ export class SchemaValidator {
   }
 
   /**
-   * Validate a single field config against a passed in value
-   * @param fieldSchema The field schema configuration
+   * Validate a single input config against a passed in value
+   * @param input The input schema configuration
    * @param val The raw value, could be an array or not
    * @param relative The relative path of object traversal
    */
-  static #validateFieldSchema(fieldSchema: FieldConfig, val: unknown, relative: string = ''): ValidationError[] {
-    const path = `${relative}${relative ? '.' : ''}${fieldSchema.name}`;
+  static #validateInputSchema(input: SchemaInputConfig, val: unknown, relative: string = ''): ValidationError[] {
+    const key = 'name' in input ? input.name : ('index' in input ? input.index : 'unknown');
+    const path = `${relative}${relative ? '.' : ''}${key}`;
     const hasValue = !(val === undefined || val === null || (typeof val === 'string' && val === '') || (Array.isArray(val) && val.length === 0));
 
     if (!hasValue) {
-      if (fieldSchema.required && fieldSchema.required.active) {
-        return this.#prepareErrors(path, [{ kind: 'required', ...fieldSchema.required }]);
+      if (input.required?.active !== false) {
+        return this.#prepareErrors(path, [{ kind: 'required', active: true, ...input.required }]);
       } else {
         return [];
       }
     }
 
-    const { type, array, view } = fieldSchema;
-    const complex = SchemaRegistry.has(type);
+    const { type, array } = input;
+    const complex = SchemaRegistryIndex.has(type);
 
     if (type === Object) {
       return [];
@@ -82,34 +81,34 @@ export class SchemaValidator {
       let errors: ValidationError[] = [];
       if (complex) {
         for (let i = 0; i < val.length; i++) {
-          const subErrors = this.#validateSchema(resolveSchema(type, val[i], view), val[i], `${path}[${i}]`);
+          const subErrors = this.#validateFields(resolveFieldMap(type, val[i]), val[i], `${path}[${i}]`);
           errors = errors.concat(subErrors);
         }
       } else {
         for (let i = 0; i < val.length; i++) {
-          const subErrors = this.#validateField(fieldSchema, val[i]);
+          const subErrors = this.#validateInput(input, val[i]);
           errors.push(...this.#prepareErrors(`${path}[${i}]`, subErrors));
         }
       }
       return errors;
     } else if (complex) {
-      return this.#validateSchema(resolveSchema(type, val, view), val, path);
+      return this.#validateFields(resolveFieldMap(type, val), val, path);
     } else {
-      const fieldErrors = this.#validateField(fieldSchema, val);
+      const fieldErrors = this.#validateInput(input, val);
       return this.#prepareErrors(path, fieldErrors);
     }
   }
 
   /**
    * Validate the range for a number, date
-   * @param field The config to validate against
+   * @param input The config to validate against
    * @param key The bounds to check
    * @param value The value to validate
    */
-  static #validateRange(field: FieldConfig, key: 'min' | 'max', value: string | number | Date): boolean {
-    const f = field[key]!;
+  static #validateRange(input: SchemaInputConfig, key: 'min' | 'max', value: string | number | Date): boolean {
+    const f = input[key]!;
     const valueNum = (typeof value === 'string') ?
-      (field.type === Date ? Date.parse(value) : parseInt(value, 10)) :
+      (input.type === Date ? Date.parse(value) : parseInt(value, 10)) :
       (value instanceof Date ? value.getTime() : value);
 
     const boundary = (typeof f.n === 'number' ? f.n : f.n.getTime());
@@ -119,54 +118,54 @@ export class SchemaValidator {
   /**
    * Validate a given field by checking all the appropriate constraints
    *
-   * @param field The config of the field to validate
+   * @param input The config of the field to validate
    * @param value The actual value
    */
-  static #validateField(field: FieldConfig, value: unknown): ValidationResult[] {
-    const criteria: ([string, FieldConfig[ValidationKindCore]] | [string])[] = [];
+  static #validateInput(input: SchemaInputConfig, value: unknown): ValidationResult[] {
+    const criteria: ([string, SchemaInputConfig[ValidationKindCore]] | [string])[] = [];
 
     if (
-      (field.type === String && (typeof value !== 'string')) ||
-      (field.type === Number && ((typeof value !== 'number') || Number.isNaN(value))) ||
-      (field.type === Date && (!(value instanceof Date) || Number.isNaN(value.getTime()))) ||
-      (field.type === Boolean && typeof value !== 'boolean')
+      (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: field.type.name.toLowerCase() }];
+      return [{ kind: 'type', type: input.type.name.toLowerCase() }];
     }
 
-    if (field.type?.validateSchema) {
-      const kind = field.type.validateSchema(value);
+    if (input.type?.validateSchema) {
+      const kind = input.type.validateSchema(value);
       switch (kind) {
         case undefined: break;
-        case 'type': return [{ kind, type: field.type.name }];
+        case 'type': return [{ kind, type: input.type.name }];
         default:
           criteria.push([kind]);
       }
     }
 
-    if (field.match && !field.match.re.test(`${value}`)) {
-      criteria.push(['match', field.match]);
+    if (input.match && !input.match.re.test(`${value}`)) {
+      criteria.push(['match', input.match]);
     }
 
-    if (field.minlength && `${value}`.length < field.minlength.n) {
-      criteria.push(['minlength', field.minlength]);
+    if (input.minlength && `${value}`.length < input.minlength.n) {
+      criteria.push(['minlength', input.minlength]);
     }
 
-    if (field.maxlength && `${value}`.length > field.maxlength.n) {
-      criteria.push(['maxlength', field.maxlength]);
+    if (input.maxlength && `${value}`.length > input.maxlength.n) {
+      criteria.push(['maxlength', input.maxlength]);
     }
 
-    if (field.enum && !field.enum.values.includes(castTo(value))) {
-      criteria.push(['enum', field.enum]);
+    if (input.enum && !input.enum.values.includes(castTo(value))) {
+      criteria.push(['enum', input.enum]);
     }
 
-    if (field.min && (!isRangeValue(value) || this.#validateRange(field, 'min', value))) {
-      criteria.push(['min', field.min]);
+    if (input.min && (!isRangeValue(value) || this.#validateRange(input, 'min', value))) {
+      criteria.push(['min', input.min]);
     }
 
-    if (field.max && (!isRangeValue(value) || this.#validateRange(field, 'max', value))) {
-      criteria.push(['max', field.max]);
+    if (input.max && (!isRangeValue(value) || this.#validateRange(input, 'max', value))) {
+      criteria.push(['max', input.max]);
     }
 
     const errors: ValidationResult[] = [];
@@ -217,14 +216,15 @@ export class SchemaValidator {
    * Validate the class level validations
    */
   static async #validateClassLevel<T>(cls: Class<T>, o: T, view?: string): Promise<ValidationError[]> {
-    const schema = SchemaRegistry.get(cls);
-    if (!schema) {
+    if (!SchemaRegistryIndex.has(cls)) {
       return [];
     }
 
+    const classConfig = SchemaRegistryIndex.getConfig(cls);
     const errors: ValidationError[] = [];
+
     // Handle class level validators
-    for (const fn of schema.validators) {
+    for (const fn of classConfig.validators) {
       try {
         const res = await fn(o, view);
         if (res) {
@@ -255,13 +255,13 @@ export class SchemaValidator {
     if (isClassInstance(o) && !(o instanceof cls || cls.Ⲑid === o.constructor.Ⲑid)) {
       throw new TypeMismatchError(cls.name, o.constructor.name);
     }
-    cls = SchemaRegistry.resolveInstanceType(cls, o);
+    cls = SchemaRegistryIndex.resolveInstanceType(cls, o);
 
-    const config = SchemaRegistry.getViewSchema(cls, view);
+    const fields = SchemaRegistryIndex.getFieldMap(cls, view);
 
     // Validate using standard behaviors
     const errors = [
-      ...this.#validateSchema(config.schema, o, ''),
+      ...this.#validateFields(fields, o, ''),
       ... await this.#validateClassLevel(cls, o, view)
     ];
     if (errors.length) {
@@ -311,19 +311,25 @@ export class SchemaValidator {
    * @param method The method being invoked
    * @param params The params to validate
    */
-  static async validateMethod<T>(cls: Class<T>, method: string, params: unknown[], prefixes: (string | undefined)[] = []): Promise<void> {
+  static async validateMethod<T>(cls: Class<T>, method: string | symbol, params: unknown[], prefixes: (string | symbol | undefined)[] = []): Promise<void> {
     const errors: ValidationError[] = [];
-    for (const field of SchemaRegistry.getMethodSchema(cls, method)) {
-      const i = field.index!;
+    const config = SchemaRegistryIndex.getMethodConfig(cls, method);
+
+    for (const param of config.parameters) {
+      const i = param.index;
       errors.push(...[
-        ... this.#validateFieldSchema(field, params[i]),
-        ... await this.#validateClassLevel(field.type, params[i])
+        ... this.#validateInputSchema(param, params[i]),
+        ... await this.#validateClassLevel(param.type, params[i])
       ].map(x => {
-        x.path = !prefixes[i] ? x.path.replace(`${field.name}.`, '') : x.path.replace(field.name, prefixes[i]!);
+        if (param.name && typeof param.name === 'string') {
+          x.path = !prefixes[i] ?
+            x.path.replace(`${param.name}.`, '') :
+            x.path.replace(param.name, prefixes[i]!.toString());
+        }
         return x;
       }));
     }
-    for (const validator of SchemaRegistry.getMethodValidators(cls, method)) {
+    for (const validator of config.validators) {
       const res = await validator(...params);
       if (res) {
         if (Array.isArray(res)) {