@teambit/semantics.entities.semantic-schema 0.0.53 → 0.0.56

package/dist/schemas/variable-like.d.ts

@@ -1,15 +1,41 @@
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 import { DocSchema } from './docs';
 /**
  * can be also a property or property-signature
  */
 export declare class VariableLikeSchema extends SchemaNode {
-    readonly location: Location;
+    readonly location: SchemaLocation;
     readonly name: string;
     readonly signature: string;
     readonly isOptional: boolean;
+    readonly defaultValue?: string;
     type: SchemaNode;
     readonly doc?: DocSchema;
-    constructor(location: Location, name: string, signature: string, type: SchemaNode, isOptional: boolean, doc?: DocSchema);
+    constructor(location: SchemaLocation, name: string, signature: string, type: SchemaNode, isOptional: boolean, doc?: DocSchema, defaultValue?: string);
+    getNodes(): SchemaNode[];
     toString(): string;
+    toObject(): {
+        name: string;
+        signature: string;
+        type: Record<string, any>;
+        isOptional: boolean;
+        doc: {
+            __schema: string;
+            name: string;
+            location: SchemaLocation;
+            signature: string;
+            raw: string;
+            comment: string;
+            tags: {
+                __schema: string;
+                location: SchemaLocation;
+                name: string;
+                signature: string;
+                tagName: string;
+                comment: string;
+            }[];
+        };
+        defaultValue: string;
+    };
+    static fromObject(obj: Record<string, any>): VariableLikeSchema;
 }

package/dist/schemas/variable-like.js

@@ -1,41 +1,47 @@
 "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.VariableLikeSchema = void 0;
-const class_transformer_1 = require("class-transformer");
 const chalk_1 = __importDefault(require("chalk"));
 const schema_node_1 = require("../schema-node");
