@webpieces/http-server 0.3.278 → 0.3.280

package/src/index.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterDefinition = exports.FilterMatcher = exports.FilterWithMeta = exports.RouteHandlerWithMeta = exports.RouteBuilderImpl = exports.MethodMeta = exports.RouteHandler = exports.HeaderRegistry = exports.WebpiecesCoreHeaders = exports.WebpiecesModule = exports.recordable = exports.SpecGenerator = exports.TestCaseRecorderImpl = exports.ServiceAuthFilter = exports.RecordingFilter = exports.LogApiFilter = exports.ContextFilter = exports.InProcessApiClientFactory = exports.WebpiecesRouteCreator = exports.WebpiecesMiddleware = exports.WebpiecesFactory = void 0;
-var WebpiecesFactory_1 = require("./WebpiecesFactory");
-Object.defineProperty(exports, "WebpiecesFactory", { enumerable: true, get: function () { return WebpiecesFactory_1.WebpiecesFactory; } });
+exports.FilterDefinition = exports.FilterMatcher = exports.FilterWithMeta = exports.RouteHandlerWithMeta = exports.RouteBuilderImpl = exports.MethodMeta = exports.RouteHandler = exports.HeaderRegistry = exports.WebpiecesCoreHeaders = exports.WebpiecesModule = exports.recordable = exports.SpecGenerator = exports.TestCaseRecorderImpl = exports.ServiceAuthFilter = exports.RecordingFilter = exports.LogApiFilter = exports.ContextFilter = exports.InProcessApiClientFactory = exports.WebpiecesRouteCreator = exports.WebpiecesMiddleware = exports.WebpiecesExpress = void 0;
+// Express adapter (the only place express lifecycle lives) over the node-only WebpiecesRouter
+var WebpiecesExpress_1 = require("./WebpiecesExpress");
+Object.defineProperty(exports, "WebpiecesExpress", { enumerable: true, get: function () { return WebpiecesExpress_1.WebpiecesExpress; } });
 var WebpiecesMiddleware_1 = require("./WebpiecesMiddleware");
 Object.defineProperty(exports, "WebpiecesMiddleware", { enumerable: true, get: function () { return WebpiecesMiddleware_1.WebpiecesMiddleware; } });
 var WebpiecesRouteCreator_1 = require("./WebpiecesRouteCreator");
 Object.defineProperty(exports, "WebpiecesRouteCreator", { enumerable: true, get: function () { return WebpiecesRouteCreator_1.WebpiecesRouteCreator; } });
-var InProcessApiClientFactory_1 = require("./InProcessApiClientFactory");
-Object.defineProperty(exports, "InProcessApiClientFactory", { enumerable: true, get: function () { return InProcessApiClientFactory_1.InProcessApiClientFactory; } });
+// InProcessApiClientFactory moved to node-only http-routing; re-export for back-compat
+var http_routing_1 = require("@webpieces/http-routing");
+Object.defineProperty(exports, "InProcessApiClientFactory", { enumerable: true, get: function () { return http_routing_1.InProcessApiClientFactory; } });
 var ContextFilter_1 = require("./filters/ContextFilter");
 Object.defineProperty(exports, "ContextFilter", { enumerable: true, get: function () { return ContextFilter_1.ContextFilter; } });
 var LogApiFilter_1 = require("./filters/LogApiFilter");
@@ -33,12 +35,12 @@ var core_util_1 = require("@webpieces/core-util");
 Object.defineProperty(exports, "HeaderRegistry", { enumerable: true, get: function () { return core_util_1.HeaderRegistry; } });
 // Re-export from http-routing for backward compatibility
 // (FilterDefinition re-exported for one-import adapter ergonomics)
