@privateaim/server-kit 0.8.13 → 0.8.15

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { isObject, hasOwnProperty as hasOwnProperty$1, createNanoID, buildDomainEventFullName } from '@privateaim/kit';
+import { isObject, hasOwnProperty as hasOwnProperty$1, createNanoID, LogLevel, buildDomainEventFullName } from '@privateaim/kit';
 import { ExchangeType } from 'amqp-extension';
 import { singa } from 'singa';
 export { VaultClient, createClient as createVaultClient } from '@hapic/vault';
@@ -10,6 +10,9 @@ import { read } from 'envix';
 import path from 'node:path';
 import { EnvironmentName } from 'typeorm-extension';
 import { transports, createLogger as createLogger$1, format } from 'winston';
+import WinstonTransport from 'winston-transport';
+import { nanoSeconds } from '@hapic/loki';
+export { LokiClient, CompactorDeletionRequestCreate as LokiCompactorDeletionRequestCreate, Config as LokiConfig, ConfigInput as LokiConfigInput, DistributorPushStream as LokiDistributorPushStream, QuerierQueryRangeOptions as LokiQuerierQueryRangeOptions, QuerierQueryResult as LokiQuerierQueryResult, createClient as createLokiClient, nanoSeconds } from '@hapic/loki';
 import { Emitter } from '@socket.io/redis-emitter';
 
 /*
@@ -17,7 +20,7 @@ import { Emitter } from '@socket.io/redis-emitter';
  * 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) {
+ */ function _define_property$b(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -34,7 +37,7 @@ class ComponentError extends Error {
     constructor(input){
         super(input.message, {
             cause: input.cause
-        }), _define_property$7(this, "code", void 0);
+        }), _define_property$b(this, "code", void 0);
         this.code = input.code;
     }
 }
@@ -82,30 +85,30 @@ function isQueueRouterPayload(input) {
     return isObject(input) && typeof input.id === 'string' && typeof input.type === 'string' && hasOwnProperty$1(input, 'data') && isObject(input.data) && hasOwnProperty$1(input, 'metadata') && isObject(input.metadata);
 }
 
