feat: MirrorNode is almost like RegularNode

Author: P0lip

src/__tests__/__snapshots__/tree.spec.ts.snap

@@ -1,4 +1,5 @@
 import { pathToPointer } from '@stoplight/json';
+import type { Dictionary } from '@stoplight/types';
 import * as treeify from 'treeify';
 
 import { MirrorNode, ReferenceNode, RegularNode, SchemaNode } from '../../nodes';
@@ -12,13 +13,13 @@ export function printTree(schema: SchemaFragment, opts?: Partial<SchemaTreeOptio
 
   const root: unknown =
     tree.root.children.length > 1
-      ? tree.root.children.map(prepareTree, new WeakSet())
+      ? tree.root.children.map(child => prepareTree.call(new WeakSet(), child))
       : prepareTree.call(new WeakSet(), tree.root.children[0]);
 
   return treeify.asTree(root as treeify.TreeObject, true, true);
 }
 
-function printRegularNode(this: WeakSet<SchemaNode>, node: RegularNode): any {
+function printRegularNode(this: WeakSet<SchemaFragment>, node: RegularNode): Dictionary<unknown> {
   return {
     ...(node.types !== null ? { types: node.types } : null),
     ...(node.primaryType !== null ? { primaryType: node.primaryType } : null),
@@ -36,30 +37,30 @@ function printReferenceNode(node: ReferenceNode) {
   };
 }
 
-function printMirrorNode(this: WeakSet<SchemaNode>, node: MirrorNode): any {
-  if (this.has(node.mirrors)) {
+function printMirrorNode(this: WeakSet<SchemaFragment>, node: MirrorNode): any {
+  if (this.has(node.fragment)) {
     return {
-      mirrors: pathToPointer(node.path as string[]),
+      mirrors: pathToPointer(node.mirroredNode.path as string[]),
     };
   }
 
-  this.add(node.mirrors);
-  return printNode.call(this, node.mirrors);
+  this.add(node.fragment);
+  return printRegularNode.call(this, node as RegularNode);
 }
 
-function printNode(this: WeakSet<SchemaNode>, node: SchemaNode) {
-  return node instanceof RegularNode
+function printNode(this: WeakSet<SchemaFragment>, node: SchemaNode) {
+  return node instanceof MirrorNode
+    ? printMirrorNode.call(this, node)
+    : node instanceof RegularNode
     ? printRegularNode.call(this, node)
     : node instanceof ReferenceNode
     ? printReferenceNode.call(this, node)
-    : node instanceof MirrorNode
-    ? printMirrorNode.call(this, node)
     : {
         kind: 'unknown node',
       };
 }
 
-function prepareTree(this: WeakSet<SchemaNode>, node: SchemaNode) {
+function prepareTree(this: WeakSet<SchemaFragment>, node: SchemaNode) {
   return {
     [pathToPointer(node.path as string[])]: printNode.call(this, node),
   };

src/__tests__/tree.spec.ts

@@ -0,0 +1 @@
+export * from './nodes';

src/__tests__/utils/printTree.ts

@@ -0,0 +1,13 @@
+import type { MirrorNode, ReferenceNode, RegularNode, SchemaNode } from '../nodes';
+
+export function isRegularNode(node: SchemaNode): node is RegularNode {
+  return 'types' in node && 'primaryType' in node && 'combiners' in node;
+}
+
+export function isMirrorNode(node: SchemaNode): node is MirrorNode {
+  return 'mirroredNode' in node;
+}
+
+export function isReferenceNode(node: SchemaNode): node is ReferenceNode {
+  return 'external' in node && 'value' in node;
+}

src/guards/index.ts

@@ -1,3 +1,4 @@
+export * from './guards';
 export * from './nodes';
 export * from './resolver';
 export * from './tree';

src/guards/nodes.ts

@@ -1,21 +1,59 @@
+import type { Dictionary } from '@stoplight/types';
+
 import { BaseNode } from './BaseNode';
-import type { SchemaNode } from './types';
+import type { RegularNode } from './RegularNode';
+import type { SchemaAnnotations, SchemaCombinerName, SchemaMeta, SchemaNode, SchemaNodeKind } from './types';
+
+export class MirrorNode extends BaseNode implements RegularNode {
+  public readonly types!: SchemaNodeKind[] | null;
+  public readonly primaryType!: SchemaNodeKind | null;
+  public readonly combiners!: SchemaCombinerName[] | null;
+
+  public readonly required!: string[] | null;
+  public readonly enum!: unknown[] | null;
+  public readonly format!: string | null;
+  public readonly title!: string | null;
+  public readonly deprecated!: boolean;
+
+  public readonly meta!: Readonly<Partial<Dictionary<unknown, SchemaMeta>>>;
+  public readonly annotations!: Readonly<Partial<Dictionary<unknown, SchemaAnnotations>>>;
+  public readonly validations!: Readonly<Dictionary<unknown>>;
+
+  public readonly simple!: boolean;
+
+  constructor(public readonly mirroredNode: SchemaNode) {
+    super(mirroredNode.fragment);
+
+    return new Proxy(this, {
+      get(target, key) {
+        if (key in target) {
+          return target[key];
+        }
+
+        if (key in mirroredNode) {
+          return Reflect.get(mirroredNode, key, mirroredNode);
+        }
+
+        return;
+      },
 
-export class MirrorNode extends BaseNode {
-  constructor(public readonly mirrors: SchemaNode) {
-    super(mirrors.fragment);
+      has(target, key) {
+        return key in target || key in mirroredNode;
+      },
+    });
   }
 
   public get children(): MirrorNode[] | null {
-    if (!('children' in this.mirrors)) return null;
+    if (!('children' in this.mirroredNode)) return null;
 
-    const referencedChildren = this.mirrors.children;
+    const referencedChildren = this.mirroredNode.children;
     if (referencedChildren === null) return null;
 
     const children: MirrorNode[] = [];
     for (const child of referencedChildren) {
       const mirroredChild = new MirrorNode(child);
       mirroredChild.parent = this;
+      mirroredChild.subpath = child.subpath;
       children.push(mirroredChild);
     }
 

src/index.ts

@@ -1,8 +1,9 @@
 import type { MirrorNode } from './MirrorNode';
 import type { ReferenceNode } from './ReferenceNode';
 import type { RegularNode } from './RegularNode';
+import type { RootNode } from './RootNode';
 
-export type SchemaNode = RegularNode | ReferenceNode | MirrorNode;
+export type SchemaNode = RootNode | RegularNode | ReferenceNode | MirrorNode;
 
 export enum SchemaNodeKind {
   Any = 'any',

src/nodes/MirrorNode.ts

@@ -1,11 +1,12 @@
 import { EventEmitter } from '@stoplight/lifecycle';
 import type { Dictionary } from '@stoplight/types';
 
+import { isRegularNode } from '../guards';
 import { mergeAllOf } from '../mergers/mergeAllOf';
 import { mergeOneOrAnyOf } from '../mergers/mergeOneOrAnyOf';
 import { ReferenceNode, RegularNode } from '../nodes';
 import { MirrorNode } from '../nodes/MirrorNode';
-import type { RootNode } from '../nodes/RootNode';
+import { RootNode } from '../nodes/RootNode';
 import { SchemaCombinerName, SchemaNode, SchemaNodeKind } from '../nodes/types';
 import type { SchemaFragment } from '../types';
 import { isObjectLiteral } from '../utils/guards';
@@ -91,8 +92,10 @@ export class Walker extends EventEmitter<Dictionary<WalkerEventHandler, WalkerEv
         continue;
       }
 
-      schemaNode.parent = initialSchemaNode;
-      schemaNode.subpath = this.path.slice(initialSchemaNode.path.length);
+      if (!(schemaNode instanceof RootNode)) {
+        schemaNode.parent = initialSchemaNode;
+        schemaNode.subpath = this.path.slice(initialSchemaNode.path.length);
+      }
 
       if ('children' in initialSchemaNode) {
         if (initialSchemaNode.children === null) {
@@ -124,7 +127,7 @@ export class Walker extends EventEmitter<Dictionary<WalkerEventHandler, WalkerEv
   protected *walkNodeChildren() {
     const { fragment, schemaNode } = this;
 
-    if (!(schemaNode instanceof RegularNode)) return;
+    if (!isRegularNode(schemaNode)) return;
 
     const {
       depth: initialDepth,