-var http_routing_1 = require("@webpieces/http-routing");
-Object.defineProperty(exports, "RouteHandler", { enumerable: true, get: function () { return http_routing_1.RouteHandler; } });
-Object.defineProperty(exports, "MethodMeta", { enumerable: true, get: function () { return http_routing_1.MethodMeta; } });
-Object.defineProperty(exports, "RouteBuilderImpl", { enumerable: true, get: function () { return http_routing_1.RouteBuilderImpl; } });
-Object.defineProperty(exports, "RouteHandlerWithMeta", { enumerable: true, get: function () { return http_routing_1.RouteHandlerWithMeta; } });
-Object.defineProperty(exports, "FilterWithMeta", { enumerable: true, get: function () { return http_routing_1.FilterWithMeta; } });
-Object.defineProperty(exports, "FilterMatcher", { enumerable: true, get: function () { return http_routing_1.FilterMatcher; } });
-Object.defineProperty(exports, "FilterDefinition", { enumerable: true, get: function () { return http_routing_1.FilterDefinition; } });
+var http_routing_2 = require("@webpieces/http-routing");
+Object.defineProperty(exports, "RouteHandler", { enumerable: true, get: function () { return http_routing_2.RouteHandler; } });
+Object.defineProperty(exports, "MethodMeta", { enumerable: true, get: function () { return http_routing_2.MethodMeta; } });
+Object.defineProperty(exports, "RouteBuilderImpl", { enumerable: true, get: function () { return http_routing_2.RouteBuilderImpl; } });
+Object.defineProperty(exports, "RouteHandlerWithMeta", { enumerable: true, get: function () { return http_routing_2.RouteHandlerWithMeta; } });
+Object.defineProperty(exports, "FilterWithMeta", { enumerable: true, get: function () { return http_routing_2.FilterWithMeta; } });
+Object.defineProperty(exports, "FilterMatcher", { enumerable: true, get: function () { return http_routing_2.FilterMatcher; } });
+Object.defineProperty(exports, "FilterDefinition", { enumerable: true, get: function () { return http_routing_2.FilterDefinition; } });
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/http/http-server/src/index.ts"],"names":[],"mappings":";;;AACA,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,6DAA4D;AAAnD,0HAAA,mBAAmB,OAAA;AAC5B,iEAAgE;AAAvD,8HAAA,qBAAqB,OAAA;AAC9B,yEAAwE;AAA/D,sIAAA,yBAAyB,OAAA;AAClC,yDAAwD;AAA/C,8GAAA,aAAa,OAAA;AACtB,uDAAsD;AAA7C,4GAAA,YAAY,OAAA;AACrB,6DAA4D;AAAnD,kHAAA,eAAe,OAAA;AACxB,iEAAgE;AAAvD,sHAAA,iBAAiB,OAAA;AAE1B,+DAA+D;AAC/D,wEAAuE;AAA9D,4HAAA,oBAAoB,OAAA;AAC7B,0DAAyD;AAAhD,8GAAA,aAAa,OAAA;AACtB,oDAAmD;AAA1C,wGAAA,UAAU,OAAA;AAEnB,mBAAmB;AACnB,6DAA4D;AAAnD,kHAAA,eAAe,OAAA;AACxB,uEAAsE;AAA7D,4HAAA,oBAAoB,OAAA;AAC7B,kDAAsD;AAA7C,2GAAA,cAAc,OAAA;AAEvB,yDAAyD;AACzD,mEAAmE;AACnE,wDAUiC;AAT7B,4GAAA,YAAY,OAAA;AAEZ,0GAAA,UAAU,OAAA;AACV,gHAAA,gBAAgB,OAAA;AAChB,oHAAA,oBAAoB,OAAA;AACpB,8GAAA,cAAc,OAAA;AAEd,6GAAA,aAAa,OAAA;AACb,gHAAA,gBAAgB,OAAA","sourcesContent":["export { WebpiecesServer } from './WebpiecesServer';\nexport { WebpiecesFactory } from './WebpiecesFactory';\nexport { WebpiecesMiddleware } from './WebpiecesMiddleware';\nexport { WebpiecesRouteCreator } from './WebpiecesRouteCreator';\nexport { InProcessApiClientFactory } from './InProcessApiClientFactory';\nexport { ContextFilter } from './filters/ContextFilter';\nexport { LogApiFilter } from './filters/LogApiFilter';\nexport { RecordingFilter } from './filters/RecordingFilter';\nexport { ServiceAuthFilter } from './filters/ServiceAuthFilter';\n\n// Test-case recording (contract lives in @webpieces/core-util)\nexport { TestCaseRecorderImpl } from './recorder/TestCaseRecorderImpl';\nexport { SpecGenerator } from './recorder/SpecGenerator';\nexport { recordable } from './recorder/recordable';\n\n// Platform Headers\nexport { WebpiecesModule } from './modules/WebpiecesModule';\nexport { WebpiecesCoreHeaders } from './headers/WebpiecesCoreHeaders';\nexport { HeaderRegistry } from '@webpieces/core-util';\n\n// Re-export from http-routing for backward compatibility\n// (FilterDefinition re-exported for one-import adapter ergonomics)\nexport {\n    RouteHandler,\n    ExpressRouteHandler,\n    MethodMeta,\n    RouteBuilderImpl,\n    RouteHandlerWithMeta,\n    FilterWithMeta,\n    HttpFilter,\n    FilterMatcher,\n    FilterDefinition,\n} from '@webpieces/http-routing';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/http/http-server/src/index.ts"],"names":[],"mappings":";;;AAAA,8FAA8F;AAC9F,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,6DAA4D;AAAnD,0HAAA,mBAAmB,OAAA;AAC5B,iEAAgE;AAAvD,8HAAA,qBAAqB,OAAA;AAC9B,uFAAuF;AACvF,wDAAoE;AAA3D,yHAAA,yBAAyB,OAAA;AAClC,yDAAwD;AAA/C,8GAAA,aAAa,OAAA;AACtB,uDAAsD;AAA7C,4GAAA,YAAY,OAAA;AACrB,6DAA4D;AAAnD,kHAAA,eAAe,OAAA;AACxB,iEAAgE;AAAvD,sHAAA,iBAAiB,OAAA;AAE1B,+DAA+D;AAC/D,wEAAuE;AAA9D,4HAAA,oBAAoB,OAAA;AAC7B,0DAAyD;AAAhD,8GAAA,aAAa,OAAA;AACtB,oDAAmD;AAA1C,wGAAA,UAAU,OAAA;AAEnB,mBAAmB;AACnB,6DAA4D;AAAnD,kHAAA,eAAe,OAAA;AACxB,uEAAsE;AAA7D,4HAAA,oBAAoB,OAAA;AAC7B,kDAAsD;AAA7C,2GAAA,cAAc,OAAA;AAEvB,yDAAyD;AACzD,mEAAmE;AACnE,wDASiC;AAR7B,4GAAA,YAAY,OAAA;AACZ,0GAAA,UAAU,OAAA;AACV,gHAAA,gBAAgB,OAAA;AAChB,oHAAA,oBAAoB,OAAA;AACpB,8GAAA,cAAc,OAAA;AAEd,6GAAA,aAAa,OAAA;AACb,gHAAA,gBAAgB,OAAA","sourcesContent":["// Express adapter (the only place express lifecycle lives) over the node-only WebpiecesRouter\nexport { WebpiecesExpress } from './WebpiecesExpress';\nexport { WebpiecesMiddleware } from './WebpiecesMiddleware';\nexport { WebpiecesRouteCreator } from './WebpiecesRouteCreator';\n// InProcessApiClientFactory moved to node-only http-routing; re-export for back-compat\nexport { InProcessApiClientFactory } from '@webpieces/http-routing';\nexport { ContextFilter } from './filters/ContextFilter';\nexport { LogApiFilter } from './filters/LogApiFilter';\nexport { RecordingFilter } from './filters/RecordingFilter';\nexport { ServiceAuthFilter } from './filters/ServiceAuthFilter';\n\n// Test-case recording (contract lives in @webpieces/core-util)\nexport { TestCaseRecorderImpl } from './recorder/TestCaseRecorderImpl';\nexport { SpecGenerator } from './recorder/SpecGenerator';\nexport { recordable } from './recorder/recordable';\n\n// Platform Headers\nexport { WebpiecesModule } from './modules/WebpiecesModule';\nexport { WebpiecesCoreHeaders } from './headers/WebpiecesCoreHeaders';\nexport { HeaderRegistry } from '@webpieces/core-util';\n\n// Re-export from http-routing for backward compatibility\n// (FilterDefinition re-exported for one-import adapter ergonomics)\nexport {\n    RouteHandler,\n    MethodMeta,\n    RouteBuilderImpl,\n    RouteHandlerWithMeta,\n    FilterWithMeta,\n    HttpFilter,\n    FilterMatcher,\n    FilterDefinition,\n} from '@webpieces/http-routing';\n// ExpressRouteHandler now lives in http-server (express adapter), not node-only http-routing\nexport { ExpressRouteHandler } from './WebpiecesMiddleware';\n"]}

