@travetto/schema 2.1.5 → 2.2.2

package/src/extension/faker.ts

@@ -1,5 +1,5 @@
 // @file-if faker
-import type * as fakerType from 'faker';
+import * as fakerType from 'faker';
 
 import { Class } from '@travetto/base';
 
@@ -9,13 +9,16 @@ import { SchemaRegistry } from '../service/registry';
 import { BindUtil } from '../bind-util';
 
 // Load faker on demand, as its very heavy in loading
-let faker = new Proxy({}, {
-  get: (t, p, r) => (faker = require('faker'))[p]
-}) as typeof fakerType;
+let faker: typeof fakerType = new Proxy(
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  {} as typeof fakerType,
+  {
+    get: (t, prop, r) => (faker = require('faker'))[prop]
+  });
 
 const DAY_IN_MS = 24 * 60 * 60 * 1000;
 
-const between = (fromDays: number, toDays: number) =>
+const between = (fromDays: number, toDays: number): Date =>
   faker.date.between(
     new Date(Date.now() + fromDays * DAY_IN_MS),
     new Date(Date.now() + toDays * DAY_IN_MS)
@@ -27,53 +30,56 @@ const between = (fromDays: number, toDays: number) =>
 export class SchemaFakerUtil {
 
   static #stringToReType: [RegExp, () => string][] = [
-    [CommonRegExp.email, () => faker.internet.email()],
-    [CommonRegExp.url, () => faker.internet.url()],
-    [CommonRegExp.telephone, () => faker.phone.phoneNumber()],
-    [CommonRegExp.postalCode, () => faker.address.zipCode()]
+    [CommonRegExp.email, (): string => faker.internet.email()],
+    [CommonRegExp.url, (): string => faker.internet.url()],
+    [CommonRegExp.telephone, (): string => faker.phone.phoneNumber()],
+    [CommonRegExp.postalCode, (): string => faker.address.zipCode()]
   ];
 
   /**
    * Mapping of field types to faker utils
    */
-  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)]
+      ],
+    };
 
   /**
    * Get an array of values
    * @param cfg Field configuration
    */
