@travetto/schema 5.0.14 → 5.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "5.0.14",
+  "version": "5.0.15",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
     "schema",
@@ -27,10 +27,10 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^5.0.14"
+    "@travetto/registry": "^5.0.15"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^5.0.11"
+    "@travetto/transformer": "^5.0.12"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/bind-util.ts

@@ -1,12 +1,12 @@
 import { castTo, Class, classConstruct, asFull, TypedObject, castKey } from '@travetto/runtime';
 
 import { DataUtil } from './data';
-import { AllViewⲐ } from './internal/types';
+import { AllViewSymbol } from './internal/types';
 import { SchemaRegistry } from './service/registry';
 import { FieldConfig } from './service/types';
 
 type BindConfig = {
-  view?: string | typeof AllViewⲐ;
+  view?: string | typeof AllViewSymbol;
   filterField?: (field: FieldConfig) => boolean;
   filterValue?: (value: unknown, field: FieldConfig) => boolean;
 };
@@ -169,7 +169,7 @@ export class BindUtil {
    * @param cfg The bind configuration
    */
   static bindSchemaToObject<T>(cons: Class<T>, obj: T, data?: object, cfg: BindConfig = {}): T {
-    const view = cfg.view ?? AllViewⲐ; // Does not convey
+    const view = cfg.view ?? AllViewSymbol; // Does not convey
     delete cfg.view;
 
     if (!!data && isInstance<T>(data)) {

package/src/decorator/schema.ts

@@ -42,7 +42,6 @@ export function MethodValidator<T extends (...args: Any[]) => Any>(fn: MethodVal
   };
 }
 
-
 /**
  * Register a specific view for a class
  * @param name The name of the view

package/src/global.d.ts

@@ -4,23 +4,11 @@ declare global {
   interface Function {
     /**
      * Will produce a new instance of this class with the provided data bound to it
+     * 
+     * NOTE: Only applies to Schema-based classes, will throw a runtime error otherwise
      * @param data The data to bind
      * @param view The optional view to limit the bind to
      */
     from<T>(this: Class<T>, data: DeepPartial<T>, view?: string): T;
   }
-
-  namespace NodeJS {
-    /**
-     * @concrete node:stream#Readable
-     */
-    interface ReadableStream { }
-  }
-}
-
-declare module 'stream' {
-  /**
-   * @concrete node:stream#Readable
-   */
-  interface Readable { }
-}
+}

package/src/internal/types.ts

@@ -1,2 +1,2 @@
-export const AllViewⲐ: unique symbol = Symbol.for('@travetto/schema:all');
+export const AllViewSymbol: unique symbol = Symbol.for('@travetto/schema:all');
 export class UnknownType { }

package/src/name.ts

@@ -1,7 +1,6 @@
-import { describeFunction } from '@travetto/runtime';
 import { ClassConfig } from './service/types';
 
