@tstdl/base 0.93.11 → 0.93.12

package/injector/injector.js

@@ -12,6 +12,7 @@ import { assert, isArray, isBoolean, isDefined, isFunction, isNotNull, isNotObje
 import { setCurrentInjectionContext } from './inject.js';
 import { afterResolve } from './interfaces.js';
 import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider } from './provider.js';
+import { RegistrationError } from './registration.error.js';
 import { runInResolutionContext } from './resolution.js';
 import { ResolveChain } from './resolve-chain.js';
 import { ResolveError } from './resolve.error.js';
@@ -277,7 +278,7 @@ export class Injector {
             return forwardRef;
         }
         if (isUndefined(token)) {
-            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
+            throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
         }
         const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
         if (isDefined(registration)) {
@@ -302,7 +303,7 @@ export class Injector {
             return forwardRef;
         }
         if (isUndefined(token)) {
-            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
+            throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
         }
         const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
         if (isDefined(registration)) {
@@ -333,12 +334,7 @@ export class Injector {
             const singletonScoped = registration.options.lifecycle == 'singleton';
             let resolveArgument = argument ?? registration.options.defaultArgument;
             if (isUndefined(resolveArgument) && isFunction(registration.options.defaultArgumentProvider)) {
-                try {
-                    resolveArgument = registration.options.defaultArgumentProvider(injector.getResolveContext(resolutionTag, context, chain));
-                }
-                catch (error) {
-                    throw new ResolveError('Error in defaultArgumentProvider.', chain, error);
-                }
+                resolveArgument = wrapInResolveError(() => registration.options.defaultArgumentProvider(injector.getResolveContext(resolutionTag, context, chain)), 'Error in defaultArgumentProvider', chain);
             }
             const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument, chain);
             if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
@@ -350,9 +346,7 @@ export class Injector {
             else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
                 return registration.resolutions.get(argumentIdentity);
             }
-            const resolutionContext = {
-                afterResolveRegistrations: [],
-            };
+            const resolutionContext = { afterResolveRegistrations: [] };
             const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, resolutionContext, injectionContext, chain);
             const resolution = {
                 tag: resolutionTag,
@@ -389,23 +383,16 @@ export class Injector {
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
                 injectionContext.argument = arg;
                 if ((provider.useClass.length > 0) && (isUndefined(typeMetadata) || !typeMetadata.data.has(injectableMetadataSymbol))) {
-                    throw new ResolveError(`${provider.useClass.name} has constructor parameters but is not injectable.`, chain);
+                    throw new ResolveError(`${provider.useClass.name} has constructor parameters but is not decorated with @Injectable.`, chain);
                 }
                 const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(resolutionTag, context, provider.useClass, metadata, arg, chain));
-                try {
-                    result = { value: runInResolutionContext(resolutionContext, () => Reflect.construct(provider.useClass, parameters)) };
-                }
-                catch (error) {
-                    if (error instanceof ResolveError) {
-                        throw error;
-                    }
-                    throw new ResolveError('Error in class constructor.', chain, error);
-                }
+                const value = wrapInResolveError(() => runInResolutionContext(resolutionContext, () => Reflect.construct(provider.useClass, parameters)), `Error during construction of '${provider.useClass.name}'`, chain);
+                result = { value };
             }
-            if (isValueProvider(provider)) {
+            else if (isValueProvider(provider)) {
                 result = { value: provider.useValue };
             }
-            if (isTokenProvider(provider)) {
+            else if (isTokenProvider(provider)) {
                 const innerToken = (provider.useToken ?? provider.useTokenProvider());
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
                 injectionContext.argument = arg;
@@ -414,17 +401,13 @@ export class Injector {
                 }
                 result = { value: this._resolve(innerToken, arg, options, context, chain.addToken(innerToken)) };
             }
-            if (isFactoryProvider(provider)) {
+            else if (isFactoryProvider(provider)) {
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
                 injectionContext.argument = arg;
-                try {
-                    result = { value: runInResolutionContext(resolutionContext, () => provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain))) };
-                }
-                catch (error) {
-                    throw new ResolveError('Error in provider factory.', chain, error);
-                }
+                const value = wrapInResolveError(() => runInResolutionContext(resolutionContext, () => provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain))), 'Error in provider factory', chain);
+                result = { value };
             }
