@travetto/schema 4.1.0 → 5.0.0-rc.0

package/README.md

@@ -379,7 +379,7 @@ Validation Failed {
 ```
 
 ## Data Utilities
-Data utilities for binding values, and type conversion. Currently [DataUtil](https://github.com/travetto/travetto/tree/main/module/schema/src/data.ts#L8) includes:
+Data utilities for binding values, and type conversion. Currently [DataUtil](https://github.com/travetto/travetto/tree/main/module/schema/src/data.ts#L10) includes:
    *  `deepAssign(a, b, mode ?)` which allows for deep assignment of `b` onto `a`, the `mode` determines how aggressive the assignment is, and how flexible it is.  `mode` can have any of the following values:
       *  `loose`, which is the default is the most lenient. It will not error out, and overwrites will always happen
       *  `coerce`, will attempt to force values from `b` to fit the types of `a`, and if it can't it will error out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "4.1.0",
+  "version": "5.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": "^4.1.0"
+    "@travetto/registry": "^5.0.0-rc.0"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^4.1.0"
+    "@travetto/transformer": "^5.0.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/bind-util.ts

@@ -1,4 +1,4 @@
-import { Class, ConcreteClass, TypedObject, ObjectUtil } from '@travetto/base';
+import { Class, ConcreteClass, TypedObject } from '@travetto/base';
 
 import { DataUtil } from './data';
 import { AllViewⲐ } from './internal/types';
@@ -50,7 +50,7 @@ export class BindUtil {
     const out: Record<string, unknown> = {};
     for (const k of Object.keys(obj)) {
       const objK = obj[k];
-      const val = ObjectUtil.isPlainObject(objK) ? this.expandPaths(objK) : objK;
+      const val = DataUtil.isPlainObject(objK) ? this.expandPaths(objK) : objK;
       const parts = k.split('.');
       const last = parts.pop()!;
       let sub = out;
@@ -77,7 +77,7 @@ export class BindUtil {
       const arr = last.indexOf('[') > 0;
 
       if (!arr) {
-        if (sub[last] && ObjectUtil.isPlainObject(val)) {
+        if (sub[last] && DataUtil.isPlainObject(val)) {
           sub[last] = DataUtil.deepAssign(sub[last], val, 'coerce');
         } else {
           sub[last] = val;
@@ -95,7 +95,7 @@ export class BindUtil {
           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           key = arrSub.length as number;
         }
-        if (arrSub[key] && ObjectUtil.isPlainObject(val) && ObjectUtil.isPlainObject(arrSub[key])) {
+        if (arrSub[key] && DataUtil.isPlainObject(val) && DataUtil.isPlainObject(arrSub[key])) {
           arrSub[key] = DataUtil.deepAssign(arrSub[key], val, 'coerce');
         } else {
           arrSub[key] = val;
@@ -114,13 +114,13 @@ export class BindUtil {
     const out: Record<string, V> = {};
     for (const [key, value] of Object.entries(data)) {
       const pre = `${prefix}${key}`;
-      if (ObjectUtil.isPlainObject(value)) {
+      if (DataUtil.isPlainObject(value)) {
         Object.assign(out, this.flattenPaths(value, `${pre}.`)
         );
       } else if (Array.isArray(value)) {
         for (let i = 0; i < value.length; i++) {
           const v = value[i];
-          if (ObjectUtil.isPlainObject(v)) {
+          if (DataUtil.isPlainObject(v)) {
             Object.assign(out, this.flattenPaths(v, `${pre}[${i}].`));
           } else {
             out[`${pre}[${i}]`] = v ?? '';
@@ -179,7 +179,7 @@ export class BindUtil {
     const view = cfg.view ?? AllViewⲐ; // Does not convey
     delete cfg.view;
 
-    if (!!data && !ObjectUtil.isPrimitive(data)) {
+    if (!!data && !DataUtil.isPrimitive(data)) {
       const conf = SchemaRegistry.get(cons);
 
       // If no configuration

package/src/data.ts

@@ -1,4 +1,6 @@
-import { Class, ClassInstance, TypedObject, ObjectUtil } from '@travetto/base';
+import { isNumberObject as isNum, isBooleanObject as isBool, isStringObject as isStr } from 'node:util/types';
+
+import { Class, ClassInstance, TypedObject } from '@travetto/base';
 
 const REGEX_PAT = /[\/](.*)[\/](i|g|m|s)?/;
 
@@ -7,13 +9,44 @@ const REGEX_PAT = /[\/](.*)[\/](i|g|m|s)?/;
  */
 export class DataUtil {
 
+  /**
+   * Is a value a plain JS object, created using {}
+   * @param obj Object to check
+   */
+  static isPlainObject(obj: unknown): obj is Record<string, unknown> {
+    return typeof obj === 'object' // separate from primitives
+      && obj !== undefined
+      && obj !== null         // is obvious
+      && obj.constructor === Object // separate instances (Array, DOM, ...)
+      && Object.prototype.toString.call(obj) === '[object Object]'; // separate build-in like Math
+  }
+
+  /**
+   * Is a value of primitive type
+   * @param el Value to check
+   */
+  static isPrimitive(el: unknown): el is (string | boolean | number | RegExp) {
+    switch (typeof el) {
+      case 'string': case 'boolean': case 'number': case 'bigint': return true;
+      case 'object': return !!el && (el instanceof RegExp || el instanceof Date || isStr(el) || isNum(el) || isBool(el));
+      default: return false;
+    }
+  }
+
+  /**
+   * Is simple, as a primitive, function or class
+   */
+  static isSimpleValue(a: unknown): a is Function | Class | string | number | RegExp | Date {
+    return this.isPrimitive(a) || typeof a === 'function';
+  }
+
   static #deepAssignRaw(a: unknown, b: unknown, mode: 'replace' | 'loose' | 'strict' | 'coerce' = 'loose'): unknown {
     const isEmptyA = a === undefined || a === null;
     const isEmptyB = b === undefined || b === null;
     const isArrA = Array.isArray(a);
     const isArrB = Array.isArray(b);
-    const isSimpA = !isEmptyA && ObjectUtil.isSimple(a);
-    const isSimpB = !isEmptyB && ObjectUtil.isSimple(b);
+    const isSimpA = !isEmptyA && this.isSimpleValue(a);
+    const isSimpB = !isEmptyB && this.isSimpleValue(b);
 
     let ret: unknown;
 
@@ -108,9 +141,15 @@ export class DataUtil {
 
     switch (type) {
       case Date: {
-        const res = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
+        let res: Date | undefined;
+        if (typeof input === 'object' && 'toDate' in input && typeof input.toDate === 'function') {
           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          new Date(parseInt(input as string, 10)) : new Date(input as Date);
+          res = input.toDate() as Date;
+        } else {
+          res = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            new Date(parseInt(input as string, 10)) : new Date(input as Date);
+        }
         if (strict && Number.isNaN(res.getTime())) {
           throw new Error(`Invalid date value: ${input}`);
         }
@@ -148,7 +187,7 @@ export class DataUtil {
         }
       }
       case Object: {
-        if (!strict || ObjectUtil.isPlainObject(input)) {
+        if (!strict || this.isPlainObject(input)) {
           return input;
         } else {
           throw new Error('Invalid object type');
@@ -157,7 +196,7 @@ export class DataUtil {
       case undefined:
       case String: return `${input}`;
     }
-    if (!strict || ObjectUtil.isPlainObject(input)) {
+    if (!strict || this.isPlainObject(input)) {
       return input;
     } else {
       throw new Error(`Unknown type ${type.name}`);
@@ -170,7 +209,7 @@ export class DataUtil {
    */
   static shallowClone<T = unknown>(a: T): T {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (Array.isArray(a) ? a.slice(0) : (ObjectUtil.isSimple(a) ? a : { ...(a as {}) })) as T;
+    return (Array.isArray(a) ? a.slice(0) : (this.isSimpleValue(a) ? a : { ...(a as {}) })) as T;
   }
 
   /**
@@ -180,7 +219,7 @@ export class DataUtil {
    * @param mode How the assignment should be handled
    */
   static deepAssign<T, U>(a: T, b: U, mode: | 'replace' | 'loose' | 'strict' | 'coerce' = 'loose'): T & U {
-    if (!a || ObjectUtil.isSimple(a)) {
+    if (!a || this.isSimpleValue(a)) {
       throw new Error(`Cannot merge onto a simple value, ${a}`);
     }
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions

package/src/service/registry.ts

@@ -411,6 +411,17 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     // Write views out
     config = this.finalizeViews(cls, config);
 
+    if (config.subTypeName && config.subTypeField in config.views[AllViewⲐ].schema) {
+      const field = config.views[AllViewⲐ].schema[config.subTypeField];
+      config.views[AllViewⲐ].schema[config.subTypeField] = {
+        ...field,
+        enum: {
+          values: [config.subTypeName],
+          message: `${config.subTypeField} can only be '${config.subTypeName}'`,
+        }
+      };
+    }
+
     return config;
   }
 

package/src/service/types.ts

@@ -1,4 +1,5 @@
-import { Primitive, Class } from '@travetto/base';
+import { Class } from '@travetto/base';
+import { Primitive } from '@travetto/schema';
 
 import { AllViewⲐ } from '../internal/types';
 import { ValidatorFn } from '../validate/types';

package/src/types.ts

@@ -1,5 +1,7 @@
+export type Primitive = number | bigint | boolean | string | Date;
+
 export type DeepPartial<T> = {
-  [P in keyof T]?: (T[P] extends (number | string | Date | boolean | undefined) ? (T[P] | undefined) :
+  [P in keyof T]?: (T[P] extends (Primitive | undefined) ? (T[P] | undefined) :
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (T[P] extends any[] ? (DeepPartial<T[P][number]> | null | undefined)[] : DeepPartial<T[P]>));
 };

package/src/validate/validator.ts

@@ -1,10 +1,11 @@
-import { Class, ClassInstance, TypedObject, ObjectUtil } from '@travetto/base';
+import { Class, ClassInstance, TypedObject } from '@travetto/base';
 
 import { FieldConfig, SchemaConfig } from '../service/types';
 import { SchemaRegistry } from '../service/registry';
 import { ValidationError, ValidationKindCore, ValidationResult } from './types';
 import { Messages } from './messages';
 import { isValidationError, TypeMismatchError, ValidationResultError } from './error';
+import { DataUtil } from '../data';
 
 /**
  * Get the schema config for Class/Schema config, including support for polymorphism
@@ -268,7 +269,7 @@ export class SchemaValidator {
    */
   static async validate<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    if (!ObjectUtil.isPlainObject(o) && !(o instanceof cls || cls.Ⲑid === (o as ClassInstance<T>).constructor.Ⲑid)) {
+    if (!DataUtil.isPlainObject(o) && !(o instanceof cls || cls.Ⲑid === (o as ClassInstance<T>).constructor.Ⲑid)) {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       throw new TypeMismatchError(cls.name, (o as ClassInstance).constructor.name);
     }