-const SYN_RE = /(__)(\d+)Ⲑsyn$/;
+const ID_RE = /(\d{1,100})Δ$/;
 
 /**
  * Name resolver, specifically for synthetic types
@@ -10,23 +9,22 @@ export class SchemaNameResolver {
 
   #schemaIdToName = new Map<string, string>();
   #digits: number;
-  #base: number;
 
   constructor(digits = 5) {
     this.#digits = digits;
-    this.#base = 10 ** this.#digits;
   }
 
   getName(schema: ClassConfig): string {
-    const id = schema.class.Ⲑid;
-    if (describeFunction(schema.class)?.synthetic && SYN_RE.test(schema.class.name)) {
+    const cls = schema.class;
+    const id = cls.Ⲑid;
+    if (ID_RE.test(cls.name)) {
       if (!this.#schemaIdToName.has(id)) {
-        const name = schema.class.name.replace(SYN_RE, (_, pref, uid) => `__${(+uid % this.#base).toString().padStart(this.#digits, '0')}`);
+        const name = cls.name.replace(ID_RE, (_, uid) => uid.slice(-this.#digits));
         this.#schemaIdToName.set(id, name);
       }
       return this.#schemaIdToName.get(id)!;
     } else {
-      return schema.class.name.replace('Ⲑsyn', '');
+      return cls.name;
     }
   }
 }

package/src/service/changes.ts

@@ -4,7 +4,7 @@ import { Class } from '@travetto/runtime';
 import { ChangeEvent } from '@travetto/registry';
 
 import { FieldConfig, ClassConfig } from './types';
-import { AllViewⲐ } from '../internal/types';
+import { AllViewSymbol } from '../internal/types';
 
 const id = (c: Class | string): string => typeof c === 'string' ? c : c.Ⲑid;
 
@@ -111,8 +111,8 @@ class $SchemaChangeListener {
    */
   emitFieldChanges({ prev, curr }: ChangeEvent<ClassConfig>): void {
 
-    const prevView = prev?.views[AllViewⲐ] || { fields: [], schema: {} };
-    const currView = curr!.views[AllViewⲐ];
+    const prevView = prev?.views[AllViewSymbol] || { fields: [], schema: {} };
+    const currView = curr!.views[AllViewSymbol];
 
     const prevFields = new Set(prevView.fields);
     const currFields = new Set(currView.fields);
@@ -132,7 +132,7 @@ class $SchemaChangeListener {
     }
 
     // Handle class references changing, but keeping same id
-    const compareTypes = (a: Class, b: Class): boolean => 'Ⲑid' in a ? a.Ⲑid === b.Ⲑid : a === b;
+    const compareTypes = (a: Class, b: Class): boolean => a.Ⲑid ? a.Ⲑid === b.Ⲑid : a === b;
 
     for (const c of currFields) {
       if (prevFields.has(c)) {

package/src/service/registry.ts

@@ -1,9 +1,9 @@
-import { Class, AppError, describeFunction, castTo, classConstruct, asFull, castKey, Any } from '@travetto/runtime';
+import { Class, AppError, describeFunction, castTo, classConstruct, asFull, castKey } from '@travetto/runtime';
 import { MetadataRegistry, RootRegistry, ChangeEvent } from '@travetto/registry';
 
 import { ClassList, FieldConfig, ClassConfig, SchemaConfig, ViewFieldsConfig, ViewConfig, SchemaMethodConfig } from './types';
 import { SchemaChangeListener } from './changes';
-import { AllViewⲐ } from '../internal/types';
+import { AllViewSymbol } from '../internal/types';
 import { MethodValidatorFn } from '../validate/types';
 
 const classToSubTypeName = (cls: Class): string => cls.name
@@ -73,7 +73,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
   ensureInstanceTypeField<T>(cls: Class, o: T): void {
     const schema = this.get(cls);
     const typeField = castKey<T>(schema.subTypeField);
-    if (schema.subTypeName && typeField in schema.views[AllViewⲐ].schema && !o[typeField]) {  // Do we have a type field defined
+    if (schema.subTypeName && typeField in schema.views[AllViewSymbol].schema && !o[typeField]) {  // Do we have a type field defined
       o[typeField] = castTo(schema.subTypeName); // Assign if missing
     }
   }
@@ -149,7 +149,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       this.#subTypes.get(base)!.set(config.subTypeName!, cls);
     }
     if (base !== cls) {
-      while (base && ('Ⲑid' in base)) {
+      while (base && base.Ⲑid) {
         this.#subTypes.get(base)!.set(config.subTypeName!, cls);
         const parent = this.getParentClass(base);
         base = parent ? this.getBaseSchema(parent) : undefined;
@@ -169,7 +169,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     SchemaChangeListener.trackSchemaDependency(curr, cls, path, this.get(cls));
 
     // Read children
-    const view = config.views[AllViewⲐ];
+    const view = config.views[AllViewSymbol];
     for (const k of view.fields) {
       if (this.has(view.schema[k].type) && view.schema[k].type !== cls) {
         this.trackSchemaDependencies(cls, view.schema[k].type, [...path, view.schema[k]]);
@@ -186,7 +186,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       metadata: {},
       methods: {},
       views: {
-        [AllViewⲐ]: {
+        [AllViewSymbol]: {
           schema: {},
           fields: []
         }
@@ -199,8 +199,8 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param cls The class to retrieve the schema for
    * @param view The view name
    */
-  getViewSchema<T>(cls: Class<T>, view?: string | typeof AllViewⲐ): ViewConfig {
-    view = view ?? AllViewⲐ;
+  getViewSchema<T>(cls: Class<T>, view?: string | typeof AllViewSymbol): ViewConfig {
+    view = view ?? AllViewSymbol;
 
     const schema = this.get(cls)!;
     if (!schema) {
@@ -296,7 +296,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param config The config to register
    */
   registerPendingFieldFacet(target: Class, prop: string, config: Partial<FieldConfig>): Class {
-    const allViewConf = this.getOrCreatePending(target).views![AllViewⲐ];
+    const allViewConf = this.getOrCreatePending(target).views![AllViewSymbol];
 
     if (!allViewConf.schema[prop]) {
       allViewConf.fields.push(prop);
@@ -359,9 +359,9 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param src Source config
    */
   mergeConfigs(dest: ClassConfig, src: Partial<ClassConfig>, inherited = false): ClassConfig {
-    dest.views[AllViewⲐ] = {
-      schema: { ...dest.views[AllViewⲐ].schema, ...src.views?.[AllViewⲐ].schema },
-      fields: [...dest.views[AllViewⲐ].fields, ...src.views?.[AllViewⲐ].fields ?? []]
+    dest.views[AllViewSymbol] = {
+      schema: { ...dest.views[AllViewSymbol].schema, ...src.views?.[AllViewSymbol].schema },
+      fields: [...dest.views[AllViewSymbol].fields, ...src.views?.[AllViewSymbol].fields ?? []]
     };
     if (!inherited) {
       dest.baseType = src.baseType ?? dest.baseType;
@@ -381,7 +381,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param conf The class config
    */
   finalizeViews<T>(target: Class<T>, conf: ClassConfig): ClassConfig {
-    const allViewConf = conf.views![AllViewⲐ];
+    const allViewConf = conf.views![AllViewSymbol];
     const pending = this.#pendingViews.get(target) ?? new Map<string, ViewFieldsConfig<string>>();
     this.#pendingViews.delete(target);
 
@@ -427,9 +427,9 @@ 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] = {
+    if (config.subTypeName && config.subTypeField in config.views[AllViewSymbol].schema) {
+      const field = config.views[AllViewSymbol].schema[config.subTypeField];
+      config.views[AllViewSymbol].schema[config.subTypeField] = {
         ...field,
         enum: {
           values: [config.subTypeName],

package/src/service/types.ts

@@ -1,6 +1,6 @@
 import { Any, Class, Primitive } from '@travetto/runtime';
 
-import { AllViewⲐ } from '../internal/types';
+import { AllViewSymbol } from '../internal/types';
 import { MethodValidatorFn, ValidatorFn } from '../validate/types';
 
 export type ClassList = Class | [Class];
@@ -69,7 +69,7 @@ export interface ClassConfig extends DescribableConfig {
   /**
    * List of all views
    */
-  views: Record<string, ViewConfig> & { [AllViewⲐ]: ViewConfig };
+  views: Record<string, ViewConfig> & { [AllViewSymbol]: ViewConfig };
   /**
    * Global validators
    */

package/src/validate/regexp.ts

@@ -1,12 +1,6 @@
 import { TypedObject } from '@travetto/runtime';
 import { Messages } from './messages';
 
-declare global {
-  interface RegExp {
-    name?: string;
-  }
-}
-
 /**
  * List of common regular expressions for fields
  */
@@ -18,8 +12,11 @@ export const CommonRegExp = {
   postalCode: /^\d{5}(?:[-\s]\d{4})?$/
 };
 
+export const CommonRegExpToName = new Map<RegExp, string>();
+
 // Rebind regexes
 for (const k of TypedObject.keys(CommonRegExp)) {
-  CommonRegExp[k].name = `[[:${k}:]]`;
-  Messages.set(CommonRegExp[k].name!, Messages.get(k)!);
+  const name = `[[:${k}:]]`;
+  CommonRegExpToName.set(CommonRegExp[k], name);
+  Messages.set(name, Messages.get(k)!);
 }

package/src/validate/validator.ts

@@ -6,6 +6,7 @@ import { ValidationError, ValidationKindCore, ValidationResult } from './types';
 import { Messages } from './messages';
 import { isValidationError, TypeMismatchError, ValidationResultError } from './error';
 import { DataUtil } from '../data';
+import { CommonRegExpToName } from './regexp';
 
 /**
  * Get the schema config for Class/Schema config, including support for polymorphism
@@ -26,12 +27,6 @@ function isRangeValue(o: unknown): o is number | string | Date {
   return typeof o === 'string' || typeof o === 'number' || o instanceof Date;
 }
 
-declare global {
-  interface RegExp {
-    name?: string;
-  }
-}
-
 /**
  * The schema validator applies the schema constraints to a given object and looks
  * for errors
@@ -195,7 +190,7 @@ export class SchemaValidator {
         kind: res.kind,
         value: res.value,
         message: '',
-        re: res.re?.name ?? res.re?.source ?? '',
+        re: CommonRegExpToName.get(res.re!) ?? res.re?.source ?? '',
         path,
         type: (typeof res.type === 'function' ? res.type.name : res.type)
       };

package/support/transformer/util.ts

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import {
   type AnyType, DeclarationUtil, LiteralUtil,
-  DecoratorUtil, DocUtil, ParamDocumentation, TransformerState, transformCast
+  DecoratorUtil, DocUtil, ParamDocumentation, TransformerState, transformCast,
 } from '@travetto/transformer';
 
 const SCHEMA_MOD = '@travetto/schema/src/decorator/schema';
@@ -33,10 +33,10 @@ export class SchemaTransformUtil {
         return state.createAccess(imp.ident, 'UnknownType');
       }
       case 'shape': {
-        const uniqueId = state.generateUniqueIdentifier(node, type);
+        const uniqueId = state.generateUniqueIdentifier(node, type, 'Δ');
 
         // Build class on the fly
-        const [id, existing] = state.createSyntheticIdentifier(uniqueId);
+        const [id, existing] = state.registerIdentifier(uniqueId);
         if (!existing) {
           const cls = state.factory.createClassDeclaration(
             [
@@ -52,7 +52,7 @@ export class SchemaTransformUtil {
             Object.entries(type.fieldTypes)
               .map(([k, v]) =>
                 this.computeField(state, state.factory.createPropertyDeclaration(
-                  [], k,
+                  [], /\W/.test(k) ? state.factory.createComputedPropertyName(state.fromLiteral(k)) : k,
                   v.undefinable || v.nullable ? state.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
                   v.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined, undefined
                 ), { type: v, root })
@@ -68,7 +68,7 @@ export class SchemaTransformUtil {
         }
         return id;
       }
-      case 'union': {
+      case 'composition': {
         if (type.commonType) {
           return this.toConcreteType(state, type.commonType, node, root);
         }
@@ -127,8 +127,8 @@ 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 (primaryExpr.key === 'union') {
+    // If we have a composition type
+    if (primaryExpr.key === 'composition') {
       const values = primaryExpr.subTypes.map(x => x.key === 'literal' ? x.value : undefined)
         .filter(x => x !== undefined && x !== null);