@pristine-ts/networking 0.0.172 → 0.0.176

package/dist/lib/esm/interceptors/request-body-converter.interceptor.js

@@ -0,0 +1,86 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { injectable, inject } from "tsyringe";
+import { moduleScoped, ServiceDefinitionTagEnum, tag } from "@pristine-ts/common";
+import { NetworkingModuleKeyname } from "../networking.module.keyname";
+import { InvalidBodyHttpError } from "../errors/invalid-body.http-error";
+let RequestBodyConverterInterceptor = class RequestBodyConverterInterceptor {
+    constructor(isActive, logHandler) {
+        this.isActive = isActive;
+        this.logHandler = logHandler;
+    }
+    interceptRequest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isActive === false) {
+                return request;
+            }
+            let contentType;
+            for (let key in request.headers) {
+                if (request.headers.hasOwnProperty(key) === false) {
+                    continue;
+                }
+                const requestHeader = request.headers[key];
+                if (key.toLowerCase() === "content-type") {
+                    contentType = requestHeader;
+                    break;
+                }
+            }
+            if (contentType === undefined) {
+                return request;
+            }
+            switch (contentType.toLowerCase()) {
+                case "application/json":
+                    switch (typeof request.body) {
+                        case "object":
+                            return request;
+                        case "string":
+                            try {
+                                if (request.body) {
+                                    request.body = JSON.parse(request.body);
+                                }
+                            }
+                            catch (e) {
+                                const errorMessage = "This request has the Content-Type header 'application/json' but the body contains invalid JSON.";
+                                this.logHandler.error(errorMessage);
+                                throw new InvalidBodyHttpError(errorMessage);
+                            }
+                            break;
+                        default:
+                            const errorMessage = "This request has the Content-Type header 'application/json' but the body contains invalid JSON.";
+                            this.logHandler.error(errorMessage);
+                            throw new InvalidBodyHttpError(errorMessage);
+                    }
+            }
+            return request;
+        });
+    }
+};
+RequestBodyConverterInterceptor = __decorate([
+    tag(ServiceDefinitionTagEnum.RequestInterceptor),
+    moduleScoped(NetworkingModuleKeyname),
+    injectable(),
+    __param(0, inject("%" + NetworkingModuleKeyname + ".request_body_converter.is_active%")),
+    __param(1, inject("LogHandlerInterface")),
+    __metadata("design:paramtypes", [Boolean, Object])
+], RequestBodyConverterInterceptor);
+export { RequestBodyConverterInterceptor };
+//# sourceMappingURL=request-body-converter.interceptor.js.map

package/dist/lib/esm/interceptors/request-body-converter.interceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body-converter.interceptor.js","sourceRoot":"","sources":["../../../../src/interceptors/request-body-converter.interceptor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAC,UAAU,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC;AAE5C,OAAO,EAAC,YAAY,EAAW,wBAAwB,EAAE,GAAG,EAAC,MAAM,qBAAqB,CAAC;AACzF,OAAO,EAAC,uBAAuB,EAAC,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAC,oBAAoB,EAAC,MAAM,mCAAmC,CAAC;AAKvE,IAAa,+BAA+B,GAA5C,MAAa,+BAA+B;IACxC,YAA2G,QAAiB,EAChE,UAA+B;QADgB,aAAQ,GAAR,QAAQ,CAAS;QAChE,eAAU,GAAV,UAAU,CAAqB;IAC3F,CAAC;IAEK,gBAAgB,CAAC,OAAgB;;YACnC,IAAG,IAAI,CAAC,QAAQ,KAAK,KAAK,EAAE;gBACxB,OAAO,OAAO,CAAC;aAClB;YAED,IAAI,WAA+B,CAAC;YAEpC,KAAK,IAAI,GAAG,IAAI,OAAO,CAAC,OAAO,EAAE;gBAC7B,IAAI,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE;oBAC/C,SAAS;iBACZ;gBAED,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBAE3C,IAAG,GAAG,CAAC,WAAW,EAAE,KAAK,cAAc,EAAE;oBACrC,WAAW,GAAG,aAAa,CAAC;oBAC5B,MAAM;iBACT;aACJ;YAED,IAAG,WAAW,KAAK,SAAS,EAAE;gBAC1B,OAAO,OAAO,CAAC;aAClB;YAED,QAAQ,WAAW,CAAC,WAAW,EAAE,EAAE;gBAC/B,KAAK,kBAAkB;oBAEnB,QAAQ,OAAO,OAAO,CAAC,IAAI,EAAE;wBACzB,KAAK,QAAQ;4BACT,OAAO,OAAO,CAAC;wBAEnB,KAAK,QAAQ;4BACT,IAAI;gCACA,IAAG,OAAO,CAAC,IAAI,EAAE;oCACb,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;iCAC3C;6BACJ;4BACD,OAAO,CAAC,EAAE;gCACN,MAAM,YAAY,GAAG,iGAAiG,CAAC;gCACvH,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;gCAEpC,MAAM,IAAI,oBAAoB,CAAC,YAAY,CAAC,CAAC;6BAChD;4BACD,MAAM;wBAEV;4BACI,MAAM,YAAY,GAAG,iGAAiG,CAAC;4BACvH,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;4BAEpC,MAAM,IAAI,oBAAoB,CAAC,YAAY,CAAC,CAAC;qBACpD;aAGR;YAED,OAAO,OAAO,CAAC;QACnB,CAAC;KAAA;CAEJ,CAAA;AA/DY,+BAA+B;IAH3C,GAAG,CAAC,wBAAwB,CAAC,kBAAkB,CAAC;IAChD,YAAY,CAAC,uBAAuB,CAAC;IACrC,UAAU,EAAE;IAEI,WAAA,MAAM,CAAC,GAAG,GAAG,uBAAuB,GAAG,oCAAoC,CAAC,CAAA;IAC5E,WAAA,MAAM,CAAC,qBAAqB,CAAC,CAAA;;GAFjC,+BAA+B,CA+D3C;SA/DY,+BAA+B"}

