@congruent-stack/congruent-api 0.6.0 → 0.9.0-rc.0

package/dist/index.cjs

@@ -158,7 +158,7 @@ class MethodEndpointHandlerRegistryEntry {
     callback(this);
     return this;
   }
-  _injection = (_dicontainer) => ({});
+  _injection = (_diScope) => ({});
   get injection() {
     return this._injection;
   }
@@ -166,28 +166,28 @@ class MethodEndpointHandlerRegistryEntry {
     this._injection = injection;
     return this;
   }
-  async trigger(data) {
+  async trigger(diScope, 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
+      (segment) => segment.startsWith(":") ? requestObject.pathParams[segment.slice(1)] ?? "?" : segment
     ).join("/")}`;
     return await this._handler({
       method: this._methodEndpoint.method,
@@ -195,32 +195,45 @@ class MethodEndpointHandlerRegistryEntry {
       genericPath: this._methodEndpoint.genericPath,
       pathSegments: this._methodEndpoint.pathSegments,
       headers,
-      pathParams: data.pathParams,
+      pathParams: requestObject.pathParams,
       query,
       body,
-      injected: this._injection(this._dicontainer.createScope())
+      injected: this._injection(diScope)
     });
   }
 }
-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,6 +248,9 @@ function middleware(apiReg, path) {
 }
 class MiddlewareHandlersRegistryEntryInternal {
   _dicontainer;
+  get dicontainer() {
+    return this._dicontainer;
+  }
   _middlewareGenericPath;
   get genericPath() {
     return this._middlewareGenericPath;
@@ -265,39 +281,42 @@ class MiddlewareHandlersRegistryEntryInternal {
     this._handler = handler;
   }
   _injection = (_dicontainer) => ({});
-  async trigger(data, next) {
+  async trigger(diScope, requestObject, next) {
     let badRequestResponse = null;
-    const headers = middlewareParseRequestDefinitionField(this._inputSchemas, "headers", data);
+    const headers = middlewareParseRequestDefinitionField(this._inputSchemas, "headers", requestObject);
     if (isHttpResponseObject(headers)) {
       badRequestResponse = headers;
       return badRequestResponse;
     }
-    const query = middlewareParseRequestDefinitionField(this._inputSchemas, "query", data);
+    const query = middlewareParseRequestDefinitionField(this._inputSchemas, "query", requestObject);
     if (isHttpResponseObject(query)) {
       badRequestResponse = query;
       return badRequestResponse;
     }
-    const body = middlewareParseRequestDefinitionField(this._inputSchemas, "body", data);
+    const body = middlewareParseRequestDefinitionField(this._inputSchemas, "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
+      (segment) => segment.startsWith(":") ? requestObject.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 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: requestObject.pathParams,
+        query,
+        body,
+        injected: this._injection(diScope)
+      },
+      next
+    );
   }
 }
 class MiddlewareHandlersRegistryEntry {
@@ -307,7 +326,7 @@ class MiddlewareHandlersRegistryEntry {
     this._registry = registry;
     this._path = path;
   }
-  _injection = (_dicontainer) => ({});
+  _injection = (_diScope) => ({});
   get injection() {
     return this._injection;
   }
@@ -332,8 +351,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 +366,38 @@ class MiddlewareHandlersRegistry {
     this._onHandlerRegisteredCallback = callback;
   }
 }
-function middlewareParseRequestDefinitionField(inputSchemas, key, data) {
+function middlewareParseRequestDefinitionField(inputSchemas, key, requestObject) {
   if (inputSchemas[key]) {
-    if (!(key in data) || data[key] === null || data[key] === void 0) {
-      if (!inputSchemas[key].safeParse(data[key]).success) {
+    if (!(key in requestObject) || requestObject[key] === null || requestObject[key] === void 0) {
+      const result2 = inputSchemas[key].safeParse(requestObject[key]);
+      if (!result2.success) {
+        switch (inputSchemas[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 = inputSchemas[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;
 }
@@ -528,12 +565,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,107 +592,153 @@ 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);
-    if (!registration) {
-      throw new Error(`Service not registered: ${serviceName}`);
-    }
-    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);
+  createTestClone() {
+    return new DIContainerTestClone(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}`);
-          }
-        }
-        return Reflect.get(target, prop);
-      }
+}
+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
+      });
     });
   }
-  createTestClone() {
-    const clone = new DIContainer();
-    return clone;
+  override(serviceNameLiteral, factory) {
+    const registration = this._map.get(serviceNameLiteral);
+    if (!registration) {
+      throw new Error(`Service not registered: ${serviceNameLiteral}`);
+    }
+    this._map.set(serviceNameLiteral, { factory, lifetime: registration.lifetime });
+    return this;
   }
 }
 
+function execMiddleware(diScope, list, input) {
+  const queue = [...list];
+  const next = async () => {
+    const current = queue.shift();
+    if (!current) {
+      return;
+    }
+    const result = await current.trigger(
+      diScope,
+      {
+        headers: input.headers,
+        pathParams: input.pathParams,
+        body: input.body,
+        query: input.query
+      },
+      next
+    );
+    if (result) {
+      return result;
+    }
+    return next();
+  };
+  return next();
+}
+
 function createInProcApiClient(contract, testContainer, registry) {
   const testApiReg = createRegistry(testContainer, contract, {
     handlerRegisteredCallback: (_entry) => {
@@ -663,6 +746,10 @@ function createInProcApiClient(contract, testContainer, registry) {
     middlewareHandlerRegisteredCallback: (_entry) => {
     }
   });
+  registry._middlewareRegistry.list.forEach((mwEntry) => {
+    testApiReg._middlewareRegistry.register(mwEntry);
+  });
+  const mwReg = testApiReg._middlewareRegistry;
   flatListAllRegistryEntries(registry).forEach((entry) => {
     if (!entry.handler) {
       return;
@@ -671,12 +758,17 @@ function createInProcApiClient(contract, testContainer, registry) {
     rt.inject(entry.injection).register(entry.handler);
   });
   const client = createClient(contract, async (input) => {
+    const diScope = testContainer.createScope();
+    const haltExecResponse = await execMiddleware(diScope, mwReg.list, input);
+    if (haltExecResponse) {
+      return haltExecResponse;
+    }
     const rt = route(testApiReg, `${input.method} ${input.genericPath}`);
-    const result = rt.trigger({
+    const result = await rt.trigger(diScope, {
       headers: input.headers,
       pathParams: input.pathParams,
-      body: input.body ?? {},
-      query: input.query ?? {}
+      body: input.body,
+      query: input.query
     });
     return result;
   });
@@ -687,6 +779,8 @@ 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;