@travetto/schema 2.1.5 → 2.2.2

package/README.md

@@ -25,7 +25,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#L11) 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#L15) decorator.
 
 **Code: Sample User Schema**
 ```typescript
@@ -69,16 +69,16 @@ This schema provides a powerful base for data binding and validation at runtime.
    *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L79) defines the allowable values that a field can have
    *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L100) defines a regular expression that the field value should match
    *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L108) enforces min length of a string
-   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116) enforces max length of a string
+   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L118) enforces max length of a string
    *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L108) enforces min value for a date or a number
-   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116) enforces max value for a date or a number
-   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L139) ensures string field matches basic email regex
-   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L146) ensures string field matches basic telephone regex
-   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L153) ensures string field matches basic url regex
-   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L192) exclude from auto schema registration
-   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L167) ensures number passed in is only a whole number
-   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L173) ensures number passed in allows fractional values
-   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L185) provides support for standard currency
+   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L118) enforces max value for a date or a number
+   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L145) ensures string field matches basic email regex
+   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L152) ensures string field matches basic telephone regex
+   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L159) ensures string field matches basic url regex
+   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L198) exclude from auto schema registration
+   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L173) ensures number passed in is only a whole number
+   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L179) ensures number passed in allows fractional values
+   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L191) provides support for standard currency
    *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L87) 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#L92) same as text, but expects longer form content
    *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L65) defines a that field should not be bindable external to the class
@@ -92,7 +92,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#L11) 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#L15) decorator.
 
 ## Binding/Validation
 At runtime, once a schema is registered, a programmer can utilize this structure to perform specific operations. Specifically binding and validation.
@@ -124,7 +124,7 @@ A binding operation could look like:
 ```typescript
 import { Person } from './person';
 