package/dist/lib/esm/{enrichers/router-response.enricher.js → interceptors/response-headers.interceptor.js}

@@ -15,23 +15,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { moduleScoped, ServiceDefinitionTagEnum, tag } from "@pristine-ts/common";
 import { NetworkingModuleKeyname } from "../networking.module.keyname";
+import { injectable } from "tsyringe";
 /**
- * The RouterResponseEnricher enriches the response of the router by adding the response headers specified by the response header decorator.
- * It is tagged as an RouterResponseEnricher so it can be automatically injected with the all the other RouterResponseEnrichers.
+ * The Response Interceptor intercepts the response of the router by adding the response headers specified by the response header decorator.
+ * It is tagged as a RequestInterceptor so it can be automatically injected with the all the other RequestInterceptor.
  */
-let RouterResponseEnricher = class RouterResponseEnricher {
-    enrichResponse(response, request, methodNode) {
+let ResponseHeadersInterceptor = class ResponseHeadersInterceptor {
+    interceptResponse(response, request, methodNode) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (methodNode.route.context && methodNode.route.context.hasOwnProperty("responseHeaders")) {
+            if (methodNode && methodNode.route.context && methodNode.route.context.hasOwnProperty("responseHeaders")) {
                 response.headers = Object.assign(Object.assign({}, response.headers), methodNode.route.context.responseHeaders);
             }
             return response;
         });
     }
 };
-RouterResponseEnricher = __decorate([
-    tag(ServiceDefinitionTagEnum.RouterResponseEnricher),
-    moduleScoped(NetworkingModuleKeyname)
-], RouterResponseEnricher);
-export { RouterResponseEnricher };
-//# sourceMappingURL=router-response.enricher.js.map
+ResponseHeadersInterceptor = __decorate([
+    tag(ServiceDefinitionTagEnum.RequestInterceptor),
+    moduleScoped(NetworkingModuleKeyname),
+    injectable()
+], ResponseHeadersInterceptor);
+export { ResponseHeadersInterceptor };
+//# sourceMappingURL=response-headers.interceptor.js.map

package/dist/lib/esm/interceptors/response-headers.interceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-headers.interceptor.js","sourceRoot":"","sources":["../../../../src/interceptors/response-headers.interceptor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAC,YAAY,EAAqB,wBAAwB,EAAE,GAAG,EAAC,MAAM,qBAAqB,CAAC;AACnG,OAAO,EAAC,uBAAuB,EAAC,MAAM,8BAA8B,CAAC;AAGrE,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACpC;;;GAGG;AAIH,IAAa,0BAA0B,GAAvC,MAAa,0BAA0B;IAC7B,iBAAiB,CAAC,QAAkB,EAAE,OAAgB,EAAE,UAA6B;;YACvF,IAAG,UAAU,IAAI,UAAU,CAAC,KAAK,CAAC,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,iBAAiB,CAAC,EAAC;gBACpG,QAAQ,CAAC,OAAO,mCAAO,QAAQ,CAAC,OAAO,GAAK,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;aACxF;YAED,OAAO,QAAQ,CAAC;QACpB,CAAC;KAAA;CACJ,CAAA;AARY,0BAA0B;IAHtC,GAAG,CAAC,wBAAwB,CAAC,kBAAkB,CAAC;IAChD,YAAY,CAAC,uBAAuB,CAAC;IACrC,UAAU,EAAE;GACA,0BAA0B,CAQtC;SARY,0BAA0B"}