-  static getArrayValue(cfg: FieldConfig) {
+  static getArrayValue(cfg: FieldConfig): unknown[] {
     const min = cfg.minlength ? cfg.minlength.n : 0;
     const max = cfg.maxlength ? cfg.maxlength.n : 10;
     const size = faker.datatype.number({ min, max });
@@ -88,9 +94,9 @@ export class SchemaFakerUtil {
    * Get a new number value
    * @param cfg Number config
    */
-  static getNumberValue(cfg: FieldConfig) {
-    let min = cfg.min ? cfg.min.n as number : undefined;
-    let max = cfg.max ? cfg.max.n as number : undefined;
+  static getNumberValue(cfg: FieldConfig): number {
+    let min = cfg.min && typeof cfg.min.n === 'number' ? cfg.min.n : undefined;
+    let max = cfg.max && typeof cfg.max.n === 'number' ? cfg.max.n : undefined;
     let precision = cfg.precision;
 
     const name = cfg.name.toUpperCase();
@@ -123,10 +129,10 @@ export class SchemaFakerUtil {
    * Get a date value
    * @param cfg Field config
    */
-  static getDateValue(cfg: FieldConfig) {
+  static getDateValue(cfg: FieldConfig): Date {
     const name = cfg.name.toUpperCase();
-    const min = cfg.min ? cfg.min.n as Date : undefined;
-    const max = cfg.max ? cfg.max.n as Date : undefined;
+    const min = cfg.min && typeof cfg.min.n !== 'number' ? cfg.min.n : undefined;
+    const max = cfg.max && typeof cfg.max.n !== 'number' ? cfg.max.n : undefined;
 
     if (min !== undefined || max !== undefined) {
       return faker.date.between(min || new Date(Date.now() - (50 * DAY_IN_MS)), max || new Date());
@@ -144,7 +150,7 @@ export class SchemaFakerUtil {
    * Get a string value
    * @param cfg Field config
    */
-  static getStringValue(cfg: FieldConfig) {
+  static getStringValue(cfg: FieldConfig): string {
     const name = cfg.name.toLowerCase();
 
     if (cfg.match) {
@@ -197,7 +203,7 @@ export class SchemaFakerUtil {
    * @param cls The class to get an instance of
    * @param view The view to define specifically
    */
-  static generate<T>(cls: Class<T>, view?: string) {
+  static generate<T>(cls: Class<T>, view?: string): T {
     const cfg = SchemaRegistry.getViewSchema(cls, view);
     const out: Record<string, unknown> = {};
 

package/src/service/changes.ts

@@ -6,7 +6,7 @@ import { ChangeEvent } from '@travetto/registry';
 import { FieldConfig, ClassConfig } from './types';
 import { AllViewⲐ } from '../internal/types';
 
-const id = (c: Class | string) => typeof c === 'string' ? c : c.ᚕid;
+const id = (c: Class | string): string => typeof c === 'string' ? c : c.ᚕid;
 
 interface FieldMapping {
   path: FieldConfig[];
@@ -45,7 +45,7 @@ class $SchemaChangeListener {
    * On schema change, emit the change event for the whole schema
    * @param cb The function to call on schema change
    */
-  onSchemaChange(handler: (e: SchemaChangeEvent) => void) {
+  onSchemaChange(handler: (e: SchemaChangeEvent) => void): void {
     this.#emitter.on('schema', handler);
   }
 
@@ -53,21 +53,21 @@ class $SchemaChangeListener {
    * On schema field change, emit the change event for the whole schema
    * @param cb The function to call on schema field change
    */
-  onFieldChange(handler: (e: FieldChangeEvent) => void) {
+  onFieldChange(handler: (e: FieldChangeEvent) => void): void {
     this.#emitter.on('field', handler);
   }
 
   /**
    * Reset the listener
    */
-  reset() {
+  reset(): void {
     this.#mapping.clear();
   }
 
   /**
    * Clear dependency mappings for a given class
    */
-  clearSchemaDependency(cls: Class) {
+  clearSchemaDependency(cls: Class): void {
     this.#mapping.delete(id(cls));
   }
 
@@ -78,7 +78,7 @@ 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) {
+  trackSchemaDependency(src: Class, parent: Class, path: FieldConfig[], config: ClassConfig): void {
     const idValue = id(src);
     if (!this.#mapping.has(idValue)) {
       this.#mapping.set(idValue, new Map());
@@ -91,7 +91,7 @@ class $SchemaChangeListener {
    * @param cls The class of the event
    * @param changes The changes to send
    */
-  emitSchemaChanges({ cls, changes }: FieldChangeEvent) {
+  emitSchemaChanges({ cls, changes }: FieldChangeEvent): void {
     const updates = new Map<string, SchemaChange>();
     const clsId = id(cls);
 
@@ -116,7 +116,7 @@ class $SchemaChangeListener {
    * @param prev The previous class config
    * @param curr The current class config
    */
-  emitFieldChanges({ prev, curr }: ChangeEvent<ClassConfig>) {
+  emitFieldChanges({ prev, curr }: ChangeEvent<ClassConfig>): void {
 
     const prevView = prev?.views[AllViewⲐ] || { fields: [], schema: {} };
     const currView = curr!.views[AllViewⲐ];
@@ -139,7 +139,7 @@ class $SchemaChangeListener {
     }
 
     // Handle class references changing, but keeping same id
-    const compareTypes = (a: Class, b: Class) => 'ᚕid' in a ? a.ᚕid === b.ᚕid : a === b;
+    const compareTypes = (a: Class, b: Class): boolean => 'ᚕid' in a ? a.ᚕid === b.ᚕid : a === b;
 
     for (const c of currFields) {
       if (prevFields.has(c)) {

package/src/service/registry.ts

@@ -1,12 +1,13 @@
-import { Class, AppError, Util } from '@travetto/base';
+import { Class, AppError, Util, ClassInstance } from '@travetto/base';
 import { MetadataRegistry, RootRegistry, ChangeEvent } from '@travetto/registry';
 
-import { ClassList, FieldConfig, ClassConfig, SchemaConfig, ViewFieldsConfig } from './types';
+import { ClassList, FieldConfig, ClassConfig, SchemaConfig, ViewFieldsConfig, ViewConfig } from './types';
 import { SchemaChangeListener } from './changes';
 import { BindUtil } from '../bind-util';
 import { AllViewⲐ } from '../internal/types';
 
 function hasType<T>(o: unknown): o is { type: Class<T> | string } {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !Util.isPrimitive(o) && 'type' in (o as object) && !!(o as Record<string, string>)['type'];
 }
 
@@ -24,31 +25,31 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     super(RootRegistry);
   }
 
-  #computeSubTypeName(cls: Class) {
+  #computeSubTypeName(cls: Class): string {
     if (!this.#typeKeys.has(cls)) {
       this.#typeKeys.set(cls, 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())
         .toLowerCase());
     }
-    return this.#typeKeys.get(cls);
+    return this.#typeKeys.get(cls)!;
   }
 
   /**
    * Get subtype name for a class
    * @param cls Base class
    */
-  getSubTypeName(cls: Class) {
+  getSubTypeName(cls: Class): string | undefined {
     if (this.get(cls).subType) {
       return this.#computeSubTypeName(cls);
     }
   }
 
   /**
-   * Ensure type is set properl
+   * Ensure type is set properly
    */
-  ensureInstanceTypeField<T>(cls: Class, o: T) {
-    const withType = (o as { type?: string });
+  ensureInstanceTypeField<T>(cls: Class, o: T): void {
+    const withType: { type?: string } = o;
     if (this.get(cls)?.subType && 'type' in this.get(cls).views[AllViewⲐ].schema && !withType.type) {  // Do we have a type field defined
       withType.type = this.#computeSubTypeName(cls); // Assign if missing
     }
@@ -59,8 +60,9 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param cls Class for instance
    * @param o Actual instance
    */
-  resolveSubTypeForInstance<T>(cls: Class<T>, o: T) {
-    return this.resolveSubType(cls, hasType<T>(o) ? o.type : (o as unknown as { constructor: Class<T> }).constructor);
+  resolveSubTypeForInstance<T>(cls: Class<T>, o: T): Class {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return this.resolveSubType(cls, hasType<T>(o) ? o.type : (o as unknown as ClassInstance<T>).constructor);
   }
 
   /**
@@ -88,7 +90,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param cls The class to register against
    * @param type The subtype name
    */
-  registerSubTypes(cls: Class, type?: string) {
+  registerSubTypes(cls: Class, type?: string): string {
     // Mark as subtype
     (this.get(cls) ?? this.getOrCreatePending(cls)).subType = true;
 
@@ -118,7 +120,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param curr The new class
    * @param path The path within the object hierarchy
    */
-  trackSchemaDependencies(cls: Class, curr: Class = cls, path: FieldConfig[] = []) {
+  trackSchemaDependencies(cls: Class, curr: Class = cls, path: FieldConfig[] = []): void {
     const config = this.get(curr);
 
     SchemaChangeListener.trackSchemaDependency(curr, cls, path, this.get(cls));
@@ -132,7 +134,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     }
   }
 
-  createPending(cls: Class) {
+  createPending(cls: Class): ClassConfig {
     return {
       class: cls,
       validators: [],
@@ -149,16 +151,16 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
   /**
    * Get schema for a given view
    * @param cls The class to retrieve the schema for
-   * @param view Thee view name
+   * @param view The view name
    */
-  getViewSchema<T>(cls: Class<T>, view?: string | typeof AllViewⲐ) {
+  getViewSchema<T>(cls: Class<T>, view?: string | typeof AllViewⲐ): ViewConfig {
     view = view ?? AllViewⲐ;
 
-    const schm = this.get(cls)!;
-    if (!schm) {
+    const schema = this.get(cls)!;
+    if (!schema) {
       throw new Error(`Unknown schema class ${cls.name}`);
     }
-    const res = schm.views[view];
+    const res = schema.views[view];
     if (!res) {
       throw new Error(`Unknown view ${view.toString()} for ${cls.name}`);
     }
@@ -206,11 +208,13 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param view View name
    * @param fields Fields to register
    */
-  registerPendingView<T>(target: Class<T>, view: string, fields: ViewFieldsConfig<T>) {
+  registerPendingView<T>(target: Class<T>, view: string, fields: ViewFieldsConfig<T>): void {
     if (!this.#pendingViews.has(target)) {
       this.#pendingViews.set(target, new Map());
     }
-    this.#pendingViews.get(target)!.set(view, fields as ViewFieldsConfig<unknown>);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const generalConfig = fields as unknown as ViewFieldsConfig<unknown>;
+    this.#pendingViews.get(target)!.set(view, generalConfig);
   }
 
   /**
@@ -220,7 +224,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param idx The param index
    * @param config The config to register
    */
-  registerPendingParamFacet(target: Class, prop: string, idx: number, config: Partial<FieldConfig>) {
+  registerPendingParamFacet(target: Class, prop: string, idx: number, config: Partial<FieldConfig>): Class {
     config.index = idx;
     return this.registerPendingFieldFacet(target, `${prop}.${idx}`, config);
   }
@@ -231,11 +235,13 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param prop The property name
    * @param config The config to register
    */
-  registerPendingFieldFacet(target: Class, prop: string, config: Partial<FieldConfig>) {
+  registerPendingFieldFacet(target: Class, prop: string, config: Partial<FieldConfig>): Class {
     const allViewConf = this.getOrCreatePending(target).views![AllViewⲐ];
 
     if (!allViewConf.schema[prop]) {
       allViewConf.fields.push(prop);
+      // Partial config while building
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       allViewConf.schema[prop] = {} as FieldConfig;
     }
 
@@ -252,7 +258,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param type List of types
    * @param conf Extra config
    */
-  registerPendingParamConfig(target: Class, method: string, idx: number, type: ClassList, conf?: Partial<FieldConfig>) {
+  registerPendingParamConfig(target: Class, method: string, idx: number, type: ClassList, conf?: Partial<FieldConfig>): Class {
     conf ??= {};
     conf.index = idx;
     return this.registerPendingFieldConfig(target, `${method}.${idx}`, type, conf);
@@ -265,7 +271,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param type List of types
    * @param conf Extra config
    */
-  registerPendingFieldConfig(target: Class, prop: string, type: ClassList, conf?: Partial<FieldConfig>) {
+  registerPendingFieldConfig(target: Class, prop: string, type: ClassList, conf?: Partial<FieldConfig>): Class {
     const fieldConf: FieldConfig = {
       owner: target,
       name: prop,
@@ -282,14 +288,14 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param dest Target config
    * @param src Source config
    */
-  mergeConfigs(dest: ClassConfig, src: ClassConfig) {
+  mergeConfigs(dest: ClassConfig, src: Partial<ClassConfig>): ClassConfig {
     dest.views[AllViewⲐ] = {
-      schema: { ...dest.views[AllViewⲐ].schema, ...src.views[AllViewⲐ].schema },
-      fields: [...dest.views[AllViewⲐ].fields, ...src.views[AllViewⲐ].fields]
+      schema: { ...dest.views[AllViewⲐ].schema, ...src.views?.[AllViewⲐ].schema },
+      fields: [...dest.views[AllViewⲐ].fields, ...src.views?.[AllViewⲐ].fields ?? []]
     };
     dest.subType = src.subType || dest.subType;
     dest.title = src.title || dest.title;
-    dest.validators = [...src.validators, ...dest.validators];
+    dest.validators = [...src.validators ?? [], ...dest.validators];
     return dest;
   }
 
@@ -298,32 +304,32 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param target The target class
    * @param conf The class config
    */
-  finalizeViews<T>(target: Class<T>, conf: ClassConfig) {
+  finalizeViews<T>(target: Class<T>, conf: ClassConfig): ClassConfig {
     const allViewConf = conf.views![AllViewⲐ];
-    const pending = this.#pendingViews.get(target) ?? new Map<string, ViewFieldsConfig<unknown>>();
+    const pending = this.#pendingViews.get(target) ?? new Map<string, ViewFieldsConfig<string>>();
     this.#pendingViews.delete(target);
 
     for (const [view, fields] of pending.entries()) {
-      const withoutSet = 'without' in fields ? new Set(fields.without as string[]) : undefined;
+      const withoutSet = 'without' in fields ? new Set<string>(fields.without) : undefined;
       const fieldList = withoutSet ?
         allViewConf.fields.filter(x => !withoutSet.has(x)) :
-        ('with' in fields ? fields.with as string[] : []);
+        ('with' in fields ? fields.with : []);
 
       conf.views![view] = {
-        fields: fieldList as string[],
-        schema: fieldList.reduce((acc, v) => {
+        fields: fieldList,
+        schema: fieldList.reduce<SchemaConfig>((acc, v) => {
           acc[v] = allViewConf.schema[v];
           return acc;
-        }, {} as SchemaConfig)
+        }, {})
       };
     }
 
     return conf;
   }
 
-  onInstallFinalize(cls: Class) {
+  onInstallFinalize(cls: Class): ClassConfig {
 
-    let config: ClassConfig = this.createPending(cls) as ClassConfig;
+    let config: ClassConfig = this.createPending(cls);
 
     // Merge parent
     const parent = this.getParentClass(cls);
@@ -339,7 +345,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     // Merge pending, back on top, to allow child to have higher precedence
     const pending = this.getOrCreatePending(cls);
     if (pending) {
-      config = this.mergeConfigs(config, pending as ClassConfig);
+      config = this.mergeConfigs(config, pending);
     }
 
     // Write views out
@@ -348,7 +354,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     return config;
   }
 
-  override onInstall(cls: Class, e: ChangeEvent<Class>) {
+  override onInstall(cls: Class, e: ChangeEvent<Class>): void {
     super.onInstall(cls, e);
 
     if (this.has(cls)) { // Track dependencies of schemas
@@ -356,7 +362,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     }
   }
 
-  override onUninstall<T>(cls: Class<T>, e: ChangeEvent<Class>) {
+  override onUninstall<T>(cls: Class<T>, e: ChangeEvent<Class>): void {
     super.onUninstall(cls, e);
     if (e.type === 'removing' && this.hasExpired(cls)) {
       // Recompute subtypes
@@ -374,7 +380,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     }
   }
 
-  override emit(ev: ChangeEvent<Class>) {
+  override emit(ev: ChangeEvent<Class>): void {
     super.emit(ev);
     if (ev.type === 'changed') {
       SchemaChangeListener.emitFieldChanges({

package/src/service/types.ts

@@ -77,7 +77,7 @@ export interface FieldConfig extends DescribableConfig {
   /**
    * Owner class
    */
-  owner: Class;
+  owner?: Class;
   /**
    * Field name
    */
@@ -112,7 +112,7 @@ export interface FieldConfig extends DescribableConfig {
   /**
    * The numeric precision
    */
-  precision?: [number, number] | [number, undefined];
+  precision?: [number, number | undefined];
   /**
    * Is the field required
    */
@@ -151,4 +151,4 @@ export interface FieldConfig extends DescribableConfig {
   access?: 'readonly' | 'writeonly';
 }
 
-export type ViewFieldsConfig<T> = { with: (keyof T)[] } | { without: (keyof T)[] };
+export type ViewFieldsConfig<T> = { with: Extract<(keyof T), string>[] } | { without: Extract<(keyof T), string>[] };

package/src/typings.d.ts

@@ -17,4 +17,11 @@ declare global {
      */
     interface ReadableStream { }
   }
-}
+}
+
+declare module 'stream' {
+  /**
+   * @concrete stream:Readable:node
+   */
+  interface Readable { }
+}

package/src/validate/error.ts

@@ -20,4 +20,8 @@ export class TypeMismatchError extends AppError {
   constructor(cls: Class | string, type: string) {
     super(`Expected ${typeof cls === 'string' ? cls : cls.name} but found ${type}`, 'data');
   }
+}
+
+export function isValidationError(err: unknown): err is ValidationError {
+  return !!err && err instanceof Error && 'path' in err;
 }

package/src/validate/regexp.ts

@@ -18,7 +18,7 @@ export const CommonRegExp = {
 };
 
 // Rebind regexes
-for (const k of Object.keys(CommonRegExp) as (keyof typeof CommonRegExp)[]) {
+for (const k of Object.keys(CommonRegExp)) {
   CommonRegExp[k].name = `[[:${k}:]]`;
   Messages.set(CommonRegExp[k].name!, Messages.get(k)!);
 }

package/src/validate/types.ts

@@ -1,4 +1,5 @@
-export type ValidationKind = 'required' | 'match' | 'min' | 'max' | 'minlength' | 'maxlength' | 'enum' | 'type' | string;
+export type ValidationKindCore = 'required' | 'match' | 'min' | 'max' | 'minlength' | 'maxlength' | 'enum' | 'type';
+export type ValidationKind = ValidationKindCore | string;
 
 /**
  * Individual Validation Error