@authup/server-kit 1.0.0-beta.26 → 1.0.0-beta.28

package/dist/index.mjs

@@ -1,17 +1,17 @@
 import { compare as compare$1, hash as hash$1 } from '@node-rs/bcrypt';
-import { subtle } from 'uncrypto';
 import { arrayBufferToBase64, base64ToArrayBuffer, isObject as isObject$1 } from '@authup/kit';
-import { JWTError, JWTAlgorithm, JWKType, OAuth2Error } from '@authup/specs';
+import { JWTAlgorithm, JWTError, JWKType } from '@authup/specs';
+import { subtle } from 'uncrypto';
 import { Algorithm, sign, verify } from '@node-rs/jsonwebtoken';
 import { isObject } from 'smob';
-import { JsonAdapter, buildKeyPath } from 'redis-extension';
-export { Client as RedisClient, ClientOptions as RedisClientOptions, JsonAdapter as RedisJsonAdapter, Watcher as RedisWatcher, buildKeyPath as buildRedisKeyPath, createClient as createRedisClient, escapeKey as escapeRedisKey, parseKeyPath as parseRedisKeyPath } from 'redis-extension';
-import { singa } from 'singa';
-import TTLCache from '@isaacs/ttlcache';
+import { TTLCache } from '@isaacs/ttlcache';
+import { createClient, JsonAdapter, buildKeyPath } from 'redis-extension';
+export { Client as RedisClient, JsonAdapter as RedisJsonAdapter, Watcher as RedisWatcher, buildKeyPath as buildRedisKeyPath, escapeKey as escapeRedisKey, parseKeyPath as parseRedisKeyPath } from 'redis-extension';
 import path from 'node:path';
 import process from 'node:process';
 import { transports, createLogger as createLogger$1, format } from 'winston';
 export { Logger } from 'winston';
+import { singa } from 'singa';
 export { VaultClient, createClient as createVaultClient } from '@hapic/vault';
 import { buildEventFullName } from '@authup/core-realtime-kit';
 import { Emitter } from '@socket.io/redis-emitter';
@@ -38,8 +38,62 @@ async function hash(str, rounds = 10) {
     return CryptoAsymmetricAlgorithm;
 }({});
 
