Before Transformer Transformation

packages/type-traverser/example/example.ts

@@ -110,28 +110,12 @@ async function run() {
       },
     };
 
-  console.log(avatarTraverserDefinition);
-
-  const graph = new InstanceGraph(avatarTraverserDefinition);
-  const aangNode = graph.getNodeFor(aang, "Bender");
-  const aangeChild = aangNode.child("friends");
-
-  const parent = aangNode.parent("Person");
-
-  const aangChildren = aangNode.allChildren();
-  aangChildren.forEach((child) => {
-    child.typeName === "Element";
-  });
-
-  const aangParents = aangNode.allParents();
-  
-
-  // /**
-  //  * Instantiate the Traverser
-  //  */
-  // const avatarTraverser = new Traverser<AvatarTraverserTypes>(
-  //   avatarTraverserDefinition,
-  // );
+  /**
+   * Instantiate the Traverser
+   */
+  const avatarTraverser = new Traverser<AvatarTraverserTypes>(
+    avatarTraverserDefinition,
+  );
 
   // /**
   //  * Create a visitor
@@ -193,85 +177,85 @@ async function run() {
   // await avatarCountingVisitor.visit(aang, "Bender", countContext);
   // console.log(countContext.numberOfBenders);
 
-  // /**
-  //  * Set up a transformer
-  //  */
-  // interface ActionablePerson {
-  //   doAction(): void;
-  //   friends: ActionablePerson[];
-  // }
-  // const avatarTransformer = avatarTraverser.createTransformer<
-  //   {
-  //     Element: {
-  //       return: string;
-  //     };
-  //     Bender: {
-  //       return: ActionablePerson;
-  //       properties: {
-  //         element: string;
-  //       };
-  //     };
-  //     NonBender: {
-  //       return: ActionablePerson;
-  //     };
-  //   },
-  //   undefined
-  // >({
-  //   Element: async (item) => {
-  //     return item.toUpperCase();
-  //   },
-  //   Bender: {
-  //     transformer: async (item, getTransformedChildren) => {
-  //       const transformedChildren = await getTransformedChildren();
-  //       return {
-  //         doAction: () => {
-  //           console.log(`I can bend ${transformedChildren.element}`);
-  //         },
-  //         friends: transformedChildren.friends,
-  //       };
-  //     },
-  //     properties: {
-  //       element: async (item, getTransformedChildren) => {
-  //         const transformedChildren = await getTransformedChildren();
-  //         return `the element of ${transformedChildren}`;
-  //       },
-  //     },
-  //   },
-  //   NonBender: {
-  //     transformer: async (item, getTransformedChildren) => {
-  //       const transformedChildren = await getTransformedChildren();
-  //       return {
-  //         doAction: () => {
-  //           console.log(`I can't bend.`);
-  //         },
-  //         friends: transformedChildren.friends,
-  //       };
-  //     },
-  //   },
-  //   Person: async (
-  //     item,
-  //     getTransformedChildren,
-  //     setReturnPointer,
-  //     _context,
-  //   ) => {
-  //     const personToReturn: ActionablePerson = {} as ActionablePerson;
-  //     setReturnPointer(personToReturn);
-  //     const transformedChildren = await getTransformedChildren();
-  //     personToReturn.doAction = transformedChildren.doAction;
-  //     personToReturn.friends = transformedChildren.friends;
-  //     return personToReturn;
-  //   },
-  // });
+  /**
+   * Set up a transformer
+   */
+  interface ActionablePerson {
+    doAction(): void;
+    friends: ActionablePerson[];
+  }
+  const avatarTransformer = avatarTraverser.createTransformer<
+    {
+      Element: {
+        return: string;
+      };
+      Bender: {
+        return: ActionablePerson;
+        properties: {
+          element: string;
+        };
+      };
+      NonBender: {
+        return: ActionablePerson;
+      };
+    },
+    undefined
+  >({
+    Element: async (item) => {
+      return item.toUpperCase();
+    },
+    Bender: {
+      transformer: async (item, getTransformedChildren) => {
+        const transformedChildren = await getTransformedChildren();
+        return {
+          doAction: () => {
+            console.log(`I can bend ${transformedChildren.element}`);
+          },
+          friends: transformedChildren.friends,
+        };
+      },
+      properties: {
+        element: async (item, getTransformedChildren) => {
+          const transformedChildren = await getTransformedChildren();
+          return `the element of ${transformedChildren}`;
+        },
+      },
+    },
+    NonBender: {
+      transformer: async (item, getTransformedChildren) => {
+        const transformedChildren = await getTransformedChildren();
+        return {
+          doAction: () => {
+            console.log(`I can't bend.`);
+          },
+          friends: transformedChildren.friends,
+        };
+      },
+    },
+    Person: async (
+      item,
+      getTransformedChildren,
+      setReturnPointer,
+      _context,
+    ) => {
+      const personToReturn: ActionablePerson = {} as ActionablePerson;
+      setReturnPointer(personToReturn);
+      const transformedChildren = await getTransformedChildren();
+      personToReturn.doAction = transformedChildren.doAction;
+      personToReturn.friends = transformedChildren.friends;
+      return personToReturn;
+    },
+  });
 
-  // /**
-  //  * Run the Transformer
-  //  */
-  // console.log(
-  //   "############################## AvatarTraverser DoAction ##############################",
-  // );
-  // const result = await avatarTransformer.transform(aang, "Bender", undefined);
-  // result.doAction();
-  // result.friends[0].doAction();
-  // result.friends[1].doAction();
+  /**
+   * Run the Transformer
+   */
+  console.log(
+    "############################## AvatarTraverser DoAction ##############################",
+  );
+  const result = await avatarTransformer.transform(aang, "Bender", undefined);
+  result.doAction();
+  result.friends[0].doAction();
+  result.friends[1].doAction();
 }
 run();

