@hexaijs/plugin-application-builder 0.1.2 → 0.2.0

package/dist/cli.d.ts

@@ -1,3 +1 @@
 #!/usr/bin/env node
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -1,61 +1,578 @@
 #!/usr/bin/env node
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+import * as path from 'path';
+import * as fs from 'fs';
+import { glob } from 'glob';
+import * as ts from 'typescript';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
+
+// src/errors.ts
+var DuplicateCommandHandlerError = class extends Error {
+  constructor(commandClassName, handlers) {
+    super(
+      `Duplicate command handlers for "${commandClassName}": ${handlers.join(", ")}`
+    );
+    this.name = "DuplicateCommandHandlerError";
+  }
+};
+var DuplicateEventHandlerError = class extends Error {
+  constructor(eventName, handlers) {
+    super(
+      `Duplicate event handlers for event "${eventName}": ${handlers.join(", ")}`
+    );
+    this.name = "DuplicateEventHandlerError";
+  }
+};
+var DuplicateQueryHandlerError = class extends Error {
+  constructor(queryClassName, handlers) {
+    super(
+      `Duplicate query handlers for "${queryClassName}": ${handlers.join(", ")}`
+    );
+    this.name = "DuplicateQueryHandlerError";
+  }
+};
+var MessageClassNotFoundError = class extends Error {
+  constructor(messageClassName, filePath) {
+    super(
+      `Cannot find "${messageClassName}" - not imported and not defined in "${filePath}"`
+    );
+    this.name = "MessageClassNotFoundError";
+  }
+};
+
+// src/metadata-extractor.ts
+var HandlerMetadataExtractor = class {
+  constructor(contextPath, outputFile, config = {}) {
+    this.contextPath = contextPath;
+    this.outputFile = outputFile;
+    if (config.commandHandlerDecorator) {
+      this.config.commandHandlerDecorator = config.commandHandlerDecorator;
+    }
+    if (config.eventHandlerDecorator) {
+      this.config.eventHandlerDecorator = config.eventHandlerDecorator;
+    }
+  }
+  config = {
+    commandHandlerDecorator: "CommandHandlerMarker",
+    eventHandlerDecorator: "EventHandlerMarker"
+  };
+  extractHandlersMetadata(files) {
+    const handlers = [];
+    for (const file of files) {
+      const sourceCode = fs.readFileSync(file, "utf-8");
+      const sourceFile = ts.createSourceFile(
+        file,
+        sourceCode,
+        ts.ScriptTarget.Latest,
+        true
+      );
+      ts.forEachChild(sourceFile, (node) => {
+        if (ts.isClassDeclaration(node)) {
+          const metadata = this.extractFromClass(
+            node,
+            file,
+            sourceFile
+          );
+          if (metadata) {
+            handlers.push(metadata);
+          }
+        }
+      });
+    }
+    return handlers;
+  }
+  extractFromClass(classNode, filePath, sourceFile) {
+    const className = classNode.name?.text;
+    if (!className) return null;
+    const decorators = ts.canHaveDecorators(classNode) ? ts.getDecorators(classNode) : void 0;
+    if (!decorators) return null;
+    for (const decorator of decorators) {
+      const expression = decorator.expression;
+      if (!ts.isCallExpression(expression)) continue;
+      const decoratorName = expression.expression.getText();
+      if (decoratorName === "CommandHandlerMarker") {
+        return this.extractCommandHandlerMetadata(
+          className,
+          expression,
+          filePath,
+          sourceFile
+        );
+      }
+      if (decoratorName === "EventHandlerMarker") {
+        return this.extractEventHandlerMetadata(
+          className,
+          expression,
+          filePath
+        );
+      }
+      if (decoratorName === "QueryHandlerMarker") {
+        return this.extractQueryHandlerMetadata(
+          className,
+          expression,
+          filePath,
+          sourceFile
+        );
+      }
+    }
+    return null;
+  }
+  extractMessageHandlerMetadata(className, expression, filePath, sourceFile) {
+    const messageClassArg = expression.arguments[0];
+    const messageClassName = messageClassArg.getText();
+    const messageImport = this.findImportForSymbol(
+      messageClassName,
+      sourceFile
+    );
+    let messagePath = "";
+    let resolvedMessageClassName = messageClassName;
+    if (messageImport) {
+      const handlerDir = path.dirname(filePath);
+      const resolvedImportPath = this.resolvePathAlias(messageImport.path);
+      const messageAbsolutePath = path.resolve(
+        handlerDir,
+        resolvedImportPath + ".ts"
+      );
+      messagePath = this.toRelativeImport(messageAbsolutePath);
+      resolvedMessageClassName = messageImport.symbol;
+    } else if (this.isClassDefinedInFile(messageClassName, sourceFile)) {
+      messagePath = this.toRelativeImport(filePath);
+    } else {
+      throw new MessageClassNotFoundError(messageClassName, filePath);
+    }
+    return {
+      messagePath,
+      messageClassName: resolvedMessageClassName
     };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
+  }
+  isClassDefinedInFile(className, sourceFile) {
+    for (const statement of sourceFile.statements) {
+      if (ts.isClassDeclaration(statement) && statement.name?.text === className) {
+        return true;
+      }
+    }
+    return false;
+  }
+  extractCommandHandlerMetadata(className, expression, filePath, sourceFile) {
+    const { messagePath, messageClassName } = this.extractMessageHandlerMetadata(
+      className,
+      expression,
+      filePath,
+      sourceFile
+    );
+    return {
+      type: "command",
+      handlerPath: this.toRelativeImport(filePath),
+      handlerClassName: className,
+      commandPath: messagePath,
+      commandClassName: messageClassName
     };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = __importStar(require("path"));
-const index_1 = require("./index");
-async function main() {
-    const args = process.argv.slice(2);
-    // Support --context-path or default to cwd
-    let contextPath = process.cwd();
-    const contextPathIndex = args.indexOf("--context-path");
-    if (contextPathIndex !== -1 && args[contextPathIndex + 1]) {
-        contextPath = path.resolve(args[contextPathIndex + 1]);
-    }
-    try {
-        console.log(`Generating application builder for: ${contextPath}`);
-        await (0, index_1.generateApplicationBuilder)(contextPath);
-        console.log("✓ Application builder generated successfully");
-    }
-    catch (error) {
-        console.error("Error generating application builder:", error);
-        process.exit(1);
+  }
+  extractEventHandlerMetadata(className, expression, filePath) {
+    let options = {};
+    if (expression.arguments.length > 0) {
+      const optionsArg = expression.arguments[0];
+      options = this.parseObjectLiteral(optionsArg);
+    }
+    return {
+      type: "event",
+      handlerPath: this.toRelativeImport(filePath),
+      handlerClassName: className,
+      eventHandlerOptions: options
+    };
+  }
+  extractQueryHandlerMetadata(className, expression, filePath, sourceFile) {
+    const { messagePath, messageClassName } = this.extractMessageHandlerMetadata(
+      className,
+      expression,
+      filePath,
+      sourceFile
+    );
+    return {
+      type: "query",
+      handlerPath: this.toRelativeImport(filePath),
+      handlerClassName: className,
+      queryPath: messagePath,
+      queryClassName: messageClassName
+    };
+  }
+  findImportForSymbol(symbol, sourceFile) {
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement)) {
+        const importClause = statement.importClause;
+        const moduleSpecifier = statement.moduleSpecifier.text;
+        if (importClause?.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
+          for (const element of importClause.namedBindings.elements) {
+            if (element.name.text === symbol) {
+              return {
+                path: moduleSpecifier,
+                symbol: element.name.text
+              };
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  toRelativeImport(absolutePath) {
+    const outputFileAbsolutePath = path.join(
+      this.contextPath,
+      this.outputFile
+    );
+    const outputDir = path.dirname(outputFileAbsolutePath);
+    const relative2 = path.relative(outputDir, absolutePath);
+    const withoutExtension = relative2.replace(/\.ts$/, "");
+    return withoutExtension.startsWith(".") ? withoutExtension : "./" + withoutExtension;
+  }
+  parseObjectLiteral(node) {
+    if (!ts.isObjectLiteralExpression(node)) {
+      return {};
+    }
+    const result = {};
+    for (const property of node.properties) {
+      if (ts.isPropertyAssignment(property)) {
+        const name = property.name.getText();
+        const value = property.initializer;
+        if (ts.isStringLiteral(value)) {
+          result[name] = value.text;
+        } else if (ts.isNumericLiteral(value)) {
+          result[name] = Number(value.text);
+        } else if (value.kind === ts.SyntaxKind.TrueKeyword) {
+          result[name] = true;
+        } else if (value.kind === ts.SyntaxKind.FalseKeyword) {
+          result[name] = false;
+        }
+      }
+    }
+    return result;
+  }
+  resolvePathAlias(importPath) {
+    const tsconfigPath = path.join(this.contextPath, "tsconfig.json");
+    if (!fs.existsSync(tsconfigPath)) return importPath;
+    const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, "utf-8"));
+    const paths = tsconfig.compilerOptions?.paths;
+    const baseUrl = tsconfig.compilerOptions?.baseUrl || ".";
+    if (!paths) return importPath;
+    for (const [alias, targets] of Object.entries(paths)) {
+      const aliasPrefix = alias.replace("/*", "");
+      if (importPath.startsWith(aliasPrefix)) {
+        const targetBase = targets[0].replace("/*", "");
+        const resolvedBase = path.join(this.contextPath, baseUrl, targetBase);
+        return importPath.replace(aliasPrefix, resolvedBase);
+      }
+    }
+    return importPath;
+  }
+};
+
+// src/code-generator.ts
+var ApplicationCodeGenerator = class {
+  constructor(config) {
+    this.config = config;
+  }
+  generateCode(handlers) {
+    this.validateNoDuplicates(handlers);
+    const imports = this.collectImports(handlers);
+    const registrations = this.generateRegistrations(handlers);
+    return this.assembleGeneratedCode(imports, registrations);
+  }
+  validateNoDuplicates(handlers) {
+    this.validateNoDuplicateCommandHandlers(handlers);
+    this.validateNoDuplicateEventHandlers(handlers);
+    this.validateNoDuplicateQueryHandlers(handlers);
+  }
+  validateNoDuplicateHandlers(handlers, typeFilter, keyExtractor, errorFactory) {
+    const filteredHandlers = handlers.filter(typeFilter);
+    const keyToHandlers = /* @__PURE__ */ new Map();
+    for (const handler of filteredHandlers) {
+      const key = keyExtractor(handler);
+      const existing = keyToHandlers.get(key) ?? [];
+      existing.push(handler.handlerClassName);
+      keyToHandlers.set(key, existing);
+    }
+    for (const [key, handlerList] of keyToHandlers) {
+      if (handlerList.length > 1) {
+        throw errorFactory(key, handlerList);
+      }
     }
+  }
+  validateNoDuplicateCommandHandlers(handlers) {
+    this.validateNoDuplicateHandlers(
+      handlers,
+      (h) => h.type === "command",
+      (h) => h.commandClassName,
+      (key, handlers2) => new DuplicateCommandHandlerError(key, handlers2)
+    );
+  }
+  validateNoDuplicateEventHandlers(handlers) {
+    const eventHandlers = handlers.filter(
+      (h) => h.type === "event"
+    );
+    const namedEventHandlers = eventHandlers.filter(
+      (h) => h.eventHandlerOptions.name !== void 0
+    );
+    this.validateNoDuplicateHandlers(
+      namedEventHandlers,
+      (h) => true,
+      (h) => h.eventHandlerOptions.name,
+      (key, handlers2) => new DuplicateEventHandlerError(key, handlers2)
+    );
+  }
+  validateNoDuplicateQueryHandlers(handlers) {
+    this.validateNoDuplicateHandlers(
+      handlers,
+      (h) => h.type === "query",
+      (h) => h.queryClassName,
+      (key, handlers2) => new DuplicateQueryHandlerError(key, handlers2)
+    );
+  }
+  createImportStatement(symbolName, importPath) {
+    return `import { ${symbolName} } from '${importPath}';`;
+  }
+  createCommandHandlerRegistration(commandClassName, handlerClassName) {
+    return `    .withCommandHandler(${commandClassName}, () => new ${handlerClassName}())`;
+  }
+  createEventHandlerRegistration(handlerClassName, eventName) {
+    const nameArg = eventName ? `, '${eventName}'` : "";
+    return `    .withEventHandler(() => new ${handlerClassName}()${nameArg})`;
+  }
+  createQueryHandlerRegistration(queryClassName, handlerClassName) {
+    return `    .withQueryHandler(${queryClassName}, () => new ${handlerClassName}())`;
+  }
+  isCommandHandler(handler) {
+    return handler.type === "command";
+  }
+  isEventHandler(handler) {
+    return handler.type === "event";
+  }
+  isQueryHandler(handler) {
+    return handler.type === "query";
+  }
+  collectImports(handlers) {
+    const imports = /* @__PURE__ */ new Set();
+    imports.add(
+      this.createImportStatement(
+        "ApplicationBuilder",
+        this.config.applicationBuilderImportPath
+      )
+    );
+    for (const handler of handlers) {
+      imports.add(
+        this.createImportStatement(
+          handler.handlerClassName,
+          handler.handlerPath
+        )
+      );
+      if (this.isCommandHandler(handler) && handler.commandPath) {
+        imports.add(
+          this.createImportStatement(
+            handler.commandClassName,
+            handler.commandPath
+          )
+        );
+      }
+      if (this.isQueryHandler(handler) && handler.queryPath) {
+        imports.add(
+          this.createImportStatement(
+            handler.queryClassName,
+            handler.queryPath
+          )
+        );
+      }
+    }
+    return imports;
+  }
+  generateRegistrations(handlers) {
+    const commandRegistrations = this.generateCommandRegistrations(handlers);
+    const queryRegistrations = this.generateQueryRegistrations(handlers);
+    const eventRegistrations = this.generateEventRegistrations(handlers);
+    return [...commandRegistrations, ...queryRegistrations, ...eventRegistrations];
+  }
+  generateCommandRegistrations(handlers) {
+    return handlers.filter(
+      (h) => this.isCommandHandler(h)
+    ).map(
+      (h) => this.createCommandHandlerRegistration(
+        h.commandClassName,
+        h.handlerClassName
+      )
+    );
+  }
+  generateQueryRegistrations(handlers) {
+    return handlers.filter(
+      (h) => this.isQueryHandler(h)
+    ).map(
+      (h) => this.createQueryHandlerRegistration(
+        h.queryClassName,
+        h.handlerClassName
+      )
+    );
+  }
+  generateEventRegistrations(handlers) {
+    return handlers.filter((h) => this.isEventHandler(h)).map((handler) => {
+      this.validateEventHandlerOptions(handler);
+      const eventName = handler.eventHandlerOptions.name;
+      return this.createEventHandlerRegistration(
+        handler.handlerClassName,
+        eventName
+      );
+    });
+  }
+  validateEventHandlerOptions(handler) {
+    const options = handler.eventHandlerOptions;
+    const invalidKeys = Object.keys(options).filter(
+      (key) => key !== "name"
+    );
+    if (invalidKeys.length > 0) {
+      throw new Error(
+        `EventHandler for ${handler.handlerClassName} has invalid options: ${invalidKeys.join(", ")}.
+Only 'name' option is supported. Use @EventHandler({ name: 'event-name' })`
+      );
+    }
+  }
+  assembleGeneratedCode(imports, registrations) {
+    const registrationCode = registrations.length > 0 ? "\n" + registrations.join("\n") : "";
+    return `
+${Array.from(imports).join("\n")}
+
+export function createApplicationBuilder(): ApplicationBuilder {
+  return new ApplicationBuilder()${registrationCode};
 }
-main().catch((error) => {
-    console.error("Unexpected error:", error);
+`;
+  }
+};
+
+// src/application-builder-generator.ts
+var ApplicationBuilderGenerator = class {
+  constructor(contextPath, config) {
+    this.contextPath = contextPath;
+    this.config = config;
+    this.metadataExtractor = new HandlerMetadataExtractor(
+      contextPath,
+      config.outputFile
+    );
+    this.codeGenerator = new ApplicationCodeGenerator(config);
+  }
+  metadataExtractor;
+  codeGenerator;
+  async generate() {
+    const handlerFiles = await this.scanHandlerFiles();
+    const handlers = this.metadataExtractor.extractHandlersMetadata(handlerFiles);
+    const code = this.codeGenerator.generateCode(handlers);
+    this.writeToFile(code);
+  }
+  async scanHandlerFiles() {
+    const allFiles = [];
+    for (const pattern of this.config.handlers) {
+      const files = await glob(pattern, {
+        cwd: this.contextPath,
+        absolute: true
+      });
+      allFiles.push(...files);
+    }
+    return allFiles.sort();
+  }
+  writeToFile(code) {
+    const outputFile = path.join(this.contextPath, this.config.outputFile);
+    const outputDir = path.dirname(outputFile);
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(outputFile, code, "utf-8");
+  }
+};
+
+// src/config.ts
+var BuildPluginConfig = class _BuildPluginConfig {
+  handlers;
+  outputFile;
+  applicationBuilderImportPath;
+  constructor(config) {
+    this.handlers = config.handlers;
+    this.outputFile = config.outputFile;
+    this.applicationBuilderImportPath = config.applicationBuilderImportPath;
+  }
+  static fromRawConfig(raw) {
+    if (!raw.applicationBuilderImportPath) {
+      throw new Error(
+        "applicationBuilderImportPath is required in hexai.config.ts\nExample: { applicationBuilderImportPath: '@/application', ... }"
+      );
+    }
+    if (!raw.handlers || raw.handlers.length === 0) {
+      throw new Error(
+        "handlers array is required and must not be empty in hexai.config.ts"
+      );
+    }
+    return new _BuildPluginConfig({
+      handlers: raw.handlers,
+      outputFile: raw.outputFile ?? "src/.generated/application-builder.ts",
+      applicationBuilderImportPath: raw.applicationBuilderImportPath
+    });
+  }
+};
+
+// src/config-loader.ts
+async function loadConfig(configPath) {
+  const configSource = fs.readFileSync(configPath, "utf-8");
+  const transpiledCode = transpileConfigFile(configSource);
+  const moduleExports = evaluateConfigModule(transpiledCode);
+  const rawConfig = extractConfigFromModule(moduleExports);
+  return BuildPluginConfig.fromRawConfig(rawConfig);
+}
+function transpileConfigFile(source) {
+  const result = ts.transpileModule(source, {
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2020
+    }
+  });
+  return result.outputText;
+}
+function evaluateConfigModule(code) {
+  const tempModule = { exports: {} };
+  const fn = new Function("module", "exports", "require", code);
+  fn(tempModule, tempModule.exports, __require);
+  return tempModule.exports;
+}
+function extractConfigFromModule(moduleExports) {
+  return moduleExports.default || moduleExports;
+}
+
+// src/main.ts
+async function generateApplicationBuilder(contextPath, options = {}) {
+  let configFile = "hexai.config.ts";
+  if (options.configFile) {
+    configFile = options.configFile;
+  }
+  const configPath = path.join(contextPath, configFile);
+  const config = await loadConfig(configPath);
+  const generator = new ApplicationBuilderGenerator(contextPath, config);
+  await generator.generate();
+}
+
+// src/cli.ts
+async function main() {
+  const args = process.argv.slice(2);
+  let contextPath = process.cwd();
+  const contextPathIndex = args.indexOf("--context-path");
+  if (contextPathIndex !== -1 && args[contextPathIndex + 1]) {
+    contextPath = path.resolve(args[contextPathIndex + 1]);
+  }
+  try {
+    console.log(`Generating application builder for: ${contextPath}`);
+    await generateApplicationBuilder(contextPath);
+    console.log("\u2713 Application builder generated successfully");
+  } catch (error) {
+    console.error("Error generating application builder:", error);
     process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error("Unexpected error:", error);
+  process.exit(1);
 });
+//# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map