fix(context): skip source scan for classes without a base class

packages/context/src/__tests__/unit/inject.unit.ts

@@ -4,6 +4,7 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {expect} from '@loopback/testlab';
+import {inherits} from 'util';
 import {
   Constructor,
   describeInjectedArguments,
@@ -105,6 +106,48 @@ describe('function argument injection', () => {
     expect(meta.map(m => m.bindingSelector)).to.deepEqual([]);
   });
 
+  it('does not read the source of a class without a base class', () => {
+    let sourceRead = false;
+    class TestClass {
+      static toString() {
+        sourceRead = true;
+        return '';
+      }
+
+      constructor(@inject('foo') foo: string) {}
+    }
+
+    const meta = describeInjectedArguments(TestClass);
+    expect(meta.map(m => m.bindingSelector)).to.deepEqual(['foo']);
+    expect(sourceRead).to.be.false();
+  });
+
+  it('does not inherit ctor args through a linked prototype chain', () => {
+    class BaseClass {
+      constructor(@inject('foo') foo: string) {}
+    }
+
+    class TestClass {
+      constructor(foo: string) {}
+    }
+    Object.setPrototypeOf(TestClass.prototype, BaseClass.prototype);
+
+    const meta = describeInjectedArguments(TestClass);
+    expect(meta).to.deepEqual([]);
+  });
+
+  it('inherits ctor args for a function linked with util.inherits', () => {
+    class BaseClass {
+      constructor(@inject('foo') foo: string) {}
+    }
+
+    function testFunction() {}
+    inherits(testFunction, BaseClass);
+
+    const meta = describeInjectedArguments(testFunction);
+    expect(meta.map(m => m.bindingSelector)).to.deepEqual(['foo']);
+  });
+
   // https://github.com/loopbackio/loopback-next/issues/2946
   it('allows custom decorator that returns a new constructor', () => {
     class HelloController {

packages/context/src/inject.ts

@@ -500,6 +500,20 @@ function findOrCreateBindingForInjection(
   return binding;
 }
 
+/**
+ * Check if the given class can inherit metadata from a base class. Besides
+ * `extends`, `Reflect.getMetadata` also follows a base class that is linked
+ * only through the `prototype` of the class.
+ *
+ * @param targetClass - Target class
+ */
+function hasBaseClass(targetClass: Object) {
+  if (Object.getPrototypeOf(targetClass) !== Function.prototype) return true;
+  const proto = (targetClass as {prototype?: object}).prototype;
+  const baseProto = proto && Object.getPrototypeOf(proto);
+  return baseProto != null && baseProto !== Object.prototype;
+}
+
 /**
  * Check if constructor injection should be applied to the base class
  * of the given target class
@@ -589,7 +603,7 @@ export function describeInjectedArguments(
   // Build the description
   const options: InspectionOptions = {};
   if (method === '') {
-    if (shouldSkipBaseConstructorInjection(target)) {
+    if (hasBaseClass(target) && shouldSkipBaseConstructorInjection(target)) {
       options.ownMetadataOnly = true;
     }
   } else if (Object.prototype.hasOwnProperty.call(target, method)) {