package/dist/lib/esm/interfaces/interfaces.js

@@ -5,10 +5,9 @@ export * from "./identity-parameteter-decorator.interface";
 export * from "./parameter-decorator.interface";
 export * from "./query-parameter-decorator.interface";
 export * from "./query-parameters-decorator.interface";
+export * from "./request-interceptor.interface";
 export * from "./request-parameter-decorator.interface";
 export * from "./route-method-decorator.interface";
 export * from "./route-parameter-decorator.interface";
 export * from "./router.interface";
-export * from "./router-request-enricher.interface";
-export * from "./router-response-enricher.interface";
 //# sourceMappingURL=interfaces.js.map

package/dist/lib/esm/interfaces/interfaces.js.map

@@ -1 +1 @@
-{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../src/interfaces/interfaces.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,4DAA4D,CAAC;AAC3E,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oBAAoB,CAAC;AACnC,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC"}
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../src/interfaces/interfaces.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,4DAA4D,CAAC;AAC3E,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,yCAAyC,CAAC;AACxD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oBAAoB,CAAC"}

package/dist/lib/esm/interfaces/request-interceptor.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=request-interceptor.interface.js.map

package/dist/lib/esm/interfaces/request-interceptor.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-interceptor.interface.js","sourceRoot":"","sources":["../../../../src/interfaces/request-interceptor.interface.ts"],"names":[],"mappings":""}

package/dist/lib/esm/mappers/mappers.js

@@ -0,0 +1,2 @@
+export * from "./request.mapper";
+//# sourceMappingURL=mappers.js.map

package/dist/lib/esm/mappers/mappers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappers.js","sourceRoot":"","sources":["../../../../src/mappers/mappers.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/lib/esm/mappers/request.mapper.js

@@ -0,0 +1,34 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { moduleScoped, Request, Response, ServiceDefinitionTagEnum, tag } from "@pristine-ts/common";
+import { injectable } from "tsyringe";
+import { NetworkingModuleKeyname } from "../networking.module.keyname";
+import { Event } from "@pristine-ts/core";
+let RequestMapper = class RequestMapper {
+    supportsMapping(rawEvent, executionContext) {
+        return rawEvent instanceof Request;
+    }
+    map(rawEvent, executionContext) {
+        return {
+            executionOrder: "sequential",
+            events: [new Event("Request", rawEvent)],
+        };
+    }
+    supportsReverseMapping(eventResponse, response, executionContext) {
+        return eventResponse.response instanceof Response;
+    }
+    reverseMap(eventResponse, response, executionContext) {
+        return eventResponse.response;
+    }
+};
+RequestMapper = __decorate([
+    moduleScoped(NetworkingModuleKeyname),
+    tag(ServiceDefinitionTagEnum.EventMapper),
+    injectable()
+], RequestMapper);
+export { RequestMapper };
+//# sourceMappingURL=request.mapper.js.map

package/dist/lib/esm/mappers/request.mapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.mapper.js","sourceRoot":"","sources":["../../../../src/mappers/request.mapper.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAC,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,wBAAwB,EAAE,GAAG,EAAC,MAAM,qBAAqB,CAAC;AACnG,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACpC,OAAO,EAAC,uBAAuB,EAAC,MAAM,8BAA8B,CAAC;AACrE,OAAO,EACH,KAAK,EAKR,MAAM,mBAAmB,CAAC;AAK3B,IAAa,aAAa,GAA1B,MAAa,aAAa;IACtB,eAAe,CAAC,QAAa,EAAE,gBAAgD;QAC3E,OAAO,QAAQ,YAAY,OAAO,CAAC;IACvC,CAAC;IAED,GAAG,CAAC,QAAa,EAAE,gBAAgD;QAC/D,OAAO;YACH,cAAc,EAAE,YAAY;YAC5B,MAAM,EAAE,CAAC,IAAI,KAAK,CAAU,SAAS,EAAE,QAAQ,CAAC,CAAC;SACpD,CAAC;IACN,CAAC;IAED,sBAAsB,CAAC,aAA+C,EAAE,QAAa,EAAE,gBAAgD;QACnI,OAAO,aAAa,CAAC,QAAQ,YAAY,QAAQ,CAAC;IACtD,CAAC;IAED,UAAU,CAAC,aAA+C,EAAE,QAAa,EAAE,gBAAgD;QACvH,OAAO,aAAa,CAAC,QAAQ,CAAC;IAClC,CAAC;CAEJ,CAAA;AApBY,aAAa;IAHzB,YAAY,CAAC,uBAAuB,CAAC;IACrC,GAAG,CAAC,wBAAwB,CAAC,WAAW,CAAC;IACzC,UAAU,EAAE;GACA,aAAa,CAoBzB;SApBY,aAAa"}

package/dist/lib/esm/models/models.js

@@ -1,4 +1,2 @@
-export * from "./request";
-export * from "./response";
 export * from "./route";
 //# sourceMappingURL=models.js.map

package/dist/lib/esm/models/models.js.map

@@ -1 +1 @@
-{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../src/models/models.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../src/models/models.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/lib/esm/networking.module.js

@@ -1,10 +1,13 @@
 import { NetworkingModuleKeyname } from "./networking.module.keyname";
 import { SecurityModule } from "@pristine-ts/security";
 import { TelemetryModule } from "@pristine-ts/telemetry";
+import { BooleanResolver, EnvironmentVariableResolver } from "@pristine-ts/configuration";
 export * from "./decorators/decorators";
-export * from "./enrichers/enrichers";
 export * from "./errors/errors";
+export * from "./handlers/handlers";
+export * from "./interceptors/interceptors";
 export * from "./interfaces/interfaces";
+export * from "./mappers/mappers";
 export * from "./models/models";
 export * from "./nodes/nodes";
 export * from "./resolvers/resolvers";
@@ -16,6 +19,15 @@ export const NetworkingModule = {
         SecurityModule,
         TelemetryModule,
     ],
-    configurationDefinitions: [],
+    configurationDefinitions: [
+        {
+            parameterName: NetworkingModuleKeyname + ".request_body_converter.is_active",
+            isRequired: false,
+            defaultValue: true,
+            defaultResolvers: [
+                new BooleanResolver(new EnvironmentVariableResolver("PRISTINE_NETWORKING_REQUEST_BODY_CONVERTER_IS_ACTIVE")),
+            ],
+        }
+    ],
 };
 //# sourceMappingURL=networking.module.js.map

package/dist/lib/esm/networking.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"networking.module.js","sourceRoot":"","sources":["../../../src/networking.module.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,uBAAuB,EAAC,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAEvD,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAE9B,cAAc,UAAU,CAAC;AAEzB,MAAM,CAAC,MAAM,gBAAgB,GAAoB;IAC7C,OAAO,EAAE,uBAAuB;IAChC,aAAa,EAAE;QACX,cAAc;QACd,eAAe;KAClB;IACD,wBAAwB,EAAE,EAEzB;CACJ,CAAA"}
+{"version":3,"file":"networking.module.js","sourceRoot":"","sources":["../../../src/networking.module.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,uBAAuB,EAAC,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAC,eAAe,EAAE,2BAA2B,EAAC,MAAM,4BAA4B,CAAC;AAExF,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAE9B,cAAc,UAAU,CAAC;AAEzB,MAAM,CAAC,MAAM,gBAAgB,GAAoB;IAC7C,OAAO,EAAE,uBAAuB;IAChC,aAAa,EAAE;QACX,cAAc;QACd,eAAe;KAClB;IACD,wBAAwB,EAAE;QACtB;YACI,aAAa,EAAE,uBAAuB,GAAG,mCAAmC;YAC5E,UAAU,EAAE,KAAK;YACjB,YAAY,EAAE,IAAI;YAClB,gBAAgB,EAAE;gBACd,IAAI,eAAe,CAAC,IAAI,2BAA2B,CAAC,sDAAsD,CAAC,CAAC;aAC/G;SACJ;KACJ;CACJ,CAAA"}

package/dist/lib/esm/router.js

@@ -20,16 +20,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { inject, singleton } from "tsyringe";
-import { Response } from "./models/response";
 import { UrlUtil } from "./utils/url.util";
 import { NotFoundHttpError } from "./errors/not-found.http-error";
 import { PathRouterNode } from "./nodes/path-router.node";
+import { Route } from "./models/route";
 import { ForbiddenHttpError } from "./errors/forbidden.http-error";
 import { ControllerMethodParameterDecoratorResolver } from "./resolvers/controller-method-parameter-decorator.resolver";
 import Url from 'url-parse';
-import { ServiceDefinitionTagEnum } from "@pristine-ts/common";
+import { tag, ServiceDefinitionTagEnum, Response } from "@pristine-ts/common";
 import { NetworkingModuleKeyname } from "./networking.module.keyname";
 import { SpanKeynameEnum } from "@pristine-ts/telemetry";
+import { controllerRegistry } from "./decorators/controller.decorator";
+import { mergeWith } from "lodash";
+import { HttpError } from "./errors/http.error";
 /**
  * The router service is the service that creates the routing tree from the controllers.
  * It also executes a request properly by routing it to the intended controller and returns the response.
@@ -49,6 +52,8 @@ let Router = class Router {
         this.authorizerManager = authorizerManager;
         this.authenticationManager = authenticationManager;
         this.root = new PathRouterNode("/");
+        // This property is used to track whether the router has been already been properly instantiated or not.
+        this.setupCompleted = false;
     }
     /**
      * This method registers a Route into the Route Tree maintained by the router.
@@ -61,6 +66,59 @@ let Router = class Router {
         const splitPaths = UrlUtil.splitPath(path);
         this.root.add(splitPaths, method, route, 0);
     }
+    // /**
+    //  * This method loops through the all the classes decorated with @controller, loops through all the methods decorated
+    //  * with @route and builds the dependency tree of all the routes.
+    //  *
+    //  * @private
+    //  */
+    setup() {
+        if (this.setupCompleted) {
+            return;
+        }
+        // Loop over all the controllers and control the Route Tree
+        controllerRegistry.forEach(controller => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            if (controller.hasOwnProperty("__metadata__") === false) {
+                return;
+            }
+            let basePath = (_b = (_a = controller.__metadata__) === null || _a === void 0 ? void 0 : _a.controller) === null || _b === void 0 ? void 0 : _b.basePath;
+            // Clean the base path by removing trailing slashes.
+            if (basePath.endsWith("/")) {
+                basePath = basePath.slice(0, basePath.length - 1);
+            }
+            for (const methodPropertyKey in (_c = controller.__metadata__) === null || _c === void 0 ? void 0 : _c.methods) {
+                if (((_e = (_d = controller.__metadata__) === null || _d === void 0 ? void 0 : _d.methods) === null || _e === void 0 ? void 0 : _e.hasOwnProperty(methodPropertyKey)) === false) {
+                    continue;
+                }
+                const method = (_f = controller.__metadata__) === null || _f === void 0 ? void 0 : _f.methods[methodPropertyKey];
+                if (method.hasOwnProperty("route") === false) {
+                    continue;
+                }
+                // Retrieve the "RouteMethodDecorator" object assigned by the @route decorator at .route
+                const routeMethodDecorator = method.route;
+                // Build the Route object that will be used the the router to dispatch a request to
+                // the appropriate controller method
+                const route = new Route(controller.constructor, routeMethodDecorator.methodKeyname);
+                route.methodArguments = (_g = method.arguments) !== null && _g !== void 0 ? _g : [];
+                route.context = mergeWith({}, (_j = (_h = controller.__metadata__) === null || _h === void 0 ? void 0 : _h.controller) === null || _j === void 0 ? void 0 : _j.__routeContext__, method.__routeContext__);
+                // Build the proper path
+                let path = routeMethodDecorator.path;
+                // Clean the path by removing the first and trailing slashes.
+                if (path.startsWith("/")) {
+                    path = path.slice(1, path.length);
+                }
+                if (path.endsWith("/")) {
+                    path = path.slice(0, path.length - 1);
+                }
+                // Build the proper path
+                const routePath = basePath + "/" + path;
+                // Register the route
+                this.register(routePath, routeMethodDecorator.httpMethod, route);
+            }
+        });
+        this.setupCompleted = true;
+    }
     /**
      * This method receives a Request object, identifies the "path" its trying to hit, navigates the internally
      * maintained Route Tree, identifies the method in the controller that represents this "path", and calls the
@@ -70,6 +128,8 @@ let Router = class Router {
      * @param container
      */
     execute(request, container) {
+        // todo: remove all the rejects and replace it with a response that contains an error.
+        // This method cannot throw.
         const tracingManager = container.resolve("TracingManagerInterface");
         const routerRequestExecutionSpan = tracingManager.startSpan(SpanKeynameEnum.RouterRequestExecution, SpanKeynameEnum.RequestExecution);
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -95,7 +155,7 @@ let Router = class Router {
                     url,
                 }, NetworkingModuleKeyname);
                 routerRequestExecutionSpan.end();
-                return reject(new NotFoundHttpError("No route found for path: '" + url.pathname + "'."));
+                return resolve(this.executeErrorResponseInterceptors(new NotFoundHttpError("No route found for path: '" + url.pathname + "'."), request, container));
             }
             // Get the route parameters
             const routeParameters = methodNode.parent.getRouteParameters(splitPath.reverse());