-function isAsymmetricAlgorithm(input) {
-    return Object.values(CryptoAsymmetricAlgorithm).indexOf(input) !== -1;
+class BaseKey {
+    key;
+    // ----------------------------------------------
+    constructor(cryptoKey){
+        this.key = cryptoKey;
+    }
+    // ----------------------------------------------
+    async toArrayBuffer() {
+        if (this.key.type === 'private') {
+            return subtle.exportKey('pkcs8', this.key);
+        }
+        if (this.key.type === 'public') {
+            return subtle.exportKey('spki', this.key);
+        }
+        return subtle.exportKey('raw', this.key);
+    }
+    async toUint8Array() {
+        const arrayBuffer = await this.toArrayBuffer();
+        return new Uint8Array(arrayBuffer);
+    }
+    async toBase64() {
+        const arrayBuffer = await this.toArrayBuffer();
+        return arrayBufferToBase64(arrayBuffer);
+    }
+    async toJWK() {
+        return subtle.exportKey('jwk', this.key);
+    }
+}
+
+/*
+ * 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 enc(type, input) {
+    return `-----BEGIN ${type}-----\n${input}\n-----END ${type}-----`;
+}
+function encodePKCS8ToPEM(base64) {
+    return enc('PRIVATE KEY', base64);
+}
+function encodeSPKIToPem(input) {
+    return enc('PUBLIC KEY', input);
+}
+// ------------------------------------------------------------
+function dec(type, input) {
+    input = input.replace(`-----BEGIN ${type}-----\n`, '');
+    input = input.replace(`\n-----END ${type}-----\n`, '');
+    input = input.replace(`-----END ${type}-----\n`, '');
+    input = input.replace(`\n-----END ${type}-----`, '');
+    return input;
+}
+function decodePemToPKCS8(input) {
+    return dec('PRIVATE KEY', input);
+}
+function decodePemToSpki(input) {
+    return dec('PUBLIC KEY', input);
 }
 
 /**
@@ -144,38 +198,91 @@ function normalizeAsymmetricKeyImportOptions(options) {
     return optionsNormalized;
 }
 
-async function createAsymmetricKeyPair(options) {
-    const optionsNormalized = normalizeAsymmetricKeyPairCreateOptions(options);
-    return subtle.generateKey(optionsNormalized, true, getKeyUsagesForAsymmetricAlgorithm(optionsNormalized.name));
+class AsymmetricKey extends BaseKey {
+    async toPem() {
+        const base64 = await this.toBase64();
+        if (this.key.type === 'public') {
+            return encodeSPKIToPem(base64);
+        }
+        if (this.key.type === 'private') {
+            return encodePKCS8ToPEM(base64);
+        }
+        throw new Error(`${this.key.type} can not be converted to pem.`);
+    }
+    // ----------------------------------------------------------------
+    static async fromPem(ctx) {
+        if (ctx.format === 'pkcs8') {
+            return AsymmetricKey.fromBase64({
+                ...ctx,
+                key: decodePemToPKCS8(ctx.key)
+            });
+        }
+        return AsymmetricKey.fromBase64({
+            ...ctx,
+            key: decodePemToSpki(ctx.key)
+        });
+    }
+    static async fromBase64(ctx) {
+        const arrayBuffer = base64ToArrayBuffer(ctx.key);
+        return AsymmetricKey.fromArrayBuffer({
+            ...ctx,
+            key: arrayBuffer
+        });
+    }
+    static async fromArrayBuffer(ctx) {
+        const normalizedOptions = normalizeAsymmetricKeyImportOptions(ctx.options);
+        const cryptoKey = await subtle.importKey(ctx.format, ctx.key, normalizedOptions, true, getKeyUsagesForAsymmetricAlgorithm(normalizedOptions.name, ctx.format));
+        return new AsymmetricKey(cryptoKey);
+    }
+    // ----------------------------------------------------------------
+    static buildImportOptionsForJWTAlgorithm(alg) {
+        if (alg === JWTAlgorithm.RS256) {
+            return {
+                name: CryptoAsymmetricAlgorithm.RSASSA_PKCS1_V1_5,
+                hash: 'SHA-256'
+            };
+        }
+        if (alg === JWTAlgorithm.RS384) {
+            return {
+                name: CryptoAsymmetricAlgorithm.RSASSA_PKCS1_V1_5,
+                hash: 'SHA-384'
+            };
+        }
+        if (alg === JWTAlgorithm.RS512) {
+            return {
+                name: CryptoAsymmetricAlgorithm.RSASSA_PKCS1_V1_5,
+                hash: 'SHA-512'
+            };
+        }
+        if (alg === JWTAlgorithm.ES256) {
+            return {
+                name: CryptoAsymmetricAlgorithm.ECDSA,
+                namedCurve: 'P-256'
+            };
+        }
+        if (alg === JWTAlgorithm.ES384) {
+            return {
+                name: CryptoAsymmetricAlgorithm.ECDSA,
+                namedCurve: 'P-384'
+            };
+        }
+        if (alg === JWTAlgorithm.ES512) {
+            return {
+                name: CryptoAsymmetricAlgorithm.ECDSA,
+                namedCurve: 'P-521'
+            };
+        }
+        throw new Error(`Signature algorithm ${alg} is not supported.`);
+    }
 }
 
-/*
- * 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 enc(type, input) {
-    return `-----BEGIN ${type}-----\n${input}\n-----END ${type}-----`;
-}
-function encodePKCS8ToPEM(base64) {
-    return enc('PRIVATE KEY', base64);
-}
-function encodeSPKIToPem(input) {
-    return enc('PUBLIC KEY', input);
-}
-// ------------------------------------------------------------
-function dec(type, input) {
-    input = input.replace(`-----BEGIN ${type}-----\n`, '');
-    input = input.replace(`\n-----END ${type}-----\n`, '');
-    input = input.replace(`-----END ${type}-----\n`, '');
-    input = input.replace(`\n-----END ${type}-----`, '');
-    return input;
-}
-function decodePemToPKCS8(input) {
-    return dec('PRIVATE KEY', input);
+function isAsymmetricAlgorithm(input) {
+    return Object.values(CryptoAsymmetricAlgorithm).indexOf(input) !== -1;
 }
-function decodePemToSpki(input) {
-    return dec('PUBLIC KEY', input);
+
+async function createAsymmetricKeyPair(options) {
+    const optionsNormalized = normalizeAsymmetricKeyPairCreateOptions(options);
+    return subtle.generateKey(optionsNormalized, true, getKeyUsagesForAsymmetricAlgorithm(optionsNormalized.name));
 }
 
 /*
@@ -191,28 +298,6 @@ function decodePemToSpki(input) {
     return SymmetricAlgorithm;
 }({});
 
-function normalizeSymmetricKeyCreateOptions(input) {
-    if (input.name === SymmetricAlgorithm.HMAC) {
-        return {
-            hash: 'SHA-256',
-            ...input
-        };
-    }
-    return {
-        length: 256,
-        name: input.name
-    };
-}
-function normalizeSymmetricKeyImportOptions(input) {
-    if (input.name === SymmetricAlgorithm.HMAC) {
-        return {
-            hash: 'SHA-256',
-            ...input
-        };
-    }
-    return input;
-}
-
 function isSymmetricAlgorithm(input) {
     return Object.values(SymmetricAlgorithm).indexOf(input) !== -1;
 }
@@ -235,90 +320,69 @@ function getKeyUsagesForSymmetricAlgorithm(name) {
     throw new SyntaxError(`Key usages can not be determined for symmetric algorithm: ${name}`);
 }
 
-async function createSymmetricKey(input) {
-    const optionsNormalized = normalizeSymmetricKeyCreateOptions(input);
-    return subtle.generateKey(optionsNormalized, true, getKeyUsagesForSymmetricAlgorithm(optionsNormalized.name));
-}
-
-function getKeyUsagesForAlgorithm(name, format) {
-    if (isAsymmetricAlgorithm(name)) {
-        return getKeyUsagesForAsymmetricAlgorithm(name, format);
+function normalizeSymmetricKeyCreateOptions(input) {
+    if (input.name === SymmetricAlgorithm.HMAC) {
+        return {
+            hash: 'SHA-256',
+            ...input
+        };
     }
-    if (isSymmetricAlgorithm(name)) {
-        return getKeyUsagesForSymmetricAlgorithm(name);
+    return {
+        length: 256,
+        name: input.name
+    };
+}
+function normalizeSymmetricKeyImportOptions(input) {
+    if (input.name === SymmetricAlgorithm.HMAC) {
+        return {
+            hash: 'SHA-256',
+            ...input
+        };
     }
-    throw new SyntaxError(`Key usages can not be determined for algorithm: ${name}`);
+    return input;
 }
 
-class CryptoKeyContainer {
-    // ----------------------------------------------
-    async toArrayBuffer() {
-        if (this.key.type === 'private') {
-            return subtle.exportKey('pkcs8', this.key);
-        }
-        if (this.key.type === 'public') {
-            return subtle.exportKey('spki', this.key);
-        }
-        return subtle.exportKey('raw', this.key);
-    }
-    async toUint8Array() {
-        const arrayBuffer = await this.toArrayBuffer();
-        return new Uint8Array(arrayBuffer);
-    }
-    async toBase64() {
-        const arrayBuffer = await this.toArrayBuffer();
-        return arrayBufferToBase64(arrayBuffer);
-    }
-    async toPem() {
-        const base64 = await this.toBase64();
-        if (this.key.type === 'public') {
-            return encodeSPKIToPem(base64);
-        }
-        if (this.key.type === 'private') {
-            return encodePKCS8ToPEM(base64);
-        }
-        throw new Error('A symmetric key can not be encoded as PEM');
-    }
-    async toJWK() {
-        return subtle.exportKey('jwk', this.key);
-    }
-    // ----------------------------------------------
-    static async fromPem(ctx) {
-        if (ctx.format === 'pkcs8') {
-            return CryptoKeyContainer.fromBase64({
-                ...ctx,
-                key: decodePemToPKCS8(ctx.key)
-            });
-        }
-        return CryptoKeyContainer.fromBase64({
-            ...ctx,
-            key: decodePemToSpki(ctx.key)
-        });
-    }
+class SymmetricKey extends BaseKey {
     static async fromBase64(ctx) {
         const arrayBuffer = base64ToArrayBuffer(ctx.key);
-        return CryptoKeyContainer.fromArrayBuffer({
+        return SymmetricKey.fromArrayBuffer({
             ...ctx,
             key: arrayBuffer
         });
     }
     static async fromArrayBuffer(ctx) {
-        let normalizedOptions;
-        if (ctx.format === 'spki' || ctx.format === 'pkcs8') {
-            normalizedOptions = normalizeAsymmetricKeyImportOptions(ctx.options);
-        } else if (ctx.format === 'raw') {
-            normalizedOptions = normalizeSymmetricKeyImportOptions(ctx.options);
-        } else {
-            throw new SyntaxError(`Format ${ctx.format} is not supported.`);
+        const normalizedOptions = normalizeSymmetricKeyImportOptions(ctx.options);
+        const cryptoKey = await subtle.importKey(ctx.format, ctx.key, normalizedOptions, true, getKeyUsagesForSymmetricAlgorithm(normalizedOptions.name));
+        return new SymmetricKey(cryptoKey);
+    }
+    static buildImportOptionsForJWTAlgorithm(alg) {
+        if (alg === JWTAlgorithm.HS256) {
+            return {
+                name: SymmetricAlgorithm.HMAC,
+                hash: 'SHA-256'
+            };
         }
-        const cryptoKey = await subtle.importKey(ctx.format, ctx.key, normalizedOptions, true, getKeyUsagesForAlgorithm(normalizedOptions.name, ctx.format));
-        return new CryptoKeyContainer(cryptoKey);
-    }
-    constructor(cryptoKey){
-        this.key = cryptoKey;
+        if (alg === JWTAlgorithm.HS384) {
+            return {
+                name: SymmetricAlgorithm.HMAC,
+                hash: 'SHA-384'
+            };
+        }
+        if (alg === JWTAlgorithm.HS512) {
+            return {
+                name: SymmetricAlgorithm.HMAC,
+                hash: 'SHA-512'
+            };
+        }
+        throw new Error(`Signature algorithm ${alg} is not supported.`);
     }
 }
 
+async function createSymmetricKey(input) {
+    const optionsNormalized = normalizeSymmetricKeyCreateOptions(input);
+    return subtle.generateKey(optionsNormalized, true, getKeyUsagesForSymmetricAlgorithm(optionsNormalized.name));
+}
+
 /**
  * Decode a JWT token with no verification.
  *
@@ -482,7 +546,7 @@ async function signToken(claims, context) {
                 if (typeof context.key === 'string') {
                     key = encodePKCS8ToPEM(context.key);
                 } else {
-                    const keyContainer = new CryptoKeyContainer(context.key);
+                    const keyContainer = new AsymmetricKey(context.key);
                     key = await keyContainer.toPem();
                 }
                 if (context.type === JWKType.RSA) {
@@ -502,7 +566,7 @@ async function signToken(claims, context) {
                 if (typeof context.key === 'string') {
                     key = context.key;
                 } else {
-                    const keyContainer = new CryptoKeyContainer(context.key);
+                    const keyContainer = new SymmetricKey(context.key);
                     key = await keyContainer.toUint8Array();
                 }
                 return sign(claims, key, {
@@ -511,7 +575,7 @@ async function signToken(claims, context) {
                 });
             }
     }
-    throw new OAuth2Error();
+    throw new JWTError();
 }
 
 /**
@@ -549,7 +613,7 @@ async function signToken(claims, context) {
                     if (typeof context.key === 'string') {
                         key = encodeSPKIToPem(context.key);
                     } else {
-                        const keyContainer = new CryptoKeyContainer(context.key);
+                        const keyContainer = new AsymmetricKey(context.key);
                         key = await keyContainer.toPem();
                     }
                     promise = verify(token, key, {
@@ -569,7 +633,7 @@ async function signToken(claims, context) {
                     if (typeof context.key === 'string') {
                         key = context.key;
                     } else {
-                        const keyContainer = new CryptoKeyContainer(context.key);
+                        const keyContainer = new SymmetricKey(context.key);
                         key = await keyContainer.toUint8Array();
                     }
                     promise = verify(token, key, {
@@ -578,40 +642,61 @@ async function signToken(claims, context) {
                     });
                 }
         }
-        output = await promise;
+        if (promise) {
+            output = await promise;
+        }
     } catch (e) {
         throw createErrorForJWTError(e);
     }
-    if (typeof output === 'undefined') {
-        throw new OAuth2Error({
-            message: 'Invalid type.'
-        });
+    if (!output) {
+        throw new JWTError();
     }
     return output;
 }
 
-const instance$3 = singa({
-    name: 'redis'
-});
-function setRedisFactory(factory) {
-    instance$3.setFactory(factory);
-}
-function isRedisClientUsable() {
-    return instance$3.has() || instance$3.hasFactory();
-}
-function setRedisClient(input) {
-    instance$3.set(input);
-}
-function useRedisClient() {
-    return instance$3.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.
+ */ class DomainEventPublisher {
+    publishers;
+    constructor(){
+        this.publishers = new Set();
+    }
+    mount(publisher) {
+        this.publishers.add(publisher);
+    }
+    async publish(ctx) {
+        const publishers = this.publishers.values();
+        while(true){
+            const it = publishers.next();
+            if (it.done) {
+                return;
+            }
+            await it.value.publish(ctx);
+        }
+    }
 }
 
-class MemoryCacheAdapter {
+class MemoryCache {
+    instance;
+    constructor(options = {}){
+        this.instance = new TTLCache({
+            checkAgeOnGet: true,
+            ttl: Infinity,
+            ...options || {}
+        });
+    }
     async has(key) {
         return this.instance.has(key);
     }
     async get(key) {
-        return this.instance.get(key);
+        const output = await this.instance.get(key);
+        if (output) {
+            return output;
+        }
+        return null;
     }
     async set(key, value, options) {
         this.instance.set(key, value, {
@@ -631,6 +716,9 @@ class MemoryCacheAdapter {
             const keys = this.instance.keys();
             let iterator = keys.next();
             while(!iterator.done){
+                if (typeof iterator.value !== 'string') {
+                    continue;
+                }
                 if (iterator.value.startsWith(options.prefix)) {
                     this.instance.delete(iterator.value);
                 }
@@ -640,30 +728,56 @@ class MemoryCacheAdapter {
         }
         this.instance.clear();
     }
-    constructor(options = {}){
-        this.instance = new TTLCache({
-            checkAgeOnGet: true,
-            ttl: Infinity,
-            ...options || {}
+}
+
+function isRedisClient(data) {
+    return isObject(data) && typeof data.connect === 'function' && typeof data.disconnect === 'function';
+}
+
+function createRedisClient(input) {
+    if (typeof input === 'boolean') {
+        return createClient({
+            connectionString: 'redis://127.0.0.1'
         });
     }
+    if (typeof input === 'string') {
+        return createClient({
+            connectionString: input
+        });
+    }
+    if (!isRedisClient(input)) {
+        return createClient({
+            options: input
+        });
+    }
+    return input;
 }
 
-class RedisCacheAdapter {
+class RedisCache {
+    client;
+    jsonAdapter;
+    constructor(input){
+        this.client = createRedisClient(input);
+        this.jsonAdapter = new JsonAdapter(this.client);
+    }
     async get(key) {
-        return this.instance.get(key);
+        const output = await this.jsonAdapter.get(key);
+        if (output) {
+            return output;
+        }
+        return null;
     }
     async has(key) {
         const output = await this.get(key);
-        return typeof output !== 'undefined';
+        return !!output;
     }
     async set(key, value, options) {
-        await this.instance.set(key, value, {
+        await this.jsonAdapter.set(key, value, {
             milliseconds: options.ttl
         });
     }
     async drop(key) {
-        await this.instance.drop(key);
+        await this.jsonAdapter.drop(key);
     }
     async dropMany(keys) {
         const pipeline = this.client.pipeline();
@@ -684,65 +798,12 @@ class RedisCacheAdapter {
         }
         await this.client.flushdb();
     }
-    constructor(){
-        this.client = useRedisClient();
-        this.instance = new JsonAdapter(this.client);
-    }
-}
-
-function createCacheAdapter() {
-    if (isRedisClientUsable()) {
-        return new RedisCacheAdapter();
-    }
-    return new MemoryCacheAdapter();
 }
 
 function buildCacheKey(options) {
     return buildKeyPath(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.
- */ class Cache {
-    async set(key, value, options = {}) {
-        await this.adapter.set(key, value, options);
-    }
-    async get(key) {
-        return this.adapter.get(key);
-    }
-    async drop(key) {
-        return this.adapter.drop(key);
-    }
-    async dropMany(keys) {
-        return this.adapter.dropMany(keys);
-    }
-    async clear(options = {}) {
-        return this.adapter.clear(options);
-    }
-    constructor(adapter){
-        this.adapter = adapter;
-    }
-}
-
-const instance$2 = singa({
-    name: 'cache',
-    factory: ()=>{
-        let adapter;
-        if (isRedisClientUsable()) {
-            adapter = new RedisCacheAdapter();
-        } else {
-            adapter = new MemoryCacheAdapter();
-        }
-        return new Cache(adapter);
-    }
-});
-function useCache() {
-    return instance$2.use();
-}
-
 function createLogger(context) {
     let items;
     const cwd = context.directory || process.cwd();
@@ -810,13 +871,15 @@ function useVaultClient() {
 }
 
 function transformDomainEventData(input) {
-    if (isObject$1(input)) {
-        const keys = Object.keys(input);
-        for(let i = 0; i < keys.length; i++){
-            const value = input[keys[i]];
-            if (value instanceof Date) {
-                input[keys[i]] = value.toISOString();
-            }
+    const keys = Object.keys(input);
+    for(let i = 0; i < keys.length; i++){
+        const key = keys[i];
+        const value = input[key];
+        if (!isObject$1(value)) {
+            continue;
+        }
+        if (value instanceof Date) {
+            input[key] = value.toISOString();
         }
     }
     return input;
@@ -829,6 +892,10 @@ function buildDomainEventChannelName(input, id) {
 }
 
 class DomainEventRedisPublisher {
+    driver;
+    constructor(input){
+        this.driver = createRedisClient(input);
+    }
     async publish(ctx) {
         const data = JSON.stringify(transformDomainEventData(ctx.content));
         const pipeline = this.driver.pipeline();
@@ -844,22 +911,25 @@ class DomainEventRedisPublisher {
         }
         await pipeline.exec();
     }
-    constructor(client){
-        this.driver = client;
-    }
 }
 
 class DomainEventSocketPublisher {
+    driver;
+    constructor(input){
+        const client = createRedisClient(input);
+        this.driver = new Emitter(client);
+    }
     async publish(ctx) {
         ctx.content = transformDomainEventData(ctx.content);
         for(let i = 0; i < ctx.destinations.length; i++){
+            const destination = ctx.destinations[i];
             let emitter;
-            if (ctx.destinations[i].namespace) {
-                emitter = this.driver.of(ctx.destinations[i].namespace);
+            if (destination.namespace) {
+                emitter = this.driver.of(destination.namespace);
             } else {
                 emitter = this.driver;
             }
-            let roomName = buildDomainEventChannelName(ctx.destinations[i].channel);
+            let roomName = buildDomainEventChannelName(destination.channel);
             const fullEventName = buildEventFullName(ctx.content.type, ctx.content.event);
             emitter.in(roomName).emit(fullEventName, {
                 ...ctx.content,
@@ -867,8 +937,8 @@ class DomainEventSocketPublisher {
                     roomName
                 }
             });
-            if (typeof ctx.destinations[i].channel === 'function') {
-                roomName = buildDomainEventChannelName(ctx.destinations[i].channel, ctx.content.data.id);
+            if (typeof destination.channel === 'function') {
+                roomName = buildDomainEventChannelName(destination.channel, ctx.content.data.id);
                 emitter.in(roomName).emit(fullEventName, {
                     ...ctx.content,
                     meta: {
@@ -879,30 +949,6 @@ class DomainEventSocketPublisher {
             }
         }
     }
-    constructor(client){
-        this.driver = new Emitter(client);
-    }
-}
-
-class DomainEventPublisher {
-    async publish(ctx) {
-        const publishers = this.publishers.values();
-        while(true){
-            const it = publishers.next();
-            if (it.done) {
-                return;
-            }
-            await it.value.publish(ctx);
-        }
-    }
-    constructor(){
-        this.publishers = new Set();
-        if (isRedisClientUsable()) {
-            const client = useRedisClient();
-            this.publishers.add(new DomainEventRedisPublisher(client));
-            this.publishers.add(new DomainEventSocketPublisher(client));
-        }
-    }
 }
 
 /*
@@ -914,5 +960,5 @@ class DomainEventPublisher {
     return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
-export { Cache, CryptoAsymmetricAlgorithm, CryptoKeyContainer, DomainEventPublisher, DomainEventRedisPublisher, DomainEventSocketPublisher, MemoryCacheAdapter, RedisCacheAdapter, SymmetricAlgorithm, buildCacheKey, compare, createAsymmetricKeyPair, createCacheAdapter, createLogger, createSymmetricKey, decodePemToPKCS8, decodePemToSpki, encodePKCS8ToPEM, encodeSPKIToPem, extractTokenHeader, extractTokenPayload, getKeyUsagesForAlgorithm, getKeyUsagesForAsymmetricAlgorithm, getKeyUsagesForSymmetricAlgorithm, hasOwnProperty, hash, isAsymmetricAlgorithm, isLoggerUsable, isRedisClientUsable, isSymmetricAlgorithm, isVaultClientUsable, normalizeAsymmetricKeyImportOptions, normalizeAsymmetricKeyPairCreateOptions, setLogger, setLoggerFactory, setRedisClient, setRedisFactory, setVaultFactory, signToken, useCache, useLogger, useRedisClient, useVaultClient, verifyToken };
+export { AsymmetricKey, BaseKey, CryptoAsymmetricAlgorithm, DomainEventPublisher, DomainEventRedisPublisher, DomainEventSocketPublisher, MemoryCache, RedisCache, SymmetricAlgorithm, SymmetricKey, buildCacheKey, compare, createAsymmetricKeyPair, createLogger, createRedisClient, createSymmetricKey, decodePemToPKCS8, decodePemToSpki, encodePKCS8ToPEM, encodeSPKIToPem, extractTokenHeader, extractTokenPayload, getKeyUsagesForAsymmetricAlgorithm, getKeyUsagesForSymmetricAlgorithm, hasOwnProperty, hash, isAsymmetricAlgorithm, isLoggerUsable, isRedisClient, isSymmetricAlgorithm, isVaultClientUsable, normalizeAsymmetricKeyImportOptions, normalizeAsymmetricKeyPairCreateOptions, setLogger, setLoggerFactory, setVaultFactory, signToken, useLogger, useVaultClient, verifyToken };
 //# sourceMappingURL=index.mjs.map