@pristine-ts/networking 0.0.165 → 0.0.166

package/dist/types/resolvers/body-parameter-decorator.resolver.d.ts

@@ -2,9 +2,29 @@ import "reflect-metadata";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { BodyParameterDecoratorInterface } from "../interfaces/body-parameter-decorator.interface";
+/**
+ * The BodyParameterDecoratorResolver resolves the value of the body of the request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @body decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class BodyParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the body of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: BodyParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/controller-method-parameter-decorator.resolver.d.ts

@@ -2,9 +2,23 @@ import { IdentityInterface } from "@pristine-ts/common";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+/**
+ * This service calls the resolvers to resolve the value to be injected in the parameter of a method.
+ */
 export declare class ControllerMethodParameterDecoratorResolver {
     private readonly methodParameterDecoratorResolvers;
+    /**
+     * This service calls the resolvers to resolve the value to be injected in the parameter of a method.
+     * @param methodParameterDecoratorResolvers The parameter decorator resolvers. All services with the tag ServiceDefinitionTagEnum.MethodParameterDecoratorResolver will be automatically injected here.
+     */
     constructor(methodParameterDecoratorResolvers: ControllerMethodParameterDecoratorResolverInterface[]);
+    /**
+     * This method calls the parameter decorator resolver that supports the type of the decorator and resolves the value to be injected in the parameter.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
     resolve(methodArgument: ParameterDecoratorInterface, request: Request, routeParameters: {
         [key: string]: string;
     }, identity?: IdentityInterface): Promise<any>;

package/dist/types/resolvers/headers-parameter-decorator.resolver.d.ts

@@ -2,9 +2,29 @@ import "reflect-metadata";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { HeadersParameterDecoratorInterface } from "../interfaces/headers-parameter-decorator.interface";
+/**
+ * The HeadersParameterDecoratorResolver resolves the value of the headers of the request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @headers decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class HeadersParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the headers of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: HeadersParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/identity-parameter-decorator.resolver.d.ts

@@ -2,9 +2,29 @@ import "reflect-metadata";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { IdentityParameterDecoratorInterface } from "../interfaces/identity-parameteter-decorator.interface";
+/**
+ * The IdentityParameterDecoratorResolver resolves the value of the identity (parsed by the authenticator) of the request
+ * so that it can be injected it into the parameter of the route of the controller that was annotated with the @identity decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class IdentityParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the identity of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: IdentityParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/query-parameter-decorator.resolver.d.ts

@@ -1,9 +1,30 @@
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { QueryParameterDecoratorInterface } from "../interfaces/query-parameter-decorator.interface";
+/**
+ * The QueryParameterDecoratorResolver resolves the value of the query parameter with the name passed to the decorator
+ * of the request so that it can be injected it into the parameter of the route of the controller that was annotated
+ * with the @queryParameter decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class QueryParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the query parameter with the specified name of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator including the query parameter name.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: QueryParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/query-parameters-decorator.resolver.d.ts

@@ -1,9 +1,29 @@
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { QueryParametersDecoratorInterface } from "../interfaces/query-parameters-decorator.interface";
+/**
+ * The QueryParametersDecoratorResolver resolves the value (a  map) of the query parameters of the request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @queryParameters decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class QueryParametersDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of all the query parameters of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: QueryParametersDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/route-parameter-decorator.resolver.d.ts

@@ -1,9 +1,29 @@
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { RouteParameterDecoratorInterface } from "../interfaces/route-parameter-decorator.interface";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+/**
+ * The RouteParameterDecoratorResolver resolves the value of the route parameter specified of the request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @routeParameter decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class RouteParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the the route parameter with the specified name of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator, including the name of the parameter to resolve.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: RouteParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/router.d.ts

@@ -7,12 +7,24 @@ import { ControllerMethodParameterDecoratorResolver } from "./resolvers/controll
 import { HttpMethod } from "@pristine-ts/common";
 import { AuthenticationManagerInterface, AuthorizerManagerInterface } from "@pristine-ts/security";
 import { LogHandlerInterface } from "@pristine-ts/logging";
+/**
+ * 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.
+ */
 export declare class Router implements RouterInterface {
     private readonly loghandler;
     private readonly controllerMethodParameterDecoratorResolver;
     private readonly authorizerManager;
     private readonly authenticationManager;
     private root;
+    /**
+     * 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.
+     * @param loghandler The log handler
+     * @param controllerMethodParameterDecoratorResolver The controller method parameter decorator resolver used to resolve the values.
+     * @param authorizerManager The authorizer manager to validate authorization.
+     * @param authenticationManager The authentication manager to validate authentication.
+     */
     constructor(loghandler: LogHandlerInterface, controllerMethodParameterDecoratorResolver: ControllerMethodParameterDecoratorResolver, authorizerManager: AuthorizerManagerInterface, authenticationManager: AuthenticationManagerInterface);
     /**
      * This method registers a Route into the Route Tree maintained by the router.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/networking",
-  "version": "0.0.165",
+  "version": "0.0.166",
   "description": "",
   "module": "dist/lib/esm/networking.module.js",
   "main": "dist/lib/cjs/networking.module.js",
@@ -19,9 +19,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pristine-ts/common": "^0.0.165",
-    "@pristine-ts/security": "^0.0.165",
-    "@pristine-ts/telemetry": "^0.0.165",
+    "@pristine-ts/common": "^0.0.166",
+    "@pristine-ts/security": "^0.0.166",
+    "@pristine-ts/telemetry": "^0.0.166",
     "url-parse": "^1.4.7"
   },
   "jest": {
@@ -58,5 +58,5 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "da23f627c5a73c8b1aec0951e4b4f10ceeff44cb"
+  "gitHead": "c452544a69d17814c83d6a99a4fd788fdaa0daff"
 }

package/dist/lib/cjs/enums/enums.js

@@ -1 +0,0 @@
-//# sourceMappingURL=enums.js.map

package/dist/lib/cjs/enums/enums.js.map

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

package/dist/lib/cjs/models/error-response-body.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorResponseBody = void 0;
-class ErrorResponseBody {
-}
-exports.ErrorResponseBody = ErrorResponseBody;
-//# sourceMappingURL=error-response-body.js.map

package/dist/lib/cjs/models/error-response-body.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-response-body.js","sourceRoot":"","sources":["../../../../src/models/error-response-body.ts"],"names":[],"mappings":";;;AAAA,MAAa,iBAAiB;CAG7B;AAHD,8CAGC"}

package/dist/lib/esm/enums/enums.js

@@ -1 +0,0 @@
-//# sourceMappingURL=enums.js.map

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

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

package/dist/lib/esm/models/error-response-body.js

@@ -1,3 +0,0 @@
-export class ErrorResponseBody {
-}
-//# sourceMappingURL=error-response-body.js.map

package/dist/lib/esm/models/error-response-body.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-response-body.js","sourceRoot":"","sources":["../../../../src/models/error-response-body.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,iBAAiB;CAG7B"}

package/dist/types/models/error-response-body.d.ts

@@ -1,4 +0,0 @@
-export declare class ErrorResponseBody {
-    message: string;
-    errors?: any[];
-}