@lowgular/code-graph 0.0.1

package/libs/cli/code-graph/src/lib/v2/extractors/extractor.doc.js

@@ -0,0 +1,345 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var extractor_doc_exports = {};
+__export(extractor_doc_exports, {
+  EXTRACTOR_ARGUMENT_CONTEXT_DOC: () => EXTRACTOR_ARGUMENT_CONTEXT_DOC,
+  EXTRACTOR_DOC: () => EXTRACTOR_DOC,
+  EXTRACTOR_HELPERS_DOC: () => EXTRACTOR_HELPERS_DOC
+});
+module.exports = __toCommonJS(extractor_doc_exports);
+var import_cypher = require("@cli/cypher");
+const EXTRACTOR_ARGUMENT_CONTEXT_DOC = {
+  current: `\`ts.Node | ts.Type\`: The current node that is being processed.
+  - For properties: The node whose property you're extracting
+  - For relationships: The source node from which you're finding related nodes
+  - Can be a \`ts.Node\` or \`ts.Type\``,
+  sourceFile: `\`ts.SourceFile\`: Current source file that is being processed
+  - Always the final parent of the current node
+  - Use \`args.sourceFile.fileName\` to get the file path`,
+  typeChecker: `\`ts.TypeChecker\`: The type checker to use to extract information from
+  - Use for type resolution and semantic analysis
+  - Access via \`args.typeChecker\``,
+  ts: `\`typeof ts\`: The TypeScript API to use to extract information from
+  - Access to all TypeScript types, enums, and utilities
+  - Use \`args.ts.SyntaxKind\` for node kinds
+  - Use \`args.ts.isIdentifier()\` for type guards, etc.`
+};
+const EXTRACTOR_HELPERS_DOC = {
+  getDescendantsBy: `Performs a breadth-first traversal of a TypeScript AST node tree, collecting all descendant nodes that match a custom predicate.
+It uses a queue-based algorithm starting from the given node, iteratively processing each node by extracting its children via getChildren(), filtering those that match the predicate into the results array, and adding all children (both matching and non-matching) back to the queue for further traversal.
+This ensures all descendants at every depth level are examined, making it useful for finding nodes based on flexible criteria (node kind, name, custom properties, etc.) rather than just syntax kind matching, and it returns a type-safe array of matching nodes cast to the specified generic type T.
+
+Signature:
+function getDescendantsBy<T extends Node>(
+  node: Node,
+  predicate: (node: Node) => boolean,
+): T[]
+
+**Use Case**: Finding nodes based on flexible criteria (node kind, name, custom properties, etc.)
+
+**Examples:**
+${(0, import_cypher.mb)(
+    `// Find all MethodDeclaration descendants
+helpers.getDescendantsBy(args.current, (node) => 
+  node.kind === args.ts.SyntaxKind.MethodDeclaration
+);`,
+    "typescript"
+  )}
+
+${(0, import_cypher.mb)(
+    `// Find all methods with specific name
+helpers.getDescendantsBy(args.current, (node) => 
+  node.kind === args.ts.SyntaxKind.MethodDeclaration && 
+  node.name?.getText() === 'getAll'
+);`,
+    "typescript"
+  )}
+
+${(0, import_cypher.mb)(
+    `// Find all nodes with decorators
+helpers.getDescendantsBy(args.current, (node) => 
+  args.ts.canHaveDecorators(node) && 
+  args.ts.getDecorators(node)?.length > 0
+);`,
+    "typescript"
+  )}
+    `,
+  getAncestorsBy: `Traverses up the TypeScript AST from a given node, collecting all ancestor nodes that match a custom predicate.
+It follows parent links from the starting node to the root, checking each ancestor against the predicate and adding matches to the results array.
+The traversal stops when it reaches a node without a parent (typically the SourceFile root), ensuring it doesn't attempt to access undefined parents.
+This provides a flexible way to find ancestor nodes based on any criteria (node kind, name, custom properties, etc.) rather than just syntax kind matching, and returns a type-safe array of matching ancestors cast to the specified generic type T, making it useful for finding containing scopes, parent declarations, or any higher-level context nodes in the AST hierarchy.
+
+Signature:
+function getAncestorsBy<T extends Node>(
+  node: Node,
+  predicate: (node: Node) => boolean,
+): T[]
+
+**Use Case**: Finding containing scopes, parent declarations, or higher-level context nodes
+
+**Examples:**
+${(0, import_cypher.mb)(
+    `// Find containing class
+helpers.getAncestorsBy(args.current, (node) => 
+  node.kind === args.ts.SyntaxKind.ClassDeclaration
+);`,
+    "typescript"
+  )}
+
+${(0, import_cypher.mb)(
+    `// Find containing function or method
+return helpers.getAncestorsBy(args.current, (node) => 
+  node.kind === args.ts.SyntaxKind.FunctionDeclaration ||
+  node.kind === args.ts.SyntaxKind.MethodDeclaration
+);`,
+    "typescript"
+  )}
+    `,
+  getType: `Resolves type information from any TypeScript AST node.
+It checks a node-based cache first, then routes by node type: for MethodDeclaration it extracts return types (explicit or inferred from call signatures), for PropertyDeclaration it prefers explicit type annotations and falls back to inferring from initializers, for TypeNode it processes explicit type annotations, and for Expression nodes it infers types from property initializers.
+For other nodes, it uses TypeScript's type checker to infer the type at the node's location.
+All resolved types are cached in the context's type resolution tracker before being returned, and the function gracefully handles errors by returning undefined.
+This provides a unified API for extracting type information regardless of whether types are explicitly annotated or inferred, making it ideal for code analysis tools that need consistent type resolution across different TypeScript code patterns.
+
+Signature:
+const getType = (
+  node: ts.Node,
+  typeChecker: ts.TypeChecker,
+  typeResolutionTracker: TypeResolutionTracker,
+): ts.Type[]
+
+**IMPORTANT**: To be consistent with other helpers the function will return array with single element if type is found and empty array if type is not found.
+
+**Use Case**: Extracting type information regardless of whether types are explicitly annotated or inferred
+
+**Examples:**
+${(0, import_cypher.mb)(
+    `// Get type of current node
+helpers.getType(args.current);`,
+    "typescript"
+  )} 
+    `,
+  getDeclarations: `Extracts all TypeScript declaration nodes from either a ts.Type or ts.Node input, using multiple strategies.
+For nodes, it first checks if it's a TypeReferenceNode and extracts the symbol from the type name; if not, it tries getSymbolAtLocation for value nodes, then falls back to getTypeAtLocation for type nodes (recursively calling itself with the resolved type).
+For type inputs, it prioritizes type aliases by checking aliasSymbol first, then handles generic types by accessing the base type via the target property, and finally extracts declarations from the type's symbol.
+The function resolves symbol aliases internally and aggregates all found declarations (including multiple declarations from the same symbol) into a single array, making it a unified entry point for declaration extraction regardless of whether you're working with types or AST nodes, with graceful error handling that returns an empty array when no declarations can be found.
+
+Signature:
+const getDeclarations = (
+  node: ts.Type | ts.Node,
+  typeChecker: ts.TypeChecker,
+): ts.Declaration[]
+
+**Use Case**: Unified entry point for declaration extraction regardless of whether you're working with types or AST nodes
+
+**Examples:**
+${(0, import_cypher.mb)(
+    `// Get declarations from current node
+helpers.getDeclarations(args.current);`,
+    "typescript"
+  )} 
+
+${(0, import_cypher.mb)(
+    `// Get declarations from current node that are class declarations
+helpers.getDeclarations(args.current).filter(d =>
+  d.kind === args.ts.SyntaxKind.ClassDeclaration
+);`,
+    "typescript"
+  )} 
+    `
+};
+const EXTRACTOR_DOC = `# Extractors
+
+You are given a great responsibility of running typescript code that you can use to extract information from the code.
+
+It can be used when extracting:
+- **properties** on GraphNodes
+- **relationships** between GraphNodes
+
+Your task is to provide missing code that will be injected in following extractor function:
+
+${(0, import_cypher.mb)(
+  `export function executeExtractor(code: string, context: ExtractorContext): any {
+  // console.log('context: ', Object.keys(context));
+  try {
+    // Create a function with the context as parameters
+    const fn = new Function(
+      ...Object.keys(context),
+      \`
+      return \${code}
+      \`,
+    );
+
+    return fn(...Object.values(context));
+  } catch (error) {
+    throw new Error('Extractor execution failed: ' + error.message);
+  }
+}`,
+  "typescript"
+)}
+
+## Return Types
+
+The function can return anything, however CodeGraph supports the following return types:
+
+### For Properties
+- **Primitive types**: \`string\`, \`number\`, \`boolean\`
+- **Arrays of primitives**: \`string[]\`, \`number[]\`, \`boolean[]\`
+- **null and undefined**: Allowed but will be ignored when returning the value (property won't be set on the node)
+
+### For Relationships
+- **Arrays of nodes**: \`ts.Node[]\` or \`ts.Type[]\`
+- The returned nodes will be processed according to the nested \`nodeExtractors\` configuration
+- Each node in the array will create an edge from the source node to that target node
+
+
+**Example for Properties:**
+${(0, import_cypher.mb)(
+  `
+// Returns a string
+"name": "args.current.name?.getText();"
+
+// Returns a boolean
+"hasDecorators": "args.ts.getDecorators(args.current)?.length > 0 || false;"
+
+// Returns an array of strings
+"decoratorNames": "args.ts.getDecorators(args.current)?.map(d => d.expression.getText()) || [];"
+`,
+  "typescript"
+)}
+
+**Example for Relationships:**
+${(0, import_cypher.mb)(
+  `
+// Returns array of MethodDeclaration nodes
+"extractorCode": "return helpers.getDescendantsBy(args.current, (node) => node.kind === args.ts.SyntaxKind.MethodDeclaration);"
+
+// Returns array of Type nodes
+"extractorCode": "const type = helpers.getType(args.current); return type ? [type] : [];"
+
+// Returns array of Declaration nodes
+"extractorCode": "return helpers.getDeclarations(args.current);"
+`,
+  "typescript"
+)}
+
+## ExtractorContext
+
+When your extractor code executes, it has access to the following context:
+
+${(0, import_cypher.mb)(
+  `
+export type ExtractorContext = {
+  args: ExtractorArgumentContext; // data structures available in your context
+  helpers: ExtractorHelpersContext; // helper functions available in your context
+};`,
+  "typescript"
+)}
+
+### ExtractorArgumentContext (args)
+${Object.entries(EXTRACTOR_ARGUMENT_CONTEXT_DOC).map(([name, content]) => `- **\`${name}\`** - ${content}`).join("\n")}
+
+**Usage Examples:**
+
+${(0, import_cypher.mb)(
+  `// Access node name
+args.current.name?.getText();
+
+// Get file path
+args.sourceFile.fileName;
+
+// Check node kind
+args.current.kind === args.ts.SyntaxKind.ClassDeclaration;
+
+// Use type guards
+args.ts.isIdentifier(args.current);
+args.ts.isStringLiteral(args.current);`,
+  "typescript"
+)}
+
+### ExtractorHelpersContext (helpers)
+
+The \`helpers\` object provides utility functions for common operations:
+
+${Object.entries(EXTRACTOR_HELPERS_DOC).map(([name, content]) => `#### ${name}
+${content}`).join("\n")}
+  
+## Complete Examples
+
+### Property Extractor Example
+
+${(0, import_cypher.mb)(
+  `
+{
+  "properties": {
+    "name": "args.current.name?.getText();",
+    "filePath": "args.sourceFile.fileName;",
+    "hasDecorators": "args.ts.getDecorators(args.current)?.length > 0 || false;",
+    "decoratorNames": "args.ts.getDecorators(args.current)?.map(d => d.expression.getText()) || [];"
+  }
+}
+`,
+  "typescript"
+)}
+
+### Relationship Extractor Example
+${(0, import_cypher.mb)(
+  `
+{
+  "relationships": {
+    "HAS_METHOD": {
+      "extractorCode": "return helpers.getDescendantsBy(args.current, (node) => node.kind === args.ts.SyntaxKind.MethodDeclaration);",
+      "nodeExtractors": {
+        "MethodDeclaration": {
+          "properties": {
+            "name": "args.current.name?.getText();"
+          }
+        }
+      }
+    },
+    "HAS_TYPE": {
+      "extractorCode": "const type = helpers.getType(args.current); return type ? [type] : [];",
+      "nodeExtractors": {
+        "Type": {
+          "relationships": {
+            "HAS_DECLARATION": {
+              "extractorCode": "return helpers.getDeclarations(args.current);",
+              "nodeExtractors": {
+                "ClassDeclaration": {
+                  "properties": {
+                    "name": "args.current.name?.getText();"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`,
+  "typescript"
+)}
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXTRACTOR_ARGUMENT_CONTEXT_DOC,
+  EXTRACTOR_DOC,
+  EXTRACTOR_HELPERS_DOC
+});

package/libs/cli/code-graph/src/lib/v2/extractors/extractor.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var extractor_exports = {};
+__export(extractor_exports, {
+  executeExtractor: () => executeExtractor,
+  extractNodeProperties: () => extractNodeProperties
+});
+module.exports = __toCommonJS(extractor_exports);
+const ts = require("typescript");
+function executeExtractor(code, context) {
+  try {
+    const fn = new Function(
+      ...Object.keys(context),
+      `
+      return ${code}
+      `
+    );
+    return fn(...Object.values(context));
+  } catch (error) {
+    throw new Error(`Extractor execution failed: ${error.message}`);
+  }
+}
+function extractNodeProperties(context, propertyExectorMap = {}) {
+  const properties = {};
+  for (const [propertyName, extractorCode] of Object.entries(
+    propertyExectorMap
+  )) {
+    const value = executeExtractor(extractorCode, context);
+    properties[propertyName] = value;
+  }
+  return properties;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeExtractor,
+  extractNodeProperties
+});

package/libs/cli/code-graph/src/lib/v2/extractors/index.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var extractors_exports = {};
+module.exports = __toCommonJS(extractors_exports);
+__reExport(extractors_exports, require("./extractor"), module.exports);
+__reExport(extractors_exports, require("./extractor.doc"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./extractor"),
+  ...require("./extractor.doc")
+});

package/libs/cli/code-graph/src/lib/v2/graph-builder/code-graph.builder.js

@@ -0,0 +1,76 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var code_graph_builder_exports = {};
+__export(code_graph_builder_exports, {
+  buildCodeGraph: () => buildCodeGraph
+});
+module.exports = __toCommonJS(code_graph_builder_exports);
+var import_typescript = require("@cli/typescript");
+var import_codegular = require("@core/codegular");
+var ts = __toESM(require("typescript"));
+var import_node = require("./node.processor");
+const buildCodeGraph = (program, config) => {
+  const codeGraph = {
+    nodesById: {},
+    edgesBySource: {},
+    edgesByTarget: {}
+  };
+  const sourceFiles = (0, import_codegular.getSolutionSourceFiles)(program);
+  const context = {
+    typeChecker: program.getTypeChecker(),
+    typeResolutionTracker: new import_typescript.TypeResolutionTracker(),
+    declarationRegistry: new import_typescript.DeclarationRegistry()
+  };
+  sourceFiles.forEach((sourceFile) => {
+    Object.keys(config.nodeExtractors).forEach((kindName) => {
+      const nodes = (0, import_codegular.getDescendantsByKind)(sourceFile, ts.SyntaxKind[kindName]);
+      nodes.forEach((node) => {
+        const extractorContext = {
+          args: {
+            current: node,
+            sourceFile,
+            typeChecker: program.getTypeChecker(),
+            ts
+          },
+          helpers: {
+            getDescendantsBy: import_codegular.getDescendantsBy,
+            getAncestorsBy: import_codegular.getAncestorsBy,
+            getType: (node2) => (0, import_typescript.getType)(node2, context.typeChecker, context.typeResolutionTracker),
+            getDeclarations: (node2) => (0, import_codegular.getDeclarations)(node2, context.typeChecker)
+          }
+        };
+        (0, import_node.processNode)(extractorContext, config.nodeExtractors, codeGraph);
+      });
+    });
+  });
+  return codeGraph;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCodeGraph
+});

package/libs/cli/code-graph/src/lib/v2/graph-builder/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graph_builder_exports = {};
+module.exports = __toCommonJS(graph_builder_exports);
+__reExport(graph_builder_exports, require("./code-graph.builder"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./code-graph.builder")
+});

package/libs/cli/code-graph/src/lib/v2/graph-builder/node.processor.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_processor_exports = {};
+__export(node_processor_exports, {
+  processNode: () => processNode
+});
+module.exports = __toCommonJS(node_processor_exports);
+var import_typescript = require("@cli/typescript");
+var import_codegular = require("@core/codegular");
+var import_core = require("../../core/core");
+var import_extractors = require("../extractors");
+var import_relationship = require("./relationship.processor");
+const ts = require("typescript");
+const processNode = (context, nodeExtractors, codeGraph) => {
+  const nodeId = (0, import_core.generateNodeId)({
+    filePath: (0, import_codegular.getFilePath)(context.args.current),
+    range: (0, import_codegular.getRange)(context.args.current)
+  });
+  const kindName = (0, import_typescript.getSyntaxKindName)(context.args.current.kind);
+  const nodeConfig = nodeExtractors[kindName];
+  const graphNode = {
+    ...nodeConfig && nodeConfig.properties ? (0, import_extractors.extractNodeProperties)(context, nodeConfig.properties) : {},
+    id: nodeId,
+    labels: [kindName]
+  };
+  (0, import_typescript.addNode)(codeGraph, graphNode);
+  (0, import_relationship.processRelationships)(nodeId, context, nodeConfig, codeGraph);
+  return graphNode;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processNode
+});

package/libs/cli/code-graph/src/lib/v2/graph-builder/relationship.processor.js

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var relationship_processor_exports = {};
+__export(relationship_processor_exports, {
+  processRelationships: () => processRelationships
+});
+module.exports = __toCommonJS(relationship_processor_exports);
+var import_typescript = require("@cli/typescript");
+var import_extractors = require("../extractors");
+var import_node = require("./node.processor");
+var import_type = require("./type.processor");
+const ts = require("typescript");
+function isTsNode(obj) {
+  return obj && "kind" in obj && typeof obj.kind === "number";
+}
+function isTsType(obj) {
+  return obj && "flags" in obj && typeof obj.flags === "number" && !("kind" in obj);
+}
+const processRelationships = (parentId, context, nodeConfig, codeGraph) => {
+  if (nodeConfig?.relationships) {
+    for (const relationshipName of Object.keys(nodeConfig.relationships)) {
+      const relationshipExtractorFnCode = nodeConfig.relationships[relationshipName].extractorCode;
+      const relationshipNodeExtractors = nodeConfig.relationships[relationshipName].nodeExtractors;
+      Object.keys(relationshipNodeExtractors).forEach((label) => {
+        const children = (0, import_extractors.executeExtractor)(relationshipExtractorFnCode, context);
+        children.forEach(
+          (child) => {
+            if (isTsType(child)) {
+              const childNode = (0, import_type.processType)(
+                { ...context, args: { ...context.args, current: child } },
+                relationshipNodeExtractors,
+                codeGraph
+              );
+              (0, import_typescript.addEdge)(codeGraph, {
+                source: parentId,
+                target: childNode.id,
+                type: relationshipName
+              });
+            } else if (isTsNode(child)) {
+              const childNode = (0, import_node.processNode)(
+                { ...context, args: { ...context.args, current: child } },
+                relationshipNodeExtractors,
+                codeGraph
+              );
+              (0, import_typescript.addEdge)(codeGraph, {
+                source: parentId,
+                target: childNode.id,
+                type: relationshipName
+              });
+            } else {
+              throw new Error(
+                `The code provided: ${relationshipExtractorFnCode} returned an invalid child: ${child}. We support only ts.Node and ts.Type array returns from executed code`
+              );
+            }
+          }
+        );
+      });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processRelationships
+});