package/src/InProcessApiClientFactory.d.ts

@@ -1,34 +0,0 @@
-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

@@ -1,77 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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/WebpiecesFactory.d.ts

@@ -1,66 +0,0 @@
-import { ContainerModule } from 'inversify';
-import { WebAppMeta, WebpiecesConfig } from '@webpieces/http-routing';
-import { WebpiecesServer } from './WebpiecesServer';
-/**
- * WebpiecesFactory - Factory for creating WebPieces server instances.
- *
- * This factory encapsulates the server creation and initialization logic:
- * 1. Creates the WebPieces DI container
- * 2. Loads the provider module for @provideSingleton decorators
- * 3. Resolves WebpiecesServerImpl from DI
- * 4. Calls initialize() with the container and meta
- * 5. Returns the server as the WebpiecesServer interface
- *
- * The returned WebpiecesServer interface only exposes start() and stop(),
- * hiding the internal initialize() method from consumers.
- *
- * Usage:
- * ```typescript
- * // Production
- * const config = new WebpiecesConfig();
- * const server = WebpiecesFactory.create(new ProdServerMeta(), config);
- * server.start(8080);
- *
- * // Testing with appOverrides
- * const appOverrides = new ContainerModule((bind) => {
- *     bind(TYPES.RemoteApi).toConstantValue(mockRemoteApi);
- * });
- * const server = WebpiecesFactory.create(new ProdServerMeta(), config, appOverrides);
- * const api = server.createApiClient(SaveApi);
- * ```
- *
- * This pattern:
- * - Enforces proper initialization order
- * - Hides implementation details from consumers
- * - Makes the API simpler and harder to misuse
- * - Follows the principle of least privilege
- */
-export declare class WebpiecesFactory {
-    /**
-     * Create a new WebPieces server instance.
-     *
-     * This method:
-     * 1. Creates the WebPieces framework DI container
-     * 2. Loads framework bindings via buildProviderModule()
-     * 3. Resolves the server implementation from DI
-     * 4. Initializes the server with the container and meta
-     * 5. Loads optional override module (for testing)
-     *
-     * @param meta - User-provided WebAppMeta with DI modules and routes
-     * @param appOverrides - Optional ContainerModule for test overrides (loaded LAST to override bindings)
-     * @returns A fully initialized WebpiecesServer ready to start()
-     */
-    /**
-     * Create a new WebPieces server instance asynchronously.
-     *
-     * Use this method when you need async operations in your override modules
-     * (e.g., rebind() in new Inversify versions).
-     *
-     * @param meta - User-provided WebAppMeta with DI modules and routes
-     * @param config - Server configuration (CORS, etc.)
-     * @param appOverrides - Optional ContainerModule for app test overrides (can use async operations)
-     * @param testMode - Optional flag for test mode (skips Express server)
-     * @returns Promise of a fully initialized WebpiecesServer ready to start()
-     */
-    static create(meta: WebAppMeta, config: WebpiecesConfig, appOverrides?: ContainerModule, testMode?: boolean): Promise<WebpiecesServer>;
-}