-const instance$a = singa({
+const instance$b = singa({
     name: 'amqp'
 });
 function setAmqpClientFactory(factory) {
-    instance$a.setFactory(factory);
+    instance$b.setFactory(factory);
 }
 function isAmqpClientUsable() {
-    return instance$a.has() || instance$a.hasFactory();
+    return instance$b.has() || instance$b.hasFactory();
 }
 function useAmqpClient() {
-    return instance$a.use();
+    return instance$b.use();
 }
 
-const instance$9 = singa({
+const instance$a = singa({
     name: 'vault'
 });
 function setVaultFactory(factory) {
-    instance$9.setFactory(factory);
+    instance$a.setFactory(factory);
 }
 function isVaultClientUsable() {
-    return instance$9.has() || instance$9.hasFactory();
+    return instance$a.has() || instance$a.hasFactory();
 }
 function useVaultClient() {
-    return instance$9.use();
+    return instance$a.use();
 }
 
 function guessAuthupTokenCreatorOptions() {
@@ -126,17 +129,17 @@ function guessAuthupTokenCreatorOptions() {
     return options;
 }
 
-const instance$8 = singa({
+const instance$9 = singa({
     name: 'clientAuthenticationHook'
 });
 function setClientAuthenticationHookFactory(factory) {
-    instance$8.setFactory(factory);
+    instance$9.setFactory(factory);
 }
 function isClientAuthenticationHookUsable() {
-    return instance$8.has() || instance$8.hasFactory();
+    return instance$9.has() || instance$9.hasFactory();
 }
 function useClientAuthenticationHook() {
-    return instance$8.use();
+    return instance$9.use();
 }
 
 class AuthupClient extends Client {
@@ -153,49 +156,49 @@ class AuthupClient extends Client {
     }
 }
 
-const instance$7 = singa({
+const instance$8 = singa({
     name: 'authup'
 });
 function useAuthupClient() {
-    return instance$7.use();
+    return instance$8.use();
 }
 function isAuthupClientUsable() {
-    return instance$7.has() || instance$7.hasFactory();
+    return instance$8.has() || instance$8.hasFactory();
 }
 function setAuthupClientFactory(factory) {
-    instance$7.setFactory(factory);
+    instance$8.setFactory(factory);
 }
 
-const instance$6 = singa({
+const instance$7 = singa({
     name: 'redis'
 });
 function setRedisFactory(factory) {
-    instance$6.setFactory(factory);
+    instance$7.setFactory(factory);
 }
 function isRedisClientUsable() {
-    return instance$6.has() || instance$6.hasFactory();
+    return instance$7.has() || instance$7.hasFactory();
 }
 function setRedisClient(input) {
-    instance$6.set(input);
+    instance$7.set(input);
 }
 function useRedisClient() {
-    return instance$6.use();
+    return instance$7.use();
 }
 
-const instance$5 = singa({
+const instance$6 = singa({
     name: 'redisPublish',
     factory: ()=>useRedisClient().duplicate()
 });
 function useRedisPublishClient() {
-    return instance$5.use();
+    return instance$6.use();
 }
 
-const instance$4 = singa({
+const instance$5 = singa({
     name: 'redisSubscribe',
     factory: ()=>useRedisClient().duplicate()
 });
 function useRedisSubscribeClient() {
-    return instance$4.use();
+    return instance$5.use();
 }
 
 /*
@@ -203,7 +206,7 @@ function useRedisSubscribeClient() {
  * 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) {
+ */ function _define_property$a(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -251,7 +254,7 @@ class MemoryCacheAdapter {
         this.instance.clear();
     }
     constructor(options = {}){
-        _define_property$6(this, "instance", void 0);
+        _define_property$a(this, "instance", void 0);
         this.instance = new TTLCache({
             checkAgeOnGet: true,
             ttl: Infinity,
@@ -265,7 +268,7 @@ class MemoryCacheAdapter {
  * 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) {
+ */ function _define_property$9(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -314,8 +317,8 @@ class RedisCacheAdapter {
         await this.client.flushdb();
     }
     constructor(){
-        _define_property$5(this, "client", void 0);
-        _define_property$5(this, "instance", void 0);
+        _define_property$9(this, "client", void 0);
+        _define_property$9(this, "instance", void 0);
         this.client = useRedisClient();
         this.instance = new JsonAdapter(this.client);
     }
@@ -337,7 +340,7 @@ 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$4(obj, key, value) {
+ */ function _define_property$8(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -370,12 +373,12 @@ class Cache {
         return this.adapter.clear(options);
     }
     constructor(adapter){
-        _define_property$4(this, "adapter", void 0);
+        _define_property$8(this, "adapter", void 0);
         this.adapter = adapter;
     }
 }
 
-const instance$3 = singa({
+const instance$4 = singa({
     name: 'cache',
     factory: ()=>{
         let adapter;
@@ -388,11 +391,365 @@ const instance$3 = singa({
     }
 });
 function useCache() {
+    return instance$4.use();
+}
+
+/*
+ * 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$7(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 LogStoreTransport extends WinstonTransport {
+    log(info, next) {
+        const { message, timestamp, stack, ...data } = info;
+        const labels = {
+            ...this.labels
+        };
+        const keys = Object.keys(data);
+        for(let i = 0; i < keys.length; i++){
+            if (typeof keys[i] !== 'string') {
+                continue;
+            }
+            const value = data[keys[i]];
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                labels[keys[i]] = `${value}`;
+            }
+        }
+        let date;
+        if (typeof timestamp === 'string') {
+            date = new Date(`${timestamp}`);
+        } else {
+            date = new Date();
+        }
+        const payload = {
+            message: stack || message,
+            time: BigInt(date.getTime()) * 1000000n,
+            labels
+        };
+        Promise.resolve().then(()=>this.instance.write(payload)).then(()=>next());
+    }
+    constructor(store, options = {}){
+        super(options), _define_property$7(this, "instance", void 0), _define_property$7(this, "labels", void 0);
+        this.instance = store;
+        this.labels = options.labels || {};
+    }
+}
+
+const instance$3 = singa({
+    name: 'loki'
+});
+function setLokiFactory(factory) {
+    instance$3.setFactory(factory);
+}
+function isLokiClientUsable() {
+    return instance$3.has() || instance$3.hasFactory();
+}
+function useLokiClient() {
     return instance$3.use();
 }
 
+/*
+ * 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$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 BaseLogStore {
+    setLabels(labels) {
+        this.labels = labels;
+    }
+    getLabels() {
+        return this.labels;
+    }
+    extendLabels(labels) {
+        const keys = Object.keys(labels);
+        for(let i = 0; i < keys.length; i++){
+            this.labels[keys[i]] = labels[keys[i]];
+        }
+    }
+    constructor(){
+        _define_property$6(this, "labels", void 0);
+    }
+}
+
+/*
+ * 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$5(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 LokiLogStore extends BaseLogStore {
+    async write(message, labels) {
+        let data;
+        if (typeof message === 'string') {
+            const labelsNormalized = {
+                ...this.labels,
+                ...labels || {}
+            };
+            const level = labelsNormalized.level || LogLevel.DEBUG;
+            delete labelsNormalized.level;
+            data = {
+                message,
+                level,
+                time: nanoSeconds(),
+                labels: labelsNormalized
+            };
+        } else {
+            const labelsNormalized = {
+                ...this.labels,
+                ...message.labels || {},
+                ...labels || {}
+            };
+            const level = message.level || labelsNormalized.level || LogLevel.DEBUG;
+            delete labelsNormalized.level;
+            data = {
+                ...message,
+                level,
+                time: message.time || nanoSeconds(),
+                labels: labelsNormalized
+            };
+        }
+        const stream = {
+            stream: data.labels,
+            values: [
+                [
+                    data.time,
+                    data.message,
+                    {
+                        level: data.level
+                    }
+                ]
+            ]
+        };
+        await this.instance.distributor.push(stream);
+        return data;
+    }
+    async delete(options) {
+        await this.instance.compactor.createDeletionRequest({
+            start: options.start,
+            ...options.end ? {
+                end: options.end
+            } : {},
+            query: this.buildQuery({
+                ...this.labels,
+                ...options.labels || {}
+            })
+        });
+    }
+    async query(input) {
+        const options = {
+            query: this.buildQuery({
+                ...this.labels,
+                ...input.labels || {}
+            })
+        };
+        if (input.sort) {
+            options.direction = input.sort === 'DESC' ? 'forward' : 'backward';
+        }
+        if (input.limit) {
+            options.limit = input.limit;
+        }
+        if (input.start) {
+            options.start = BigInt(new Date(`${input.start}`).getTime()) * 1000000n;
+        }
+        if (input.end) {
+            options.end = BigInt(new Date(`${input.end}`).getTime()) * 1000000n;
+        }
+        const output = [];
+        const response = await this.instance.querier.queryRange(options);
+        if (response.data.resultType === 'streams') {
+            for(let i = 0; i < response.data.result.length; i++){
+                const set = response.data.result[i];
+                const labels = set.stream;
+                let level;
+                if (labels.level) {
+                    level = labels.level;
+                } else {
+                    level = labels.detected_level;
+                }
+                delete labels.level;
+                delete labels.detected_level;
+                if (!labels.service) {
+                    labels.service = labels.service_name;
+                }
+                delete labels.service_name;
+                for(let j = 0; j < set.values.length; j++){
+                    output.push({
+                        time: BigInt(set.values[j][0]),
+                        message: set.values[j][1],
+                        level,
+                        labels
+                    });
+                }
+            }
+        }
+        return [
+            output,
+            output.length
+        ];
+    }
+    // ----------------------------------------------
+    buildQuery(labels) {
+        const output = [];
+        const keys = Object.keys(labels);
+        for(let i = 0; i < keys.length; i++){
+            output.push(`${keys[i]}="${labels[keys[i]]}"`);
+        }
+        return `{${output.join(',')}}`;
+    }
+    constructor(instance, labels){
+        super(), _define_property$5(this, "instance", void 0);
+        this.instance = instance;
+        this.labels = labels || {};
+    }
+}
+
+/*
+ * 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 MemoryLogStore extends BaseLogStore {
+    // todo: apply query options
+    async delete() {
+        return Promise.resolve();
+    }
+    async query(options = {}) {
+        // todo: apply all query options
+        const data = this.items.filter((item)=>{
+            if (options.labels) {
+                if (!item.labels) {
+                    return false;
+                }
+                const labelKeys = Object.keys(options.labels);
+                for(let i = 0; i < labelKeys.length; i++){
+                    if (!item.labels[labelKeys[i]]) {
+                        return false;
+                    }
+                    if (item.labels[labelKeys[i]] !== options.labels[labelKeys[i]]) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+        return [
+            data,
+            data.length
+        ];
+    }
+    async write(message, labels) {
+        let data;
+        if (typeof message === 'string') {
+            const labelsNormalized = {
+                ...this.labels,
+                ...labels || {}
+            };
+            const level = labelsNormalized.level || LogLevel.DEBUG;
+            delete labelsNormalized.level;
+            data = {
+                message,
+                level,
+                time: nanoSeconds(),
+                labels: labelsNormalized
+            };
+        } else {
+            const labelsNormalized = {
+                ...this.labels,
+                ...message.labels || {},
+                ...labels || {}
+            };
+            const level = message.level || labelsNormalized.level || LogLevel.DEBUG;
+            delete labelsNormalized.level;
+            data = {
+                ...message,
+                level,
+                time: message.time || nanoSeconds(),
+                labels: labelsNormalized
+            };
+        }
+        this.items.push(data);
+        return data;
+    }
+    constructor(labels){
+        super(), _define_property$4(this, "items", void 0);
+        this.items = [];
+        this.labels = labels;
+    }
+}
+
+const instance$2 = singa({
+    name: 'logStore',
+    factory: ()=>{
+        if (isLokiClientUsable()) {
+            const loki = useLokiClient();
+            return new LokiLogStore(loki);
+        }
+        return new MemoryLogStore();
+    }
+});
+function isLogStoreUsable() {
+    return instance$2.has() || instance$2.hasFactory();
+}
+function setLogStoreFactory(input) {
+    instance$2.setFactory(input);
+}
+function useLogStore() {
+    return instance$2.use();
+}
+
 function createLogger(ctx = {}) {
-    const { directory, options = {} } = ctx;
+    const store = ctx.store || useLogStore();
     let loggerTransports;
     if (read('env') === EnvironmentName.PRODUCTION) {
         loggerTransports = [
@@ -400,50 +757,58 @@ function createLogger(ctx = {}) {
                 level: 'info'
             }),
             new transports.File({
-                filename: path.join(directory || process.cwd(), 'access.log'),
+                filename: path.join(ctx.directory || process.cwd(), 'access.log'),
                 level: 'http',
                 maxsize: 10 * 1024 * 1024,
                 maxFiles: 5
             }),
             new transports.File({
-                filename: path.join(directory || process.cwd(), 'error.log'),
+                filename: path.join(ctx.directory || process.cwd(), 'error.log'),
                 level: 'warn',
                 maxsize: 10 * 1024 * 1024,
                 maxFiles: 5
+            }),
+            new LogStoreTransport(store, {
+                level: 'http',
+                labels: ctx.labels
             })
         ];
     } else {
         loggerTransports = [
             new transports.Console({
                 level: 'debug'
+            }),
+            new LogStoreTransport(store, {
+                level: 'http',
+                labels: ctx.labels
             })
         ];
     }
     return createLogger$1({
         format: format.combine(format.errors({
             stack: true
-        }), format.timestamp(), format.colorize(), format.simple()),
+        }), format.timestamp(), format.simple()),
         level: 'debug',
         transports: loggerTransports,
         // todo: deeply merge options
-        ...options || {}
+        ...ctx.options || {}
     });
 }
 
-const instance$2 = singa({
+const instance$1 = singa({
     name: 'logger'
 });
 function setLoggerFactory(factory) {
-    instance$2.setFactory(factory);
+    instance$1.setFactory(factory);
 }
 function isLoggerUsable() {
-    return instance$2.has() || instance$2.hasFactory();
+    return instance$1.has() || instance$1.hasFactory();
 }
 function setLogger(input) {
-    instance$2.set(input);
+    instance$1.set(input);
 }
 function useLogger() {
-    return instance$2.use();
+    return instance$1.use();
 }
 
 /*
@@ -473,14 +838,14 @@ class DomainEventPublisher {
             await this.publish(ctx);
         } catch (e) {
             if (isLoggerUsable()) {
-                useLogger().error(`Publishing event ${buildDomainEventFullName(ctx.data.type, ctx.data.event)} failed`);
+                useLogger().error(`Publishing event ${buildDomainEventFullName(ctx.metadata.domain, ctx.metadata.event)} failed`);
                 useLogger().error(e);
             }
         }
     }
     async publish(ctx) {
         if (isLoggerUsable()) {
-            useLogger().info(`Publishing event ${buildDomainEventFullName(ctx.data.type, ctx.data.event)}`);
+            useLogger().info(`Publishing event ${buildDomainEventFullName(ctx.metadata.domain, ctx.metadata.event)}`);
         }
         const publishers = this.publishers.values();
         while(true){
@@ -536,15 +901,29 @@ function buildEventChannelName(input, id) {
 }
 class DomainEventRedisPublisher {
     async publish(ctx) {
-        const data = JSON.stringify(transformEventData(ctx.data));
+        const payload = {
+            type: ctx.metadata.domain,
+            event: ctx.metadata.event,
+            data: transformEventData(ctx.data)
+        };
+        const payloadSerialized = JSON.stringify(payload);
         const pipeline = this.driver.pipeline();
         for(let i = 0; i < ctx.destinations.length; i++){
-            const keyPrefix = ctx.destinations[i].namespace ? `${ctx.destinations[i].namespace}:` : '';
-            let key = keyPrefix + buildEventChannelName(ctx.destinations[i].channel);
-            pipeline.publish(key, data);
-            if (typeof ctx.destinations[i].channel === 'function') {
-                key = keyPrefix + buildEventChannelName(ctx.destinations[i].channel, ctx.data.data.id);
-                pipeline.publish(key, data);
+            const destination = ctx.destinations[i];
+            let keyPrefix;
+            if (destination.namespace) {
+                keyPrefix = typeof destination.namespace === 'function' ? destination.namespace(ctx.data) : destination.namespace;
+            }
+            let key;
+            if (keyPrefix) {
+                key = keyPrefix + buildEventChannelName(destination.channel);
+            } else {
+                key = buildEventChannelName(destination.channel);
+            }
+            pipeline.publish(key, payloadSerialized);
+            if (typeof destination.channel === 'function') {
+                key = keyPrefix + buildEventChannelName(destination.channel, ctx.data.id);
+                pipeline.publish(key, payloadSerialized);
             }
         }
         await pipeline.exec();
@@ -577,23 +956,28 @@ class DomainEventSocketPublisher {
     async publish(ctx) {
         ctx.data = transformEventData(ctx.data);
         for(let i = 0; i < ctx.destinations.length; i++){
+            const destination = ctx.destinations[i];
             let namespace;
-            if (ctx.destinations[i].namespace) {
-                namespace = ctx.destinations[i].namespace;
+            if (destination.namespace) {
+                namespace = typeof destination.namespace === 'function' ? destination.namespace(ctx.data) : destination.namespace;
             } else {
                 namespace = '/';
             }
             const emitter = new Emitter(this.client, {}, namespace);
-            const fullEventName = buildDomainEventFullName(ctx.data.type, ctx.data.event);
+            const fullEventName = buildDomainEventFullName(ctx.metadata.domain, ctx.metadata.event);
             const rooms = [
-                buildEventChannelName(ctx.destinations[i].channel)
+                buildEventChannelName(destination.channel)
             ];
-            if (typeof ctx.destinations[i].channel === 'function') {
-                rooms.push(buildEventChannelName(ctx.destinations[i].channel, ctx.data.data.id));
+            if (typeof destination.channel === 'function') {
+                rooms.push(buildEventChannelName(destination.channel, ctx.data.id));
             }
             for(let j = 0; j < rooms.length; j++){
                 emitter.in(rooms[j]).emit(fullEventName, {
-                    ...ctx.data,
+                    data: {
+                        data: ctx.data,
+                        type: ctx.metadata.domain,
+                        event: ctx.metadata.event
+                    },
                     meta: {
                         namespace,
                         roomName: rooms[j]
@@ -608,7 +992,7 @@ class DomainEventSocketPublisher {
     }
 }
 
-const instance$1 = singa({
+const singaInstance = singa({
     name: 'domainEventPublisher',
     factory: ()=>{
         const publisher = new DomainEventPublisher();
@@ -620,8 +1004,11 @@ const instance$1 = singa({
         return publisher;
     }
 });
+function useDomainEventPublisherSinga() {
+    return singaInstance;
+}
 function useDomainEventPublisher() {
-    return instance$1.use();
+    return singaInstance.use();
 }
 
 /*
@@ -744,5 +1131,5 @@ function useQueueRouter() {
     return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
-export { AuthupClient, Cache, ComponentError, DomainEventPublisher, DomainEventRedisPublisher, DomainEventSocketPublisher, MemoryCacheAdapter, QueueRouter, QueueRouterRoutingType, RedisCacheAdapter, buildCacheKey, buildQueueRouterPublishPayload, createCacheAdapter, createLogger, guessAuthupTokenCreatorOptions, hasOwnProperty, isAmqpClientUsable, isAuthupClientUsable, isClientAuthenticationHookUsable, isComponentError, isLoggerUsable, isQueuePayload, isQueueRouterPayload, isQueueRouterUsable, isRedisClientUsable, isVaultClientUsable, setAmqpClientFactory, setAuthupClientFactory, setClientAuthenticationHookFactory, setLogger, setLoggerFactory, setRedisClient, setRedisFactory, setVaultFactory, useAmqpClient, useAuthupClient, useCache, useClientAuthenticationHook, useDomainEventPublisher, useLogger, useQueueRouter, useRedisClient, useRedisPublishClient, useRedisSubscribeClient, useVaultClient };
+export { AuthupClient, Cache, ComponentError, DomainEventPublisher, DomainEventRedisPublisher, DomainEventSocketPublisher, LokiLogStore, MemoryCacheAdapter, MemoryLogStore, QueueRouter, QueueRouterRoutingType, RedisCacheAdapter, buildCacheKey, buildQueueRouterPublishPayload, createCacheAdapter, createLogger, guessAuthupTokenCreatorOptions, hasOwnProperty, isAmqpClientUsable, isAuthupClientUsable, isClientAuthenticationHookUsable, isComponentError, isLogStoreUsable, isLoggerUsable, isLokiClientUsable, isQueuePayload, isQueueRouterPayload, isQueueRouterUsable, isRedisClientUsable, isVaultClientUsable, setAmqpClientFactory, setAuthupClientFactory, setClientAuthenticationHookFactory, setLogStoreFactory, setLogger, setLoggerFactory, setLokiFactory, setRedisClient, setRedisFactory, setVaultFactory, useAmqpClient, useAuthupClient, useCache, useClientAuthenticationHook, useDomainEventPublisher, useDomainEventPublisherSinga, useLogStore, useLogger, useLokiClient, useQueueRouter, useRedisClient, useRedisPublishClient, useRedisSubscribeClient, useVaultClient };
 //# sourceMappingURL=index.mjs.map