From 60c8c3ac280df906891a344014fab3123f640f2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roberto=20Pintos=20L=C3=B3pez?= Date: Sat, 2 Nov 2024 18:55:59 +0100 Subject: [PATCH 1/6] refactor(core): add LegacyMetadataReader --- .../src/metadata/models/LegacyConstructorMetadata.ts | 6 ++++++ .../core/src/metadata/models/LegacyMetadataReader.ts | 9 +++++++++ 2 files changed, 15 insertions(+) create mode 100644 packages/container/libraries/core/src/metadata/models/LegacyConstructorMetadata.ts create mode 100644 packages/container/libraries/core/src/metadata/models/LegacyMetadataReader.ts diff --git a/packages/container/libraries/core/src/metadata/models/LegacyConstructorMetadata.ts b/packages/container/libraries/core/src/metadata/models/LegacyConstructorMetadata.ts new file mode 100644 index 0000000..d1ee562 --- /dev/null +++ b/packages/container/libraries/core/src/metadata/models/LegacyConstructorMetadata.ts @@ -0,0 +1,6 @@ +import { LegacyMetadataMap } from './LegacyMetadataMap'; + +export interface LegacyConstructorMetadata { + compilerGeneratedMetadata: NewableFunction[] | undefined; + userGeneratedMetadata: LegacyMetadataMap; +} diff --git a/packages/container/libraries/core/src/metadata/models/LegacyMetadataReader.ts b/packages/container/libraries/core/src/metadata/models/LegacyMetadataReader.ts new file mode 100644 index 0000000..811f16f --- /dev/null +++ b/packages/container/libraries/core/src/metadata/models/LegacyMetadataReader.ts @@ -0,0 +1,9 @@ +import { LegacyConstructorMetadata } from './LegacyConstructorMetadata'; +import { LegacyMetadataMap } from './LegacyMetadataMap'; + +export interface LegacyMetadataReader { + getConstructorMetadata( + constructorFunc: NewableFunction, + ): LegacyConstructorMetadata; + getPropertiesMetadata(constructorFunc: NewableFunction): LegacyMetadataMap; +} From 4deb201fef6ff2a5ec72f5979027a49a2168a421 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roberto=20Pintos=20L=C3=B3pez?= Date: Sat, 2 Nov 2024 18:56:34 +0100 Subject: [PATCH 2/6] test(core): update tests with additional assertions --- .../calculations/getClassMetadata.spec.ts | 35 ++++++++++++++++++- .../getClassMetadataProperties.spec.ts | 4 +-- 2 files changed, 36 insertions(+), 3 deletions(-) diff --git a/packages/container/libraries/core/src/metadata/calculations/getClassMetadata.spec.ts b/packages/container/libraries/core/src/metadata/calculations/getClassMetadata.spec.ts index 2dee690..0e4be92 100644 --- a/packages/container/libraries/core/src/metadata/calculations/getClassMetadata.spec.ts +++ b/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, diff --git a/packages/container/libraries/core/src/metadata/calculations/getClassMetadataProperties.spec.ts b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataProperties.spec.ts index 4cf4140..938e41e 100644 --- a/packages/container/libraries/core/src/metadata/calculations/getClassMetadataProperties.spec.ts +++ b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataProperties.spec.ts @@ -111,7 +111,7 @@ describe(getClassMetadataProperties.name, () => { ); }); - it('should return an empty Map', () => { + it('should return a Map', () => { const expected: Map = new Map([ [legacyMetadataMapPropertyFixture, classElementMetadataFixture], ]); @@ -185,7 +185,7 @@ describe(getClassMetadataProperties.name, () => { ); }); - it('should return an empty Map', () => { + it('should return a Map', () => { const expected: Map = new Map([ [legacyMetadataMapPropertyFixture, classElementMetadataFixture], ]); From 54ecd13ba3158c29eda2d99054da3c7e5765c29d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roberto=20Pintos=20L=C3=B3pez?= Date: Sat, 2 Nov 2024 18:56:56 +0100 Subject: [PATCH 3/6] refactor(core): add getClassMetadataPropertiesFromMetadataReader --- ...tadataPropertiesFromMetadataReader.spec.ts | 184 ++++++++++++++++++ ...assMetadataPropertiesFromMetadataReader.ts | 33 ++++ 2 files changed, 217 insertions(+) create mode 100644 packages/container/libraries/core/src/metadata/calculations/getClassMetadataPropertiesFromMetadataReader.spec.ts create mode 100644 packages/container/libraries/core/src/metadata/calculations/getClassMetadataPropertiesFromMetadataReader.ts diff --git a/packages/container/libraries/core/src/metadata/calculations/getClassMetadataPropertiesFromMetadataReader.spec.ts b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataPropertiesFromMetadataReader.spec.ts new file mode 100644 index 0000000..0c3bcff --- /dev/null +++ b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataPropertiesFromMetadataReader.spec.ts @@ -0,0 +1,184 @@ +import { afterAll, beforeAll, describe, expect, it, jest } from '@jest/globals'; + +jest.mock('./getClassElementMetadataFromLegacyMetadata'); + +import { Newable } from '@inversifyjs/common'; + +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 { getClassMetadataPropertiesFromMetadataReader } from './getClassMetadataPropertiesFromMetadataReader'; + +describe(getClassMetadataPropertiesFromMetadataReader.name, () => { + describe('when called, and metadataReader.getPropertiesMetadata() returns LegacyMetadataMap with a symbol property', () => { + let legacyMetadataMapPropertyFixture: string | symbol; + let legacyMetadataListFixture: LegacyMetadata[]; + + let classElementMetadataFixture: ClassElementMetadata; + + let typeFixture: Newable; + let metadataReaderMock: jest.Mocked; + + let result: unknown; + + beforeAll(() => { + legacyMetadataMapPropertyFixture = Symbol(); + legacyMetadataListFixture = [ + { + key: 'key-fixture', + value: 'value-fixture', + }, + ]; + + classElementMetadataFixture = { + kind: ClassElementMetadataKind.singleInjection, + name: undefined, + optional: false, + tags: new Map(), + targetName: undefined, + value: Symbol(), + }; + + typeFixture = class {}; + + metadataReaderMock = { + getConstructorMetadata: jest.fn(), + getPropertiesMetadata: jest.fn(), + }; + + const legacyMetadataMap: LegacyMetadataMap = { + [legacyMetadataMapPropertyFixture]: legacyMetadataListFixture, + }; + + metadataReaderMock.getPropertiesMetadata.mockReturnValueOnce( + legacyMetadataMap, + ); + + ( + getClassElementMetadataFromLegacyMetadata as jest.Mock< + typeof getClassElementMetadataFromLegacyMetadata + > + ).mockReturnValueOnce(classElementMetadataFixture); + + result = getClassMetadataPropertiesFromMetadataReader( + typeFixture, + metadataReaderMock, + ); + }); + + afterAll(() => { + jest.clearAllMocks(); + }); + + it('should call metadataReader.getPropertiesMetadata()', () => { + expect(metadataReaderMock.getPropertiesMetadata).toHaveBeenCalledTimes(1); + expect(metadataReaderMock.getPropertiesMetadata).toHaveBeenCalledWith( + typeFixture, + ); + }); + + it('should call getClassElementMetadataFromLegacyMetadata()', () => { + expect(getClassElementMetadataFromLegacyMetadata).toHaveBeenCalledTimes( + 1, + ); + expect(getClassElementMetadataFromLegacyMetadata).toHaveBeenCalledWith( + legacyMetadataListFixture, + ); + }); + + it('should return a Map', () => { + const expected: Map = new Map([ + [legacyMetadataMapPropertyFixture, classElementMetadataFixture], + ]); + + expect(result).toStrictEqual(expected); + }); + }); + + describe('when called, and metadataReader.getPropertiesMetadata() returns LegacyMetadataMap with a string property', () => { + let legacyMetadataMapPropertyFixture: string | symbol; + let legacyMetadataListFixture: LegacyMetadata[]; + + let classElementMetadataFixture: ClassElementMetadata; + + let typeFixture: Newable; + let metadataReaderMock: jest.Mocked; + + let result: unknown; + + beforeAll(() => { + legacyMetadataMapPropertyFixture = 'property-fixture'; + legacyMetadataListFixture = [ + { + key: 'key-fixture', + value: 'value-fixture', + }, + ]; + + classElementMetadataFixture = { + kind: ClassElementMetadataKind.singleInjection, + name: undefined, + optional: false, + tags: new Map(), + targetName: undefined, + value: Symbol(), + }; + + typeFixture = class {}; + metadataReaderMock = { + getConstructorMetadata: jest.fn(), + getPropertiesMetadata: jest.fn(), + }; + + const legacyMetadataMap: LegacyMetadataMap = { + [legacyMetadataMapPropertyFixture]: legacyMetadataListFixture, + }; + + metadataReaderMock.getPropertiesMetadata.mockReturnValueOnce( + legacyMetadataMap, + ); + + ( + getClassElementMetadataFromLegacyMetadata as jest.Mock< + typeof getClassElementMetadataFromLegacyMetadata + > + ).mockReturnValueOnce(classElementMetadataFixture); + + result = getClassMetadataPropertiesFromMetadataReader( + typeFixture, + metadataReaderMock, + ); + }); + + afterAll(() => { + jest.clearAllMocks(); + }); + + it('should call metadataReader.getPropertiesMetadata()', () => { + expect(metadataReaderMock.getPropertiesMetadata).toHaveBeenCalledTimes(1); + expect(metadataReaderMock.getPropertiesMetadata).toHaveBeenCalledWith( + typeFixture, + ); + }); + + it('should call getClassElementMetadataFromLegacyMetadata()', () => { + expect(getClassElementMetadataFromLegacyMetadata).toHaveBeenCalledTimes( + 1, + ); + expect(getClassElementMetadataFromLegacyMetadata).toHaveBeenCalledWith( + legacyMetadataListFixture, + ); + }); + + it('should return a Map', () => { + const expected: Map = new Map([ + [legacyMetadataMapPropertyFixture, classElementMetadataFixture], + ]); + + expect(result).toStrictEqual(expected); + }); + }); +}); diff --git a/packages/container/libraries/core/src/metadata/calculations/getClassMetadataPropertiesFromMetadataReader.ts b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataPropertiesFromMetadataReader.ts new file mode 100644 index 0000000..e348554 --- /dev/null +++ b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataPropertiesFromMetadataReader.ts @@ -0,0 +1,33 @@ +import { Newable } from '@inversifyjs/common'; + +import { ClassElementMetadata } from '../models/ClassElementMetadata'; +import { LegacyMetadata } from '../models/LegacyMetadata'; +import { LegacyMetadataMap } from '../models/LegacyMetadataMap'; +import { LegacyMetadataReader } from '../models/LegacyMetadataReader'; +import { getClassElementMetadataFromLegacyMetadata } from './getClassElementMetadataFromLegacyMetadata'; + +export function getClassMetadataPropertiesFromMetadataReader< + TInstance, + TArgs extends unknown[], +>( + type: Newable, + metadataReader: LegacyMetadataReader, +): Map { + const propertiesLegacyMetadata: LegacyMetadataMap = + metadataReader.getPropertiesMetadata(type); + + const propertiesMetadata: Map = + new Map(); + + for (const property of Reflect.ownKeys(propertiesLegacyMetadata)) { + const legacyMetadata: LegacyMetadata[] = propertiesLegacyMetadata[ + property + ] as LegacyMetadata[]; + propertiesMetadata.set( + property, + getClassElementMetadataFromLegacyMetadata(legacyMetadata), + ); + } + + return propertiesMetadata; +} From ede547110719a0b86ce5da8ca6041676acec1366 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roberto=20Pintos=20L=C3=B3pez?= Date: Sat, 2 Nov 2024 18:57:12 +0100 Subject: [PATCH 4/6] refactor(core): add getClassMetadataConstructorArgumentsFromMetadataReader --- ...tructorArgumentsFromMetadataReader.spec.ts | 246 ++++++++++++++++++ ...aConstructorArgumentsFromMetadataReader.ts | 47 ++++ 2 files changed, 293 insertions(+) create mode 100644 packages/container/libraries/core/src/metadata/calculations/getClassMetadataConstructorArgumentsFromMetadataReader.spec.ts create mode 100644 packages/container/libraries/core/src/metadata/calculations/getClassMetadataConstructorArgumentsFromMetadataReader.ts diff --git a/packages/container/libraries/core/src/metadata/calculations/getClassMetadataConstructorArgumentsFromMetadataReader.spec.ts b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataConstructorArgumentsFromMetadataReader.spec.ts new file mode 100644 index 0000000..669ecbf --- /dev/null +++ b/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; + + 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; + + 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; + + 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]); + }); + }); +}); diff --git a/packages/container/libraries/core/src/metadata/calculations/getClassMetadataConstructorArgumentsFromMetadataReader.ts b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataConstructorArgumentsFromMetadataReader.ts new file mode 100644 index 0000000..7cbe683 --- /dev/null +++ b/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, + 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; +} From 59474b40ed31bfb0c673c8732f425211315fb2b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roberto=20Pintos=20L=C3=B3pez?= Date: Sat, 2 Nov 2024 18:57:29 +0100 Subject: [PATCH 5/6] refactor(core): add getClassMetadataFromMetadataReader --- ...getClassMetadataFromMetadataReader.spec.ts | 140 ++++++++++++++++++ .../getClassMetadataFromMetadataReader.ts | 40 +++++ 2 files changed, 180 insertions(+) create mode 100644 packages/container/libraries/core/src/metadata/calculations/getClassMetadataFromMetadataReader.spec.ts create mode 100644 packages/container/libraries/core/src/metadata/calculations/getClassMetadataFromMetadataReader.ts diff --git a/packages/container/libraries/core/src/metadata/calculations/getClassMetadataFromMetadataReader.spec.ts b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataFromMetadataReader.spec.ts new file mode 100644 index 0000000..7f27994 --- /dev/null +++ b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataFromMetadataReader.spec.ts @@ -0,0 +1,140 @@ +import { afterAll, beforeAll, describe, expect, it, jest } from '@jest/globals'; + +jest.mock('@inversifyjs/reflect-metadata-utils'); + +import { getReflectMetadata } from '@inversifyjs/reflect-metadata-utils'; + +jest.mock('./getClassMetadataConstructorArgumentsFromMetadataReader'); +jest.mock('./getClassMetadataPropertiesFromMetadataReader'); + +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'; +import { LegacyMetadata } from '../models/LegacyMetadata'; +import { LegacyMetadataReader } from '../models/LegacyMetadataReader'; +import { getClassMetadataConstructorArgumentsFromMetadataReader } from './getClassMetadataConstructorArgumentsFromMetadataReader'; +import { getClassMetadataFromMetadataReader } from './getClassMetadataFromMetadataReader'; +import { getClassMetadataPropertiesFromMetadataReader } from './getClassMetadataPropertiesFromMetadataReader'; + +describe(getClassMetadataFromMetadataReader.name, () => { + describe('when called, and getReflectMetadata() returns LegacyMetadata', () => { + let constructorArgumentsMetadataFixture: ClassElementMetadata[]; + let propertiesMetadataFixture: Map; + let postConstructMetadataFixture: LegacyMetadata; + let preDestroyMetadataFixture: LegacyMetadata; + + let typeFixture: Newable; + let metadataReaderFixture: LegacyMetadataReader; + + let result: unknown; + + beforeAll(() => { + constructorArgumentsMetadataFixture = [ + { + kind: ClassElementMetadataKind.unmanaged, + }, + ]; + + propertiesMetadataFixture = new Map([ + [ + 'property-fixture', + { + kind: ClassElementMetadataKind.singleInjection, + name: undefined, + optional: false, + tags: new Map(), + targetName: undefined, + value: Symbol(), + }, + ], + ]); + + postConstructMetadataFixture = { + key: 'post-construct-key-fixture', + value: 'post-construct-value-fixture', + }; + + preDestroyMetadataFixture = { + key: 'pre-destroy-key-fixture', + value: 'pre-destroy-value-fixture', + }; + + typeFixture = class {}; + metadataReaderFixture = Symbol() as unknown as LegacyMetadataReader; + + ( + getClassMetadataConstructorArgumentsFromMetadataReader as jest.Mock< + typeof getClassMetadataConstructorArgumentsFromMetadataReader + > + ).mockReturnValueOnce(constructorArgumentsMetadataFixture); + + ( + getClassMetadataPropertiesFromMetadataReader as jest.Mock< + typeof getClassMetadataPropertiesFromMetadataReader + > + ).mockReturnValueOnce(propertiesMetadataFixture); + + (getReflectMetadata as jest.Mock) + .mockReturnValueOnce(postConstructMetadataFixture) + .mockReturnValueOnce(preDestroyMetadataFixture); + + result = getClassMetadataFromMetadataReader( + typeFixture, + metadataReaderFixture, + ); + }); + + 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 getClassMetadataConstructorArgumentsFromMetadataReader()', () => { + expect( + getClassMetadataConstructorArgumentsFromMetadataReader, + ).toHaveBeenCalledTimes(1); + expect( + getClassMetadataConstructorArgumentsFromMetadataReader, + ).toHaveBeenCalledWith(typeFixture, metadataReaderFixture); + }); + + it('should call getClassMetadataPropertiesFromMetadataReader()', () => { + expect( + getClassMetadataPropertiesFromMetadataReader, + ).toHaveBeenCalledTimes(1); + expect(getClassMetadataPropertiesFromMetadataReader).toHaveBeenCalledWith( + typeFixture, + metadataReaderFixture, + ); + }); + + it('should return ClassMetadata', () => { + const expected: ClassMetadata = { + constructorArguments: constructorArgumentsMetadataFixture, + lifecycle: { + postConstructMethodName: postConstructMetadataFixture.value as string, + preDestroyMethodName: preDestroyMetadataFixture.value as string, + }, + properties: propertiesMetadataFixture, + }; + + expect(result).toStrictEqual(expected); + }); + }); +}); diff --git a/packages/container/libraries/core/src/metadata/calculations/getClassMetadataFromMetadataReader.ts b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataFromMetadataReader.ts new file mode 100644 index 0000000..8b3b69f --- /dev/null +++ b/packages/container/libraries/core/src/metadata/calculations/getClassMetadataFromMetadataReader.ts @@ -0,0 +1,40 @@ +import { Newable } from '@inversifyjs/common'; +import { getReflectMetadata } from '@inversifyjs/reflect-metadata-utils'; + +import { POST_CONSTRUCT, PRE_DESTROY } from '../../reflectMetadata/data/keys'; +import { ClassMetadata } from '../models/ClassMetadata'; +import { LegacyMetadata } from '../models/LegacyMetadata'; +import { LegacyMetadataReader } from '../models/LegacyMetadataReader'; +import { getClassMetadataConstructorArgumentsFromMetadataReader } from './getClassMetadataConstructorArgumentsFromMetadataReader'; +import { getClassMetadataPropertiesFromMetadataReader } from './getClassMetadataPropertiesFromMetadataReader'; + +export function getClassMetadataFromMetadataReader< + TInstance, + TArgs extends unknown[], +>( + type: Newable, + metadataReader: LegacyMetadataReader, +): ClassMetadata { + const postConstructMetadata: LegacyMetadata | undefined = + getReflectMetadata(type, POST_CONSTRUCT); + const preDestroyMetadata: LegacyMetadata | undefined = + getReflectMetadata(type, PRE_DESTROY); + + const classMetadata: ClassMetadata = { + constructorArguments: + getClassMetadataConstructorArgumentsFromMetadataReader( + type, + metadataReader, + ), + lifecycle: { + postConstructMethodName: postConstructMetadata?.value as string, + preDestroyMethodName: preDestroyMetadata?.value as string, + }, + properties: getClassMetadataPropertiesFromMetadataReader( + type, + metadataReader, + ), + }; + + return classMetadata; +} From c588a5ab2d3523d086a6e8f0a6b7a79ee0e788fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roberto=20Pintos=20L=C3=B3pez?= Date: Sat, 2 Nov 2024 18:57:47 +0100 Subject: [PATCH 6/6] feat(core): expose getClassMetadataFromMetadataReader --- .changeset/tough-suits-repeat.md | 5 +++++ packages/container/libraries/core/src/index.ts | 7 ++++++- 2 files changed, 11 insertions(+), 1 deletion(-) create mode 100644 .changeset/tough-suits-repeat.md diff --git a/.changeset/tough-suits-repeat.md b/.changeset/tough-suits-repeat.md new file mode 100644 index 0000000..15bdd84 --- /dev/null +++ b/.changeset/tough-suits-repeat.md @@ -0,0 +1,5 @@ +--- +"@inversifyjs/core": minor +--- + +Added `getClassMetadataFromMetadataReader`. diff --git a/packages/container/libraries/core/src/index.ts b/packages/container/libraries/core/src/index.ts index 80c6721..5dad9ca 100644 --- a/packages/container/libraries/core/src/index.ts +++ b/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, +};