packages/type-traverser/src/ReverseRelationshipTypes.ts

@@ -4,7 +4,7 @@ import type {
   PrimitiveType,
   TraverserTypes,
   UnionType,
-} from "./TraverserTypes";
+} from "./traverser/TraverserTypes";
 
 export type InterfaceReverseRelationshipIndentifier<
   Types extends TraverserTypes<any>,

packages/type-traverser/src/index.ts

@@ -1,9 +1,9 @@
-export * from "./TraverserTypes";
+export * from "./traverser/TraverserTypes";
 export * from "./UtilTypes";
-export * from "./TraverserDefinition";
-export * from "./TransformerReturnTypes";
-export * from "./TransformerReturnTypesDefaults";
-export * from "./Traverser";
-export * from "./Transformer";
+export * from "./traverser/TraverserDefinition";
+export * from "./transformer/TransformerReturnTypes";
+export * from "./transformer/TransformerReturnTypesDefaults";
+export * from "./traverser/Traverser";
+export * from "./transformer/Transformer";
 export * from "./Visitor";
 export * from "./Visitors";

packages/type-traverser/src/instanceGraph/InstanceGraph.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { MultiMap } from "../transformerSubTraversers/util/MultiMap";
-import type { TraverserTypes } from "../TraverserTypes";
+import type { TraverserTypes } from "../traverser/TraverserTypes";
 import {
   createInstanceNodeFor,
   type InstanceNodeFor,
 } from "./nodes/createInstanceNodeFor";
