@hexaijs/plugin-application-builder 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,16 +1,597 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cliPlugin = exports.DuplicateQueryHandlerError = exports.DuplicateEventHandlerError = exports.DuplicateCommandHandlerError = exports.QueryHandlerMarker = exports.EventHandlerMarker = exports.CommandHandlerMarker = exports.generateApplicationBuilder = void 0;
-var main_1 = require("./main");
-Object.defineProperty(exports, "generateApplicationBuilder", { enumerable: true, get: function () { return main_1.generateApplicationBuilder; } });
-var decorators_1 = require("./decorators");
-Object.defineProperty(exports, "CommandHandlerMarker", { enumerable: true, get: function () { return decorators_1.CommandHandlerMarker; } });
-Object.defineProperty(exports, "EventHandlerMarker", { enumerable: true, get: function () { return decorators_1.EventHandlerMarker; } });
-Object.defineProperty(exports, "QueryHandlerMarker", { enumerable: true, get: function () { return decorators_1.QueryHandlerMarker; } });
-var errors_1 = require("./errors");
-Object.defineProperty(exports, "DuplicateCommandHandlerError", { enumerable: true, get: function () { return errors_1.DuplicateCommandHandlerError; } });
-Object.defineProperty(exports, "DuplicateEventHandlerError", { enumerable: true, get: function () { return errors_1.DuplicateEventHandlerError; } });
-Object.defineProperty(exports, "DuplicateQueryHandlerError", { enumerable: true, get: function () { return errors_1.DuplicateQueryHandlerError; } });
-var hexai_plugin_1 = require("./hexai-plugin");
-Object.defineProperty(exports, "cliPlugin", { enumerable: true, get: function () { return hexai_plugin_1.cliPlugin; } });
+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');
+});
+
+// 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
+    };
+  }
+  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
+    };
+  }
+  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};
+}
+`;
+  }
+};
+
+// 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/decorators/index.ts
+function createMessageHandlerMarker() {
+  return function(messageClass) {
+    return function(target) {
+      return target;
+    };
+  };
+}
+var CommandHandlerMarker = createMessageHandlerMarker();
+var QueryHandlerMarker = createMessageHandlerMarker();
+function EventHandlerMarker(options) {
+  return function(target) {
+    return target;
+  };
+}
+var cliPlugin = {
+  name: "generate-app-builder",
+  description: "Generate ApplicationBuilder code from decorated handlers",
+  options: [
+    {
+      flags: "-p, --context-path <path>",
+      description: "Path to the bounded context directory",
+      required: true
+    },
+    {
+      flags: "-f, --config-file <name>",
+      description: "Config file name to use (default: hexai.config.ts)"
+    }
+  ],
+  run: async (args, config) => {
+    const contextPath = path.resolve(String(args.contextPath));
+    const configFile = args.configFile !== void 0 ? String(args.configFile) : config.configFile;
+    console.log(`Generating application builder for: ${contextPath}`);
+    await generateApplicationBuilder(contextPath, {
+      configFile
+    });
+    console.log("\u2713 Application builder generated successfully");
+  }
+};
+
+export { CommandHandlerMarker, DuplicateCommandHandlerError, DuplicateEventHandlerError, DuplicateQueryHandlerError, EventHandlerMarker, QueryHandlerMarker, cliPlugin, generateApplicationBuilder };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map