-export function Test() {
+export function Test(): Person {
   return Person.from({
     name: 'Test',
     age: 19.999978,
@@ -181,7 +181,7 @@ import { SchemaValidator } from '@travetto/schema';
 
 import { Person } from './person';
 
-export async function validate() {
+export async function validate(): Promise<void> {
 
   const person = Person.from({
     name: 'Test',
@@ -210,15 +210,14 @@ Validation Failed {
   "errors": [
     {
       "kind": "type",
-      "type": "number",
+      "message": "age is not a valid number",
       "path": "age",
-      "message": "age is not a valid number"
+      "type": "number"
     },
     {
       "kind": "required",
-      "active": true,
-      "path": "address.street2",
-      "message": "address.street2 is required"
+      "message": "address.street2 is required",
+      "path": "address.street2"
     }
   ]
 }
@@ -230,9 +229,9 @@ Within the schema framework, it is possible to add custom validators class level
 
 **Code: Password Validator**
 ```typescript
-import { Schema, Validator } from '@travetto/schema';
+import { Schema, Validator, ValidationError } from '@travetto/schema';
 
-const passwordValidator = (user: User) => {
+const passwordValidator = (user: User): ValidationError | undefined => {
   const p = user.password;
   const hasNum = /\d/.test(p);
   const hasSpecial = /[!@#$%%^&*()<>?/,.;':"']/.test(p);
@@ -307,38 +306,41 @@ In addition to the general types, the code relies upon name matching to provide
 
 **Code: Supported Mappings**
 ```typescript
-static #namesToType = {
-    string: [
-      [/^(image|img).*url$/, () => faker.image.imageUrl()],
-      [/^url$/, () => faker.internet.url()],
-      [/^email(addr(ress)?)?$/, () => faker.internet.email()],
-      [/^(tele)?phone(num|number)?$/, () => faker.phone.phoneNumber()],
-      [/^((postal|zip)code)|zip$/, () => faker.address.zipCode()],
-      [/f(irst)?name/, () => faker.name.firstName()],
-      [/l(ast)?name/, () => faker.name.lastName()],
-      [/^ip(add(ress)?)?$/, () => faker.internet.ip()],
-      [/^ip(add(ress)?)?(v?)6$/, () => faker.internet.ipv6()],
-      [/^username$/, () => faker.internet.userName()],
-      [/^domain(name)?$/, () => faker.internet.domainName()],
-      [/^file(path|name)?$/, () => faker.system.filePath()],
-      [/^street(1)?$/, () => faker.address.streetAddress()],
-      [/^street2$/, () => faker.address.secondaryAddress()],
-      [/^county$/, () => faker.address.county()],
-      [/^country$/, () => faker.address.country()],
-      [/^state$/, () => faker.address.state()],
-      [/^lon(gitude)?$/, () => faker.address.longitude()],
-      [/^lat(itude)?$/, () => faker.address.latitude()],
-      [/(profile).*(image|img)/, () => faker.image.avatar()],
-      [/(image|img)/, () => faker.image.image()],
-      [/^company(name)?$/, () => faker.company.companyName()],
-      [/(desc|description)$/, () => faker.lorem.sentences(10)]
-    ] as [RegExp, () => string][],
-    date: [
-      [/dob|birth/, () => faker.date.past(60)],
-      [/creat(e|ion)/, () => between(-200, -100)],
-      [/(update|modif(y|ied))/, () => between(-100, -50)]
-    ] as [RegExp, () => Date][],
-  };
+static #namesToType: {
+    string: [RegExp, () => string][];
+    date: [RegExp, () => Date][];
+  } = {
+      string: [
+        [/^(image|img).*url$/, (): string => faker.image.imageUrl()],
+        [/^url$/, (): string => faker.internet.url()],
+        [/^email(addr(ress)?)?$/, (): string => faker.internet.email()],
+        [/^(tele)?phone(num|number)?$/, (): string => faker.phone.phoneNumber()],
+        [/^((postal|zip)code)|zip$/, (): string => faker.address.zipCode()],
+        [/f(irst)?name/, (): string => faker.name.firstName()],
+        [/l(ast)?name/, (): string => faker.name.lastName()],
+        [/^ip(add(ress)?)?$/, (): string => faker.internet.ip()],
+        [/^ip(add(ress)?)?(v?)6$/, (): string => faker.internet.ipv6()],
+        [/^username$/, (): string => faker.internet.userName()],
+        [/^domain(name)?$/, (): string => faker.internet.domainName()],
+        [/^file(path|name)?$/, (): string => faker.system.filePath()],
+        [/^street(1)?$/, (): string => faker.address.streetAddress()],
+        [/^street2$/, (): string => faker.address.secondaryAddress()],
+        [/^county$/, (): string => faker.address.county()],
+        [/^country$/, (): string => faker.address.country()],
+        [/^state$/, (): string => faker.address.state()],
+        [/^lon(gitude)?$/, (): string => faker.address.longitude()],
+        [/^lat(itude)?$/, (): string => faker.address.latitude()],
+        [/(profile).*(image|img)/, (): string => faker.image.avatar()],
+        [/(image|img)/, (): string => faker.image.image()],
+        [/^company(name)?$/, (): string => faker.company.companyName()],
+        [/(desc|description)$/, (): string => faker.lorem.sentences(10)]
+      ],
+      date: [
+        [/dob|birth/, (): Date => faker.date.past(60)],
+        [/creat(e|ion)/, (): Date => between(-200, -100)],
+        [/(update|modif(y|ied))/, (): Date => between(-100, -50)]
+      ],
+    };
 ```
 
 An example of this would be:
@@ -366,7 +368,7 @@ class User {
   address: Address;
 }
 
-export function generate() {
+export function generate(): User {
   const user = SchemaFakerUtil.generate(User);
   return user;
 }
@@ -392,7 +394,7 @@ export type Point = [number, number];
 const INVALID = Symbol.for('invalid-point');
 
 export class PointImpl {
-  static validateSchema(input: unknown) {
+  static validateSchema(input: unknown): 'type' | undefined {
     const ret = this.bindSchema(input);
     return ret !== INVALID && ret && !isNaN(ret[0]) && !isNaN(ret[1]) ? undefined : 'type';
   }
@@ -439,9 +441,9 @@ Validation Failed {
   "errors": [
     {
       "kind": "type",
-      "type": "PointImpl",
+      "message": "point is not a valid PointImpl",
       "path": "point",
-      "message": "point is not a valid PointImpl"
+      "type": "PointImpl"
     }
   ]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/schema",
   "displayName": "Schema",
-  "version": "2.1.5",
+  "version": "2.2.2",
   "description": "Data type registry for runtime validation, reflection and binding. ",
   "keywords": [
     "schema",
@@ -29,8 +29,8 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^2.1.5",
-    "@travetto/transformer": "^2.1.4"
+    "@travetto/registry": "^2.2.2",
+    "@travetto/transformer": "^2.2.2"
   },
   "optionalPeerDependencies": {
     "@types/faker": "^5.5.9",

package/src/bind-util.ts

@@ -28,15 +28,16 @@ export class BindUtil {
         }
       }
     }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return val as T;
   }
 
   /**
    * Register `from` on the Function prototype
    */
-  static register() {
+  static register(): void {
     const proto = Object.getPrototypeOf(Function);
-    proto.from = function (data: object | ClassInstance, view?: string) {
+    proto.from = function (data: object | ClassInstance, view?: string): unknown {
       return BindUtil.bindSchema(this, data, view);
     };
   }
@@ -48,10 +49,11 @@ export class BindUtil {
    *
    * @param obj The object to convert
    */
-  static expandPaths(obj: Record<string, unknown>) {
+  static expandPaths(obj: Record<string, unknown>): Record<string, unknown> {
     const out: Record<string, unknown> = {};
     for (const k of Object.keys(obj)) {
-      const val = Util.isPlainObject(obj[k]) ? this.expandPaths(obj[k] as Record<string, unknown>) : obj[k];
+      const objK = obj[k];
+      const val = Util.isPlainObject(objK) ? this.expandPaths(objK) : objK;
       const parts = k.split('.');
       const last = parts.pop()!;
       let sub = out;
@@ -65,12 +67,14 @@ export class BindUtil {
         if (!(name in sub)) {
           sub[name] = typeof key === 'number' ? [] : {};
         }
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         sub = sub[name] as Record<string, unknown>;
 
         if (idx && key !== undefined) {
           if (sub[key] === undefined) {
             sub[key] = {};
           }
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           sub = sub[key] as Record<string, unknown>;
         }
       }
@@ -88,8 +92,10 @@ export class BindUtil {
         let key = arr ? (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined)) : undefined;
         if (sub[name] === undefined) {
           sub[name] = (typeof key === 'string') ? {} : [];
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           sub = sub[name] as Record<string, unknown>;
           if (key === undefined) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             key = sub.length as number;
           }
           if (sub[key] && Util.isPlainObject(val) && Util.isPlainObject(sub[key])) {
@@ -108,7 +114,7 @@ export class BindUtil {
    * @param conf The object to flatten the paths for
    * @param val The starting prefix
    */
-  static flattenPaths(data: Record<string, unknown>, prefix: string = '') {
+  static flattenPaths(data: Record<string, unknown>, prefix: string = ''): Record<string, unknown> {
     const out: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(data)) {
       const pre = `${prefix}${key}`;
@@ -144,18 +150,23 @@ export class BindUtil {
     if (data === null || data === undefined) {
       return data;
     }
-    const cls = SchemaRegistry.resolveSubTypeForInstance(cons, data) as Class<T>;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const cls = SchemaRegistry.resolveSubTypeForInstance<T>(cons, data as T);
     if (data instanceof cls) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return data as T;
     } else {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const tgt = new (cls as ConcreteClass<T>)();
       SchemaRegistry.ensureInstanceTypeField(cls, tgt);
 
       for (const [k, v] of Object.entries(tgt)) { // Do not retain undefined fields
         if (v === undefined) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           delete tgt[k as keyof T];
         }
       }
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return this.bindSchemaToObject(cls, tgt, data as object, view);
     }
   }
@@ -175,7 +186,8 @@ export class BindUtil {
 
       // If no configuration
       if (!conf) {
-        for (const k of Object.keys(data) as (keyof typeof obj)[]) {
+        for (const k of Object.keys(data)) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           obj[k] = data[k as keyof typeof data];
         }
       } else {
@@ -205,7 +217,8 @@ export class BindUtil {
             continue;
           }
 
-          let v = data[inboundField as keyof typeof data] as unknown;
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          let v: unknown = data[inboundField as keyof typeof data];
 
           if (v !== undefined && v !== null) {
             const config = viewConf.schema[schemaFieldName];
@@ -228,6 +241,7 @@ export class BindUtil {
             }
           }
 
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           obj[schemaFieldName as keyof typeof obj] = v as (typeof obj)[keyof typeof obj];
         }
       }
@@ -243,23 +257,21 @@ export class BindUtil {
    * @param applyDefaults
    * @returns
    */
-  static coerceField(field: FieldConfig, val: unknown, applyDefaults = false) {
+  static coerceField(field: FieldConfig, val: unknown, applyDefaults = false): unknown {
     if ((val === undefined || val === null) && applyDefaults) {
       val = field.default;
     }
     const complex = SchemaRegistry.has(field.type);
     if (field.array) {
-      if (!Array.isArray(val)) {
-        val = [val];
-      }
+      const valArr = !Array.isArray(val) ? [val] : val;
       if (complex) {
-        val = (val as unknown[]).map(x => this.bindSchema(field.type, x as object, field.view));
+        val = valArr.map(x => this.bindSchema(field.type, x, field.view));
       } else {
-        val = (val as unknown[]).map(x => Util.coerceType(x, field.type, false));
+        val = valArr.map(x => Util.coerceType(x, field.type, false));
       }
     } else {
       if (complex) {
-        val = this.bindSchema(field.type, val as object, field.view);
+        val = this.bindSchema(field.type, val, field.view);
       } else {
         val = Util.coerceType(val, field.type, false);
       }

package/src/decorator/common.ts

@@ -3,20 +3,24 @@ import { Class, ClassInstance } from '@travetto/base';
 import { DescribableConfig } from '../service/types';
 import { SchemaRegistry } from '../service/registry';
 
+function isClassInstance(o: Class | ClassInstance, property?: string): o is ClassInstance {
+  return !!property;
+}
+
 /**
  * Describe a model or a field
  * @param config The describe configuration
  * @augments `@trv:schema/Describe`
  */
 export function Describe(config: Partial<DescribableConfig>) {
-  return (target: Class | ClassInstance, property?: string, descOrIdx?: PropertyDescriptor | number) => {
-    if (property) {
+  return (target: Class | ClassInstance, property?: string, descOrIdx?: PropertyDescriptor | number): void => {
+    if (isClassInstance(target, property)) {
       if (descOrIdx !== undefined && typeof descOrIdx === 'number') {
         property = `${property}.${descOrIdx}`;
       }
-      SchemaRegistry.registerPendingFieldFacet((target as ClassInstance).constructor, property!, config);
+      SchemaRegistry.registerPendingFieldFacet(target.constructor, property!, config);
     } else {
-      SchemaRegistry.register(target as Class, config);
+      SchemaRegistry.register(target, config);
     }
   };
 }

package/src/decorator/field.ts

@@ -5,7 +5,7 @@ import { CommonRegExp } from '../validate/regexp';
 import { ClassList, FieldConfig } from '../service/types';
 
 function prop(obj: Partial<FieldConfig>) {
-  return (t: ClassInstance, k: string, idx?: number | PropertyDescriptor) => {
+  return (t: ClassInstance, k: string, idx?: number | PropertyDescriptor): void => {
     if (idx !== undefined && typeof idx === 'number') {
       SchemaRegistry.registerPendingParamFacet(t.constructor, k, idx, obj);
     } else {
@@ -14,20 +14,20 @@ function prop(obj: Partial<FieldConfig>) {
   };
 }
 
-const stringArrProp = prop as
-  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | unknown[]>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
+// eslint-disable-next-line max-len
+const stringArrProp: (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | unknown[]>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void = prop;
 
-const stringArrStringProp = prop as
-  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | string[]>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
+// eslint-disable-next-line max-len
+const stringArrStringProp: (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | string[]>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void = prop;
 
-const numberProp = prop as
-  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
+// eslint-disable-next-line max-len
+const numberProp: (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void = prop;
 
-const stringNumberProp = prop as
-  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
+// eslint-disable-next-line max-len
+const stringNumberProp: (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void = prop;
 
-const dateNumberProp = prop as
-  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, Date | number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
+// eslint-disable-next-line max-len
+const dateNumberProp: (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, Date | number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void = prop;
 
 /**
  * Registering a field
@@ -36,7 +36,7 @@ const dateNumberProp = prop as
  * @augments `@trv:schema/Field`
  */
 export function Field(type: ClassList, config?: Partial<FieldConfig>) {
-  return (f: ClassInstance, k: string, idx?: number | PropertyDescriptor) => {
+  return (f: ClassInstance, k: string, idx?: number | PropertyDescriptor): void => {
     if (idx !== undefined && typeof idx === 'number') {
       SchemaRegistry.registerPendingParamConfig(f.constructor, k, idx, type, config);
     } else {
@@ -50,33 +50,33 @@ export function Field(type: ClassList, config?: Partial<FieldConfig>) {
  * @param aliases List of all aliases for a field
  * @augments `@trv:schema/Field`
  */
-export function Alias(...aliases: string[]) { return prop({ aliases }); }
+export function Alias(...aliases: string[]): ReturnType<typeof prop> { return prop({ aliases }); }
 /**
  * Mark a field as writeonly
  * @param active This determines if this field is readonly or not.
  * @augments `@trv:schema/Field`
  */
-export function Writeonly(active = true) { return prop({ access: 'writeonly' }); }
+export function Writeonly(active = true): ReturnType<typeof prop> { return prop({ access: 'writeonly' }); }
 /**
  * Mark a field as readonly
  * @param active This determines if this field is readonly or not.
  * @augments `@trv:schema/Field`
  */
-export function Readonly(active = true) { return prop({ access: 'readonly' }); }
+export function Readonly(active = true): ReturnType<typeof prop> { return prop({ access: 'readonly' }); }
 /**
  * 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 `@trv:schema/Field`
  */
-export function Required(active = true, message?: string) { return prop({ required: { active, message } }); }
+export function Required(active = true, message?: string): ReturnType<typeof prop> { return prop({ required: { active, message } }); }
 /**
  * Define a field as a set of enumerated values
- * @param vals The list of values allowed for the enumeration
+ * @param values The list of values allowed for the enumeration
  * @param message The error message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function Enum(values: string[], message?: string) {
+export function Enum(values: string[], message?: string): ReturnType<typeof stringNumberProp> {
   message = message || `{path} is only allowed to be "${values.join('" or "')}"`;
   return stringNumberProp({ enum: { values, message } });
 }
@@ -84,12 +84,12 @@ export function Enum(values: string[], message?: string) {
  * Mark the field as indicating it's storing textual data
  * @augments `@trv:schema/Field`
  */
-export function Text() { return stringArrStringProp({ specifier: 'text' }); }
+export function Text(): ReturnType<typeof stringArrStringProp> { return stringArrStringProp({ specifier: 'text' }); }
 /**
  * Mark the field to indicate it's for long form text
  * @augments `@trv:schema/Field`
  */
-export function LongText() { return stringArrStringProp({ specifier: 'text-long' }); }
+export function LongText(): ReturnType<typeof stringArrStringProp> { return stringArrStringProp({ specifier: 'text-long' }); }
 
 /**
  * Require the field to match a specific RegExp
@@ -97,7 +97,7 @@ export function LongText() { return stringArrStringProp({ specifier: 'text-long'
  * @param message The message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function Match(re: RegExp, message?: string) { return stringArrStringProp({ match: { re, message } }); }
+export function Match(re: RegExp, message?: string): ReturnType<typeof stringArrStringProp> { return stringArrStringProp({ match: { re, message } }); }
 
 /**
  * The minimum length for the string or array
@@ -105,7 +105,9 @@ export function Match(re: RegExp, message?: string) { return stringArrStringProp
  * @param message The message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function MinLength(n: number, message?: string) { return stringArrProp({ minlength: { n, message }, ...(n === 0 ? { required: { active: false } } : {}) }); }
+export function MinLength(n: number, message?: string): ReturnType<typeof stringArrProp> {
+  return stringArrProp({ minlength: { n, message }, ...(n === 0 ? { required: { active: false } } : {}) });
+}
 
 /**
  * The maximum length for the string or array
@@ -113,7 +115,7 @@ export function MinLength(n: number, message?: string) { return stringArrProp({
  * @param message The message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function MaxLength(n: number, message?: string) { return stringArrProp({ maxlength: { n, message } }); }
+export function MaxLength(n: number, message?: string): ReturnType<typeof stringArrProp> { return stringArrProp({ maxlength: { n, message } }); }
 
 /**
  * The minimum value
@@ -121,7 +123,9 @@ export function MaxLength(n: number, message?: string) { return stringArrProp({
  * @param message The message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function Min<T extends number | Date>(n: T, message?: string) { return dateNumberProp({ min: { n, message } }); }
+export function Min<T extends number | Date>(n: T, message?: string): ReturnType<typeof dateNumberProp> {
+  return dateNumberProp({ min: { n, message } });
+}
 
 /**
  * The maximum value
@@ -129,28 +133,30 @@ export function Min<T extends number | Date>(n: T, message?: string) { return da
  * @param message The message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function Max<T extends number | Date>(n: T, message?: string) { return dateNumberProp({ max: { n, message } }); }
+export function Max<T extends number | Date>(n: T, message?: string): ReturnType<typeof dateNumberProp> {
+  return dateNumberProp({ max: { n, message } });
+}
 
 /**
  * Mark a field as an email
  * @param message The message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function Email(message?: string) { return Match(CommonRegExp.email, message); }
+export function Email(message?: string): ReturnType<typeof Match> { return Match(CommonRegExp.email, message); }
 
 /**
  * Mark a field as an telephone number
  * @param message The message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function Telephone(message?: string) { return Match(CommonRegExp.telephone, message); }
+export function Telephone(message?: string): ReturnType<typeof Match> { return Match(CommonRegExp.telephone, message); }
 
 /**
  * Mark a field as a url
  * @param message The message to show when the constraint fails
  * @augments `@trv:schema/Field`
  */
-export function Url(message?: string) { return Match(CommonRegExp.url, message); }
+export function Url(message?: string): ReturnType<typeof Match> { return Match(CommonRegExp.url, message); }
 
 /**
  * Determine the numeric precision of the value
@@ -158,31 +164,31 @@ export function Url(message?: string) { return Match(CommonRegExp.url, message);
  * @param decimals The number of decimal digits to support
  * @augments `@trv:schema/Field`
  */
-export function Precision(digits: number, decimals?: number) { return numberProp({ precision: [digits, decimals] }); }
+export function Precision(digits: number, decimals?: number): ReturnType<typeof numberProp> { return numberProp({ precision: [digits, decimals] }); }
 
 /**
  * Mark a number as an integer
  * @augments `@trv:schema/Field`
  */
-export function Integer() { return Precision(0); }
+export function Integer(): ReturnType<typeof numberProp> { return Precision(0); }
 
 /**
  * Mark a number as a float
  * @augments `@trv:schema/Field`
  */
-export function Float() { return Precision(10, 7); }
+export function Float(): ReturnType<typeof numberProp> { return Precision(10, 7); }
 
 /**
  * Mark a number as a long value
  * @augments `@trv:schema/Field`
  */
-export function Long() { return Precision(19, 0); }
+export function Long(): ReturnType<typeof numberProp> { return Precision(19, 0); }
 
 /**
  * Mark a number as a currency
  * @augments `@trv:schema/Field`
  */
-export function Currency() { return Precision(13, 2); }
+export function Currency(): ReturnType<typeof numberProp> { return Precision(13, 2); }
 
 /**
  * Mark a field as ignored

package/src/decorator/schema.ts

@@ -22,7 +22,8 @@ export function Schema() { // Auto is used during compilation
  * @param fn The validator function
  */
 export function Validator<T>(fn: ValidatorFn<T, string>) {
-  return (target: Class<T>) => {
+  return (target: Class<T>): void => {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     SchemaRegistry.getOrCreatePending(target).validators!.push(fn as ValidatorFn<unknown, unknown>);
   };
 }
@@ -33,7 +34,7 @@ export function Validator<T>(fn: ValidatorFn<T, string>) {
  * @param fields The specific fields to add as part of a view
  */
 export function View<T>(name: string, fields: ViewFieldsConfig<Partial<T>>) {
-  return (target: Class<Partial<T>>) => {
+  return (target: Class<Partial<T>>): void => {
     SchemaRegistry.registerPendingView(target, name, fields);
   };
 }
@@ -44,7 +45,7 @@ export function View<T>(name: string, fields: ViewFieldsConfig<Partial<T>>) {
  * @returns
  */
 export function SubType<T>(name: string) {
-  return (target: Class<Partial<T>>) => {
+  return (target: Class<Partial<T>>): void => {
     SchemaRegistry.registerSubTypes(target, name);
   };
 }