-import type { TraverserDefinitions } from "../TraverserDefinition";
+import type { TraverserDefinitions } from "../traverser/TraverserDefinition";
 
 export class InstanceGraph<Types extends TraverserTypes<any>> {
   protected objectMap: MultiMap<

packages/type-traverser/src/instanceGraph/nodes/InstanceNode.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { TraverserDefinition } from "../..";
 import type { ParentIdentifiers } from "../../reverseRelationshipTypes";
-import type { TraverserTypes } from "../../TraverserTypes";
+import type { TraverserTypes } from "../../traverser/TraverserTypes";
 import type { InstanceGraph } from "../instanceGraph";
 import type { InstanceNodeFor } from "./createInstanceNodeFor";
 
@@ -11,7 +11,7 @@ export abstract class InstanceNode<
   Type extends Types[TypeName],
 > {
   readonly graph: InstanceGraph<Types>;
-  readonly instance: Types[TypeName]["type"];
+  readonly instance: Type["type"];
   readonly typeName: TypeName;
   protected readonly parents: Record<
     string,

packages/type-traverser/src/instanceGraph/nodes/InterfaceInstanceNode.ts

@@ -1,5 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { InterfaceType, TraverserTypes } from "../../TraverserTypes";
+import type {
+  InterfaceType,
+  TraverserTypes,
+} from "../../traverser/TraverserTypes";
 import type { InstanceGraph } from "../instanceGraph";
 import type { InstanceNodeFor } from "./createInstanceNodeFor";
 import { InstanceNode } from "./InstanceNode";

packages/type-traverser/src/instanceGraph/nodes/PrimitiveInstanceNode.ts

@@ -1,5 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { PrimitiveType, TraverserTypes } from "../../TraverserTypes";
+import type {
+  PrimitiveType,
+  TraverserTypes,
+} from "../../traverser/TraverserTypes";
 import { InstanceNode } from "./InstanceNode";
 
 export class PrimitiveInstanceNode<

packages/type-traverser/src/instanceGraph/nodes/UnionInstanceNode.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { TraverserTypes, UnionType } from "../../TraverserTypes";
+import type { TraverserTypes, UnionType } from "../../traverser/TraverserTypes";
 import type { InstanceNodeFor } from "./createInstanceNodeFor";
 import { InstanceNode } from "./InstanceNode";
 

packages/type-traverser/src/instanceGraph/nodes/createInstanceNodeFor.ts

@@ -4,7 +4,7 @@ import type {
   PrimitiveType,
   TraverserTypes,
   UnionType,
-} from "../../TraverserTypes";
+} from "../../traverser/TraverserTypes";
 import type { InstanceGraph } from "../instanceGraph";
 import { InterfaceInstanceNode } from "./InterfaceInstanceNode";
 import { PrimitiveInstanceNode } from "./PrimitiveInstanceNode";

packages/type-traverser/src/transformer/Transformer.ts

@@ -12,11 +12,11 @@ import type {
   TraverserTypes,
   UnionReturnType,
   UnionType,
-} from ".";
-import { transformerParentSubTraverser } from "./transformerSubTraversers/TransformerParentSubTraverser";
-import { CircularDepenedencyAwaiter } from "./transformerSubTraversers/util/CircularDependencyAwaiter";
-import { MultiMap } from "./transformerSubTraversers/util/MultiMap";
-import { SuperPromise } from "./transformerSubTraversers/util/SuperPromise";
+} from "..";
+import { transformerParentSubTraverser } from "../transformerSubTraversers/TransformerParentSubTraverser";
+import { CircularDepenedencyAwaiter } from "../transformerSubTraversers/util/CircularDependencyAwaiter";
+import { MultiMap } from "../transformerSubTraversers/util/MultiMap";
+import { SuperPromise } from "../transformerSubTraversers/util/SuperPromise";
 import type {
   GetTransformedChildrenFunction,
   InterfaceTransformerDefinition,

packages/type-traverser/src/transformer/TransformerReturnTypes.ts

@@ -3,7 +3,7 @@ import type {
   PrimitiveType,
   TraverserTypes,
   UnionType,
-} from ".";
+} from "..";
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export type InterfaceReturnType<Type extends InterfaceType<any>> = {

packages/type-traverser/src/transformer/TransformerReturnTypesDefaults.ts

@@ -10,7 +10,7 @@ import type {
   TraverserTypes,
   UnionInputReturnType,
   UnionType,
-} from ".";
+} from "..";
 
 export type RecursivelyFindReturnType<
   Types extends TraverserTypes<any>,

