@pristine-ts/security 0.0.186 → 0.0.190

package/dist/types/guards/role.guard.d.ts

@@ -2,11 +2,35 @@ import { IdentityInterface } from "@pristine-ts/common";
 import { GuardInterface } from "../interfaces/guard.interface";
 import { GuardContextInterface } from "../interfaces/guard-context.interface";
 import { Request } from "@pristine-ts/common";
+/**
+ * The role guard is a guard that validates if the identity making the request has the required roles.
+ */
 export declare class RoleGuard implements GuardInterface {
     private readonly rolesClaimKey;
+    /**
+     * The keyname of the guard.
+     */
     keyname: string;
+    /**
+     * The context for the guard to use.
+     */
     guardContext?: GuardContextInterface;
+    /**
+     * The role guard is a guard that validates if the identity making the request has the required roles.
+     * @param rolesClaimKey The key in the claims of the access token where the roles are defined.
+     */
     constructor(rolesClaimKey: string);
+    /**
+     * Sets the context for the guard.
+     * @param context The context for the guard to use.
+     */
     setContext(context: any): Promise<void>;
+    /**
+     * Returns whether or not the guard authorizes the request.
+     * For the role guard, it validates that the identity making the request has the requested roles.
+     * The identity needs all of the requested roles to be authorized.
+     * @param request The request to authorize.
+     * @param identity The identity making the request.
+     */
     isAuthorized(request: Request, identity?: IdentityInterface): Promise<boolean>;
 }

package/dist/types/interfaces/authentication-manager.interface.d.ts

@@ -1,6 +1,17 @@
 import { DependencyContainer } from "tsyringe";
 import { IdentityInterface } from "@pristine-ts/common";
 import { Request } from "@pristine-ts/common";
+/**
+ * The Authentication Manager Interface defines what the authentication manager should implement.
+ * It facilitates mocking.
+ */
 export interface AuthenticationManagerInterface {
+    /**
+     * Authenticates a request.
+     * @param request The request.
+     * @param routeContext The context for the route.
+     * @param container The dependency container.
+     * @returns { IdentityInterface | undefined } The identity making the request if available. Otherwise undefined.
+     */
     authenticate(request: Request, routeContext: any, container: DependencyContainer): Promise<IdentityInterface | undefined>;
 }

package/dist/types/interfaces/authenticator-context.interface.d.ts

@@ -1,6 +1,18 @@
 import { AuthenticatorInterface } from "./authenticator.interface";
+/**
+ * The Authenticator Context Interface defines what the context of an authenticator should have.
+ */
 export interface AuthenticatorContextInterface {
+    /**
+     * The name of the constructor of the authenticator.
+     */
     constructorName: string;
+    /**
+     * The actual authenticator.
+     */
     authenticator: AuthenticatorInterface | Function;
+    /**
+     * The options to be used by the authenticator.
+     */
     options: any;
 }

package/dist/types/interfaces/authenticator.interface.d.ts

@@ -1,6 +1,15 @@
 import { IdentityInterface } from "@pristine-ts/common";
 import { ContextAwareInterface } from "@pristine-ts/common";
 import { Request } from "@pristine-ts/common";
+/**
+ * The Authenticator Interface defines what an authenticator should implement.
+ * It extends the ContextAwareInterface.
+ */
 export interface AuthenticatorInterface extends ContextAwareInterface {
+    /**
+     * Authenticates the request by providing the identity making the request if it exists.
+     * @param request The request to authenticate.
+     * @returns {IdentityInterface | undefined} The Identity making the request if it exists
+     */
     authenticate(request: Request): Promise<IdentityInterface | undefined>;
 }

package/dist/types/interfaces/authorizer-manager.interface.d.ts

@@ -1,6 +1,17 @@
 import { DependencyContainer } from "tsyringe";
 import { IdentityInterface } from "@pristine-ts/common";
 import { Request } from "@pristine-ts/common";
+/**
+ * The Authentication Manager Interface defines what the authentication manager should implement.
+ * It facilitates mocking.
+ */
 export interface AuthorizerManagerInterface {
+    /**
+     * Returns whether or not the request is authorized to access the route.
+     * @param request The request.
+     * @param routeContext The context associated with the route.
+     * @param container The dependency container.
+     * @param identity The identity making the request.
+     */
     isAuthorized(request: Request, routeContext: any, container: DependencyContainer, identity?: IdentityInterface): Promise<boolean>;
 }

package/dist/types/interfaces/guard-context.interface.d.ts

@@ -1,6 +1,19 @@
 import { GuardInterface } from "./guard.interface";
