@travetto/schema 3.1.7 → 3.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "3.1.7",
+  "version": "3.1.9",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
     "schema",
@@ -27,7 +27,7 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^3.1.4"
+    "@travetto/registry": "^3.1.5"
   },
   "peerDependencies": {
     "@travetto/transformer": "^3.1.5"

package/src/bind-util.ts

@@ -55,10 +55,10 @@ export class BindUtil {
       let sub = out;
       while (parts.length > 0) {
         const part = parts.shift()!;
-        const arr = part.indexOf('[') > 0;
+        const partArr = part.indexOf('[') > 0;
         const name = part.split(/[^A-Za-z_0-9]/)[0];
-        const idx = arr ? part.split(/[\[\]]/)[1] : '';
-        const key = arr ? (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined)) : undefined;
+        const idx = partArr ? part.split(/[\[\]]/)[1] : '';
+        const key = partArr ? (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined)) : undefined;
 
         if (!(name in sub)) {
           sub[name] = typeof key === 'number' ? [] : {};
@@ -73,31 +73,31 @@ export class BindUtil {
         }
       }
 
-      if (last.indexOf('[') < 0) {
+      const arr = last.indexOf('[') > 0;
+
+      if (!arr) {
         if (sub[last] && ObjectUtil.isPlainObject(val)) {
           sub[last] = DataUtil.deepAssign(sub[last], val, 'coerce');
         } else {
           sub[last] = val;
         }
       } else {
-        const arr = last.indexOf('[') > 0;
         const name = last.split(/[^A-Za-z_0-9]/)[0];
-        const idx = arr ? last.split(/[\[\]]/)[1] : '';
+        const idx = last.split(/[\[\]]/)[1];
+
+        let key = (/^\d+$/.test(idx) ? parseInt(idx, 10) : (idx.trim() || undefined));
+        sub[name] ??= (typeof key === 'string') ? {} : [];
 
-        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
+        const arrSub = sub[name] as Record<string, unknown>;
+        if (key === undefined) {
           // 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] && ObjectUtil.isPlainObject(val) && ObjectUtil.isPlainObject(sub[key])) {
-            sub[key] = DataUtil.deepAssign(sub[key], val, 'coerce');
-          } else {
-            sub[key] = val;
-          }
+          key = arrSub.length as number;
+        }
+        if (arrSub[key] && ObjectUtil.isPlainObject(val) && ObjectUtil.isPlainObject(arrSub[key])) {
+          arrSub[key] = DataUtil.deepAssign(arrSub[key], val, 'coerce');
+        } else {
+          arrSub[key] = val;
         }
       }
     }
@@ -109,8 +109,8 @@ 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 = ''): Record<string, unknown> {
-    const out: Record<string, unknown> = {};
+  static flattenPaths<V extends string = string>(data: Record<string, unknown>, prefix: string = ''): Record<string, V> {
+    const out: Record<string, V> = {};
     for (const [key, value] of Object.entries(data)) {
       const pre = `${prefix}${key}`;
       if (ObjectUtil.isPlainObject(value)) {
@@ -126,7 +126,8 @@ export class BindUtil {
           }
         }
       } else {
-        out[pre] = value ?? '';
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        out[pre] = (value ?? '') as V;
       }
     }
     return out;
@@ -273,6 +274,9 @@ export class BindUtil {
     if ((val === undefined || val === null) && applyDefaults) {
       val = field.default;
     }
+    if (!field.required && (val === undefined || val === null)) {
+      return val;
+    }
     const complex = SchemaRegistry.has(field.type);
     if (field.array) {
       const valArr = !Array.isArray(val) ? [val] : val;

package/src/validate/validator.ts

@@ -56,8 +56,16 @@ export class SchemaValidator {
    * @param relative The relative path of object traversal
    */
   static #validateFieldSchema(fieldSchema: FieldConfig, val: unknown, relative: string = ''): ValidationError[] {
-    const path = `${relative}${relative && '.'}${fieldSchema.name}`;
+    return this.#validateFieldSchemaRaw(fieldSchema, val, `${relative}${relative ? '.' : ''}${fieldSchema.name}`);
+  }
 
+  /**
+   * Validate a single field config against a passed in value
+   * @param fieldSchema The field schema configuration
+   * @param val The raw value, could be an array or not
+   * @param path The current path of validation traversal
+   */
+  static #validateFieldSchemaRaw(fieldSchema: FieldConfig, val: unknown, path: string = ''): ValidationError[] {
     const hasValue = !(val === undefined || val === null || (typeof val === 'string' && val === '') || (Array.isArray(val) && val.length === 0));
 
     if (!hasValue) {
@@ -316,10 +324,10 @@ export class SchemaValidator {
    * @param method The method being invoked
    * @param params The params to validate
    */
-  static async validateMethod<T>(cls: Class<T>, method: string, params: unknown[]): Promise<void> {
+  static async validateMethod<T>(cls: Class<T>, method: string, params: unknown[], prefixes: (string | undefined)[] = []): Promise<void> {
     const errors: ValidationError[] = [];
     for (const field of SchemaRegistry.getMethodSchema(cls, method)) {
-      errors.push(...this.#validateFieldSchema(field, params[field.index!]));
+      errors.push(...this.#validateFieldSchemaRaw(field, params[field.index!], prefixes[field.index!]));
     }
     if (errors.length) {
       throw new ValidationResultError(errors);

package/support/transform-util.ts

@@ -111,7 +111,8 @@ export class SchemaTransformUtil {
     // If we have a union type
     if (typeExpr.key === 'union') {
       const values = typeExpr.subTypes.map(x => x.key === 'literal' ? x.value : undefined)
-        .filter(x => x !== undefined && x !== null);
+        .filter(x => x !== undefined && x !== null)
+        .sort();
 
       if (values.length === typeExpr.subTypes.length) {
         attrs.push(state.factory.createPropertyAssignment('enum', state.fromLiteral({
@@ -210,11 +211,11 @@ export class SchemaTransformUtil {
     const { out, type } = this.unwrapType(anyType);
     switch (type?.key) {
       case 'managed': out.type = state.typeToIdentifier(type); break;
-      case 'shape': out.type = SchemaTransformUtil.toConcreteType(state, type, target); break;
+      case 'shape': out.type = this.toConcreteType(state, type, target); break;
       case 'literal': {
         if (type.ctor) {
           out.type = out.array ?
-            SchemaTransformUtil.toConcreteType(state, type, target) :
+            this.toConcreteType(state, type, target) :
             state.factory.createIdentifier(type.ctor.name);
         }
       }