@teambit/semantics.entities.semantic-schema 0.0.10 → 0.0.11

package/dist/schemas/type.js.map

@@ -1 +1 @@
-{"version":3,"file":"type.js","sourceRoot":"","sources":["../../schemas/type.ts"],"names":[],"mappings":";;;;;;AAAA,kDAA0B;AAG1B,MAAa,UAAU;IACrB,YAAoB,IAAY,EAAU,IAAgB,EAAU,SAAiB;QAAjE,SAAI,GAAJ,IAAI,CAAQ;QAAU,SAAI,GAAJ,IAAI,CAAY;QAAU,cAAS,GAAT,SAAS,CAAQ;IAAG,CAAC;IACzF,QAAQ;QACN,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;YACtC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAC1B,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC;IACJ,CAAC;IACD,QAAQ;QACN,OAAO,GAAG,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC7D,CAAC;CACF;AAbD,gCAaC"}
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../../schemas/type.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yDAA8C;AAC9C,kDAA0B;AAC1B,gDAAsD;AACtD,gEAA6D;AAE7D,MAAa,UAAW,SAAQ,wBAAU;IAGxC,YAAqB,QAAkB,EAAW,IAAY,EAAE,IAAgB,EAAW,SAAiB;QAC1G,KAAK,EAAE,CAAC;QADW,aAAQ,GAAR,QAAQ,CAAU;QAAW,SAAI,GAAJ,IAAI,CAAQ;QAA6B,cAAS,GAAT,SAAS,CAAQ;QAE1G,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC7D,CAAC;CACF;AATC;IADC,IAAA,6BAAS,EAAC,yCAAmB,CAAC;wCACL;AAF5B,gCAWC"}

package/dist/schemas/variable.d.ts

