Add getClassMetadataFromMetadataReader

.changeset/tough-suits-repeat.md

@@ -0,0 +1,5 @@
+---
+"@inversifyjs/core": minor
+---
+
+Added `getClassMetadataFromMetadataReader`.

packages/container/libraries/core/src/index.ts

@@ -1,4 +1,5 @@
 import { getClassMetadata } from './metadata/calculations/getClassMetadata';
+import { getClassMetadataFromMetadataReader } from './metadata/calculations/getClassMetadataFromMetadataReader';
 import { ClassElementMetadata } from './metadata/models/ClassElementMetadata';
 import { ClassElementMetadataKind } from './metadata/models/ClassElementMetadataKind';
 import { ClassMetadata } from './metadata/models/ClassMetadata';
@@ -20,4 +21,8 @@ export type {
   UnmanagedClassElementMetadata,
 };
 
-export { ClassElementMetadataKind, getClassMetadata };
+export {
+  ClassElementMetadataKind,
+  getClassMetadata,
+  getClassMetadataFromMetadataReader,
+};

packages/container/libraries/core/src/metadata/calculations/getClassMetadata.spec.ts

@@ -7,6 +7,9 @@ import { getReflectMetadata } from '@inversifyjs/reflect-metadata-utils';
 jest.mock('./getClassMetadataConstructorArguments');
 jest.mock('./getClassMetadataProperties');
 
+import { Newable } from '@inversifyjs/common';
+
+import { POST_CONSTRUCT, PRE_DESTROY } from '../../reflectMetadata/data/keys';
 import { ClassElementMetadata } from '../models/ClassElementMetadata';
 import { ClassElementMetadataKind } from '../models/ClassElementMetadataKind';
 import { ClassMetadata } from '../models/ClassMetadata';
