@privateaim/server-kit 0.8.20 → 0.8.22

package/dist/index.mjs

@@ -1,12 +1,12 @@
-import { isObject, hasOwnProperty as hasOwnProperty$1, createNanoID, buildDomainEventFullName } from '@privateaim/kit';
+import { createNanoID, isObject, hasOwnProperty as hasOwnProperty$1, buildDomainEventFullName, WEEK_IN_MS, HOUR_IN_MS } from '@privateaim/kit';
 import { ExchangeType } from 'amqp-extension';
 export { Client as AmqpClient } from 'amqp-extension';
 import { singa } from 'singa';
 export { VaultClient, createClient as createVaultClient } from '@hapic/vault';
 import { Client, ClientAuthenticationHook } from '@authup/core-http-kit';
 import { JsonAdapter, buildKeyPath } from 'redis-extension';
-export { Client as RedisClient, ClientOptions as RedisClientOptions, buildKeyPath as buildRedisKeyPath, createClient as createRedisClient } from 'redis-extension';
-import TTLCache from '@isaacs/ttlcache';
+export { Client as RedisClient, buildKeyPath as buildRedisKeyPath, createClient as createRedisClient } from 'redis-extension';
+import { TTLCache } from '@isaacs/ttlcache';
 import { transports, createLogger as createLogger$1, format } from 'winston';
 import { read } from 'envix';
 import Transport from 'winston-transport';
@@ -24,129 +24,71 @@ import { Emitter } from '@socket.io/redis-emitter';
     return EnvironmentName;
 }({});
 
