function visit()

in packages/cdk-graph/src/core/graph.ts [2679:2788]
102 lines of code
16 McCabe index (conditional complexity)

  function visit(sNode: SerializedGraph.SGNode, parent: Node): void {
    const nodeProps: ITypedNodeProps = {
      ...(omit(sNode, [
        "children",
        "parent",
        "stack",
        "nodeType",
      ] as (keyof SerializedGraph.SGNode)[]) as Omit<
        SerializedGraph.SGNode,
        "children" | "parent" | "stack" | "nodeType"
      >),
      parent: sNode.parent ? store.getNode(sNode.parent) : undefined,
      // resolve stack node, unless stack is itself
      stack:
        sNode.stack && sNode.stack !== sNode.uuid
          ? store.getStack(sNode.stack)
          : undefined,
      store,
    };

    if (nodeProps.parent?.uuid !== parent.uuid) {
      throw new Error(
        `SerializedNode parent ${sNode.parent} does not match visitor parent ${parent.uuid}`
      );
    }

    let node: Node | undefined = undefined;

    switch (sNode.nodeType) {
      case NodeTypeEnum.APP: {
        node = new AppNode({
          ...nodeProps,
          parent,
        });
        break;
      }
      case NodeTypeEnum.STAGE: {
        node = new StageNode(nodeProps);
        break;
      }
      case NodeTypeEnum.STACK: {
        node = new StackNode(nodeProps);
        break;
      }
      case NodeTypeEnum.NESTED_STACK: {
        node = new NestedStackNode({
          ...nodeProps,
          parentStack: StackNode.of(parent),
        });
        break;
      }
      case NodeTypeEnum.OUTPUT: {
        node = new OutputNode({
          ...nodeProps,
          value: nodeProps.attributes![OutputNode.ATTR_VALUE],
          exportName: nodeProps.attributes![
            OutputNode.ATTR_EXPORT_NAME
          ] as string,
          description: nodeProps.attributes!.description as string,
        });
        break;
      }
      case NodeTypeEnum.PARAMETER: {
        node = new ParameterNode({
          ...nodeProps,
          value: nodeProps.attributes![ParameterNode.ATTR_VALUE],
          parameterType: nodeProps.attributes![
            ParameterNode.ATTR_TYPE
          ] as string,
          description: nodeProps.attributes!.description as string,
        });
        break;
      }
      case NodeTypeEnum.CFN_RESOURCE: {
        node = new CfnResourceNode(nodeProps);
        break;
      }
      case NodeTypeEnum.RESOURCE: {
        node = new ResourceNode({
          ...nodeProps,
          cdkOwned: !!nodeProps.flags?.includes(FlagEnum.CDK_OWNED),
        });
        break;
      }
      case NodeTypeEnum.DEFAULT: {
        node = new Node({
          ...nodeProps,
          nodeType: NodeTypeEnum.DEFAULT,
        });
        break;
      }
    }

    if (node == null) {
      console.debug(sNode.nodeType, sNode);
      throw new Error(
        `NodeType ${sNode.nodeType} missing deserialization mapping`
      );
    }

    // ensure node is registered in store
    assert(
      store.getNode(sNode.uuid) === node,
      `Node ${sNode.uuid} did not register in store`
    );

    Object.values(sNode.children || {}).forEach((sChild) => {
      visit(sChild, node!);
    });
  }