@privateaim/server-kit 0.8.15 → 0.8.17

package/dist/index.cjs

@@ -7,20 +7,29 @@ var vault = require('@hapic/vault');
 var coreHttpKit = require('@authup/core-http-kit');
 var redisExtension = require('redis-extension');
 var TTLCache = require('@isaacs/ttlcache');
-var envix = require('envix');
-var path = require('node:path');
-var typeormExtension = require('typeorm-extension');
 var winston = require('winston');
-var WinstonTransport = require('winston-transport');
-var loki = require('@hapic/loki');
+var envix = require('envix');
+var Transport = require('winston-transport');
 var redisEmitter = require('@socket.io/redis-emitter');
 
+/*
+ * 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.
+ */ var EnvironmentName = /*#__PURE__*/ function(EnvironmentName) {
+    EnvironmentName["TEST"] = "test";
+    EnvironmentName["DEVELOPMENT"] = "development";
+    EnvironmentName["PRODUCTION"] = "production";
+    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$b(obj, key, value) {
+ */ function _define_property$9(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -37,11 +46,81 @@ class ComponentError extends Error {
     constructor(input){
         super(input.message, {
             cause: input.cause
-        }), _define_property$b(this, "code", void 0);
+        }), _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 setup() {
+        const keys = Object.keys(this.handlers);
+        for(let i = 0; i < keys.length; i++){
+            const handler = this.handlers[keys[i]];
+            if (!isComponentHandlerFn(handler) && handler.setup) {
+                await handler.setup();
+            }
+        }
+    }
+    async execute(key, value = {}, metadata = {}) {
+        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, "handlers", void 0);
+        this.handlers = {};
+    }
+}
+
 function isComponentError(input) {
     if (!kit.isObject(input)) {
         return false;
@@ -85,30 +164,30 @@ function isQueueRouterPayload(input) {
     return kit.isObject(input) && typeof input.id === 'string' && typeof input.type === 'string' && kit.hasOwnProperty(input, 'data') && kit.isObject(input.data) && kit.hasOwnProperty(input, 'metadata') && kit.isObject(input.metadata);
 }
 
-const instance$b = singa.singa({
+const instance$a = singa.singa({
     name: 'amqp'
 });
 function setAmqpClientFactory(factory) {
-    instance$b.setFactory(factory);
+    instance$a.setFactory(factory);
 }
 function isAmqpClientUsable() {
-    return instance$b.has() || instance$b.hasFactory();
+    return instance$a.has() || instance$a.hasFactory();
 }
 function useAmqpClient() {
-    return instance$b.use();
+    return instance$a.use();
 }
 
-const instance$a = singa.singa({
+const instance$9 = singa.singa({
     name: 'vault'
 });
 function setVaultFactory(factory) {
-    instance$a.setFactory(factory);
+    instance$9.setFactory(factory);
 }
 function isVaultClientUsable() {
-    return instance$a.has() || instance$a.hasFactory();
+    return instance$9.has() || instance$9.hasFactory();
 }
 function useVaultClient() {
-    return instance$a.use();
+    return instance$9.use();
 }
 
 function guessAuthupTokenCreatorOptions() {
@@ -129,17 +208,17 @@ function guessAuthupTokenCreatorOptions() {
     return options;
 }
 
-const instance$9 = singa.singa({
+const instance$8 = singa.singa({
     name: 'clientAuthenticationHook'
 });
 function setClientAuthenticationHookFactory(factory) {
-    instance$9.setFactory(factory);
+    instance$8.setFactory(factory);
 }
 function isClientAuthenticationHookUsable() {
-    return instance$9.has() || instance$9.hasFactory();
+    return instance$8.has() || instance$8.hasFactory();
 }
 function useClientAuthenticationHook() {
-    return instance$9.use();
+    return instance$8.use();
 }
 
 class AuthupClient extends coreHttpKit.Client {
@@ -156,49 +235,49 @@ class AuthupClient extends coreHttpKit.Client {
     }
 }
 
-const instance$8 = singa.singa({
+const instance$7 = singa.singa({
     name: 'authup'
 });
 function useAuthupClient() {
-    return instance$8.use();
+    return instance$7.use();
 }
 function isAuthupClientUsable() {
-    return instance$8.has() || instance$8.hasFactory();
+    return instance$7.has() || instance$7.hasFactory();
 }
 function setAuthupClientFactory(factory) {
-    instance$8.setFactory(factory);
+    instance$7.setFactory(factory);
 }
 
-const instance$7 = singa.singa({
+const instance$6 = singa.singa({
     name: 'redis'
 });
 function setRedisFactory(factory) {
-    instance$7.setFactory(factory);
+    instance$6.setFactory(factory);
 }
 function isRedisClientUsable() {
-    return instance$7.has() || instance$7.hasFactory();
+    return instance$6.has() || instance$6.hasFactory();
 }
 function setRedisClient(input) {
-    instance$7.set(input);
+    instance$6.set(input);
 }
 function useRedisClient() {
-    return instance$7.use();
+    return instance$6.use();
 }
 
-const instance$6 = singa.singa({
+const instance$5 = singa.singa({
     name: 'redisPublish',
     factory: ()=>useRedisClient().duplicate()
 });
 function useRedisPublishClient() {
-    return instance$6.use();
+    return instance$5.use();
 }
 
-const instance$5 = singa.singa({
+const instance$4 = singa.singa({
     name: 'redisSubscribe',
     factory: ()=>useRedisClient().duplicate()
 });
 function useRedisSubscribeClient() {
-    return instance$5.use();
+    return instance$4.use();
 }
 
 /*
@@ -206,7 +285,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$a(obj, key, value) {
+ */ function _define_property$7(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -254,7 +333,7 @@ class MemoryCacheAdapter {
         this.instance.clear();
     }
     constructor(options = {}){
-        _define_property$a(this, "instance", void 0);
+        _define_property$7(this, "instance", void 0);
         this.instance = new TTLCache({
             checkAgeOnGet: true,
             ttl: Infinity,
@@ -268,7 +347,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$9(obj, key, value) {
+ */ function _define_property$6(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -317,8 +396,8 @@ class RedisCacheAdapter {
         await this.client.flushdb();
     }
     constructor(){
-        _define_property$9(this, "client", void 0);
-        _define_property$9(this, "instance", void 0);
+        _define_property$6(this, "client", void 0);
+        _define_property$6(this, "instance", void 0);
         this.client = useRedisClient();
         this.instance = new redisExtension.JsonAdapter(this.client);
     }
@@ -340,7 +419,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$8(obj, key, value) {
+ */ function _define_property$5(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -373,12 +452,12 @@ class Cache {
         return this.adapter.clear(options);
     }
     constructor(adapter){
-        _define_property$8(this, "adapter", void 0);
+        _define_property$5(this, "adapter", void 0);
         this.adapter = adapter;
     }
 }
 
-const instance$4 = singa.singa({
+const instance$3 = singa.singa({
     name: 'cache',
     factory: ()=>{
         let adapter;
@@ -391,261 +470,26 @@ const instance$4 = singa.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.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
+class LoggerConsoleTransport extends winston.transports.Console {
+    constructor(options = {}){
+        super({
+            level: envix.read('env') === EnvironmentName.PRODUCTION ? 'info' : 'debug',
+            ...options
         });
-    } 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);
-    }
+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$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 || kit.LogLevel.DEBUG;
-            delete labelsNormalized.level;
-            data = {
-                message,
-                level,
-                time: loki.nanoSeconds(),
-                labels: labelsNormalized
-            };
-        } else {
-            const labelsNormalized = {
-                ...this.labels,
-                ...message.labels || {},
-                ...labels || {}
-            };
-            const level = message.level || labelsNormalized.level || kit.LogLevel.DEBUG;
-            delete labelsNormalized.level;
-            data = {
-                ...message,
-                level,
-                time: message.time || loki.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.
+ * 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, {
@@ -659,160 +503,52 @@ class LokiLogStore extends BaseLogStore {
     }
     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 || kit.LogLevel.DEBUG;
-            delete labelsNormalized.level;
-            data = {
-                message,
-                level,
-                time: loki.nanoSeconds(),
-                labels: labelsNormalized
-            };
-        } else {
-            const labelsNormalized = {
-                ...this.labels,
-                ...message.labels || {},
-                ...labels || {}
-            };
-            const level = message.level || labelsNormalized.level || kit.LogLevel.DEBUG;
-            delete labelsNormalized.level;
-            data = {
-                ...message,
-                level,
-                time: message.time || loki.nanoSeconds(),
-                labels: labelsNormalized
-            };
-        }
-        this.items.push(data);
-        return data;
-    }
-    constructor(labels){
-        super(), _define_property$4(this, "items", void 0);
-        this.items = [];
-        this.labels = labels;
+class LoggerMemoryTransport extends Transport {
+    log(info, next) {
+        this.items.push(info);
+        next();
     }
-}
-
-const instance$2 = singa.singa({
-    name: 'logStore',
-    factory: ()=>{
-        if (isLokiClientUsable()) {
-            const loki = useLokiClient();
-            return new LokiLogStore(loki);
-        }
-        return new MemoryLogStore();
+    constructor(...args){
+        super(...args), _define_property$4(this, "items", []);
     }
-});
-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 store = ctx.store || useLogStore();
-    let loggerTransports;
-    if (envix.read('env') === typeormExtension.EnvironmentName.PRODUCTION) {
-        loggerTransports = [
-            new winston.transports.Console({
-                level: 'info'
-            }),
-            new winston.transports.File({
-                filename: path.join(ctx.directory || process.cwd(), 'access.log'),
-                level: 'http',
-                maxsize: 10 * 1024 * 1024,
-                maxFiles: 5
-            }),
-            new winston.transports.File({
-                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 winston.transports.Console({
-                level: 'debug'
-            }),
-            new LogStoreTransport(store, {
-                level: 'http',
-                labels: ctx.labels
-            })
-        ];
+    const transports = [
+        ...ctx.transports || []
+    ];
+    if (transports.length === 0) {
+        transports.push(createLoggerConsoleTransport());
     }
     return winston.createLogger({
         format: winston.format.combine(winston.format.errors({
             stack: true
         }), winston.format.timestamp(), winston.format.simple()),
         level: 'debug',
-        transports: loggerTransports,
+        transports,
         // todo: deeply merge options
         ...ctx.options || {}
     });
 }
 
-const instance$1 = singa.singa({
+const instance$2 = singa.singa({
     name: 'logger'
 });
 function setLoggerFactory(factory) {
-    instance$1.setFactory(factory);
+    instance$2.setFactory(factory);
 }
 function isLoggerUsable() {
-    return instance$1.has() || instance$1.hasFactory();
+    return instance$2.has() || instance$2.hasFactory();
 }
 function setLogger(input) {
-    instance$1.set(input);
+    instance$2.set(input);
 }
 function useLogger() {
-    return instance$1.use();
+    return instance$2.use();
 }
 
 /*
- * Copyright (c) 2024-2024.
+ * 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.
@@ -829,40 +565,50 @@ function useLogger() {
     }
     return obj;
 }
-class DomainEventPublisher {
-    addPublisher(publisher) {
-        this.publishers.add(publisher);
+class EntityEventPublisher {
+    register(consumer) {
+        this.handlers.add(consumer);
     }
     async safePublish(ctx) {
         try {
             await this.publish(ctx);
         } catch (e) {
             if (isLoggerUsable()) {
-                useLogger().error(`Publishing event ${kit.buildDomainEventFullName(ctx.metadata.domain, ctx.metadata.event)} failed`);
+                useLogger().error(`Publishing event ${kit.buildDomainEventFullName(ctx.metadata.ref_type, ctx.metadata.event)} failed`);
                 useLogger().error(e);
             }
         }
     }
     async publish(ctx) {
         if (isLoggerUsable()) {
-            useLogger().info(`Publishing event ${kit.buildDomainEventFullName(ctx.metadata.domain, ctx.metadata.event)}`);
+            useLogger().debug(`Publishing event ${kit.buildDomainEventFullName(ctx.metadata.ref_type, ctx.metadata.event)}`);
         }
-        const publishers = this.publishers.values();
+        let destinations = [];
+        if (typeof ctx.destinations === 'function') {
+            destinations = ctx.destinations(ctx.data);
+        } else {
+            destinations = ctx.destinations;
+        }
+        const consumeContext = {
+            ...ctx,
+            destinations
+        };
+        const handlers = this.handlers.values();
         while(true){
-            const it = publishers.next();
-            if (it.done) {
+            const handler = handlers.next();
+            if (handler.done) {
                 return;
             }
-            await it.value.publish(ctx);
+            await handler.value.handle(consumeContext);
         }
     }
     constructor(){
-        _define_property$3(this, "publishers", void 0);
-        this.publishers = new Set();
+        _define_property$3(this, "handlers", void 0);
+        this.handlers = new Set();
     }
 }
 
-function transformEventData(input) {
+function transformEntityEventData(input) {
     if (kit.isObject(input)) {
         const keys = Object.keys(input);
         for(let i = 0; i < keys.length; i++){
@@ -874,11 +620,25 @@ function transformEventData(input) {
     }
     return input;
 }
-function buildEventChannelName(input, id) {
-    if (typeof input === 'string') {
-        return input;
+
+/*
+ * 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 stringify(input) {
+    return typeof input === 'string' ? input : input.join('/');
+}
+function buildEntityEventRedisChannel(channel, namespace) {
+    const channelNormalized = stringify(channel);
+    let namespaceNormalized;
+    if (namespace) {
+        namespaceNormalized = stringify(namespace);
     }
-    return input(id);
+    if (typeof namespaceNormalized === 'undefined') {
+        return channelNormalized;
+    }
+    return `${namespaceNormalized}/${channelNormalized}`;
 }
 
 /*
@@ -899,32 +659,19 @@ function buildEventChannelName(input, id) {
     }
     return obj;
 }
-class DomainEventRedisPublisher {
-    async publish(ctx) {
+class EntityEventRedisHandler {
+    async handle(ctx) {
         const payload = {
-            type: ctx.metadata.domain,
+            type: ctx.metadata.ref_type,
             event: ctx.metadata.event,
-            data: transformEventData(ctx.data)
+            data: transformEntityEventData(ctx.data)
         };
         const payloadSerialized = JSON.stringify(payload);
         const pipeline = this.driver.pipeline();
         for(let i = 0; i < ctx.destinations.length; i++){
             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);
-            }
+            const key = buildEntityEventRedisChannel(destination.channel, destination.namespace);
             pipeline.publish(key, payloadSerialized);
-            if (typeof destination.channel === 'function') {
-                key = keyPrefix + buildEventChannelName(destination.channel, ctx.data.id);
-                pipeline.publish(key, payloadSerialized);
-            }
         }
         await pipeline.exec();
     }
@@ -952,39 +699,42 @@ class DomainEventRedisPublisher {
     }
     return obj;
 }
-class DomainEventSocketPublisher {
-    async publish(ctx) {
-        ctx.data = transformEventData(ctx.data);
+class EntityEventSocketHandler {
+    async handle(ctx) {
+        ctx.data = transformEntityEventData(ctx.data);
         for(let i = 0; i < ctx.destinations.length; i++){
             const destination = ctx.destinations[i];
-            let namespace;
-            if (destination.namespace) {
-                namespace = typeof destination.namespace === 'function' ? destination.namespace(ctx.data) : destination.namespace;
-            } else {
-                namespace = '/';
-            }
+            const namespace = this.buildNamespace(destination.namespace);
+            const roomName = this.buildChannel(destination.channel);
+            const fullEventName = kit.buildDomainEventFullName(ctx.metadata.ref_type, ctx.metadata.event);
             const emitter = new redisEmitter.Emitter(this.client, {}, namespace);
-            const fullEventName = kit.buildDomainEventFullName(ctx.metadata.domain, ctx.metadata.event);
-            const rooms = [
-                buildEventChannelName(destination.channel)
-            ];
-            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, {
-                    data: {
-                        data: ctx.data,
-                        type: ctx.metadata.domain,
-                        event: ctx.metadata.event
-                    },
-                    meta: {
-                        namespace,
-                        roomName: rooms[j]
-                    }
-                });
-            }
+            emitter.in(roomName).emit(fullEventName, {
+                data: {
+                    data: ctx.data,
+                    type: ctx.metadata.ref_type,
+                    event: ctx.metadata.event
+                },
+                meta: {
+                    namespace,
+                    roomName
+                }
+            });
+        }
+    }
+    buildNamespace(namespace) {
+        if (typeof namespace === 'undefined') {
+            return '/';
+        }
+        if (typeof namespace === 'string') {
+            return namespace.startsWith('/') ? namespace : `/${namespace}`;
         }
+        return `/${namespace.join('/')}`;
+    }
+    buildChannel(channel) {
+        if (typeof channel === 'string') {
+            return channel;
+        }
+        return channel.join('/');
     }
     constructor(client){
         _define_property$1(this, "client", void 0);
@@ -992,23 +742,14 @@ class DomainEventSocketPublisher {
     }
 }
 
-const singaInstance = singa.singa({
-    name: 'domainEventPublisher',
-    factory: ()=>{
-        const publisher = new DomainEventPublisher();
-        if (isRedisClientUsable()) {
-            const client = useRedisClient();
-            publisher.addPublisher(new DomainEventRedisPublisher(client));
-            publisher.addPublisher(new DomainEventSocketPublisher(client));
-        }
-        return publisher;
-    }
+const instance$1 = singa.singa({
+    name: 'entityEventPublisher'
 });
-function useDomainEventPublisherSinga() {
-    return singaInstance;
+function setEntityEventPublisherFactory(factory) {
+    instance$1.setFactory(factory);
 }
-function useDomainEventPublisher() {
-    return singaInstance.use();
+function useEntityEventPublisher() {
+    return instance$1.use();
 }
 
 /*
@@ -1031,7 +772,9 @@ function useDomainEventPublisher() {
 }
 class QueueRouter {
     //----------------------------------------------------------------
-    publish(message) {
+    publish(message, options = {}) {
+        var _options;
+        (_options = options).logging ?? (_options.logging = true);
         let exchange;
         if (message.metadata.routing.type === 'work') {
             exchange = this.driver.of({
@@ -1044,7 +787,7 @@ class QueueRouter {
                 name: message.metadata.routing.namespace || 'FLAME'
             });
         }
-        if (isLoggerUsable()) {
+        if (options.logging && isLoggerUsable()) {
             useLogger().debug(`Publishing queue message ${message.type} in ${message.metadata.routing.key}`);
         }
         return exchange.publish(message.metadata.routing.key, message, {
@@ -1053,6 +796,11 @@ class QueueRouter {
             persistent: message.metadata.persistent ?? message.metadata.routing.type === QueueRouterRoutingType.WORK
         });
     }
+    consumeAny(routing, fn) {
+        return this.consume(routing, {
+            $any: (payload)=>fn(payload)
+        });
+    }
     consume(routing, handlers) {
         let exchange;
         if (routing.type === 'work') {
@@ -1097,7 +845,14 @@ class QueueRouter {
                     }
                     return;
                 }
-                await handler(payload);
+                try {
+                    await handler(payload);
+                } catch (e) {
+                    if (isLoggerUsable()) {
+                        useLogger().error(e);
+                    }
+                    throw e;
+                }
             }
         });
     }
@@ -1122,15 +877,10 @@ function useQueueRouter() {
     return instance.use();
 }
 
-/*
- * 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);
-}
-
+Object.defineProperty(exports, "AmqpClient", {
+    enumerable: true,
+    get: function () { return amqpExtension.Client; }
+});
 Object.defineProperty(exports, "VaultClient", {
     enumerable: true,
     get: function () { return vault.VaultClient; }
@@ -1155,67 +905,33 @@ Object.defineProperty(exports, "createRedisClient", {
     enumerable: true,
     get: function () { return redisExtension.createClient; }
 });
-Object.defineProperty(exports, "LokiClient", {
-    enumerable: true,
-    get: function () { return loki.LokiClient; }
-});
-Object.defineProperty(exports, "LokiCompactorDeletionRequestCreate", {
-    enumerable: true,
-    get: function () { return loki.CompactorDeletionRequestCreate; }
-});
-Object.defineProperty(exports, "LokiConfig", {
-    enumerable: true,
-    get: function () { return loki.Config; }
-});
-Object.defineProperty(exports, "LokiConfigInput", {
-    enumerable: true,
-    get: function () { return loki.ConfigInput; }
-});
-Object.defineProperty(exports, "LokiDistributorPushStream", {
-    enumerable: true,
-    get: function () { return loki.DistributorPushStream; }
-});
-Object.defineProperty(exports, "LokiQuerierQueryRangeOptions", {
-    enumerable: true,
-    get: function () { return loki.QuerierQueryRangeOptions; }
-});
-Object.defineProperty(exports, "LokiQuerierQueryResult", {
-    enumerable: true,
-    get: function () { return loki.QuerierQueryResult; }
-});
-Object.defineProperty(exports, "createLokiClient", {
-    enumerable: true,
-    get: function () { return loki.createClient; }
-});
-Object.defineProperty(exports, "nanoSeconds", {
-    enumerable: true,
-    get: function () { return loki.nanoSeconds; }
-});
 exports.AuthupClient = AuthupClient;
 exports.Cache = Cache;
 exports.ComponentError = ComponentError;
-exports.DomainEventPublisher = DomainEventPublisher;
-exports.DomainEventRedisPublisher = DomainEventRedisPublisher;
-exports.DomainEventSocketPublisher = DomainEventSocketPublisher;
-exports.LokiLogStore = LokiLogStore;
+exports.ComponentHandlers = ComponentHandlers;
+exports.EntityEventPublisher = EntityEventPublisher;
+exports.EntityEventRedisHandler = EntityEventRedisHandler;
+exports.EntityEventSocketHandler = EntityEventSocketHandler;
+exports.EnvironmentName = EnvironmentName;
+exports.LoggerConsoleTransport = LoggerConsoleTransport;
+exports.LoggerMemoryTransport = LoggerMemoryTransport;
 exports.MemoryCacheAdapter = MemoryCacheAdapter;
-exports.MemoryLogStore = MemoryLogStore;
 exports.QueueRouter = QueueRouter;
 exports.QueueRouterRoutingType = QueueRouterRoutingType;
 exports.RedisCacheAdapter = RedisCacheAdapter;
 exports.buildCacheKey = buildCacheKey;
+exports.buildEntityEventRedisChannel = buildEntityEventRedisChannel;
 exports.buildQueueRouterPublishPayload = buildQueueRouterPublishPayload;
 exports.createCacheAdapter = createCacheAdapter;
 exports.createLogger = createLogger;
+exports.createLoggerConsoleTransport = createLoggerConsoleTransport;
 exports.guessAuthupTokenCreatorOptions = guessAuthupTokenCreatorOptions;
 exports.hasOwnProperty = hasOwnProperty;
 exports.isAmqpClientUsable = isAmqpClientUsable;
 exports.isAuthupClientUsable = isAuthupClientUsable;
 exports.isClientAuthenticationHookUsable = isClientAuthenticationHookUsable;
 exports.isComponentError = isComponentError;
-exports.isLogStoreUsable = isLogStoreUsable;
 exports.isLoggerUsable = isLoggerUsable;
-exports.isLokiClientUsable = isLokiClientUsable;
 exports.isQueuePayload = isQueuePayload;
 exports.isQueueRouterPayload = isQueueRouterPayload;
 exports.isQueueRouterUsable = isQueueRouterUsable;
@@ -1224,10 +940,9 @@ exports.isVaultClientUsable = isVaultClientUsable;
 exports.setAmqpClientFactory = setAmqpClientFactory;
 exports.setAuthupClientFactory = setAuthupClientFactory;
 exports.setClientAuthenticationHookFactory = setClientAuthenticationHookFactory;
-exports.setLogStoreFactory = setLogStoreFactory;
+exports.setEntityEventPublisherFactory = setEntityEventPublisherFactory;
 exports.setLogger = setLogger;
 exports.setLoggerFactory = setLoggerFactory;
-exports.setLokiFactory = setLokiFactory;
 exports.setRedisClient = setRedisClient;
 exports.setRedisFactory = setRedisFactory;
 exports.setVaultFactory = setVaultFactory;
@@ -1235,11 +950,8 @@ exports.useAmqpClient = useAmqpClient;
 exports.useAuthupClient = useAuthupClient;
 exports.useCache = useCache;
 exports.useClientAuthenticationHook = useClientAuthenticationHook;
-exports.useDomainEventPublisher = useDomainEventPublisher;
-exports.useDomainEventPublisherSinga = useDomainEventPublisherSinga;
-exports.useLogStore = useLogStore;
+exports.useEntityEventPublisher = useEntityEventPublisher;
 exports.useLogger = useLogger;
-exports.useLokiClient = useLokiClient;
 exports.useQueueRouter = useQueueRouter;
 exports.useRedisClient = useRedisClient;
 exports.useRedisPublishClient = useRedisPublishClient;