@travetto/schema 7.0.0-rc.1 → 7.0.0-rc.3

package/src/service/registry-adapter.ts

@@ -7,14 +7,16 @@ import {
   CONSTRUCTOR_PROPERTY
 } from './types';
 
+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, l, r) => `${l}_${r.toLowerCase()}`)
-  .replace(/([a-z]|\b)([A-Z])/g, (all, l, r) => l ? `${l}_${r.toLowerCase()}` : r.toLowerCase())
+  .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 md = base.metadata ??= {};
-  const out = md[key] ??= {};
+  const metadata = base.metadata ??= {};
+  const out = metadata[key] ??= {};
   for (const d of data) {
     safeAssign(out, d);
   }
@@ -69,6 +71,7 @@ function getConstructorConfig<T extends SchemaClassConfig>(base: Partial<T>, par
   const parentCons = parent?.methods?.[CONSTRUCTOR_PROPERTY];
   const baseCons = base.methods?.[CONSTRUCTOR_PROPERTY];
   return {
+    class: base.class!,
     parameters: [],
     validators: [],
     ...parentCons,
@@ -92,8 +95,8 @@ function combineClassWithParent<T extends SchemaClassConfig>(base: T, parent: T)
     case 'Required':
     case 'Partial': {
       base.fields = Object.fromEntries(
-        Object.entries(parent.fields).map(([k, v]) => [k, {
-          ...v,
+        Object.entries(parent.fields).map(([key, value]) => [key, {
+          ...value,
           required: {
             active: base.mappedOperation === 'Required'
           }
@@ -105,8 +108,8 @@ 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(([k]) =>
-          base.mappedOperation === 'Pick' ? keys.has(k) : !keys.has(k)
+        Object.entries(parent.fields).filter(([key]) =>
+          base.mappedOperation === 'Pick' ? keys.has(key) : !keys.has(key)
         )
       );
       break;
@@ -145,7 +148,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
   }
 
   register(...data: Partial<SchemaClassConfig>[]): SchemaClassConfig {
-    const cfg = this.#config ??= {
+    const config = this.#config ??= {
       methods: {},
       class: this.#cls,
       views: {},
@@ -153,38 +156,38 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
       interfaces: [],
       fields: {},
     };
-    return combineClasses(cfg, data);
+    return combineClasses(config, data);
   }
 
   registerMetadata<T>(key: symbol, ...data: Partial<T>[]): T {
-    const cfg = this.register({});
-    return assignMetadata(key, cfg, data);
+    const config = this.register({});
+    return assignMetadata(key, config, data);
   }
 
   getMetadata<T>(key: symbol): T | undefined {
-    const md = this.#config?.metadata;
-    return castTo<T>(md?.[key]);
+    const metadata = this.#config?.metadata;
+    return castTo<T>(metadata?.[key]);
   }
 
-  registerField(field: string | symbol, ...data: Partial<SchemaFieldConfig>[]): SchemaFieldConfig {
-    const config = this.register({});
-    const cfg = config.fields[field] ??= { name: field, owner: this.#cls, type: null! };
-    const combined = combineInputs(cfg, data);
+  registerField(field: string, ...data: Partial<SchemaFieldConfig>[]): SchemaFieldConfig {
+    const classConfig = this.register({});
+    const config = classConfig.fields[field] ??= { name: field, class: this.#cls, type: null! };
+    const combined = combineInputs(config, data);
     return combined;
   }
 
-  registerFieldMetadata<T>(field: string | symbol, key: symbol, ...data: Partial<T>[]): T {
-    const cfg = this.registerField(field);
-    return assignMetadata(key, cfg, data);
+  registerFieldMetadata<T>(field: string, key: symbol, ...data: Partial<T>[]): T {
+    const config = this.registerField(field);
+    return assignMetadata(key, config, data);
   }
 
-  getFieldMetadata<T>(field: string | symbol, key: symbol): T | undefined {
-    const md = this.#config?.fields[field]?.metadata;
-    return castTo<T>(md?.[key]);
+  getFieldMetadata<T>(field: string, key: symbol): T | undefined {
+    const metadata = this.#config?.fields[field]?.metadata;
+    return castTo<T>(metadata?.[key]);
   }
 
-  registerClass({ methods, ...cfg }: Partial<SchemaClassConfig> = {}): SchemaClassConfig {
-    this.register({ ...cfg });
+  registerClass({ methods, ...config }: Partial<SchemaClassConfig> = {}): SchemaClassConfig {
+    this.register({ ...config });
     if (methods?.[CONSTRUCTOR_PROPERTY]) {
       const { parameters, ...rest } = methods[CONSTRUCTOR_PROPERTY];
       this.registerMethod(CONSTRUCTOR_PROPERTY, rest);
@@ -195,36 +198,36 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     return this.#config;
   }
 
-  registerMethod(method: string | symbol, ...data: Partial<SchemaMethodConfig>[]): SchemaMethodConfig {
-    const config = this.register();
-    const cfg = config.methods[method] ??= { parameters: [], validators: [] };
-    return combineMethods(cfg, data);
+  registerMethod(method: string, ...data: Partial<SchemaMethodConfig>[]): SchemaMethodConfig {
+    const classConfig = this.register();
+    const config = classConfig.methods[method] ??= { class: this.#cls, parameters: [], validators: [] };
+    return combineMethods(config, data);
   }
 
-  registerMethodMetadata<T>(method: string | symbol, key: symbol, ...data: Partial<T>[]): T {
-    const cfg = this.registerMethod(method);
-    return assignMetadata(key, cfg, data);
+  registerMethodMetadata<T>(method: string, key: symbol, ...data: Partial<T>[]): T {
+    const config = this.registerMethod(method);
+    return assignMetadata(key, config, data);
   }
 
-  getMethodMetadata<T>(method: string | symbol, key: symbol): T | undefined {
-    const md = this.#config?.methods[method]?.metadata;
-    return castTo<T>(md?.[key]);
+  getMethodMetadata<T>(method: string, key: symbol): T | undefined {
+    const metadata = this.#config?.methods[method]?.metadata;
+    return castTo<T>(metadata?.[key]);
   }
 
-  registerParameter(method: string | symbol, idx: number, ...data: Partial<SchemaParameterConfig>[]): SchemaParameterConfig {
+  registerParameter(method: string, idx: number, ...data: Partial<SchemaParameterConfig>[]): SchemaParameterConfig {
     const params = this.registerMethod(method, {}).parameters;
-    const cfg = params[idx] ??= { method, index: idx, owner: this.#cls, array: false, type: null! };
-    return combineInputs(cfg, data);
+    const config = params[idx] ??= { method, index: idx, class: this.#cls, array: false, type: null! };
+    return combineInputs(config, data);
   }
 
-  registerParameterMetadata<T>(method: string | symbol, idx: number, key: symbol, ...data: Partial<T>[]): T {
-    const cfg = this.registerParameter(method, idx);
-    return assignMetadata(key, cfg, data);
+  registerParameterMetadata<T>(method: string, idx: number, key: symbol, ...data: Partial<T>[]): T {
+    const config = this.registerParameter(method, idx);
+    return assignMetadata(key, config, data);
   }
 
-  getParameterMetadata<T>(method: string | symbol, idx: number, key: symbol): T | undefined {
-    const md = this.#config?.methods[method]?.parameters[idx]?.metadata;
-    return castTo<T>(md?.[key]);
+  getParameterMetadata<T>(method: string, idx: number, key: symbol): T | undefined {
+    const metadata = this.#config?.methods[method]?.parameters[idx]?.metadata;
+    return castTo<T>(metadata?.[key]);
   }
 
   finalize(parent?: SchemaClassConfig): void {
@@ -256,13 +259,13 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
       const fields = config.views[view];
       const withoutSet = 'without' in fields ? new Set<string>(fields.without) : undefined;
       const fieldList = withoutSet ?
-        Object.keys(config.fields).filter(x => !withoutSet.has(x)) :
+        Object.keys(config.fields).filter(field => !withoutSet.has(field)) :
         ('with' in fields ? fields.with : []);
 
       this.#views.set(view,
-        fieldList.reduce<SchemaFieldMap>((acc, v) => {
-          acc[v] = config.fields[v];
-          return acc;
+        fieldList.reduce<SchemaFieldMap>((map, value) => {
+          map[value] = config.fields[value];
+          return map;
         }, {})
       );
     }
@@ -278,19 +281,19 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     return this.#config;
   }
 
-  getField(field: string | symbol): SchemaFieldConfig {
+  getField(field: string): SchemaFieldConfig {
     return this.#config.fields[field];
   }
 
-  getMethod(method: string | symbol): SchemaMethodConfig {
-    const res = this.#config.methods[method];
-    if (!res) {
+  getMethod(method: string): SchemaMethodConfig {
+    const methodConfig = this.#config.methods[method];
+    if (!methodConfig) {
       throw new AppError(`Unknown method ${String(method)} on class ${this.#cls.Ⲑid}`);
     }
-    return res;
+    return methodConfig;
   }
 
-  getMethodReturnType(method: string | symbol): Class {
+  getMethodReturnType(method: string): Class {
     return this.getMethod(method).returnType!.type;
   }
 
@@ -305,8 +308,8 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
   }
 
   /**
-  * Provides the prototype-derived descriptor for a property
-  */
+   * Provides the prototype-derived descriptor for a property
+   */
   getAccessorDescriptor(field: string): PropertyDescriptor {
     if (!this.#accessorDescriptors.has(field)) {
       let proto = this.#cls.prototype;
@@ -321,16 +324,16 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
   /**
    * Ensure type is set properly
    */
-  ensureInstanceTypeField<T>(o: T): T {
+  ensureInstanceTypeField<T>(value: T): T {
     const config = this.getDiscriminatedConfig();
     if (config) {
       const typeField = castKey<T>(config.discriminatedField);
-      o[typeField] ??= castTo(config.discriminatedType); // Assign if missing
+      value[typeField] ??= castTo(config.discriminatedType); // Assign if missing
     }
-    return o;
+    return value;
   }
 
-  getDiscriminatedConfig(): Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>> | undefined {
+  getDiscriminatedConfig(): SchemaDiscriminatedInfo | undefined {
     const { discriminatedField, discriminatedType, discriminatedBase } = this.#config;
     if (discriminatedType && discriminatedField) {
       return { discriminatedType, discriminatedField, discriminatedBase: !!discriminatedBase };

package/src/service/registry-index.ts

@@ -1,9 +1,8 @@
-import { ChangeEvent, RegistrationMethods, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { AppError, castKey, castTo, Class, classConstruct, getParentClass, Util } from '@travetto/runtime';
+import { RegistrationMethods, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { AppError, castKey, castTo, Class, classConstruct, getParentClass } from '@travetto/runtime';
 
 import { SchemaFieldConfig, SchemaClassConfig } from './types.ts';
-import { SchemaRegistryAdapter } from './registry-adapter.ts';
-import { SchemaChangeListener } from './changes.ts';
+import { SchemaDiscriminatedInfo, SchemaRegistryAdapter } from './registry-adapter.ts';
 
 /**
  * Schema registry index for managing schema configurations across classes
@@ -20,7 +19,7 @@ export class SchemaRegistryIndex implements RegistryIndex {
     return this.#instance.store.get(cls).get();
   }
 
-  static getDiscriminatedConfig<T>(cls: Class<T>): Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>> | undefined {
+  static getDiscriminatedConfig<T>(cls: Class<T>): SchemaDiscriminatedInfo | undefined {
     return this.#instance.store.get(cls).getDiscriminatedConfig();
   }
 
@@ -28,16 +27,12 @@ export class SchemaRegistryIndex implements RegistryIndex {
     return this.#instance.store.has(cls);
   }
 
-  static getClassById(classId: string): Class {
-    return this.#instance.store.getClassById(classId);
-  }
-
   static getDiscriminatedTypes(cls: Class): string[] | undefined {
     return this.#instance.getDiscriminatedTypes(cls);
   }
 
-  static resolveInstanceType<T>(cls: Class<T>, o: T): Class {
-    return this.#instance.resolveInstanceType(cls, o);
+  static resolveInstanceType<T>(cls: Class<T>, item: T): Class {
+    return this.#instance.resolveInstanceType(cls, item);
   }
 
   static visitFields<T>(cls: Class<T>, onField: (field: SchemaFieldConfig, path: SchemaFieldConfig[]) => void): void {
@@ -68,6 +63,8 @@ export class SchemaRegistryIndex implements RegistryIndex {
   #baseSchema = new Map<Class, Class>();
   #byDiscriminatedTypes = new Map<Class, Map<string, Class>>();
 
+  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+
   /**
    * Register discriminated types for a class
    */
@@ -84,44 +81,11 @@ export class SchemaRegistryIndex implements RegistryIndex {
     this.#byDiscriminatedTypes.get(base)!.set(config.discriminatedType, cls);
   }
 
-  #onChanged(event: ChangeEvent<Class> & { type: 'changed' }): void {
-    Util.queueMacroTask().then(() => {
-      SchemaChangeListener.emitFieldChanges({
-        type: 'changed',
-        curr: this.getClassConfig(event.curr),
-        prev: this.getClassConfig(event.prev)
-      });
-    });
-  }
-
-  #onRemoving(event: ChangeEvent<Class> & { type: 'removing' }): void {
-    SchemaChangeListener.clearSchemaDependency(event.prev);
-  }
-
-  #onAdded(event: ChangeEvent<Class> & { type: 'added' }): void {
-    Util.queueMacroTask().then(() => {
-      SchemaChangeListener.emitFieldChanges({
-        type: 'added',
-        curr: this.getClassConfig(event.curr)
-      });
-    });
-  }
-
-  process(events: ChangeEvent<Class>[]): void {
-    for (const event of events) {
-      if (event.type === 'changed') {
-        this.#onChanged(event);
-      } else if (event.type === 'removing') {
-        this.#onRemoving(event);
-      } else if (event.type === 'added') {
-        this.#onAdded(event);
-      }
-    }
-
+  beforeChangeSetComplete(): void {
     // Rebuild indices after every "process" batch
     this.#byDiscriminatedTypes.clear();
-    for (const el of this.store.getClasses()) {
-      this.#registerDiscriminatedTypes(el);
+    for (const cls of this.store.getClasses()) {
+      this.#registerDiscriminatedTypes(cls);
     }
   }
 
@@ -134,15 +98,15 @@ export class SchemaRegistryIndex implements RegistryIndex {
    */
   getBaseClass(cls: Class): Class {
     if (!this.#baseSchema.has(cls)) {
-      let conf = this.getClassConfig(cls);
+      let config = this.getClassConfig(cls);
       let parent: Class | undefined = cls;
-      while (parent && conf.discriminatedType && !conf.discriminatedBase) {
+      while (parent && config.discriminatedType && !config.discriminatedBase) {
         parent = getParentClass(parent);
         if (parent) {
-          conf = this.store.getOptional(parent)?.get() ?? conf;
+          config = this.store.getOptional(parent)?.get() ?? config;
         }
       }
-      this.#baseSchema.set(cls, conf.class);
+      this.#baseSchema.set(cls, config.class);
     }
     return this.#baseSchema.get(cls)!;
   }
@@ -150,16 +114,16 @@ export class SchemaRegistryIndex implements RegistryIndex {
   /**
    * Find the resolved type for a given instance
    * @param cls Class for instance
-   * @param o Actual instance
+   * @param item Actual instance
    */
-  resolveInstanceType<T>(cls: Class<T>, o: T): Class {
+  resolveInstanceType<T>(cls: Class<T>, item: T): Class {
     const { discriminatedField, discriminatedType, class: targetClass } = this.store.get(cls).get();
     if (!discriminatedField) {
       return targetClass;
     } else {
       const base = this.getBaseClass(targetClass);
       const map = this.#byDiscriminatedTypes.get(base);
-      const type = castTo<string>(o[castKey<T>(discriminatedField)]) ?? discriminatedType;
+      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`);
       }
@@ -174,25 +138,6 @@ export class SchemaRegistryIndex implements RegistryIndex {
     }
   }
 
-  /**
-   * Track changes to schemas, and track the dependent changes
-   * @param cls The root class of the hierarchy
-   * @param curr The new class
-   * @param path The path within the object hierarchy
-   */
-  trackSchemaDependencies(cls: Class, curr: Class = cls, path: SchemaFieldConfig[] = []): void {
-    const config = this.getClassConfig(curr);
-
-    SchemaChangeListener.trackSchemaDependency(curr, cls, path, this.getClassConfig(cls));
-
-    // Read children
-    for (const field of Object.values(config.fields)) {
-      if (SchemaRegistryIndex.has(field.type) && field.type !== cls) {
-        this.trackSchemaDependencies(cls, field.type, [...path, field]);
-      }
-    }
-  }
-
   /**
    * Visit fields recursively
    */

package/src/service/types.ts

@@ -3,7 +3,7 @@ import { Any, Class, Primitive } from '@travetto/runtime';
 import { MethodValidatorFn, ValidatorFn } from '../validate/types.ts';
 
 type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
-export type TemplateLiteral = { op: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
+export type TemplateLiteral = { operation: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
 
 export const CONSTRUCTOR_PROPERTY = 'CONSTRUCTOR';
 
@@ -36,6 +36,10 @@ export type SchemaBasicType = {
  * Basic schema configuration
  */
 export interface SchemaCoreConfig {
+  /**
+   * Schema class
+   */
+  class: Class;
   /**
    * Description
    */
@@ -83,17 +87,13 @@ export interface SchemaFieldMap {
   /**
    * List of all fields
    */
-  [key: string | symbol]: SchemaFieldConfig;
+  [key: string]: SchemaFieldConfig;
 }
 
 /**
  * Class configuration
  */
 export interface SchemaClassConfig extends SchemaCoreConfig {
-  /**
-   * Target class
-   */
-  class: Class;
   /**
    * List of all views
    */
@@ -121,7 +121,7 @@ export interface SchemaClassConfig extends SchemaCoreConfig {
   /**
    * Method configs
    */
-  methods: Record<string | symbol, SchemaMethodConfig>;
+  methods: Record<string, SchemaMethodConfig>;
   /**
    * Interfaces that the class implements
    */
@@ -144,10 +144,6 @@ export interface SchemaInputConfig extends SchemaCoreConfig, SchemaBasicType {
    * Key name for validation when dealing with complex types
    */
   view?: string;
-  /**
-   * Owner class
-   */
-  owner: Class;
   /**
    * List of aliases
    */
@@ -167,23 +163,23 @@ export interface SchemaInputConfig extends SchemaCoreConfig, SchemaBasicType {
   /**
    * Does the field expect a match
    */
-  match?: { re: RegExp, message?: string, template?: TemplateLiteral };
+  match?: { regex: RegExp, message?: string, template?: TemplateLiteral };
   /**
    * Minimum value configuration
    */
-  min?: { n: number | Date, message?: string };
+  min?: { limit: number | Date, message?: string };
   /**
    * Maximum value configuration
    */
-  max?: { n: number | Date, message?: string };
+  max?: { limit: number | Date, message?: string };
   /**
    * Minimum length configuration
    */
-  minlength?: { n: number, message?: string };
+  minlength?: { limit: number, message?: string };
   /**
    * Maximum length configuration
    */
-  maxlength?: { n: number, message?: string };
+  maxlength?: { limit: number, message?: string };
   /**
    * Enumerated values
    */
@@ -209,7 +205,7 @@ export interface SchemaParameterConfig extends SchemaInputConfig {
   /**
    * Method the parameter belongs to
    */
-  method: string | symbol;
+  method: string;
   /**
    * Source text for the parameter
    */
@@ -223,7 +219,7 @@ export interface SchemaFieldConfig extends SchemaInputConfig {
   /**
    * Field name
    */
-  name: string | symbol;
+  name: string;
   /**
    * Is the field readonly, or write only?, defaults to no restrictions
    */

package/src/types.ts

@@ -3,6 +3,6 @@ export class UnknownType { }
 /**
  * Geometric Point as [number,number] with validation and binding support
  *
- * @concrete ./internal/types.ts#PointImpl
+ * @concrete ./internal/types.ts#PointContract
  */
 export type Point = [number, number];

package/src/validate/error.ts

@@ -22,6 +22,6 @@ export class TypeMismatchError extends AppError {
   }
 }
 
-export function isValidationError(err: unknown): err is ValidationError {
-  return !!err && err instanceof Error && 'path' in err;
+export function isValidationError(error: unknown): error is ValidationError {
+  return !!error && error instanceof Error && 'path' in error;
 }

package/src/validate/messages.ts

@@ -5,14 +5,14 @@ export const Messages = new Map<string, string>(Object.entries({
   default: '{path} is not valid',
   type: '{path} is not a valid {type}',
   required: '{path} is required',
-  minlength: '{path} is not long enough ({n})',
-  maxlength: '{path} is too long ({n})',
-  match: '{path} should match {re}',
-  min: '{path} is less than ({n})',
-  max: '{path} is greater than ({n})',
-  telephone: '{path} is not a valid phone number',
-  url: '{path} is not a valid url',
-  simpleName: '{path} is not a proper name',
-  postalCode: '{path} is not a valid postal code',
-  email: '{path} is not a valid email address'
+  minlength: '{path} is not long enough ({limit})',
+  maxlength: '{path} is too long ({limit})',
+  match: '{path} should match {regex}',
+  min: '{path} is less than ({limit})',
+  max: '{path} is greater than ({limit})',
+  '[[:telephone:]]': '{path} is not a valid phone number',
+  '[[:url:]]': '{path} is not a valid url',
+  '[[:simpleName:]]': '{path} is not a proper name',
+  '[[:postalCode:]]': '{path} is not a valid postal code',
+  '[[:email:]]': '{path} is not a valid email address'
 }));

package/src/validate/regex.ts

@@ -0,0 +1,22 @@
+import { TypedObject } from '@travetto/runtime';
+
+/**
+ * List of common regular expressions for fields
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const [CommonRegex, CommonRegexToName] = (() => {
+  const regexToName = new Map<RegExp, string>();
+  const regexes = {
+    email: /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
+    telephone: /^(\+?\d{1,3}(\s*-?\s*|\s+))?((\(\d{3}\))|\d{3})(\s*|-|[.])(\d{3})(\s*|-|[.])(\d{4})(\s+(x|ext[.]?)\s*\d+)?$/,
+    url: /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/,
+    simpleName: /^([a-zA-Z\u0080-\u024F]{0,100}(?:. |-| |')){0,10}[a-zA-Z\u0080-\u024F]+$/,
+    postalCode: /^\d{5}(?:[-\s]\d{4})?$/
+  };
+  // Rebind regexes
+  for (const key of TypedObject.keys(regexes)) {
+    const name = `[[:${key}:]]`;
+    regexToName.set(regexes[key], name);
+  }
+  return [regexes, regexToName];
+})();

package/src/validate/types.ts

@@ -25,11 +25,11 @@ export interface ValidationError {
   /**
    * Regular expression to match
    */
-  re?: string;
+  regex?: string;
   /**
    * Number to compare against
    */
-  n?: number | Date;
+  limit?: number | Date;
   /**
    * The type of the field
    */
@@ -63,11 +63,11 @@ export interface ValidationResult {
   /**
    * Potential regular expression for the result
    */
-  re?: RegExp;
+  regex?: RegExp;
   /**
    * Number to compare against
    */
-  n?: number | Date;
+  limit?: number | Date;
 }
 
 type OrPromise<T> = T | Promise<T>;