@travetto/schema 8.0.0-alpha.2 → 8.0.0-alpha.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "8.0.0-alpha.2",
+  "version": "8.0.0-alpha.20",
   "type": "module",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
@@ -28,10 +28,10 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^8.0.0-alpha.2"
+    "@travetto/registry": "^8.0.0-alpha.19"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^8.0.0-alpha.2"
+    "@travetto/transformer": "^8.0.0-alpha.13"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/bind-util.ts

@@ -20,6 +20,16 @@ function isInstance<T>(value: unknown): value is T {
  */
 export class BindUtil {
 
+  /**
+   * Utility to make a property accessor enumerable at runtime
+   */
+  static registerAccessor(instance: any, property: string): void {
+    Object.defineProperty(instance, property, {
+      ...Object.getOwnPropertyDescriptor(Object.getPrototypeOf(instance), property),
+      enumerable: true
+    });
+  }
+
   /**
    * Coerce a value to match the field config type
    * @param config The field config to coerce to
@@ -153,6 +163,10 @@ export class BindUtil {
       const instance = classConstruct<T & { type?: string }>(resolvedCls);
 
       for (const key of TypedObject.keys(instance)) { // Do not retain undefined fields
+        const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+        if (descriptor?.get) {
+          continue;
+        }
         if (instance[key] === undefined) {
           delete instance[key];
         }
@@ -244,13 +258,6 @@ export class BindUtil {
           }
 
           input[castKey<T>(schemaFieldName)] = castTo(value);
-
-          if (field.accessor) {
-            Object.defineProperty(input, schemaFieldName, {
-              ...adapter.getAccessorDescriptor(schemaFieldName),
-              enumerable: true
-            });
-          }
         }
       }
     }

package/src/service/registry-adapter.ts

@@ -4,7 +4,7 @@ import { RuntimeError, BinaryUtil, castKey, castTo, type Class, describeFunction
 import {
   type SchemaClassConfig, type SchemaMethodConfig, type SchemaFieldConfig,
   type SchemaParameterConfig, type SchemaInputConfig, type SchemaFieldMap, type SchemaCoreConfig,
-  type SchemaBasicType, CONSTRUCTOR_PROPERTY
+  CONSTRUCTOR_PROPERTY
 } from './types.ts';
 
 export type SchemaDiscriminatedInfo = Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>>;
@@ -23,19 +23,13 @@ function assignMetadata<T>(key: symbol, base: SchemaCoreConfig, data: Partial<T>
   return castTo(out);
 }
 
-function combineCore<T extends SchemaCoreConfig>(base: T, config: Partial<T>): T {
-  return safeAssign(base, {
+function combineCore<T extends SchemaCoreConfig>(base: T, config: Partial<T>): Pick<Partial<T>, 'metadata' | 'private' | 'description' | 'examples'> {
+  return {
     ...config.metadata ? { metadata: { ...base.metadata, ...config.metadata } } : {},
     ...config.private ? { private: config.private ?? base.private } : {},
     ...config.description ? { description: config.description || base.description } : {},
     ...config.examples ? { examples: [...(base.examples ?? []), ...(config.examples ?? [])] } : {},
-  });
-}
-
-function ensureBinary<T extends SchemaBasicType>(config?: T): void {
-  if (config?.type) {
-    config.binary = BinaryUtil.isBinaryTypeReference(config.type);
-  }
+  };
 }
 
 function combineInputs<T extends SchemaInputConfig>(base: T, configs: Partial<T>[]): T {
@@ -51,10 +45,9 @@ function combineInputs<T extends SchemaInputConfig>(base: T, configs: Partial<T>
             values: (config.enum?.values ?? base.enum?.values ?? []).toSorted()
           }
         } : {},
+        ...combineCore(base, config)
       });
     }
-    combineCore(base, config);
-    ensureBinary(base);
   }
   return base;
 }
@@ -63,16 +56,15 @@ function combineMethods<T extends SchemaMethodConfig>(base: T, configs: Partial<
   for (const config of configs) {
     safeAssign(base, {
       ...config,
+      ...combineCore(base, config),
       parameters: config.parameters ?? base.parameters,
       validators: [...base.validators, ...(config.validators ?? [])],
     });
-    combineCore(base, config);
     if (config.parameters) {
       for (const param of config.parameters) {
         safeAssign(base.parameters[param.index], param);
       }
     }
-    ensureBinary(config.returnType);
   }
   return base;
 }
@@ -137,11 +129,11 @@ function combineClasses<T extends SchemaClassConfig>(base: T, configs: Partial<T
       ...config,
       ...config.views ? { views: { ...base.views, ...config.views } } : {},
       ...config.validators ? { validators: [...base.validators, ...config.validators] } : {},
+      ...combineCore(base, config),
       interfaces: [...base.interfaces, ...(config.interfaces ?? [])],
       methods: { ...base.methods, ...config.methods },
       fields: { ...base.fields, ...config.fields },
     });
-    combineCore(base, config);
   }
   return base;
 }
@@ -284,6 +276,38 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
 
     for (const method of Object.values(config.methods)) {
       method.parameters = method.parameters.toSorted((a, b) => (a.index! - b.index!));
+      if (method.returnType?.type) {
+        method.returnType.binary = BinaryUtil.isBinaryTypeReference(method.returnType.type);
+      }
+      for (const input of method.parameters) {
+        if (input.type) {
+          input.binary = BinaryUtil.isBinaryTypeReference(input.type);
+        }
+      }
+    }
+
+    // Validate if aliases are duplicated
+    const aliasMap: Record<string, SchemaFieldConfig> = {};
+    for (const field of Object.values(config.fields)) {
+      if (field.type) {
+        field.binary = BinaryUtil.isBinaryTypeReference(field.type);
+      }
+      for (const alias of field.aliases ?? []) {
+        if (alias in aliasMap && aliasMap[alias].name !== field.name) {
+          throw new RuntimeError(
+            `Alias ${alias} has been specified multiple times ${this.#cls.name}#(${field.name},${aliasMap[alias].name})`,
+            {
+              details: {
+                alias,
+                class: this.#cls.name,
+                field1: field.name,
+                field2: aliasMap[alias].name
+              }
+            }
+          );
+        }
+        aliasMap[alias] = field;
+      }
     }
   }
 

package/src/service/types.ts

@@ -232,7 +232,7 @@ export interface SchemaFieldConfig extends SchemaInputConfig {
   /**
    * Is this field a getter or setter
    */
-  accessor?: string;
+  accessor?: boolean;
 }
 
 export type ViewFieldsConfig<T> = { with: Extract<(keyof T), string>[] } | { without: Extract<(keyof T), string>[] };

package/src/validate/validator.ts

@@ -199,13 +199,13 @@ export class SchemaValidator {
         delete error.regex;
       }
 
-      const msg = result.message ?? (
+      const message = result.message ?? (
         Messages.get(error.regex ?? '') ??
         Messages.get(error.kind) ??
         Messages.get('default')!
       );
 
-      error.message = msg
+      error.message = message
         .replace(/\{([^}]+)\}/g, (_, key: (keyof ValidationError)) => `${error[key]}`);
 
       out.push(error);

package/support/transformer/util.ts

@@ -14,6 +14,7 @@ export class SchemaTransformUtil {
   static INPUT_IMPORT = '@travetto/schema/src/decorator/input.ts';
   static COMMON_IMPORT = '@travetto/schema/src/decorator/common.ts';
   static TYPES_IMPORT = '@travetto/schema/src/types.ts';
+  static BIND_UTIL_IMPORT = '@travetto/schema/src/bind-util.ts';
 
   /**
    * Produce concrete type given transformer type
@@ -40,7 +41,8 @@ export class SchemaTransformUtil {
           const cls = state.factory.createClassDeclaration(
             [
               state.createDecorator(this.SCHEMA_IMPORT, 'Schema', state.fromLiteral({
-                description: type.comment,
+
+                description: type.description,
                 mappedOperation: type.operation,
                 mappedFields: type.fields,
               })),
@@ -71,10 +73,16 @@ class ${uniqueId} extends ${type.mappedClassName} {
           const cls = state.factory.createClassDeclaration(
             [
               state.createDecorator(this.SCHEMA_IMPORT, 'Schema', state.fromLiteral({
-                description: type.comment
+                description: type.description
               })),
             ],
-            id, [], [],
+            id,
+            [],
+            type.extendsFrom ? [
+              state.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+                state.factory.createExpressionWithTypeArguments(state.getOrImport(type.extendsFrom), [])
+              ])
+            ] : [],
             Object.entries(type.fieldTypes)
               .map(([key, value]) =>
                 this.computeInput(state, state.factory.createPropertyDeclaration(
@@ -350,13 +358,29 @@ class ${uniqueId} extends ${type.mappedClassName} {
       targetType = returnType.typeArguments[0];
     }
 
-    // TODO: Standardize this using jsdoc
     let innerReturnType: AnyType | undefined;
-    if (targetType.key === 'managed' && targetType.importName.startsWith('@travetto/')) {
-      innerReturnType = state.getApparentTypeOfField(targetType.original!, 'body');
+    if (targetType.key === 'managed' && targetType.innerTypeProperty) {
+      innerReturnType = state.getApparentTypeOfField(targetType.original!, targetType.innerTypeProperty);
     }
 
     const finalReturnType = SchemaTransformUtil.ensureType(state, innerReturnType ?? returnType, node);
     return finalReturnType ? [state.fromLiteral({ returnType: finalReturnType })] : [];
   }
+
+  /**
+   * Helper to create inline defineProperty statement for accessors
+   */
+  static createAccessorDefineProperty(state: TransformerState, accessorName: string): ts.Statement {
+    const bindUtilImport = state.importFile(this.BIND_UTIL_IMPORT);
+    return state.factory.createExpressionStatement(
+      state.factory.createCallExpression(
+        state.createAccess(bindUtilImport.identifier, 'BindUtil', 'registerAccessor'),
+        undefined,
+        [
+          state.factory.createThis(),
+          state.factory.createStringLiteral(accessorName)
+        ]
+      )
+    );
+  }
 }

package/support/transformer.schema.ts

@@ -6,6 +6,7 @@ const CONSTRUCTOR_PROPERTY = 'CONSTRUCTOR';
 const InSchema = Symbol();
 const IsOptIn = Symbol();
 const AccessorsSymbol = Symbol();
+const GettersSymbol = Symbol();
 const AutoEnrollMethods = Symbol();
 
 interface AutoState {
@@ -13,6 +14,7 @@ interface AutoState {
   [IsOptIn]?: boolean;
   [AutoEnrollMethods]?: Set<string>;
   [AccessorsSymbol]?: Set<string>;
+  [GettersSymbol]?: Set<string>;
 }
 
 /**
@@ -64,6 +66,7 @@ export class SchemaTransformer {
    */
   static startSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
     state[AccessorsSymbol] = new Set();
+    state[GettersSymbol] = new Set();
     state[AutoEnrollMethods] = new Set();
     state[InSchema] = true;
 
@@ -90,10 +93,11 @@ export class SchemaTransformer {
     const existing = state.findDecorator(this, node, 'Schema', SchemaTransformUtil.SCHEMA_IMPORT);
     const cons = node.members.find(member => ts.isConstructorDeclaration(member));
 
-    const attrs: Record<string, string | boolean | ts.Expression | number | object | unknown[]> = {};
+    const attrs: Record<string, string | boolean | ts.Expression | number | object | unknown[] | undefined> = {};
 
     if (comments.description) {
       attrs.description = comments.description;
+      attrs.examples = comments.examples;
     }
 
     // Extract all interfaces
@@ -129,9 +133,40 @@ export class SchemaTransformer {
       params = [...params, state.fromLiteral(attrs)];
     }
 
+    let newMembers = node.members;
+    const accessors = state[GettersSymbol] ? [...state[GettersSymbol]] : [];
+    if (accessors.length > 0) {
+      node = DeclarationUtil.ensureConstructor(state.factory, node);
+
+      const accessorStatements = accessors.map(accessorName =>
+        SchemaTransformUtil.createAccessorDefineProperty(state, accessorName)
+      );
+
+      const consIndex = node.members.findIndex(member => ts.isConstructorDeclaration(member));
+      const consNode = node.members[consIndex] as ts.ConstructorDeclaration;
+      const insertIndex = DeclarationUtil.getConstructorInsertIndex(consNode);
+      const newStatements = [
+        ...consNode.body?.statements.slice(0, insertIndex) ?? [],
+        ...accessorStatements,
+        ...consNode.body?.statements.slice(insertIndex) ?? []
+      ];
+      const updatedCons = state.factory.updateConstructorDeclaration(
+        consNode,
+        consNode.modifiers,
+        consNode.parameters,
+        state.factory.createBlock(newStatements, true)
+      );
+      newMembers = ts.factory.createNodeArray([
+        ...node.members.slice(0, consIndex),
+        updatedCons,
+        ...node.members.slice(consIndex + 1)
+      ]);
+    }
+
     delete state[InSchema];
     delete state[IsOptIn];
     delete state[AccessorsSymbol];
+    delete state[GettersSymbol];
     delete state[AutoEnrollMethods];
 
     return state.factory.updateClassDeclaration(
@@ -142,7 +177,7 @@ export class SchemaTransformer {
       node.name,
       node.typeParameters,
       node.heritageClauses,
-      node.members
+      newMembers
     );
   }
 
@@ -200,6 +235,7 @@ export class SchemaTransformer {
     if (this.isInvisible(state, node) || DeclarationUtil.isStatic(node)) {
       return node;
     }
+    state[GettersSymbol]?.add(node.name.getText());
     if (state[AccessorsSymbol]?.has(node.name.getText())) {
       return node;
     } else {