@zlink-systems/nestjs 0.29.1 → 0.30.1

package/dist/providers.js

@@ -6,9 +6,11 @@ exports.conditionalClientProviders = conditionalClientProviders;
 exports.conditionalClientProvidersForFactory = conditionalClientProvidersForFactory;
 exports.conditionalClientTokens = conditionalClientTokens;
 exports.createRuntimeHost = createRuntimeHost;
-exports.createNestHandlerInstance = createNestHandlerInstance;
-exports.validateNestConstructorDependencies = validateNestConstructorDependencies;
+exports.nestHandlerFactories = nestHandlerFactories;
+exports.registeredNestHandlerFactory = registeredNestHandlerFactory;
+exports.prepareNestHandlerFactory = prepareNestHandlerFactory;
 exports.providerToken = providerToken;
+const common_1 = require("@nestjs/common");
 const constants_1 = require("@nestjs/common/constants");
 const core_1 = require("@nestjs/core");
 const unknown_element_exception_1 = require("@nestjs/core/errors/exceptions/unknown-element.exception");
@@ -126,7 +128,9 @@ const CONDITIONAL_CLIENT_PROVIDER_SPECS = [
         isEnabled: (registration) => framework_loader_1.framework.hasActorManager(registration),
         create: async (registration, runtime, moduleRef, discovery) => {
             const host = requireRuntime(runtime);
-            return framework_loader_1.framework.createIntegrationActorManager(registration, host, moduleRef === undefined ? undefined : createProviderResolver(moduleRef, discovery));
+            return framework_loader_1.framework.createIntegrationActorManager(registration, host, moduleRef === undefined
+                ? undefined
+                : createProviderResolver(moduleRef, discovery, registration));
         }
     },
     {
@@ -225,6 +229,18 @@ function hasLocationStores(registration) {
     return (registration.locations.useInMemoryStores || registration.locations.storeInstance !== undefined);
 }
 function createRuntimeHost(registration, moduleRef, discovery) {
+    const runtime = framework_loader_1.framework.createIntegrationRuntimeHost(registration, createProviderResolver(moduleRef, discovery, registration));
+    runtime.onModuleInit = async () => {
+        await runtime.start();
+    };
+    runtime.onModuleDestroy = async () => {
+        await runtime.shutdown();
+    };
+    runtime.onApplicationBootstrap = async () => { };
+    return runtime;
+}
+function createProviderResolver(moduleRef, discovery, registration) {
+    const factories = nestHandlerFactories(registration);
     const types = new Set([...registration.spotFactories, ...registration.filterTypes]);
     for (const node of registration.spotNodes.values()) {
         if (node.entrySpotType !== undefined)
@@ -238,6 +254,8 @@ function createRuntimeHost(registration, moduleRef, discovery) {
         for (const value of Object.values(node.instanceSpotFactoryRegistrations ?? {}))
             types.add(value.implementation);
         for (const handler of [
+            ...(node.routeSendHandlers ?? []),
+            ...(node.routeRequestHandlers ?? []),
             ...(node.entrySpotTimerHandlers ?? []),
             ...(node.entrySpotPacketHandlers ?? []),
             ...(node.entrySpotSubscriptionHandlers ?? []),
@@ -248,27 +266,34 @@ function createRuntimeHost(registration, moduleRef, discovery) {
             ...(node.spotSubscriptionHandlers ?? []),
             ...(node.spotActorSendHandlers ?? []),
             ...(node.spotActorRequestHandlers ?? [])
-        ])
-            types.add(handler.handlerType);
+        ]) {
+            const handlerType = handler.handlerType;
+            if (handlerType !== undefined)
+                types.add(handlerType);
+        }
+        for (const channel of Object.values(node.meshChannels ?? {})) {
+            for (const handler of [...(channel.sendHandlers ?? []), ...(channel.requestHandlers ?? [])]) {
+                const handlerType = handler.handlerType;
+                if (handlerType !== undefined)
+                    types.add(handlerType);
+            }
+        }
+    }
+    function prepareHandler(type) {
+        return registeredNestHandlerFactory(factories, type, moduleRef).scopeFree;
     }
     for (const type of types)
-        validateNestConstructorDependencies(moduleRef, type);
-    const runtime = framework_loader_1.framework.createIntegrationRuntimeHost(registration, createProviderResolver(moduleRef, discovery));
-    runtime.onModuleInit = async () => {
-        await runtime.start();
-    };
-    runtime.onModuleDestroy = async () => {
-        await runtime.shutdown();
-    };
-    runtime.onApplicationBootstrap = async () => { };
-    return runtime;
-}
-function createProviderResolver(moduleRef, discovery) {
+        prepareHandler(type);
+    function createHandler(contextId, dependencies, type) {
+        const factory = factories.get(type);
+        if (factory === undefined)
+            throw new Error(`Handler creation was not prepared: ${type.name}`);
+        return factory(moduleRef, contextId, dependencies);
+    }
     const resolver = {
         get(type) {
-            const discovered = findDiscoveredProvider(discovery, type)?.instance;
-            if (discovered !== undefined) {
-                return discovered;
+            if (discovery !== undefined) {
+                return findDiscoveredProvider(discovery, type)?.instance;
             }
             try {
                 return moduleRef.get(type, { strict: false });
@@ -283,56 +308,68 @@ function createProviderResolver(moduleRef, discovery) {
             return await creationModuleRef.create(type);
         }
     };
-    Object.defineProperty(resolver, Symbol.for('@zlink-systems/framework.handler-instance-scope-factory'), {
-        value: {
-            create(context) {
-                const currentContextId = (0, dispatch_scope_1.currentNestDispatchContext)();
-                const contextId = currentContextId ?? core_1.ContextIdFactory.create();
-                if (context !== undefined && currentContextId === undefined) {
-                    moduleRef.registerRequestByContextId({ zlinkContext: context }, contextId);
-                }
-                const instances = new Map();
-                const dependencies = new Map();
-                const owned = [];
-                let disposed = false;
-                return {
-                    async resolve(type) {
-                        if (disposed) {
-                            throw new Error('Handler instance scope is already disposed.');
-                        }
-                        let instance = instances.get(type);
-                        if (instance === undefined) {
-                            instance = createNestHandlerInstance(moduleRef, contextId, dependencies, type).then(async (created) => {
+    let freeScopeStorage;
+    framework_loader_1.framework.registerIntegrationHandlerInstanceScopeFactory(resolver, {
+        prepare: prepareHandler,
+        create(context) {
+            const currentContextId = (0, dispatch_scope_1.currentNestDispatchContext)();
+            const contextId = currentContextId ?? core_1.ContextIdFactory.create();
+            if (context !== undefined && currentContextId === undefined) {
+                moduleRef.registerRequestByContextId({ zlinkContext: context }, contextId);
+            }
+            const storage = freeScopeStorage ?? new NestHandlerScopeStorage();
+            freeScopeStorage = storage.next;
+            storage.next = undefined;
+            const { instances, dependencies, owned } = storage;
+            let disposed = false;
+            return {
+                resolve(type) {
+                    if (disposed) {
+                        return Promise.reject(new Error('Handler instance scope is already disposed.'));
+                    }
+                    let instance = instances.get(type);
+                    if (instance === undefined) {
+                        try {
+                            const finish = (created) => {
                                 if (disposed) {
-                                    await framework_loader_1.framework.disposeIntegrationHandler(created);
-                                    throw new Error('Handler instance scope was disposed during activation.');
+                                    return framework_loader_1.framework.disposeIntegrationHandler(created).then(() => {
+                                        throw new Error('Handler instance scope was disposed during activation.');
+                                    });
                                 }
                                 owned.push(created);
                                 return created;
-                            });
+                            };
+                            const created = createHandler(contextId, dependencies, type);
+                            instance = isNestPromiseLike(created)
+                                ? Promise.resolve(created).then(finish)
+                                : Promise.resolve(finish(created));
                             instances.set(type, instance);
                         }
-                        return (await instance);
-                    },
-                    async dispose() {
-                        if (disposed)
-                            return;
-                        disposed = true;
-                        const pending = [...instances.values()];
-                        await Promise.allSettled(pending);
-                        try {
-                            await framework_loader_1.framework.disposeIntegrationHandlers(owned);
-                        }
-                        finally {
-                            owned.length = 0;
-                            instances.clear();
-                            dependencies.clear();
+                        catch (error) {
+                            return Promise.reject(error);
                         }
                     }
-                };
-            }
-        },
-        enumerable: false
+                    return instance;
+                },
+                async dispose() {
+                    if (disposed)
+                        return;
+                    disposed = true;
+                    if (owned.length !== instances.size)
+                        await Promise.allSettled(instances.values());
+                    try {
+                        await framework_loader_1.framework.disposeIntegrationHandlers(owned);
+                    }
+                    finally {
+                        owned.length = 0;
+                        instances.clear();
+                        dependencies.clear();
+                        storage.next = freeScopeStorage;
+                        freeScopeStorage = storage;
+                    }
+                }
+            };
+        }
     });
     framework_loader_1.framework.registerIntegrationHandlerFilterScope(resolver, (context, callback) => (0, dispatch_scope_1.runInNestDispatchScope)(moduleRef, context, async () => {
         const contextId = (0, dispatch_scope_1.currentNestDispatchContext)();
@@ -341,7 +378,7 @@ function createProviderResolver(moduleRef, discovery) {
         try {
             return await callback({
                 async resolve(type) {
-                    const instance = await createNestHandlerInstance(moduleRef, contextId, dependencies, type);
+                    const instance = await createHandler(contextId, dependencies, type);
                     owned.push(instance);
                     return instance;
                 }
@@ -353,20 +390,86 @@ function createProviderResolver(moduleRef, discovery) {
     }));
     return resolver;
 }
-async function createNestHandlerInstance(moduleRef, contextId, dependencies, type) {
+const NEST_HANDLER_FACTORIES = Symbol('Nest handler factories');
+function nestHandlerFactories(registration, prepared) {
+    const owner = registration;
+    return (owner[NEST_HANDLER_FACTORIES] ??= prepared ?? new Map());
+}
+function registeredNestHandlerFactory(factories, type, moduleRef) {
+    let factory = factories.get(type);
+    if (factory === undefined) {
+        factory = prepareNestHandlerFactory(type, moduleRef);
+        factories.set(type, factory);
+    }
+    return factory;
+}
+class NestHandlerScopeStorage {
+    instances = new Map();
+    dependencies = new Map();
+    owned = [];
+    next;
+}
+function prepareNestHandlerFactory(type, moduleRef) {
     const { reflected, optional } = nestConstructorDependencies(type);
-    const parameters = await Promise.all(reflected.map((token, index) => resolveNestHandlerDependency(moduleRef, contextId, dependencies, token, optional.has(index))));
-    const instance = new type(...parameters);
-    const properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, type);
+    const parameters = reflected.map((token, index) => prepareNestDependency(nestDependencyToken(token), optional.has(index), moduleRef));
     const optionalProperties = new Set(Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, type) ?? []);
-    for (const property of properties ?? []) {
-        const dependency = await resolveNestHandlerDependency(moduleRef, contextId, dependencies, property.type, optionalProperties.has(property.key));
-        if (dependency !== undefined) {
-            instance[property.key] = dependency;
+    const properties = (Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, type) ?? []).map((property) => ({
+        key: property.key,
+        resolve: prepareNestDependency(nestDependencyToken(property.type), optionalProperties.has(property.key), moduleRef)
+    }));
+    const Constructor = type;
+    if (parameters.length === 0 && properties.length === 0) {
+        const activate = () => new Constructor();
+        return Object.assign(activate, { scopeFree: activate });
+    }
+    return (moduleRef, contextId, dependencies) => {
+        const create = (arguments_) => injectNestHandlerProperties(new Constructor(...arguments_), properties, 0, moduleRef, contextId, dependencies);
+        const arguments_ = parameters.map((resolve) => resolve(moduleRef, contextId, dependencies));
+        return arguments_.some(isNestPromiseLike)
+            ? Promise.all(arguments_).then(create)
+            : create(arguments_);
+    };
+}
+function prepareNestDependency(token, optional, moduleRef) {
+    let lookup = (ref, contextId) => ref.resolve(token, contextId, { strict: false });
+    if (moduleRef !== undefined) {
+        try {
+            if (moduleRef.introspect(token).scope ===
+                common_1.Scope.DEFAULT) {
+                lookup = (ref) => ref.get(token, { strict: false });
+            }
+        }
+        catch (error) {
+            if (!(error instanceof unknown_element_exception_1.UnknownElementException) || !optional)
+                throw error;
         }
     }
+    return (ref, contextId, dependencies) => resolveNestHandlerDependency(dependencies, token, optional, lookup, ref, contextId);
+}
+function injectNestHandlerProperties(instance, properties, index, moduleRef, contextId, dependencies) {
+    for (; index < properties.length; index++) {
+        const property = properties[index];
+        const dependency = property.resolve(moduleRef, contextId, dependencies);
+        if (isNestPromiseLike(dependency)) {
+            const next = index + 1;
+            return Promise.resolve(dependency).then((value) => {
+                assignNestHandlerProperty(instance, property.key, value);
+                return injectNestHandlerProperties(instance, properties, next, moduleRef, contextId, dependencies);
+            });
+        }
+        assignNestHandlerProperty(instance, property.key, dependency);
+    }
     return instance;
 }
+function assignNestHandlerProperty(instance, key, dependency) {
+    if (dependency !== undefined)
+        instance[key] = dependency;
+}
+function isNestPromiseLike(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
 function nestConstructorDependencies(type) {
     const reflected = [
         ...(Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) ??
@@ -379,18 +482,6 @@ function nestConstructorDependencies(type) {
     const optional = new Set(Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, type) ?? []);
     return { reflected, optional };
 }
-function validateNestConstructorDependencies(moduleRef, type) {
-    const { reflected, optional } = nestConstructorDependencies(type);
-    for (const [index, token] of reflected.entries()) {
-        try {
-            moduleRef.introspect(nestDependencyToken(token));
-        }
-        catch (error) {
-            if (!(error instanceof unknown_element_exception_1.UnknownElementException) || !optional.has(index))
-                throw error;
-        }
-    }
-}
 function nestDependencyToken(token) {
     const forwardReference = typeof token === 'object' && token !== null && 'forwardRef' in token
         ? token
@@ -399,25 +490,30 @@ function nestDependencyToken(token) {
         ? forwardReference.forwardRef()
         : token;
 }
-async function resolveNestHandlerDependency(moduleRef, contextId, dependencies, token, optional) {
-    const resolvedToken = nestDependencyToken(token);
-    let dependency = dependencies.get(resolvedToken);
-    if (dependency === undefined) {
-        dependency = moduleRef.resolve(resolvedToken, contextId, {
-            strict: false
-        });
-        dependencies.set(resolvedToken, dependency);
-    }
+function resolveNestHandlerDependency(dependencies, token, optional, lookup, moduleRef, contextId) {
+    if (dependencies.has(token))
+        return dependencies.get(token);
     try {
-        return await dependency;
+        const dependency = lookup(moduleRef, contextId);
+        const result = isNestPromiseLike(dependency)
+            ? Promise.resolve(dependency).then((value) => {
+                dependencies.set(token, value);
+                return value;
+            }, (error) => nestDependencyFailure(dependencies, token, optional, error))
+            : dependency;
+        dependencies.set(token, result);
+        return result;
     }
     catch (error) {
-        dependencies.delete(resolvedToken);
-        if (optional)
-            return undefined;
-        throw error;
+        return nestDependencyFailure(dependencies, token, optional, error);
     }
 }
+function nestDependencyFailure(dependencies, token, optional, error) {
+    dependencies.delete(token);
+    if (optional)
+        return undefined;
+    throw error;
+}
 function findDiscoveredProvider(discovery, type) {
     for (const wrapper of discovery?.getProviders() ?? []) {
         if (wrapper.token === type ||
@@ -432,7 +528,7 @@ function providerToken(provider) {
     return typeof provider === 'function' ? provider : provider.provide;
 }
 async function createSpotManager(registration, runtime, moduleRef, discovery) {
-    return framework_loader_1.framework.createIntegrationSpotManager(registration, runtime, moduleRef === undefined ? undefined : createProviderResolver(moduleRef, discovery));
+    return framework_loader_1.framework.createIntegrationSpotManager(registration, runtime, moduleRef === undefined ? undefined : createProviderResolver(moduleRef, discovery, registration));
 }
 async function createSpotOutbound(_registration, runtime, _moduleRef, _discovery) {
     return framework_loader_1.framework.createIntegrationSpotOutbound(runtime);

package/dist/registration-composer.d.ts

@@ -1,6 +1,8 @@
 import type { DiscoveryService, ModuleRef } from '@nestjs/core';
 import type { ZLinkFrameworkRegistrationOptions } from './framework-integration-contracts';
 import { type ZLinkModuleOptions, type ZLinkNestModuleRegistrationOptions } from './contracts';
-export declare function createDiscoveredOptions(options: ZLinkNestModuleRegistrationOptions, discovery: DiscoveryService, moduleRef: ModuleRef): ZLinkFrameworkRegistrationOptions;
+import { type NestHandlerFactories } from './providers';
+export declare function createDiscoveredRegistration(options: ZLinkNestModuleRegistrationOptions, discovery: DiscoveryService, moduleRef: ModuleRef): import("./framework-integration-contracts").ZLinkFrameworkRegistration;
+export declare function createDiscoveredOptions(options: ZLinkNestModuleRegistrationOptions, discovery: DiscoveryService, moduleRef: ModuleRef, factories?: NestHandlerFactories): ZLinkFrameworkRegistrationOptions;
 export declare function createRegistrationOptions(options: ZLinkNestModuleRegistrationOptions): ZLinkFrameworkRegistrationOptions;
 export declare function assertBuiltModuleOptions(options: ZLinkModuleOptions): ZLinkNestModuleRegistrationOptions;

package/dist/registration-composer.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiscoveredRegistration = createDiscoveredRegistration;
 exports.createDiscoveredOptions = createDiscoveredOptions;
 exports.createRegistrationOptions = createRegistrationOptions;
 exports.assertBuiltModuleOptions = assertBuiltModuleOptions;
@@ -7,8 +8,15 @@ const contracts_1 = require("./contracts");
 const provider_discovery_1 = require("./provider-discovery");
 const handler_adapters_1 = require("./handler-adapters");
 const framework_loader_1 = require("./framework-loader");
+const providers_1 = require("./providers");
 const spot_node_handler_registry_1 = require("./spot-node-handler-registry");
-function createDiscoveredOptions(options, discovery, moduleRef) {
+function createDiscoveredRegistration(options, discovery, moduleRef) {
+    const factories = new Map();
+    const registration = framework_loader_1.framework.createFrameworkRegistration(createDiscoveredOptions(options, discovery, moduleRef, factories));
+    (0, providers_1.nestHandlerFactories)(registration, factories);
+    return registration;
+}
+function createDiscoveredOptions(options, discovery, moduleRef, factories = new Map()) {
     const registrationOptions = createRegistrationOptions(options);
     const channels = { ...(registrationOptions.channels ?? {}) };
     const useImplicitHandlers = options.implicitHandlerAutoRegistration !== false;
@@ -25,11 +33,11 @@ function createDiscoveredOptions(options, discovery, moduleRef) {
     const sessionProviderRefs = useImplicitHandlers
         ? (0, provider_discovery_1.discoverSessionProviderRefs)(discovery, moduleRef)
         : [];
-    const spotNodes = createDiscoveredMeshChannelOptions(createDiscoveredSpotNodeOptions(registrationOptions.spotNodes, spotActorProviderRefs, spotProviderRefs, spotTimerProviderRefs), providerRefs, moduleRef);
+    const spotNodes = createDiscoveredMeshChannelOptions(createDiscoveredSpotNodeOptions(registrationOptions.spotNodes, spotActorProviderRefs, spotProviderRefs, spotTimerProviderRefs), providerRefs, moduleRef, factories);
     for (const [channelName, channel] of Object.entries(options.fanoutChannels ?? {})) {
         const existingChannel = channels[channelName];
-        const publishHandlers = (0, handler_adapters_1.createDiscoveredPublishHandlers)(providerRefs, channel.handlerGroups, moduleRef);
-        const manualPublishHandlers = (0, handler_adapters_1.createManualPublishHandlers)(channel.publishHandlerTypes, moduleRef);
+        const publishHandlers = (0, handler_adapters_1.createDiscoveredPublishHandlers)(providerRefs, channel.handlerGroups, moduleRef, factories);
+        const manualPublishHandlers = (0, handler_adapters_1.createManualPublishHandlers)(channel.publishHandlerTypes, moduleRef, factories);
         channels[channelName] = {
             ...existingChannel,
             publishHandlers: [
@@ -45,13 +53,13 @@ function createDiscoveredOptions(options, discovery, moduleRef) {
             ...existingChannel,
             requestHandlers: [
                 ...(existingChannel.requestHandlers ?? []),
-                ...(0, handler_adapters_1.createManualRequestHandlers)(channel.requestHandlerTypes, moduleRef),
-                ...(0, handler_adapters_1.createDiscoveredRequestHandlers)(providerRefs, channel.handlerGroups, moduleRef)
+                ...(0, handler_adapters_1.createManualRequestHandlers)(channel.requestHandlerTypes, moduleRef, factories),
+                ...(0, handler_adapters_1.createDiscoveredRequestHandlers)(providerRefs, channel.handlerGroups, moduleRef, factories)
             ],
             sendHandlers: [
                 ...(existingChannel.sendHandlers ?? []),
-                ...(0, handler_adapters_1.createManualSendHandlers)(channel.sendHandlerTypes, moduleRef),
-                ...(0, handler_adapters_1.createDiscoveredChannelSendHandlers)(providerRefs, channel.handlerGroups, moduleRef)
+                ...(0, handler_adapters_1.createManualSendHandlers)(channel.sendHandlerTypes, moduleRef, factories),
+                ...(0, handler_adapters_1.createDiscoveredChannelSendHandlers)(providerRefs, channel.handlerGroups, moduleRef, factories)
             ]
         };
     }
@@ -73,7 +81,7 @@ function attachDiscoveredSessionHandlers(streamNodes, handlerTypes) {
         return [name, configured];
     }));
 }
-function createDiscoveredMeshChannelOptions(value, providerRefs, moduleRef) {
+function createDiscoveredMeshChannelOptions(value, providerRefs, moduleRef, factories) {
     if (value === undefined || Array.isArray(value)) {
         return value;
     }
@@ -88,12 +96,12 @@ function createDiscoveredMeshChannelOptions(value, providerRefs, moduleRef) {
                     {
                         ...channel,
                         requestHandlers: [
-                            ...(0, handler_adapters_1.createManualRequestHandlers)(channel.requestHandlers, moduleRef),
-                            ...(0, handler_adapters_1.createDiscoveredRequestHandlers)(providerRefs, channel.handlerGroups, moduleRef)
+                            ...(0, handler_adapters_1.createManualRequestHandlers)(channel.requestHandlers, moduleRef, factories),
+                            ...(0, handler_adapters_1.createDiscoveredRequestHandlers)(providerRefs, channel.handlerGroups, moduleRef, factories)
                         ],
                         sendHandlers: [
-                            ...(0, handler_adapters_1.createManualSendHandlers)(channel.sendHandlers, moduleRef),
-                            ...(0, handler_adapters_1.createDiscoveredSendHandlers)(providerRefs, channel.handlerGroups, moduleRef)
+                            ...(0, handler_adapters_1.createManualSendHandlers)(channel.sendHandlers, moduleRef, factories),
+                            ...(0, handler_adapters_1.createDiscoveredSendHandlers)(providerRefs, channel.handlerGroups, moduleRef, factories)
                         ]
                     }
                 ]))
@@ -264,6 +272,7 @@ function createRegistrationOptions(options) {
             routingId: channel.routingId,
             routingIdPrefix: channel.routingIdPrefix,
             noDrop: channel.noDrop,
+            sendTimeoutMs: channel.sendTimeoutMs,
             publishHandlers: channel.publishHandlers,
             publisher: channel.publisher,
             subscriber: channel.subscriber,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/nestjs",
-  "version": "0.29.1",
+  "version": "0.30.1",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -21,8 +21,8 @@
   },
   "dependencies": {
     "@nestjs/common": "^10.4.22",
-    "@zlink-systems/framework": "0.29.1",
-    "@zlink-systems/http-client": "0.29.1",
+    "@zlink-systems/framework": "0.30.1",
+    "@zlink-systems/http-client": "0.30.1",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.2"
   },