[FEATURE] add support for reflections and guards

lib/index.ts

@@ -19,3 +19,4 @@ export * from './validator';
 export * from './config/service';
 export * from './foundation';
 export { registerAs } from '@nestjs/config';
+export * from './reflections';

lib/reflections/index.ts

@@ -0,0 +1,2 @@
+export * from './reflector';
+export * from './setMetadata';

lib/reflections/reflector.ts

@@ -0,0 +1,117 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import 'reflect-metadata';
+import { ulid } from 'ulid';
+import { Obj } from '../utils';
+
+/**
+ * Reflector is a class to easily fetch metadata from a class and request handler method
+ * at the runtime.
+ */
+export class Reflector {
+  constructor(
+    private cls: any,
+    private handler?: Function,
+  ) {}
+
+  /**
+   * Gets the metadata from the `handler` method and `handler's class`,
+   * if the metadata from the handler is not empty, then return the handler data.
+   * Otherwise, return the class' metadata.
+   *
+   * @param keyOrDecorator
+   * @returns
+   */
+  allAndOverride<T = any>(keyOrDecorator: string | Object): T {
+    const decoratorKey =
+      typeof keyOrDecorator === 'function'
+        ? keyOrDecorator['KEY']
+        : keyOrDecorator;
+
+    const dataFromHandler = Reflect.getMetadata(decoratorKey, this.handler);
+    const dataFromClass = Reflect.getMetadata(decoratorKey, this.cls);
+    return dataFromHandler || dataFromClass;
+  }
+
+  /**
+   * Gets the metadata from the `handler` method and `handler's class`
+   * and merges it. It can currently merge the array and objects.
+   *
+   * @param keyOrDecorator string | Object
+   * @returns
+   */
+  allAndMerge<T = any>(keyOrDecorator: string | Object): T {
+    const decoratorKey =
+      typeof keyOrDecorator === 'function'
+        ? keyOrDecorator['KEY']
+        : keyOrDecorator;
+
+    const dataFromHandler = Reflect.getMetadata(decoratorKey, this.handler);
+    const dataFromClass = Reflect.getMetadata(decoratorKey, this.cls);
+
+    if (Array.isArray(dataFromHandler) && Array.isArray(dataFromClass)) {
+      return dataFromHandler.concat(dataFromClass) as T;
+    }
+
+    if (Obj.isObj(dataFromHandler) && Obj.isObj(dataFromClass)) {
+      return { ...dataFromClass, ...dataFromHandler } as T;
+    }
+
+    return [dataFromClass, dataFromHandler] as T;
+  }
+
+  /**
+   * Gets the metadata from the `handler's class` and returns it.
+   * @param keyOrDecorator
+   * @param defaultValue
+   * @returns
+   */
+  getFromClass<T = any>(keyOrDecorator: string | Object, defaultValue?: T): T {
+    const key =
+      typeof keyOrDecorator === 'function'
+        ? keyOrDecorator['KEY']
+        : keyOrDecorator;
+
+    const data = Reflect.getMetadata(key, this.cls);
+    return data || defaultValue;
+  }
+
+  /**
+   * Gets the metadata from the `handler` method and returns it.
+   * @param keyOrDecorator string
+   * @param defaultValue T
+   * @returns
+   */
+  getFromMethod<T = any>(keyOrDecorator: string | Object, defaultValue?: T): T {
+    const key =
+      typeof keyOrDecorator === 'function'
+        ? keyOrDecorator['KEY']
+        : keyOrDecorator;
+
+    const data = Reflect.getMetadata(key, this.handler);
+    return data || defaultValue;
+  }
+
+  /**
+   * A shorthand to create a decorator for quickly setting metadata
+   * on controllers and methods.
+   * @param decoratorKey string
+   * @returns
+   */
+  public static createDecorator<TParam>(decoratorKey?: string) {
+    const metadataKey = decoratorKey || ulid();
+    const decoratorFn =
+      (metadataValue: TParam) =>
+      (target: object | Function, key?: string | symbol, descriptor?: any) => {
+        if (descriptor) {
+          Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
+          return descriptor;
+        }
+
+        Reflect.defineMetadata(metadataKey, metadataValue, target);
+        return target;
+      };
+
+    decoratorFn.KEY = metadataKey;
+    return decoratorFn;
+  }
+}

lib/reflections/setMetadata.ts

@@ -0,0 +1,22 @@
+/* eslint-disable @typescript-eslint/ban-types */
+export const SetMetadata = <K = string, V = any>(
+  metadataKey: K,
+  metadataValue: V,
+) => {
+  const decoratorFn = (
+    target: object | Function,
+    key?: string | symbol,
+    descriptor?: any,
+  ) => {
+    if (descriptor) {
+      Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
+      return descriptor;
+    }
+
+    Reflect.defineMetadata(metadataKey, metadataValue, target);
+    return target;
+  };
+
+  decoratorFn.KEY = metadataKey;
+  return decoratorFn;
+};

lib/rest/foundation/guards/baseGuard.ts

@@ -1,15 +1,30 @@
-import { CanActivate, ExecutionContext, Inject } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
+import { CanActivate, ExecutionContext } from '@nestjs/common';
 import { Request, Response } from '../interface';
+import { Reflector } from '../../../reflections';
 
 export abstract class IntentGuard implements CanActivate {
-  @Inject()
-  private reflector: Reflector;
-
   async canActivate(context: ExecutionContext): Promise<boolean> {
+    /**
+     * Get Express Request Object
+     */
     const expressRequest = context.switchToHttp().getRequest();
-    return this.boot(expressRequest, expressRequest);
+
+    /**
+     * Get Express Response Object
+     */
+    const expressResponse = context.switchToHttp().getResponse();
+
+    /**
+     * Initialise a new Reflector class.
+     */
+    const reflector = new Reflector(context.getClass(), context.getHandler());
+
+    return this.guard(expressRequest, expressResponse, reflector);
   }
 
-  abstract boot(req: Request, res: Response): boolean | Promise<boolean>;
+  abstract guard(
+    req: Request,
+    res: Response,
+    reflector: Reflector,
+  ): boolean | Promise<boolean>;
 }