package/src/WebpiecesFactory.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpiecesFactory = void 0;
-const inversify_1 = require("inversify");
-const binding_decorators_1 = require("@inversifyjs/binding-decorators");
-const http_routing_1 = require("@webpieces/http-routing");
-const WebpiecesServerImpl_1 = require("./WebpiecesServerImpl");
-/**
- * WebpiecesFactory - Factory for creating WebPieces server instances.
- *
- * This factory encapsulates the server creation and initialization logic:
- * 1. Creates the WebPieces DI container
- * 2. Loads the provider module for @provideSingleton decorators
- * 3. Resolves WebpiecesServerImpl from DI
- * 4. Calls initialize() with the container and meta
- * 5. Returns the server as the WebpiecesServer interface
- *
- * The returned WebpiecesServer interface only exposes start() and stop(),
- * hiding the internal initialize() method from consumers.
- *
- * Usage:
- * ```typescript
- * // Production
- * const config = new WebpiecesConfig();
- * const server = WebpiecesFactory.create(new ProdServerMeta(), config);
- * server.start(8080);
- *
- * // Testing with appOverrides
- * const appOverrides = new ContainerModule((bind) => {
- *     bind(TYPES.RemoteApi).toConstantValue(mockRemoteApi);
- * });
- * const server = WebpiecesFactory.create(new ProdServerMeta(), config, appOverrides);
- * const api = server.createApiClient(SaveApi);
- * ```
- *
- * This pattern:
- * - Enforces proper initialization order
- * - Hides implementation details from consumers
- * - Makes the API simpler and harder to misuse
- * - Follows the principle of least privilege
- */
-class WebpiecesFactory {
-    /**
-     * Create a new WebPieces server instance.
-     *
-     * This method:
-     * 1. Creates the WebPieces framework DI container
-     * 2. Loads framework bindings via buildProviderModule()
-     * 3. Resolves the server implementation from DI
-     * 4. Initializes the server with the container and meta
-     * 5. Loads optional override module (for testing)
-     *
-     * @param meta - User-provided WebAppMeta with DI modules and routes
-     * @param appOverrides - Optional ContainerModule for test overrides (loaded LAST to override bindings)
-     * @returns A fully initialized WebpiecesServer ready to start()
-     */
-    /**
-     * Create a new WebPieces server instance asynchronously.
-     *
-     * Use this method when you need async operations in your override modules
-     * (e.g., rebind() in new Inversify versions).
-     *
-     * @param meta - User-provided WebAppMeta with DI modules and routes
-     * @param config - Server configuration (CORS, etc.)
-     * @param appOverrides - Optional ContainerModule for app test overrides (can use async operations)
-     * @param testMode - Optional flag for test mode (skips Express server)
-     * @returns Promise of a fully initialized WebpiecesServer ready to start()
-     */
-    static async create(meta, config, appOverrides, testMode) {
-        // Create WebPieces container for framework-level bindings
-        const webpiecesContainer = new inversify_1.Container();
-        // Bind WebAppMeta so it can be injected into framework classes
-        webpiecesContainer.bind(http_routing_1.WEBAPP_META_TOKEN).toConstantValue(meta);
-        // Bind WebpiecesConfig so it can be injected into framework classes
-        webpiecesContainer.bind(http_routing_1.WEBPIECES_CONFIG_TOKEN).toConstantValue(config);
-        // Load buildProviderModule to auto-scan for @provideSingleton decorators
-        await webpiecesContainer.load((0, binding_decorators_1.buildProviderModule)());
-        // Resolve WebpiecesServerImpl from DI container
-        const serverImpl = webpiecesContainer.get(WebpiecesServerImpl_1.WebpiecesServerImpl);
-        // Initialize the server asynchronously (loads app DI modules, registers routes)
-        await serverImpl.initialize(webpiecesContainer, appOverrides);
-        // Return as interface to hide initialize() from consumers
-        return serverImpl;
-    }
-}
-exports.WebpiecesFactory = WebpiecesFactory;
-//# sourceMappingURL=WebpiecesFactory.js.map

