@webpieces/http-server 0.3.234 → 0.3.236

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/http-server",
-  "version": "0.3.234",
+  "version": "0.3.236",
   "description": "WebPieces server with filter chain and dependency injection",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -22,7 +22,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@webpieces/http-routing": "0.3.234",
+    "@webpieces/http-routing": "0.3.236",
     "cors": "2.8.5"
   },
   "devDependencies": {

package/src/InProcessApiClientFactory.d.ts

@@ -0,0 +1,34 @@
+import { RouteBuilderImpl } from '@webpieces/http-routing';
+/**
+ * InProcessApiClientFactory - Creates API client proxies that invoke routes
+ * in-process (full filter chain + controller) WITHOUT any HTTP overhead.
+ *
+ * Extracted from WebpiecesServerImpl so both the full server
+ * (WebpiecesServer.createApiClient) and the embeddable adapter
+ * (WebpiecesRouteCreator.createApiClient) share one code path.
+ *
+ * The client uses the ApiPrototype class to discover routes via decorators,
+ * then creates pre-configured invoker functions for each API method.
+ *
+ * IMPORTANT: This loops over the API methods (from decorators), NOT all routes.
+ * For each API method, it sets up the filter chain ONCE during proxy creation,
+ * so subsequent calls reuse the same filter chain (efficient!).
+ */
+export declare class InProcessApiClientFactory {
+    private routeBuilder;
+    constructor(routeBuilder: RouteBuilderImpl);
+    /**
+     * Create an API client proxy for testing.
+     *
+     * @param apiPrototype - The API prototype class with routing decorators (can be abstract)
+     * @returns A proxy that implements the API interface
+     *
+     * Example:
+     * ```typescript
+     * const saveApi = factory.createApiClient<SaveApi>(SaveApi);
+     * const response = await saveApi.save(request);
+     * ```
+     */
+    createApiClient<T>(apiPrototype: abstract new (...args: any[]) => T): T;
+    private runMethod;
+}

package/src/InProcessApiClientFactory.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InProcessApiClientFactory = void 0;
+const http_routing_1 = require("@webpieces/http-routing");
+const core_context_1 = require("@webpieces/core-context");
+/**
+ * InProcessApiClientFactory - Creates API client proxies that invoke routes
+ * in-process (full filter chain + controller) WITHOUT any HTTP overhead.
+ *
+ * Extracted from WebpiecesServerImpl so both the full server
+ * (WebpiecesServer.createApiClient) and the embeddable adapter
+ * (WebpiecesRouteCreator.createApiClient) share one code path.
+ *
+ * The client uses the ApiPrototype class to discover routes via decorators,
+ * then creates pre-configured invoker functions for each API method.
+ *
+ * IMPORTANT: This loops over the API methods (from decorators), NOT all routes.
+ * For each API method, it sets up the filter chain ONCE during proxy creation,
+ * so subsequent calls reuse the same filter chain (efficient!).
+ */
+class InProcessApiClientFactory {
+    routeBuilder;
+    constructor(routeBuilder) {
+        this.routeBuilder = routeBuilder;
+    }
+    /**
+     * Create an API client proxy for testing.
+     *
+     * @param apiPrototype - The API prototype class with routing decorators (can be abstract)
+     * @returns A proxy that implements the API interface
+     *
+     * Example:
+     * ```typescript
+     * const saveApi = factory.createApiClient<SaveApi>(SaveApi);
+     * const response = await saveApi.save(request);
+     * ```
+     */
+    // webpieces-disable no-any-unknown -- abstract constructor signature requires any[] args
+    createApiClient(apiPrototype) {
+        // Get endpoints from the API prototype using @ApiPath/@Endpoint decorators
+        const basePath = (0, http_routing_1.getApiPath)(apiPrototype) || '';
+        const endpoints = (0, http_routing_1.getEndpoints)(apiPrototype) || {};
+        // Create proxy object
+        // webpieces-disable no-any-unknown -- proxy holds methods of arbitrary API shapes
+        const proxy = {};
+        // Loop over API endpoints and create proxy functions
+        for (const [methodName, endpointPath] of Object.entries(endpoints)) {
+            const httpMethod = 'POST';
+            const path = basePath + endpointPath;
+            const authMeta = (0, http_routing_1.getAuthMeta)(apiPrototype, methodName);
+            const routeMeta = new http_routing_1.RouteMetadata(httpMethod, path, methodName, apiPrototype.name, authMeta);
+            // Create invoker service ONCE (sets up filter chain once, not on every call!)
+            const service = this.routeBuilder.createRouteInvoker(httpMethod, path);
+            // Proxy method creates MethodMeta and calls the pre-configured service
+            // webpieces-disable no-any-unknown -- request/response DTO types are erased at proxy level
+            proxy[methodName] = async (requestDto) => {
+                // Auto-activate a RequestContext if the test did not wrap the call itself
+                if (!core_context_1.RequestContext.isActive()) {
+                    return core_context_1.RequestContext.run(async () => {
+                        return await this.runMethod(routeMeta, requestDto, service);
+                    });
+                }
+                return await this.runMethod(routeMeta, requestDto, service);
+            };
+        }
+        return proxy;
+    }
+    // webpieces-disable no-any-unknown -- DTO types are erased at the routing layer
+    async runMethod(routeMeta, requestDto, service) {
+        // Create MethodMeta without headers (in-process mode - no HTTP involved)
+        const meta = new http_routing_1.MethodMeta(routeMeta, undefined, requestDto);
+        const responseWrapper = await service.invoke(meta);
+        return responseWrapper.response;
+    }
+}
+exports.InProcessApiClientFactory = InProcessApiClientFactory;
+//# sourceMappingURL=InProcessApiClientFactory.js.map

package/src/InProcessApiClientFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InProcessApiClientFactory.js","sourceRoot":"","sources":["../../../../../packages/http/http-server/src/InProcessApiClientFactory.ts"],"names":[],"mappings":";;;AAAA,0DAOiC;AACjC,0DAAyD;AAGzD;;;;;;;;;;;;;;GAcG;AACH,MAAa,yBAAyB;IACd;IAApB,YAAoB,YAA8B;QAA9B,iBAAY,GAAZ,YAAY,CAAkB;IAAG,CAAC;IAEtD;;;;;;;;;;;OAWG;IACH,yFAAyF;IACzF,eAAe,CAAI,YAAgD;QAC/D,2EAA2E;QAC3E,MAAM,QAAQ,GAAG,IAAA,yBAAU,EAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QAChD,MAAM,SAAS,GAAG,IAAA,2BAAY,EAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QAEnD,sBAAsB;QACtB,kFAAkF;QAClF,MAAM,KAAK,GAA4B,EAAE,CAAC;QAE1C,qDAAqD;QACrD,KAAK,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YACjE,MAAM,UAAU,GAAG,MAAM,CAAC;YAC1B,MAAM,IAAI,GAAG,QAAQ,GAAG,YAAY,CAAC;YAErC,MAAM,QAAQ,GAAG,IAAA,0BAAW,EAAC,YAAY,EAAE,UAAU,CAAC,CAAC;YACvD,MAAM,SAAS,GAAG,IAAI,4BAAa,CAAC,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAE/F,8EAA8E;YAC9E,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YAEvE,uEAAuE;YACvE,2FAA2F;YAC3F,KAAK,CAAC,UAAU,CAAC,GAAG,KAAK,EAAE,UAAmB,EAAoB,EAAE;gBAChE,0EAA0E;gBAC1E,IAAI,CAAC,6BAAc,CAAC,QAAQ,EAAE,EAAE,CAAC;oBAC7B,OAAO,6BAAc,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;wBACjC,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;oBAChE,CAAC,CAAC,CAAC;gBACP,CAAC;gBACD,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;YAChE,CAAC,CAAC;QACN,CAAC;QAED,OAAO,KAAU,CAAC;IACtB,CAAC;IAED,gFAAgF;IACxE,KAAK,CAAC,SAAS,CAAC,SAAwB,EAAE,UAAmB,EAAE,OAAiD;QACpH,yEAAyE;QACzE,MAAM,IAAI,GAAG,IAAI,yBAAU,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QAC9D,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACnD,OAAO,eAAe,CAAC,QAAQ,CAAC;IACpC,CAAC;CACJ;AA3DD,8DA2DC","sourcesContent":["import {\n    getApiPath,\n    getAuthMeta,\n    getEndpoints,\n    MethodMeta,\n    RouteBuilderImpl,\n    RouteMetadata,\n} from '@webpieces/http-routing';\nimport { RequestContext } from '@webpieces/core-context';\nimport { Service, WpResponse } from '@webpieces/http-filters';\n\n/**\n * InProcessApiClientFactory - Creates API client proxies that invoke routes\n * in-process (full filter chain + controller) WITHOUT any HTTP overhead.\n *\n * Extracted from WebpiecesServerImpl so both the full server\n * (WebpiecesServer.createApiClient) and the embeddable adapter\n * (WebpiecesRouteCreator.createApiClient) share one code path.\n *\n * The client uses the ApiPrototype class to discover routes via decorators,\n * then creates pre-configured invoker functions for each API method.\n *\n * IMPORTANT: This loops over the API methods (from decorators), NOT all routes.\n * For each API method, it sets up the filter chain ONCE during proxy creation,\n * so subsequent calls reuse the same filter chain (efficient!).\n */\nexport class InProcessApiClientFactory {\n    constructor(private routeBuilder: RouteBuilderImpl) {}\n\n    /**\n     * Create an API client proxy for testing.\n     *\n     * @param apiPrototype - The API prototype class with routing decorators (can be abstract)\n     * @returns A proxy that implements the API interface\n     *\n     * Example:\n     * ```typescript\n     * const saveApi = factory.createApiClient<SaveApi>(SaveApi);\n     * const response = await saveApi.save(request);\n     * ```\n     */\n    // webpieces-disable no-any-unknown -- abstract constructor signature requires any[] args\n    createApiClient<T>(apiPrototype: abstract new (...args: any[]) => T): T {\n        // Get endpoints from the API prototype using @ApiPath/@Endpoint decorators\n        const basePath = getApiPath(apiPrototype) || '';\n        const endpoints = getEndpoints(apiPrototype) || {};\n\n        // Create proxy object\n        // webpieces-disable no-any-unknown -- proxy holds methods of arbitrary API shapes\n        const proxy: Record<string, unknown> = {};\n\n        // Loop over API endpoints and create proxy functions\n        for (const [methodName, endpointPath] of Object.entries(endpoints)) {\n            const httpMethod = 'POST';\n            const path = basePath + endpointPath;\n\n            const authMeta = getAuthMeta(apiPrototype, methodName);\n            const routeMeta = new RouteMetadata(httpMethod, path, methodName, apiPrototype.name, authMeta);\n\n            // Create invoker service ONCE (sets up filter chain once, not on every call!)\n            const service = this.routeBuilder.createRouteInvoker(httpMethod, path);\n\n            // Proxy method creates MethodMeta and calls the pre-configured service\n            // webpieces-disable no-any-unknown -- request/response DTO types are erased at proxy level\n            proxy[methodName] = async (requestDto: unknown): Promise<unknown> => {\n                // Auto-activate a RequestContext if the test did not wrap the call itself\n                if (!RequestContext.isActive()) {\n                    return RequestContext.run(async () => {\n                        return await this.runMethod(routeMeta, requestDto, service);\n                    });\n                }\n                return await this.runMethod(routeMeta, requestDto, service);\n            };\n        }\n\n        return proxy as T;\n    }\n\n    // webpieces-disable no-any-unknown -- DTO types are erased at the routing layer\n    private async runMethod(routeMeta: RouteMetadata, requestDto: unknown, service: Service<MethodMeta, WpResponse<unknown>>): Promise<unknown> {\n        // Create MethodMeta without headers (in-process mode - no HTTP involved)\n        const meta = new MethodMeta(routeMeta, undefined, requestDto);\n        const responseWrapper = await service.invoke(meta);\n        return responseWrapper.response;\n    }\n}\n"]}

package/src/WebpiecesRouteCreator.d.ts

@@ -0,0 +1,90 @@
+import { Express } from 'express';
+import { Container } from 'inversify';
+import { ClassType, FilterDefinition, RouteBuilderImpl } from '@webpieces/http-routing';
+import { WebpiecesMiddleware } from './WebpiecesMiddleware';
+/**
+ * WebpiecesRouteCreator - Embeddable adapter that mounts the webpieces
+ * api -> filters -> controller pipeline onto ANY existing Express app.
+ *
+ * Legacy Express apps can adopt webpieces incrementally: existing routes and
+ * middleware keep working untouched; each wired webpieces route is fully
+ * self-contained (own body parsing, own RequestContext, own error->JSON mapping).
+ * This class never calls app.use() - it only registers per-route handlers.
+ *
+ * Usage:
+ * ```typescript
+ * const app = express();                       // your existing legacy app
+ * const container = new Container();
+ * await container.load(buildProviderModule()); // picks up @provideSingleton classes
+ * await container.load(WebpiecesModule);       // required if you use ContextFilter
+ *
+ * const creator = new WebpiecesRouteCreator(app, container);
+ * creator.wireFilters(
+ *     new FilterDefinition(2000, ContextFilter, '*'),
+ *     new FilterDefinition(1900, AuthFilter, 'src/controllers/admin/**'),
+ * );
+ * creator.wireApi(SaveApi, SaveController);    // controller resolved from container
+ * creator.wireApi(PublicApi, PublicController);
+ * app.listen(8080);
+ * ```
+ *
+ * Notes:
+ * - ALL wireFilters() calls must come BEFORE the first wireApi() call. Filter
+ *   chains are composed per-route at wireApi time, so late filters would be
+ *   silently ignored - we throw instead.
+ * - Scoped filter glob patterns match the controller filepath from the
+ *   @SourceFile decorator, falling back to the pattern `**\/{ClassName}.ts`.
+ * - Want webpieces' localhost CORS? Opt in yourself:
+ *   `app.use(new WebpiecesMiddleware().corsForLocalhost())`.
+ *
+ * This same class is used internally by WebpiecesServerImpl.start(), so the
+ * full server and the embeddable adapter share one code path.
+ */
+export declare class WebpiecesRouteCreator {
+    private app;
+    private routeBuilder;
+    private middleware;
+    private clientFactory;
+    /** Locks wireFilters() once the first wireApi() has composed a filter chain. */
+    private apisWired;
+    /**
+     * @param app - The Express app to mount routes on (yours - never taken over)
+     * @param container - Inversify container used to resolve controllers and filters
+     * @param routeBuilder - Internal: WebpiecesServerImpl passes its DI singleton; standalone users omit
+     * @param middleware - Internal: WebpiecesServerImpl passes its DI singleton; standalone users omit
+     */
+    constructor(app: Express, container: Container, routeBuilder?: RouteBuilderImpl, middleware?: WebpiecesMiddleware);
+    /**
+     * Register filters that wrap every matching route (glob pattern vs controller filepath).
+     * Must be called before the first wireApi() - filter chains are composed per-route.
+     */
+    wireFilters(...defs: FilterDefinition[]): void;
+    /**
+     * Wire an API prototype class (with @ApiPath/@Endpoint decorators) to its
+     * controller, mounting one Express route per endpoint with the full filter
+     * chain. The controller is resolved from the Inversify container.
+     */
+    wireApi<TApi, TController extends TApi>(apiPrototype: ClassType<TApi>, controllerClass: ClassType<TController>): void;
+    /**
+     * Mount every route currently registered on the RouteBuilder.
+     * Used by WebpiecesServerImpl.start() where routes were registered up front
+     * from WebAppMeta.getRoutes().
+     *
+     * @returns Number of routes mounted
+     */
+    mountRegisteredRoutes(): number;
+    /**
+     * Create an in-process API client (full filter chain + controller, no HTTP).
+     * Same testing story as WebpiecesServer.createApiClient().
+     */
+    createApiClient<T>(apiPrototype: abstract new (...args: any[]) => T): T;
+    /**
+     * Escape hatch for advanced wiring (e.g. addRoute with a hand-built RouteDefinition).
+     */
+    getRouteBuilder(): RouteBuilderImpl;
+    /**
+     * Compose the filter chain for one route and register it on the Express app.
+     */
+    private mountRoute;
+    private registerHandler;
+}

package/src/WebpiecesRouteCreator.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebpiecesRouteCreator = void 0;
+const http_routing_1 = require("@webpieces/http-routing");
+const WebpiecesMiddleware_1 = require("./WebpiecesMiddleware");
+const InProcessApiClientFactory_1 = require("./InProcessApiClientFactory");
+/**
+ * WebpiecesRouteCreator - Embeddable adapter that mounts the webpieces
+ * api -> filters -> controller pipeline onto ANY existing Express app.
+ *
+ * Legacy Express apps can adopt webpieces incrementally: existing routes and
+ * middleware keep working untouched; each wired webpieces route is fully
+ * self-contained (own body parsing, own RequestContext, own error->JSON mapping).
+ * This class never calls app.use() - it only registers per-route handlers.
+ *
+ * Usage:
+ * ```typescript
+ * const app = express();                       // your existing legacy app
+ * const container = new Container();
+ * await container.load(buildProviderModule()); // picks up @provideSingleton classes
+ * await container.load(WebpiecesModule);       // required if you use ContextFilter
+ *
+ * const creator = new WebpiecesRouteCreator(app, container);
+ * creator.wireFilters(
+ *     new FilterDefinition(2000, ContextFilter, '*'),
+ *     new FilterDefinition(1900, AuthFilter, 'src/controllers/admin/**'),
+ * );
+ * creator.wireApi(SaveApi, SaveController);    // controller resolved from container
+ * creator.wireApi(PublicApi, PublicController);
+ * app.listen(8080);
+ * ```
+ *
+ * Notes:
+ * - ALL wireFilters() calls must come BEFORE the first wireApi() call. Filter
+ *   chains are composed per-route at wireApi time, so late filters would be
+ *   silently ignored - we throw instead.
+ * - Scoped filter glob patterns match the controller filepath from the
+ *   @SourceFile decorator, falling back to the pattern `**\/{ClassName}.ts`.
+ * - Want webpieces' localhost CORS? Opt in yourself:
+ *   `app.use(new WebpiecesMiddleware().corsForLocalhost())`.
+ *
+ * This same class is used internally by WebpiecesServerImpl.start(), so the
+ * full server and the embeddable adapter share one code path.
+ */
+class WebpiecesRouteCreator {
+    app;
+    routeBuilder;
+    middleware;
+    clientFactory;
+    /** Locks wireFilters() once the first wireApi() has composed a filter chain. */
+    apisWired = false;
+    /**
+     * @param app - The Express app to mount routes on (yours - never taken over)
+     * @param container - Inversify container used to resolve controllers and filters
+     * @param routeBuilder - Internal: WebpiecesServerImpl passes its DI singleton; standalone users omit
+     * @param middleware - Internal: WebpiecesServerImpl passes its DI singleton; standalone users omit
+     */
+    constructor(app, container, routeBuilder, middleware) {
+        this.app = app;
+        this.routeBuilder = routeBuilder ?? new http_routing_1.RouteBuilderImpl();
+        this.routeBuilder.setContainer(container);
+        this.middleware = middleware ?? new WebpiecesMiddleware_1.WebpiecesMiddleware();
+        this.clientFactory = new InProcessApiClientFactory_1.InProcessApiClientFactory(this.routeBuilder);
+    }
+    /**
+     * Register filters that wrap every matching route (glob pattern vs controller filepath).
+     * Must be called before the first wireApi() - filter chains are composed per-route.
+     */
+    wireFilters(...defs) {
+        if (this.apisWired) {
+            throw new Error('wireFilters() must be called before wireApi() - filter chains are composed per-route at wireApi time, so filters added later would never run.');
+        }
+        for (const def of defs) {
+            this.routeBuilder.addFilter(def);
+        }
+    }
+    /**
+     * Wire an API prototype class (with @ApiPath/@Endpoint decorators) to its
+     * controller, mounting one Express route per endpoint with the full filter
+     * chain. The controller is resolved from the Inversify container.
+     */
+    wireApi(apiPrototype, controllerClass) {
+        this.apisWired = true;
+        // Reuses all existing validation: @ApiPath present, controller extends
+        // api prototype, every endpoint implemented + has @Authentication.
+        const factory = new http_routing_1.ApiRoutingFactory(apiPrototype, controllerClass);
+        // Mount only the routes added by THIS call
+        const routesBefore = this.routeBuilder.getRoutes().length;
+        factory.configure(this.routeBuilder);
+        const routes = this.routeBuilder.getRoutes();
+        for (let i = routesBefore; i < routes.length; i++) {
+            this.mountRoute(routes[i]);
+        }
+    }
+    /**
+     * Mount every route currently registered on the RouteBuilder.
+     * Used by WebpiecesServerImpl.start() where routes were registered up front
+     * from WebAppMeta.getRoutes().
+     *
+     * @returns Number of routes mounted
+     */
+    mountRegisteredRoutes() {
+        const routes = this.routeBuilder.getRoutes();
+        for (const routeWithMeta of routes) {
+            this.mountRoute(routeWithMeta);
+        }
+        return routes.length;
+    }
+    /**
+     * Create an in-process API client (full filter chain + controller, no HTTP).
+     * Same testing story as WebpiecesServer.createApiClient().
+     */
+    // webpieces-disable no-any-unknown -- abstract constructor signature requires any[] args
+    createApiClient(apiPrototype) {
+        return this.clientFactory.createApiClient(apiPrototype);
+    }
+    /**
+     * Escape hatch for advanced wiring (e.g. addRoute with a hand-built RouteDefinition).
+     */
+    getRouteBuilder() {
+        return this.routeBuilder;
+    }
+    /**
+     * Compose the filter chain for one route and register it on the Express app.
+     */
+    mountRoute(routeWithMeta) {
+        const service = this.routeBuilder.createRouteHandler(routeWithMeta);
+        const routeMeta = routeWithMeta.definition.routeMeta;
+        // ExpressWrapper handles the full request/response cycle per route:
+        // RequestContext.run, header read, manual JSON body parse, error->ProtocolError
+        const wrapper = this.middleware.createExpressWrapper(service, routeMeta);
+        this.registerHandler(routeMeta.httpMethod, routeMeta.path, wrapper.execute.bind(wrapper));
+    }
+    registerHandler(httpMethod, path, expressHandler) {
+        switch (httpMethod.toLowerCase()) {
+            case 'get':
+                this.app.get(path, expressHandler);
+                break;
+            case 'post':
+                this.app.post(path, expressHandler);
+                break;
+            case 'put':
+                this.app.put(path, expressHandler);
+                break;
+            case 'delete':
+                this.app.delete(path, expressHandler);
+                break;
+            case 'patch':
+                this.app.patch(path, expressHandler);
+                break;
+            default:
+                console.warn(`[WebpiecesRouteCreator] Unknown HTTP method: ${httpMethod}`);
+        }
+    }
+}
+exports.WebpiecesRouteCreator = WebpiecesRouteCreator;
+//# sourceMappingURL=WebpiecesRouteCreator.js.map

package/src/WebpiecesRouteCreator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebpiecesRouteCreator.js","sourceRoot":"","sources":["../../../../../packages/http/http-server/src/WebpiecesRouteCreator.ts"],"names":[],"mappings":"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","sourcesContent":["import { Express } from 'express';\nimport { Container } from 'inversify';\nimport {\n    ApiRoutingFactory,\n    ClassType,\n    ExpressRouteHandler,\n    FilterDefinition,\n    RouteBuilderImpl,\n    RouteHandlerWithMeta,\n} from '@webpieces/http-routing';\nimport { WebpiecesMiddleware } from './WebpiecesMiddleware';\nimport { InProcessApiClientFactory } from './InProcessApiClientFactory';\n\n/**\n * WebpiecesRouteCreator - Embeddable adapter that mounts the webpieces\n * api -> filters -> controller pipeline onto ANY existing Express app.\n *\n * Legacy Express apps can adopt webpieces incrementally: existing routes and\n * middleware keep working untouched; each wired webpieces route is fully\n * self-contained (own body parsing, own RequestContext, own error->JSON mapping).\n * This class never calls app.use() - it only registers per-route handlers.\n *\n * Usage:\n * ```typescript\n * const app = express();                       // your existing legacy app\n * const container = new Container();\n * await container.load(buildProviderModule()); // picks up @provideSingleton classes\n * await container.load(WebpiecesModule);       // required if you use ContextFilter\n *\n * const creator = new WebpiecesRouteCreator(app, container);\n * creator.wireFilters(\n *     new FilterDefinition(2000, ContextFilter, '*'),\n *     new FilterDefinition(1900, AuthFilter, 'src/controllers/admin/**'),\n * );\n * creator.wireApi(SaveApi, SaveController);    // controller resolved from container\n * creator.wireApi(PublicApi, PublicController);\n * app.listen(8080);\n * ```\n *\n * Notes:\n * - ALL wireFilters() calls must come BEFORE the first wireApi() call. Filter\n *   chains are composed per-route at wireApi time, so late filters would be\n *   silently ignored - we throw instead.\n * - Scoped filter glob patterns match the controller filepath from the\n *   @SourceFile decorator, falling back to the pattern `**\\/{ClassName}.ts`.\n * - Want webpieces' localhost CORS? Opt in yourself:\n *   `app.use(new WebpiecesMiddleware().corsForLocalhost())`.\n *\n * This same class is used internally by WebpiecesServerImpl.start(), so the\n * full server and the embeddable adapter share one code path.\n */\nexport class WebpiecesRouteCreator {\n    private routeBuilder: RouteBuilderImpl;\n    private middleware: WebpiecesMiddleware;\n    private clientFactory: InProcessApiClientFactory;\n\n    /** Locks wireFilters() once the first wireApi() has composed a filter chain. */\n    private apisWired = false;\n\n    /**\n     * @param app - The Express app to mount routes on (yours - never taken over)\n     * @param container - Inversify container used to resolve controllers and filters\n     * @param routeBuilder - Internal: WebpiecesServerImpl passes its DI singleton; standalone users omit\n     * @param middleware - Internal: WebpiecesServerImpl passes its DI singleton; standalone users omit\n     */\n    constructor(\n        private app: Express,\n        container: Container,\n        routeBuilder?: RouteBuilderImpl,\n        middleware?: WebpiecesMiddleware,\n    ) {\n        this.routeBuilder = routeBuilder ?? new RouteBuilderImpl();\n        this.routeBuilder.setContainer(container);\n        this.middleware = middleware ?? new WebpiecesMiddleware();\n        this.clientFactory = new InProcessApiClientFactory(this.routeBuilder);\n    }\n\n    /**\n     * Register filters that wrap every matching route (glob pattern vs controller filepath).\n     * Must be called before the first wireApi() - filter chains are composed per-route.\n     */\n    wireFilters(...defs: FilterDefinition[]): void {\n        if (this.apisWired) {\n            throw new Error(\n                'wireFilters() must be called before wireApi() - filter chains are composed per-route at wireApi time, so filters added later would never run.',\n            );\n        }\n        for (const def of defs) {\n            this.routeBuilder.addFilter(def);\n        }\n    }\n\n    /**\n     * Wire an API prototype class (with @ApiPath/@Endpoint decorators) to its\n     * controller, mounting one Express route per endpoint with the full filter\n     * chain. The controller is resolved from the Inversify container.\n     */\n    wireApi<TApi, TController extends TApi>(\n        apiPrototype: ClassType<TApi>,\n        controllerClass: ClassType<TController>,\n    ): void {\n        this.apisWired = true;\n\n        // Reuses all existing validation: @ApiPath present, controller extends\n        // api prototype, every endpoint implemented + has @Authentication.\n        const factory = new ApiRoutingFactory(apiPrototype, controllerClass);\n\n        // Mount only the routes added by THIS call\n        const routesBefore = this.routeBuilder.getRoutes().length;\n        factory.configure(this.routeBuilder);\n        const routes = this.routeBuilder.getRoutes();\n\n        for (let i = routesBefore; i < routes.length; i++) {\n            this.mountRoute(routes[i]);\n        }\n    }\n\n    /**\n     * Mount every route currently registered on the RouteBuilder.\n     * Used by WebpiecesServerImpl.start() where routes were registered up front\n     * from WebAppMeta.getRoutes().\n     *\n     * @returns Number of routes mounted\n     */\n    mountRegisteredRoutes(): number {\n        const routes = this.routeBuilder.getRoutes();\n        for (const routeWithMeta of routes) {\n            this.mountRoute(routeWithMeta);\n        }\n        return routes.length;\n    }\n\n    /**\n     * Create an in-process API client (full filter chain + controller, no HTTP).\n     * Same testing story as WebpiecesServer.createApiClient().\n     */\n    // webpieces-disable no-any-unknown -- abstract constructor signature requires any[] args\n    createApiClient<T>(apiPrototype: abstract new (...args: any[]) => T): T {\n        return this.clientFactory.createApiClient(apiPrototype);\n    }\n\n    /**\n     * Escape hatch for advanced wiring (e.g. addRoute with a hand-built RouteDefinition).\n     */\n    getRouteBuilder(): RouteBuilderImpl {\n        return this.routeBuilder;\n    }\n\n    /**\n     * Compose the filter chain for one route and register it on the Express app.\n     */\n    private mountRoute(routeWithMeta: RouteHandlerWithMeta): void {\n        const service = this.routeBuilder.createRouteHandler(routeWithMeta);\n        const routeMeta = routeWithMeta.definition.routeMeta;\n\n        // ExpressWrapper handles the full request/response cycle per route:\n        // RequestContext.run, header read, manual JSON body parse, error->ProtocolError\n        const wrapper = this.middleware.createExpressWrapper(service, routeMeta);\n\n        this.registerHandler(\n            routeMeta.httpMethod,\n            routeMeta.path,\n            wrapper.execute.bind(wrapper),\n        );\n    }\n\n    private registerHandler(httpMethod: string, path: string, expressHandler: ExpressRouteHandler): void {\n        switch (httpMethod.toLowerCase()) {\n            case 'get':\n                this.app.get(path, expressHandler);\n                break;\n            case 'post':\n                this.app.post(path, expressHandler);\n                break;\n            case 'put':\n                this.app.put(path, expressHandler);\n                break;\n            case 'delete':\n                this.app.delete(path, expressHandler);\n                break;\n            case 'patch':\n                this.app.patch(path, expressHandler);\n                break;\n            default:\n                console.warn(`[WebpiecesRouteCreator] Unknown HTTP method: ${httpMethod}`);\n        }\n    }\n}\n"]}

package/src/WebpiecesServerImpl.d.ts

@@ -1,5 +1,5 @@
 import { Container, ContainerModule } from 'inversify';
-import { ExpressRouteHandler, RouteBuilderImpl, WebAppMeta } from '@webpieces/http-routing';
+import { RouteBuilderImpl, WebAppMeta } from '@webpieces/http-routing';
 import { WebpiecesServer } from './WebpiecesServer';
 import { WebpiecesMiddleware } from './WebpiecesMiddleware';
 /**
@@ -84,14 +84,6 @@ export declare class WebpiecesServerImpl implements WebpiecesServer {
      * @returns Promise that resolves when server is ready
      */
     start(port?: number, testMode?: boolean): Promise<void>;
-    /**
-     * Register Express routes - the SINGLE loop over routes.
-     * For each route: createHandler (sets up filter chain) → wrapExpress → registerHandler.
-     *
-     * @returns Number of routes registered
-     */
-    private registerExpressRoutes;
-    registerHandler(httpMethod: string, path: string, expressHandler: ExpressRouteHandler): void;
     /**
      * Stop the HTTP server.
      * Returns a Promise that resolves when the server is stopped,
@@ -131,5 +123,5 @@ export declare class WebpiecesServerImpl implements WebpiecesServer {
      * ```
      */
     createApiClient<T>(apiPrototype: abstract new (...args: any[]) => T): T;
-    private runMethod;
+    private clientFactory?;
 }

package/src/WebpiecesServerImpl.js

@@ -7,7 +7,8 @@ const inversify_1 = require("inversify");
 const binding_decorators_1 = require("@inversifyjs/binding-decorators");
 const http_routing_1 = require("@webpieces/http-routing");
 const WebpiecesMiddleware_1 = require("./WebpiecesMiddleware");
-const core_context_1 = require("@webpieces/core-context");
+const WebpiecesRouteCreator_1 = require("./WebpiecesRouteCreator");
+const InProcessApiClientFactory_1 = require("./InProcessApiClientFactory");
 /**
  * WebpiecesServerImpl - Internal server implementation.
  *
@@ -145,8 +146,10 @@ let WebpiecesServerImpl = class WebpiecesServerImpl {
         this.app.use(this.middleware.corsForLocalhost());
         // Layer 3: Request/Response Logging
         this.app.use(this.middleware.logNextLayer.bind(this.middleware));
-        // Register routes
-        const routeCount = this.registerExpressRoutes();
+        // Register routes via the shared adapter (same code path as the
+        // embeddable WebpiecesRouteCreator used by legacy Express apps)
+        const routeCreator = new WebpiecesRouteCreator_1.WebpiecesRouteCreator(this.app, this.appContainer, this.routeBuilder, this.middleware);
+        const routeCount = routeCreator.mountRegisteredRoutes();
         // Start listening - wrap in Promise
         const promise = new Promise((resolve, reject) => {
             this.server = this.app.listen(this.port, (error) => {
@@ -162,52 +165,6 @@ let WebpiecesServerImpl = class WebpiecesServerImpl {
         });
         await promise;
     }
-    /**
-     * Register Express routes - the SINGLE loop over routes.
-     * For each route: createHandler (sets up filter chain) → wrapExpress → registerHandler.
-     *
-     * @returns Number of routes registered
-     */
-    registerExpressRoutes() {
-        if (!this.app) {
-            throw new Error('Express app not initialized');
-        }
-        const routes = this.routeBuilder.getRoutes();
-        let count = 0;
-        for (const routeWithMeta of routes) {
-            const service = this.routeBuilder.createRouteHandler(routeWithMeta);
-            const routeMeta = routeWithMeta.definition.routeMeta;
-            // Create ExpressWrapper directly (handles full request/response cycle)
-            const wrapper = this.middleware.createExpressWrapper(service, routeMeta);
-            this.registerHandler(routeMeta.httpMethod, routeMeta.path, wrapper.execute.bind(wrapper));
-            count++;
-        }
-        return count;
-    }
-    registerHandler(httpMethod, path, expressHandler) {
-        if (!this.app) {
-            throw new Error('Express app not initialized');
-        }
-        switch (httpMethod.toLowerCase()) {
-            case 'get':
-                this.app.get(path, expressHandler);
-                break;
-            case 'post':
-                this.app.post(path, expressHandler);
-                break;
-            case 'put':
-                this.app.put(path, expressHandler);
-                break;
-            case 'delete':
-                this.app.delete(path, expressHandler);
-                break;
-            case 'patch':
-                this.app.patch(path, expressHandler);
-                break;
-            default:
-                console.warn(`[WebpiecesServer] Unknown HTTP method: ${httpMethod}`);
-        }
-    }
     /**
      * Stop the HTTP server.
      * Returns a Promise that resolves when the server is stopped,
@@ -263,47 +220,18 @@ let WebpiecesServerImpl = class WebpiecesServerImpl {
      * const response = await saveApi.save(request);
      * ```
      */
+    // webpieces-disable no-any-unknown -- abstract constructor signature requires any[] args
     createApiClient(apiPrototype) {
         if (!this.initialized) {
             throw new Error('Server not initialized. Call initialize() before createApiClient().');
         }
-        // Get endpoints from the API prototype using @ApiPath/@Endpoint decorators
-        const basePath = (0, http_routing_1.getApiPath)(apiPrototype) || '';
-        const endpoints = (0, http_routing_1.getEndpoints)(apiPrototype) || {};
-        // Create proxy object
-        const proxy = {};
-        // Loop over API endpoints and create proxy functions
-        for (const [methodName, endpointPath] of Object.entries(endpoints)) {
-            const httpMethod = 'POST';
-            const path = basePath + endpointPath;
-            const authMeta = (0, http_routing_1.getAuthMeta)(apiPrototype, methodName);
-            const routeMeta = new http_routing_1.RouteMetadata(httpMethod, path, methodName, apiPrototype.name, authMeta);
-            // Create invoker service ONCE (sets up filter chain once, not on every call!)
-            const service = this.routeBuilder.createRouteInvoker(httpMethod, path);
-            // Proxy method creates MethodMeta and calls the pre-configured service
-            // IMPORTANT: Tests MUST wrap calls in RequestContext.run() themselves
-            // This forces explicit context setup in tests, matching production behavior
-            proxy[methodName] = async (requestDto) => {
-                // Verify we're inside an active RequestContext
-                // This helps test authors know they need to wrap their test in RequestContext.run()
-                if (!core_context_1.RequestContext.isActive()) {
-                    //Many devs may not activate headers
-                    return core_context_1.RequestContext.run(async () => {
-                        return await this.runMethod(routeMeta, requestDto, service);
-                    });
-                }
-                return await this.runMethod(routeMeta, requestDto, service);
-            };
+        // Delegates to the shared factory (same code path as WebpiecesRouteCreator.createApiClient)
+        if (!this.clientFactory) {
+            this.clientFactory = new InProcessApiClientFactory_1.InProcessApiClientFactory(this.routeBuilder);
         }
-        return proxy;
-    }
-    async runMethod(routeMeta, requestDto, service) {
-        // Create MethodMeta without headers (test mode - no HTTP involved)
-        // requestHeaders is optional, so we can omit it
-        const meta = new http_routing_1.MethodMeta(routeMeta, undefined, requestDto);
-        const responseWrapper = await service.invoke(meta);
-        return responseWrapper.response;
+        return this.clientFactory.createApiClient(apiPrototype);
     }
+    clientFactory;
 };
 exports.WebpiecesServerImpl = WebpiecesServerImpl;
 exports.WebpiecesServerImpl = WebpiecesServerImpl = tslib_1.__decorate([