@travetto/schema 8.0.0-alpha.21 → 8.0.0-alpha.23

package/src/type-config.ts

@@ -1,7 +1,7 @@
-import { isUint8Array, isUint16Array, isUint32Array, isArrayBuffer } from 'node:util/types';
 import { Readable } from 'node:stream';
+import { isArrayBuffer, isUint8Array, isUint16Array, isUint32Array } from 'node:util/types';
 
-import { type Class, type BinaryArray, type BinaryType, type BinaryStream, BinaryUtil, toConcrete } from '@travetto/runtime';
+import { type BinaryArray, type BinaryStream, type BinaryType, BinaryUtil, type Class, toConcrete } from '@travetto/runtime';
 
 type SchemaTypeConfig = {
   /**
@@ -40,7 +40,7 @@ export class SchemaTypeUtil {
 
   static register(type: Class | Function, fn: (value: unknown) => boolean): void {
     SchemaTypeUtil.setSchemaTypeConfig(type, {
-      validate: (item: unknown) => fn(item) ? undefined : 'type'
+      validate: (item: unknown) => (fn(item) ? undefined : 'type')
     });
   }
 

package/src/types.ts

@@ -1,8 +1,8 @@
-export class UnknownType { }
+export class UnknownType {}
 
 /**
  * Geometric Point as [number,number] with validation and binding support
  *
  * @concrete ./internal/types.ts#PointContract
  */
-export type Point = [number, number];
+export type Point = [number, number];

package/src/validate/error.ts

@@ -1,4 +1,5 @@
 import { type Class, RuntimeError } from '@travetto/runtime';
+
 import type { ValidationError } from './types.ts';
 
 /**
@@ -24,4 +25,4 @@ export class TypeMismatchError extends RuntimeError {
 
 export function isValidationError(error: unknown): error is ValidationError {
   return !!error && error instanceof Error && 'path' in error;
-}
+}

package/src/validate/messages.ts

@@ -1,18 +1,20 @@
 /**
  * List of validation messages
  */
-export const Messages = new Map<string, string>(Object.entries({
-  default: '{path} is not valid',
-  type: '{path} is not a valid {type}',
-  required: '{path} is required',
-  minlength: '{path} is not long enough ({limit})',
-  maxlength: '{path} is too long ({limit})',
-  match: '{path} should match {regex}',
-  min: '{path} is less than ({limit})',
-  max: '{path} is greater than ({limit})',
-  '[[:telephone:]]': '{path} is not a valid phone number',
-  '[[:url:]]': '{path} is not a valid url',
-  '[[:simpleName:]]': '{path} is not a proper name',
-  '[[:postalCode:]]': '{path} is not a valid postal code',
-  '[[:email:]]': '{path} is not a valid email address'
-}));
+export const Messages = new Map<string, string>(
+  Object.entries({
+    default: '{path} is not valid',
+    type: '{path} is not a valid {type}',
+    required: '{path} is required',
+    minlength: '{path} is not long enough ({limit})',
+    maxlength: '{path} is too long ({limit})',
+    match: '{path} should match {regex}',
+    min: '{path} is less than ({limit})',
+    max: '{path} is greater than ({limit})',
+    '[[:telephone:]]': '{path} is not a valid phone number',
+    '[[:url:]]': '{path} is not a valid url',
+    '[[:simpleName:]]': '{path} is not a proper name',
+    '[[:postalCode:]]': '{path} is not a valid postal code',
+    '[[:email:]]': '{path} is not a valid email address'
+  })
+);

package/src/validate/regex.ts

@@ -3,7 +3,6 @@ import { TypedObject } from '@travetto/runtime';
 /**
  * List of common regular expressions for fields
  */
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export const [CommonRegex, CommonRegexToName] = (() => {
   const regexToName = new Map<RegExp, string>();
   const regexes = {
@@ -19,4 +18,4 @@ export const [CommonRegex, CommonRegexToName] = (() => {
     regexToName.set(regexes[key], name);
   }
   return [regexes, regexToName];
-})();
+})();

package/src/validate/validator.ts

@@ -1,14 +1,14 @@
-import { castKey, castTo, type Class, type ClassInstance, TypedObject } from '@travetto/runtime';
+import { type Class, type ClassInstance, castKey, castTo, TypedObject } from '@travetto/runtime';
 
-import type { SchemaInputConfig, SchemaFieldMap } from '../service/types.ts';
-import type { ValidationError, ValidationKindCore, ValidationResult } from './types.ts';
-import { Messages } from './messages.ts';
-import { isValidationError, TypeMismatchError, ValidationResultError } from './error.ts';
 import { DataUtil } from '../data.ts';
-import { CommonRegexToName } from './regex.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
+import type { SchemaFieldMap, SchemaInputConfig } from '../service/types.ts';
 import { SchemaTypeUtil } from '../type-config.ts';
 import { UnknownType } from '../types.ts';
+import { isValidationError, TypeMismatchError, ValidationResultError } from './error.ts';
+import { Messages } from './messages.ts';
+import { CommonRegexToName } from './regex.ts';
+import type { ValidationError, ValidationKindCore, ValidationResult } from './types.ts';
 
 const PrimitiveTypes = new Set<Function>([String, Number, BigInt, Boolean]);
 type NumericComparable = number | bigint | Date;
@@ -32,7 +32,7 @@ function isRangeValue(value: unknown): value is NumericComparable {
 }
 
 function isLengthValue(value: unknown): value is { length: number } {
-  return (typeof value === 'string' || (typeof value === 'object' && !!value && 'length' in value && typeof value.length === 'number'));
+  return typeof value === 'string' || (typeof value === 'object' && !!value && 'length' in value && typeof value.length === 'number');
 }
 
 /**
@@ -40,7 +40,6 @@ function isLengthValue(value: unknown): value is { length: number } {
  * for errors
  */
 export class SchemaValidator {
-
   /**
    * Validate the schema for a given object
    * @param fields The config to validate against
@@ -51,7 +50,8 @@ export class SchemaValidator {
     let errors: ValidationError[] = [];
 
     for (const [field, fieldConfig] of TypedObject.entries(fields)) {
-      if (fieldConfig.access !== 'readonly') { // Do not validate readonly fields
+      if (fieldConfig.access !== 'readonly') {
+        // Do not validate readonly fields
         errors = errors.concat(this.#validateInputSchema(fieldConfig, item[castKey<T>(field)], relative));
       }
     }
@@ -66,9 +66,14 @@ export class SchemaValidator {
    * @param relative The relative path of object traversal
    */
   static #validateInputSchema(input: SchemaInputConfig, value: unknown, relative: string = ''): ValidationError[] {
-    const key = 'name' in input ? input.name : ('index' in input ? input.index : 'unknown');
+    const key = 'name' in input ? input.name : 'index' in input ? input.index : 'unknown';
     const path = `${relative}${relative ? '.' : ''}${key}`;
-    const hasValue = !(value === undefined || value === null || (typeof value === 'string' && value === '') || (Array.isArray(value) && value.length === 0));
+    const hasValue = !(
+      value === undefined ||
+      value === null ||
+      (typeof value === 'string' && value === '') ||
+      (Array.isArray(value) && value.length === 0)
+    );
 
     if (!hasValue) {
       if (input.required?.active !== false) {
@@ -89,12 +94,12 @@ export class SchemaValidator {
       }
       let errors: ValidationError[] = [];
       if (complex) {
-        for (let i = 0; i < value.length; i++) {
+        for (let i = 0; i < value.length; i += 1) {
           const subErrors = this.#validateFields(resolveFieldMap(type, value[i]), value[i], `${path}[${i}]`);
           errors = errors.concat(subErrors);
         }
       } else {
-        for (let i = 0; i < value.length; i++) {
+        for (let i = 0; i < value.length; i += 1) {
           const subErrors = this.#validateInput(input, value[i]);
           errors.push(...this.#prepareErrors(`${path}[${i}]`, subErrors));
         }
@@ -116,8 +121,8 @@ export class SchemaValidator {
    */
   static #validateRange(input: SchemaInputConfig, key: 'min' | 'max', value: NumericComparable): boolean {
     const config = input[key]!;
-    const parsed = (value instanceof Date ? value.getTime() : value);
-    const boundary = (config.limit instanceof Date) ? config.limit.getTime() : config.limit;
+    const parsed = value instanceof Date ? value.getTime() : value;
+    const boundary = config.limit instanceof Date ? config.limit.getTime() : config.limit;
     return key === 'min' ? parsed < boundary : parsed > boundary;
   }
 
@@ -134,9 +139,12 @@ export class SchemaValidator {
     if (config?.validate) {
       const kind = config.validate(value);
       switch (kind) {
-        case undefined: break;
-        case 'type': return [{ kind, type: input.type.name }];
-        default: return [{ kind, value }];
+        case undefined:
+          break;
+        case 'type':
+          return [{ kind, type: input.type.name }];
+        default:
+          return [{ kind, value }];
       }
     } else if (PrimitiveTypes.has(input.type)) {
       if (typeof value !== input.type.name.toLowerCase()) {
@@ -145,7 +153,8 @@ export class SchemaValidator {
         return [{ kind: 'type', type: 'number' }];
       }
     } else if (SchemaRegistryIndex.has(input.type)) {
-      if (!(value instanceof input.type)) { // If not an instance of the type
+      if (!(value instanceof input.type)) {
+        // If not an instance of the type
         return [{ kind: 'type', type: input.type.name }];
       }
     }
@@ -192,21 +201,16 @@ export class SchemaValidator {
         message: '',
         regex: CommonRegexToName.get(result.regex!) ?? result.regex?.source ?? '',
         path,
-        type: (typeof result.type === 'function' ? result.type.name : result.type)
+        type: typeof result.type === 'function' ? result.type.name : result.type
       };
 
       if (!error.regex) {
         delete error.regex;
       }
 
-      const message = result.message ?? (
-        Messages.get(error.regex ?? '') ??
-        Messages.get(error.kind) ??
-        Messages.get('default')!
-      );
+      const message = result.message ?? Messages.get(error.regex ?? '') ?? Messages.get(error.kind) ?? Messages.get('default')!;
 
-      error.message = message
-        .replace(/\{([^}]+)\}/g, (_, key: (keyof ValidationError)) => `${error[key]}`);
+      error.message = message.replace(/\{([^}]+)\}/g, (_, key: keyof ValidationError) => `${error[key]}`);
 
       out.push(error);
     }
@@ -261,10 +265,7 @@ export class SchemaValidator {
     const fields = SchemaRegistryIndex.get(cls).getFields(view);
 
     // Validate using standard behaviors
-    const errors = [
-      ...this.#validateFields(fields, item, ''),
-      ... await this.#validateClassLevel(cls, item, view)
-    ];
+    const errors = [...this.#validateFields(fields, item, ''), ...(await this.#validateClassLevel(cls, item, view))];
     if (errors.length) {
       throw new ValidationResultError(errors);
     }
@@ -279,8 +280,7 @@ export class SchemaValidator {
    * @param view The view to limit by
    */
   static async validateAll<T>(cls: Class<T>, items: T[], view?: string): Promise<T[]> {
-    return await Promise.all<T>((items ?? [])
-      .map(item => this.validate(cls, item, view)));
+    return await Promise.all<T>((items ?? []).map(item => this.validate(cls, item, view)));
   }
 
   /**
@@ -294,7 +294,8 @@ export class SchemaValidator {
     try {
       await this.validate(cls, item, view);
     } catch (error) {
-      if (error instanceof ValidationResultError) { // Don't check required fields
+      if (error instanceof ValidationResultError) {
+        // Don't check required fields
         const errs = error.details.errors.filter(validationError => validationError.kind !== 'required');
         if (errs.length) {
           error.details.errors = errs;
@@ -318,17 +319,14 @@ export class SchemaValidator {
 
     for (const param of config.parameters) {
       const i = param.index;
-      errors.push(...[
-        ... this.#validateInputSchema(param, params[i]),
-        ... await this.#validateClassLevel(param.type, params[i])
-      ].map(error => {
-        if (param.name && typeof param.name === 'string') {
-          error.path = !prefixes[i] ?
-            error.path.replace(`${param.name}.`, '') :
-            error.path.replace(param.name, prefixes[i]!);
-        }
-        return error;
-      }));
+      errors.push(
+        ...[...this.#validateInputSchema(param, params[i]), ...(await this.#validateClassLevel(param.type, params[i]))].map(error => {
+          if (param.name && typeof param.name === 'string') {
+            error.path = !prefixes[i] ? error.path.replace(`${param.name}.`, '') : error.path.replace(param.name, prefixes[i]!);
+          }
+          return error;
+        })
+      );
     }
     for (const validator of config.validators) {
       const error = await validator(...params);
@@ -344,4 +342,4 @@ export class SchemaValidator {
       throw new ValidationResultError(errors);
     }
   }
-}
+}

package/support/transformer/util.ts

@@ -1,13 +1,19 @@
 import ts from 'typescript';
+
 import {
-  type AnyType, DeclarationUtil, LiteralUtil,
-  DecoratorUtil, DocUtil, type ParamDocumentation, type TransformerState, transformCast,
+  type AnyType,
+  DeclarationUtil,
+  DecoratorUtil,
+  DocUtil,
+  LiteralUtil,
+  type ParamDocumentation,
+  type TransformerState,
+  transformCast
 } from '@travetto/transformer';
 
-export type ComputeConfig = { type?: AnyType, root?: ts.Node, name?: string, index?: number };
+export type ComputeConfig = { type?: AnyType; root?: ts.Node; name?: string; index?: number };
 
 export class SchemaTransformUtil {
-
   static SCHEMA_IMPORT = '@travetto/schema/src/decorator/schema.ts';
   static METHOD_IMPORT = '@travetto/schema/src/decorator/method.ts';
   static FIELD_IMPORT = '@travetto/schema/src/decorator/field.ts';
@@ -21,12 +27,16 @@ export class SchemaTransformUtil {
    */
   static toConcreteType(state: TransformerState, type: AnyType, node: ts.Node, root: ts.Node = node): ts.Expression {
     switch (type.key) {
-      case 'pointer': return this.toConcreteType(state, type.target, node, root);
-      case 'managed': return state.getOrImport(type);
-      case 'tuple': return state.fromLiteral(type.subTypes.map(subType => this.toConcreteType(state, subType, node, root)!));
-      case 'template': return state.createIdentifier(type.ctor.name);
+      case 'pointer':
+        return this.toConcreteType(state, type.target, node, root);
+      case 'managed':
+        return state.getOrImport(type);
+      case 'tuple':
+        return state.fromLiteral(type.subTypes.map(subType => this.toConcreteType(state, subType, node, root)!));
+      case 'template':
+        return state.createIdentifier(type.ctor.name);
       case 'literal': {
-        if ((type.ctor === Array) && type.typeArguments?.length) {
+        if (type.ctor === Array && type.typeArguments?.length) {
           return state.fromLiteral([this.toConcreteType(state, type.typeArguments[0], node, root)]);
         } else if (type.ctor) {
           return state.createIdentifier(type.ctor.name!);
@@ -40,16 +50,20 @@ export class SchemaTransformUtil {
         if (!existing) {
           const cls = state.factory.createClassDeclaration(
             [
-              state.createDecorator(this.SCHEMA_IMPORT, 'Schema', state.fromLiteral({
-
-                description: type.description,
-                mappedOperation: type.operation,
-                mappedFields: type.fields,
-              })),
+              state.createDecorator(
+                this.SCHEMA_IMPORT,
+                'Schema',
+                state.fromLiteral({
+                  description: type.description,
+                  mappedOperation: type.operation,
+                  mappedFields: type.fields
+                })
+              )
             ],
-            id, [], [state.factory.createHeritageClause(
-              ts.SyntaxKind.ExtendsKeyword, [state.factory.createExpressionWithTypeArguments(base, [])]
-            )], []
+            id,
+            [],
+            [state.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [state.factory.createExpressionWithTypeArguments(base, [])])],
+            []
           );
           cls.getText = (): string => `
 class ${uniqueId} extends ${type.mappedClassName} { 
@@ -72,32 +86,43 @@ class ${uniqueId} extends ${type.mappedClassName} {
         if (!existing) {
           const cls = state.factory.createClassDeclaration(
             [
-              state.createDecorator(this.SCHEMA_IMPORT, 'Schema', state.fromLiteral({
-                description: type.description
-              })),
+              state.createDecorator(
+                this.SCHEMA_IMPORT,
+                'Schema',
+                state.fromLiteral({
+                  description: type.description
+                })
+              )
             ],
             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(
-                  [], /\W/.test(key) ? state.factory.createComputedPropertyName(state.fromLiteral(key)) : key,
+            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(
+                  [],
+                  /\W/.test(key) ? state.factory.createComputedPropertyName(state.fromLiteral(key)) : key,
                   value.undefinable || value.nullable ? state.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-                  value.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined, undefined
-                ), { type: value, root })
+                  value.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined,
+                  undefined
+                ),
+                { type: value, root }
               )
+            )
           );
-          cls.getText = (): string => [
-            `class ${uniqueId} {`,
-            ...Object.entries(type.fieldTypes)
-              .map(([key, value]) => `  ${key}${value.nullable ? '?' : ''}: ${value.name};`),
-            '}'
-          ].join('\n');
+          cls.getText = (): string =>
+            [
+              `class ${uniqueId} {`,
+              ...Object.entries(type.fieldTypes).map(([key, value]) => `  ${key}${value.nullable ? '?' : ''}: ${value.name};`),
+              '}'
+            ].join('\n');
           state.addStatements([cls], root || node);
         }
         return id;
@@ -108,7 +133,9 @@ class ${uniqueId} extends ${type.mappedClassName} {
         }
         break;
       }
-      case 'foreign':
+      case 'foreign': {
+        break;
+      }
       default: {
         // Object
       }
@@ -119,27 +146,25 @@ class ${uniqueId} extends ${type.mappedClassName} {
   /**
    * Compute decorator params from property/parameter/getter/setter
    */
-  static computeInputDecoratorParams<T extends ts.PropertyDeclaration | ts.ParameterDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration>(
-    state: TransformerState,
-    node: T,
-    config?: ComputeConfig
-  ): ts.Expression[] {
+  static computeInputDecoratorParams<
+    T extends ts.PropertyDeclaration | ts.ParameterDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration
+  >(state: TransformerState, node: T, config?: ComputeConfig): ts.Expression[] {
     const typeExpr = config?.type ?? state.resolveType(ts.isSetAccessor(node) ? node.parameters[0] : node);
     const attrs: Record<string, string | boolean | object | number | ts.Expression> = {};
 
     if (!ts.isGetAccessorDeclaration(node) && !ts.isSetAccessorDeclaration(node)) {
-      // eslint-disable-next-line no-bitwise
       if ((ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Readonly) > 0) {
         attrs.access = 'readonly';
-      } else if (!!node.questionToken || !!typeExpr.undefinable || !!node.initializer) {
+      } else if (node.questionToken || typeExpr.undefinable || node.initializer) {
         attrs.required = { active: false };
       }
-      if (node.initializer !== undefined && (
-        ts.isLiteralExpression(node.initializer) ||
-        node.initializer.kind === ts.SyntaxKind.TrueKeyword ||
-        node.initializer.kind === ts.SyntaxKind.FalseKeyword ||
-        (ts.isArrayLiteralExpression(node.initializer) && node.initializer.elements.length === 0)
-      )) {
+      if (
+        node.initializer !== undefined &&
+        (ts.isLiteralExpression(node.initializer) ||
+          node.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+          node.initializer.kind === ts.SyntaxKind.FalseKeyword ||
+          (ts.isArrayLiteralExpression(node.initializer) && node.initializer.elements.length === 0))
+      ) {
         attrs.default = node.initializer;
       }
     } else {
@@ -150,12 +175,12 @@ class ${uniqueId} extends ${type.mappedClassName} {
       }
       if (!pair.getter) {
         attrs.access = 'writeonly';
-      } else if (!!typeExpr.undefinable) {
+      } else if (typeExpr.undefinable) {
         attrs.required = { active: false };
       }
     }
 
-    const rawName = node.getSourceFile()?.text ? node.name.getText() ?? undefined : undefined;
+    const rawName = node.getSourceFile()?.text ? (node.name.getText() ?? undefined) : undefined;
     const providedName = config?.name ?? rawName!;
     attrs.name = providedName;
 
@@ -169,7 +194,7 @@ class ${uniqueId} extends ${type.mappedClassName} {
     // If we have a composition type
     if (primaryExpr.key === 'composition') {
       const values = primaryExpr.subTypes
-        .map(subType => subType.key === 'literal' ? subType.value : undefined)
+        .map(subType => (subType.key === 'literal' ? subType.value : undefined))
         .filter(value => value !== undefined && value !== null);
 
       if (values.length === primaryExpr.subTypes.length) {
@@ -189,8 +214,8 @@ class ${uniqueId} extends ${type.mappedClassName} {
 
     if (ts.isParameter(node)) {
       const parentComments = DocUtil.describeDocs(node.parent);
-      const paramComments: Partial<ParamDocumentation> = (parentComments.params ?? [])
-        .find(param => param.name === node.name.getText()) || {};
+      const paramComments: Partial<ParamDocumentation> =
+        (parentComments.params ?? []).find(param => param.name === node.name.getText()) || {};
 
       if (paramComments.description) {
         attrs.description = paramComments.description;
@@ -223,13 +248,19 @@ class ${uniqueId} extends ${type.mappedClassName} {
     }
 
     const resolved = this.toConcreteType(state, typeExpr, node, config?.root ?? node);
-    const type = typeExpr.key === 'foreign' ? state.getConcreteType(node, state.factory.createIdentifier('Object')) :
-      ts.isArrayLiteralExpression(resolved) ? resolved.elements[0] : resolved;
-
-    params.unshift(LiteralUtil.fromLiteral(state.factory, {
-      array: ts.isArrayLiteralExpression(resolved),
-      type
-    }));
+    const type =
+      typeExpr.key === 'foreign'
+        ? state.getConcreteType(node, state.factory.createIdentifier('Object'))
+        : ts.isArrayLiteralExpression(resolved)
+          ? resolved.elements[0]
+          : resolved;
+
+    params.unshift(
+      LiteralUtil.fromLiteral(state.factory, {
+        array: ts.isArrayLiteralExpression(resolved),
+        type
+      })
+    );
 
     if (existing) {
       const args = DecoratorUtil.getArguments(existing) ?? [];
@@ -248,7 +279,9 @@ class ${uniqueId} extends ${type.mappedClassName} {
    * Compute property information from declaration
    */
   static computeInput<T extends ts.PropertyDeclaration | ts.ParameterDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration>(
-    state: TransformerState, node: T, config?: ComputeConfig
+    state: TransformerState,
+    node: T,
+    config?: ComputeConfig
   ): T {
     const existingField = state.findDecorator('@travetto/schema', node, 'Field', this.FIELD_IMPORT);
     const existingInput = state.findDecorator('@travetto/schema', node, 'Input', this.INPUT_IMPORT);
@@ -265,17 +298,21 @@ class ${uniqueId} extends ${type.mappedClassName} {
 
     let result: unknown;
     if (ts.isPropertyDeclaration(node)) {
-      result = state.factory.updatePropertyDeclaration(node,
-        modifiers, node.name, node.questionToken, node.type, node.initializer);
+      result = state.factory.updatePropertyDeclaration(node, modifiers, node.name, node.questionToken, node.type, node.initializer);
     } else if (ts.isParameter(node)) {
-      result = state.factory.updateParameterDeclaration(node,
-        modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
+      result = state.factory.updateParameterDeclaration(
+        node,
+        modifiers,
+        node.dotDotDotToken,
+        node.name,
+        node.questionToken,
+        node.type,
+        node.initializer
+      );
     } else if (ts.isGetAccessorDeclaration(node)) {
-      result = state.factory.updateGetAccessorDeclaration(node,
-        modifiers, node.name, node.parameters, node.type, node.body);
+      result = state.factory.updateGetAccessorDeclaration(node, modifiers, node.name, node.parameters, node.type, node.body);
     } else {
-      result = state.factory.updateSetAccessorDeclaration(node,
-        modifiers, node.name, node.parameters, node.body);
+      result = state.factory.updateSetAccessorDeclaration(node, modifiers, node.name, node.parameters, node.body);
     }
     return transformCast(result);
   }
@@ -283,7 +320,7 @@ class ${uniqueId} extends ${type.mappedClassName} {
   /**
    * Unwrap type
    */
-  static unwrapType(type: AnyType): { out: Record<string, unknown>, type: AnyType } {
+  static unwrapType(type: AnyType): { out: Record<string, unknown>; type: AnyType } {
     const out: Record<string, unknown> = {};
 
     while (type?.key === 'literal' && type.typeArguments?.length) {
@@ -307,15 +344,21 @@ class ${uniqueId} extends ${type.mappedClassName} {
         out.type = state.getForeignTarget(type);
         break;
       }
-      case 'managed': out.type = state.typeToIdentifier(type); break;
-      case 'mapped': out.type = this.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 'managed':
+        out.type = state.typeToIdentifier(type);
+        break;
+      case 'mapped':
+        out.type = this.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 ?
-            this.toConcreteType(state, type, target) :
-            state.factory.createIdentifier(type.ctor.name);
+          out.type = out.array ? this.toConcreteType(state, type, target) : state.factory.createIdentifier(type.ctor.name);
         }
       }
     }
@@ -332,14 +375,16 @@ class ${uniqueId} extends ${type.mappedClassName} {
   static findInnerReturnMethod(state: TransformerState, node: ts.MethodDeclaration, methodName: string): ts.MethodDeclaration | undefined {
     // Process returnType
     const { type } = this.unwrapType(state.resolveReturnType(node));
-    let cls;
+    let cls: ts.Type | ts.ClassDeclaration | undefined;
     switch (type?.key) {
       case 'managed': {
         const [decorator] = DeclarationUtil.getDeclarations(type.original!);
         cls = decorator && ts.isClassDeclaration(decorator) ? decorator : undefined;
         break;
       }
-      case 'shape': cls = type.original; break;
+      case 'shape':
+        cls = type.original;
+        break;
     }
     if (cls) {
       return state.findMethodByName(cls, methodName);
@@ -373,14 +418,10 @@ class ${uniqueId} extends ${type.mappedClassName} {
   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)
-        ]
-      )
+      state.factory.createCallExpression(state.createAccess(bindUtilImport.identifier, 'BindUtil', 'registerAccessor'), undefined, [
+        state.factory.createThis(),
+        state.factory.createStringLiteral(accessorName)
+      ])
     );
   }
-}
+}