+/**
+ * The Guard Context Interface defines what a guard should implement.
+ * It extends the ContextAwareInterface.
+ */
 export interface GuardContextInterface {
+    /**
+     * The constructor name of the class of the guard.
+     */
     constructorName: string;
+    /**
+     * The actual guard.
+     */
     guard: GuardInterface | Function;
+    /**
+     * The options for the guard to use.
+     */
     options: any;
 }

package/dist/types/interfaces/guard.interface.d.ts

@@ -2,8 +2,23 @@ import { ContextAwareInterface } from "@pristine-ts/common";
 import { IdentityInterface } from "@pristine-ts/common";
 import { GuardContextInterface } from "./guard-context.interface";
 import { Request } from "@pristine-ts/common";
+/**
+ * The Guard Interface defines what a guard should implement.
+ * It extends the ContextAwareInterface.
+ */
 export interface GuardInterface extends ContextAwareInterface {
+    /**
+     * The keyname for the guard.
+     */
     keyname: string;
+    /**
+     * The context for the guard to use.
+     */
     guardContext?: GuardContextInterface;
+    /**
+     * Returns whether the guard authorizes the request to access the route or not.
+     * @param request The request ot authorize.
+     * @param identity The identity making the request.
+     */
     isAuthorized(request: Request, identity?: IdentityInterface): Promise<boolean>;
 }

package/dist/types/interfaces/identity-provider.interface.d.ts

@@ -1,4 +1,13 @@
 import { IdentityInterface } from "@pristine-ts/common";
+/**
+ * The Identity Provider Interface defines what an Identity provider should implement.
+ * This is useful if you need to define your own Identity object that extends the IdentityInterface.
+ * You can provide your own IdentityProvider.
+ */
 export interface IdentityProviderInterface {
+    /**
+     * Provides the identity from the base Identity that was extracted from the request.
+     * @param identity The identity that was extracted from the request.
+     */
     provide(identity: IdentityInterface): Promise<IdentityInterface>;
 }

package/dist/types/interfaces/interfaces.d.ts

@@ -1,6 +1,8 @@
 export * from "./authentication-manager.interface";
 export * from "./authenticator.interface";
+export * from "./authenticator-context.interface";
 export * from "./authorizer-manager.interface";
 export * from "./guard.interface";
 export * from "./guard-context.interface";
+export * from "./identity-provider.interface";
 export * from "./voter.interface";

package/dist/types/interfaces/voter.interface.d.ts

@@ -1,6 +1,20 @@
 import { VoteEnum } from "../enums/vote.enum";
 import { IdentityInterface } from "@pristine-ts/common";
+/**
+ * The voter interface defines what a voter should implement.
+ * A voter is used to vote whether or not the identity should be allowed to execute an action on a resource.
+ */
 export interface VoterInterface {
+    /**
+     * Whether or not the voter supports that type of resource.
+     * @param resource The resource.
+     */
     supports(resource: object): boolean;
+    /**
+     * Votes on whether or not the identity should be allowed to execute an action on a resource.
+     * @param identity The identity executing the action.
+     * @param action The action that the identity is trying to execute.
+     * @param resource The resource on which the action is executed.
+     */
     vote(identity: IdentityInterface, action: string, resource: object): Promise<VoteEnum>;
 }

package/dist/types/managers/authentication.manager.d.ts

@@ -5,10 +5,26 @@ import { LogHandlerInterface } from "@pristine-ts/logging";
 import { AuthenticatorFactory } from "../factories/authenticator.factory";
 import { IdentityProviderInterface } from "../interfaces/identity-provider.interface";
 import { Request } from "@pristine-ts/common";
+/**
+ * The authentication manager provides authentication by returning the identity executing the action.
+ * It is tagged and can be injected using AuthenticationManagerInterface which facilitates mocking.
+ */
 export declare class AuthenticationManager implements AuthenticationManagerInterface {
     private readonly identityProviders;
     private readonly logHandler;
     private readonly authenticatorFactory;
+    /**
+     * The authentication manager provides authentication by returning the identity executing the action.
+     * @param identityProviders The identity providers to use to provide the identity. All services tagged with ServiceDefinitionTagEnum.IdentityProvider will be injected here.
+     * @param logHandler The log handler to output logs.
+     * @param authenticatorFactory The factory to create the authenticator.
+     */
     constructor(identityProviders: IdentityProviderInterface[], logHandler: LogHandlerInterface, authenticatorFactory: AuthenticatorFactory);
+    /**
+     * Authenticates a request by providing the identity that made the request.
+     * @param request The request to authenticate
+     * @param routeContext The context associated with the route.
+     * @param container The dependency container from which to resolve the authenticator.
+     */
     authenticate(request: Request, routeContext: any, container: DependencyContainer): Promise<IdentityInterface | undefined>;
 }

