@privateaim/server-kit 0.8.14 → 0.8.16

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { isObject, hasOwnProperty as hasOwnProperty$1, createNanoID, buildDomainEventFullName } 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';
@@ -7,18 +8,16 @@ 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';
 import { read } from 'envix';
-import path from 'node:path';
 import { EnvironmentName } from 'typeorm-extension';
 import { transports, createLogger as createLogger$1, format } from 'winston';
 import { Emitter } from '@socket.io/redis-emitter';
-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';
 
 /*
  * 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$7(obj, key, value) {
+ */ function _define_property$8(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -35,11 +34,81 @@ class ComponentError extends Error {
     constructor(input){
         super(input.message, {
             cause: input.cause
-        }), _define_property$7(this, "code", void 0);
+        }), _define_property$8(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$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 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$7(this, "handlers", void 0);
+        this.handlers = {};
+    }
+}
+
 function isComponentError(input) {
     if (!isObject(input)) {
         return false;
@@ -83,30 +152,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$b = singa({
+const instance$9 = singa({
     name: 'amqp'
 });
 function setAmqpClientFactory(factory) {
-    instance$b.setFactory(factory);
+    instance$9.setFactory(factory);
 }
 function isAmqpClientUsable() {
-    return instance$b.has() || instance$b.hasFactory();
+    return instance$9.has() || instance$9.hasFactory();
 }
 function useAmqpClient() {
-    return instance$b.use();
+    return instance$9.use();
 }
 
-const instance$a = singa({
+const instance$8 = singa({
     name: 'vault'
 });
 function setVaultFactory(factory) {
-    instance$a.setFactory(factory);
+    instance$8.setFactory(factory);
 }
 function isVaultClientUsable() {
-    return instance$a.has() || instance$a.hasFactory();
+    return instance$8.has() || instance$8.hasFactory();
 }
 function useVaultClient() {
-    return instance$a.use();
+    return instance$8.use();
 }
 
 function guessAuthupTokenCreatorOptions() {
@@ -127,17 +196,17 @@ function guessAuthupTokenCreatorOptions() {
     return options;
 }
 
-const instance$9 = singa({
+const instance$7 = singa({
     name: 'clientAuthenticationHook'
 });
 function setClientAuthenticationHookFactory(factory) {
-    instance$9.setFactory(factory);
+    instance$7.setFactory(factory);
 }
 function isClientAuthenticationHookUsable() {
-    return instance$9.has() || instance$9.hasFactory();
+    return instance$7.has() || instance$7.hasFactory();
 }
 function useClientAuthenticationHook() {
-    return instance$9.use();
+    return instance$7.use();
 }
 
 class AuthupClient extends Client {
@@ -154,49 +223,49 @@ class AuthupClient extends Client {
     }
 }
 
-const instance$8 = singa({
+const instance$6 = singa({
     name: 'authup'
 });
 function useAuthupClient() {
-    return instance$8.use();
+    return instance$6.use();
 }
 function isAuthupClientUsable() {
-    return instance$8.has() || instance$8.hasFactory();
+    return instance$6.has() || instance$6.hasFactory();
 }
 function setAuthupClientFactory(factory) {
-    instance$8.setFactory(factory);
+    instance$6.setFactory(factory);
 }
 
-const instance$7 = singa({
+const instance$5 = singa({
     name: 'redis'
 });
 function setRedisFactory(factory) {
-    instance$7.setFactory(factory);
+    instance$5.setFactory(factory);
 }
 function isRedisClientUsable() {
-    return instance$7.has() || instance$7.hasFactory();
+    return instance$5.has() || instance$5.hasFactory();
 }
 function setRedisClient(input) {
-    instance$7.set(input);
+    instance$5.set(input);
 }
 function useRedisClient() {
-    return instance$7.use();
+    return instance$5.use();
 }
 
-const instance$6 = singa({
+const instance$4 = singa({
     name: 'redisPublish',
     factory: ()=>useRedisClient().duplicate()
 });
 function useRedisPublishClient() {
-    return instance$6.use();
+    return instance$4.use();
 }
 
-const instance$5 = singa({
+const instance$3 = singa({
     name: 'redisSubscribe',
     factory: ()=>useRedisClient().duplicate()
 });
 function useRedisSubscribeClient() {
-    return instance$5.use();
+    return instance$3.use();
 }
 
 /*
@@ -376,7 +445,7 @@ class Cache {
     }
 }
 
-const instance$4 = singa({
+const instance$2 = singa({
     name: 'cache',
     factory: ()=>{
         let adapter;
@@ -389,62 +458,56 @@ const instance$4 = singa({
     }
 });
 function useCache() {
-    return instance$4.use();
+    return instance$2.use();
 }
 
+function toTransports(input) {
+    return Array.isArray(input) ? input : [
+        input
+    ];
+}
 function createLogger(ctx = {}) {
-    const { directory, options = {} } = ctx;
     let loggerTransports;
     if (read('env') === EnvironmentName.PRODUCTION) {
         loggerTransports = [
             new transports.Console({
                 level: 'info'
             }),
-            new transports.File({
-                filename: path.join(directory || process.cwd(), 'access.log'),
-                level: 'http',
-                maxsize: 10 * 1024 * 1024,
-                maxFiles: 5
-            }),
-            new transports.File({
-                filename: path.join(directory || process.cwd(), 'error.log'),
-                level: 'warn',
-                maxsize: 10 * 1024 * 1024,
-                maxFiles: 5
-            })
+            ...ctx.transports ? toTransports(ctx.transports) : []
         ];
     } else {
         loggerTransports = [
             new transports.Console({
                 level: 'debug'
-            })
+            }),
+            ...ctx.transports ? toTransports(ctx.transports) : []
         ];
     }
     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$3 = singa({
+const instance$1 = singa({
     name: 'logger'
 });
 function setLoggerFactory(factory) {
-    instance$3.setFactory(factory);
+    instance$1.setFactory(factory);
 }
 function isLoggerUsable() {
-    return instance$3.has() || instance$3.hasFactory();
+    return instance$1.has() || instance$1.hasFactory();
 }
 function setLogger(input) {
-    instance$3.set(input);
+    instance$1.set(input);
 }
 function useLogger() {
-    return instance$3.use();
+    return instance$1.use();
 }
 
 /*
@@ -466,35 +529,45 @@ function useLogger() {
     return obj;
 }
 class DomainEventPublisher {
-    addPublisher(publisher) {
-        this.publishers.add(publisher);
+    addConsumer(consumer) {
+        this.consumers.add(consumer);
     }
     async safePublish(ctx) {
         try {
             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)}`);
+        }
+        let destinations = [];
+        if (typeof ctx.destinations === 'function') {
+            destinations = ctx.destinations(ctx.data);
+        } else {
+            destinations = ctx.destinations;
         }
-        const publishers = this.publishers.values();
+        const consumeContext = {
+            ...ctx,
+            destinations
+        };
+        const consumers = this.consumers.values();
         while(true){
-            const it = publishers.next();
+            const it = consumers.next();
             if (it.done) {
                 return;
             }
-            await it.value.publish(ctx);
+            await it.value.consume(consumeContext);
         }
     }
     constructor(){
-        _define_property$3(this, "publishers", void 0);
-        this.publishers = new Set();
+        _define_property$3(this, "consumers", void 0);
+        this.consumers = new Set();
     }
 }
 
@@ -510,11 +583,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 buildDomainEventRedisChannel(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}`;
 }
 
 /*
@@ -536,17 +623,18 @@ function buildEventChannelName(input, id) {
     return obj;
 }
 class DomainEventRedisPublisher {
-    async publish(ctx) {
-        const data = JSON.stringify(transformEventData(ctx.data));
+    async consume(ctx) {
+        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];
+            const key = buildDomainEventRedisChannel(destination.channel, destination.namespace);
+            pipeline.publish(key, payloadSerialized);
         }
         await pipeline.exec();
     }
@@ -556,6 +644,27 @@ class DomainEventRedisPublisher {
     }
 }
 
+/*
+ * 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 buildDomainEventSocketNamespace(namespace) {
+    if (typeof namespace === 'undefined') {
+        return '/';
+    }
+    if (typeof namespace === 'string') {
+        return namespace.startsWith('/') ? namespace : `/${namespace}`;
+    }
+    return `/${namespace.join('/')}`;
+}
+function buildDomainEventSocketChannel(channel) {
+    if (typeof channel === 'string') {
+        return channel;
+    }
+    return channel.join('/');
+}
+
 /*
  * Copyright (c) 2022-2024.
  * Author Peter Placzek (tada5hi)
@@ -574,33 +683,26 @@ class DomainEventRedisPublisher {
     }
     return obj;
 }
-class DomainEventSocketPublisher {
-    async publish(ctx) {
+class DomainEventSocketConsumer {
+    async consume(ctx) {
         ctx.data = transformEventData(ctx.data);
         for(let i = 0; i < ctx.destinations.length; i++){
-            let namespace;
-            if (ctx.destinations[i].namespace) {
-                namespace = ctx.destinations[i].namespace;
-            } else {
-                namespace = '/';
-            }
+            const destination = ctx.destinations[i];
+            const namespace = buildDomainEventSocketNamespace(destination.namespace);
+            const roomName = buildDomainEventSocketChannel(destination.channel);
+            const fullEventName = buildDomainEventFullName(ctx.metadata.domain, ctx.metadata.event);
             const emitter = new Emitter(this.client, {}, namespace);
-            const fullEventName = buildDomainEventFullName(ctx.data.type, ctx.data.event);
-            const rooms = [
-                buildEventChannelName(ctx.destinations[i].channel)
-            ];
-            if (typeof ctx.destinations[i].channel === 'function') {
-                rooms.push(buildEventChannelName(ctx.destinations[i].channel, ctx.data.data.id));
-            }
-            for(let j = 0; j < rooms.length; j++){
-                emitter.in(rooms[j]).emit(fullEventName, {
-                    ...ctx.data,
-                    meta: {
-                        namespace,
-                        roomName: rooms[j]
-                    }
-                });
-            }
+            emitter.in(roomName).emit(fullEventName, {
+                data: {
+                    data: ctx.data,
+                    type: ctx.metadata.domain,
+                    event: ctx.metadata.event
+                },
+                meta: {
+                    namespace,
+                    roomName
+                }
+            });
         }
     }
     constructor(client){
@@ -609,33 +711,23 @@ class DomainEventSocketPublisher {
     }
 }
 
-const instance$2 = singa({
+const singaInstance = singa({
     name: 'domainEventPublisher',
     factory: ()=>{
         const publisher = new DomainEventPublisher();
         if (isRedisClientUsable()) {
             const client = useRedisClient();
-            publisher.addPublisher(new DomainEventRedisPublisher(client));
-            publisher.addPublisher(new DomainEventSocketPublisher(client));
+            publisher.addConsumer(new DomainEventRedisPublisher(client));
+            publisher.addConsumer(new DomainEventSocketConsumer(client));
         }
         return publisher;
     }
 });
-function useDomainEventPublisher() {
-    return instance$2.use();
-}
-
-const instance$1 = singa({
-    name: 'loki'
-});
-function setLokiFactory(factory) {
-    instance$1.setFactory(factory);
-}
-function isLokiClientUsable() {
-    return instance$1.has() || instance$1.hasFactory();
+function useDomainEventPublisherSinga() {
+    return singaInstance;
 }
-function useLokiClient() {
-    return instance$1.use();
+function useDomainEventPublisher() {
+    return singaInstance.use();
 }
 
 /*
@@ -658,7 +750,9 @@ function useLokiClient() {
 }
 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({
@@ -671,7 +765,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, {
@@ -680,6 +774,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') {
@@ -724,7 +823,14 @@ class QueueRouter {
                     }
                     return;
                 }
-                await handler(payload);
+                try {
+                    await handler(payload);
+                } catch (e) {
+                    if (isLoggerUsable()) {
+                        useLogger().error(e);
+                    }
+                    throw e;
+                }
             }
         });
     }
@@ -749,14 +855,5 @@ 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);
-}
-
-export { AuthupClient, Cache, ComponentError, DomainEventPublisher, DomainEventRedisPublisher, DomainEventSocketPublisher, MemoryCacheAdapter, QueueRouter, QueueRouterRoutingType, RedisCacheAdapter, buildCacheKey, buildQueueRouterPublishPayload, createCacheAdapter, createLogger, guessAuthupTokenCreatorOptions, hasOwnProperty, isAmqpClientUsable, isAuthupClientUsable, isClientAuthenticationHookUsable, isComponentError, isLoggerUsable, isLokiClientUsable, isQueuePayload, isQueueRouterPayload, isQueueRouterUsable, isRedisClientUsable, isVaultClientUsable, setAmqpClientFactory, setAuthupClientFactory, setClientAuthenticationHookFactory, setLogger, setLoggerFactory, setLokiFactory, setRedisClient, setRedisFactory, setVaultFactory, useAmqpClient, useAuthupClient, useCache, useClientAuthenticationHook, useDomainEventPublisher, useLogger, useLokiClient, useQueueRouter, useRedisClient, useRedisPublishClient, useRedisSubscribeClient, useVaultClient };
+export { AuthupClient, Cache, ComponentError, ComponentHandlers, DomainEventPublisher, DomainEventRedisPublisher, DomainEventSocketConsumer, MemoryCacheAdapter, QueueRouter, QueueRouterRoutingType, RedisCacheAdapter, buildCacheKey, buildDomainEventRedisChannel, buildDomainEventSocketChannel, buildDomainEventSocketNamespace, 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, useDomainEventPublisherSinga, useLogger, useQueueRouter, useRedisClient, useRedisPublishClient, useRedisSubscribeClient, useVaultClient };
 //# sourceMappingURL=index.mjs.map