@travetto/schema 3.1.9 → 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.9",
+  "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.5"
+    "@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/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,18 +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)
+    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)) {
@@ -212,6 +226,7 @@ export class SchemaTransformUtil {
     switch (type?.key) {
       case 'managed': out.type = state.typeToIdentifier(type); 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 ?