@travetto/schema 6.0.1 → 7.0.0-rc.0

package/README.md

@@ -18,7 +18,7 @@ This module's purpose is to allow for proper declaration and validation of data
 This module provides a mechanism for registering classes and field level information as well the ability to apply that information at runtime.
 
 ## Registration
-The registry's schema information is defined by [Typescript](https://typescriptlang.org) AST and only applies to classes registered with the [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L13) decoration.
+The registry's schema information is defined by [Typescript](https://typescriptlang.org) AST and only applies to classes registered with the [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19) decoration.
 
 ### Classes
 The module utilizes AST transformations to collect schema information, and facilitate the registration process without user intervention. The class can also be described using providing a:
@@ -26,7 +26,7 @@ The module utilizes AST transformations to collect schema information, and facil
    *  `description` - detailed description of the schema
    *  `examples` - A set of examples as [JSON](https://www.json.org) or [YAML](https://en.wikipedia.org/wiki/YAML)
 
-The `title` will be picked up from the [JSDoc](http://usejsdoc.org/about-getting-started.html) comments, and additionally all fields can be set using the [@Describe](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/common.ts#L15) decorator.
+The `title` will be picked up from the [JSDoc](http://usejsdoc.org/about-getting-started.html) comments, and additionally all fields can be set using the [@Describe](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/common.ts#L12) decorator.
 
 **Code: Sample User Schema**
 ```typescript
@@ -64,28 +64,28 @@ 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#L25) defines a field that will be serialized.
-   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L63) defines a that field should be required
-   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L70) defines the allowable values that a field can have
-   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L91) defines a regular expression that the field value should match
-   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) enforces min length of a string
-   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L109) enforces max length of a string
-   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) enforces min value for a date or a number
-   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L109) enforces max value for a date or a number
-   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L136) ensures string field matches basic email regex
-   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L143) ensures string field matches basic telephone regex
-   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L150) ensures string field matches basic url regex
-   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L189) exclude from auto schema registration
-   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L164) ensures number passed in is only a whole number
-   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L170) ensures number passed in allows fractional values
-   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L182) provides support for standard currency
-   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L78) 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/field.ts#L83) same as text, but expects longer form content
-   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L50) 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#L45) 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#L56) 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/field.ts#L198) attributes additional specifiers to a field, allowing for more specification beyond just the field's type.
-   *  [@SubTypeField](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L204) allows for promoting a given field as the owner of the sub type discriminator (defaults to `type`).
+   *  [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L21) defines a field that will be serialized.
+   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L47) defines a that field should be required
+   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L56) defines the allowable values that a field can have
+   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L82) defines a regular expression that the field value should match
+   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L91) enforces min length of a string
+   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L102) enforces max length of a string
+   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L91) enforces min value for a date or a number
+   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L102) enforces max value for a date or a number
+   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L132) ensures string field matches basic email regex
+   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L140) ensures string field matches basic telephone regex
+   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L148) 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#L164) ensures number passed in is only a whole number
+   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L171) ensures number passed in allows fractional values
+   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L185) provides support for standard currency
+   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L66) 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#L73) same as text, but expects longer form content
+   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L37) 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#L30) 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#L45) 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#L193) 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#L200) 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. 
 
@@ -93,7 +93,7 @@ Just like the class, all fields can be defined with
    *  `description` - detailed description of the schema
    *  `examples` - A set of examples as [JSON](https://www.json.org) or [YAML](https://en.wikipedia.org/wiki/YAML)
 
-And similarly, the `description` will be picked up from the [JSDoc](http://usejsdoc.org/about-getting-started.html) comments, and additionally all fields can be set using the [@Describe](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/common.ts#L15) decorator.
+And similarly, the `description` will be picked up from the [JSDoc](http://usejsdoc.org/about-getting-started.html) comments, and additionally all fields can be set using the [@Describe](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/common.ts#L12) decorator.
 
 ### Parameters
 Parameters are available in certain scenarios (e.g. [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") endpoints and [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") main methods).  In these scenarios, all of the field decorators are valid, but need to be called slightly differently to pass the typechecker. The simple solution is to use the `Arg` field of the decorator to convince Typescript its the correct type.
@@ -115,7 +115,7 @@ export class ParamUsage {
 At runtime, once a schema is registered, a programmer can utilize this structure to perform specific operations. Specifically binding and validation.
 
 ### Binding
-Binding is a very simple operation, as it takes in a class registered as as [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L13) and a JS object that will be the source of the binding. Given the schema:
+Binding is a very simple operation, as it takes in a class registered as as [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19) and a JS object that will be the source of the binding. Given the schema:
 
 **Code: Sub Schemas via Address**
 ```typescript
@@ -302,6 +302,10 @@ export interface ValidationError {
    * The type of the field
    */
   type?: string;
+  /**
+   * Source of the error
+   */
+  source?: string;
 }
 ```
 

package/__index__.ts

@@ -1,9 +1,10 @@
 import type { } from './src/global.d.ts';
 export * from './src/decorator/field.ts';
+export * from './src/decorator/input.ts';
 export * from './src/decorator/schema.ts';
+export * from './src/decorator/method.ts';
 export * from './src/decorator/common.ts';
 export * from './src/service/changes.ts';
-export * from './src/service/registry.ts';
 export * from './src/service/types.ts';
 export * from './src/validate/messages.ts';
 export * from './src/validate/regexp.ts';
@@ -13,4 +14,5 @@ export * from './src/validate/types.ts';
 export * from './src/bind-util.ts';
 export * from './src/data.ts';
 export * from './src/name.ts';
-export * from './src/types.ts';
+export * from './src/types.ts';
+export * from './src/service/registry-index.ts';

package/package.json

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

package/src/bind-util.ts

@@ -1,13 +1,13 @@
 import { castTo, Class, classConstruct, asFull, TypedObject, castKey } from '@travetto/runtime';
 
 import { DataUtil } from './data.ts';
-import { SchemaRegistry } from './service/registry.ts';
-import { FieldConfig } from './service/types.ts';
+import { SchemaInputConfig, SchemaParameterConfig, SchemaFieldMap } from './service/types.ts';
+import { SchemaRegistryIndex } from './service/registry-index.ts';
 
 type BindConfig = {
   view?: string;
-  filterField?: (field: FieldConfig) => boolean;
-  filterValue?: (value: unknown, field: FieldConfig) => boolean;
+  filterInput?: (input: SchemaInputConfig) => boolean;
+  filterValue?: (value: unknown, input: SchemaInputConfig) => boolean;
 };
 
 function isInstance<T>(o: unknown): o is T {
@@ -24,7 +24,7 @@ export class BindUtil {
    * @param conf The field config to coerce to
    * @param val The provided value
    */
-  static #coerceType<T>(conf: FieldConfig, val: unknown): T | null | undefined {
+  static #coerceType<T>(conf: SchemaInputConfig, val: unknown): T | null | undefined {
     if (conf.type?.bindSchema) {
       val = conf.type.bindSchema(val);
     } else {
@@ -144,19 +144,21 @@ export class BindUtil {
     if (data === null || data === undefined) {
       return data;
     }
-    const cls = SchemaRegistry.resolveInstanceType<T>(cons, asFull<T>(data));
-    if (data instanceof cls) {
+    if (data instanceof cons) {
       return castTo(data);
     } else {
-      const tgt = classConstruct<T & { type?: string }>(cls);
-      SchemaRegistry.ensureInstanceTypeField(cls, tgt);
+      const cls = SchemaRegistryIndex.resolveInstanceType<T>(cons, asFull<T>(data));
+      const instance = classConstruct<T & { type?: string }>(cls);
 
-      for (const k of TypedObject.keys(tgt)) { // Do not retain undefined fields
-        if (tgt[k] === undefined) {
-          delete tgt[k];
+      for (const k of TypedObject.keys(instance)) { // Do not retain undefined fields
+        if (instance[k] === undefined) {
+          delete instance[k];
         }
       }
-      return this.bindSchemaToObject(cls, tgt, data, cfg);
+
+      const out = this.bindSchemaToObject(cls, instance, data, cfg);
+      SchemaRegistryIndex.get(cls).ensureInstanceTypeField(out);
+      return out;
     }
   }
 
@@ -172,7 +174,8 @@ export class BindUtil {
     delete cfg.view;
 
     if (!!data && isInstance<T>(data)) {
-      const conf = SchemaRegistry.get(cons);
+      const adapter = SchemaRegistryIndex.get(cons);
+      const conf = adapter.get();
 
       // If no configuration
       if (!conf) {
@@ -180,19 +183,17 @@ export class BindUtil {
           obj[k] = data[k];
         }
       } else {
-        let viewConf = conf.totalView;
+        let schema: SchemaFieldMap = conf.fields;
         if (view) {
-          viewConf = conf.views[view];
-          if (!viewConf) {
+          schema = adapter.getSchema(view);
+          if (!schema) {
             throw new Error(`View not found: ${view.toString()}`);
           }
         }
 
-        for (const schemaFieldName of viewConf.fields) {
-          const field = viewConf.schema[schemaFieldName];
-
+        for (const [schemaFieldName, field] of Object.entries(schema)) {
           let inboundField: string | undefined = undefined;
-          if (field.access === 'readonly' || cfg.filterField?.(field) === false) {
+          if (field.access === 'readonly' || cfg.filterInput?.(field) === false) {
             continue; // Skip trying to write readonly fields
           }
           if (schemaFieldName in data) {
@@ -227,7 +228,7 @@ export class BindUtil {
               }
             }
 
-            if (SchemaRegistry.has(field.type)) {
+            if (SchemaRegistryIndex.has(field.type)) {
               if (field.array && Array.isArray(v)) {
                 v = v.map(el => this.bindSchema(field.type, el, cfg));
               } else {
@@ -244,7 +245,7 @@ export class BindUtil {
 
           if (field.accessor) {
             Object.defineProperty(obj, schemaFieldName, {
-              ...SchemaRegistry.getAccessorDescriptor(cons, schemaFieldName),
+              ...adapter.getAccessorDescriptor(schemaFieldName),
               enumerable: true
             });
           }
@@ -257,31 +258,32 @@ export class BindUtil {
 
   /**
    * Coerce field to type
-   * @param field
+   * @param cfg
    * @param val
    * @param applyDefaults
    * @returns
    */
-  static coerceField(field: FieldConfig, val: unknown, applyDefaults = false): unknown {
+  static coerceInput(cfg: SchemaInputConfig, val: unknown, applyDefaults = false): unknown {
     if ((val === undefined || val === null) && applyDefaults) {
-      val = Array.isArray(field.default) ? field.default.slice(0) : field.default;
+      val = Array.isArray(cfg.default) ? cfg.default.slice(0) : cfg.default;
     }
-    if (!field.required && (val === undefined || val === null)) {
+    if (cfg.required?.active === false && (val === undefined || val === null)) {
       return val;
     }
-    const complex = SchemaRegistry.has(field.type);
-    if (field.array) {
+    const complex = SchemaRegistryIndex.has(cfg.type);
+    const bindCfg: BindConfig | undefined = (complex && 'view' in cfg && typeof cfg.view === 'string') ? { view: cfg.view } : undefined;
+    if (cfg.array) {
       const valArr = !Array.isArray(val) ? [val] : val;
       if (complex) {
-        val = valArr.map(x => this.bindSchema(field.type, x, { view: field.view }));
+        val = valArr.map(x => this.bindSchema(cfg.type, x, bindCfg));
       } else {
-        val = valArr.map(x => DataUtil.coerceType(x, field.type, false));
+        val = valArr.map(x => DataUtil.coerceType(x, cfg.type, false));
       }
     } else {
       if (complex) {
-        val = this.bindSchema(field.type, val, { view: field.view });
+        val = this.bindSchema(cfg.type, val, bindCfg);
       } else {
-        val = DataUtil.coerceType(val, field.type, false);
+        val = DataUtil.coerceType(val, cfg.type, false);
       }
     }
     return val;
@@ -293,11 +295,11 @@ export class BindUtil {
    * @param params
    * @returns
    */
-  static coerceFields(fields: FieldConfig[], params: unknown[], applyDefaults = true): unknown[] {
+  static coerceParameters(fields: SchemaParameterConfig[], params: unknown[], applyDefaults = true): unknown[] {
     params = [...params];
     // Coerce types
     for (const el of fields) {
-      params[el.index!] = this.coerceField(el, params[el.index!], applyDefaults);
+      params[el.index!] = this.coerceInput(el, params[el.index!], applyDefaults);
     }
     return params;
   }
@@ -309,7 +311,8 @@ export class BindUtil {
    * @param params
    * @returns
    */
-  static coerceMethodParams<T>(cls: Class<T>, method: string, params: unknown[], applyDefaults = true): unknown[] {
-    return this.coerceFields(SchemaRegistry.getMethodSchema(cls, method), params, applyDefaults);
+  static coerceMethodParams<T>(cls: Class<T>, method: string | symbol, params: unknown[], applyDefaults = true): unknown[] {
+    const paramConfigs = SchemaRegistryIndex.getMethodConfig(cls, method).parameters;
+    return this.coerceParameters(paramConfigs, params, applyDefaults);
   }
 }

package/src/decorator/common.ts

@@ -1,27 +1,43 @@
-import { Class, ClassInstance } from '@travetto/runtime';
+import { Class, ClassInstance, getClass } from '@travetto/runtime';
 
-import { DescribableConfig } from '../service/types.ts';
-import { SchemaRegistry } from '../service/registry.ts';
-
-function isClassInstance(o: Class | ClassInstance, property?: string): o is ClassInstance {
-  return !!property;
-}
+import { SchemaCoreConfig } from '../service/types.ts';
+import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
 /**
  * Describe a model or a field
  * @param config The describe configuration
- * @augments `@travetto/schema:Describe`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function Describe(config: Partial<DescribableConfig>) {
-  return (target: Class | ClassInstance, property?: string, descOrIdx?: PropertyDescriptor | number): void => {
-    if (isClassInstance(target, property)) {
+export function Describe(config: Partial<Omit<SchemaCoreConfig, 'metadata'>>) {
+  return (instanceOrCls: Class | ClassInstance, property?: string | symbol, descOrIdx?: PropertyDescriptor | number): void => {
+    const adapter = SchemaRegistryIndex.getForRegister(getClass(instanceOrCls));
+    if (!property) {
+      adapter.register(config);
+    } else {
       if (descOrIdx !== undefined && typeof descOrIdx === 'number') {
-        SchemaRegistry.registerPendingParamFacet(target.constructor, property!, descOrIdx, config);
+        adapter.registerParameter(property, descOrIdx, config);
+      } else if (typeof descOrIdx === 'object' && typeof descOrIdx.value === 'function') {
+        adapter.registerMethod(property, config);
       } else {
-        SchemaRegistry.registerPendingFieldFacet(target.constructor, property!, config);
+        adapter.registerField(property, config);
       }
-    } else {
-      SchemaRegistry.register(target, config);
     }
   };
-}
+}
+
+/**
+ * Mark a field/method as private
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export const IsPrivate = (): (instanceOrCls: Class | ClassInstance, property?: string | symbol) => void => Describe({ private: true });
+
+/**
+ * Mark a field/method as ignored
+ * @augments `@travetto/schema:Ignore`
+ * @kind decorator
+ */
+export function Ignore(): PropertyDecorator {
+  return () => { };
+}

package/src/decorator/field.ts

@@ -1,18 +1,13 @@
-import { Any, ClassInstance } from '@travetto/runtime';
+import { Any, ClassInstance, getClass } from '@travetto/runtime';
 
-import { SchemaRegistry } from '../service/registry.ts';
-import { CommonRegExp } from '../validate/regexp.ts';
-import { ClassList, FieldConfig } from '../service/types.ts';
+import { SchemaFieldConfig } 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 prop<V>(obj: Partial<FieldConfig>): PropType<V> {
-  return (t: ClassInstance, k: string, idx?: number | TypedPropertyDescriptor<Any>): void => {
-    if (idx !== undefined && typeof idx === 'number') {
-      SchemaRegistry.registerPendingParamFacet(t.constructor, k, idx, obj);
-    } else {
-      SchemaRegistry.registerPendingFieldFacet(t.constructor, k, obj);
-    }
+function field<V>(...obj: Partial<SchemaFieldConfig>[]): PropType<V> {
+  return (instance: ClassInstance, property: string | symbol): void => {
+    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, ...obj);
   };
 }
 
@@ -20,189 +15,31 @@ function prop<V>(obj: Partial<FieldConfig>): PropType<V> {
  * Registering a field
  * @param type The type for the field
  * @param config The field configuration
- * @augments `@travetto/schema:Field`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function Field(type: ClassList, ...config: Partial<FieldConfig>[]) {
-  return (f: ClassInstance, k: string, idx?: number | TypedPropertyDescriptor<Any>): void => {
-    if (idx !== undefined && typeof idx === 'number') {
-      SchemaRegistry.registerPendingParamConfig(f.constructor, k, idx, type, Object.assign({}, ...config));
-    } else {
-      SchemaRegistry.registerPendingFieldConfig(f.constructor, k, type, Object.assign({}, ...config));
-    }
-  };
+export function Field(type: Pick<SchemaFieldConfig, 'type' | 'array'>, ...config: Partial<SchemaFieldConfig>[]): PropType<unknown> {
+  return field(type, ...config);
 }
 
-/**
- * Alias for the field
- * @param aliases List of all aliases for a field
- * @augments `@travetto/schema:Field`
- */
-export function Alias(...aliases: string[]): PropType<unknown> { return prop({ aliases }); }
 /**
  * Mark a field as writeonly
- * @augments `@travetto/schema:Field`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function Writeonly(): PropType<unknown> { return prop({ access: 'writeonly' }); }
+export function Writeonly(): PropType<unknown> { return field({ access: 'writeonly' }); }
+
 /**
  * Mark a field as readonly
- * @augments `@travetto/schema:Field`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function Readonly(): PropType<unknown> { return prop({ access: 'readonly' }); }
+export function Readonly(): PropType<unknown> { return field({ access: 'readonly' }); }
+
 /**
  * Mark a field as sensitive
  * @param active This determines if this field is sensitive or not.
- * @augments `@travetto/schema:Field`
- */
-export function Secret(active = true): PropType<unknown> { return prop({ secret: active }); }
-/**
- * Mark a field 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:Field`
- */
-export function Required(active = true, message?: string): PropType<unknown> { return prop({ required: { active, message } }); }
-/**
- * Define a field 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:Field`
- */
-export function Enum(values: string[], message?: string): PropType<string | number> {
-  message = message || `{path} is only allowed to be "${values.join('" or "')}"`;
-  return prop({ enum: { values, message } });
-}
-/**
- * Mark the field as indicating it's storing textual data
- * @augments `@travetto/schema:Field`
- */
-export function Text(): PropType<string | string[]> { return prop({ specifiers: ['text'] }); }
-/**
- * Mark the field to indicate it's for long form text
- * @augments `@travetto/schema:Field`
- */
-export function LongText(): PropType<string | string[]> { return prop({ specifiers: ['text', 'long'] }); }
-
-/**
- * Require the field 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:Field`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function Match(re: RegExp, message?: string): PropType<string | string[]> { return prop({ 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:Field`
- */
-export function MinLength(n: number, message?: string): PropType<string | unknown[]> {
-  return prop({ 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:Field`
- */
-export function MaxLength(n: number, message?: string): PropType<string | unknown[]> { return prop({ maxlength: { n, message } }); }
-
-/**
- * The minimum value
- * @param n The minimum value
- * @param message The message to show when the constraint fails
- * @augments `@travetto/schema:Field`
- */
-export function Min<T extends number | Date>(n: T, message?: string): PropType<Date | number> {
-  return prop({ min: { n, message } });
-}
-
-/**
- * The maximum value
- * @param n The maximum value
- * @param message The message to show when the constraint fails
- * @augments `@travetto/schema:Field`
- */
-export function Max<T extends number | Date>(n: T, message?: string): PropType<Date | number> {
-  return prop({ max: { n, message } });
-}
-
-/**
- * Mark a field as an email
- * @param message The message to show when the constraint fails
- * @augments `@travetto/schema:Field`
- */
-export function Email(message?: string): PropType<string | string[]> { return Match(CommonRegExp.email, message); }
-
-/**
- * Mark a field as an telephone number
- * @param message The message to show when the constraint fails
- * @augments `@travetto/schema:Field`
- */
-export function Telephone(message?: string): PropType<string | string[]> { return Match(CommonRegExp.telephone, message); }
-
-/**
- * Mark a field as a url
- * @param message The message to show when the constraint fails
- * @augments `@travetto/schema:Field`
- */
-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:Field`
- */
-export function Precision(digits: number, decimals?: number): PropType<number> { return prop({ precision: [digits, decimals] }); }
-
-/**
- * Mark a number as an integer
- * @augments `@travetto/schema:Field`
- */
-export function Integer(): PropType<number> { return Precision(0); }
-
-/**
- * Mark a number as a float
- * @augments `@travetto/schema:Field`
- */
-export function Float(): PropType<number> { return Precision(10, 7); }
-
-/**
- * Mark a number as a long value
- * @augments `@travetto/schema:Field`
- */
-export function Long(): PropType<number> { return Precision(19, 0); }
-
-/**
- * Mark a number as a currency
- * @augments `@travetto/schema:Field`
- */
-export function Currency(): PropType<number> { return Precision(13, 2); }
-
-/**
- * Mark a field as ignored
- *
- * @augments `@travetto/schema:Ignore`
- */
-export function Ignore(): PropertyDecorator {
-  return () => { };
-}
-
-/**
- * Specifier for the field
- * @param specifiers The specifiers for a field
- * @augments `@travetto/schema:Field`
- */
-export function Specifier(...specifiers: string[]): PropType<unknown> { return prop({ specifiers }); }
-
-/**
- * Sets the subtype field via a property decorator
- * @augments `@travetto/schema:Field`
- */
-export function SubTypeField(): ((t: ClassInstance, k: string) => void) {
-  return (t: ClassInstance, k: string): void => {
-    SchemaRegistry.register(t.constructor, { subTypeField: k });
-  };
-}
+export function Secret(active = true): PropType<unknown> { return field({ secret: active }); }