feat: Add metadata inspector

packages/authentication/src/decorators/authenticate.ts

@@ -3,7 +3,11 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Reflector, Constructor} from '@loopback/context';
+import {
+  MetadataInspector,
+  Constructor,
+  MethodDecoratorFactory,
+} from '@loopback/context';
 import {AuthenticationBindings} from '../keys';
 
 /**
@@ -21,18 +25,13 @@ export interface AuthenticationMetadata {
  * @param options Additional options to configure the authentication.
  */
 export function authenticate(strategyName: string, options?: Object) {
-  return function(controllerClass: Object, methodName: string) {
-    const metadataObj: AuthenticationMetadata = {
+  return MethodDecoratorFactory.createDecorator<AuthenticationMetadata>(
+    AuthenticationBindings.METADATA,
+    {
       strategy: strategyName,
       options: options || {},
-    };
-    Reflector.defineMetadata(
-      AuthenticationBindings.METADATA,
-      metadataObj,
-      controllerClass,
-      methodName,
-    );
-  };
+    },
+  );
 }
 
 /**
@@ -45,7 +44,7 @@ export function getAuthenticateMetadata(
   controllerClass: Constructor<{}>,
   methodName: string,
 ): AuthenticationMetadata | undefined {
-  return Reflector.getMetadata(
+  return MetadataInspector.getMethodMetadata<AuthenticationMetadata>(
     AuthenticationBindings.METADATA,
     controllerClass.prototype,
     methodName,

packages/context/src/inject.ts

@@ -4,9 +4,10 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {
-  Reflector,
+  MetadataInspector,
   ParameterDecoratorFactory,
   PropertyDecoratorFactory,
+  MetadataMap,
 } from '@loopback/metadata';
 import {BoundValue, ValueOrPromise} from './binding';
 import {Context} from './context';
@@ -186,9 +187,12 @@ export function describeInjectedArguments(
   method?: string | symbol,
 ): Injection[] {
   method = method || '';
-  const meta = Reflector.getMetadata(PARAMETERS_KEY, target);
-  if (meta == null) return [];
-  return meta[method] || [];
+  const meta = MetadataInspector.getAllParameterMetadata<Injection>(
+    PARAMETERS_KEY,
+    target,
+    method,
+  );
+  return meta || [];
 }
 
 /**
@@ -199,8 +203,11 @@ export function describeInjectedArguments(
 export function describeInjectedProperties(
   // tslint:disable-next-line:no-any
   target: any,
-): {[p: string]: Injection} {
-  const metadata: {[name: string]: Injection} =
-    Reflector.getMetadata(PROPERTIES_KEY, target) || {};
+): MetadataMap<Injection> {
+  const metadata =
+    MetadataInspector.getAllPropertyMetadata<Injection>(
+      PROPERTIES_KEY,
+      target,
+    ) || {};
   return metadata;
 }

packages/metadata/src/decorator-factory.ts

@@ -6,7 +6,7 @@
 import {Reflector} from './reflect';
 import * as _ from 'lodash';
 import * as debugModule from 'debug';
-const debug = debugModule('loopback:decorator');
+const debug = debugModule('loopback:metadata:decorator');
 
 // tslint:disable:no-any
 

packages/metadata/src/index.ts

@@ -5,3 +5,4 @@
 
 export * from './reflect';
 export * from './decorator-factory';
+export * from './inspector';

packages/metadata/src/inspector.ts

@@ -0,0 +1,166 @@
+// Copyright IBM Corp. 2013,2017. All Rights Reserved.
+// Node module: @loopback/metadata
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Reflector, NamespacedReflect} from './reflect';
+import {MetadataMap} from './decorator-factory';
+
+const TSReflector = new NamespacedReflect();
+
+/**
+ * Design time metadata for a method
+ */
+export interface DesignTimeMethodMetadata {
+  type: Function;
+  parameterTypes: Function[];
+  returnType: Function;
+}
+
+/**
+ * Inspector for metadata applied by decorators
+ */
+export class MetadataInspector {
+  /**
+   * Get the metadata associated with the given key for a given class
+   * @param key Metadata key
+   * @param target Class that contains the metadata
+   */
+  static getClassMetadata<T>(key: string, target: Function): T | undefined {
+    return Reflector.getMetadata(key, target);
+  }
+
+  /**
+   * Get the metadata associated with the given key for all methods of the
+   * target class or prototype
+   * @param key Metadata key
+   * @param target Class for static methods or prototype for instance methods
+   */
+  static getAllMethodMetadata<T>(
+    key: string,
+    target: Object,
+  ): MetadataMap<T> | undefined {
+    return Reflector.getMetadata(key, target);
+  }
+
+  /**
+   * Get the metadata associated with the given key for a given method of the
+   * target class or prototype
+   * @param key Metadata key
+   * @param target Class for static methods or prototype for instance methods
+   * @param methodName Method name. If not present, default to '' to use
+   * the constructor
+   */
+  static getMethodMetadata<T>(
+    key: string,
+    target: Object,
+    methodName?: string | symbol,
+  ): T | undefined {
+    methodName = methodName || '';
+    const meta: MetadataMap<T> = Reflector.getMetadata(key, target);
+    return meta && meta[methodName];
+  }
+
+  /**
+   * Get the metadata associated with the given key for all properties of the
+   * target class or prototype
+   * @param key Metadata key
+   * @param target Class for static methods or prototype for instance methods
+   */
+  static getAllPropertyMetadata<T>(
+    key: string,
+    target: Object,
+  ): MetadataMap<T> | undefined {
+    return Reflector.getMetadata(key, target);
+  }
+
+  /**
+   * Get the metadata associated with the given key for a given property of the
+   * target class or prototype
+   * @param key Metadata key
+   * @param target Class for static properties or prototype for instance
+   * properties
+   * @param propertyName Property name
+   */
+  static getPropertyMetadata<T>(
+    key: string,
+    target: Object,
+    propertyName: string | symbol,
+  ): T | undefined {
+    const meta: MetadataMap<T> = Reflector.getMetadata(key, target);
+    return meta && meta[propertyName];
+  }
+
+  /**
+   * Get the metadata associated with the given key for all parameters of a
+   * given method
+   * @param key Metadata key
+   * @param target Class for static methods or prototype for instance methods
+   * @param methodName Method name. If not present, default to '' to use
+   * the constructor
+   */
+  static getAllParameterMetadata<T>(
+    key: string,
+    target: Object,
+    methodName?: string | symbol,
+  ): T[] | undefined {
+    methodName = methodName || '';
+    const meta: MetadataMap<T[]> = Reflector.getMetadata(key, target);
+    return meta && meta[methodName];
+  }
+
+  /**
+   * Get the metadata associated with the given key for a parameter of a given
+   * method by index
+   * @param key Metadata key
+   * @param target Class for static methods or prototype for instance methods
+   * @param methodName Method name. If not present, default to '' to use
+   * the constructor
+   * @param index Index of the parameter, starting with 0
+   */
+  static getParameterMetadata<T>(
+    key: string,
+    target: Object,
+    methodName: string | symbol,
+    index: number,
+  ): T | undefined {
+    methodName = methodName || '';
+    const meta: MetadataMap<T[]> = Reflector.getMetadata(key, target);
+    const params = meta && meta[methodName];
+    return params && params[index];
+  }
+
+  /**
+   * Get TypeScript design time type for the property
+   * @param target Class or prototype
+   * @param propertyName Property name
+   */
+  static getDesignTypeForProperty(
+    target: Object,
+    propertyName: string | symbol,
+  ): Function {
+    return TSReflector.getMetadata('design:type', target, propertyName);
+  }
+
+  static getDesignTypeForMethod(
+    target: Object,
+    methodName: string | symbol,
+  ): DesignTimeMethodMetadata {
+    const type = TSReflector.getMetadata('design:type', target, methodName);
+    const parameterTypes = TSReflector.getMetadata(
+      'design:paramtypes',
+      target,
+      methodName,
+    );
+    const returnType = TSReflector.getMetadata(
+      'design:returntype',
+      target,
+      methodName,
+    );
+    return {
+      type,
+      parameterTypes,
+      returnType,
+    };
+  }
+}

packages/metadata/test/unit/decorator-factory.ts → packages/metadata/test/unit/decorator-factory.test.ts

@@ -5,14 +5,15 @@
 
 import {expect} from '@loopback/testlab';
 import {
-  Reflector,
   ClassDecoratorFactory,
   PropertyDecoratorFactory,
   MethodDecoratorFactory,
   ParameterDecoratorFactory,
   DecoratorFactory,
 } from '../..';
 
+import {Reflector} from '../../src/reflect';
+
 describe('ClassDecoratorFactory', () => {
   /**
    * Define `@classDecorator(spec)`