packages/type-traverser/src/transformer/Transformers.ts

@@ -10,7 +10,8 @@ import type {
   TraverserTypes,
   UnionReturnType,
   UnionType,
-} from ".";
+} from "..";
+import type { InterfaceInstanceNode } from "../instanceGraph/nodes/InterfaceInstanceNode";
 
 export type GetTransformedChildrenFunction<TransformedChildrenType> =
   () => Promise<TransformedChildrenType>;
@@ -30,6 +31,7 @@ export type InterfaceTransformerFunction<
     [PropertyName in keyof ReturnType["properties"]]: ReturnType["properties"][PropertyName];
   }>,
   setReturnPointer: SetReturnPointerFunction<ReturnType["return"]>,
+  node: InterfaceInstanceNode<Types, Type>,
   context: Context,
 ) => Promise<ReturnType["return"]>;
 

packages/type-traverser/src/transformerSubTraversers/TransformerInterfaceSubTraverser.ts

@@ -5,8 +5,8 @@ import type {
   TransformerReturnTypes,
 } from "../TransformerReturnTypes";
 import type { InterfaceTransformerDefinition } from "../Transformers";
-import type { InterfaceTraverserDefinition } from "../TraverserDefinition";
-import type { InterfaceType } from "../TraverserTypes";
+import type { InterfaceTraverserDefinition } from "../traverser/TraverserDefinition";
+import type { InterfaceType } from "../traverser/TraverserTypes";
 import { transformerParentSubTraverser } from "./TransformerParentSubTraverser";
 import type { TransformerSubTraverserGlobals } from "./util/transformerSubTraverserTypes";
 

packages/type-traverser/src/transformerSubTraversers/TransformerPrimitiveSubTraverser.ts

@@ -5,7 +5,7 @@ import type {
   TransformerReturnTypes,
 } from "../TransformerReturnTypes";
 import type { PrimitiveTransformerDefinition } from "../Transformers";
-import type { PrimitiveType } from "../TraverserTypes";
+import type { PrimitiveType } from "../traverser/TraverserTypes";
 import type { TransformerSubTraverserGlobals } from "./util/transformerSubTraverserTypes";
 
 export async function transformerPrimitiveSubTraverser<

packages/type-traverser/src/transformerSubTraversers/TransformerUnionSubTraverser.ts

@@ -5,8 +5,8 @@ import type {
   UnionReturnType,
 } from "../TransformerReturnTypes";
 import type { UnionTransformerDefinition } from "../Transformers";
-import type { UnionTraverserDefinition } from "../TraverserDefinition";
-import type { UnionType } from "../TraverserTypes";
+import type { UnionTraverserDefinition } from "../traverser/TraverserDefinition";
+import type { UnionType } from "../traverser/TraverserTypes";
 import { transformerParentSubTraverser } from "./TransformerParentSubTraverser";
 import type { TransformerSubTraverserGlobals } from "./util/transformerSubTraverserTypes";
 

packages/type-traverser/src/traverser/Traverser.ts

@@ -4,9 +4,9 @@ import type {
   TraverserDefinitions,
   TraverserTypes,
   VisitorsInput,
-} from ".";
-import { Transformer, Visitor } from ".";
-import type { TransformersInput } from "./Transformers";
+} from "..";
+import { Transformer, Visitor } from "..";
+import type { TransformersInput } from "../transformer/Transformers";
 
 export class Traverser<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

packages/type-traverser/src/traverser/TraverserDefinition.ts