-const class_transformers_1 = require("../class-transformers");
+const docs_1 = require("./docs");
+const schema_registry_1 = require("../schema-registry");
 /**
  * can be also a property or property-signature
  */
 class VariableLikeSchema extends schema_node_1.SchemaNode {
-    constructor(location, name, signature, type, isOptional, doc) {
+    constructor(location, name, signature, type, isOptional, doc, defaultValue) {
         super();
         this.location = location;
         this.name = name;
         this.signature = signature;
         this.isOptional = isOptional;
+        this.defaultValue = defaultValue;
         this.type = type;
         this.doc = doc;
     }
+    getNodes() {
+        return [this.type];
+    }
     toString() {
         return `${chalk_1.default.bold(this.name)}${this.isOptional ? '?' : ''}: ${this.type.toString()}`;
     }
+    toObject() {
+        var _a;
+        return Object.assign(Object.assign({}, super.toObject()), { name: this.name, signature: this.signature, type: this.type.toObject(), isOptional: this.isOptional, doc: (_a = this.doc) === null || _a === void 0 ? void 0 : _a.toObject(), defaultValue: this.defaultValue });
+    }
+    static fromObject(obj) {
+        const location = obj.location;
+        const name = obj.name;
+        const signature = obj.signature;
+        const type = schema_registry_1.SchemaRegistry.fromObject(obj.type);
+        const isOptional = obj.isOptional;
+        const doc = obj.doc ? docs_1.DocSchema.fromObject(obj.doc) : undefined;
+        const defaultValue = obj.defaultValue;
+        return new VariableLikeSchema(location, name, signature, type, isOptional, doc, defaultValue);
+    }
 }
-__decorate([
-    (0, class_transformer_1.Transform)(class_transformers_1.schemaObjToInstance)
-], VariableLikeSchema.prototype, "type", void 0);
-__decorate([
-    (0, class_transformer_1.Transform)(class_transformers_1.schemaObjToInstance)
-], VariableLikeSchema.prototype, "doc", void 0);
 exports.VariableLikeSchema = VariableLikeSchema;
 //# sourceMappingURL=variable-like.js.map

package/dist/schemas/variable-like.js.map

@@ -1 +1 @@
-{"version":3,"file":"variable-like.js","sourceRoot":"","sources":["../../schemas/variable-like.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yDAA8C;AAC9C,kDAA0B;AAC1B,gDAAsD;AACtD,8DAA4D;AAG5D;;GAEG;AACH,MAAa,kBAAmB,SAAQ,wBAAU;IAMhD,YACW,QAAkB,EAClB,IAAY,EACZ,SAAiB,EAC1B,IAAgB,EACP,UAAmB,EAC5B,GAAe;QAEf,KAAK,EAAE,CAAC;QAPC,aAAQ,GAAR,QAAQ,CAAU;QAClB,SAAI,GAAJ,IAAI,CAAQ;QACZ,cAAS,GAAT,SAAS,CAAQ;QAEjB,eAAU,GAAV,UAAU,CAAS;QAI5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC1F,CAAC;CACF;AApBC;IADC,IAAA,6BAAS,EAAC,wCAAmB,CAAC;gDACd;AAGjB;IADC,IAAA,6BAAS,EAAC,wCAAmB,CAAC;+CACN;AAL3B,gDAsBC"}
+{"version":3,"file":"variable-like.js","sourceRoot":"","sources":["../../schemas/variable-like.ts"],"names":[],"mappings":";;;;;;AAAA,kDAA0B;AAC1B,gDAA4D;AAC5D,iCAAmC;AACnC,wDAAoD;AAEpD;;GAEG;AACH,MAAa,kBAAmB,SAAQ,wBAAU;IAIhD,YACW,QAAwB,EACxB,IAAY,EACZ,SAAiB,EAC1B,IAAgB,EACP,UAAmB,EAC5B,GAAe,EACN,YAAqB;QAE9B,KAAK,EAAE,CAAC;QARC,aAAQ,GAAR,QAAQ,CAAgB;QACxB,SAAI,GAAJ,IAAI,CAAQ;QACZ,cAAS,GAAT,SAAS,CAAQ;QAEjB,eAAU,GAAV,UAAU,CAAS;QAEnB,iBAAY,GAAZ,YAAY,CAAS;QAG9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,QAAQ;QACN,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrB,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC1F,CAAC;IAED,QAAQ;;QACN,uCACK,KAAK,CAAC,QAAQ,EAAE,KACnB,IAAI,EAAE,IAAI,CAAC,IAAI,EACf,SAAS,EAAE,IAAI,CAAC,SAAS,EACzB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAC1B,UAAU,EAAE,IAAI,CAAC,UAAU,EAC3B,GAAG,EAAE,MAAA,IAAI,CAAC,GAAG,0CAAE,QAAQ,EAAE,EACzB,YAAY,EAAE,IAAI,CAAC,YAAY,IAC/B;IACJ,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,GAAwB;QACxC,MAAM,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC;QAC9B,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;QACtB,MAAM,SAAS,GAAG,GAAG,CAAC,SAAS,CAAC;QAChC,MAAM,IAAI,GAAG,gCAAc,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjD,MAAM,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;QAClC,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,gBAAS,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAChE,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,CAAC;QACtC,OAAO,IAAI,kBAAkB,CAAC,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC;IAChG,CAAC;CACF;AAhDD,gDAgDC"}

package/dist/unknown-schema-factory.d.ts

@@ -0,0 +1,4 @@
+import { SchemaLocation } from './schema-node';
+export declare class UnknownSchemaFactory {
+    static create(location: SchemaLocation, name: string, schemaObj: Record<string, any>): any;
+}

package/dist/unknown-schema-factory.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownSchemaFactory = void 0;
+class UnknownSchemaFactory {
+    static create(location, name, schemaObj) {
+        // dynamic require() to import UnknownSchema at runtime when it's needed, which breaks the circular dependency.
+        // eslint-disable-next-line global-require
+        const { UnknownSchema } = require('./schemas/unknown-schema');
+        return new UnknownSchema(location, name, schemaObj);
+    }
+}
+exports.UnknownSchemaFactory = UnknownSchemaFactory;
+//# sourceMappingURL=unknown-schema-factory.js.map

package/dist/unknown-schema-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-schema-factory.js","sourceRoot":"","sources":["../unknown-schema-factory.ts"],"names":[],"mappings":";;;AAEA,MAAa,oBAAoB;IAC/B,MAAM,CAAC,MAAM,CAAC,QAAwB,EAAE,IAAY,EAAE,SAA8B;QAClF,+GAA+G;QAC/G,0CAA0C;QAC1C,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;QAC9D,OAAO,IAAI,aAAa,CAAC,QAAQ,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;CACF;AAPD,oDAOC"}

package/index.ts

@@ -1,5 +1,13 @@
+import * as Schemas from './schemas';
+
+export { SchemaNode, ISchemaNode } from './schema-node';
 export { APISchema } from './api-schema';
 export { Export, StaticProperties } from './export';
-export type { SchemaNode, Location } from './schema-node';
-export * from './schemas';
+export type { SchemaLocation as Location } from './schema-node';
 export { TagName } from './schemas/docs/tag';
+export { SchemaRegistry } from './schema-registry';
+export { SchemaNodeConstructor } from './schema-node-constructor';
+export { Modifier } from './schemas/function-like';
+export { Schemas };
+
+export * from './schemas';

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@teambit/semantics.entities.semantic-schema",
-  "version": "0.0.53",
-  "homepage": "https://bit.dev/teambit/semantics/entities/semantic-schema",
+  "version": "0.0.56",
+  "homepage": "https://bit.cloud/teambit/semantics/entities/semantic-schema",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.semantics",
     "name": "entities/semantic-schema",
-    "version": "0.0.53"
+    "version": "0.0.56"
   },
   "dependencies": {
     "chalk": "2.4.2",
-    "class-transformer": "0.5.1",
     "lodash": "4.17.21",
     "@teambit/component-id": "0.0.427"
   },

package/schema-node-constructor.ts

@@ -0,0 +1,8 @@
+import { SchemaNode } from './schema-node';
+
+export interface SchemaNodeConstructor {
+  new (...args: any[]): SchemaNode;
+  readonly prototype: SchemaNode;
+  name: string;
+  fromObject(obj: Record<string, any>): SchemaNode;
+}

package/schema-node.ts

@@ -1,26 +1,82 @@
-import { instanceToPlain } from 'class-transformer';
+import { pickBy } from 'lodash';
 import { DocSchema } from './schemas';
 
+export interface ISchemaNode {
+  __schema: string;
+  location: SchemaLocation;
+  doc?: DocSchema;
+  signature?: string;
+  name?: string;
+  toObject(): Record<string, any>;
+  toString(): string;
+  getNodes(): SchemaNode[];
+  findNode(predicate: (node: SchemaNode) => boolean, visitedNodes?: Set<SchemaNode>): SchemaNode | undefined;
+  getAllNodesRecursively(visitedNodes?: Set<SchemaNode>): SchemaNode[];
+}
+
 /**
  * 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 abstract class SchemaNode {
+export abstract class SchemaNode implements ISchemaNode {
   readonly __schema = this.constructor.name;
-  abstract readonly location: Location;
+  abstract readonly location: SchemaLocation;
   readonly doc?: DocSchema;
   readonly signature?: string;
   readonly name?: string;
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static fromObject(obj: Record<string, any>): SchemaNode {
+    throw new Error(`Method 'fromObject' not implemented in subclass.`);
+  }
+
+  toObject(): Record<string, any> {
+    return pickBy(
+      {
+        __schema: this.__schema,
+        location: this.location,
+        doc: this.doc ? this.doc.toObject() : undefined,
+        signature: this.signature,
+        name: this.name,
+      },
+      (v) => v !== undefined
+    );
+  }
+
   abstract toString(): string;
 
-  toObject() {
-    return instanceToPlain(this);
+  getNodes(): SchemaNode[] {
+    return [this];
+  }
+
+  getAllNodesRecursively(visitedNodes = new Set<SchemaNode>()): SchemaNode[] {
+    if (visitedNodes.has(this)) {
+      return [];
+    }
+
+    visitedNodes.add(this);
+
+    const nodes = this.getNodes();
+    return [this, ...nodes.flatMap((node) => node.getAllNodesRecursively(visitedNodes))];
+  }
+
+  findNode(predicate: (node: SchemaNode) => boolean, visitedNodes = new Set<SchemaNode>()): SchemaNode | undefined {
+    if (predicate(this)) return this;
+    if (visitedNodes.has(this)) return undefined;
+
+    visitedNodes.add(this);
+
+    for (const child of this.getNodes()) {
+      const foundNode = child.findNode(predicate, visitedNodes);
+      if (foundNode) return foundNode;
+    }
+
+    return undefined;
   }
 }
 
-export type Location = {
+export type SchemaLocation = {
   /**
    * file-path relative to the component root-dir. normalized to Linux.
    */

package/schema-registry.ts

@@ -0,0 +1,33 @@
+import { SchemaNodeConstructor } from './schema-node-constructor';
+import { UnknownSchemaFactory } from './unknown-schema-factory';
+
+export class SchemaRegistry {
+  private static instance = new SchemaRegistry();
+  private _schemas: Record<string, SchemaNodeConstructor>;
+
+  private constructor() {
+    this._schemas = {};
+  }
+
+  static register(schema: SchemaNodeConstructor) {
+    if (this.instance._schemas[schema.name]) return;
+    this.instance._schemas[schema.name] = schema;
+  }
+
+  static schemas() {
+    return this.instance._schemas;
+  }
+
+  static fromObject(obj: Record<string, any>) {
+    if (!obj.__schema) {
+      throw new Error(`fatal: "__schema" is missing, make sure the transformer is set on SchemaNode type`);
+    }
+
+    const SchemaClass = this.instance._schemas[obj.__schema];
+    if (!SchemaClass) {
+      // for backward and forward compatibility, to not break the users, it's better to return an unknown schema than throwing.
+      return UnknownSchemaFactory.create(obj.location || { path: '', line: 0, character: 0 }, obj.__schema, obj);
+    }
+    return SchemaClass.fromObject(obj);
+  }
+}

package/schemas/class.ts

@@ -1,21 +1,17 @@
-import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjArrayToInstances, schemaObjToInstance } from '../class-transformers';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 import { DocSchema } from './docs';
 import { ExpressionWithTypeArgumentsSchema } from './expression-with-arguments';
