@travetto/schema 6.0.1 → 7.0.0-rc.1

package/src/decorator/input.ts

@@ -0,0 +1,207 @@
+import { Any, Class, ClassInstance, getClass } from '@travetto/runtime';
+
+import { CommonRegExp } from '../validate/regexp.ts';
+import { CONSTRUCTOR_PROPERTY, SchemaInputConfig } from '../service/types.ts';
+import { SchemaRegistryIndex } from '../service/registry-index.ts';
+
+type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(t: T, k: K, idx?: TypedPropertyDescriptor<Any> | number) => void);
+
+function input<V>(...obj: Partial<SchemaInputConfig>[]): PropType<V> {
+  return (instanceOrCls: ClassInstance | Class, property: string | symbol, idx?: number | TypedPropertyDescriptor<Any>): void => {
+    const adapter = SchemaRegistryIndex.getForRegister(getClass(instanceOrCls));
+    const propertyKey = property ?? CONSTRUCTOR_PROPERTY;
+    if (typeof idx === 'number') {
+      adapter.registerParameter(propertyKey, idx, ...obj);
+    } else {
+      adapter.registerField(propertyKey, ...obj);
+    }
+  };
+}
+
+/**
+ * Registering an input
+ * @param type The type for the input
+ * @param config The input configuration
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Input(type: Pick<SchemaInputConfig, 'type' | 'array'>, ...config: Partial<SchemaInputConfig>[]): PropType<unknown> {
+  return input(type, ...config);
+}
+
+/**
+ * Alias for the input
+ * @param aliases List of all aliases for a field
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Alias(...aliases: string[]): PropType<unknown> { return input({ aliases }); }
+
+/**
+ * Mark an input as required
+ * @param active This determines if this field is required or not.
+ * @param message The error message when a the constraint fails.
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Required(active = true, message?: string): PropType<unknown> { return input({ required: { active, message } }); }
+
+/**
+ * Define an input as a set of enumerated values
+ * @param values The list of values allowed for the enumeration
+ * @param message The error message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Enum(values: string[], message?: string): PropType<string | number> {
+  message = message || `{path} is only allowed to be "${values.join('" or "')}"`;
+  return input({ enum: { values, message } });
+}
+
+/**
+ * Mark the input as indicating it's storing textual data
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Text(): PropType<string | string[]> { 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'] }); }
+
+/**
+ * Require the input to match a specific RegExp
+ * @param re The regular expression to match against
+ * @param message The message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Match(re: RegExp, message?: string): PropType<string | string[]> { return input({ match: { re, message } }); }
+
+/**
+ * The minimum length for the string or array
+ * @param n The minimum length
+ * @param message The message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function MinLength(n: number, message?: string): PropType<string | unknown[]> {
+  return input({ minlength: { n, message }, ...(n === 0 ? { required: { active: false } } : {}) });
+}
+
+/**
+ * The maximum length for the string or array
+ * @param n The maximum length
+ * @param message The message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function MaxLength(n: number, message?: string): PropType<string | unknown[]> { return input({ maxlength: { n, message } }); }
+
+/**
+ * The minimum value
+ * @param n The minimum value
+ * @param message The message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Min<T extends number | Date>(n: T, message?: string): PropType<Date | number> {
+  return input({ min: { n, message } });
+}
+
+/**
+ * The maximum value
+ * @param n The maximum value
+ * @param message The message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Max<T extends number | Date>(n: T, message?: string): PropType<Date | number> {
+  return input({ max: { n, message } });
+}
+
+/**
+ * Mark an input as an email
+ * @param message The message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Email(message?: string): PropType<string | string[]> { return Match(CommonRegExp.email, message); }
+
+/**
+ * Mark an input as an telephone number
+ * @param message The message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Telephone(message?: string): PropType<string | string[]> { return Match(CommonRegExp.telephone, message); }
+
+/**
+ * Mark an input as a url
+ * @param message The message to show when the constraint fails
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function Url(message?: string): PropType<string | string[]> { return Match(CommonRegExp.url, message); }
+
+/**
+ * Determine the numeric precision of the value
+ * @param digits The number of digits a number should have
+ * @param decimals The number of decimal digits to support
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+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<number> { return Precision(0); }
+
+/**
+ * Mark a number as a float
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+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<number> { 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); }
+
+/**
+ * Specifier for the input
+ * @param specifiers The specifiers for an input
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+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(): ((t: ClassInstance, k: string) => void) {
+  return (instance: ClassInstance, property: string): void => {
+    SchemaRegistryIndex.getForRegister(getClass(instance)).register({
+      discriminatedBase: true,
+      discriminatedField: property
+    });
+  };
+}

package/src/decorator/method.ts

@@ -0,0 +1,28 @@
+import { Any, castTo, ClassInstance, getClass } from '@travetto/runtime';
+
+import { SchemaMethodConfig } from '../service/types';
+import { SchemaRegistryIndex } from '../service/registry-index';
+import { MethodValidatorFn } from '../validate/types';
+
+/**
+ * Registering a method
+ * @param config The method configuration
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
+ */
+export function Method(...config: Partial<SchemaMethodConfig>[]) {
+  return (instanceOrCls: ClassInstance, property: string | symbol): void => {
+    SchemaRegistryIndex.getForRegister(getClass(instanceOrCls)).registerMethod(property, ...config);
+  };
+}
+
+/**
+ * Add a custom validator for a given method
+ *
+ * @param fn The validator function
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
+ */
+export function MethodValidator<T extends (...args: Any[]) => Any>(fn: MethodValidatorFn<Parameters<T>>): MethodDecorator {
+  return Method({ validators: [castTo(fn)] });
+}

