@congruent-stack/congruent-api 0.7.0 → 0.10.0

package/dist/index.cjs

@@ -19,6 +19,11 @@ class HttpMethodEndpoint {
     }
     return this._cachedGenericPath;
   }
+  createPath(pathParams) {
+    return `/${this.pathSegments.map(
+      (segment) => segment.startsWith(":") ? pathParams[segment.slice(1)] ?? "?" : segment
+    ).join("/")}`;
+  }
   _method = null;
   get method() {
     return this._method;
@@ -112,6 +117,7 @@ var HttpStatusCode = /* @__PURE__ */ ((HttpStatusCode2) => {
   HttpStatusCode2[HttpStatusCode2["Forbidden_403"] = 403] = "Forbidden_403";
   HttpStatusCode2[HttpStatusCode2["NotFound_404"] = 404] = "NotFound_404";
   HttpStatusCode2[HttpStatusCode2["Conflict_409"] = 409] = "Conflict_409";
+  HttpStatusCode2[HttpStatusCode2["UnprocessableEntity_422"] = 422] = "UnprocessableEntity_422";
   HttpStatusCode2[HttpStatusCode2["InternalServerError_500"] = 500] = "InternalServerError_500";
   HttpStatusCode2[HttpStatusCode2["NotImplemented_501"] = 501] = "NotImplemented_501";
   HttpStatusCode2[HttpStatusCode2["BadGateway_502"] = 502] = "BadGateway_502";
@@ -140,6 +146,9 @@ class MethodEndpointHandlerRegistryEntry {
     this._methodEndpoint = methodEndpoint;
     this._dicontainer = dicontainer;
   }
+  get genericPath() {
+    return this._methodEndpoint.genericPath;
+  }
   _handler = null;
   get handler() {
     return this._handler;
@@ -149,6 +158,7 @@ class MethodEndpointHandlerRegistryEntry {
     if (this._onHandlerRegisteredCallback) {
       this._onHandlerRegisteredCallback(this);
     }
+    return this;
   }
   _onHandlerRegisteredCallback = null;
   _onHandlerRegistered(callback) {
@@ -158,7 +168,7 @@ class MethodEndpointHandlerRegistryEntry {
     callback(this);
     return this;
   }
-  _injection = (_dicontainer) => ({});
+  _injection = (_diScope) => ({});
   get injection() {
     return this._injection;
   }
@@ -166,61 +176,152 @@ class MethodEndpointHandlerRegistryEntry {
     this._injection = injection;
     return this;
   }
-  async trigger(data) {
+  _decoratorFactories = [];
+  get decoratorFactories() {
+    return this._decoratorFactories;
+  }
+  /**
+   * 
+   * @param decoratorFactory must be a function that takes exactly the DI scope type and returns an instance of a class that implements IEndpointHandlerDecorator
+   * @returns this
+   * 
+   * Initially, the method was defined as:
+   * ```ts
+   * decorate<
+   *   TDecoratorSchemas extends IDecoratorHandlerSchemas, 
+   *   TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>
+   * > (
+   *   decoratorFactory: IEndpointHandlerDecoratorFactory<TDecoratorSchemas, TDIContainer, TDecorator>
+   * ): this {
+   *   this._decoratorFactories.push(decoratorFactory);
+   *   return this;
+   * }
+   * ```
+   * 
+   * and the type IEndpointHandlerDecoratorFactory was defined as:
+   * ```ts
+   * type IEndpointHandlerDecoratorFactory<
+   *   TDecoratorSchemas extends IDecoratorHandlerSchemas, 
+   *   TDIContainer extends DIContainer, 
+   *   TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>
+   * > = (diScope: ReturnType<TDIContainer['createScope']>) => TDecorator;
+   * ```
+   * 
+   * However, TypeScript was incorrectly inferring the types when using the 'decorate' method. 
+   * The end developer would have had to explicitly provide the generic types, which is not ideal.
+   * 
+   * With the current definition, TypeScript can infer the types from the decoratorFactory parameter, 
+   * making it easier to use.
+   */
+  decorate(decoratorFactory, decoratingArgs) {
+    this._decoratorFactories.push((scope) => decoratorFactory(scope, decoratingArgs));
+    return this;
+  }
+  decorateWith(decoratorStaticMethodFactory, decoratingArgs) {
+    this._decoratorFactories.push((scope) => decoratorStaticMethodFactory.create(scope, decoratingArgs));
+    return this;
+  }
+  async trigger(diScope, requestObject) {
+    return this.triggerNoStaticTypeCheck(diScope, requestObject, { originalRequest: requestObject });
+  }
+  async exec(injected, requestObject) {
     if (!this._handler) {
       throw new Error("Handler not set for this endpoint");
     }
     let badRequestResponse = null;
-    const headers = parseRequestDefinitionField(this._methodEndpoint.definition, "headers", data);
+    const headers = parseRequestDefinitionField(this._methodEndpoint.definition, "headers", requestObject);
     if (isHttpResponseObject(headers)) {
       badRequestResponse = headers;
       return badRequestResponse;
     }
-    const query = parseRequestDefinitionField(this._methodEndpoint.definition, "query", data);
+    const query = parseRequestDefinitionField(this._methodEndpoint.definition, "query", requestObject);
     if (isHttpResponseObject(query)) {
       badRequestResponse = query;
       return badRequestResponse;
     }
-    const body = parseRequestDefinitionField(this._methodEndpoint.definition, "body", data);
+    const body = parseRequestDefinitionField(this._methodEndpoint.definition, "body", requestObject);
     if (isHttpResponseObject(body)) {
       badRequestResponse = body;
       return badRequestResponse;
     }
-    const path = `/${this._methodEndpoint.pathSegments.map(
-      (segment) => segment.startsWith(":") ? data.pathParams[segment.slice(1)] ?? "?" : segment
-    ).join("/")}`;
+    const path = this._methodEndpoint.createPath(requestObject.pathParams);
     return await this._handler({
       method: this._methodEndpoint.method,
       path,
       genericPath: this._methodEndpoint.genericPath,
       pathSegments: this._methodEndpoint.pathSegments,
       headers,
-      pathParams: data.pathParams,
+      pathParams: requestObject.pathParams,
       query,
-      body,
-      injected: this._injection(this._dicontainer.createScope())
-    });
+      body
+    }, injected);
+  }
+  async triggerNoStaticTypeCheck(diScope, requestObject, context) {
+    if (!this._handler) {
+      throw new Error("Handler not set for this endpoint");
+    }
+    let badRequestResponse = null;
+    const headers = parseRequestDefinitionField(this._methodEndpoint.definition, "headers", requestObject);
+    if (isHttpResponseObject(headers)) {
+      badRequestResponse = headers;
+      return badRequestResponse;
+    }
+    const query = parseRequestDefinitionField(this._methodEndpoint.definition, "query", requestObject);
+    if (isHttpResponseObject(query)) {
+      badRequestResponse = query;
+      return badRequestResponse;
+    }
+    const body = parseRequestDefinitionField(this._methodEndpoint.definition, "body", requestObject);
+    if (isHttpResponseObject(body)) {
+      badRequestResponse = body;
+      return badRequestResponse;
+    }
+    const path = this._methodEndpoint.createPath(requestObject.pathParams);
+    Object.assign(context, this._injection(diScope));
+    return await this._handler({
+      method: this._methodEndpoint.method,
+      path,
+      genericPath: this._methodEndpoint.genericPath,
+      pathSegments: this._methodEndpoint.pathSegments,
+      headers,
+      pathParams: requestObject.pathParams,
+      query,
+      body
+    }, context);
   }
 }
-function parseRequestDefinitionField(definition, key, data) {
+function parseRequestDefinitionField(definition, key, requestObject) {
   if (definition[key]) {
-    if (!(key in data) || data[key] === null || data[key] === void 0) {
-      if (!definition[key].safeParse(data[key]).success) {
+    if (!(key in requestObject) || requestObject[key] === null || requestObject[key] === void 0) {
+      const result2 = definition[key].safeParse(requestObject[key]);
+      if (!result2.success) {
+        switch (definition[key].type) {
+          case "optional":
+            if (requestObject[key] === null) {
+              return void 0;
+            }
+            break;
+          case "nullable":
+            if (requestObject[key] === void 0) {
+              return null;
+            }
+            break;
+        }
         return {
           code: HttpStatusCode.BadRequest_400,
           body: `'${key}' is required for this endpoint` + (key === "body" ? ", { 'Content-Type': 'application/json' } header might be missing" : "")
         };
       }
-      return null;
+      return result2.data;
     }
-    const result = definition[key].safeParse(data[key]);
+    const result = definition[key].safeParse(requestObject[key]);
     if (!result.success) {
       return {
         code: HttpStatusCode.BadRequest_400,
         body: result.error.issues
       };
     }
-    return result.data ?? null;
+    return result.data;
   }
   return null;
 }
@@ -235,11 +336,33 @@ function middleware(apiReg, path) {
 }
 class MiddlewareHandlersRegistryEntryInternal {
   _dicontainer;
+  get dicontainer() {
+    return this._dicontainer;
+  }
   _middlewareGenericPath;
   get genericPath() {
     return this._middlewareGenericPath;
   }
-  _splitMiddlewarePath() {
+  _middlewarePathSegments;
+  get pathSegments() {
+    return this._middlewarePathSegments;
+  }
+  _middlewareMethod;
+  get method() {
+    return this._middlewareMethod;
+  }
+  _middlewareSchemas;
+  get middlewareSchemas() {
+    return this._middlewareSchemas;
+  }
+  _handler;
+  constructor(diContainer, middlewarePath, middlewareSchemas, decoratorFactories, injection, handler) {
+    this._dicontainer = diContainer;
+    this._middlewareGenericPath = middlewarePath;
+    this._middlewareSchemas = middlewareSchemas;
+    this._decoratorFactories.push(...decoratorFactories);
+    this._injection = injection;
+    this._handler = handler;
     const splitResult = this._middlewareGenericPath.split(" ");
     let method = "";
     let pathSegments = [];
@@ -250,54 +373,56 @@ class MiddlewareHandlersRegistryEntryInternal {
       }
       pathSegments = splitResult[1].split("/").map((segment) => segment.trim()).filter((segment) => segment !== "");
     }
-    return {
-      method,
-      pathSegments
-    };
+    this._middlewareMethod = method;
+    this._middlewarePathSegments = pathSegments;
   }
-  _inputSchemas;
-  _handler;
-  constructor(diContainer, middlewarePath, inputSchemas, injection, handler) {
-    this._dicontainer = diContainer;
-    this._middlewareGenericPath = middlewarePath;
-    this._inputSchemas = inputSchemas;
-    this._injection = injection;
-    this._handler = handler;
+  _decoratorFactories = [];
+  get decoratorFactories() {
+    return this._decoratorFactories;
   }
   _injection = (_dicontainer) => ({});
-  async trigger(data, next) {
+  async trigger(diScope, requestObject, context) {
+    return this.triggerNoStaticTypeCheck(diScope, requestObject, context);
+  }
+  async triggerNoStaticTypeCheck(diScope, requestObject, context) {
     let badRequestResponse = null;
-    const headers = middlewareParseRequestDefinitionField(this._inputSchemas, "headers", data);
+    const headers = middlewareParseRequestDefinitionField(this._middlewareSchemas, "headers", requestObject);
     if (isHttpResponseObject(headers)) {
       badRequestResponse = headers;
       return badRequestResponse;
     }
-    const query = middlewareParseRequestDefinitionField(this._inputSchemas, "query", data);
+    const query = middlewareParseRequestDefinitionField(this._middlewareSchemas, "query", requestObject);
     if (isHttpResponseObject(query)) {
       badRequestResponse = query;
       return badRequestResponse;
     }
-    const body = middlewareParseRequestDefinitionField(this._inputSchemas, "body", data);
+    const body = middlewareParseRequestDefinitionField(this._middlewareSchemas, "body", requestObject);
     if (isHttpResponseObject(body)) {
       badRequestResponse = body;
       return badRequestResponse;
     }
-    const { method, pathSegments } = this._splitMiddlewarePath();
-    const path = `/${pathSegments.map(
-      (segment) => segment.startsWith(":") ? data.pathParams[segment.slice(1)] ?? "?" : segment
+    const path = this.createPath(requestObject.pathParams);
+    Object.assign(context, this._injection(diScope));
+    return await this._handler(
+      {
+        method: this.method,
+        // TODO: might be empty, as middleware can be registered with path only, without method
+        path,
+        genericPath: this.genericPath,
+        pathSegments: this.pathSegments,
+        headers,
+        pathParams: requestObject.pathParams,
+        query,
+        body
+      },
+      context
+    );
+  }
+  createPath(pathParams) {
+    const path = `/${this.pathSegments.map(
+      (segment) => segment.startsWith(":") ? pathParams[segment.slice(1)] ?? "?" : segment
     ).join("/")}`;
-    return await this._handler({
-      method,
-      // TODO: might be empty, as middleware can be registered with path only, without method, possible fix: take it from express.request.method
-      path,
-      genericPath: this.genericPath,
-      pathSegments,
-      headers,
-      pathParams: data.pathParams,
-      query,
-      body,
-      injected: this._injection(this._dicontainer.createScope())
-    }, next);
+    return path;
   }
 }
 class MiddlewareHandlersRegistryEntry {
@@ -307,7 +432,7 @@ class MiddlewareHandlersRegistryEntry {
     this._registry = registry;
     this._path = path;
   }
-  _injection = (_dicontainer) => ({});
+  _injection = (_diScope) => ({});
   get injection() {
     return this._injection;
   }
@@ -315,16 +440,62 @@ class MiddlewareHandlersRegistryEntry {
     this._injection = injection;
     return this;
   }
-  register(inputSchemas, handler) {
+  register(middlewareSchemas, handler) {
     const internalEntry = new MiddlewareHandlersRegistryEntryInternal(
       this._registry.dicontainer,
       this._path,
-      inputSchemas,
+      middlewareSchemas,
+      this._decoratorFactories,
       this._injection,
       handler
     );
     this._registry.register(internalEntry);
   }
+  _decoratorFactories = [];
+  get decoratorFactories() {
+    return this._decoratorFactories;
+  }
+  /**
+   * 
+   * @param decoratorFactory must be a function that takes exactly the DI scope type and returns an instance of a class that implements IEndpointHandlerDecorator
+   * @returns this
+   * 
+   * Initially, the method was defined as:
+   * ```ts
+   * decorate<
+   *   TDecoratorSchemas extends IDecoratorHandlerSchemas, 
+   *   TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>
+   * > (
+   *   decoratorFactory: IEndpointHandlerDecoratorFactory<TDecoratorSchemas, TDIContainer, TDecorator>
+   * ): this {
+   *   this._decoratorFactories.push(decoratorFactory);
+   *   return this;
+   * }
+   * ```
+   * 
+   * and the type IEndpointHandlerDecoratorFactory was defined as:
+   * ```ts
+   * type IEndpointHandlerDecoratorFactory<
+   *   TDecoratorSchemas extends IDecoratorHandlerSchemas, 
+   *   TDIContainer extends DIContainer, 
+   *   TDecorator extends IEndpointHandlerDecorator<TDecoratorSchemas>
+   * > = (diScope: ReturnType<TDIContainer['createScope']>) => TDecorator;
+   * ```
+   * 
+   * However, TypeScript was incorrectly inferring the types when using the 'decorate' method. 
+   * The end developer would have had to explicitly provide the generic types, which is not ideal.
+   * 
+   * With the current definition, TypeScript can infer the types from the decoratorFactory parameter, 
+   * making it easier to use.
+   */
+  decorate(decoratorFactory) {
+    this._decoratorFactories.push(decoratorFactory);
+    return this;
+  }
+  decorateWith(decoratorStaticMethodFactory) {
+    this._decoratorFactories.push(decoratorStaticMethodFactory.create);
+    return this;
+  }
 }
 class MiddlewareHandlersRegistry {
   dicontainer;
@@ -332,8 +503,13 @@ class MiddlewareHandlersRegistry {
     this.dicontainer = dicontainer;
     this._onHandlerRegisteredCallback = callback;
   }
+  _list = [];
+  get list() {
+    return this._list;
+  }
   register(entry) {
     if (this._onHandlerRegisteredCallback) {
+      this._list.push(entry);
       this._onHandlerRegisteredCallback(entry);
     }
   }
@@ -342,25 +518,38 @@ class MiddlewareHandlersRegistry {
     this._onHandlerRegisteredCallback = callback;
   }
 }
-function middlewareParseRequestDefinitionField(inputSchemas, key, data) {
-  if (inputSchemas[key]) {
-    if (!(key in data) || data[key] === null || data[key] === void 0) {
-      if (!inputSchemas[key].safeParse(data[key]).success) {
+function middlewareParseRequestDefinitionField(middlewareSchemas, key, requestObject) {
+  if (middlewareSchemas[key]) {
+    if (!(key in requestObject) || requestObject[key] === null || requestObject[key] === void 0) {
+      const result2 = middlewareSchemas[key].safeParse(requestObject[key]);
+      if (!result2.success) {
+        switch (middlewareSchemas[key].type) {
+          case "optional":
+            if (requestObject[key] === null) {
+              return void 0;
+            }
+            break;
+          case "nullable":
+            if (requestObject[key] === void 0) {
+              return null;
+            }
+            break;
+        }
         return {
           code: HttpStatusCode.BadRequest_400,
           body: `'${key}' is required for this endpoint` + (key === "body" ? ", { 'Content-Type': 'application/json' } header might be missing" : "")
         };
       }
-      return null;
+      return result2.data;
     }
-    const result = inputSchemas[key].safeParse(data[key]);
+    const result = middlewareSchemas[key].safeParse(requestObject[key]);
     if (!result.success) {
       return {
         code: HttpStatusCode.BadRequest_400,
         body: result.error.issues
       };
     }
-    return result.data ?? null;
+    return result.data;
   }
   return null;
 }
@@ -484,6 +673,41 @@ function registerEntryHandler(endpointEntry, handler) {
   endpointEntry.register(handler);
 }
 
+async function execHandlerChain(diScope, allHandlerEntries, input) {
+  const queue = [...allHandlerEntries];
+  let response = void 0;
+  const next = async () => {
+    if (response) {
+      return;
+    }
+    const current = queue.shift();
+    if (!current) {
+      return;
+    }
+    if (!input.genericPath.startsWith(current.genericPath)) {
+      await next();
+      return;
+    }
+    const currResponse = await current.triggerNoStaticTypeCheck(
+      diScope,
+      input,
+      {
+        next
+      }
+    );
+    if (response) {
+      return;
+    }
+    if (currResponse) {
+      response = currResponse;
+      return;
+    }
+    await next();
+  };
+  await next();
+  return response;
+}
+
 function partialPathString(_apiReg, path) {
   return path;
 }
@@ -528,12 +752,12 @@ class InnerApiClient {
         delete currObj[key];
         InnerApiClient._initialize(client, val, clientGenericHandler);
       } else if (val instanceof HttpMethodEndpoint) {
-        currObj[key] = (req) => {
+        currObj[key] = (requestObject) => {
           const pathParams = { ...client.__CONTEXT__.pathParameters };
           client.__CONTEXT__ = InnerApiClient._initNewContext();
-          const headers = clientParseRequestDefinitionField(val.definition, "headers", req);
-          const query = clientParseRequestDefinitionField(val.definition, "query", req);
-          const body = clientParseRequestDefinitionField(val.definition, "body", req);
+          const headers = clientParseRequestDefinitionField(val.definition, "headers", requestObject);
+          const query = clientParseRequestDefinitionField(val.definition, "query", requestObject);
+          const body = clientParseRequestDefinitionField(val.definition, "body", requestObject);
           const path = `/${val.pathSegments.map(
             (segment) => segment.startsWith(":") ? pathParams[segment.slice(1)] ?? "?" : segment
           ).join("/")}`;
@@ -555,138 +779,304 @@ class InnerApiClient {
   }
 }
 const ApiClient = InnerApiClient;
-function clientParseRequestDefinitionField(definition, key, data) {
+function clientParseRequestDefinitionField(definition, key, requestObject) {
   if (definition[key]) {
-    if (!(key in data) || data[key] === null || data[key] === void 0) {
-      if (!definition[key].safeParse(data[key]).success) {
-        throw new Error(`${key} are required for this endpoint`);
+    if (!(key in requestObject) || requestObject[key] === null || requestObject[key] === void 0) {
+      const result2 = definition[key].safeParse(requestObject[key]);
+      if (!result2.success) {
+        switch (definition[key].type) {
+          case "optional":
+            if (requestObject[key] === null) {
+              return void 0;
+            }
+            break;
+          case "nullable":
+            if (requestObject[key] === void 0) {
+              return null;
+            }
+            break;
+        }
+        throw new Error(`'${key}' is required for this endpoint`);
       }
-      return null;
+      return result2.data;
     }
-    const result = definition[key].safeParse(data[key]);
+    const result = definition[key].safeParse(requestObject[key]);
     if (!result.success) {
       throw new Error(`Validation for '${key}' failed`, { cause: result.error });
     }
-    return result.data ?? null;
+    return result.data;
   }
   return null;
 }
 
-class DIContainer {
-  registry = /* @__PURE__ */ new Map();
-  singletons = /* @__PURE__ */ new Map();
-  proxy;
-  /**
-   * The constructor returns a Proxy. This is the runtime magic that intercepts
-   * calls to methods like `getLoggerService()`. It parses the method name,
-   * finds the corresponding service class in the registry, and resolves it.
-   */
-  constructor() {
-    this.proxy = new Proxy(this, {
-      get: (target, prop, receiver) => {
-        if (typeof prop === "string" && prop.startsWith("get")) {
-          const serviceName = prop.substring(3);
-          if (target.registry.has(serviceName)) {
-            return () => target.resolveByName(serviceName);
+class DIContainerBase {
+  _map = /* @__PURE__ */ new Map();
+  _singletonInstances = /* @__PURE__ */ new Map();
+  createScope() {
+    const proxy = new Proxy({
+      _map: this._map,
+      _singletonInstances: this._singletonInstances,
+      _scopedInstances: /* @__PURE__ */ new Map(),
+      _isBuildingSingleton: false
+    }, {
+      get: (target, prop) => {
+        if (prop.startsWith("get")) {
+          const serviceName = prop.slice(3);
+          if (target._map.has(serviceName)) {
+            const entry = target._map.get(serviceName);
+            switch (entry.lifetime) {
+              case "transient":
+                return () => {
+                  if (target._isBuildingSingleton) {
+                    throw new Error(`Cannot resolve transient service '${serviceName}' while building a singleton`);
+                  }
+                  return entry.factory(proxy);
+                };
+              case "scoped":
+                return () => {
+                  if (target._isBuildingSingleton) {
+                    throw new Error(`Cannot resolve scoped service '${serviceName}' while building a singleton`);
+                  }
+                  if (!target._scopedInstances.has(serviceName)) {
+                    const instance = entry.factory(proxy);
+                    target._scopedInstances.set(serviceName, instance);
+                  }
+                  return target._scopedInstances.get(serviceName);
+                };
+              case "singleton":
+                return () => {
+                  if (!target._singletonInstances.has(serviceName)) {
+                    target._isBuildingSingleton = true;
+                    try {
+                      const instance = entry.factory(proxy);
+                      target._singletonInstances.set(serviceName, instance);
+                    } finally {
+                      target._isBuildingSingleton = false;
+                    }
+                  }
+                  return target._singletonInstances.get(serviceName);
+                };
+              default:
+                throw new Error(`Unsupported lifetime: ${entry.lifetime}`);
+            }
           } else {
             throw new Error(`Service not registered: ${serviceName}`);
           }
         }
-        return Reflect.get(target, prop, receiver);
+        throw new Error(`Property access denied by Proxy: ${String(prop)}`);
       }
     });
-    return this.proxy;
+    return proxy;
   }
-  /**
-   * Registers a service with explicit service name (fully type-safe).
-   */
-  register(serviceNameLiteral, factory, lifetime = "transient") {
-    this.registry.set(serviceNameLiteral, { factory, lifetime });
+}
+class DIContainer extends DIContainerBase {
+  register(serviceNameCapitalizedLiteral, factory, lifetime) {
+    const entry = { factory, lifetime };
+    this._map.set(serviceNameCapitalizedLiteral, entry);
     return this;
   }
-  /**
-   * Resolves a service by service name.
-   */
-  resolveByName(serviceName) {
-    const registration = this.registry.get(serviceName);
+  createTestClone() {
+    return new DIContainerTestClone(this);
+  }
+}
+class DIContainerTestClone extends DIContainerBase {
+  constructor(original) {
+    super();
+    original["_map"].forEach((value, key) => {
+      this._map.set(key, {
+        factory: (_scope) => {
+          throw new Error(`Service registration not overridden: ${key}`);
+        },
+        lifetime: value.lifetime
+      });
+    });
+  }
+  override(serviceNameLiteral, factory) {
+    const registration = this._map.get(serviceNameLiteral);
     if (!registration) {
-      throw new Error(`Service not registered: ${serviceName}`);
+      throw new Error(`Service not registered: ${serviceNameLiteral}`);
     }
-    if (registration.lifetime === "singleton") {
-      if (!this.singletons.has(serviceName)) {
-        const instance = registration.factory(this.proxy);
-        this.singletons.set(serviceName, instance);
-      }
-      return this.singletons.get(serviceName);
-    }
-    return registration.factory(this.proxy);
+    this._map.set(serviceNameLiteral, { factory, lifetime: registration.lifetime });
+    return this;
   }
-  /**
-   * Creates a scoped container with typed method access to services.
-   */
-  createScope() {
-    const scope = {};
-    return new Proxy(scope, {
-      get: (target, prop) => {
-        if (typeof prop === "string" && prop.startsWith("get")) {
-          const serviceName = prop.substring(3);
-          if (this.registry.has(serviceName)) {
-            const registration = this.registry.get(serviceName);
-            return () => {
-              if (registration?.lifetime === "transient") {
-                return this.resolveByName(serviceName);
-              }
-              const cacheKey = `_cached_${serviceName}`;
-              if (!target[cacheKey]) {
-                target[cacheKey] = this.resolveByName(serviceName);
-              }
-              return target[cacheKey];
-            };
-          } else {
-            throw new Error(`Service not registered: ${serviceName}`);
-          }
+}
+
+async function triggerEndpointDecoratorNoStaticTypeCheck(endpoint, decorator, requestObject, context) {
+  let badRequestResponse = null;
+  const headers = decoratorParseRequestDefinitionField(endpoint.definition, "headers", requestObject);
+  if (isHttpResponseObject(headers)) {
+    badRequestResponse = headers;
+    return badRequestResponse;
+  }
+  const query = decoratorParseRequestDefinitionField(endpoint.definition, "query", requestObject);
+  if (isHttpResponseObject(query)) {
+    badRequestResponse = query;
+    return badRequestResponse;
+  }
+  const body = decoratorParseRequestDefinitionField(endpoint.definition, "body", requestObject);
+  if (isHttpResponseObject(body)) {
+    badRequestResponse = body;
+    return badRequestResponse;
+  }
+  const path = endpoint.createPath(requestObject.pathParams);
+  return decorator.handle({
+    ...requestObject,
+    method: endpoint.method,
+    genericPath: endpoint.genericPath,
+    path,
+    pathSegments: endpoint.pathSegments
+  }, context);
+}
+async function triggerMiddlewareDecoratorNoStaticTypeCheck(middlewareEntry, decorator, requestObject, context) {
+  let badRequestResponse = null;
+  const headers = decoratorParseRequestDefinitionField(middlewareEntry.middlewareSchemas, "headers", requestObject);
+  if (isHttpResponseObject(headers)) {
+    badRequestResponse = headers;
+    return badRequestResponse;
+  }
+  const query = decoratorParseRequestDefinitionField(middlewareEntry.middlewareSchemas, "query", requestObject);
+  if (isHttpResponseObject(query)) {
+    badRequestResponse = query;
+    return badRequestResponse;
+  }
+  const body = decoratorParseRequestDefinitionField(middlewareEntry.middlewareSchemas, "body", requestObject);
+  if (isHttpResponseObject(body)) {
+    badRequestResponse = body;
+    return badRequestResponse;
+  }
+  const path = middlewareEntry.createPath(requestObject.pathParams);
+  return decorator.handle({
+    ...requestObject,
+    method: middlewareEntry.method,
+    // TODO: might be empty, as middleware can be registered with path only, without method
+    genericPath: middlewareEntry.genericPath,
+    path,
+    pathSegments: middlewareEntry.pathSegments
+  }, context);
+}
+function decoratorParseRequestDefinitionField(decoratorSchemas, key, requestObject) {
+  if (decoratorSchemas[key]) {
+    if (!(key in requestObject) || requestObject[key] === null || requestObject[key] === void 0) {
+      const result2 = decoratorSchemas[key].safeParse(requestObject[key]);
+      if (!result2.success) {
+        switch (decoratorSchemas[key].type) {
+          case "optional":
+            if (requestObject[key] === null) {
+              return void 0;
+            }
+            break;
+          case "nullable":
+            if (requestObject[key] === void 0) {
+              return null;
+            }
+            break;
         }
-        return Reflect.get(target, prop);
+        return {
+          code: HttpStatusCode.BadRequest_400,
+          body: `'${key}' is required for this endpoint` + (key === "body" ? ", { 'Content-Type': 'application/json' } header might be missing" : "")
+        };
       }
-    });
-  }
-  createTestClone() {
-    const clone = new DIContainer();
-    return clone;
+      return result2.data;
+    }
+    const result = decoratorSchemas[key].safeParse(requestObject[key]);
+    if (!result.success) {
+      return {
+        code: HttpStatusCode.BadRequest_400,
+        body: result.error.issues
+      };
+    }
+    return result.data;
   }
+  return null;
 }
 
-function createInProcApiClient(contract, testContainer, registry) {
-  const testApiReg = createRegistry(testContainer, contract, {
-    handlerRegisteredCallback: (_entry) => {
-    },
-    middlewareHandlerRegisteredCallback: (_entry) => {
+function createInProcApiClient(contract, testContainer, registry, options) {
+  const mwHandlers = [];
+  const mwReg = registry._middlewareRegistry;
+  const mwNdx = 0;
+  for (const mwEntry of mwReg.list) {
+    if (!options?.filterMiddleware) {
+      addMiddlewareDecorators(mwHandlers, mwEntry);
+      mwHandlers.push(mwEntry);
+      continue;
     }
-  });
-  flatListAllRegistryEntries(registry).forEach((entry) => {
-    if (!entry.handler) {
-      return;
+    const isIncluded = options.filterMiddleware(mwEntry.genericPath, mwNdx);
+    if (!isIncluded) {
+      continue;
     }
-    const rt = route(testApiReg, `${entry.methodEndpoint.method} ${entry.methodEndpoint.genericPath}`);
-    rt.inject(entry.injection).register(entry.handler);
-  });
+    addMiddlewareDecorators(mwHandlers, mwEntry);
+    mwHandlers.push(mwEntry);
+  }
   const client = createClient(contract, async (input) => {
-    const rt = route(testApiReg, `${input.method} ${input.genericPath}`);
-    const result = rt.trigger({
-      headers: input.headers,
-      pathParams: input.pathParams,
-      body: input.body ?? {},
-      query: input.query ?? {}
+    if (options?.enhanceRequest) {
+      input = options.enhanceRequest(input);
+    }
+    const diScope = testContainer.createScope();
+    const allHandlerEntries = [...mwHandlers];
+    const endpointHandlerEntry = route(registry, `${input.method} ${input.genericPath}`);
+    if (!endpointHandlerEntry.handler) {
+      throw new Error(`No handler registered for ${input.method} ${input.genericPath}`);
+    }
+    endpointHandlerEntry.decoratorFactories.forEach((decoratorFactory) => {
+      allHandlerEntries.push({
+        genericPath: endpointHandlerEntry.genericPath,
+        triggerNoStaticTypeCheck: async (diScope2, requestObject, context) => {
+          const decorator = decoratorFactory(diScope2);
+          return await triggerEndpointDecoratorNoStaticTypeCheck(
+            endpointHandlerEntry.methodEndpoint,
+            decorator,
+            requestObject,
+            context
+          );
+        }
+      });
     });
-    return result;
+    if (options?.mockEndpointResponse) {
+      const mockResponse = options.mockEndpointResponse(input.genericPath, input.method, diScope);
+      if (mockResponse) {
+        allHandlerEntries.push({
+          genericPath: endpointHandlerEntry.genericPath,
+          triggerNoStaticTypeCheck: async (_diScope, _requestObject, _next) => {
+            return mockResponse;
+          }
+        });
+      } else {
+        allHandlerEntries.push(endpointHandlerEntry);
+      }
+    } else {
+      allHandlerEntries.push(endpointHandlerEntry);
+    }
+    const response = await execHandlerChain(diScope, allHandlerEntries, input);
+    if (!response) {
+      throw new Error(`No response from ${input.method} ${input.genericPath}`);
+    }
+    return response;
   });
   return client;
 }
+function addMiddlewareDecorators(mwHandlers, mwEntry) {
+  mwEntry.decoratorFactories.forEach((decoratorFactory) => {
+    mwHandlers.push({
+      genericPath: mwEntry.genericPath,
+      triggerNoStaticTypeCheck: async (diScope, requestObject, context) => {
+        const decorator = decoratorFactory(diScope);
+        return await triggerMiddlewareDecoratorNoStaticTypeCheck(
+          mwEntry,
+          decorator,
+          requestObject,
+          context
+        );
+      }
+    });
+  });
+}
 
 exports.ApiClient = ApiClient;
 exports.ApiContract = ApiContract;
 exports.ApiHandlersRegistry = ApiHandlersRegistry;
 exports.DIContainer = DIContainer;
+exports.DIContainerBase = DIContainerBase;
+exports.DIContainerTestClone = DIContainerTestClone;
 exports.HttpMethodEndpoint = HttpMethodEndpoint;
 exports.HttpMethodEndpointResponse = HttpMethodEndpointResponse;
 exports.HttpStatusCode = HttpStatusCode;
@@ -699,6 +1089,7 @@ exports.createClient = createClient;
 exports.createInProcApiClient = createInProcApiClient;
 exports.createRegistry = createRegistry;
 exports.endpoint = endpoint;
+exports.execHandlerChain = execHandlerChain;
 exports.flatListAllRegistryEntries = flatListAllRegistryEntries;
 exports.isHttpResponseObject = isHttpResponseObject;
 exports.isHttpStatusCode = isHttpStatusCode;
@@ -708,3 +1099,5 @@ exports.partialPathString = partialPathString;
 exports.register = register;
 exports.response = response;
 exports.route = route;
+exports.triggerEndpointDecoratorNoStaticTypeCheck = triggerEndpointDecoratorNoStaticTypeCheck;
+exports.triggerMiddlewareDecoratorNoStaticTypeCheck = triggerMiddlewareDecoratorNoStaticTypeCheck;