package/dist/types/managers/authorizer.manager.d.ts

@@ -4,9 +4,25 @@ import { IdentityInterface } from "@pristine-ts/common";
 import { AuthorizerManagerInterface } from "../interfaces/authorizer-manager.interface";
 import { GuardFactory } from "../factories/guard.factory";
 import { Request } from "@pristine-ts/common";
+/**
+ * The authorizer manager provides authorization by authorizing the action.
+ * It is tagged and can be injected using AuthorizerManagerInterface which facilitates mocking.
+ */
 export declare class AuthorizerManager implements AuthorizerManagerInterface {
     private readonly logHandler;
     private readonly guardFactory;
+    /**
+     * The authorizer manager provides authorization by authorizing the action.
+     * @param logHandler The log handler to output logs.
+     * @param guardFactory The factory to create the guard.
+     */
     constructor(logHandler: LogHandlerInterface, guardFactory: GuardFactory);
+    /**
+     * Returns whether or not the request is authorized to access the route.
+     * @param request The request to authorize.
+     * @param routeContext The route context.
+     * @param container The dependency container to resolve the guard from.
+     * @param identity The identity making the request.
+     */
     isAuthorized(request: Request, routeContext: any, container: DependencyContainer, identity?: IdentityInterface): Promise<boolean>;
 }

package/dist/types/managers/managers.d.ts

@@ -1,3 +1,3 @@
-export * from "./authorizer.manager";
 export * from "./authentication.manager";
+export * from "./authorizer.manager";
 export * from "./permission.manager";

package/dist/types/managers/permission.manager.d.ts

@@ -2,9 +2,25 @@ import { VoterInterface } from "../interfaces/voter.interface";
 import { VotingStrategyEnum } from "../enums/voting-strategy.enum";
 import { LogHandlerInterface } from "@pristine-ts/logging";
 import { IdentityInterface } from "@pristine-ts/common";
+/**
+ * The permission manager verifies if the correct permission are there to access and take an action on a resource.
+ */
 export declare class PermissionManager {
     private readonly voters;
     private readonly logHandler;
+    /**
+     * The permission manager verifies if the correct permission are there to access and take an action on a resource.
+     * @param voters The voters that determine if access is granted.
+     * All services with the tag ServiceDefinitionTagEnum.Voter will be injected here
+     * @param logHandler The log handler to output logs.
+     */
     constructor(voters: VoterInterface[], logHandler: LogHandlerInterface);
+    /**
+     * Returns whether or not the permission manager grants access to the resource.
+     * @param identity The identity trying to have access to a resource.
+     * @param action The action trying to be executed on the resource.
+     * @param resource The resource being accessed.
+     * @param votingStrategy The voting strategy that defines how to merge the votes. Default is DenyOnUnanimousAbstention.
+     */
     hasAccessToResource(identity: IdentityInterface, action: string, resource: object, votingStrategy?: VotingStrategyEnum): Promise<boolean>;
 }

package/dist/types/providers/default-identity.provider.d.ts

@@ -1,7 +1,9 @@
 import { IdentityInterface } from "@pristine-ts/common";
 import { IdentityProviderInterface } from "../interfaces/identity-provider.interface";
 /**
+ * This default identity provider is here so that there is always at least one service tagged with IdentityProvider
  * Until there's a fix for: https://github.com/microsoft/tsyringe/issues/63
+ * It resolves the same identity it is passed.
  */
 export declare class DefaultIdentityProvider implements IdentityProviderInterface {
     provide(identity: IdentityInterface): Promise<IdentityInterface>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/security",
-  "version": "0.0.186",
+  "version": "0.0.190",
   "description": "",
   "module": "dist/lib/esm/security.module.js",
   "main": "dist/lib/cjs/security.module.js",
@@ -19,8 +19,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pristine-ts/common": "^0.0.186",
-    "@pristine-ts/logging": "^0.0.186"
+    "@pristine-ts/common": "^0.0.190",
+    "@pristine-ts/logging": "^0.0.190"
   },
   "devDependencies": {
     "@types/jsonwebtoken": "^8.5.0"
@@ -59,5 +59,5 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "2d4944c7529f632b6d3df2cb2954a99029977cb4"
+  "gitHead": "b3a54c2748face44898cbd15d479c72eea834719"
 }