Add optional decorator

packages/container/libraries/core/src/metadata/actions/updateMetadataOptional.spec.ts

@@ -0,0 +1,87 @@
+import { beforeAll, describe, expect, it } from '@jest/globals';
+
+import { InversifyCoreError } from '../../error/models/InversifyCoreError';
+import { InversifyCoreErrorKind } from '../../error/models/InversifyCoreErrorKind';
+import { ClassElementMetadataKind } from '../models/ClassElementMetadataKind';
+import { ManagedClassElementMetadata } from '../models/ManagedClassElementMetadata';
+import { MaybeManagedClassElementMetadata } from '../models/MaybeManagedClassElementMetadata';
+import { updateMetadataOptional } from './updateMetadataOptional';
+
+describe(updateMetadataOptional.name, () => {
+  describe('having metadata with no optional', () => {
+    let metadataFixture:
+      | ManagedClassElementMetadata
+      | MaybeManagedClassElementMetadata;
+
+    beforeAll(() => {
+      metadataFixture = {
+        kind: ClassElementMetadataKind.singleInjection,
+        name: undefined,
+        optional: false,
+        tags: new Map(),
+        targetName: undefined,
+        value: 'service-id',
+      };
+    });
+
+    describe('when called', () => {
+      let result: unknown;
+
+      beforeAll(() => {
+        result = updateMetadataOptional(metadataFixture);
+      });
+
+      it('should return metadata', () => {
+        const expected:
+          | ManagedClassElementMetadata
+          | MaybeManagedClassElementMetadata = {
+          ...metadataFixture,
+          optional: true,
+        };
+
+        expect(result).toStrictEqual(expected);
+      });
+    });
+  });
+
+  describe('having metadata with optional', () => {
+    let metadataFixture:
+      | ManagedClassElementMetadata
+      | MaybeManagedClassElementMetadata;
+
+    beforeAll(() => {
+      metadataFixture = {
+        kind: ClassElementMetadataKind.singleInjection,
+        name: undefined,
+        optional: true,
+        tags: new Map(),
+        targetName: undefined,
+        value: 'service-id',
+      };
+    });
+
+    describe('when called', () => {
+      let result: unknown;
+
+      beforeAll(() => {
+        try {
+          updateMetadataOptional(metadataFixture);
+        } catch (error: unknown) {
+          result = error;
+        }
+      });
+
+      it('should throw InversifyCoreError', () => {
+        const expectedErrorProperties: Partial<InversifyCoreError> = {
+          kind: InversifyCoreErrorKind.injectionDecoratorConflict,
+          message: 'Unexpected duplicated optional decorator',
+        };
+
+        expect(result).toBeInstanceOf(InversifyCoreError);
+        expect(result).toStrictEqual(
+          expect.objectContaining(expectedErrorProperties),
+        );
+      });
+    });
+  });
+});

packages/container/libraries/core/src/metadata/actions/updateMetadataOptional.ts

@@ -0,0 +1,19 @@
+import { InversifyCoreError } from '../../error/models/InversifyCoreError';
+import { InversifyCoreErrorKind } from '../../error/models/InversifyCoreErrorKind';
+import { ManagedClassElementMetadata } from '../models/ManagedClassElementMetadata';
+import { MaybeManagedClassElementMetadata } from '../models/MaybeManagedClassElementMetadata';
+
+export function updateMetadataOptional(
+  metadata: ManagedClassElementMetadata | MaybeManagedClassElementMetadata,
+): ManagedClassElementMetadata | MaybeManagedClassElementMetadata {
+  if (metadata.optional) {
+    throw new InversifyCoreError(
+      InversifyCoreErrorKind.injectionDecoratorConflict,
+      'Unexpected duplicated optional decorator',
+    );
+  }
+
+  metadata.optional = true;
+
+  return metadata;
+}

packages/container/libraries/core/src/metadata/decorators/optional.int.spec.ts

@@ -0,0 +1,84 @@
+import { beforeAll, describe, expect, it } from '@jest/globals';
+
+import 'reflect-metadata';
+
+import { getReflectMetadata } from '@inversifyjs/reflect-metadata-utils';
+
+import { classMetadataReflectKey } from '../../reflectMetadata/data/classMetadataReflectKey';
+import { MaybeClassElementMetadataKind } from '../models/MaybeClassElementMetadataKind';
+import { MaybeClassMetadata } from '../models/MaybeClassMetadata';
+import { optional } from './optional';
+
+describe(optional.name, () => {
+  describe('when called', () => {
+    let result: unknown;
+
+    beforeAll(() => {
+      class Foo {
+        @optional()
+        public readonly bar!: string;
+
+        @optional()
+        public readonly baz!: string;
+
+        constructor(
+          @optional()
+          public firstParam: number,
+          @optional()
+          public secondParam: number,
+        ) {}
+      }
+
+      result = getReflectMetadata(Foo, classMetadataReflectKey);
+    });
+
+    it('should return expected metadata', () => {
+      const expected: MaybeClassMetadata = {
+        constructorArguments: [
+          {
+            kind: MaybeClassElementMetadataKind.unknown,
+            name: undefined,
+            optional: true,
+            tags: new Map(),
+            targetName: undefined,
+          },
+          {
+            kind: MaybeClassElementMetadataKind.unknown,
+            name: undefined,
+            optional: true,
+            tags: new Map(),
+            targetName: undefined,
+          },
+        ],
+        lifecycle: {
+          postConstructMethodName: undefined,
+          preDestroyMethodName: undefined,
+        },
+        properties: new Map([
+          [
+            'bar',
+            {
+              kind: MaybeClassElementMetadataKind.unknown,
+              name: undefined,
+              optional: true,
+              tags: new Map(),
+              targetName: undefined,
+            },
+          ],
+          [
+            'baz',
+            {
+              kind: MaybeClassElementMetadataKind.unknown,
+              name: undefined,
+              optional: true,
+              tags: new Map(),
+              targetName: undefined,
+            },
+          ],
+        ]),
+      };
+
+      expect(result).toStrictEqual(expected);
+    });
+  });
+});