-            if (isUndefined(result)) {
+            else {
                 throw new Error('Unsupported provider.');
             }
             if (isSyncOrAsyncDisposable(result.value) && !this.#disposableStackRegistrations.has(result.value)) {
@@ -442,15 +425,9 @@ export class Injector {
         const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
         const injectToken = (injectMetadata.injectToken ?? metadata.type);
         if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
-            return injectMetadata.injectArgumentMapper(resolveArgument);
-        }
-        let parameterResolveArgument;
-        try {
-            parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
-        }
-        catch (error) {
-            throw new ResolveError('Error in parameter argument provider (forwardArgumentMapper or resolveArgumentProvider).', getChain(injectToken), error);
+            return wrapInResolveError(() => injectMetadata.injectArgumentMapper(resolveArgument), 'Error in injectArgumentMapper', getChain(injectToken));
         }
+        const parameterResolveArgument = wrapInResolveError(() => injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken))), 'Error in parameter argument provider (forwardArgumentMapper or resolveArgumentProvider)', getChain(injectToken));
         const { forwardRef } = injectMetadata;
         if (isDefined(forwardRef) && isDefined(injectMetadata.mapper)) {
             const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
@@ -459,12 +436,7 @@ export class Injector {
         const resolveFn = (injectMetadata.resolveAll == true) ? '_resolveAll' : '_resolve';
         const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef, forwardRefTypeHint: injectMetadata.forwardRefTypeHint }, context, getChain(injectToken));
         if (isDefined(injectMetadata.mapper)) {
-            try {
-                return injectMetadata.mapper(resolved);
-            }
-            catch (error) {
-                throw new ResolveError('Error in inject mapper.', getChain(injectToken), error);
-            }
+            return wrapInResolveError(() => injectMetadata.mapper(resolved), 'Error in inject mapper', getChain(injectToken));
         }
         return resolved;
     }