@@ -129,7 +189,7 @@ let Router = class Router {
                     error = new ForbiddenHttpError("You are not allowed to access this.");
                 }
                 routerRequestExecutionSpan.end();
-                return reject(error);
+                return resolve(this.executeErrorResponseInterceptors(error, request, container, methodNode));
             }
             // Call the controller with the resolved Method arguments
             try {
@@ -142,20 +202,20 @@ let Router = class Router {
                         identity
                     }, NetworkingModuleKeyname);
                     routerRequestExecutionSpan.end();
-                    return reject(new ForbiddenHttpError("You are not allowed to access this."));
+                    return resolve(this.executeErrorResponseInterceptors(new ForbiddenHttpError("You are not allowed to access this."), request, container, methodNode));
                 }
-                // Execute all the enrichers to enrich the request.
-                const requestEnrichersSpan = tracingManager.startSpan(SpanKeynameEnum.RouterRequestEnrichers, SpanKeynameEnum.RouterRequestExecution);
-                const enrichedRequest = yield this.executeRequestEnrichers(request, container, methodNode);
-                requestEnrichersSpan.end();
+                // Execute all the interceptors
+                const requestInterceptorsSpan = tracingManager.startSpan(SpanKeynameEnum.RequestInterceptors, SpanKeynameEnum.RouterRequestExecution);
+                const interceptedRequest = yield this.executeRequestInterceptors(request, container, methodNode);
+                requestInterceptorsSpan.end();
                 this.loghandler.debug("This request has been enriched", {
                     request,
-                    enrichedRequest,
+                    interceptedRequest,
                 }, NetworkingModuleKeyname);
                 // Resolve the value to inject in the method arguments that have a decorator resolver
                 const resolvedMethodArguments = [];
                 for (const methodArgument of methodNode.route.methodArguments) {
-                    resolvedMethodArguments.push(yield this.controllerMethodParameterDecoratorResolver.resolve(methodArgument, enrichedRequest, routeParameters, identity));
+                    resolvedMethodArguments.push(yield this.controllerMethodParameterDecoratorResolver.resolve(methodArgument, interceptedRequest, routeParameters, identity));
                 }
                 this.loghandler.debug("Controller argument resolved", {
                     resolvedMethodArguments,
@@ -179,12 +239,12 @@ let Router = class Router {
                     returnedResponse.status = 200;
                     returnedResponse.body = response;
                 }
-                const responseEnrichersSpan = tracingManager.startSpan(SpanKeynameEnum.RouterResponseEnrichers, SpanKeynameEnum.RouterRequestExecution);
-                const enrichedResponse = yield this.executeResponseEnrichers(returnedResponse, request, container, methodNode);
-                responseEnrichersSpan.end();
+                const responseInterceptorsSpan = tracingManager.startSpan(SpanKeynameEnum.ResponseInterceptors, SpanKeynameEnum.RouterRequestExecution);
+                const interceptedResponse = yield this.executeResponseInterceptors(returnedResponse, request, container, methodNode);
+                responseInterceptorsSpan.end();
                 this.loghandler.debug("This response has been enriched", {
                     returnedResponse,
-                    enrichedResponse,
+                    enrichedResponse: interceptedResponse,
                 }, NetworkingModuleKeyname);
                 routerRequestExecutionSpan.end();
                 return resolve(returnedResponse);
@@ -193,84 +253,142 @@ let Router = class Router {
                 this.loghandler.error("There was an error trying to execute the request in the router", {
                     error,
                 }, NetworkingModuleKeyname);
+                // Execute router interceptors for the error response;
                 routerRequestExecutionSpan.end();
-                return reject(error);
+                return resolve(this.executeErrorResponseInterceptors(error, request, container, methodNode));
             }
         }));
     }
     /**
-     * This method executes all the Router response enrichers and returns the response updated by the enrichers.
+     * This method executes all the Request Interceptors and returns the request updated by the interceptors.
      *
-     * @param response
      * @param request
      * @param container
      * @param methodNode
      * @private
      */
