@travetto/schema 3.1.8 → 3.2.0-rc.0

package/README.md

@@ -36,6 +36,7 @@ export class User {
   name: string;
   age: number;
   favoriteFood?: 'pizza' | 'burrito' | 'salad';
+  height?: `${number}${'m' | 'ft'}`;
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "3.1.8",
+  "version": "3.2.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": "^3.1.4"
+    "@travetto/registry": "^3.2.0-rc.0"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^3.1.5"
+    "@travetto/transformer": "^3.2.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

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/service/types.ts

@@ -5,6 +5,9 @@ import { ValidatorFn } from '../validate/types';
 
 export type ClassList = Class | [Class];
 
+type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
+export type TemplateLiteral = { op: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
+
 /**
  * Basic describable configuration
  */
@@ -135,7 +138,7 @@ export interface FieldConfig extends DescribableConfig {
   /**
    * Does the field expect a match
    */
-  match?: { re: RegExp, message?: string };
+  match?: { re: RegExp, message?: string, template?: TemplateLiteral };
   /**
    * Minimum value configuration
    */

package/support/transform-util.ts

@@ -1,5 +1,8 @@
 import ts from 'typescript';
-import { type AnyType, DeclarationUtil, DecoratorUtil, DocUtil, ParamDocumentation, TransformerState } from '@travetto/transformer';
+import {
+  type AnyType, DeclarationUtil, LiteralUtil,
+  DecoratorUtil, DocUtil, ParamDocumentation, TransformerState
+} from '@travetto/transformer';
 
 const SCHEMA_MOD = '@travetto/schema/src/decorator/schema';
 const FIELD_MOD = '@travetto/schema/src/decorator/field';
@@ -15,6 +18,7 @@ export class SchemaTransformUtil {
       case 'pointer': return this.toConcreteType(state, type.target, node, root);
       case 'managed': return state.getOrImport(type);
       case 'tuple': return state.fromLiteral(type.subTypes.map(x => this.toConcreteType(state, x, node, root)!));
+      case 'template': return state.createIdentifier(type.ctor.name);
       case 'literal': {
         if ((type.ctor === Array) && type.typeArguments?.length) {
           return state.fromLiteral([this.toConcreteType(state, type.typeArguments[0], node, root)]);
@@ -108,17 +112,28 @@ export class SchemaTransformUtil {
       ));
     }
 
+    const primaryExpr = typeExpr.key === 'literal' && typeExpr.typeArguments?.[0] ? typeExpr.typeArguments[0] : typeExpr;
+
+    // We need to ensure we aren't being tripped up by the wrapper for arrays, sets, etc.
     // 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);
+    if (primaryExpr.key === 'union') {
+      const values = primaryExpr.subTypes.map(x => x.key === 'literal' ? x.value : undefined)
+        .filter(x => x !== undefined && x !== null)
+        .sort();
 
-      if (values.length === typeExpr.subTypes.length) {
+      if (values.length === primaryExpr.subTypes.length) {
         attrs.push(state.factory.createPropertyAssignment('enum', state.fromLiteral({
           values,
           message: `{path} is only allowed to be "${values.join('" or "')}"`
         })));
       }
+    } else if (primaryExpr.key === 'template' && primaryExpr.template) {
+      const re = LiteralUtil.templateLiteralToRegex(primaryExpr.template);
+      attrs.push(state.factory.createPropertyAssignment('match', state.fromLiteral({
+        re: new RegExp(re),
+        template: primaryExpr.template,
+        message: `{path} must match "${re}"`
+      })));
     }
 
     if (ts.isParameter(node)) {
@@ -210,11 +225,12 @@ 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 'template': out.type = state.factory.createIdentifier(type.ctor.name); 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);
         }
       }