@grafema/core 0.2.5-beta → 0.2.7

package/src/core/NodeFactory.ts

@@ -1,17 +1,12 @@
 /**
- * NodeFactory - centralized graph node creation
+ * NodeFactory - centralized graph node creation (facade)
  *
- * Single point for creating all node types with:
- * - Required field validation
- * - Standard field set for each type
- * - Automatic ID generation
+ * Single point for creating all node types. Delegates to domain-specific
+ * factories in ./factories/ while maintaining a unified public API.
  *
- * Delegates creation to node contracts from ./nodes/
+ * All callers use NodeFactory.createX() - the domain split is an internal detail.
  */
 
-import { createHash } from 'crypto';
-import { basename, relative } from 'path';
-
 import {
   ServiceNode,
   EntrypointNode,
@@ -37,199 +32,39 @@ import {
   ClassNode,
   ExportNode,
   ExternalModuleNode,
+  ExternalFunctionNode,
   InterfaceNode,
   TypeNode,
+  TypeParameterNode,
   EnumNode,
   DecoratorNode,
   ExpressionNode,
-  ArgumentExpressionNode,
   IssueNode,
   PluginNode,
-  type EntrypointType,
-  type EntrypointTrigger,
-  type DecoratorTargetType,
-  type InterfacePropertyRecord,
-  type EnumMemberRecord,
-  type IssueSeverity,
+  RustModuleNode,
+  RustFunctionNode,
+  RustStructNode,
+  RustImplNode,
+  RustMethodNode,
+  RustTraitNode,
+  RustCallNode,
+  ReactNode,
+  SocketIONode,
+  SocketConnectionNode,
+  DatabaseNode,
+  ServiceLayerNode,
 } from './nodes/index.js';
 
 import type { BaseNodeRecord } from '@grafema/types';
-import { brandNode } from '@grafema/types';
-import type { ScopeContext } from './SemanticId.js';
-
-interface ServiceOptions {
-  version?: string;
-  entrypoint?: string;
-  discoveryMethod?: string;
-  description?: string;
-  dependencies?: string[];
-  serviceType?: string;
-  testFiles?: string[];
-  metadata?: {
-    type?: string;
-    testFiles?: string[];
-  };
-}
-
-interface EntrypointOptions {
-  id?: string;
-  name?: string;
-  trigger?: EntrypointTrigger;
-  source?: string;
-  serviceId?: string;
-}
-
-interface ModuleOptions {
-  contentHash?: string;
-  isTest?: boolean;
-}
-
-interface ModuleContextOptions {
-  contentHash?: string;
-  isTest?: boolean;
-}
-
-interface FunctionOptions {
-  async?: boolean;
-  generator?: boolean;
-  exported?: boolean;
-  arrowFunction?: boolean;
-  parentScopeId?: string;
-  isClassMethod?: boolean;
-  className?: string;
-  params?: string[];
-  counter?: number;
-}
-
-interface ScopeOptions {
-  name?: string;
-  conditional?: boolean;
-  parentScopeId?: string;
-  parentFunctionId?: string;
-  capturesFrom?: string[];
-  counter?: number;
-}
-
-interface CallSiteOptions {
-  parentScopeId?: string;
-  counter?: number;
-}
-
-interface MethodCallOptions {
-  parentScopeId?: string;
-  args?: unknown[];
-  counter?: number;
-}
-
-interface ConstructorCallOptions {
-  counter?: number;
-}
-
-interface VariableOptions {
-  parentScopeId?: string;
-  counter?: number;
-}
-
-interface ConstantOptions {
-  value?: unknown;
-  parentScopeId?: string;
-  counter?: number;
-}
-
-interface LiteralOptions {
-  parentCallId?: string;
-  argIndex?: number;
-  counter?: number;
-}
-
-interface ObjectLiteralOptions {
-  parentCallId?: string;
-  argIndex?: number;
-  counter?: number;
-}
 
-interface ArrayLiteralOptions {
-  parentCallId?: string;
-  argIndex?: number;
-  counter?: number;
-}
-
-interface EventListenerOptions {
-  parentScopeId?: string;
-  callbackArg?: string;
-  counter?: number;
-}
-
-interface HttpRequestOptions {
-  parentScopeId?: string;
-  counter?: number;
-}
-
-interface DatabaseQueryOptions {
-  parentScopeId?: string;
-}
-
-interface ImportOptions {
-  importType?: 'default' | 'named' | 'namespace';
-  importBinding?: 'value' | 'type' | 'typeof';
-  imported?: string;
-  local?: string;
-}
-
-interface ClassOptions {
-  exported?: boolean;
-  superClass?: string;
-  methods?: string[];
-  isInstantiationRef?: boolean;
-}
-
-interface ExportOptions {
-  exportKind?: 'value' | 'type';
-  local?: string;
-  default?: boolean;
-  source?: string;
-  exportType?: 'default' | 'named' | 'all';
-}
-
-interface InterfaceOptions {
-  extends?: string[];
-  properties?: InterfacePropertyRecord[];
-  isExternal?: boolean;
-}
-
-interface TypeOptions {
-  aliasOf?: string;
-}
-
-interface EnumOptions {
-  isConst?: boolean;
-  members?: EnumMemberRecord[];
-}
-
-interface DecoratorOptions {
-  arguments?: unknown[];
-}
-
-interface ExpressionOptions {
-  // MemberExpression
-  object?: string;
-  property?: string;
-  computed?: boolean;
-  computedPropertyVar?: string;
-  // Binary/Logical
-  operator?: string;
-  // Tracking
-  path?: string;
-  baseName?: string;
-  propertyPath?: string[];
-  arrayIndex?: number;
-}
-
-interface ArgumentExpressionOptions extends ExpressionOptions {
-  parentCallId: string;
-  argIndex: number;
-  counter?: number;
-}
+import { CoreFactory } from './factories/CoreFactory.js';
+import { HttpFactory } from './factories/HttpFactory.js';
+import { RustFactory } from './factories/RustFactory.js';
+import { ReactFactory } from './factories/ReactFactory.js';
+import { SocketFactory } from './factories/SocketFactory.js';
+import { DatabaseFactory } from './factories/DatabaseFactory.js';
+import { ServiceFactory } from './factories/ServiceFactory.js';
+import { ExternalFactory } from './factories/ExternalFactory.js';
 
 // Validator type for node classes
 interface NodeValidator {
@@ -237,459 +72,118 @@ interface NodeValidator {
 }
 
 export class NodeFactory {
-  /**
-   * Create SERVICE node
-   */
-  static createService(name: string, projectPath: string, options: ServiceOptions = {}) {
-    return brandNode(ServiceNode.create(name, projectPath, options));
-  }
-
-  /**
-   * Create ENTRYPOINT node
-   */
-  static createEntrypoint(file: string, entrypointType: EntrypointType, options: EntrypointOptions = {}) {
-    return brandNode(EntrypointNode.create(file, entrypointType, options));
-  }
-
-  /**
-   * Create MODULE node (LEGACY)
-   */
-  static createModule(filePath: string, projectPath: string, options: ModuleOptions = {}) {
-    if (!filePath) throw new Error('NodeFactory.createModule: filePath is required');
-    if (!projectPath) throw new Error('NodeFactory.createModule: projectPath is required');
-
-    const contentHash = options.contentHash || this._hashFile(filePath);
-    const relativePath = relative(projectPath, filePath) || basename(filePath);
-
-    return brandNode(ModuleNode.create(filePath, relativePath, contentHash, options));
-  }
-
-  /**
-   * Create MODULE node with semantic ID (NEW API)
-   *
-   * Uses ScopeContext for stable identifiers.
-   *
-   * @param context - Scope context with file path (relative to project root)
-   * @param options - Optional contentHash and isTest flag
-   * @returns ModuleNodeRecord with semantic ID
-   */
-  static createModuleWithContext(context: ScopeContext, options: ModuleContextOptions = {}) {
-    return brandNode(ModuleNode.createWithContext(context, options));
-  }
-
-  /**
-   * Create FUNCTION node
-   */
-  static createFunction(name: string, file: string, line: number, column: number, options: FunctionOptions = {}) {
-    return brandNode(FunctionNode.create(name, file, line, column, options));
-  }
-
-  /**
-   * Create SCOPE node
-   */
-  static createScope(scopeType: string, file: string, line: number, options: ScopeOptions = {}) {
-    return brandNode(ScopeNode.create(scopeType, file, line, options));
-  }
-
-  /**
-   * Create BRANCH node
-   */
-  static createBranch(branchType: 'switch' | 'if' | 'ternary', file: string, line: number, column: number, options: { parentScopeId?: string; counter?: number } = {}) {
-    return brandNode(BranchNode.create(branchType, file, line, column, options));
-  }
-
-  /**
-   * Create CASE node
-   */
-  static createCase(
-    value: unknown,
-    isDefault: boolean,
-    fallsThrough: boolean,
-    isEmpty: boolean,
-    file: string,
-    line: number,
-    column: number,
-    options: { parentBranchId?: string; counter?: number } = {}
-  ) {
-    return brandNode(CaseNode.create(value, isDefault, fallsThrough, isEmpty, file, line, column, options));
-  }
-
-  /**
-   * Create CALL_SITE node
-   */
-  static createCallSite(targetName: string, file: string, line: number, column: number, options: CallSiteOptions = {}) {
-    return brandNode(CallSiteNode.create(targetName, file, line, column, options));
-  }
-
-  /**
-   * Create METHOD_CALL node
-   */
-  static createMethodCall(objectName: string | undefined, methodName: string, file: string, line: number, column: number, options: MethodCallOptions = {}) {
-    return brandNode(MethodCallNode.create(objectName, methodName, file, line, column, options));
-  }
-
-  /**
-   * Create CONSTRUCTOR_CALL node
-   *
-   * Represents a `new ClassName()` expression.
-   * Used for data flow: VARIABLE --ASSIGNED_FROM--> CONSTRUCTOR_CALL
-   *
-   * @param className - Name of the constructor (e.g., 'Date', 'MyClass')
-   * @param file - File path
-   * @param line - Line number
-   * @param column - Column position
-   * @param options - Optional counter for disambiguation
-   */
-  static createConstructorCall(className: string, file: string, line: number, column: number, options: ConstructorCallOptions = {}) {
-    return brandNode(ConstructorCallNode.create(className, file, line, column, options));
-  }
-
-  /**
-   * Generate CONSTRUCTOR_CALL node ID without creating the full node
-   *
-   * Used by JSASTAnalyzer when creating assignment metadata.
-   * The full node is created later by GraphBuilder.
-   */
-  static generateConstructorCallId(className: string, file: string, line: number, column: number, options: ConstructorCallOptions = {}): string {
-    return ConstructorCallNode.generateId(className, file, line, column, options);
-  }
-
-  /**
-   * Check if a class name is a built-in JavaScript constructor
-   */
-  static isBuiltinConstructor(className: string): boolean {
-    return ConstructorCallNode.isBuiltinConstructor(className);
-  }
-
-  /**
-   * Create VARIABLE_DECLARATION node
-   */
-  static createVariableDeclaration(name: string, file: string, line: number, column: number, options: VariableOptions = {}) {
-    return brandNode(VariableDeclarationNode.create(name, file, line, column, options));
-  }
-
-  /**
-   * Create CONSTANT node
-   */
-  static createConstant(name: string, file: string, line: number, column: number, options: ConstantOptions = {}) {
-    return brandNode(ConstantNode.create(name, file, line, column, options));
-  }
-
-  /**
-   * Create LITERAL node
-   */
-  static createLiteral(value: unknown, file: string, line: number, column: number, options: LiteralOptions = {}) {
-    return brandNode(LiteralNode.create(value, file, line, column, options));
-  }
-
-  /**
-   * Create OBJECT_LITERAL node
-   */
-  static createObjectLiteral(file: string, line: number, column: number, options: ObjectLiteralOptions = {}) {
-    return brandNode(ObjectLiteralNode.create(file, line, column, options));
-  }
-
-  /**
-   * Create ARRAY_LITERAL node
-   */
-  static createArrayLiteral(file: string, line: number, column: number, options: ArrayLiteralOptions = {}) {
-    return brandNode(ArrayLiteralNode.create(file, line, column, options));
-  }
-
-  /**
-   * Create EXTERNAL_STDIO node (singleton)
-   */
-  static createExternalStdio() {
-    return brandNode(ExternalStdioNode.create());
-  }
-
-  /**
-   * Create net:request singleton node
-   *
-   * This node represents the external network as a system resource.
-   * Should be created once per graph.
-   *
-   * All HTTP_REQUEST nodes connect to this singleton via CALLS edges.
-   *
-   * @returns NetworkRequestNodeRecord - singleton node
-   */
-  static createNetworkRequest() {
-    return brandNode(NetworkRequestNode.create());
-  }
-
-  /**
-   * Create EVENT_LISTENER node
-   */
-  static createEventListener(eventName: string, objectName: string | undefined, file: string, line: number, column: number, options: EventListenerOptions = {}) {
-    return brandNode(EventListenerNode.create(eventName, objectName, file, line, column, options));
-  }
-
-  /**
-   * Create HTTP_REQUEST node
-   */
-  static createHttpRequest(url: string | undefined, method: string | undefined, file: string, line: number, column: number, options: HttpRequestOptions = {}) {
-    return brandNode(HttpRequestNode.create(url, method, file, line, column, options));
-  }
-
-  /**
-   * Create DATABASE_QUERY node
-   */
-  static createDatabaseQuery(query: string | undefined, operation: string | undefined, file: string, line: number, column: number, options: DatabaseQueryOptions = {}) {
-    return brandNode(DatabaseQueryNode.create(query, operation, file, line, column, options));
-  }
-
-  /**
-   * Create IMPORT node
-   *
-   * ImportNode automatically detects importType from imported field:
-   * - imported === 'default' → importType: 'default'
-   * - imported === '*' → importType: 'namespace'
-   * - anything else → importType: 'named'
-   *
-   * @param name - Local binding name (how it's used in this file)
-   * @param file - Absolute file path
-   * @param line - Line number (for debugging, not part of ID)
-   * @param column - Column position (0 if unavailable)
-   * @param source - Source module (e.g., 'react', './utils')
-   * @param options - Optional fields
-   * @returns ImportNodeRecord
-   */
-  static createImport(
-    name: string,
-    file: string,
-    line: number,
-    column: number,
-    source: string,
-    options: ImportOptions = {}
-  ) {
-    return brandNode(ImportNode.create(name, file, line, column, source, options));
-  }
-
-  /**
-   * Create CLASS node
-   */
-  static createClass(
-    name: string,
-    file: string,
-    line: number,
-    column: number,
-    options: ClassOptions = {}
-  ) {
-    return brandNode(ClassNode.create(name, file, line, column, options));
-  }
-
-  /**
-   * Create EXPORT node
-   */
-  static createExport(
-    name: string,
-    file: string,
-    line: number,
-    column: number,
-    options: ExportOptions = {}
-  ) {
-    return brandNode(ExportNode.create(name, file, line, column, options));
-  }
-
-  /**
-   * Create EXTERNAL_MODULE node
-   *
-   * Represents external npm packages or Node.js built-in modules.
-   * Uses singleton pattern - same source always produces same ID.
-   *
-   * @param source - Module name (e.g., 'lodash', '@tanstack/react-query', 'node:fs')
-   */
-  static createExternalModule(source: string) {
-    return brandNode(ExternalModuleNode.create(source));
-  }
-
-  /**
-   * Create INTERFACE node
-   */
-  static createInterface(
-    name: string,
-    file: string,
-    line: number,
-    column: number,
-    options: InterfaceOptions = {}
-  ) {
-    return brandNode(InterfaceNode.create(name, file, line, column, options));
-  }
-
-  /**
-   * Create TYPE node
-   */
-  static createType(
-    name: string,
-    file: string,
-    line: number,
-    column: number,
-    options: TypeOptions = {}
-  ) {
-    return brandNode(TypeNode.create(name, file, line, column, options));
-  }
-
-  /**
-   * Create ENUM node
-   */
-  static createEnum(
-    name: string,
-    file: string,
-    line: number,
-    column: number,
-    options: EnumOptions = {}
-  ) {
-    return brandNode(EnumNode.create(name, file, line, column, options));
-  }
-
-  /**
-   * Create DECORATOR node
-   */
-  static createDecorator(
-    name: string,
-    file: string,
-    line: number,
-    column: number,
-    targetId: string,
-    targetType: DecoratorTargetType,
-    options: DecoratorOptions = {}
-  ) {
-    return brandNode(DecoratorNode.create(name, file, line, column, targetId, targetType, options));
-  }
-
-  /**
-   * Create EXPRESSION node
-   */
-  static createExpression(
-    expressionType: string,
-    file: string,
-    line: number,
-    column: number,
-    options: ExpressionOptions = {}
-  ) {
-    return brandNode(ExpressionNode.create(expressionType, file, line, column, options));
-  }
-
-  /**
-   * Generate EXPRESSION node ID without creating the full node
-   *
-   * Used by JSASTAnalyzer when creating assignment metadata.
-   * The full node is created later by GraphBuilder.
-   *
-   * @param expressionType - Type of expression (MemberExpression, BinaryExpression, etc.)
-   * @param file - File path
-   * @param line - Line number
-   * @param column - Column position
-   * @returns Generated ID string in colon format
-   */
-  static generateExpressionId(
-    expressionType: string,
-    file: string,
-    line: number,
-    column: number
-  ): string {
-    return ExpressionNode.generateId(expressionType, file, line, column);
-  }
-
-  /**
-   * Create EXPRESSION node from assignment metadata
-   *
-   * Used by GraphBuilder when processing variableAssignments.
-   * The ID is provided from upstream (generated by JSASTAnalyzer).
-   *
-   * @param expressionType - Type of expression
-   * @param file - File path
-   * @param line - Line number
-   * @param column - Column position
-   * @param options - Must include id; optional: expression properties
-   */
-  static createExpressionFromMetadata(
-    expressionType: string,
-    file: string,
-    line: number,
-    column: number,
-    options: ExpressionOptions & { id: string }
-  ) {
-    return brandNode(ExpressionNode.createFromMetadata(expressionType, file, line, column, options));
-  }
-
-  /**
-   * Create EXPRESSION node with argument context
-   *
-   * Used when EXPRESSION appears as a call argument and we need to track
-   * which call and argument position for data flow analysis.
-   *
-   * @param expressionType - Type of expression (BinaryExpression, LogicalExpression, etc.)
-   * @param file - File path
-   * @param line - Line number
-   * @param column - Column position
-   * @param options - Required: parentCallId, argIndex; Optional: expression properties, counter
-   * @returns ArgumentExpressionNodeRecord
-   */
-  static createArgumentExpression(
-    expressionType: string,
-    file: string,
-    line: number,
-    column: number,
-    options: ArgumentExpressionOptions
-  ) {
-    return brandNode(ArgumentExpressionNode.create(expressionType, file, line, column, options));
-  }
-
-  /**
-   * Create ISSUE node
-   *
-   * Issues represent detected problems in the codebase.
-   * Used by validation plugins to persist findings in the graph.
-   *
-   * @param category - Issue category (security, performance, style, smell)
-   * @param severity - error | warning | info
-   * @param message - Human-readable description
-   * @param plugin - Name of the plugin that detected this issue
-   * @param file - File path where issue was detected
-   * @param line - Line number
-   * @param column - Column number (optional)
-   * @param options - Optional context data
-   */
-  static createIssue(
-    category: string,
-    severity: IssueSeverity,
-    message: string,
-    plugin: string,
-    file: string,
-    line: number,
-    column: number = 0,
-    options: { context?: Record<string, unknown> } = {}
-  ) {
-    return brandNode(IssueNode.create(category, severity, message, plugin, file, line, column, options));
-  }
-
-  /**
-   * Create grafema:plugin node.
-   *
-   * Represents a Grafema plugin in the analysis pipeline.
-   * Created by the Orchestrator at startup to make the pipeline
-   * queryable via the graph.
-   *
-   * @param name - Plugin class name (e.g., 'HTTPConnectionEnricher')
-   * @param phase - Plugin phase (DISCOVERY, INDEXING, ANALYSIS, ENRICHMENT, VALIDATION)
-   * @param options - Optional fields (priority, file, builtin, creates, dependencies)
-   */
-  static createPlugin(
-    name: string,
-    phase: string,
-    options: {
-      priority?: number;
-      file?: string;
-      line?: number;
-      builtin?: boolean;
-      createsNodes?: string[];
-      createsEdges?: string[];
-      dependencies?: string[];
-    } = {}
-  ) {
-    return brandNode(PluginNode.create(name, phase, options));
-  }
+  // ==========================================
+  // Core node types (delegate to CoreFactory)
+  // ==========================================
+
+  static createService = CoreFactory.createService.bind(CoreFactory);
+  static createEntrypoint = CoreFactory.createEntrypoint.bind(CoreFactory);
+  static createModule = CoreFactory.createModule.bind(CoreFactory);
+  static createModuleWithContext = CoreFactory.createModuleWithContext.bind(CoreFactory);
+  static createFunction = CoreFactory.createFunction.bind(CoreFactory);
+  static createScope = CoreFactory.createScope.bind(CoreFactory);
+  static createBranch = CoreFactory.createBranch.bind(CoreFactory);
+  static createCase = CoreFactory.createCase.bind(CoreFactory);
+  static createCallSite = CoreFactory.createCallSite.bind(CoreFactory);
+  static createMethodCall = CoreFactory.createMethodCall.bind(CoreFactory);
+  static createConstructorCall = CoreFactory.createConstructorCall.bind(CoreFactory);
+  static generateConstructorCallId = CoreFactory.generateConstructorCallId.bind(CoreFactory);
+  static isBuiltinConstructor = CoreFactory.isBuiltinConstructor.bind(CoreFactory);
+  static createVariableDeclaration = CoreFactory.createVariableDeclaration.bind(CoreFactory);
+  static createConstant = CoreFactory.createConstant.bind(CoreFactory);
+  static createLiteral = CoreFactory.createLiteral.bind(CoreFactory);
+  static createObjectLiteral = CoreFactory.createObjectLiteral.bind(CoreFactory);
+  static createArrayLiteral = CoreFactory.createArrayLiteral.bind(CoreFactory);
+  static createExternalStdio = CoreFactory.createExternalStdio.bind(CoreFactory);
+  static createEventListener = CoreFactory.createEventListener.bind(CoreFactory);
+  static createImport = CoreFactory.createImport.bind(CoreFactory);
+  static createClass = CoreFactory.createClass.bind(CoreFactory);
+  static createExport = CoreFactory.createExport.bind(CoreFactory);
+  static createInterface = CoreFactory.createInterface.bind(CoreFactory);
+  static createType = CoreFactory.createType.bind(CoreFactory);
+  static createTypeParameter = CoreFactory.createTypeParameter.bind(CoreFactory);
+  static createEnum = CoreFactory.createEnum.bind(CoreFactory);
+  static createDecorator = CoreFactory.createDecorator.bind(CoreFactory);
+  static createExpression = CoreFactory.createExpression.bind(CoreFactory);
+  static generateExpressionId = CoreFactory.generateExpressionId.bind(CoreFactory);
+  static createExpressionFromMetadata = CoreFactory.createExpressionFromMetadata.bind(CoreFactory);
+  static createArgumentExpression = CoreFactory.createArgumentExpression.bind(CoreFactory);
+  static createIssue = CoreFactory.createIssue.bind(CoreFactory);
+  static createPlugin = CoreFactory.createPlugin.bind(CoreFactory);
+  static _hashFile = CoreFactory._hashFile.bind(CoreFactory);
+
+  // ==========================================
+  // HTTP domain (delegate to HttpFactory)
+  // ==========================================
+
+  static createNetworkRequest = HttpFactory.createNetworkRequest.bind(HttpFactory);
+  static createHttpRoute = HttpFactory.createHttpRoute.bind(HttpFactory);
+  static createFetchRequest = HttpFactory.createFetchRequest.bind(HttpFactory);
+  static createExpressMount = HttpFactory.createExpressMount.bind(HttpFactory);
+  static createExpressMiddleware = HttpFactory.createExpressMiddleware.bind(HttpFactory);
+  static createExternalApi = HttpFactory.createExternalApi.bind(HttpFactory);
+  static createHttpRequest = HttpFactory.createHttpRequest.bind(HttpFactory);
+
+  // ==========================================
+  // Rust domain (delegate to RustFactory)
+  // ==========================================
+
+  static createRustModule = RustFactory.createRustModule.bind(RustFactory);
+  static createRustFunction = RustFactory.createRustFunction.bind(RustFactory);
+  static createRustStruct = RustFactory.createRustStruct.bind(RustFactory);
+  static createRustImpl = RustFactory.createRustImpl.bind(RustFactory);
+  static createRustMethod = RustFactory.createRustMethod.bind(RustFactory);
+  static createRustTrait = RustFactory.createRustTrait.bind(RustFactory);
+  static createRustCall = RustFactory.createRustCall.bind(RustFactory);
+
+  // ==========================================
+  // React domain (delegate to ReactFactory)
+  // ==========================================
+
+  static createReactNode = ReactFactory.createReactNode.bind(ReactFactory);
+
+  // ==========================================
+  // Socket domain (delegate to SocketFactory)
+  // ==========================================
+
+  static createSocketIOEmit = SocketFactory.createSocketIOEmit.bind(SocketFactory);
+  static createSocketIOListener = SocketFactory.createSocketIOListener.bind(SocketFactory);
+  static createSocketIORoom = SocketFactory.createSocketIORoom.bind(SocketFactory);
+  static createSocketIOEvent = SocketFactory.createSocketIOEvent.bind(SocketFactory);
+  static createUnixSocket = SocketFactory.createUnixSocket.bind(SocketFactory);
+  static createTcpConnection = SocketFactory.createTcpConnection.bind(SocketFactory);
+  static createUnixServer = SocketFactory.createUnixServer.bind(SocketFactory);
+  static createTcpServer = SocketFactory.createTcpServer.bind(SocketFactory);
+
+  // ==========================================
+  // Database domain (delegate to DatabaseFactory)
+  // ==========================================
+
+  static createDatabaseQuery = DatabaseFactory.createDatabaseQuery.bind(DatabaseFactory);
+  static createDbConnection = DatabaseFactory.createDbConnection.bind(DatabaseFactory);
+  static createDbQuery = DatabaseFactory.createDbQuery.bind(DatabaseFactory);
+  static createSQLiteQuery = DatabaseFactory.createSQLiteQuery.bind(DatabaseFactory);
+  static createDbTable = DatabaseFactory.createDbTable.bind(DatabaseFactory);
+
+  // ==========================================
+  // Service Layer (delegate to ServiceFactory)
+  // ==========================================
+
+  static createServiceClass = ServiceFactory.createServiceClass.bind(ServiceFactory);
+  static createServiceInstance = ServiceFactory.createServiceInstance.bind(ServiceFactory);
+  static createServiceRegistration = ServiceFactory.createServiceRegistration.bind(ServiceFactory);
+  static createServiceUsage = ServiceFactory.createServiceUsage.bind(ServiceFactory);
+
+  // ==========================================
+  // External modules (delegate to ExternalFactory)
+  // ==========================================
+
+  static createExternalModule = ExternalFactory.createExternalModule.bind(ExternalFactory);
+  static createExternalFunction = ExternalFactory.createExternalFunction.bind(ExternalFactory);
+
+  // ==========================================
+  // Validation (stays in facade - needs all node types)
+  // ==========================================
 
   /**
    * Validate node by its type
@@ -720,11 +214,20 @@ export class NodeFactory {
       'CLASS': ClassNode,
       'EXPORT': ExportNode,
       'EXTERNAL_MODULE': ExternalModuleNode,
+      'EXTERNAL_FUNCTION': ExternalFunctionNode,
       'INTERFACE': InterfaceNode,
       'TYPE': TypeNode,
+      'TYPE_PARAMETER': TypeParameterNode,
       'ENUM': EnumNode,
       'DECORATOR': DecoratorNode,
-      'EXPRESSION': ExpressionNode
+      'EXPRESSION': ExpressionNode,
+      'RUST_MODULE': RustModuleNode,
+      'RUST_FUNCTION': RustFunctionNode,
+      'RUST_STRUCT': RustStructNode,
+      'RUST_IMPL': RustImplNode,
+      'RUST_METHOD': RustMethodNode,
+      'RUST_TRAIT': RustTraitNode,
+      'RUST_CALL': RustCallNode,
     };
 
     // Handle issue:* types dynamically
@@ -737,6 +240,31 @@ export class NodeFactory {
       return PluginNode.validate(node);
     }
 
+    // Handle React domain types (react:*, dom:*, browser:*, canvas:*)
+    if (ReactNode.isReactDomainType(node.type)) {
+      return ReactNode.validate(node);
+    }
+
+    // Handle Socket.IO types (socketio:*)
+    if (SocketIONode.isSocketIOType(node.type)) {
+      return SocketIONode.validate(node);
+    }
+
+    // Handle socket types (os:unix-*, net:tcp-*)
+    if (SocketConnectionNode.isSocketType(node.type)) {
+      return SocketConnectionNode.validate(node);
+    }
+
+    // Handle database domain types (db:*)
+    if (DatabaseNode.isDatabaseType(node.type)) {
+      return DatabaseNode.validate(node);
+    }
+
+    // Handle service layer types (SERVICE_*)
+    if (ServiceLayerNode.isServiceLayerType(node.type)) {
+      return ServiceLayerNode.validate(node);
+    }
+
     const validator = validators[node.type];
     if (!validator) {
       return [`Unknown node type: ${node.type}`];
@@ -744,11 +272,4 @@ export class NodeFactory {
 
     return validator.validate(node);
   }
-
-  /**
-   * Helper: hash file path for stable ID
-   */
-  static _hashFile(filePath: string): string {
-    return createHash('md5').update(filePath).digest('hex').substring(0, 12);
-  }
 }