@@ -22,6 +25,8 @@ describe(getClassMetadata.name, () => {
     let postConstructMetadataFixture: LegacyMetadata;
     let preDestroyMetadataFixture: LegacyMetadata;
 
+    let typeFixture: Newable;
+
     let result: unknown;
 
     beforeAll(() => {
@@ -55,6 +60,8 @@ describe(getClassMetadata.name, () => {
         value: 'pre-destroy-value-fixture',
       };
 
+      typeFixture = class {};
+
       (
         getClassMetadataConstructorArguments as jest.Mock<
           typeof getClassMetadataConstructorArguments
@@ -71,13 +78,39 @@ describe(getClassMetadata.name, () => {
         .mockReturnValueOnce(postConstructMetadataFixture)
         .mockReturnValueOnce(preDestroyMetadataFixture);
 
-      result = getClassMetadata(class {});
+      result = getClassMetadata(typeFixture);
     });
 
     afterAll(() => {
       jest.clearAllMocks();
     });
 
+    it('should call getReflectMetadata()', () => {
+      expect(getReflectMetadata).toHaveBeenCalledTimes(2);
+      expect(getReflectMetadata).toHaveBeenNthCalledWith(
+        1,
+        typeFixture,
+        POST_CONSTRUCT,
+      );
+      expect(getReflectMetadata).toHaveBeenNthCalledWith(
+        2,
+        typeFixture,
+        PRE_DESTROY,
+      );
+    });
+
+    it('should call getClassMetadataConstructorArguments()', () => {
+      expect(getClassMetadataConstructorArguments).toHaveBeenCalledTimes(1);
+      expect(getClassMetadataConstructorArguments).toHaveBeenCalledWith(
+        typeFixture,
+      );
+    });
+
+    it('should call getClassMetadataProperties()', () => {
+      expect(getClassMetadataProperties).toHaveBeenCalledTimes(1);
+      expect(getClassMetadataProperties).toHaveBeenCalledWith(typeFixture);
+    });
+
     it('should return ClassMetadata', () => {
       const expected: ClassMetadata = {
         constructorArguments: constructorArgumentsMetadataFixture,

packages/container/libraries/core/src/metadata/calculations/getClassMetadataConstructorArgumentsFromMetadataReader.spec.ts

@@ -0,0 +1,246 @@
+import { afterAll, beforeAll, describe, expect, it, jest } from '@jest/globals';
+
+import { Newable } from '@inversifyjs/common';
+
+jest.mock('./getClassElementMetadataFromLegacyMetadata');
+jest.mock('./getClassElementMetadataFromNewable');
+
+import { ClassElementMetadata } from '../models/ClassElementMetadata';
+import { ClassElementMetadataKind } from '../models/ClassElementMetadataKind';
+import { LegacyMetadata } from '../models/LegacyMetadata';
+import { LegacyMetadataMap } from '../models/LegacyMetadataMap';
+import { LegacyMetadataReader } from '../models/LegacyMetadataReader';
+import { getClassElementMetadataFromLegacyMetadata } from './getClassElementMetadataFromLegacyMetadata';
+import { getClassElementMetadataFromNewable } from './getClassElementMetadataFromNewable';
+import { getClassMetadataConstructorArgumentsFromMetadataReader } from './getClassMetadataConstructorArgumentsFromMetadataReader';
+
+describe(getClassMetadataConstructorArgumentsFromMetadataReader.name, () => {
+  describe('when called, and getReflectMetadata() provides typescript metadata', () => {
+    let typescriptTypeFixture: Newable;
+
+    let typeFixture: Newable;
+    let metadataReaderMock: jest.Mocked<LegacyMetadataReader>;
+
+    let classElementMetadataFixture: ClassElementMetadata;
+
+    let result: unknown;
+
+    beforeAll(() => {
+      typescriptTypeFixture = class {};
+
+      typeFixture = class {};
+      metadataReaderMock = {
+        getConstructorMetadata: jest.fn(),
+        getPropertiesMetadata: jest.fn(),
+      };
+
+      classElementMetadataFixture = {
+        kind: ClassElementMetadataKind.unmanaged,
+      };
+
+      metadataReaderMock.getConstructorMetadata.mockReturnValueOnce({
+        compilerGeneratedMetadata: [typescriptTypeFixture],
+        userGeneratedMetadata: {},
+      });
+
+      (
+        getClassElementMetadataFromNewable as jest.Mock<
+          typeof getClassElementMetadataFromNewable
+        >
+      ).mockReturnValueOnce(classElementMetadataFixture);
+
+      result = getClassMetadataConstructorArgumentsFromMetadataReader(
+        typeFixture,
+        metadataReaderMock,
+      );
+    });
+
+    afterAll(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should call metadataReader.getConstructorMetadata()', () => {
+      expect(metadataReaderMock.getConstructorMetadata).toHaveBeenCalledTimes(
+        1,
+      );
+      expect(metadataReaderMock.getConstructorMetadata).toHaveBeenCalledWith(
+        typeFixture,
+      );
+    });
+
+    it('should call getClassElementMetadataFromNewable()', () => {
+      expect(getClassElementMetadataFromNewable).toHaveBeenCalledTimes(1);
+      expect(getClassElementMetadataFromNewable).toHaveBeenCalledWith(
+        typescriptTypeFixture,
+      );
+    });
+
+    it('should return ClassElementMetadata[]', () => {
+      expect(result).toStrictEqual([classElementMetadataFixture]);
+    });
+  });
+
+  describe('when called, and getReflectMetadata() provides tag metadata', () => {
+    let legacyMetadataMapPropertyFixture: string | symbol;
+    let legacyMetadataListFixture: LegacyMetadata[];
+
+    let typeFixture: Newable;
+    let metadataReaderMock: jest.Mocked<LegacyMetadataReader>;
+
+    let classElementMetadataFixture: ClassElementMetadata;
+
+    let result: unknown;
+
+    beforeAll(() => {
+      legacyMetadataMapPropertyFixture = '0';
+      legacyMetadataListFixture = [
+        {
+          key: 'key-fixture',
+          value: 'value-fixture',
+        },
+      ];
+
+      const legacyMetadataMap: LegacyMetadataMap = {
+        [legacyMetadataMapPropertyFixture]: legacyMetadataListFixture,
+      };
+
+      typeFixture = class {};
+      metadataReaderMock = {
+        getConstructorMetadata: jest.fn(),
+        getPropertiesMetadata: jest.fn(),
+      };
+
+      classElementMetadataFixture = {
+        kind: ClassElementMetadataKind.unmanaged,
+      };
+
+      metadataReaderMock.getConstructorMetadata.mockReturnValueOnce({
+        compilerGeneratedMetadata: undefined,
+        userGeneratedMetadata: legacyMetadataMap,
+      });
+
+      (
+        getClassElementMetadataFromLegacyMetadata as jest.Mock<
+          typeof getClassElementMetadataFromLegacyMetadata
+        >
+      ).mockReturnValueOnce(classElementMetadataFixture);
+
+      result = getClassMetadataConstructorArgumentsFromMetadataReader(
+        typeFixture,
+        metadataReaderMock,
+      );
+    });
+
+    afterAll(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should call metadataReader.getConstructorMetadata()', () => {
+      expect(metadataReaderMock.getConstructorMetadata).toHaveBeenCalledTimes(
+        1,
+      );
+      expect(metadataReaderMock.getConstructorMetadata).toHaveBeenCalledWith(
+        typeFixture,
+      );
+    });
+
+    it('should call getClassElementMetadataFromLegacyMetadata()', () => {
+      expect(getClassElementMetadataFromLegacyMetadata).toHaveBeenCalledTimes(
+        1,
+      );
+      expect(getClassElementMetadataFromLegacyMetadata).toHaveBeenCalledWith(
+        legacyMetadataListFixture,
+      );
+    });
+
+    it('should return ClassElementMetadata[]', () => {
+      expect(result).toStrictEqual([classElementMetadataFixture]);
+    });
+  });
+
+  describe('when called, and getReflectMetadata() provides both typescript and tag metadata', () => {
+    let legacyMetadataMapPropertyFixture: string | symbol;
+    let legacyMetadataListFixture: LegacyMetadata[];
+
+    let typescriptTypeFixture: Newable;
+
+    let typeFixture: Newable;
+    let metadataReaderMock: jest.Mocked<LegacyMetadataReader>;
+
+    let classElementMetadataFixture: ClassElementMetadata;
+
+    let result: unknown;
+
+    beforeAll(() => {
+      legacyMetadataMapPropertyFixture = '0';
+      legacyMetadataListFixture = [
+        {
+          key: 'key-fixture',
+          value: 'value-fixture',
+        },
+      ];
+
+      const legacyMetadataMap: LegacyMetadataMap = {
+        [legacyMetadataMapPropertyFixture]: legacyMetadataListFixture,
+      };
+
+      typescriptTypeFixture = class {};
+
+      typeFixture = class {};
+      metadataReaderMock = {
+        getConstructorMetadata: jest.fn(),
+        getPropertiesMetadata: jest.fn(),
+      };
+
+      classElementMetadataFixture = {
+        kind: ClassElementMetadataKind.unmanaged,
+      };
+
+      metadataReaderMock.getConstructorMetadata.mockReturnValueOnce({
+        compilerGeneratedMetadata: [typescriptTypeFixture],
+        userGeneratedMetadata: legacyMetadataMap,
+      });
+
+      (
+        getClassElementMetadataFromLegacyMetadata as jest.Mock<
+          typeof getClassElementMetadataFromLegacyMetadata
+        >
+      ).mockReturnValueOnce(classElementMetadataFixture);
+
+      result = getClassMetadataConstructorArgumentsFromMetadataReader(
+        typeFixture,
+        metadataReaderMock,
+      );
+    });
+
+    afterAll(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should call metadataReader.getConstructorMetadata()', () => {
+      expect(metadataReaderMock.getConstructorMetadata).toHaveBeenCalledTimes(
+        1,
+      );
+      expect(metadataReaderMock.getConstructorMetadata).toHaveBeenCalledWith(
+        typeFixture,
+      );
+    });
+
+    it('should call getClassElementMetadataFromLegacyMetadata()', () => {
+      expect(getClassElementMetadataFromLegacyMetadata).toHaveBeenCalledTimes(
+        1,
+      );
+      expect(getClassElementMetadataFromLegacyMetadata).toHaveBeenCalledWith(
+        legacyMetadataListFixture,
+      );
+    });
+
+    it('should not call getClassElementMetadataFromNewable()', () => {
+      expect(getClassElementMetadataFromNewable).not.toHaveBeenCalled();
+    });
+
+    it('should return ClassElementMetadata[]', () => {
+      expect(result).toStrictEqual([classElementMetadataFixture]);
+    });
+  });
+});

packages/container/libraries/core/src/metadata/calculations/getClassMetadataConstructorArgumentsFromMetadataReader.ts

@@ -0,0 +1,47 @@
+import { Newable } from '@inversifyjs/common';
+
+import { ClassElementMetadata } from '../models/ClassElementMetadata';
+import { LegacyConstructorMetadata } from '../models/LegacyConstructorMetadata';
+import { LegacyMetadataReader } from '../models/LegacyMetadataReader';
+import { getClassElementMetadataFromLegacyMetadata } from './getClassElementMetadataFromLegacyMetadata';
+import { getClassElementMetadataFromNewable } from './getClassElementMetadataFromNewable';
+
+export function getClassMetadataConstructorArgumentsFromMetadataReader<
+  TInstance,
+  TArgs extends unknown[],
+>(
+  type: Newable<TInstance, TArgs>,
+  metadataReader: LegacyMetadataReader,
+): ClassElementMetadata[] {
+  const legacyConstructorMetadata: LegacyConstructorMetadata =
+    metadataReader.getConstructorMetadata(type);
+
+  const constructorArgumentsMetadata: ClassElementMetadata[] = [];
+
+  for (const [stringifiedIndex, metadataList] of Object.entries(
+    legacyConstructorMetadata.userGeneratedMetadata,
+  )) {
+    const index: number = parseInt(stringifiedIndex);
+
+    constructorArgumentsMetadata[index] =
+      getClassElementMetadataFromLegacyMetadata(metadataList);
+  }
+
+  if (legacyConstructorMetadata.compilerGeneratedMetadata !== undefined) {
+    for (
+      let i: number = 0;
+      i < legacyConstructorMetadata.compilerGeneratedMetadata.length;
+      ++i
+    ) {
+      if (constructorArgumentsMetadata[i] === undefined) {
+        const typescriptMetadata: Newable = legacyConstructorMetadata
+          .compilerGeneratedMetadata[i] as Newable;
+
+        constructorArgumentsMetadata[i] =
+          getClassElementMetadataFromNewable(typescriptMetadata);
+      }
+    }
+  }
+
+  return constructorArgumentsMetadata;
+}