@haskou/ddd-kernel 0.1.0

package/dist/adapters/index.cjs

@@ -0,0 +1,651 @@
+"use strict";
+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);
+
+// src/adapters/index.ts
+var adapters_exports = {};
+__export(adapters_exports, {
+  ConsoleKernelLogger: () => ConsoleKernelLogger,
+  Consumer: () => Consumer,
+  ExpressKernelServer: () => ExpressKernelServer,
+  InMemoryEventBus: () => InMemoryEventBus,
+  InMemoryPubSub: () => InMemoryPubSub,
+  InMemoryRepository: () => InMemoryRepository,
+  InvalidDomainEventError: () => InvalidDomainEventError,
+  MongoRepository: () => MongoRepository,
+  NoFailedMessagesError: () => NoFailedMessagesError,
+  Route: () => Route,
+  RoutePrefix: () => RoutePrefix
+});
+module.exports = __toCommonJS(adapters_exports);
+
+// src/adapters/db/in-memory/InMemoryRepository.ts
+var InMemoryRepository = class {
+  entities = /* @__PURE__ */ new Map();
+  findById(id) {
+    return Promise.resolve(this.entities.get(id) ?? null);
+  }
+  save(entity) {
+    this.entities.set(entity.id, entity);
+    return Promise.resolve();
+  }
+  delete(id) {
+    this.entities.delete(id);
+    return Promise.resolve();
+  }
+};
+
+// src/adapters/db/mongo/MongoRepository.ts
+var MongoRepository = class {
+  constructor(collection, mapper) {
+    this.collection = collection;
+    this.mapper = mapper;
+  }
+  collection;
+  mapper;
+  async findById(id) {
+    const document = await this.collection.findOne({
+      id
+    });
+    if (!document) {
+      return null;
+    }
+    return this.mapper.toEntity(document);
+  }
+  async save(entity) {
+    const document = this.mapper.toDocument(entity);
+    await this.collection.updateOne(
+      { id: document.id },
+      { $set: document },
+      { upsert: true }
+    );
+  }
+  async delete(id) {
+    await this.collection.deleteOne({
+      id
+    });
+  }
+};
+
+// src/adapters/kernel/console/ConsoleKernelLogger.ts
+var ConsoleKernelLogger = class {
+  debug(message) {
+    console.debug(message);
+  }
+  error(message) {
+    console.error(message);
+  }
+  info(message) {
+    console.info(message);
+  }
+  warn(message) {
+    console.warn(message);
+  }
+};
+
+// src/Kernel.ts
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/infrastructure/dependency-injection/DependencyInjection.ts
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_node_dependency_injection = require("node-dependency-injection");
+var import_node_path = __toESM(require("path"), 1);
+var DependencyInjection = class _DependencyInjection {
+  constructor(options = {
+    containerBuild: process.env.CONTAINER_BUILD === "true",
+    servicesYamlPath: import_node_path.default.resolve(
+      process.cwd(),
+      "config",
+      "container",
+      "services.yaml"
+    ),
+    sourceDirectory: import_node_path.default.resolve(process.cwd(), "src")
+  }) {
+    this.options = options;
+    this.container = new import_node_dependency_injection.ContainerBuilder(false, this.options.sourceDirectory);
+  }
+  options;
+  static configuredInstance;
+  autowire;
+  loader;
+  container;
+  static configure(options) {
+    _DependencyInjection.configuredInstance = new _DependencyInjection(options);
+    return _DependencyInjection.configuredInstance;
+  }
+  static get instance() {
+    if (!_DependencyInjection.configuredInstance) {
+      throw new Error("DependencyInjection has not been configured.");
+    }
+    return _DependencyInjection.configuredInstance;
+  }
+  get definitions() {
+    const container = this.container;
+    return container._definitions || /* @__PURE__ */ new Map();
+  }
+  get aliases() {
+    const container = this.container;
+    return container._alias || /* @__PURE__ */ new Map();
+  }
+  async ensureFolderExists(filePath) {
+    await import_fs_extra.default.mkdir(import_node_path.default.dirname(filePath), { recursive: true });
+  }
+  getServiceClassName(serviceName) {
+    return typeof serviceName === "function" ? serviceName.name : void 0;
+  }
+  parentMatchesService(parentId, serviceClassName) {
+    if (!parentId) {
+      return false;
+    }
+    const parentName = Buffer.from(parentId, "base64").toString("utf8");
+    return parentName.endsWith(`__${serviceClassName}__${serviceClassName}`);
+  }
+  serviceIdMatchesService(serviceId, serviceClassName) {
+    const serviceName = Buffer.from(serviceId, "base64").toString("utf8");
+    return serviceName.endsWith(`__${serviceClassName}__${serviceClassName}`);
+  }
+  findConcreteChildServiceId(serviceName) {
+    const serviceClassName = this.getServiceClassName(serviceName);
+    if (!serviceClassName) {
+      return void 0;
+    }
+    const matches = [...this.definitions.entries()].filter(([, definition]) => definition._abstract !== true).filter(
+      ([, definition]) => this.parentMatchesService(definition._parent, serviceClassName)
+    ).map(([id]) => id);
+    return matches[matches.length - 1];
+  }
+  findRegisteredServiceId(serviceName) {
+    const serviceClassName = this.getServiceClassName(serviceName);
+    if (!serviceClassName) {
+      return void 0;
+    }
+    const matches = [...this.definitions.keys()].filter(
+      (id) => this.serviceIdMatchesService(id, serviceClassName)
+    );
+    return matches[matches.length - 1];
+  }
+  findAliasServiceId(serviceName) {
+    const serviceClassName = this.getServiceClassName(serviceName);
+    if (!serviceClassName) {
+      return void 0;
+    }
+    const matches = [...this.aliases.keys()].filter(
+      (id) => this.serviceIdMatchesService(id, serviceClassName)
+    );
+    return matches[matches.length - 1];
+  }
+  registerParentAliases() {
+    for (const [id, definition] of this.definitions.entries()) {
+      if (definition._abstract === true || !definition._parent) {
+        continue;
+      }
+      this.container.setAlias(definition._parent, id);
+    }
+  }
+  async compile() {
+    if (this.options.containerBuild) {
+      await this.ensureFolderExists(this.options.servicesYamlPath);
+      this.autowire = new import_node_dependency_injection.Autowire(this.container);
+      this.autowire.serviceFile = new import_node_dependency_injection.ServiceFile(
+        this.options.servicesYamlPath,
+        false
+      );
+      await this.autowire.process();
+    } else {
+      this.loader = new import_node_dependency_injection.YamlFileLoader(this.container);
+      await this.loader.load(this.options.servicesYamlPath);
+    }
+    this.registerParentAliases();
+    await this.container.compile();
+  }
+  getService(serviceName) {
+    const childServiceId = this.findConcreteChildServiceId(serviceName);
+    if (childServiceId) {
+      return this.container.get(childServiceId);
+    }
+    const aliasServiceId = this.findAliasServiceId(serviceName);
+    if (aliasServiceId) {
+      return this.container.get(aliasServiceId);
+    }
+    const registeredServiceId = this.findRegisteredServiceId(serviceName);
+    if (registeredServiceId) {
+      return this.container.get(registeredServiceId);
+    }
+    return this.container.get(serviceName);
+  }
+};
+
+// src/Kernel.ts
+var Kernel = class _Kernel {
+  constructor(options = {}) {
+    this.options = options;
+    this.loggerInstance = options.logger ?? new ConsoleKernelLogger();
+    this.dependencyInjectionInstance = options.di;
+    _Kernel.state.activeKernel = this;
+  }
+  options;
+  static stateKey = /* @__PURE__ */ Symbol.for(
+    "@haskou/ddd-kernel/kernel-state"
+  );
+  consumerMiddlewares = [];
+  consumersList = [];
+  loggerInstance;
+  routesList = [];
+  schedulersList = [];
+  shutdownHooks = [];
+  dependencyInjectionInstance;
+  static get state() {
+    const stateContainer = globalThis;
+    stateContainer[_Kernel.stateKey] = stateContainer[_Kernel.stateKey] ?? {};
+    return stateContainer[_Kernel.stateKey];
+  }
+  static get configDirectory() {
+    return import_node_path2.default.resolve(_Kernel.rootDirectory, "config");
+  }
+  static get consumers() {
+    return _Kernel.getActiveKernel().consumers;
+  }
+  static get consumerMiddleware() {
+    return _Kernel.getActiveKernel().consumerMiddleware;
+  }
+  static get di() {
+    return _Kernel.getActiveKernel().di;
+  }
+  static get logger() {
+    return _Kernel.getActiveKernel().logger;
+  }
+  static get rootDirectory() {
+    return process.cwd();
+  }
+  static get routes() {
+    return _Kernel.getActiveKernel().routes;
+  }
+  static get schedulers() {
+    return _Kernel.getActiveKernel().schedulers;
+  }
+  static get sourceDirectory() {
+    return import_node_path2.default.resolve(_Kernel.rootDirectory, "src");
+  }
+  static getActiveKernel() {
+    if (!_Kernel.state.activeKernel) {
+      _Kernel.state.activeKernel = new _Kernel();
+    }
+    return _Kernel.state.activeKernel;
+  }
+  async closeCandidate(candidate) {
+    if (candidate.shutdown) {
+      await candidate.shutdown();
+      return;
+    }
+    if (candidate.close) {
+      await candidate.close();
+      return;
+    }
+    if (candidate.stop) {
+      await candidate.stop();
+      return;
+    }
+    if (candidate.flush) {
+      await candidate.flush();
+    }
+  }
+  getConsumerFromClass(ClassDefinition) {
+    return this.di.getService(ClassDefinition);
+  }
+  getInitializerFromClass(ClassDefinition) {
+    return this.di.getService(ClassDefinition);
+  }
+  getRuntimeFromClass(ClassDefinition) {
+    return this.di.getService(ClassDefinition);
+  }
+  getSchedulerFromClass(ClassDefinition) {
+    return this.di.getService(ClassDefinition);
+  }
+  get consumers() {
+    return this.consumersList;
+  }
+  get consumerMiddleware() {
+    return this.consumerMiddlewares;
+  }
+  get di() {
+    if (!this.dependencyInjectionInstance) {
+      throw new Error("Kernel dependency injection has not been initialized.");
+    }
+    return this.dependencyInjectionInstance;
+  }
+  get logger() {
+    return this.loggerInstance;
+  }
+  get routes() {
+    return this.routesList;
+  }
+  get schedulers() {
+    return this.schedulersList;
+  }
+  async dependencyInjection() {
+    this.dependencyInjectionInstance = this.dependencyInjectionInstance ?? DependencyInjection.configure({
+      containerBuild: process.env.CONTAINER_BUILD === "true",
+      servicesYamlPath: this.options.servicesYamlPath ?? import_node_path2.default.resolve(_Kernel.configDirectory, "container", "services.yaml"),
+      sourceDirectory: this.options.sourceDirectory ?? _Kernel.sourceDirectory
+    });
+    await this.dependencyInjectionInstance.compile();
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  registerConsumerMiddleware(...middlewares) {
+    this.consumerMiddlewares.push(...middlewares);
+  }
+  registerConsumers(...ClassDefinitions) {
+    for (const ClassDefinition of ClassDefinitions) {
+      this.consumersList.push(this.getConsumerFromClass(ClassDefinition));
+    }
+  }
+  registerConsumerInstances(...consumers) {
+    this.consumersList.push(...consumers);
+  }
+  registerRoutes(...ClassDefinitions) {
+    this.routesList.push(...ClassDefinitions);
+  }
+  registerSchedulers(...ClassDefinitions) {
+    for (const ClassDefinition of ClassDefinitions) {
+      this.schedulersList.push(this.getSchedulerFromClass(ClassDefinition));
+    }
+  }
+  registerSchedulerInstances(...schedulers) {
+    this.schedulersList.push(...schedulers);
+  }
+  registerShutdownHook(hook) {
+    this.shutdownHooks.push(hook);
+  }
+  removeConsumers() {
+    this.consumersList.length = 0;
+  }
+  removeRoutes() {
+    this.routesList.length = 0;
+  }
+  removeSchedulers() {
+    this.schedulersList.length = 0;
+  }
+  async runConsumers() {
+    for (const consumer of this.consumersList) {
+      await consumer.init();
+    }
+  }
+  async runInitializers(...ClassDefinitions) {
+    for (const ClassDefinition of ClassDefinitions) {
+      await this.getInitializerFromClass(ClassDefinition).ensure();
+    }
+  }
+  async runRuntimes(...ClassDefinitions) {
+    for (const ClassDefinition of ClassDefinitions) {
+      const runtime = this.getRuntimeFromClass(ClassDefinition);
+      await runtime.run();
+      this.registerShutdownHook(
+        () => this.closeCandidate(runtime)
+      );
+    }
+  }
+  async runSchedulerNowAndSchedule(ClassDefinition) {
+    const scheduler = this.getSchedulerFromClass(ClassDefinition);
+    await scheduler.runOnce();
+    await scheduler.init();
+    this.schedulersList.push(scheduler);
+  }
+  async runSchedulers() {
+    for (const scheduler of this.schedulersList) {
+      await scheduler.init();
+    }
+  }
+  async shutdown() {
+    for (const consumer of [...this.consumersList].reverse()) {
+      await this.closeCandidate(consumer);
+    }
+    for (const scheduler of [...this.schedulersList].reverse()) {
+      await this.closeCandidate(scheduler);
+    }
+    for (const hook of [...this.shutdownHooks].reverse()) {
+      await hook();
+    }
+    await this.closeCandidate(this.loggerInstance);
+  }
+};
+
+// src/adapters/pubsub/Consumer.ts
+var Consumer = class {
+  constructor(consumer) {
+    this.consumer = consumer;
+  }
+  consumer;
+  async runMiddleware(event, middlewares, index) {
+    const middleware = middlewares[index];
+    if (!middleware) {
+      await this.handler(event);
+      return;
+    }
+    await middleware.handle(
+      event,
+      () => this.runMiddleware(event, middlewares, index + 1)
+    );
+  }
+  async init() {
+    await this.consumer.consume(
+      this.queueName,
+      this.eventName,
+      this.domainEvent,
+      this.exchange,
+      (event) => this.runMiddleware(event, Kernel.consumerMiddleware, 0)
+    );
+  }
+  get(service) {
+    return Kernel.di.getService(service);
+  }
+};
+
+// src/adapters/pubsub/amqp/AmqpMessageBusAdapter.ts
+var import_amqplib = __toESM(require("amqplib"), 1);
+var import_node_crypto = require("crypto");
+
+// src/adapters/pubsub/amqp/InvalidDomainEventError.ts
+var InvalidDomainEventError = class extends Error {
+  constructor(message) {
+    super(`Invalid domain event: ${message}`);
+    this.name = "InvalidDomainEventError";
+  }
+};
+
+// src/adapters/pubsub/amqp/NoFailedMessagesError.ts
+var NoFailedMessagesError = class extends Error {
+  constructor(queueName) {
+    super(`No failed messages found in "${queueName}".`);
+    this.name = "NoFailedMessagesError";
+  }
+};
+
+// src/adapters/pubsub/in-memory/InMemoryEventBus.ts
+var InMemoryEventBus = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  handlers = /* @__PURE__ */ new Map();
+  subscribe(name, handler) {
+    const handlers = this.handlers.get(name) ?? [];
+    handlers.push(handler);
+    this.handlers.set(name, handlers);
+  }
+  async publish(event) {
+    const handlers = this.handlers.get(event.name) ?? [];
+    for (const handler of handlers) {
+      await handler(event, this.context);
+    }
+  }
+};
+
+// src/adapters/pubsub/in-memory/InMemoryPubSub.ts
+var InMemoryPubSub = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  consumers = /* @__PURE__ */ new Map();
+  async publish(topic, message) {
+    const consumers = this.consumers.get(topic) ?? /* @__PURE__ */ new Set();
+    for (const consumer of consumers) {
+      await consumer(message, this.context);
+    }
+  }
+  subscribe(topic, consumer) {
+    const consumers = this.consumers.get(topic) ?? /* @__PURE__ */ new Set();
+    const castConsumer = consumer;
+    consumers.add(castConsumer);
+    this.consumers.set(topic, consumers);
+    return Promise.resolve({
+      close: () => {
+        consumers.delete(castConsumer);
+        return Promise.resolve();
+      }
+    });
+  }
+};
+
+// src/adapters/ui/express/ExpressKernelServer.ts
+var import_routing_controllers = require("routing-controllers");
+var ExpressKernelServer = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  appInstance;
+  serverInstance;
+  registerErrorHandlers(app) {
+    const handlers = this.options.errorHandlers ?? [this.defaultErrorHandler()];
+    for (const handler of handlers) {
+      app.use(handler);
+    }
+  }
+  defaultErrorHandler() {
+    return (error, request, response) => {
+      void request;
+      response.status(500).json({
+        error: error instanceof Error ? error.message : String(error)
+      });
+    };
+  }
+  get app() {
+    if (!this.appInstance) {
+      throw new Error("HTTP server is not running.");
+    }
+    return this.appInstance;
+  }
+  get server() {
+    if (!this.serverInstance) {
+      throw new Error("HTTP server is not running.");
+    }
+    return this.serverInstance;
+  }
+  close() {
+    if (!this.serverInstance) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      this.serverInstance?.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        this.serverInstance = void 0;
+        this.appInstance = void 0;
+        resolve();
+      });
+    });
+  }
+  run() {
+    const app = (0, import_routing_controllers.createExpressServer)({
+      controllers: this.options.kernel.getRoutes(),
+      routePrefix: this.options.routePrefix
+    });
+    for (const middleware of this.options.middlewares ?? []) {
+      app.use(middleware);
+    }
+    this.registerErrorHandlers(app);
+    this.appInstance = app;
+    return new Promise((resolve) => {
+      this.serverInstance = app.listen(this.options.port ?? 3e3, () => {
+        resolve();
+      });
+    });
+  }
+};
+
+// src/adapters/ui/express/RoutePrefix.ts
+var RoutePrefix = class _RoutePrefix {
+  value;
+  static fromEnvironment(value) {
+    return new _RoutePrefix(value);
+  }
+  constructor(value) {
+    if (!value || value === "/") {
+      this.value = "";
+      return;
+    }
+    const normalizedPrefix = value.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+    this.value = normalizedPrefix ? `/${normalizedPrefix}` : "";
+  }
+  includes(requestPath) {
+    return this.value.length > 0 && (requestPath === this.value || requestPath.startsWith(`${this.value}/`));
+  }
+  isEmpty() {
+    return this.value.length === 0;
+  }
+  toString() {
+    return this.value;
+  }
+};
+
+// src/adapters/ui/routes/Route.ts
+var Route = class {
+  get(service) {
+    return Kernel.di.getService(service);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsoleKernelLogger,
+  Consumer,
+  ExpressKernelServer,
+  InMemoryEventBus,
+  InMemoryPubSub,
+  InMemoryRepository,
+  InvalidDomainEventError,
+  MongoRepository,
+  NoFailedMessagesError,
+  Route,
+  RoutePrefix
+});
+//# sourceMappingURL=index.cjs.map