Bump axios from 1.7.4 to 1.7.7

Bumps [axios](https://github.com/axios/axios) from 1.7.4 to 1.7.7.
- [Release notes](https://github.com/axios/axios/releases)
- [Changelog](https://github.com/axios/axios/blob/v1.x/CHANGELOG.md)
- [Commits](https://github.com/axios/axios/compare/v1.7.4...v1.7.7)

---
updated-dependencies:
- dependency-name: axios
  dependency-type: direct:development
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

CHANGELOG.md

@@ -9,21 +9,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- feat: Add new `IdentifierRequiredError` class for missing identifiers.
-- feat: Add the option to use the decorators without passing the identifier: In this case, the identifier will be the class name (register) or the property name (inject).
 - Add pre release building to release workflow on dev/* branches an version changes.
 
+
 ### Deprecated
 
 
 ### Removed
 
-- feat!: Disable `experimentalDecorators` and `emitDecoratorMetadata` in the `tsconfig.json` file to reflect the change to the stable decorators api.
 
 ### Fixed
 
-- feat!: Update `Register`, `RegisterInstance` and `Inject` decorators to reflect the change to the stable decorators api.
-- feat!: Update `Inject` Decorator typing to reflect the correct property type.
 
 ### Security
 

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "ts-injex",
-  "version": "0.1.0-alpha",
+  "version": "0.1.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "ts-injex",
-      "version": "0.1.0-alpha",
+      "version": "0.1.0",
       "license": "MIT",
       "dependencies": {
         "eslint-plugin-prettier": "^5.2.1",
@@ -18,7 +18,7 @@
         "@types/node": "^20.14.11",
         "@typescript-eslint/eslint-plugin": "^8.1.0",
         "@typescript-eslint/parser": "^8.1.0",
-        "axios": "^1.7.2",
+        "axios": "^1.7.7",
         "eslint-plugin-deprecation": "^3.0.0",
         "eslint-plugin-import": "^2.29.1",
         "eslint-plugin-jsdoc": "^50.2.2",
@@ -2026,9 +2026,9 @@
       }
     },
     "node_modules/axios": {
-      "version": "1.7.4",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.4.tgz",
-      "integrity": "sha512-DukmaFRnY6AzAALSH4J2M3k6PkaC+MfaAGdEERRWcC9q3/TWQwLpHR8ZRLKTdQ3aBDL64EdluRDjJqKw+BPZEw==",
+      "version": "1.7.7",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz",
+      "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==",
       "dev": true,
       "dependencies": {
         "follow-redirects": "^1.15.6",
@@ -5958,11 +5958,6 @@
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
       "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg=="
     },
-    "node_modules/reflect-metadata": {
-      "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
-      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q=="
-    },
     "node_modules/regexp.prototype.flags": {
       "version": "1.5.2",
       "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.2.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-injex",
-  "version": "0.1.0-alpha",
+  "version": "0.1.0",
   "description": "Simple boilerplate code free dependency injection system for TypeScript.",
   "type": "module",
   "main": "./dist/index.js",
@@ -47,7 +47,7 @@
     "ts-jest": "^29.2.3",
     "typedoc": "^0.26.5",
     "istanbul-badges-readme": "^1.9.0",
-    "axios": "^1.7.2"
+    "axios": "^1.7.7"
   },
   "dependencies": {
     "eslint-plugin-prettier": "^5.2.1",

src/__tests__/Decorators.spec.ts

@@ -1,9 +1,9 @@
 /* istanbul ignore file */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Inject } from 'src/decorators/Inject';
-import { DependencyResolutionError } from '../interfaces/Exceptions';
+import { DependencyResolutionError } from 'src/interfaces/Exceptions';
+import { ForceConstructor } from 'src/types/GenericContructor';
 import { ITSinjex_, ITSinjex } from '../interfaces/ITSinjex';
-import { ForceConstructor } from '../types/GenericContructor';
 
 /**
  * Test the Inject decorator.
@@ -67,29 +67,6 @@ export function test_InjectDecorator(
             expect(instance.getDependency().value).toBe('test-value-init');
         });
 
-        it('should inject dependency and run initializer without identifier', () => {
-            container.register('MockDependencyIdentifier', {
-                value: 'test-value',
-            });
-
-            class TestClass {
-                @Inject(undefined, (x: string) => {
-                    (x as unknown as { value: string }).value =
-                        'test-value-init';
-
-                    return x;
-                })
-                MockDependencyIdentifier!: any;
-
-                public getDependency() {
-                    return this.MockDependencyIdentifier;
-                }
-            }
-
-            const instance = new TestClass();
-            expect(instance.getDependency().value).toBe('test-value-init');
-        });
-
         it('should throw an error when necessary is true and the initializer throws an error', () => {
             let _error: Error | undefined = undefined;
 
@@ -101,7 +78,7 @@ export function test_InjectDecorator(
                 class TestClass {
                     @Inject(
                         'InitThrowDependencie',
-                        (): any => {
+                        () => {
                             throw new Error('Initializer error');
                         },
                         true,
@@ -298,19 +275,6 @@ export function test_RegisterDecorator(
                 TestClass,
             );
         });
-
-        it('should register a dependency without an identifier', () => {
-            @register()
-            class TestClass {
-                private readonly _dependency!: any;
-
-                public getDependency() {
-                    return this._dependency;
-                }
-            }
-
-            expect(container.resolve('TestClass')).toBe(TestClass);
-        });
     });
 }
 
@@ -347,23 +311,6 @@ export function test_RegisterInstanceDecorator(
             ).toBe('instance');
         });
 
-        it('should register an instance of a dependency with an identifier', () => {
-            @registerInstance()
-            class TestClass {
-                private readonly _dependency!: any;
-
-                public getDependency() {
-                    return this._dependency;
-                }
-
-                public mark: string = 'instance';
-            }
-
-            expect(container.resolve<TestClass>('TestClass').mark).toBe(
-                'instance',
-            );
-        });
-
         it('should register an instance of a dependency an run the init function', () => {
             @registerInstance(
                 'InstanceIdentifier',

src/decorators/Inject.ts

@@ -1,27 +1,26 @@
-import { TSinjex } from '../classes/TSinjex';
 import {
     DependencyResolutionError,
-    IdentifierRequiredError,
     InitializationError,
     InjectorError,
     NoInstantiationMethodError,
-} from '../interfaces/Exceptions';
+} from 'src/interfaces/Exceptions';
+import { TSinjex } from '../classes/TSinjex';
 import { Identifier } from '../types/Identifier';
 import { InitDelegate } from '../types/InitDelegate';
 
 /**
  * A decorator to inject a dependency from a DI (Dependency Injection) container into a class property.
- * @template TargetType The type of the class to inject the dependency into.
- * @template DependencyType The type of the dependency to be injected.
- * @template PropertyType The type of the property to be injected.
- * @param identifier The {@link Identifier|identifier} used to resolve the dependencie in the DI container or the property name if not provided.
- * @param init An optional initializer {@link InitDelegate|function} to transform the dependency before injection
+ * @template T The type of the dependency to be injected.
+ * @template U The type of the property to be injected.
+ * @param identifier The identifier used to resolve the class in the DI container.
+ * @see {@link Identifier} for more information on identifiers.
+ * @param init Optional an initializer function to transform the dependency before injection
  * or true to instantiate the dependency if it has a constructor.
+ * @see {@link InitDelegate} for more information on initializer functions.
  * @param necessary If true, throws an error if the dependency is not found.
  * @returns The resolved dependency or undefined if the dependency is not necessary
  * and not found, or throws an error if the dependency is necessary and not found.
  * @throws **Only throws errors if the dependency is necessary.**
- * @throws An {@link IdentifierRequiredError} if the identifier is not provided and the class name is not available.
  * @throws A {@link DependencyResolutionError} if the dependency is not found.
  * @throws A {@link InjectorError} if an error occurs during the injection process.
  * @throws A {@link NoInstantiationMethodError} if the dependency does not have a constructor.
@@ -41,83 +40,71 @@ import { InitDelegate } from '../types/InitDelegate';
  * }
  * ```
  */
-export function Inject<TargetType, DependencyType, PropertyType>(
-    identifier?: Identifier,
-    init?: InitDelegate<DependencyType, PropertyType> | true,
+export function Inject<T, U>(
+    identifier: Identifier,
+    init?: InitDelegate<T, U> | true,
     necessary = true,
 ) {
-    return function (
-        constructor: undefined,
-        context: ClassFieldDecoratorContext<TargetType>,
-    ): (
-        this: TargetType,
-        initialValue: PropertyType | undefined,
-    ) => PropertyType {
-        const _identifier = identifier ?? context.name;
-
-        if (_identifier == null && necessary === true)
-            throw new IdentifierRequiredError();
-
+    return function (target: unknown, propertyKey: string | symbol): void {
         /**
          * Function to evaluate the dependency lazily
          * to avoid circular dependencies, not found dependencies, etc.
          * @returns The resolved dependency or undefined if the dependency is not found.
          */
-        const resolve = (): DependencyType | undefined => {
-            return TSinjex.getInstance().resolve<DependencyType>(
-                _identifier,
-                necessary,
-            );
+        const resolve = (): T | undefined => {
+            return TSinjex.getInstance().resolve<T>(identifier, necessary);
         };
 
-        return function (
-            this: TargetType,
-            initialValue: PropertyType | undefined,
-        ): PropertyType {
-            let instance: DependencyType | PropertyType | undefined;
+        Object.defineProperty(target, propertyKey, {
+            get() {
+                let instance: T | U | undefined;
 
-            const dependency: DependencyType | undefined = tryAndCatch(
-                () => resolve(),
-                necessary,
-                _identifier,
-                DependencyResolutionError,
-            );
+                const dependency: T | undefined = tryAndCatch(
+                    () => resolve(),
+                    necessary,
+                    identifier,
+                    DependencyResolutionError,
+                );
 
-            if (dependency != null) {
-                const initFunction: (() => PropertyType) | undefined =
-                    typeof init === 'function' && dependency != null
-                        ? (): PropertyType => init(dependency)
-                        : init === true && hasConstructor(dependency)
-                          ? (): PropertyType => new dependency() as PropertyType
-                          : undefined;
+                if (dependency != null) {
+                    const initFunction: (() => U) | undefined =
+                        typeof init === 'function' && dependency != null
+                            ? (): U => init(dependency)
+                            : init === true && hasConstructor(dependency)
+                              ? (): U => new dependency() as U
+                              : undefined;
 
-                if (init == null) instance = dependency;
-                else if (initFunction != null)
-                    instance = tryAndCatch(
-                        initFunction,
-                        necessary,
-                        _identifier,
-                        InitializationError,
-                    );
-                else if (necessary)
-                    throw new NoInstantiationMethodError(_identifier);
-            } else if (necessary)
-                throw new DependencyResolutionError(_identifier);
+                    if (init == null) instance = dependency;
+                    else if (initFunction != null)
+                        instance = tryAndCatch(
+                            initFunction,
+                            necessary,
+                            identifier,
+                            InitializationError,
+                        );
+                    else if (necessary)
+                        throw new NoInstantiationMethodError(identifier);
+                } else if (necessary)
+                    throw new DependencyResolutionError(identifier);
 
+                /**
+                 * Replace itself with the resolved dependency
+                 * for performance reasons.
+                 */
+                Object.defineProperty(this, propertyKey, {
+                    value: instance,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false,
+                });
+
+                return instance;
+            },
             /**
-             * Replace itself with the resolved dependency
-             * for performance reasons.
+             * Make the property configurable to allow replacing it
              */
-            Object.defineProperty(this, context.name, {
-                value: instance,
-                writable: false,
-                enumerable: false,
-                configurable: false,
-            });
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return instance as any;
-        };
+            configurable: true,
+        });
     };
 }
 

src/decorators/Register.ts

@@ -1,14 +1,14 @@
 import { TSinjex } from '../classes/TSinjex';
-import { IdentifierRequiredError } from '../interfaces/Exceptions';
 import { Identifier } from '../types/Identifier';
 
 /**
  * A decorator to register a class in the **TSinjex** DI (Dependency Injection) container.
  * @template TargetType The type of the class to be registered.
- * @param identifier The {@link Identifier|identifier} used to register the class in the DI container or the class name if not provided.
- * @param deprecated If true, the dependency is deprecated and a warning is logged only once upon the first resolution of the dependency.
+ * @param identifier The identifier used to register the class in the DI container.
+ * @see {@link Identifier} for more information on identifiers.
+ * @param deprecated If true, the dependency is deprecated and a warning
+ * is logged only once upon the first resolution of the dependency.
  * @returns The decorator function to be applied on the class.
- * @throws An {@link IdentifierRequiredError} if the identifier is not provided and the class name is not available.
  * @example
  * ```ts
  * \@Register('MyClassIdentifier')
@@ -19,16 +19,12 @@ import { Identifier } from '../types/Identifier';
  */
 export function Register<
     TargetType extends new (...args: unknown[]) => InstanceType<TargetType>,
->(identifier?: Identifier, deprecated?: boolean) {
-    return function (
-        constructor: TargetType,
-        context: ClassDecoratorContext<TargetType>,
-    ) {
-        const _identifier = identifier ?? context.name;
-
-        if (_identifier == null) throw new IdentifierRequiredError();
-
+>(identifier: Identifier, deprecated?: boolean) {
+    return function (constructor: TargetType, ...args: unknown[]): void {
+        // Get the instance of the DI container
         const diContainer = TSinjex.getInstance();
-        diContainer.register(_identifier, constructor, deprecated);
+
+        // Register the class in the DI container
+        diContainer.register(identifier, constructor, deprecated);
     };
 }

src/decorators/RegisterInstance.ts

@@ -1,16 +1,16 @@
 import { TSinjex } from '../classes/TSinjex';
-import { IdentifierRequiredError } from '../interfaces/Exceptions';
 import { Identifier } from '../types/Identifier';
 import { InitDelegate } from '../types/InitDelegate';
 
 /**
  * A decorator to register an instance of a class in the DI (Dependency Injection) container.
  * @template TargetType The type of the class whose instance is to be registered.
- * @param identifier The {@link Identifier|identifier} used to register the class in the DI container or the class name if not provided.
- * @param init An optional initializer {@link InitDelegate|function} which get the constructor of the class
+ * @param identifier The identifier used to register the instance in the DI container.
+ * @see {@link Identifier} for more information on identifiers.
+ * @param init An optional initializer function which get the constructor of the class
  * as input and returns an instance of the class.
+ * @see {@link InitDelegate} for more information on initializer functions.
  * @returns The decorator function to be applied on the class.
- * @throws An {@link IdentifierRequiredError} if the identifier is not provided and the class name is not available.
  * @example
  * ```ts
  * \@RegisterInstance('MyClassInstanceIdentifier', (constructor) => new constructor())
@@ -22,51 +22,43 @@ import { InitDelegate } from '../types/InitDelegate';
 export function RegisterInstance<
     TargetType extends new (..._args: unknown[]) => InstanceType<TargetType>,
 >(
-    identifier?: Identifier,
+    identifier: Identifier,
     init?: InitDelegate<
         TargetType & { new (..._args: unknown[]): InstanceType<TargetType> },
         InstanceType<TargetType>
     >,
 ) {
-    return function (
-        constructor: TargetType,
-        context: ClassDecoratorContext<TargetType>,
-    ): void {
-        const _identifier = identifier ?? context.name;
-
-        if (_identifier == null) throw new IdentifierRequiredError();
-
+    return function (constructor: TargetType, ...args: unknown[]): void {
+        // Get the instance of the DI container
         const diContainer = TSinjex.getInstance();
         let instance: InstanceType<TargetType>;
 
-        /**
-         * Get the instance of the class
-         * and replace the lazy proxy with the instance
-         * for performance optimization.
-         */
-        const getAndRegisterInstance = (): void => {
-            if (instance == null) {
-                if (init) {
-                    instance = init(constructor);
-                } else {
-                    instance = new constructor();
-                }
-            }
-            diContainer.register(_identifier, instance);
-        };
-
         // Create a proxy to instantiate the class when needed (Lazy Initialization)
-        const lazyProxy: unknown = new Proxy(
+        let lazyProxy: unknown = new Proxy(
             {},
             {
-                get(_target, prop, _receiver) {
-                    getAndRegisterInstance();
+                get(target, prop, receiver) {
+                    if (instance == null) {
+                        if (init) {
+                            instance = init(constructor);
+                        } else {
+                            instance = new constructor(...args);
+                        }
+                    }
+                    lazyProxy = instance;
 
                     // Return the requested property of the instance
                     return instance[prop as keyof InstanceType<TargetType>];
                 },
-                set(_target, prop, value, _receiver) {
-                    getAndRegisterInstance();
+                set(target, prop, value, receiver) {
+                    if (instance == null) {
+                        if (init) {
+                            instance = init(constructor);
+                        } else {
+                            instance = new constructor(...args);
+                        }
+                    }
+                    lazyProxy = instance;
 
                     // Set the requested property of the instance
                     return (instance[prop as keyof InstanceType<TargetType>] =
@@ -75,6 +67,7 @@ export function RegisterInstance<
             },
         );
 
-        diContainer.register(_identifier, lazyProxy);
+        // Register the lazy proxy in the DI container
+        diContainer.register(identifier, lazyProxy);
     };
 }

src/interfaces/Exceptions.ts

@@ -15,19 +15,6 @@ export class TSinjexError extends Error {
     }
 }
 
-/**
- * Error class for missing identifiers in {@link ITSinjex} methods.
- */
-export class IdentifierRequiredError extends TSinjexError {
-    /**
-     * Creates a new instance of {@link IdentifierRequiredError}
-     */
-    constructor() {
-        super('Identifier is required.');
-        this.name = 'TSinjexIdentifierRequiredError';
-    }
-}
-
 /**
  * Error class for dependency resolution errors in {@link ITSinjex}.
  * @see {@link ITSinjex.resolve}

tsconfig.json

@@ -18,6 +18,8 @@
         "importHelpers": true,
         "isolatedModules": true,
         "resolveJsonModule": true,
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
         "strictNullChecks": true,
         "strictPropertyInitialization": true,
         "lib": [