package/src/WebpiecesFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebpiecesFactory.js","sourceRoot":"","sources":["../../../../../packages/http/http-server/src/WebpiecesFactory.ts"],"names":[],"mappings":";;;AAAA,yCAAuD;AACvD,wEAAsE;AACtE,0DAAiH;AAEjH,+DAA4D;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAa,gBAAgB;IACzB;;;;;;;;;;;;;OAaG;IAEH;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,KAAK,CAAC,MAAM,CACf,IAAgB,EAChB,MAAuB,EACvB,YAA8B,EAC9B,QAAkB;QAElB,0DAA0D;QAC1D,MAAM,kBAAkB,GAAG,IAAI,qBAAS,EAAE,CAAC;QAE3C,+DAA+D;QAC/D,kBAAkB,CAAC,IAAI,CAAa,gCAAiB,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAE7E,oEAAoE;QACpE,kBAAkB,CAAC,IAAI,CAAkB,qCAAsB,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QAEzF,yEAAyE;QACzE,MAAM,kBAAkB,CAAC,IAAI,CAAC,IAAA,wCAAmB,GAAE,CAAC,CAAC;QAErD,gDAAgD;QAChD,MAAM,UAAU,GAAG,kBAAkB,CAAC,GAAG,CAAC,yCAAmB,CAAC,CAAC;QAE/D,gFAAgF;QAChF,MAAM,UAAU,CAAC,UAAU,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;QAE9D,0DAA0D;QAC1D,OAAO,UAAU,CAAC;IACtB,CAAC;CACJ;AAvDD,4CAuDC","sourcesContent":["import { Container, ContainerModule } from 'inversify';\nimport { buildProviderModule } from '@inversifyjs/binding-decorators';\nimport { WebAppMeta, WEBAPP_META_TOKEN, WebpiecesConfig, WEBPIECES_CONFIG_TOKEN } from '@webpieces/http-routing';\nimport { WebpiecesServer } from './WebpiecesServer';\nimport { WebpiecesServerImpl } from './WebpiecesServerImpl';\n\n/**\n * WebpiecesFactory - Factory for creating WebPieces server instances.\n *\n * This factory encapsulates the server creation and initialization logic:\n * 1. Creates the WebPieces DI container\n * 2. Loads the provider module for @provideSingleton decorators\n * 3. Resolves WebpiecesServerImpl from DI\n * 4. Calls initialize() with the container and meta\n * 5. Returns the server as the WebpiecesServer interface\n *\n * The returned WebpiecesServer interface only exposes start() and stop(),\n * hiding the internal initialize() method from consumers.\n *\n * Usage:\n * ```typescript\n * // Production\n * const config = new WebpiecesConfig();\n * const server = WebpiecesFactory.create(new ProdServerMeta(), config);\n * server.start(8080);\n *\n * // Testing with appOverrides\n * const appOverrides = new ContainerModule((bind) => {\n *     bind(TYPES.RemoteApi).toConstantValue(mockRemoteApi);\n * });\n * const server = WebpiecesFactory.create(new ProdServerMeta(), config, appOverrides);\n * const api = server.createApiClient(SaveApi);\n * ```\n *\n * This pattern:\n * - Enforces proper initialization order\n * - Hides implementation details from consumers\n * - Makes the API simpler and harder to misuse\n * - Follows the principle of least privilege\n */\nexport class WebpiecesFactory {\n    /**\n     * Create a new WebPieces server instance.\n     *\n     * This method:\n     * 1. Creates the WebPieces framework DI container\n     * 2. Loads framework bindings via buildProviderModule()\n     * 3. Resolves the server implementation from DI\n     * 4. Initializes the server with the container and meta\n     * 5. Loads optional override module (for testing)\n     *\n     * @param meta - User-provided WebAppMeta with DI modules and routes\n     * @param appOverrides - Optional ContainerModule for test overrides (loaded LAST to override bindings)\n     * @returns A fully initialized WebpiecesServer ready to start()\n     */\n\n    /**\n     * Create a new WebPieces server instance asynchronously.\n     *\n     * Use this method when you need async operations in your override modules\n     * (e.g., rebind() in new Inversify versions).\n     *\n     * @param meta - User-provided WebAppMeta with DI modules and routes\n     * @param config - Server configuration (CORS, etc.)\n     * @param appOverrides - Optional ContainerModule for app test overrides (can use async operations)\n     * @param testMode - Optional flag for test mode (skips Express server)\n     * @returns Promise of a fully initialized WebpiecesServer ready to start()\n     */\n    static async create(\n        meta: WebAppMeta,\n        config: WebpiecesConfig,\n        appOverrides?: ContainerModule,\n        testMode?: boolean\n    ): Promise<WebpiecesServer> {\n        // Create WebPieces container for framework-level bindings\n        const webpiecesContainer = new Container();\n\n        // Bind WebAppMeta so it can be injected into framework classes\n        webpiecesContainer.bind<WebAppMeta>(WEBAPP_META_TOKEN).toConstantValue(meta);\n\n        // Bind WebpiecesConfig so it can be injected into framework classes\n        webpiecesContainer.bind<WebpiecesConfig>(WEBPIECES_CONFIG_TOKEN).toConstantValue(config);\n\n        // Load buildProviderModule to auto-scan for @provideSingleton decorators\n        await webpiecesContainer.load(buildProviderModule());\n\n        // Resolve WebpiecesServerImpl from DI container\n        const serverImpl = webpiecesContainer.get(WebpiecesServerImpl);\n\n        // Initialize the server asynchronously (loads app DI modules, registers routes)\n        await serverImpl.initialize(webpiecesContainer, appOverrides);\n\n        // Return as interface to hide initialize() from consumers\n        return serverImpl;\n    }\n}\n"]}

package/src/WebpiecesServer.d.ts

@@ -1,71 +0,0 @@
-import { Container } from 'inversify';
-/**
- * WebpiecesServer - Public interface for WebPieces server.
- *
- * This interface exposes the methods needed by application code:
- * - start(): Start the HTTP server
- * - stop(): Stop the HTTP server
- * - createApiClient(): Create API client proxy for testing (no HTTP!)
- * - getContainer(): Access DI container for verification
- *
- * The initialization logic is hidden inside WebpiecesFactory.create().
- * This provides a clean API and prevents accidental re-initialization.
- *
- * Usage:
- * ```typescript
- * // Production
- * const server = WebpiecesFactory.create(new ProdServerMeta());
- * await server.start(8080);
- *
- * // Testing (no HTTP needed!)
- * const server = WebpiecesFactory.create(new ProdServerMeta(), overrides);
- * const api = server.createApiClient(SaveApi);
- * const response = await api.save(request);
- * ```
- */
-export interface WebpiecesServer {
-    /**
-     * Start the HTTP server with Express.
-     * Returns a Promise that resolves when the server is listening,
-     * or rejects if the server fails to start.
-     *
-     * @param port - The port to listen on (default: 8080)
-     * @returns Promise that resolves when server is ready
-     */
-    start(port?: number): Promise<void>;
-    /**
-     * Stop the HTTP server.
-     * Returns a Promise that resolves when the server is stopped,
-     * or rejects if there's an error stopping the server.
-     *
-     * @returns Promise that resolves when server is stopped
-     */
-    stop(): Promise<void>;
-    /**
-     * Create an API client proxy for testing.
-     *
-     * This creates a client that routes calls through the full filter chain
-     * and controller, but WITHOUT any HTTP overhead. Perfect for testing!
-     *
-     * The client uses the ApiPrototype class to discover routes via decorators,
-     * then invokes the corresponding controller method through the filter chain.
-     *
-     * @param apiPrototype - The API prototype class with routing decorators (can be abstract)
-     * @returns A proxy that implements the API interface
-     *
-     * Example:
-     * ```typescript
-     * const saveApi = server.createApiClient<SaveApi>(SaveApi);
-     * const response = await saveApi.save(request);
-     * ```
-     */
-    createApiClient<T>(apiPrototype: abstract new (...args: any[]) => T): T;
-    /**
-     * Get the application DI container.
-     *
-     * Useful for testing to verify state or access services directly.
-     *
-     * @returns The application Container
-     */
-    getContainer(): Container;
-}

package/src/WebpiecesServer.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=WebpiecesServer.js.map

package/src/WebpiecesServer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebpiecesServer.js","sourceRoot":"","sources":["../../../../../packages/http/http-server/src/WebpiecesServer.ts"],"names":[],"mappings":"","sourcesContent":["import { Container } from 'inversify';\n\n/**\n * WebpiecesServer - Public interface for WebPieces server.\n *\n * This interface exposes the methods needed by application code:\n * - start(): Start the HTTP server\n * - stop(): Stop the HTTP server\n * - createApiClient(): Create API client proxy for testing (no HTTP!)\n * - getContainer(): Access DI container for verification\n *\n * The initialization logic is hidden inside WebpiecesFactory.create().\n * This provides a clean API and prevents accidental re-initialization.\n *\n * Usage:\n * ```typescript\n * // Production\n * const server = WebpiecesFactory.create(new ProdServerMeta());\n * await server.start(8080);\n *\n * // Testing (no HTTP needed!)\n * const server = WebpiecesFactory.create(new ProdServerMeta(), overrides);\n * const api = server.createApiClient(SaveApi);\n * const response = await api.save(request);\n * ```\n */\nexport interface WebpiecesServer {\n    /**\n     * Start the HTTP server with Express.\n     * Returns a Promise that resolves when the server is listening,\n     * or rejects if the server fails to start.\n     *\n     * @param port - The port to listen on (default: 8080)\n     * @returns Promise that resolves when server is ready\n     */\n    start(port?: number): Promise<void>;\n\n    /**\n     * Stop the HTTP server.\n     * Returns a Promise that resolves when the server is stopped,\n     * or rejects if there's an error stopping the server.\n     *\n     * @returns Promise that resolves when server is stopped\n     */\n    stop(): Promise<void>;\n\n    /**\n     * Create an API client proxy for testing.\n     *\n     * This creates a client that routes calls through the full filter chain\n     * and controller, but WITHOUT any HTTP overhead. Perfect for testing!\n     *\n     * The client uses the ApiPrototype class to discover routes via decorators,\n     * then invokes the corresponding controller method through the filter chain.\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 = server.createApiClient<SaveApi>(SaveApi);\n     * const response = await saveApi.save(request);\n     * ```\n     */\n    createApiClient<T>(apiPrototype: abstract new (...args: any[]) => T): T;\n\n    /**\n     * Get the application DI container.\n     *\n     * Useful for testing to verify state or access services directly.\n     *\n     * @returns The application Container\n     */\n    getContainer(): Container;\n}\n"]}

package/src/WebpiecesServerImpl.d.ts

@@ -1,103 +0,0 @@
-import { Container, ContainerModule } from 'inversify';
-import { RouteBuilderImpl, WebAppMeta } from '@webpieces/http-routing';
-import { WebpiecesServer } from './WebpiecesServer';
-import { WebpiecesMiddleware } from './WebpiecesMiddleware';
-export declare class WebpiecesServerImpl implements WebpiecesServer {
-    private meta;
-    private routeBuilder;
-    private middleware;
-    private webpiecesContainer;
-    /**
-     * Application container: User's application bindings.
-     * This is a child container of webpiecesContainer, so it can access
-     * framework bindings while keeping app bindings separate.
-     */
-    private appContainer;
-    private initialized;
-    private app?;
-    private server?;
-    private port;
-    constructor(meta: WebAppMeta, routeBuilder: RouteBuilderImpl, middleware: WebpiecesMiddleware);
-    /**
-     * Initialize the server asynchronously.
-     * This is called by WebpiecesFactory.create() after resolving this class from DI.
-     * This method is internal and not exposed on the WebpiecesServer interface.
-     *
-     * @param webpiecesContainer - The framework container
-     * @param meta - User-provided WebAppMeta with DI modules and routes
-     * @param appOverrides - Optional ContainerModule for app test overrides (loaded LAST)
-     */
-    initialize(webpiecesContainer: Container, appOverrides?: ContainerModule): Promise<void>;
-    /**
-     * Load DI modules from WebAppMeta.
-     *
-     * Currently, all user modules are loaded into the application container.
-     * In the future, we could separate:
-     * - WebPieces framework modules -> webpiecesContainer
-     * - Application modules -> appContainer
-     *
-     * For now, everything goes into appContainer which has access to webpiecesContainer.
-     *
-     * @param appOverrides - Optional ContainerModule for app test overrides (loaded LAST to override bindings)
-     */
-    private loadDIModules;
-    /**
-     * Register routes from WebAppMeta.
-     *
-     * Creates an explicit RouteBuilderImpl instead of an anonymous object.
-     * This improves:
-     * - Traceability: Can Cmd+Click on addRoute to see implementation
-     * - Debugging: Explicit class shows up in stack traces
-     * - Understanding: Clear class name vs anonymous object
-     */
-    private registerRoutes;
-    /**
-     * Start the HTTP server with Express.
-     * Returns a Promise that resolves when the server is listening,
-     * or rejects if the server fails to start.
-     *
-     * @param port - The port to listen on (default: 8080)
-     * @returns Promise that resolves when server is ready
-     */
-    start(port?: number, testMode?: boolean): Promise<void>;
-    /**
-     * Stop the HTTP server.
-     * Returns a Promise that resolves when the server is stopped,
-     * or rejects if there's an error stopping the server.
-     *
-     * @returns Promise that resolves when server is stopped
-     */
-    stop(): Promise<void>;
-    /**
-     * Get the application DI container.
-     *
-     * Useful for testing to verify state or access services directly.
-     *
-     * @returns The application Container
-     */
-    getContainer(): Container;
-    /**
-     * Create an API client proxy for testing.
-     *
-     * This creates a client that routes calls through the full filter chain
-     * and controller, but WITHOUT any HTTP overhead. Perfect for testing!
-     *
-     * 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!).
-     *
-     * @param apiPrototype - The abstract API prototype whose routing decorators declare the routes
-     * @returns A proxy that implements the API interface
-     *
-     * Example:
-     * ```typescript
-     * const saveApi = server.createApiClient<SaveApi>(SaveApi);
-     * const response = await saveApi.save(request);
-     * ```
-     */
-    createApiClient<T>(apiPrototype: abstract new (...args: any[]) => T): T;
-    private clientFactory?;
-}