-/*
- * Copyright (c) 2023-2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function _define_property$9(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-class ComponentError extends Error {
-    constructor(input){
-        super(input.message, {
-            cause: input.cause
-        }), _define_property$9(this, "code", void 0);
-        this.code = input.code;
-    }
-}
-
-/*
- * Copyright (c) 2022-2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-function isComponentHandlerFn(input) {
-    return typeof input === 'function';
-}
-
 /*
  * Copyright (c) 2025.
  * Author Peter Placzek (tada5hi)
  * For the full copyright and license information,
  * view the LICENSE file that was distributed with this source code.
- */ function _define_property$8(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-class ComponentHandlers {
-    mount(key, fn) {
-        this.handlers[key] = fn;
-    }
-    unmount(key) {
-        delete this.handlers[key];
-    }
-    async initialize() {
-        if (this.initializing || this.initialized) {
-            return;
-        }
-        this.initializing = true;
-        const keys = Object.keys(this.handlers);
-        for(let i = 0; i < keys.length; i++){
-            const handler = this.handlers[keys[i]];
-            if (!isComponentHandlerFn(handler) && handler.initialize) {
-                await handler.initialize();
+ */ class CompoundComponentCaller {
+    callers;
+    constructor(callers){
+        this.callers = callers;
+    }
+    async call(key, ...payload) {
+        const [data, metadata] = payload;
+        for(let i = 0; i < this.callers.length; i++){
+            const caller = this.callers[i];
+            try {
+                await caller.call(key, data, metadata);
+                return;
+            } catch (e) {
+            // continue;
             }
         }
-        this.initialized = true;
-        this.initializing = false;
-    }
-    async execute(key, value = {}, metadata = {}) {
-        await this.initialize();
-        const handler = this.handlers[key];
-        if (!handler) {
-            return;
-        }
-        if (isComponentHandlerFn(handler)) {
-            await handler(value, {
-                key,
-                metadata
-            });
-        } else {
-            await handler.handle(value, {
-                key,
-                metadata
-            });
-        }
-    }
-    constructor(){
-        _define_property$8(this, "initializing", void 0);
-        _define_property$8(this, "initialized", void 0);
-        _define_property$8(this, "handlers", void 0);
-        this.initializing = false;
-        this.initialized = false;
-        this.handlers = {};
+        throw new Error('No caller could call component.');
     }
 }
 
-function isComponentError(input) {
-    if (!isObject(input)) {
-        return false;
+class DirectComponentCaller {
+    component;
+    constructor(component){
+        this.component = component;
     }
-    if (typeof input.message !== 'undefined' && typeof input.message !== 'string') {
-        return false;
+    /**
+     * Call a specific handler and collect all unhandled events.
+     *
+     * @param key
+     * @param payload
+     */ async call(key, ...payload) {
+        const [data, metadata] = payload;
+        await this.callAndWait(key, data, metadata);
     }
-    if (typeof input.code === 'undefined') {
-        return true;
+    async callWith(key, data, metadata, options) {
+        if (!this.component.handle) {
+            throw new Error(`Component ${this.component.constructor.name} can not be called.`);
+        }
+        metadata.correlationId = metadata.correlationId || createNanoID();
+        await this.component.handle(key, data, metadata, options);
+    }
+    /**
+     * Call a specific handler and collect all unhandled events.
+     *
+     * @param key
+     * @param payload
+     */ async callAndWait(key, ...payload) {
+        const [data, metadata] = payload;
+        if (!this.component.handle) {
+            throw new Error(`Component ${this.component.constructor.name} can not be called.`);
+        }
+        const events = {};
+        const options = {
+            handle: (childValue, childContext)=>{
+                events[childContext.key] = childValue;
+            }
+        };
+        await this.callWith(key, data, metadata, options);
+        return events;
     }
-    return typeof input.code === 'string' || input.code === null;
-}
-
-function isQueuePayload(input) {
-    return isObject(input) && hasOwnProperty$1(input, 'data') && isObject(input.data) && hasOwnProperty$1(input, 'metadata') && isObject(input.metadata);
 }
 
 /*
@@ -291,25 +233,15 @@ function useRedisSubscribeClient() {
     return instance$4.use();
 }
 
-/*
- * Copyright (c) 2024-2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function _define_property$7(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
+class MemoryCacheAdapter {
+    instance;
+    constructor(options = {}){
+        this.instance = new TTLCache({
+            checkAgeOnGet: true,
+            ttl: Infinity,
+            ...options || {}
         });
-    } else {
-        obj[key] = value;
     }
-    return obj;
-}
-class MemoryCacheAdapter {
     async get(key) {
         return this.instance.get(key);
     }
@@ -334,7 +266,7 @@ class MemoryCacheAdapter {
             const keys = this.instance.keys();
             let iterator = keys.next();
             while(!iterator.done){
-                if (iterator.value.startsWith(options.prefix)) {
+                if (typeof iterator.value === 'string' && iterator.value.startsWith(options.prefix)) {
                     this.instance.delete(iterator.value);
                 }
                 iterator = keys.next();
@@ -343,35 +275,15 @@ class MemoryCacheAdapter {
         }
         this.instance.clear();
     }
-    constructor(options = {}){
-        _define_property$7(this, "instance", void 0);
-        this.instance = new TTLCache({
-            checkAgeOnGet: true,
-            ttl: Infinity,
-            ...options || {}
-        });
-    }
 }
 
-/*
- * Copyright (c) 2024-2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function _define_property$6(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 class RedisCacheAdapter {
+    client;
+    instance;
+    constructor(){
+        this.client = useRedisClient();
+        this.instance = new JsonAdapter(this.client);
+    }
     async get(key) {
         return this.instance.get(key);
     }
@@ -406,12 +318,6 @@ class RedisCacheAdapter {
         }
         await this.client.flushdb();
     }
-    constructor(){
-        _define_property$6(this, "client", void 0);
-        _define_property$6(this, "instance", void 0);
-        this.client = useRedisClient();
-        this.instance = new JsonAdapter(this.client);
-    }
 }
 
 function createCacheAdapter() {
@@ -430,20 +336,11 @@ function buildCacheKey(options) {
  * Author Peter Placzek (tada5hi)
  * For the full copyright and license information,
  * view the LICENSE file that was distributed with this source code.
- */ function _define_property$5(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
+ */ class Cache {
+    adapter;
+    constructor(adapter){
+        this.adapter = adapter;
     }
-    return obj;
-}
-class Cache {
     async set(key, value, options = {}) {
         await this.adapter.set(key, value, options);
     }
@@ -462,10 +359,6 @@ class Cache {
     async clear(options = {}) {
         return this.adapter.clear(options);
     }
-    constructor(adapter){
-        _define_property$5(this, "adapter", void 0);
-        this.adapter = adapter;
-    }
 }
 
 const instance$3 = singa({
@@ -496,32 +389,12 @@ function createLoggerConsoleTransport(options = {}) {
     return new LoggerConsoleTransport(options);
 }
 
-/*
- * Copyright (c) 2025.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function _define_property$4(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 class LoggerMemoryTransport extends Transport {
+    items = [];
     log(info, next) {
         this.items.push(info);
         next();
     }
-    constructor(...args){
-        super(...args), _define_property$4(this, "items", []);
-    }
 }
 
 function createLogger(ctx = {}) {
@@ -558,25 +431,11 @@ function useLogger() {
     return instance$2.use();
 }
 
-/*
- * Copyright (c) 2024-2025.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function _define_property$3(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 class EntityEventPublisher {
+    handlers;
+    constructor(){
+        this.handlers = new Set();
+    }
     register(consumer) {
         this.handlers.add(consumer);
     }
@@ -613,10 +472,6 @@ class EntityEventPublisher {
             await handler.value.handle(consumeContext);
         }
     }
-    constructor(){
-        _define_property$3(this, "handlers", void 0);
-        this.handlers = new Set();
-    }
 }
 
 function transformEntityEventData(input) {
@@ -652,25 +507,11 @@ function buildEntityEventRedisChannel(channel, namespace) {
     return `${namespaceNormalized}/${channelNormalized}`;
 }
 
-/*
- * Copyright (c) 2023-2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function _define_property$2(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 class EntityEventRedisHandler {
+    driver;
+    constructor(client){
+        this.driver = client;
+    }
     async handle(ctx) {
         const payload = {
             type: ctx.metadata.ref_type,
@@ -686,31 +527,13 @@ class EntityEventRedisHandler {
         }
         await pipeline.exec();
     }
-    constructor(client){
-        _define_property$2(this, "driver", void 0);
-        this.driver = client;
-    }
 }
 
-/*
- * Copyright (c) 2022-2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function _define_property$1(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 class EntityEventSocketHandler {
+    client;
+    constructor(client){
+        this.client = client;
+    }
     async handle(ctx) {
         ctx.data = transformEntityEventData(ctx.data);
         for(let i = 0; i < ctx.destinations.length; i++){
@@ -746,10 +569,6 @@ class EntityEventSocketHandler {
         }
         return channel.join('/');
     }
-    constructor(client){
-        _define_property$1(this, "client", void 0);
-        this.client = client;
-    }
 }
 
 const instance$1 = singa({
@@ -762,29 +581,102 @@ function useEntityEventPublisher() {
     return instance$1.use();
 }
 
-/*
- * Copyright (c) 2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
+function isTaskEntry(input) {
+    return isObject(input) && typeof input.type === 'string' && isObject(input.data);
+}
+
+class TaskManager {
+    driver;
+    constructor(driver){
+        this.driver = driver;
+    }
+    /**
+     * Store a specific job by type.
+     *
+     * @param type
+     * @param data
+     * @param options
+     */ async create(type, data, options = {}) {
+        let id;
+        if (options.key) {
+            id = `task:${options.key(type, data)}`;
+        } else {
+            id = `task:${createNanoID()}`;
+        }
+        if (options.lock) {
+            const isLocked = await this.isLocked(id);
+            if (isLocked) {
+                return id;
+            }
+        }
+        const entity = {
+            data,
+            type
+        };
+        await this.driver.set(id, entity, {
+            ttl: WEEK_IN_MS
         });
-    } else {
-        obj[key] = value;
+        if (options.lock) {
+            await this.createLock(id);
+        }
+        return id;
+    }
+    /**
+     * Get a job by id and type
+     *
+     * @param type
+     * @param id
+     * @param autoDelete
+     */ async get(type, id, autoDelete = true) {
+        const entity = await this.resolve(id, autoDelete);
+        if (!entity) {
+            throw new Error(`Job with id ${id} could not be found.`);
+        }
+        if (type && entity.type !== type) {
+            throw new Error(`Job type ${entity.type} does not not match with ${type}`);
+        }
+        return entity.data;
+    }
+    /**
+     * Find a random job.
+     *
+     * @param id
+     * @param autoDelete
+     */ async resolve(id, autoDelete = true) {
+        const entity = await this.driver.get(id);
+        if (!entity || !isTaskEntry(entity)) {
+            return undefined;
+        }
+        await this.clearLock(id);
+        if (autoDelete) {
+            await this.driver.drop(id);
+        }
+        return entity;
+    }
+    // -------------------------------------------------
+    async createLock(id) {
+        await this.driver.set(`taskLock:${id}`, true, {
+            ttl: HOUR_IN_MS
+        });
+    }
+    async clearLock(id) {
+        await this.driver.drop(`taskLock:${id}`);
+    }
+    async isLocked(id) {
+        const isActive = await this.driver.get(`taskLock:${id}`);
+        return !!isActive;
     }
-    return obj;
 }
+
 class QueueRouter {
+    driver;
+    //----------------------------------------------------------------
+    constructor(driver){
+        this.driver = driver;
+    }
     //----------------------------------------------------------------
     publish(message, options = {}) {
-        var _options;
-        (_options = options).logging ?? (_options.logging = true);
+        options.logging ??= true;
         let exchange;
         if (message.metadata.routing.type === 'work') {
             exchange = this.driver.of({
@@ -866,11 +758,6 @@ class QueueRouter {
             }
         });
     }
-    //----------------------------------------------------------------
-    constructor(driver){
-        _define_property(this, "driver", void 0);
-        this.driver = driver;
-    }
 }
 
 const instance = singa({
@@ -887,5 +774,218 @@ function useQueueRouter() {
     return instance.use();
 }
 
-export { AuthupClient, Cache, ComponentError, ComponentHandlers, EntityEventPublisher, EntityEventRedisHandler, EntityEventSocketHandler, EnvironmentName, LoggerConsoleTransport, LoggerMemoryTransport, MemoryCacheAdapter, QueueRouter, QueueRouterRoutingType, RedisCacheAdapter, buildCacheKey, buildEntityEventRedisChannel, buildQueueRouterPublishPayload, createCacheAdapter, createLogger, createLoggerConsoleTransport, guessAuthupTokenCreatorOptions, hasOwnProperty, isAmqpClientUsable, isAuthupClientUsable, isClientAuthenticationHookUsable, isComponentError, isLoggerUsable, isQueuePayload, isQueueRouterPayload, isQueueRouterUsable, isRedisClientUsable, isVaultClientUsable, setAmqpClientFactory, setAuthupClientFactory, setClientAuthenticationHookFactory, setEntityEventPublisherFactory, setLogger, setLoggerFactory, setRedisClient, setRedisFactory, setVaultFactory, useAmqpClient, useAuthupClient, useCache, useClientAuthenticationHook, useEntityEventPublisher, useLogger, useQueueRouter, useRedisClient, useRedisPublishClient, useRedisSubscribeClient, useVaultClient };
+class QueueDispatchComponentCaller {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    async call(type, ...payload) {
+        const [data, metadata] = payload;
+        if (!isQueueRouterUsable()) {
+            useLogger().warn(`Can not publish ${type} event.`);
+            return;
+        }
+        const client = useQueueRouter();
+        await client.publish(buildQueueRouterPublishPayload({
+            type,
+            data,
+            metadata: {
+                ...metadata,
+                routing: this.options.queue
+            }
+        }), {
+            logging: this.options.logging ?? true
+        });
+    }
+}
+
+class QueueWorkerComponentCaller {
+    component;
+    options;
+    constructor(component, options){
+        this.component = component;
+        this.options = options;
+    }
+    async start() {
+        if (!isQueueRouterUsable()) {
+            useLogger().warn(`Can not consume queue for component ${this.component.constructor.name}`);
+            return;
+        }
+        const client = useQueueRouter();
+        await client.consumeAny(this.options.consumeQueue, async (payload)=>{
+            await this.call(payload.type, payload.data, payload.metadata);
+        });
+    }
+    /**
+     * Call a specific handler and collect all unhandled events.
+     *
+     * @param key
+     * @param payload
+     */ async call(key, ...payload) {
+        const [data, metadata] = payload;
+        if (!this.component.handle) {
+            throw new Error(`Component ${this.component.constructor.name} can not be called.`);
+        }
+        const client = useQueueRouter();
+        const options = {
+            handle: async (childValue, childContext)=>{
+                if (this.options.publishQueue) {
+                    /**
+                     *
+                     * publish unhandled requests to publish queue.
+                     */ await client.publish(buildQueueRouterPublishPayload({
+                        type: childContext.key,
+                        data: childValue,
+                        metadata: {
+                            ...metadata || {},
+                            ...childContext.metadata,
+                            routing: this.options.publishQueue
+                        }
+                    }));
+                } else {
+                    useLogger().warn(`Component ${this.component.constructor.name} event ${childContext.key} could not be handled.`);
+                }
+            }
+        };
+        await this.component.handle(key, data, metadata, options);
+    }
+}
+
+/*
+ * Copyright (c) 2023-2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ class ComponentError extends Error {
+    code;
+    constructor(input){
+        super(input.message, {
+            cause: input.cause
+        });
+        this.code = input.code;
+    }
+}
+
+/*
+ * Copyright (c) 2022-2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+function isComponentHandler(input) {
+    if (!isObject(input)) {
+        return false;
+    }
+    return !(!hasOwnProperty(input, 'execute') || typeof input.execute !== 'function');
+}
+function isComponentHandlerFn(input) {
+    return typeof input === 'function';
+}
+
+/*
+ * Copyright (c) 2025.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ class BaseComponent {
+    initializePromise;
+    initialized;
+    handlers;
+    constructor(){
+        this.initializePromise = undefined;
+        this.initialized = false;
+        this.handlers = new Map();
+    }
+    mount(key, fn) {
+        this.handlers.set(key, fn);
+    }
+    unmount(key) {
+        this.handlers.delete(key);
+    }
+    async initialize() {
+        if (this.initialized) {
+            return Promise.resolve();
+        }
+        if (this.initializePromise) {
+            return this.initializePromise;
+        }
+        const promises = [];
+        const keys = Array.from(this.handlers.keys());
+        for(let i = 0; i < keys.length; i++){
+            const handler = this.handlers.get(keys[i]);
+            if (typeof handler !== 'function' && handler.initialize) {
+                promises.push(Promise.resolve().then(()=>handler.initialize()));
+            }
+        }
+        this.initializePromise = new Promise((resolve, reject)=>{
+            Promise.all(promises).then(()=>resolve()).catch((err)=>reject(err));
+        });
+        this.initializePromise.finally(()=>{
+            setTimeout(()=>{
+                this.initialized = true;
+                this.initializePromise = undefined;
+            }, 0);
+        });
+        return this.initializePromise;
+    }
+    /**
+     * Handle specific component event.
+     *
+     * @param key
+     * @param data
+     * @param metadata
+     * @param options
+     */ async handle(key, data, metadata = {}, options = {}) {
+        await this.initialize();
+        const context = {
+            key,
+            metadata,
+            handle: (childKey, childData, childMetadata)=>{
+                this.handle(childKey, childData, {
+                    ...metadata,
+                    ...childMetadata || {}
+                }, {
+                    ...options,
+                    ...options || {}
+                });
+            }
+        };
+        let handler = this.handlers.get(key);
+        if (handler) {
+            if (typeof handler === 'function') {
+                return handler(data, context);
+            }
+            return handler.handle(data, context);
+        }
+        handler = this.handlers.get('*');
+        if (handler) {
+            if (typeof handler === 'function') {
+                return handler(data, context);
+            }
+            return handler.handle(data, context);
+        }
+        if (options.handle) {
+            return options.handle(data, context);
+        }
+        return Promise.resolve();
+    }
+}
+
+function isComponentError(input) {
+    if (!isObject(input)) {
+        return false;
+    }
+    if (typeof input.message !== 'undefined' && typeof input.message !== 'string') {
+        return false;
+    }
+    if (typeof input.code === 'undefined') {
+        return true;
+    }
+    return typeof input.code === 'string' || input.code === null;
+}
+
+export { AuthupClient, BaseComponent, Cache, ComponentError, CompoundComponentCaller, DirectComponentCaller, EntityEventPublisher, EntityEventRedisHandler, EntityEventSocketHandler, EnvironmentName, LoggerConsoleTransport, LoggerMemoryTransport, MemoryCacheAdapter, QueueDispatchComponentCaller, QueueRouter, QueueRouterRoutingType, QueueWorkerComponentCaller, RedisCacheAdapter, TaskManager, buildCacheKey, buildEntityEventRedisChannel, buildQueueRouterPublishPayload, createCacheAdapter, createLogger, createLoggerConsoleTransport, guessAuthupTokenCreatorOptions, hasOwnProperty, isAmqpClientUsable, isAuthupClientUsable, isClientAuthenticationHookUsable, isComponentError, isComponentHandler, isComponentHandlerFn, isLoggerUsable, isQueueRouterPayload, isQueueRouterUsable, isRedisClientUsable, isVaultClientUsable, setAmqpClientFactory, setAuthupClientFactory, setClientAuthenticationHookFactory, setEntityEventPublisherFactory, setLogger, setLoggerFactory, setRedisClient, setRedisFactory, setVaultFactory, useAmqpClient, useAuthupClient, useCache, useClientAuthenticationHook, useEntityEventPublisher, useLogger, useQueueRouter, useRedisClient, useRedisPublishClient, useRedisSubscribeClient, useVaultClient };
 //# sourceMappingURL=index.mjs.map