+import { SchemaRegistry } from '../schema-registry';
 
 export class ClassSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   readonly members: SchemaNode[];
-
-  @Transform(schemaObjToInstance)
   readonly doc?: DocSchema;
 
   constructor(
     readonly name: string,
     members: SchemaNode[],
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly signature: string,
     doc?: DocSchema,
     readonly typeParams?: string[],
@@ -27,8 +23,37 @@ export class ClassSchema extends SchemaNode {
     this.doc = doc;
   }
 
+  getNodes() {
+    return this.members;
+  }
+
   toString() {
     const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
     return `${chalk.bold.underline(this.name)}\n${membersStr}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      members: this.members.map((member) => member.toObject()),
+      doc: this.doc?.toObject(),
+      signature: this.signature,
+      typeParams: this.typeParams,
+      extendsNodes: this.extendsNodes?.map((node) => node.toObject()),
+      implementNodes: this.implementNodes?.map((node) => node.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ClassSchema {
+    const name = obj.name;
+    const members = obj.members.map((member: any) => SchemaRegistry.fromObject(member));
+    const location = obj.location;
+    const signature = obj.signature;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    const typeParams = obj.typeParams;
+    const extendsNodes = obj.extendsNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));
+    const implementNodes = obj.implementNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));
+    return new ClassSchema(name, members, location, signature, doc, typeParams, extendsNodes, implementNodes);
+  }
 }

package/schemas/conditional-type.ts

@@ -1,25 +1,18 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjToInstance } from '../class-transformers';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 
 /**
  * e.g. `T extends U ? Y : N`
  *
  */
 export class ConditionalTypeSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly checkType: SchemaNode;
-
-  @Transform(schemaObjToInstance)
   readonly extendsType: SchemaNode;
-
-  @Transform(schemaObjToInstance)
   readonly trueType: SchemaNode;
-
-  @Transform(schemaObjToInstance)
   readonly falseType: SchemaNode;
+
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     checkType: SchemaNode,
     extendsType: SchemaNode,
     trueType: SchemaNode,
@@ -32,7 +25,30 @@ export class ConditionalTypeSchema extends SchemaNode {
     this.falseType = falseType;
   }
 
+  getNodes() {
+    return [this.checkType, this.extendsType, this.trueType, this.falseType];
+  }
+
   toString() {
     return `${this.checkType.toString()} extends ${this.extendsType.toString()} ? ${this.trueType.toString()} : ${this.falseType.toString()}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      checkType: this.checkType.toObject(),
+      extendsType: this.extendsType.toObject(),
+      trueType: this.trueType.toObject(),
+      falseType: this.falseType.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ConditionalTypeSchema {
+    const location = obj.location;
+    const checkType = SchemaRegistry.fromObject(obj.checkType);
+    const extendsType = SchemaRegistry.fromObject(obj.extendsType);
+    const trueType = SchemaRegistry.fromObject(obj.trueType);
+    const falseType = SchemaRegistry.fromObject(obj.falseType);
+    return new ConditionalTypeSchema(location, checkType, extendsType, trueType, falseType);
+  }
 }

package/schemas/constructor.ts

@@ -1,4 +1,4 @@
-import { Location } from '../schema-node';
+import { SchemaLocation } from '../schema-node';
 import { ParameterSchema } from './parameter';
 import { FunctionLikeSchema, Modifier } from './function-like';
 import { DocSchema } from './docs';
@@ -6,13 +6,23 @@ import { ThisTypeSchema } from './this-type';
 
 export class ConstructorSchema extends FunctionLikeSchema {
   constructor(
-    location: Location,
+    location: SchemaLocation,
     params: ParameterSchema[],
-    returns: ThisTypeSchema,
+    returnType: ThisTypeSchema,
     signature: string,
     modifiers: Modifier[] = [],
     doc?: DocSchema
   ) {
-    super(location, 'constructor', params, returns, signature, modifiers, doc, undefined);
+    super(location, 'constructor', params, returnType, signature, modifiers, doc, undefined);
+  }
+
+  static fromObject(obj: Record<string, any>): ConstructorSchema {
+    const location = obj.location;
+    const params = obj.params.map((param: any) => ParameterSchema.fromObject(param));
+    const returns = ThisTypeSchema.fromObject(obj.returnType);
+    const signature = obj.signature;
+    const modifiers = obj.modifiers;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    return new ConstructorSchema(location, params, returns, signature, modifiers, doc);
   }
 }

package/schemas/docs/doc.ts

@@ -1,12 +1,11 @@
-import { Transform } from 'class-transformer';
-import { schemaObjArrayToInstances } from '../../class-transformers';
-import { Location, SchemaNode } from '../../schema-node';
+import { SchemaLocation, SchemaNode } from '../../schema-node';
+import { SchemaRegistry } from '../../schema-registry';
 import { TagName, TagSchema } from './tag';
 
 export class DocSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   readonly tags?: TagSchema[];
-  constructor(readonly location: Location, readonly raw: string, readonly comment?: string, tags?: TagSchema[]) {
+
+  constructor(readonly location: SchemaLocation, readonly raw: string, readonly comment?: string, tags?: TagSchema[]) {
     super();
     this.tags = tags;
   }
@@ -24,4 +23,22 @@ export class DocSchema extends SchemaNode {
   findTag(tagName: TagName) {
     return this.tags?.find((tag) => tag.tagName === tagName);
   }
+
+  toObject() {
+    return {
+      __schema: this.__schema,
+      name: this.name,
+      location: this.location,
+      signature: this.signature,
+      raw: this.raw,
+      comment: this.comment,
+      tags: this.tags ? this.tags.map((tag) => tag.toObject()) : undefined,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): DocSchema {
+    const location = obj.location;
+    const tags = obj.tags ? obj.tags.map((tag: any) => SchemaRegistry.fromObject(tag)) : undefined;
+    return new DocSchema(location, obj.raw, obj.comment, tags);
+  }
 }

package/schemas/docs/property-like-tag.ts

@@ -1,15 +1,13 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../../schema-node';
+import { SchemaLocation, SchemaNode } from '../../schema-node';
+import { SchemaRegistry } from '../../schema-registry';
 import { TagName, TagSchema } from './tag';
-import { schemaObjToInstance } from '../../class-transformers';
 
 /**
  * e.g. `@param myParam {string} some comment`
  */
 export class PropertyLikeTagSchema extends TagSchema {
-  @Transform(schemaObjToInstance)
   readonly type?: SchemaNode;
-  constructor(readonly location: Location, readonly name: string, readonly comment?: string, type?: SchemaNode) {
+  constructor(readonly location: SchemaLocation, readonly name: string, readonly comment?: string, type?: SchemaNode) {
     super(location, TagName.parameter, comment);
     this.type = type;
   }
@@ -19,4 +17,20 @@ export class PropertyLikeTagSchema extends TagSchema {
     const type = this.type ? ` {${this.type.toString()}} ` : '';
     return `@${this.tagName} ${this.name}${type} ${comment}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type?.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): PropertyLikeTagSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const comment = obj.comment;
+    const type = obj.type ? SchemaRegistry.fromObject(obj.type) : undefined;
+    return new PropertyLikeTagSchema(location, name, comment, type);
+  }
 }

package/schemas/docs/return-tag.ts

@@ -1,15 +1,14 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../../schema-node';
+import { SchemaLocation, SchemaNode } from '../../schema-node';
+import { SchemaRegistry } from '../../schema-registry';
 import { TagName, TagSchema } from './tag';
-import { schemaObjToInstance } from '../../class-transformers';
 
 /**
  * e.g. `@return {string} some comment`
  */
 export class ReturnTagSchema extends TagSchema {
-  @Transform(schemaObjToInstance)
   readonly type?: SchemaNode;
-  constructor(readonly location: Location, readonly comment?: string, type?: SchemaNode) {
+
+  constructor(readonly location: SchemaLocation, readonly comment?: string, type?: SchemaNode) {
     super(location, TagName.return, comment);
     this.type = type;
   }
@@ -18,4 +17,18 @@ export class ReturnTagSchema extends TagSchema {
     const comment = this.comment ? ` ${this.comment}` : '';
     return `@${this.tagName}${comment}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type?.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ReturnTagSchema {
+    const location = obj.location;
+    const comment = obj.comment;
+    const type = obj.type ? SchemaRegistry.fromObject(obj.type) : undefined;
+    return new ReturnTagSchema(location, comment, type);
+  }
 }

package/schemas/docs/tag.ts

@@ -1,10 +1,10 @@
-import { Location, SchemaNode } from '../../schema-node';
+import { SchemaLocation, SchemaNode } from '../../schema-node';
 
 /**
  * e.g. `@deprecated please use something else`
  */
 export class TagSchema extends SchemaNode {
-  constructor(readonly location: Location, readonly tagName: TagName | string, readonly comment?: string) {
+  constructor(readonly location: SchemaLocation, readonly tagName: TagName | string, readonly comment?: string) {
     super();
   }
 
@@ -12,6 +12,24 @@ export class TagSchema extends SchemaNode {
     const comment = this.comment ? ` ${this.comment}` : '';
     return `@${this.tagName}${comment}`;
   }
+
+  static fromObject(obj: Record<string, any>): TagSchema {
+    const location = obj.location;
+    const tagName = obj.tagName;
+    const comment = obj.comment;
+    return new TagSchema(location, tagName, comment);
+  }
+
+  toObject() {
+    return {
+      __schema: this.__schema,
+      location: this.location,
+      name: this.name,
+      signature: this.signature,
+      tagName: this.tagName,
+      comment: this.comment,
+    };
+  }
 }
 
 export enum TagName {

package/schemas/enum-member.ts

@@ -1,14 +1,11 @@
-import { Transform } from 'class-transformer';
-import { schemaObjToInstance } from '../class-transformers';
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 import { DocSchema } from './docs';
 
 export class EnumMemberSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly doc?: DocSchema;
 
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly name: string,
     readonly signature: string,
     readonly value?: string,
@@ -22,4 +19,23 @@ export class EnumMemberSchema extends SchemaNode {
     if (!this.value) return this.name;
     return `${this.name}=${this.value}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      signature: this.signature,
+      value: this.value,
+      doc: this.doc?.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): EnumMemberSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const signature = obj.signature;
+    const value = obj.value;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    return new EnumMemberSchema(location, name, signature, value, doc);
+  }
 }