@@ -4,7 +4,7 @@ import type {
   TraverserTypes,
   UnionType,
   PrimitiveType,
-} from ".";
+} from "..";
 
 export type InterfaceTraverserDefinition<Type extends InterfaceType<any>> = {
   kind: "interface";

packages/type-traverser/src/traverser/TraverserTypes.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { AssertExtends, KeyTypes } from "./UtilTypes";
+import type { AssertExtends, KeyTypes } from "../UtilTypes";
 
 export interface InterfaceType<TypeNames extends KeyTypes> {
   kind: "interface";

packages/type-traverser/src/visitorSubTraversers/VisitorInterfaceSubTraverser.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { InterfaceVisitorDefinition, TraverserTypes } from "..";
-import type { InterfaceTraverserDefinition } from "../TraverserDefinition";
-import type { InterfaceType } from "../TraverserTypes";
+import type { InterfaceTraverserDefinition } from "../traverser/TraverserDefinition";
+import type { InterfaceType } from "../traverser/TraverserTypes";
 import type { VisitorSubTraverserGlobals } from "./util/visitorSubTraverserTypes";
 import { visitorParentSubTraverser } from "./VisitorParentSubTraverser";
 

packages/type-traverser/src/visitorSubTraversers/VisitorPrimitiveSubTraverser.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { PrimitiveVisitorDefinition, TraverserTypes } from "..";
-import type { PrimitiveType } from "../TraverserTypes";
+import type { PrimitiveType } from "../traverser/TraverserTypes";
 import type { VisitorSubTraverserGlobals } from "./util/visitorSubTraverserTypes";
 
 export async function visitorPrimitiveSubTraverser<

packages/type-traverser/src/visitorSubTraversers/VisitorUnionSubTraverser.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { TraverserTypes, UnionVisitorDefinition } from "..";
-import type { UnionTraverserDefinition } from "../TraverserDefinition";
-import type { UnionType } from "../TraverserTypes";
+import type { UnionTraverserDefinition } from "../traverser/TraverserDefinition";
+import type { UnionType } from "../traverser/TraverserTypes";
 import type { VisitorSubTraverserGlobals } from "./util/visitorSubTraverserTypes";
 import { visitorParentSubTraverser } from "./VisitorParentSubTraverser";
 

packages/type-traverser/test/integration/avatar/avatar.test.ts

@@ -100,53 +100,62 @@ describe("AvatarExample", () => {
       },
     };
 
-  it("returns child nodes when child methods are called.", () => {
-    const graph = new InstanceGraph(avatarTraverserDefinition);
-    const aangBender = graph.getNodeFor(aang, "Bender");
-    expect(aangBender.typeName).toBe("Bender");
-    expect(aangBender.instance.name).toBe("Aang");
-    // child
-    const aangElement = aangBender.child("element");
-    expect(aangElement.instance).toBe("Air");
-    expect(aangElement.typeName).toBe("Element");
-    const aangFriends = aangBender.child("friends");
-    expect(aangFriends.length).toBe(2);
-    const sokkaPerson = aangFriends[0];
-    const kataraPerson = aangFriends[1];
-    expect(sokkaPerson.instance.name).toBe("Sokka");
-    expect(kataraPerson.instance.name).toBe("Katara");
-    expect(sokkaPerson.typeName).toBe("Person");
-    expect(kataraPerson.typeName).toBe("Person");
-    const sokkaNonBender = sokkaPerson.child();
-    expect(sokkaNonBender.instance.name).toBe("Sokka");
-    expect(sokkaNonBender.typeName).toBe("NonBender");
-    if (sokkaNonBender.typeName === "NonBender") {
-      const aangPerson = sokkaNonBender.child("friends")[0];
-      const aangBender2 = aangPerson.child();
-      expect(aangBender2).toBe(aangBender);
-    }
-    // allChildren
-    const [childElemement, childSokka, childKatara] = aangBender.allChildren();
-    expect(childElemement.instance).toBe("Air");
-    expect((childSokka.instance as NonBender).name).toBe("Sokka");
-    expect((childKatara.instance as Bender).name).toBe("Katara");
-    const childOfSokkaPerson = sokkaPerson.allChildren();
-    expect(childOfSokkaPerson.length).toBe(1);
-    expect(childOfSokkaPerson[0].instance.name).toBe("Sokka");
+  describe("Build Instance Graph", () => {
+    it("returns child nodes when child methods are called.", () => {
+      const graph = new InstanceGraph(avatarTraverserDefinition);
+      const aangBender = graph.getNodeFor(aang, "Bender");
+      expect(aangBender.typeName).toBe("Bender");
+      expect(aangBender.instance.name).toBe("Aang");
+      // child
+      const aangElement = aangBender.child("element");
+      expect(aangElement.instance).toBe("Air");
+      expect(aangElement.typeName).toBe("Element");
+      const aangFriends = aangBender.child("friends");
+      expect(aangFriends.length).toBe(2);
+      const sokkaPerson = aangFriends[0];
+      const kataraPerson = aangFriends[1];
+      expect(sokkaPerson.instance.name).toBe("Sokka");
+      expect(kataraPerson.instance.name).toBe("Katara");
+      expect(sokkaPerson.typeName).toBe("Person");
+      expect(kataraPerson.typeName).toBe("Person");
+      const sokkaNonBender = sokkaPerson.child();
+      expect(sokkaNonBender.instance.name).toBe("Sokka");
+      expect(sokkaNonBender.typeName).toBe("NonBender");
+      if (sokkaNonBender.typeName === "NonBender") {
+        const aangPerson = sokkaNonBender.child("friends")[0];
+        const aangBender2 = aangPerson.child();
+        expect(aangBender2).toBe(aangBender);
+      }
+      // allChildren
+      const [childElemement, childSokka, childKatara] =
+        aangBender.allChildren();
+      expect(childElemement.instance).toBe("Air");
+      expect((childSokka.instance as NonBender).name).toBe("Sokka");
+      expect((childKatara.instance as Bender).name).toBe("Katara");
+      const childOfSokkaPerson = sokkaPerson.allChildren();
+      expect(childOfSokkaPerson.length).toBe(1);
+      expect(childOfSokkaPerson[0].instance.name).toBe("Sokka");
+    });
+
+    it("returns parent nodes when parent methods are called.", () => {
+      const graph = new InstanceGraph(avatarTraverserDefinition);
+      const aangBender = graph.getNodeFor(aang, "Bender");
+      // parent
+      const [aangPerson] = aangBender.parent("Person");
+      expect(aangPerson.instance.name).toBe("Aang");
+      expect(aangPerson.typeName).toBe("Person");
+      const [sokkaNonBender] = aangPerson.parent("NonBender", "friends");
+      const [kataraBender] = aangPerson.parent("Bender", "friends");
+      expect(sokkaNonBender.typeName).toBe("NonBender");
+      expect(sokkaNonBender.instance.name).toBe("Sokka");
+      expect(kataraBender.typeName).toBe("Bender");
+      expect(kataraBender.instance.name).toBe("Katara");
+    });
   });
 
-  it("returns parent nodes when parent methods are called.", () => {
-    const graph = new InstanceGraph(avatarTraverserDefinition);
-    const aangBender = graph.getNodeFor(aang, "Bender");
-    // parent
-    const [aangPerson] = aangBender.parent("Person");
-    expect(aangPerson.instance.name).toBe("Aang");
-    expect(aangPerson.typeName).toBe("Person");
-    const [sokkaNonBender] = aangPerson.parent("NonBender", "friends");
-    const [kataraBender] = aangPerson.parent("Bender", "friends");
-    expect(sokkaNonBender.typeName).toBe("NonBender");
-    expect(sokkaNonBender.instance.name).toBe("Sokka");
-    expect(kataraBender.typeName).toBe("Bender");
-    expect(kataraBender.instance.name).toBe("Katara");
+  describe("Transformer", () => {
+    it("transforms", () => {
+      
+    })
   });
 });