@solid-stack/agnos-express 1.0.0

package/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2026 Solid Stack Digital
+
+All rights reserved.
+
+This software and its associated documentation files (the "Software") are 
+proprietary to Solid Stack Digital. 
+
+Strictly confidential. No part of this Software may be used, copied, 
+modified, merged, published, distributed, sublicensed, or sold in any form 
+or by any means without the prior written permission of the copyright owner.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# @solid-stack/agnos-express
+
+Express presentation adapter for the [Agnos](https://github.com/solid-stack-digital/agnos) clean application architecture framework.
+
+---
+
+## ✨ Features
+
+- ⚡ **Seamless Agnos Integration**: Implements the `IPresentation` lifecycle interface (`init`, `run`, `stop`).
+- 🧩 **Dependency Injection**: Fully integrated with `@solid-stack/di` using `ValueToken` and `MultiToken` patterns.
+- 🚀 **Auto-Discovery**: Automatic feature route discovery from `pxExpress` directories and global middleware loading.
+- 🛡️ **Clean Encapsulation**: Minimal public API surface — all internals are abstracted.
+- 📦 **Dual ESM & CommonJS Output**: Bundled via `tsup` with complete TypeScript type declarations.
+
+---
+
+## 📦 Installation
+
+```bash
+pnpm add @solid-stack/agnos-express @solid-stack/agnos @solid-stack/di express
+```
+
+---
+
+## 🚀 Quick Start
+
+### 1. Define a Route
+
+Create a route handler extending `ExpressRoute`:
+
+```typescript
+import { ExpressRoute } from "@solid-stack/agnos-express";
+import type { Request, Response } from "express";
+
+export default class GetUsersRoute extends ExpressRoute {
+  method = "get" as const;
+  path = "/";
+
+  handler = async (req: Request, res: Response) => {
+    res.json({ users: [{ id: 1, name: "Alice" }] });
+  };
+}
+```
+
+### 2. Bootstrap Application
+
+```typescript
+import { Container } from "@solid-stack/di";
+import { start } from "@solid-stack/agnos";
+import { loadExpressPresentation } from "@solid-stack/agnos-express";
+
+async function main() {
+  const container = new Container();
+
+  // Load Express presentation layer
+  await loadExpressPresentation(container, {
+    port: 3000,
+    featuresDir: "./src/features",
+    mainDir: "./src/presentation",
+  });
+
+  // Start Agnos application lifecycle
+  await start(container, {
+    featuresDir: "./src/features",
+  });
+}
+
+main().catch(console.error);
+```
+
+---
+
+## 📁 Directory Architecture
+
+```text
+my-app/
+├── src/
+│   ├── features/
+│   │   └── users/
+│   │       ├── pxExpress/
+│   │       │   ├── index.ts          # export const path = '/users';
+│   │       │   └── handlers/
+│   │       │       └── getUsers.ts   # export default class GetUsersRoute extends ExpressRoute
+│   │       └── DepsProvider.ts
+│   └── presentation/
+│       └── index.ts                  # export const middlewares = [...]; export const errorHandlers = [...];
+```
+
+---
+
+## 🛠️ Available Scripts
+
+| Command | Description |
+| --- | --- |
+| `pnpm dev` | Starts `tsup` in watch mode for development |
+| `pnpm build` | Bundles ESM/CJS outputs and generates TypeScript type declarations |
+| `pnpm test` | Runs tests using Vitest |
+| `pnpm test:watch` | Runs Vitest in interactive watch mode |
+| `pnpm test:coverage` | Runs tests with code coverage reporting |
+| `pnpm typecheck` | Typechecks the project using TypeScript (`tsc --noEmit`) |
+| `pnpm check` | Runs typecheck, tests, and build in sequence |
+
+---
+
+## 📄 License
+
+MIT © [Solid Stack Digital](https://github.com/solid-stack-digital)

package/dist/constants/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Default configuration constants for Agnos Express presentation.
+ */
+export declare const DEFAULT_PORT = 3000;
+export declare const DEFAULT_HOST = "0.0.0.0";
+export declare const DEFAULT_FEATURE_PX_DIR = "pxExpress";
+export declare const DEFAULT_HANDLERS_DIR = "handlers";
+//# sourceMappingURL=index.d.ts.map

package/dist/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,YAAY,OAAO,CAAC;AACjC,eAAO,MAAM,YAAY,YAAY,CAAC;AACtC,eAAO,MAAM,sBAAsB,cAAc,CAAC;AAClD,eAAO,MAAM,oBAAoB,aAAa,CAAC"}

package/dist/core/ExpressPresentation.d.ts

@@ -0,0 +1,50 @@
+import type { Server } from "node:http";
+import { type Express } from "express";
+import { type DepsType } from "@solid-stack/di";
+import { IPresentation, ILogger } from "@solid-stack/agnos";
+import { ExpressPxConfigsToken, ExpressRoutersToken, ExpressMiddlewaresToken, ExpressErrorHandlersToken } from "../types/index.js";
+/**
+ * Express HTTP Presentation Layer implementation for the Agnos framework.
+ *
+ * Implements the IPresentation lifecycle contract:
+ * - init: Configures JSON body parsing, attaches global middlewares, routers, and error handlers.
+ * - run: Starts the HTTP server on the configured port and host.
+ * - stop: Gracefully shuts down the HTTP server.
+ */
+export declare class ExpressPresentation implements IPresentation {
+    deps: DepsType<typeof ExpressPresentation.deps>;
+    private readonly app;
+    private server;
+    static deps: {
+        configs: typeof ExpressPxConfigsToken;
+        errorHandlers: typeof ExpressErrorHandlersToken;
+        middlewares: typeof ExpressMiddlewaresToken;
+        routers: typeof ExpressRoutersToken;
+        logger: typeof ILogger;
+    };
+    constructor(deps: DepsType<typeof ExpressPresentation.deps>);
+    /**
+     * Initializes middleware, feature routers, and error handlers on the Express app.
+     */
+    init(): Promise<void>;
+    private attachMiddlewares;
+    private attachRouters;
+    private attachErrorHandlers;
+    /**
+     * Starts the Express server listening on the configured port and host.
+     */
+    run(): Promise<void>;
+    /**
+     * Gracefully closes the running HTTP server.
+     */
+    stop(): Promise<void>;
+    /**
+     * Returns the underlying Express application instance.
+     */
+    getApp(): Express;
+    /**
+     * Returns the active Node HTTP server instance, or null if not currently running.
+     */
+    getServer(): Server | null;
+}
+//# sourceMappingURL=ExpressPresentation.d.ts.map

package/dist/core/ExpressPresentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressPresentation.d.ts","sourceRoot":"","sources":["../../src/core/ExpressPresentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAgB,EAEd,KAAK,OAAO,EAGb,MAAM,SAAS,CAAC;AACjB,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,EACvB,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;GAOG;AACH,qBACa,mBAAoB,YAAW,aAAa;IAYpC,IAAI,EAAE,QAAQ,CAAC,OAAO,mBAAmB,CAAC,IAAI,CAAC;IAXlE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAU;IAC9B,OAAO,CAAC,MAAM,CAAuB;IAErC,OAAc,IAAI;QAChB,OAAO;QACP,aAAa;QACb,WAAW;QACX,OAAO;QACP,MAAM;MACN;IAEF,YAAmB,IAAI,EAAE,QAAQ,CAAC,OAAO,mBAAmB,CAAC,IAAI,CAAC,EAEjE;IAED;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAM1B;IAED,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,aAAa;IAoCrB,OAAO,CAAC,mBAAmB;IAS3B;;OAEG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CA0BzB;IAED;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAgB1B;IAED;;OAEG;IACI,MAAM,IAAI,OAAO,CAEvB;IAED;;OAEG;IACI,SAAS,IAAI,MAAM,GAAG,IAAI,CAEhC;CACF"}

package/dist/core/ExpressRoute.d.ts

@@ -0,0 +1,24 @@
+import type { RequestHandler } from "express";
+import type { ExpressRouteMethod } from "../types/index.js";
+/**
+ * Abstract base class for defining an Express route handler within an Agnos feature.
+ */
+export declare abstract class ExpressRoute {
+    /**
+     * The HTTP method for this route (e.g. 'get', 'post', 'put', 'delete').
+     */
+    abstract method: ExpressRouteMethod;
+    /**
+     * The sub-path for this route relative to the feature router's base path (e.g. '/' or '/:id').
+     */
+    abstract path: string;
+    /**
+     * The Express request handler function.
+     */
+    abstract handler: RequestHandler;
+    /**
+     * Optional route-level middlewares executed before handler.
+     */
+    middlewares?: RequestHandler[];
+}
+//# sourceMappingURL=ExpressRoute.d.ts.map

package/dist/core/ExpressRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressRoute.d.ts","sourceRoot":"","sources":["../../src/core/ExpressRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D;;GAEG;AACH,8BAAsB,YAAY;IAChC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IAEjC;;OAEG;IACH,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CAChC"}

package/dist/core/ExpressRouter.d.ts

@@ -0,0 +1,20 @@
+import type { RequestHandler } from "express";
+import type { ExpressRoute } from "./ExpressRoute.js";
+/**
+ * Abstract base class for defining an Express router grouping multiple routes under a common path prefix.
+ */
+export declare abstract class ExpressRouter {
+    /**
+     * The base URL path prefix for this router (e.g. '/users' or '/api/v1/orders').
+     */
+    abstract get path(): string;
+    /**
+     * The collection of routes registered under this router.
+     */
+    abstract get routes(): ExpressRoute[];
+    /**
+     * Optional router-level middlewares executed for all routes in this router.
+     */
+    middlewares?: RequestHandler[];
+}
+//# sourceMappingURL=ExpressRouter.d.ts.map

package/dist/core/ExpressRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressRouter.d.ts","sourceRoot":"","sources":["../../src/core/ExpressRouter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;GAEG;AACH,8BAAsB,aAAa;IACjC;;OAEG;IACH,aAAoB,IAAI,IAAI,MAAM,CAAC;IAEnC;;OAEG;IACH,aAAoB,MAAM,IAAI,YAAY,EAAE,CAAC;IAE7C;;OAEG;IACI,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CACvC"}

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export { ExpressPresentation } from "./ExpressPresentation.js";
+export { loadExpressPresentation } from "./loadExpressPresentation.js";
+export { ExpressRoute } from "./ExpressRoute.js";
+export { ExpressRouter } from "./ExpressRouter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/core/loadExpressPresentation.d.ts

@@ -0,0 +1,16 @@
+import type { Container } from "@solid-stack/di";
+import { type ExpressPresentationOptions } from "../types/index.js";
+/**
+ * Bootstraps and registers the Express presentation layer in the DI container.
+ *
+ * Configures:
+ * 1. ExpressPxConfigsToken with port and optional host.
+ * 2. Autoloads global middlewares and error handlers from mainDir if specified.
+ * 3. Autoloads feature routes from featuresDir if specified.
+ * 4. Binds IPresentation to ExpressPresentation.
+ *
+ * @param container - The @solid-stack/di Container instance.
+ * @param options - Presentation bootstrap options.
+ */
+export declare const loadExpressPresentation: (container: Container, options?: ExpressPresentationOptions) => Promise<void>;
+//# sourceMappingURL=loadExpressPresentation.d.ts.map

package/dist/core/loadExpressPresentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadExpressPresentation.d.ts","sourceRoot":"","sources":["../../src/core/loadExpressPresentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,mBAAmB,CAAC;AAK3B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,cACvB,SAAS,YACV,0BAA0B,KACnC,OAAO,CAAC,IAAI,CAkBd,CAAC"}

package/dist/index.cjs

@@ -0,0 +1,387 @@
+'use strict';
+
+var express = require('express');
+var di = require('@solid-stack/di');
+var agnos = require('@solid-stack/agnos');
+var fs2 = require('fs/promises');
+var path2 = require('path');
+var url = require('url');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var express__default = /*#__PURE__*/_interopDefault(express);
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var ExpressPxConfigsToken = class extends di.ValueToken {
+};
+var ExpressRoutersToken = class extends di.MultiToken {
+};
+var ExpressMiddlewaresToken = class extends di.MultiToken {
+};
+var ExpressErrorHandlersToken = class extends di.MultiToken {
+};
+
+// src/core/ExpressPresentation.ts
+var _ExpressPresentation_decorators, _init;
+_ExpressPresentation_decorators = [di.MakeInjectable];
+exports.ExpressPresentation = class ExpressPresentation {
+  constructor(deps) {
+    this.deps = deps;
+    this.app = express__default.default();
+  }
+  deps;
+  app;
+  server = null;
+  static deps = {
+    configs: ExpressPxConfigsToken,
+    errorHandlers: ExpressErrorHandlersToken,
+    middlewares: ExpressMiddlewaresToken,
+    routers: ExpressRoutersToken,
+    logger: agnos.ILogger
+  };
+  /**
+   * Initializes middleware, feature routers, and error handlers on the Express app.
+   */
+  async init() {
+    this.app.use(express__default.default.json());
+    this.attachMiddlewares();
+    this.attachRouters();
+    this.attachErrorHandlers();
+  }
+  attachMiddlewares() {
+    const middlewares = this.deps.middlewares ?? [];
+    for (const middleware of middlewares) {
+      this.app.use((req, res, next) => middleware.handler(req, res, next));
+    }
+  }
+  attachRouters() {
+    const routers = this.deps.routers ?? [];
+    this.deps.logger.debug("Registering Express routers...", {
+      count: routers.length
+    });
+    for (const subRouter of routers) {
+      const router = express.Router();
+      if (subRouter.middlewares && subRouter.middlewares.length > 0) {
+        for (const mw of subRouter.middlewares) {
+          router.use(mw);
+        }
+      }
+      for (const route of subRouter.routes) {
+        this.deps.logger.debug(
+          `Registering route: [${route.method.toUpperCase()}] ${subRouter.path}${route.path}`
+        );
+        const routeHandler = (req, res, next) => route.handler(req, res, next);
+        if (route.middlewares && route.middlewares.length > 0) {
+          router[route.method](route.path, ...route.middlewares, routeHandler);
+        } else {
+          router[route.method](route.path, routeHandler);
+        }
+      }
+      this.app.use(subRouter.path, router);
+    }
+  }
+  attachErrorHandlers() {
+    const errorHandlers = this.deps.errorHandlers ?? [];
+    for (const errorHandler of errorHandlers) {
+      const handler = (err, req, res, next) => errorHandler.handler(err, req, res, next);
+      this.app.use(handler);
+    }
+  }
+  /**
+   * Starts the Express server listening on the configured port and host.
+   */
+  async run() {
+    return new Promise((resolve, reject) => {
+      try {
+        const { port, host } = this.deps.configs;
+        const onListening = () => {
+          this.deps.logger.info(
+            `Express server listening on ${host ? `${host}:` : "port "}${port}`
+          );
+          resolve();
+        };
+        if (host) {
+          this.server = this.app.listen(port, host, onListening);
+        } else {
+          this.server = this.app.listen(port, onListening);
+        }
+        this.server.on("error", (err) => {
+          this.deps.logger.error("Express server error:", err);
+          reject(err);
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  /**
+   * Gracefully closes the running HTTP server.
+   */
+  async stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        return resolve();
+      }
+      this.server.close((err) => {
+        if (err) {
+          this.deps.logger.error("Error closing Express server:", err);
+          return reject(err);
+        }
+        this.deps.logger.info("Express server stopped receiving new requests.");
+        this.server = null;
+        resolve();
+      });
+    });
+  }
+  /**
+   * Returns the underlying Express application instance.
+   */
+  getApp() {
+    return this.app;
+  }
+  /**
+   * Returns the active Node HTTP server instance, or null if not currently running.
+   */
+  getServer() {
+    return this.server;
+  }
+};
+_init = __decoratorStart(null);
+exports.ExpressPresentation = __decorateElement(_init, 0, "ExpressPresentation", _ExpressPresentation_decorators, exports.ExpressPresentation);
+__runInitializers(_init, 1, exports.ExpressPresentation);
+async function folderExists(dir) {
+  try {
+    const stats = await fs2.stat(dir);
+    return stats.isDirectory();
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+// src/utils/autoLoadMainPx.ts
+async function autoLoadMainPx(c, mainDir) {
+  if (!await folderExists(mainDir)) {
+    return;
+  }
+  const mainDirContents = await fs2__default.default.readdir(mainDir, { withFileTypes: true });
+  const indexFile = mainDirContents.find(
+    (f) => f.isFile() && (f.name === "index.ts" || f.name === "index.js" || f.name === "index.mjs" || f.name === "index.cjs")
+  );
+  if (!indexFile) {
+    throw new agnos.PresentationError(
+      `No index.ts or index.js file found in the main presentation directory: ${mainDir}`,
+      { phase: "init" }
+    );
+  }
+  const indexFilePath = path2__default.default.join(mainDir, indexFile.name);
+  const imported = await import(url.pathToFileURL(indexFilePath).href);
+  const middlewares = imported.middlewares;
+  if (middlewares && Array.isArray(middlewares)) {
+    for (const middleware of middlewares) {
+      c.provideMulti(ExpressMiddlewaresToken, middleware);
+    }
+  }
+  const errorHandlers = imported.errorHandlers;
+  if (errorHandlers && Array.isArray(errorHandlers)) {
+    for (const errorHandler of errorHandlers) {
+      c.provideMulti(ExpressErrorHandlersToken, errorHandler);
+    }
+  }
+}
+
+// src/core/ExpressRouter.ts
+var ExpressRouter = class {
+  /**
+   * Optional router-level middlewares executed for all routes in this router.
+   */
+  middlewares;
+};
+
+// src/core/ExpressRoute.ts
+var ExpressRoute = class {
+  /**
+   * Optional route-level middlewares executed before handler.
+   */
+  middlewares;
+};
+
+// src/constants/index.ts
+var DEFAULT_PORT = 3e3;
+var DEFAULT_FEATURE_PX_DIR = "pxExpress";
+var DEFAULT_HANDLERS_DIR = "handlers";
+
+// src/utils/autoLoadFeature.ts
+async function autoLoadFeature(c, featuresDir) {
+  var _FeatureRouter_decorators, _init2, _a;
+  if (!await folderExists(featuresDir)) {
+    return;
+  }
+  const features = await fs2__default.default.readdir(featuresDir, { withFileTypes: true });
+  for (const feature of features) {
+    if (!feature.isDirectory()) continue;
+    const featureName = feature.name;
+    const pxExpressDir = path2__default.default.join(
+      featuresDir,
+      featureName,
+      DEFAULT_FEATURE_PX_DIR
+    );
+    if (!await folderExists(pxExpressDir)) continue;
+    const pxExpressDirFiles = await fs2__default.default.readdir(pxExpressDir);
+    const indexFile = pxExpressDirFiles.find(
+      (f) => f === "index.ts" || f === "index.js" || f === "index.mjs" || f === "index.cjs"
+    );
+    if (!indexFile) {
+      throw new agnos.FeatureLoadError(
+        featureName,
+        pxExpressDir,
+        `The express presentation of feature "${featureName}" (${pxExpressDir}) does not have an index.ts or index.js file.`
+      );
+    }
+    const indexFilePath = path2__default.default.join(pxExpressDir, indexFile);
+    const imported = await import(url.pathToFileURL(indexFilePath).href);
+    const routePath = imported.path;
+    if (typeof routePath !== "string") {
+      throw new agnos.FeatureLoadError(
+        featureName,
+        indexFilePath,
+        `The express presentation of feature "${featureName}" (${pxExpressDir}) has an index file, but it doesn't export a string named 'path'.`
+      );
+    }
+    const routeClasses = [];
+    const routesDir = path2__default.default.join(pxExpressDir, DEFAULT_HANDLERS_DIR);
+    if (await folderExists(routesDir)) {
+      const routeFiles = await fs2__default.default.readdir(routesDir);
+      for (const routeFile of routeFiles) {
+        if (!routeFile.match(/\.(js|ts|mjs|cjs)$/) || routeFile.endsWith(".d.ts") || routeFile.includes(".test.") || routeFile.includes(".spec.")) {
+          continue;
+        }
+        const routeFilePath = path2__default.default.join(routesDir, routeFile);
+        const routeFileModule = await import(url.pathToFileURL(routeFilePath).href);
+        const routeClass = routeFileModule.default;
+        if (!routeClass) {
+          throw new agnos.FeatureLoadError(
+            featureName,
+            routeFilePath,
+            `The route file "${routeFile}" in feature "${featureName}" doesn't have a default export.`
+          );
+        }
+        if (typeof routeClass !== "function" || !(routeClass.prototype instanceof ExpressRoute)) {
+          throw new agnos.FeatureLoadError(
+            featureName,
+            routeFilePath,
+            `The default export in "${routeFile}" (feature: "${featureName}") does not inherit from ExpressRoute.`
+          );
+        }
+        if (!di.diFactoryRegistry.has(routeClass)) {
+          if (routeClass.deps) {
+            di.registerInjectable(routeClass);
+          } else {
+            di.diFactoryRegistry.set(
+              routeClass,
+              () => new routeClass()
+            );
+          }
+        }
+        routeClasses.push({
+          meta: { name: routeClass.name },
+          class: routeClass
+        });
+      }
+    }
+    const featureDeps = routeClasses.reduce(
+      (acc, entry) => {
+        const depKey = entry.meta.name.charAt(0).toLowerCase() + entry.meta.name.slice(1);
+        acc[depKey] = entry.class;
+        return acc;
+      },
+      {}
+    );
+    const optionalMiddlewares = Array.isArray(imported.middlewares) ? imported.middlewares : void 0;
+    _FeatureRouter_decorators = [di.MakeInjectable];
+    class FeatureRouter extends (_a = ExpressRouter) {
+      constructor(deps) {
+        super();
+        this.deps = deps;
+      }
+      deps;
+      static deps = featureDeps;
+      middlewares = optionalMiddlewares;
+      get path() {
+        return routePath;
+      }
+      get routes() {
+        return Object.values(this.deps);
+      }
+    }
+    _init2 = __decoratorStart(_a);
+    FeatureRouter = __decorateElement(_init2, 0, "FeatureRouter", _FeatureRouter_decorators, FeatureRouter);
+    __runInitializers(_init2, 1, FeatureRouter);
+    const routerClassName = `${featureName.charAt(0).toUpperCase() + featureName.slice(1)}ExpressRouter`;
+    Object.defineProperty(FeatureRouter, "name", {
+      value: routerClassName
+    });
+    c.provideMulti(ExpressRoutersToken, FeatureRouter);
+  }
+}
+
+// src/core/loadExpressPresentation.ts
+var loadExpressPresentation = async (container, options) => {
+  const port = options?.port ?? DEFAULT_PORT;
+  const host = options?.host;
+  container.provideValue(ExpressPxConfigsToken, {
+    port,
+    ...host ? { host } : {}
+  });
+  if (options?.mainDir) {
+    await autoLoadMainPx(container, options.mainDir);
+  }
+  if (options?.featuresDir) {
+    await autoLoadFeature(container, options.featuresDir);
+  }
+  container.provide(agnos.IPresentation, exports.ExpressPresentation);
+};
+
+exports.ExpressErrorHandlersToken = ExpressErrorHandlersToken;
+exports.ExpressMiddlewaresToken = ExpressMiddlewaresToken;
+exports.ExpressPxConfigsToken = ExpressPxConfigsToken;
+exports.ExpressRoute = ExpressRoute;
+exports.ExpressRouter = ExpressRouter;
+exports.ExpressRoutersToken = ExpressRoutersToken;
+exports.loadExpressPresentation = loadExpressPresentation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map