Acerca de @clavisco/guard

Token: Guard

Permite agregar guards generales para autenticación, permisos de enrutamiento y acceso a componentes

¿Qué resuelve?

Define un ambiente estandar para validar los permisos, la validéz de las sesiones de usuario y realizar de forma mas limpia el enrutamiento hacia las vistas habilitadas para una sesión

Dependencias

• @clavisco/core
• @clavisco/linker

Providers disponibles

GetRoutesGuardFactory (Opcional)

Debe indicar una instancia del servicio que proveera la información de las rutas, es requerido que el servicio indicado implemente la interface Guard.Route.Interfaces.IGetRoutesFactory e indicar las dependencias (si las tiene), como se muestra en el ejemplo:

const GetRoutesServiceFactory = (http: HttpClient) => new GetRoutesService(http);
...
{
    provide: 'GetRoutesGuardFactory',
    useFactory: GetRoutesServiceFactory,
    deps: [ HttpClient ]
}

ValidateRouteGuardFactory (Opcional)

Debe indicar una instancia del servicio que proveera la validación para las rutas, es requerido que el servicio indicado implemente la interface Guard.Route.Interfaces.IValidateRouteFactory e indicar las dependencias (si las tiene), como se muestra en el ejemplo:

const ValidateRouteServiceFactory = () => new ValidateRouteService();
...
{
    provide: 'ValidateRouteGuardFactory',
    useFactory: ValidateRouteServiceFactory
}

GetPermissionsGuardFactory (Opcional)

Debe indicar una instancia del servicio que proveera la información de los permisos, es requerido que el servicio indicado implemente la interface Guard.Route.Interfaces.IGetPermissionsFactory e indicar las dependencias (si las tiene), como se muestra en el ejemplo:

const GetPermissionsServiceFactory = (http: HttpClient) => new GetPermissionsService(http);

...
{
    provide: 'GetPermissionsGuardFactory',
    useFactory: GetPermissionsServiceFactory,
    deps: [ HttpClient ]
}

ValidatePermissionGuardFactory (Opcional)

Debe indicar una instancia del servicio que proveera la validación para los permisos, es requerido que el servicio indicado implemente la interface Guard.Route.Interfaces.IValidatePermisionFactory e indicar las dependencias (si las tiene), como se muestra en el ejemplo:

const ValidatePermissionServiceFactory = () => new ValidatePermissionService();
...
{
    provide: 'ValidatePermissionGuardFactory',
    useFactory: ValidatePermissionServiceFactory
}

GetSessionGuardFactory (Opcional)

Debe indicar una instancia del servicio que proveera la información de la sesión actual del usuario, es requerido que el servicio indicado implemente la interface Guard.Auth.Interfaces.IGetSessionFactory e indicar las dependencias (si las tiene), como se muestra en el ejemplo:

const GetSessionServiceFactory = (http: HttpClient) => new GetSessionService(http);
...
{
    provide: 'GetSessionGuardFactory',
    useFactory: GetSessionServiceFactory,
    deps: [ HttpClient ]
}

ValidateSessionGuardFactory (Opcional)

Debe indicar una instancia del servicio que proveera la validación para la sesión del usuario actual, es requerido que el servicio indicado implemente la interface Guard.Auth.Interfaces.IValidateSessionFactory e indicar las dependencias (si las tiene), como se muestra en el ejemplo:

const ValidateSessionServiceFactory = () => new ValidateSessionService();
...
{
    provide: 'ValidateSessionGuardFactory',
    useFactory: ValidateSessionServiceFactory
}

GuardOptions (Opcional*)

* Este provider es opcional si se especifican los providers GetRoutesGuardFactory, GetPermissionsGuardFactory y/o GetSessionGuardFactory, o si alguna de estas caracteristicas no se desea utilizar.

Cuando se indica este provider esta implementando un comportamiento estandar en la validación de rutas, permisos o sesiones, para ello solo debe indicar la fuente de datos para la lista de rutas, permisos o sesión mediante la activacion de la opcion correspondiente como se muestra en el ejemplo:

{
    provide: 'GuardOptions',
    useValue: {
        // Sesiones
        Auth: {
          Key: 'Session',
          Storage: 'local',
          Expire: 'ExpireTime',
          Token: 'access_token',
          Redirect: '/login'
        },
        // Rutas o enrutamiento
        Routes: {
          Key: 'NotNecesaryWhenFactory',
          Storage: 'factory',
          Redirect: '401'
        },
        // Permisos o accesos
        Permissions: {
          Key: 'PermissionsKey',
          Storage: 'local',
          Redirect: '401'
        }
    }
},

Todos los atributos en este provider son opcionales, tomando en cuenta las indicaciones previas.

El formato esperado para la implementacion estandar esta definido por las interfaces IRouteElement e IPermissionElement para rutas y permisos respectivamente, en el caso de las sesiones como no es posible definir un estandar para el default se definen como any, pero es necesario especificar el Key del Expire y Token, como se muestra en el ejemplo.

Autentication Interceptor

Debido a que un guard no suele ser suficiente para validar los accesos no autorizados, ya sea por token vencido o incorrectos se crea el siguiente interceptor el cual se encarga de validar las respuestas con estatus 401 y desviar la aplicación hacia la ruta definida en el Redirect del GuardOptions.Auth segun se desee realizar la validacion, cabe destacar que no es obligatorio, pero si recomendado

import { AuthGuardInterceptor } from '@clavisco/guard';
...
{ provide: HTTP_INTERCEPTORS, useClass: AuthGuardInterceptor, multi: true }
...

¿Cómo lo uso?

1. Primero debemos cumplir las depencias mencionadas al inicio de este documento
2. Ejecutar el comando npm i @clavisco/guard en el directorio root del proyecto
3. En el respectivo modulo de rutas solo debe indicar el o los guards que desea implementar para un modulo, vista o componente como se muestrar en el siguiente ejemplo:

import { RouteGuard, PermissionGuard, AuthGuard } from '@clavisco/guard';

const routes: Routes = [
    ...
    { path: 'home', component: HomeComponent, canActivate: [ RouteGuard, AuthGuard ] },
    { path: 'users', component: UserComponent, canActivate: [ PermissionGuard ] },
    { path: 'invoice', component: InvoiceComponent, canActivate: [ RouteGuard, PermissionGuard ] },
   ...
]

4. Implemente el o los providers que desee aplicar segun corresponda a la configuracion deseada, una configuracion estandar puede ser la siguiente:

{
    provide: 'GuardOptions',
    useValue: {
        // Sesiones
        Auth: {
          Key: 'Session',
          Storage: 'local',
          Expire: 'ExpireTime',
          Token: 'access_token',
          Redirect: '/login'
        },
        // Rutas o enrutamiento
        Routes: {
          Key: 'NotNecesaryWhenFactory',
          Storage: 'factory',
          Redirect: '/401'
        },
        // Permisos o accesos
        Permissions: {
          Key: 'PermissionsKey',
          Storage: 'local',
          Redirect: '/401'
        }
    }
},

5. Agregar el autentication intercepto a la lista de interceptores para el modulo donde desee aplicar el componente, como se muestra en el siguiente ejemplo:

import { AuthGuardInterceptor } from '@clavisco/guard';
...
{ provide: HTTP_INTERCEPTORS, useClass: AuthGuardInterceptor, multi: true }
...

8. Ya con esto tenemos una implementación básica con el uso de guards para permisos, enrutamiento y autenticación
9. Video explicativo sobre el uso @clavisco/guard

Clavis Consultores ©