-    executeResponseEnrichers(response, request, container, methodNode) {
+    executeRequestInterceptors(request, container, methodNode) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            // Execute all the request enrichers
-            let enrichedResponse = response;
-            // Check first if there are any Router Response enrichers
-            if (container.isRegistered(ServiceDefinitionTagEnum.RouterResponseEnricher, true)) {
-                const enrichers = container.resolveAll(ServiceDefinitionTagEnum.RouterResponseEnricher);
-                for (const enricher of enrichers) {
-                    // We don't have a guarantee that the Router response enrichers will implement the Interface, even though we specify it should.
+            // Execute all the request interceptors
+            let interceptedRequest = request;
+            // Check first if there are any Request Interceptors
+            if (container.isRegistered(ServiceDefinitionTagEnum.RequestInterceptor, true)) {
+                const interceptors = container.resolveAll(ServiceDefinitionTagEnum.RequestInterceptor);
+                for (const interceptor of interceptors) {
+                    // We don't have a guarantee that the Router Interceptors will implement the Interface, even though we specify it should.
                     // So, we have to verify that the method exists, and if it doesn't we throw
-                    if (typeof enricher.enrichResponse === "undefined") {
-                        //todo should we type this error ?
-                        throw new Error("The Router Response Enricher named: '" + enricher.constructor.name + "' doesn't have the 'enrichResponse' method. RouterResponseEnrichers should implement the RouterResponseEnricher interface.");
+                    if (typeof interceptor.interceptRequest === "undefined") {
+                        // Simply log a message for now that the interceptors doesn't implement the 'interceptRequest' method.
+                        this.loghandler.info("The Request Interceptor doesn't implement the interceptRequest method.", { name: interceptor.constructor.name, interceptor });
+                        continue;
                     }
                     try {
                         // https://stackoverflow.com/a/27760489/684101
-                        enrichedResponse = yield Promise.resolve(enricher.enrichResponse(enrichedResponse, request, methodNode));
+                        interceptedRequest = (_c = yield ((_b = (_a = interceptor).interceptRequest) === null || _b === void 0 ? void 0 : _b.call(_a, interceptedRequest, methodNode))) !== null && _c !== void 0 ? _c : interceptedRequest;
                     }
                     catch (e) {
-                        this.loghandler.error("There was an exception thrown while executing the 'enrichResponse' method of the RouterResponseEnricher named: '" + enricher.constructor.name + "'.", { e }, NetworkingModuleKeyname);
+                        this.loghandler.error("There was an exception thrown while executing the 'interceptedRequest' method of the RequestInterceptor named: '" + interceptor.constructor.name + "'.", { e }, NetworkingModuleKeyname);
                         throw e;
                     }
                 }
             }
-            return enrichedResponse;
+            return interceptedRequest;
         });
     }
     /**
-     * This method executes all the Router request enrichers and returns the request updated by the enrichers.
+     * This method executes all the Request Interceptors and returns the response updated by the interceptors.
      *
+     * @param response
      * @param request
      * @param container
      * @param methodNode
      * @private
      */
-    executeRequestEnrichers(request, container, methodNode) {
+    executeResponseInterceptors(response, request, container, methodNode) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            // Execute all the request enrichers
-            let enrichedRequest = request;
-            // Check first if there are any Router Request enrichers
-            if (container.isRegistered(ServiceDefinitionTagEnum.RouterRequestEnricher, true)) {
-                const enrichers = container.resolveAll(ServiceDefinitionTagEnum.RouterRequestEnricher);
-                for (const enricher of enrichers) {
-                    // We don't have a guarantee that the Router response enrichers will implement the Interface, even though we specify it should.
+            // Execute all the request interceptors
+            let interceptedResponse = response;
+            // Check first if there are any Request interceptors
+            if (container.isRegistered(ServiceDefinitionTagEnum.RequestInterceptor, true)) {
+                const interceptors = container.resolveAll(ServiceDefinitionTagEnum.RequestInterceptor);
+                for (const interceptor of interceptors) {
+                    // We don't have a guarantee that the Router response interceptors will implement the Interface, even though we specify it should.
                     // So, we have to verify that the method exists, and if it doesn't we throw
-                    if (typeof enricher.enrichRequest === "undefined") {
-                        //todo should we type this error ?
-                        throw new Error("The Router Request Enricher named: '" + enricher.constructor.name + "' doesn't have the 'enrichRequest' method. RouterRequestEnrichers should implement the RouterRequestEnricher interface.");
+                    if (typeof interceptor.interceptResponse === "undefined") {
+                        // Simply log a message for now that the interceptors doesn't implement the 'interceptResponse' method.
+                        this.loghandler.info("The Request Interceptor doesn't implement the interceptResponse method.", { name: interceptor.constructor.name, interceptor });
+                        continue;
                     }
                     try {
-                        // https://stackoverflow.com/a/27760489/684101
-                        enrichedRequest = yield Promise.resolve(enricher.enrichRequest(enrichedRequest, methodNode));
+                        interceptedResponse = (_c = yield ((_b = (_a = interceptor).interceptResponse) === null || _b === void 0 ? void 0 : _b.call(_a, interceptedResponse, request, methodNode))) !== null && _c !== void 0 ? _c : interceptedResponse;
+                    }
+                    catch (e) {
+                        this.loghandler.error("There was an exception thrown while executing the 'interceptResponse' method of the RequestInterceptor named: '" + interceptor.constructor.name + "'.", { e }, NetworkingModuleKeyname);
+                        throw e;
+                    }
+                }
+            }
+            return interceptedResponse;
+        });
+    }
+    /**
+     * This method executes all the Request Interceptors and returns the response updated by the error interceptors.
+     *
+     * @param error
+     * @param request
+     * @param container
+     * @param methodNode
+     * @private
+     */
+    executeErrorResponseInterceptors(error, request, container, methodNode) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Execute all the request interceptors
+            let interceptedResponse = new Response();
+            if (error instanceof HttpError) {
+                interceptedResponse.status = error.httpStatus;
+                interceptedResponse.body = {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                    errors: error.errors,
+                    extra: error.extra,
+                };
+            }
+            else {
+                interceptedResponse.status = 500;
+                interceptedResponse.body = { name: error.name, message: error.message, stack: error.stack };
+            }
+            interceptedResponse.request = request;
+            // Check first if there are any Request interceptors
+            if (container.isRegistered(ServiceDefinitionTagEnum.RequestInterceptor, true)) {
+                const interceptors = container.resolveAll(ServiceDefinitionTagEnum.RequestInterceptor);
+                for (const interceptor of interceptors) {
+                    // We don't have a guarantee that the Router response interceptors will implement the Interface, even though we specify it should.
+                    // So, we have to verify that the method exists, and if it doesn't we throw
+                    if (typeof interceptor.interceptError === "undefined") {
+                        // Simply log a message for now that the interceptors doesn't implement the 'interceptError' method.
+                        this.loghandler.info("The Request Interceptor doesn't implement the interceptError method.", { name: interceptor.constructor.name, interceptor });
+                        continue;
+                    }
+                    try {
+                        interceptedResponse = (_c = yield ((_b = (_a = interceptor).interceptError) === null || _b === void 0 ? void 0 : _b.call(_a, error, interceptedResponse, request, methodNode))) !== null && _c !== void 0 ? _c : interceptedResponse;
                     }
                     catch (e) {
-                        this.loghandler.error("There was an exception thrown while executing the 'enrichedRequest' method of the RouterRequestEnricher named: '" + enricher.constructor.name + "'.", { e }, NetworkingModuleKeyname);
+                        this.loghandler.error("There was an exception thrown while executing the 'interceptError' method of the RequestInterceptor named: '" + interceptor.constructor.name + "'.", { e }, NetworkingModuleKeyname);
                         throw e;
                     }
                 }
             }
-            return enrichedRequest;
+            interceptedResponse = yield this.executeResponseInterceptors(interceptedResponse, request, container, methodNode);
+            return interceptedResponse;
         });
     }
 };
 Router = __decorate([
+    tag("RouterInterface"),
     singleton(),
     __param(0, inject("LogHandlerInterface")),
     __param(2, inject("AuthorizerManagerInterface")),