@@ -1,17 +1,9 @@
-import { SchemaNode } from '../schema-node';
-export declare class VariableSchema implements SchemaNode {
+import { Location, SchemaNode } from '../schema-node';
+export declare class VariableSchema extends SchemaNode {
+    readonly location: Location;
     readonly name: string;
-    private signature;
-    private type;
-    constructor(name: string, signature: string, type: SchemaNode);
-    getSignature(): string;
-    toObject(): {
-        constructorName: string;
-        name: string;
-        signature: string;
-        type: Record<string, any> & {
-            constructorName: string;
-        };
-    };
+    readonly signature: string;
+    type: SchemaNode;
+    constructor(location: Location, name: string, signature: string, type: SchemaNode);
     toString(): string;
 }

package/dist/schemas/variable.js

@@ -1,30 +1,33 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VariableSchema = void 0;
+const class_transformer_1 = require("class-transformer");
 const chalk_1 = __importDefault(require("chalk"));
-class VariableSchema {
-    constructor(name, signature, type) {
+const schema_node_1 = require("../schema-node");
+const schema_obj_to_class_1 = require("../schema-obj-to-class");
+class VariableSchema extends schema_node_1.SchemaNode {
+    constructor(location, name, signature, type) {
+        super();
+        this.location = location;
         this.name = name;
         this.signature = signature;
         this.type = type;
     }
-    getSignature() {
-        return this.signature;
-    }
-    toObject() {
-        return {
-            constructorName: this.constructor.name,
-            name: this.name,
-            signature: this.signature,
-            type: this.type.toObject(),
-        };
-    }
     toString() {
         return `${chalk_1.default.bold(this.name)}: ${this.type.toString()}`;
     }
 }
+__decorate([
+    (0, class_transformer_1.Transform)(schema_obj_to_class_1.schemaObjToInstance)
+], VariableSchema.prototype, "type", void 0);
 exports.VariableSchema = VariableSchema;
 //# sourceMappingURL=variable.js.map

package/dist/schemas/variable.js.map

@@ -1 +1 @@
-{"version":3,"file":"variable.js","sourceRoot":"","sources":["../../schemas/variable.ts"],"names":[],"mappings":";;;;;;AAAA,kDAA0B;AAG1B,MAAa,cAAc;IACzB,YAAqB,IAAY,EAAU,SAAiB,EAAU,IAAgB;QAAjE,SAAI,GAAJ,IAAI,CAAQ;QAAU,cAAS,GAAT,SAAS,CAAQ;QAAU,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAC1F,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,QAAQ;QACN,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;YACtC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;SAC3B,CAAC;IACJ,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC7D,CAAC;CACF;AAlBD,wCAkBC"}
+{"version":3,"file":"variable.js","sourceRoot":"","sources":["../../schemas/variable.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yDAA8C;AAC9C,kDAA0B;AAC1B,gDAAsD;AACtD,gEAA6D;AAE7D,MAAa,cAAe,SAAQ,wBAAU;IAG5C,YAAqB,QAAkB,EAAW,IAAY,EAAW,SAAiB,EAAE,IAAgB;QAC1G,KAAK,EAAE,CAAC;QADW,aAAQ,GAAR,QAAQ,CAAU;QAAW,SAAI,GAAJ,IAAI,CAAQ;QAAW,cAAS,GAAT,SAAS,CAAQ;QAExF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC7D,CAAC;CACF;AATC;IADC,IAAA,6BAAS,EAAC,yCAAmB,CAAC;4CACd;AAFnB,wCAWC"}

package/{schemas/export.ts → export.ts}

@@ -1,20 +1,17 @@
-import { SchemaNode } from '../schema-node';
-
 type Primitive = string | number | boolean | null | undefined;
 export type StaticProperties = Map<string, Primitive>;
 
-export class Export implements SchemaNode {
+/**
+ * @todo: this was implemented before all other schemas and is used only for composition.
+ * it needs to be align with other schemas.
+ */
+export class Export {
   constructor(
     /**
      * named export identifier of the module export.
      */
     readonly identifier: string,
 
-    /**
-     * API node.
-     */
-    readonly nodes?: SchemaNode[],
-
     /**
      * static properties attached to this export
      * @example

package/index.ts

@@ -1,9 +1,8 @@
 export { APISchema } from './api-schema';
+export { Export, StaticProperties } from './export';
 export type { SchemaNode, Location } from './schema-node';
 export {
-  Export,
   Module,
-  StaticProperties,
   FunctionLikeSchema,
   Modifier,
   TypeRefSchema,

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "@teambit/semantics.entities.semantic-schema",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "homepage": "https://bit.dev/teambit/semantics/entities/semantic-schema",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.semantics",
     "name": "entities/semantic-schema",
-    "version": "0.0.10"
+    "version": "0.0.11"
   },
   "dependencies": {
     "chalk": "2.4.2",
-    "json-schema": "0.4.0"
+    "class-transformer": "0.5.1",
+    "json-schema": "0.4.0",
+    "lodash": "4.17.21"
   },
   "devDependencies": {
     "@types/json-schema": "7.0.9",
+    "@types/lodash": "4.14.165",
     "@types/mocha": "9.1.0",
     "@babel/runtime": "7.12.18",
     "@types/node": "12.20.4",

package/{preview-1652757984397.js → preview-1652930732694.js}

@@ -1 +1 @@
-export const overview = [require('/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.semantics_entities_semantic-schema@0.0.10/dist/semantic-schema.docs.md')]
+export const overview = [require('/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.semantics_entities_semantic-schema@0.0.11/dist/semantic-schema.docs.md')]

package/schema-node.ts

@@ -1,13 +1,20 @@
+import { instanceToPlain } from 'class-transformer';
+
 /**
- * an interface for implementing a new schema node.
+ * a convenient abstract class for all schema to extend.
+ * the reason for having it as an abstract class and not an interface, for now, is mostly for the `__schema` prop.
+ * this way it won't need to be implemented in each one of the subclasses.
  */
-export interface SchemaNode {
-  readonly location?: Location;
-  getSignature?(): string;
+export abstract class SchemaNode {
+  readonly __schema = this.constructor.name;
+  abstract readonly location: Location;
+  readonly signature?: string;
 
-  toString(): string;
+  abstract toString(): string;
 
-  toObject(): Record<string, any> & { constructorName: string };
+  toObject() {
+    return instanceToPlain(this);
+  }
 }
 
 export type Location = { file: string; line: number; character: number };

package/schema-obj-to-class.ts

@@ -0,0 +1,36 @@
+import { plainToInstance, TransformationType, ClassConstructor } from 'class-transformer';
+import { compact } from 'lodash';
+import { SchemaNode } from './schema-node';
+import * as Schemas from './schemas';
+
+export function schemaObjArrayToInstances({ value, type }: { value: SchemaNode[]; type: TransformationType }) {
+  if (type !== TransformationType.PLAIN_TO_CLASS) {
+    return value;
+  }
+  return value.map((obj) => transformFromObjectToInstance(obj));
+}
+
+export function schemaObjToInstance({ value, type }: { value: Record<string, any>; type: TransformationType }) {
+  if (type !== TransformationType.PLAIN_TO_CLASS) {
+    return value;
+  }
+  return transformFromObjectToInstance(value);
+}
+
+function transformFromObjectToInstance(obj: Record<string, any>): SchemaNode {
+  if (!obj.__schema) {
+    throw new Error(`fatal: "__schema" is missing, make sure the transformer is set on SchemaNode type`);
+  }
+  const SchemaClass = getClassBySchemaName(obj.__schema);
+  return plainToInstance(SchemaClass, obj);
+}
+
+function getClassBySchemaName(schemaName: string): ClassConstructor<SchemaNode> {
+  const schemasClasses = compact(Object.values(Schemas));
+  const schemaClass = schemasClasses.find((schema) => schema.name === schemaName);
+  if (!schemaClass) {
+    throw new Error(`unable to find schema "${schemaName}". the following schemas are supported:
+${schemasClasses.map((s) => s.name).join(', ')}`);
+  }
+  return schemaClass;
+}

package/schemas/class.ts

@@ -1,15 +1,14 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
 import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class ClassSchema implements SchemaNode {
-  constructor(readonly className: string, readonly members: SchemaNode[], readonly location: Location) {}
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.className,
-      members: this.members.map((member) => member.toObject()),
-    };
+export class ClassSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly members: SchemaNode[];
+  constructor(readonly className: string, members: SchemaNode[], readonly location: Location) {
+    super();
+    this.members = members;
   }
 
   toString() {

package/schemas/constructor.ts

@@ -1,19 +1,19 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 import { ParameterSchema } from './parameter';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class ConstructorSchema implements SchemaNode {
-  constructor(readonly params: ParameterSchema[]) {}
+export class ConstructorSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly params: ParameterSchema[];
+  constructor(readonly location: Location, params: ParameterSchema[]) {
+    super();
+    this.params = params;
+  }
 
   toString() {
     const paramsStr = this.params.map((param) => param.toString()).join(', ');
     return `${chalk.bold('constructor')}(${paramsStr})`;
   }
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      args: this.params.map((arg) => arg.toObject()),
-    };
-  }
 }

package/schemas/function-like.ts

@@ -1,40 +1,37 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
 import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances, schemaObjToInstance } from '../schema-obj-to-class';
 import { ParameterSchema } from './parameter';
 
 export type Modifier = 'static' | 'public' | 'private' | 'protected' | 'readonly' | 'abstract' | 'async' | 'override';
 
-export class FunctionLikeSchema implements SchemaNode {
+export class FunctionLikeSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly returnType: SchemaNode;
+
+  @Transform(schemaObjArrayToInstances)
+  readonly params: ParameterSchema[];
+
   constructor(
+    readonly location: Location,
     readonly name: string,
     // readonly doc: any,
-    readonly params: ParameterSchema[],
+    params: ParameterSchema[],
 
-    readonly returnType: SchemaNode,
+    returnType: SchemaNode,
     readonly signature: string,
-    readonly location: Location,
     readonly modifiers: Modifier[] = []
-  ) {}
-
-  serialize() {}
-
-  toJsonSchema() {}
+  ) {
+    super();
+    this.params = params;
+    this.returnType = returnType;
+  }
 
   getSignature() {
     return this.signature;
   }
 
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      params: this.params,
-      returnType: this.returnType.toObject(),
-      signature: this.signature,
-      modifiers: this.modifiers,
-    };
-  }
-
   toString() {
     const paramsStr = this.params.map((param) => param.toString()).join(', ');
     const modifiersStr = this.modifiers.length ? `${this.modifiers.join(' ')} ` : '';

package/schemas/get-accessor.ts

@@ -1,21 +1,19 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class GetAccessorSchema implements SchemaNode {
-  constructor(private name: string, private type: SchemaNode, private signature: string) {}
+export class GetAccessorSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
+  constructor(readonly location: Location, readonly name: string, type: SchemaNode, readonly signature: string) {
+    super();
+    this.type = type;
+  }
   getSignature() {
     return this.signature;
   }
 
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      type: this.type.toObject(),
-      signature: this.signature,
-    };
-  }
-
   toString() {
     return `get ${chalk.bold(this.name)}(): ${this.type.toString()}`;
   }

package/schemas/index-signature.ts

@@ -1,19 +1,23 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
 import { ParameterSchema } from './parameter';
+import { schemaObjArrayToInstances, schemaObjToInstance } from '../schema-obj-to-class';
 
 /**
  * e.g. `{ [key: string]: boolean };`
  * the "[key: string]" is the "parameter", and the "boolean" is the "type".
  */
-export class IndexSignatureSchema implements SchemaNode {
-  constructor(private params: ParameterSchema[], private type: SchemaNode) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      parameters: this.params,
-      type: this.type.toObject(),
-    };
+export class IndexSignatureSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly params: ParameterSchema[];
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
+  constructor(readonly location: Location, params: ParameterSchema[], type: SchemaNode) {
+    super();
+    this.params = params;
+    this.type = type;
   }
+
   toString() {
     const paramsStr = this.params.map((param) => param.toString()).join(', ');
     return `[${paramsStr}]: ${this.type.toString()}`;

package/schemas/index.ts

@@ -1,5 +1,4 @@
 export { Module } from './module';
-export { Export, StaticProperties } from './export';
 export { FunctionLikeSchema, Modifier } from './function-like';
 export { TypeRefSchema } from './type-ref';
 export { VariableSchema } from './variable';

package/schemas/inference-type.ts

@@ -1,16 +1,11 @@
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 
 /**
  * where there is no explicit type, the type is taken from the "quickinfo" of tsserver
  */
-export class InferenceTypeSchema implements SchemaNode {
-  constructor(private type: string) {}
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      type: this.type,
-    };
+export class InferenceTypeSchema extends SchemaNode {
+  constructor(readonly location: Location, readonly type: string) {
+    super();
   }
 
   toString() {

package/schemas/interface.ts

@@ -1,15 +1,16 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class InterfaceSchema implements SchemaNode {
-  constructor(private name: string, private members: SchemaNode[]) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      types: this.members.map((type) => type.toObject()),
-    };
+export class InterfaceSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly members: SchemaNode[];
+  constructor(readonly location: Location, readonly name: string, members: SchemaNode[]) {
+    super();
+    this.members = members;
   }
+
   toString() {
     const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
     return `${chalk.bold.underline(this.name)}\n${membersStr}`;

package/schemas/keyword-type.ts

@@ -1,16 +1,11 @@
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 
 /**
  * e.g. 'string', 'boolean', etc.
  */
-export class KeywordTypeSchema implements SchemaNode {
-  constructor(private name: string) {}
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-    };
+export class KeywordTypeSchema extends SchemaNode {
+  constructor(readonly location: Location, private name: string) {
+    super();
   }
 
   toString() {

package/schemas/literal-type.ts

@@ -1,10 +1,12 @@
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 
 /**
  * e.g. const a: 'a';
  */
-export class LiteralTypeSchema implements SchemaNode {
-  constructor(private name: string) {}
+export class LiteralTypeSchema extends SchemaNode {
+  constructor(readonly location: Location, readonly name: string) {
+    super();
+  }
 
   toObject() {
     return {

package/schemas/module.ts

@@ -1,13 +1,15 @@
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
-import { Export } from '../schemas';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class Module implements SchemaNode {
+export class Module extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  exports: SchemaNode[];
   namespace?: string;
-  constructor(public exports: SchemaNode[]) {}
-
-  getExportSchemas(): Export[] {
-    return this.exports.filter((e) => e instanceof Export) as Export[];
+  constructor(readonly location: Location, exports: SchemaNode[]) {
+    super();
+    this.exports = exports;
   }
 
   toObject() {

package/schemas/parameter.ts

@@ -1,22 +1,21 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class ParameterSchema implements SchemaNode {
+export class ParameterSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
   constructor(
+    readonly location: Location,
     readonly name: string,
-    readonly type: SchemaNode,
+    type: SchemaNode,
     readonly defaultValue?: any,
     readonly description?: string
-  ) {}
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      type: this.type.toObject(),
-      defaultValue: this.defaultValue,
-      description: this.description,
-    };
+  ) {
+    super();
+    this.type = type;
   }
+
   toString() {
     return `${this.name}: ${this.type.toString()}`;
   }

package/schemas/set-accessor.ts

@@ -1,22 +1,20 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 import { ParameterSchema } from './parameter';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class SetAccessorSchema implements SchemaNode {
-  constructor(private name: string, private param: ParameterSchema, private signature: string) {}
+export class SetAccessorSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly param: ParameterSchema;
+  constructor(readonly location: Location, readonly name: string, param: ParameterSchema, readonly signature: string) {
+    super();
+    this.param = param;
+  }
   getSignature() {
     return this.signature;
   }
 
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      param: this.param,
-      signature: this.signature,
-    };
-  }
-
   toString() {
     return `set ${chalk.bold(this.name)}(${this.param.toString()})`;
   }

package/schemas/tuple-type.ts

@@ -1,13 +1,15 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class TupleTypeSchema implements SchemaNode {
-  constructor(private elements: SchemaNode[]) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      elements: this.elements.map((elem) => elem.toObject()),
-    };
+export class TupleTypeSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly elements: SchemaNode[];
+  constructor(readonly location: Location, elements: SchemaNode[]) {
+    super();
+    this.elements = elements;
   }
+
   toString() {
     return `[${this.elements.map((elem) => elem.toString()).join(', ')}]`;
   }

package/schemas/type-array.ts

@@ -1,13 +1,15 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class TypeArraySchema implements SchemaNode {
-  constructor(private type: SchemaNode) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      type: this.type.toObject(),
-    };
+export class TypeArraySchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
+  constructor(readonly location: Location, type: SchemaNode) {
+    super();
+    this.type = type;
   }
+
   toString() {
     return `${this.type.toString()}[]`;
   }