package/src/decorator/schema.ts

@@ -1,22 +1,27 @@
-import { Any, castTo, Class, ClassInstance, DeepPartial } from '@travetto/runtime';
+import { castTo, Class, DeepPartial } from '@travetto/runtime';
 
 import { BindUtil } from '../bind-util.ts';
-import { SchemaRegistry } from '../service/registry.ts';
-import { ClassConfig, ViewFieldsConfig } from '../service/types.ts';
-import { MethodValidatorFn, ValidatorFn } from '../validate/types.ts';
+import { SchemaClassConfig, ViewFieldsConfig } from '../service/types.ts';
+import { ValidatorFn } from '../validate/types.ts';
+import { SchemaRegistryIndex } from '../service/registry-index.ts';
+
+/**
+ * Provides all the valid string type fields from a given type T
+ */
+type ValidStringField<T> = { [K in Extract<keyof T, string>]: T[K] extends string ? K : never }[Extract<keyof T, string>];
 
 /**
  * Register a class as a Schema
  *
  * @augments `@travetto/schema:Schema`
+ * @kind decorator
  */
-export function Schema(cfg?: Partial<Pick<ClassConfig, 'subTypeName' | 'subTypeField' | 'baseType'>>) { // Auto is used during compilation
-  return <T, U extends Class<T>>(target: U): U => {
-    target.from ??= function <V>(this: Class<V>, data: DeepPartial<V>, view?: string): V {
+export function Schema(cfg?: Partial<Pick<SchemaClassConfig, 'validators' | 'methods'>>) {
+  return <T, U extends Class<T>>(cls: U): void => {
+    cls.from ??= function <V>(this: Class<V>, data: DeepPartial<V>, view?: string): V {
       return BindUtil.bindSchema(this, data, { view });
     };
-    SchemaRegistry.register(target, cfg);
-    return target;
+    SchemaRegistryIndex.getForRegister(cls).registerClass(cfg);
   };
 }
 
@@ -24,41 +29,43 @@ export function Schema(cfg?: Partial<Pick<ClassConfig, 'subTypeName' | 'subTypeF
  * Add a custom validator, can be at the class level
  *
  * @param fn The validator function
+ * @kind decorator
  */
 export const Validator = <T>(fn: ValidatorFn<T, string>) =>
-  (target: Class<T>, _k?: string): void => {
-    SchemaRegistry.getOrCreatePending(target).validators!.push(castTo(fn));
+  (cls: Class<T>): void => {
+    SchemaRegistryIndex.getForRegister(cls).register({ validators: [castTo(fn)] });
   };
 
 /**
- * Add a custom validator for a given method
- *
- * @param fn The validator function
+ * Register a specific view for a class
+ * @param name The name of the view
+ * @param fields The specific fields to add as part of a view
+ * @kind decorator
  */
-export function MethodValidator<T extends (...args: Any[]) => Any>(fn: MethodValidatorFn<Parameters<T>>) {
-  return (target: ClassInstance, k: string, _prop: TypedPropertyDescriptor<T>): void => {
-    SchemaRegistry.registerPendingMethod(target.constructor, k).validators!.push(castTo(fn));
+export function View<T>(name: string, fields: ViewFieldsConfig<Partial<T>>) {
+  return (cls: Class<Partial<T>>): void => {
+    SchemaRegistryIndex.getForRegister(cls).register({ views: { [name]: fields } });
   };
 }
 
 /**
- * Register a specific view for a class
- * @param name The name of the view
- * @param fields The specific fields to add as part of a view
+ * Register a class as a discriminated class, by a specific type
+ * @param type The type to use for discrimination
+ * @kind decorator
  */
-export function View<T>(name: string, fields: ViewFieldsConfig<Partial<T>>) {
-  return (target: Class<Partial<T>>): void => {
-    SchemaRegistry.registerPendingView(target, name, fields);
+export function SubType<T>(type?: string) {
+  return (cls: Class<Partial<T>>): void => {
+    SchemaRegistryIndex.getForRegister(cls).register({ discriminatedType: type });
   };
 }
 
 /**
- * Register a class as a subtype, with a specific discriminator
- * @param name
- * @returns
+ * Register a class as a discriminated class
+ * @param field The field to use for discrimination
+ * @kind decorator
  */
-export function SubType<T>(name: string) {
-  return (target: Class<Partial<T>>): void => {
-    SchemaRegistry.register(target, { subTypeName: name });
+export function Discriminated<T>(field: ValidStringField<T>) {
+  return (cls: Class<Partial<T>>): void => {
+    SchemaRegistryIndex.getForRegister(cls).register({ discriminatedField: field, discriminatedBase: true });
   };
 }

package/src/name.ts

@@ -1,4 +1,4 @@
-import { ClassConfig } from './service/types.ts';
+import { SchemaClassConfig } from './service/types.ts';
 
 const ID_RE = /(\d{1,100})Δ$/;
 
@@ -14,7 +14,7 @@ export class SchemaNameResolver {
     this.#digits = digits;
   }
 
-  getName(schema: ClassConfig): string {
+  getName(schema: SchemaClassConfig): string {
     const cls = schema.class;
     const id = cls.Ⲑid;
     if (ID_RE.test(cls.name)) {

package/src/service/changes.ts

@@ -3,27 +3,25 @@ import { EventEmitter } from 'node:events';
 import { Class } from '@travetto/runtime';
 import { ChangeEvent } from '@travetto/registry';
 
-import { FieldConfig, ClassConfig } from './types.ts';
-
-const id = (c: Class | string): string => typeof c === 'string' ? c : c.Ⲑid;
+import { SchemaFieldConfig, SchemaClassConfig } from './types.ts';
 
 interface FieldMapping {
-  path: FieldConfig[];
-  config: ClassConfig;
+  path: SchemaFieldConfig[];
+  config: SchemaClassConfig;
 }
 
 export interface FieldChangeEvent {
   cls: Class;
-  changes: ChangeEvent<FieldConfig>[];
+  changes: ChangeEvent<SchemaFieldConfig>[];
 }
 
 interface SubSchemaChange {
-  path: FieldConfig[];
-  fields: ChangeEvent<FieldConfig>[];
+  path: SchemaFieldConfig[];
+  fields: ChangeEvent<SchemaFieldConfig>[];
 }
 
 export interface SchemaChange {
-  config: ClassConfig;
+  config: SchemaClassConfig;
   subs: SubSchemaChange[];
 }
 
@@ -33,7 +31,7 @@ export interface SchemaChangeEvent {
 }
 
 /**
- * Schema change listener.  Handles all changes that occur via the SchemaRegistry
+ * Schema change listener.  Handles all changes that occur via the SchemaRegistryIndex
  */
 class $SchemaChangeListener {
 
@@ -60,7 +58,7 @@ class $SchemaChangeListener {
    * Clear dependency mappings for a given class
    */
   clearSchemaDependency(cls: Class): void {
-    this.#mapping.delete(id(cls));
+    this.#mapping.delete(cls.Ⲑid);
   }
 
   /**
@@ -70,12 +68,12 @@ class $SchemaChangeListener {
    * @param path The path within the object hierarchy to arrive at the class
    * @param config The configuration or the class
    */
-  trackSchemaDependency(src: Class, parent: Class, path: FieldConfig[], config: ClassConfig): void {
-    const idValue = id(src);
+  trackSchemaDependency(src: Class, parent: Class, path: SchemaFieldConfig[], config: SchemaClassConfig): void {
+    const idValue = src.Ⲑid;
     if (!this.#mapping.has(idValue)) {
       this.#mapping.set(idValue, new Map());
     }
-    this.#mapping.get(idValue)!.set(id(parent), { path, config });
+    this.#mapping.get(idValue)!.set(parent.Ⲑid, { path, config });
   }
 
   /**
@@ -85,7 +83,7 @@ class $SchemaChangeListener {
    */
   emitSchemaChanges({ cls, changes }: FieldChangeEvent): void {
     const updates = new Map<string, SchemaChange>();
-    const clsId = id(cls);
+    const clsId = cls.Ⲑid;
 
     if (this.#mapping.has(clsId)) {
       const deps = this.#mapping.get(clsId)!;
@@ -108,25 +106,24 @@ class $SchemaChangeListener {
    * @param prev The previous class config
    * @param curr The current class config
    */
-  emitFieldChanges({ prev, curr }: ChangeEvent<ClassConfig>): void {
-
-    const prevView = prev?.totalView || { fields: [], schema: {} };
-    const currView = curr!.totalView;
+  emitFieldChanges(ev: ChangeEvent<SchemaClassConfig>): void {
+    const prev = 'prev' in ev ? ev.prev : undefined;
+    const curr = 'curr' in ev ? ev.curr : undefined;
 
-    const prevFields = new Set(prevView.fields);
-    const currFields = new Set(currView.fields);
+    const prevFields = new Set(Object.keys(prev?.fields ?? {}));
+    const currFields = new Set(Object.keys(curr?.fields ?? {}));
 
-    const changes: ChangeEvent<FieldConfig>[] = [];
+    const changes: ChangeEvent<SchemaFieldConfig>[] = [];
 
     for (const c of currFields) {
-      if (!prevFields.has(c)) {
-        changes.push({ curr: currView.schema[c], type: 'added' });
+      if (!prevFields.has(c) && curr) {
+        changes.push({ curr: curr.fields[c], type: 'added' });
       }
     }
 
     for (const c of prevFields) {
-      if (!currFields.has(c)) {
-        changes.push({ prev: prevView.schema[c], type: 'removing' });
+      if (!currFields.has(c) && prev) {
+        changes.push({ prev: prev.fields[c], type: 'removing' });
       }
     }
 
@@ -134,14 +131,14 @@ class $SchemaChangeListener {
     const compareTypes = (a: Class, b: Class): boolean => a.Ⲑid ? a.Ⲑid === b.Ⲑid : a === b;
 
     for (const c of currFields) {
-      if (prevFields.has(c)) {
-        const prevSchema = prevView.schema[c];
-        const currSchema = currView.schema[c];
+      if (prevFields.has(c) && prev && curr) {
+        const prevSchema = prev.fields[c];
+        const currSchema = curr.fields[c];
         if (
           JSON.stringify(prevSchema) !== JSON.stringify(currSchema) ||
           !compareTypes(prevSchema.type, currSchema.type)
         ) {
-          changes.push({ prev: prevView.schema[c], curr: currView.schema[c], type: 'changed' });
+          changes.push({ prev: prev.fields[c], curr: curr.fields[c], type: 'changed' });
         }
       }
     }