@@ -485,7 +457,7 @@ export class Injector {
         return values;
     }
     getResolveContext(resolutionTag, resolveContext, chain) {
-        const context = {
+        return {
             resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
             resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
             cancellationSignal: this.#disposeToken,
@@ -494,21 +466,19 @@ export class Injector {
                 return resolveContext.resolutionContextData.get(resolutionTag);
             },
         };
-        return context;
     }
     getAfterResolveContext(resolutionTag, resolveContext) {
-        const context = {
+        return {
             cancellationSignal: this.#disposeToken,
             addDisposeHandler: this.#addDisposeHandler,
             get data() {
                 return resolveContext.resolutionContextData.get(resolutionTag);
             },
         };
-        return context;
     }
     getInjectionContext(resolveContext, resolveArgument, chain) {
         let injectIndex = 0;
-        const context = {
+        return {
             injector: this,
             argument: resolveArgument,
             inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
@@ -518,7 +488,6 @@ export class Injector {
             injectAllAsync: async (token, argument, options) => await this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
             injectManyAsync: async (...tokens) => await this.resolveManyAsync(...tokens),
         };
-        return context;
     }
     assertNotDisposed() {
         if (this.disposed) {
@@ -533,7 +502,7 @@ function addRegistration(registrations, registration) {
     if (isClassProvider(registration.provider)) {
         const injectable = reflectionRegistry.getMetadata(registration.provider.useClass)?.data.has(injectableMetadataSymbol) ?? false;
         if (!injectable) {
-            throw new Error(`${registration.provider.useClass.name} is not injectable.`);
+            throw new RegistrationError(`${registration.provider.useClass.name} is not decorated with Injectable and cannot be registered.`);
         }
     }
     const multi = registration.options.multi ?? false;
@@ -541,7 +510,8 @@ function addRegistration(registrations, registration) {
     const hasExistingRegistration = isDefined(existingRegistration);
     const existingIsMulti = hasExistingRegistration && isArray(existingRegistration);
     if (hasExistingRegistration && (existingIsMulti != multi)) {
-        throw new Error('Cannot mix multi and non-multi registrations.');
+        const tokenName = getTokenName(registration.token);
+        throw new RegistrationError(`Cannot mix multi and non-multi registrations for token: ${tokenName}.`);
     }
     if (multi && existingIsMulti) {
         existingRegistration.push(registration);
@@ -568,29 +538,31 @@ function postProcess(context) {
     }
     derefForwardRefs(context);
     for (const resolution of context.resolutions) {
-        try {
-            for (const afterResolveHandler of resolution.afterResolveRegistrations) {
-                const returnValue = afterResolveHandler(resolution.argument, resolution.afterResolveContext);
-                throwOnPromise(returnValue, 'registerAfterResolve()', resolution.chain);
-            }
-            if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
-                const returnValue = resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
-                throwOnPromise(returnValue, '[afterResolve]', resolution.chain);
-            }
-            if (isProviderWithInitializer(resolution.registration.provider)) {
-                const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
-                throwOnPromise(returnValue, 'provider afterResolve handler', resolution.chain);
-            }
-            if (isDefined(resolution.registration.options.afterResolve)) {
-                const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
+        const { registration, value, argument, afterResolveContext, afterResolveRegistrations, chain } = resolution;
+        const provider = registration.provider;
+        for (const afterResolveHandler of afterResolveRegistrations) {
+            wrapInResolveError(() => {
+                const returnValue = afterResolveHandler(argument, afterResolveContext);
+                throwOnPromise(returnValue, 'registerAfterResolve()', chain);
+            }, 'Error in registered afterResolve handler', chain);
+        }
+        if (!isTokenProvider(provider) && isFunction(value?.[afterResolve])) {
+            wrapInResolveError(() => {
+                const returnValue = value[afterResolve](argument, afterResolveContext);
+                throwOnPromise(returnValue, '[afterResolve] method', chain);
+            }, 'Error in [afterResolve] method', chain);
+        }
+        if (isProviderWithInitializer(provider)) {
+            wrapInResolveError(() => {
+                const returnValue = provider.afterResolve?.(value, argument, afterResolveContext);
+                throwOnPromise(returnValue, 'provider afterResolve handler', chain);
+            }, 'Error in providers afterResolve handler', chain);
+        }
+        if (isDefined(registration.options.afterResolve)) {
+            wrapInResolveError(() => {
+                const returnValue = registration.options.afterResolve(value, argument, afterResolveContext);
                 throwOnPromise(returnValue, 'registration afterResolve handler', resolution.chain);
-            }
-        }
-        catch (error) {
-            if (error instanceof ResolveError) {
-                throw error;
-            }
-            throw new ResolveError('Error in afterResolve hook.', resolution.chain, error);
+            }, `Error in registration afterResolve handler`, chain);
         }
     }
 }
@@ -600,42 +572,31 @@ async function postProcessAsync(context) {
     }
     derefForwardRefs(context);
     for (const resolution of context.resolutions) {
-        try {
-            for (const afterResolveHandler of resolution.afterResolveRegistrations) {
-                await afterResolveHandler(resolution.argument, resolution.afterResolveContext);
-            }
-            if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
-                await resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
-            }
-            if (isProviderWithInitializer(resolution.registration.provider)) {
-                await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
-            }
-            if (isDefined(resolution.registration.options.afterResolve)) {
-                await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
-            }
+        const { registration, value, argument, afterResolveContext, afterResolveRegistrations, chain } = resolution;
+        const provider = registration.provider;
+        for (const afterResolveHandler of afterResolveRegistrations) {
+            await wrapInResolveErrorAsync(async () => await afterResolveHandler(argument, afterResolveContext), 'Error in registered async afterResolve handler', chain);
         }
-        catch (error) {
-            if (error instanceof ResolveError) {
-                throw error;
-            }
-            throw new ResolveError('Error in async afterResolve hook.', resolution.chain, error);
+        if (!isTokenProvider(provider) && isFunction(value?.[afterResolve])) {
+            await wrapInResolveErrorAsync(async () => await value[afterResolve](argument, afterResolveContext), 'Error in async [afterResolve] method', chain);
+        }
+        if (isProviderWithInitializer(provider)) {
+            await wrapInResolveErrorAsync(async () => await provider.afterResolve?.(value, argument, afterResolveContext), 'Error in providers async afterResolve handler', chain);
+        }
+        if (isDefined(registration.options.afterResolve)) {
+            await wrapInResolveErrorAsync(() => registration.options.afterResolve(value, argument, afterResolveContext), 'Error in registration async afterResolve handler', chain);
         }
     }
 }
 function resolveArgumentIdentity(registration, resolveArgument, chain) {
     if (isDefined(registration.options.argumentIdentityProvider) && ((registration.options.lifecycle == 'resolution') || (registration.options.lifecycle == 'singleton'))) {
-        try {
-            return registration.options.argumentIdentityProvider(resolveArgument);
-        }
-        catch (error) {
-            throw new ResolveError('Error in argumentIdentityProvider.', chain, error);
-        }
+        return wrapInResolveError(() => registration.options.argumentIdentityProvider(resolveArgument), 'Error in argumentIdentityProvider', chain);
     }
     return resolveArgument;
 }
 function setResolving(token, context, chain) {
     if (context.resolving.has(token)) {
-        throw new ResolveError('Circular dependency to itself detected. Please check your registrations and providers. ForwardRef might be a solution.', chain);
+        throw new ResolveError('Circular dependency detected. Use forwardRef for circular dependencies between classes.', chain);
     }
     context.resolving.add(token);
 }
@@ -644,12 +605,12 @@ function deleteResolving(token, context) {
 }
 function throwOnPromise(value, type, chain) {
     if (isPromise(value)) {
-        throw new ResolveError(`Cannot evaluate async ${type} in synchronous resolve, use resolveAsync() instead.`, chain);
+        throw new ResolveError(`Cannot evaluate async ${type} in a synchronous resolve. Use resolveAsync() instead.`, chain);
     }
 }
 function checkOverflow(chain, context) {
     if ((chain.length > 100) || (++context.resolves > 7500)) {
-        throw new ResolveError('Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle or forwardRef instead.', chain);
+        throw new ResolveError('Resolve stack overflow. This may indicate a circular dependency with transient lifecycles. Consider using a scoped or singleton lifecycle, or forwardRef.', chain);
     }
 }
 function derefForwardRefs(context) {
@@ -658,10 +619,31 @@ function derefForwardRefs(context) {
             continue;
         }
         for (const [key, value] of objectEntries(resolution.value)) {
-            if (!context.forwardRefs.has(value)) {
-                continue;
+            if (context.forwardRefs.has(value)) {
+                resolution.value[key] = ForwardRef.deref(value);
             }
-            resolution.value[key] = ForwardRef.deref(value);
         }
     }
 }
+function wrapInResolveError(action, errorMessage, chain) {
+    try {
+        return action();
+    }
+    catch (error) {
+        if (error instanceof ResolveError) {
+            throw error;
+        }
+        throw new ResolveError(errorMessage, chain, error);
+    }
+}
+async function wrapInResolveErrorAsync(action, errorMessage, chain) {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof ResolveError) {
+            throw error;
+        }
+        throw new ResolveError(errorMessage, chain, error);
+    }
+}

package/injector/registration.error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from '../errors/custom.error.js';
+/**
+ * Represents an error that occurs during the provider registration phase.
+ * This indicates a configuration or setup issue, rather than a runtime resolution failure.
+ */
+export declare class RegistrationError extends CustomError {
+    constructor(message: string);
+}

package/injector/registration.error.js

@@ -0,0 +1,11 @@
+import { CustomError } from '../errors/custom.error.js';
+/**
+ * Represents an error that occurs during the provider registration phase.
+ * This indicates a configuration or setup issue, rather than a runtime resolution failure.
+ */
+export class RegistrationError extends CustomError {
+    constructor(message) {
+        super({ message });
+        this.name = 'RegistrationError';
+    }
+}

package/injector/resolve.error.js

@@ -1,12 +1,9 @@
 import { CustomError } from '../errors/custom.error.js';
-import { isDefined } from '../utils/type-guards.js';
 export class ResolveError extends CustomError {
     constructor(message, chain, cause) {
-        const causeMessage = isDefined(cause) ? `\n  cause: ${cause.message}` : '';
         super({
-            message: `${message}${causeMessage}\n  chain: ${chain.format(15)}`,
+            message: `${message}\n  chain: ${chain.format(15)}`,
             cause,
-            stack: cause?.stack,
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.11",
+  "version": "0.93.12",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"