@tsed/di 8.38.0-beta.1 → 8.38.0-beta.3

package/lib/esm/common/services/InjectorService.js

@@ -183,7 +183,7 @@ export class InjectorService {
      * @returns `true` if the instance is cached, `false` otherwise
      */
     has(token) {
-        return this.#cache.get(token) !== undefined;
+        return this.#cache.has(token);
     }
     /**
      * Create an alias for a provider token.
@@ -222,9 +222,8 @@ export class InjectorService {
      * @returns The resolved provider instance
      */
     resolve(token, options = {}) {
-        let instance = options.locals ? options.locals.get(token) : undefined;
-        if (instance !== undefined) {
-            return instance;
+        if (options.locals?.has(token)) {
+            return options.locals.get(token);
         }
         if (token === DI_USE_PARAM_OPTIONS) {
             return options.useOpts;
@@ -233,23 +232,19 @@ export class InjectorService {
             // keep this configuration for legacy code that use as custom Configuration service
             return this.settings;
         }
-        instance = !options.rebuild ? this.#cache.get(token) : undefined;
-        if (instance != undefined) {
-            return instance;
+        if (!options.rebuild && this.#cache.has(token)) {
+            return this.#cache.get(token);
         }
         const provider = this.ensureProvider(token);
-        if (provider && provider.scope === ProviderScope.SINGLETON && !options.rebuild && !this.#registeredSingletonHooks.has(provider.token)) {
-            this.registerHooks(provider, options);
-        }
         // maybe not necessary
         if (!provider || options.rebuild) {
-            instance = this.invokeToken(token, options);
+            const instance = this.invokeToken(token, options);
             if (provider) {
                 return this.setToCache(provider, instance);
             }
             return instance;
         }
-        instance = this.invokeToken(token, options);
+        const instance = this.invokeToken(token, options);
         switch (provider.scope) {
             case ProviderScope.SINGLETON:
                 return this.setToCache(provider, instance);
@@ -472,30 +467,31 @@ export class InjectorService {
             $emit("$beforeInvoke", token, [resolvedOpts]);
             $emit(`$beforeInvoke:${String(provider.type)}`, [resolvedOpts]);
             let instance;
-            let currentDependency = false;
+            let currentDependency;
+            let currentDependencyIndex = -1;
+            let hasCurrentDependency = false;
             try {
-                const invokeDependency = (parent) => (token, index) => {
-                    currentDependency = { token, index, deps };
-                    if (isArray(token)) {
-                        return this.getMany(token[0], options);
-                    }
-                    return isInheritedFrom(token, Provider, 1)
-                        ? provider
-                        : this.resolve(token, {
-                            parent,
-                            locals: options.locals,
-                            useOpts: provider?.getArgOpts(index) || options.useOpts
-                        });
-                };
                 // Invoke manually imported providers
-                imports.forEach(invokeDependency());
+                for (let index = 0; index < imports.length; index++) {
+                    currentDependency = imports[index];
+                    currentDependencyIndex = index;
+                    hasCurrentDependency = true;
+                    this.invokeDependency(currentDependency, index, undefined, provider, options);
+                }
                 // Inject dependencies
-                const services = deps.map(invokeDependency(token));
-                currentDependency = false;
+                const services = new Array(deps.length);
+                for (let index = 0; index < deps.length; index++) {
+                    currentDependency = deps[index];
+                    currentDependencyIndex = index;
+                    hasCurrentDependency = true;
+                    services[index] = this.invokeDependency(currentDependency, index, token, provider, options);
+                }
+                hasCurrentDependency = false;
                 instance = construct(services);
             }
             catch (error) {
-                InjectionError.throwInjectorError(token, currentDependency, error);
+                const dependency = hasCurrentDependency ? { token: currentDependency, index: currentDependencyIndex, deps } : false;
+                InjectionError.throwInjectorError(token, dependency, error);
             }
             if (instance === undefined) {
                 throw new InjectionError(token, `Unable to create new instance from undefined value. Check your provider declaration for ${nameOf(token)}`);
@@ -519,6 +515,18 @@ export class InjectorService {
             }
         });
     }
+    invokeDependency(token, index, parent, provider, options) {
+        if (isArray(token)) {
+            return this.getMany(token[0], options);
+        }
+        return isInheritedFrom(token, Provider, 1)
+            ? provider
+            : this.resolve(token, {
+                parent,
+                locals: options.locals,
+                useOpts: provider.getArgOpts(index) || options.useOpts
+            });
+    }
     resolveImportsProviders() {
         const imports = this.settings.imports;
         if (!imports) {
@@ -572,13 +580,7 @@ export class InjectorService {
         if (!token || token === Object) {
             throw new Error("Given token is undefined. Could mean a circular dependency problem. Try to use @Inject(() => Token) to solve it.");
         }
-        let provider;
-        if (!this.providers.get(token)) {
-            provider = new Provider(token);
-        }
-        else {
-            provider = this.providers.get(token);
-        }
+        const provider = this.#providers.get(token) || new Provider(token);
         deps = deps || provider.deps;
         imports = imports || provider.imports;
         if (provider.useValue !== undefined) {

package/lib/types/common/services/InjectorService.d.ts

@@ -261,6 +261,7 @@ export declare class InjectorService {
      */
     protected invokeToken<T>(target: TokenProvider, options?: Partial<InvokeOptions>): T | Promise<T>;
     private mergeProviders;
+    private invokeDependency;
     private resolveImportsProviders;
     /**
      * Create options to invoke a provider or class.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/di",
-  "version": "8.38.0-beta.1",
+  "version": "8.38.0-beta.3",
   "description": "DI module for Ts.ED Framework",
   "source": "./src/index.ts",
   "type": "module",
@@ -29,11 +29,11 @@
     "uuid": "^14.0.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.38.0-beta.1",
-    "@tsed/core": "8.38.0-beta.1",
-    "@tsed/hooks": "8.38.0-beta.1",
+    "@tsed/barrels": "8.38.0-beta.3",
+    "@tsed/core": "8.38.0-beta.3",
+    "@tsed/hooks": "8.38.0-beta.3",
     "@tsed/logger": "^8.0.0",
-    "@tsed/typescript": "8.38.0-beta.1",
+    "@tsed/typescript": "8.38.0-beta.3",
     "cross-env": "7.0.3",
     "typescript": "6.0.2",
     "vite": "7.3.2",