@authup/server-kit 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/index.cjs

@@ -1,25 +1,44 @@
 'use strict';
 
-var bcrypt = require('bcrypt');
+var bcrypt = require('@node-rs/bcrypt');
 var node_crypto = require('node:crypto');
-var core = require('@authup/core');
+var kit = require('@authup/kit');
 var path = require('node:path');
 var fs = require('node:fs');
-var jsonwebtoken = require('jsonwebtoken');
+var jsonwebtoken = require('@node-rs/jsonwebtoken');
 var smob = require('smob');
+var process$1 = require('node:process');
+var winston = require('winston');
+var singa = require('singa');
 var redisExtension = require('redis-extension');
+var vault = require('@hapic/vault');
 var redisEmitter = require('@socket.io/redis-emitter');
-var http = require('node:http');
-var https = require('node:https');
-var proxyFromEnv = require('proxy-from-env');
-var nodemailer = require('nodemailer');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var process__namespace = /*#__PURE__*/_interopNamespaceDefault(process$1);
 
 async function compare(value, hashedValue) {
     return bcrypt.compare(value, hashedValue);
 }
 
-async function hash(str, saltOrRounds = 10) {
-    return bcrypt.hash(str, saltOrRounds);
+async function hash(str, rounds = 10) {
+    return bcrypt.hash(str, rounds);
 }
 
 /*
@@ -34,10 +53,10 @@ async function hash(str, saltOrRounds = 10) {
 })(exports.KeyPairKind || (exports.KeyPairKind = {}));
 
 function isKeyPair(data) {
-    return core.isObject(data) && typeof data.privateKey !== 'undefined' && typeof data.publicKey !== 'undefined';
+    return kit.isObject(data) && typeof data.privateKey !== 'undefined' && typeof data.publicKey !== 'undefined';
 }
 function isKeyPairWithPublicKey(data) {
-    return core.isObject(data) && typeof data.publicKey !== 'undefined';
+    return kit.isObject(data) && typeof data.publicKey !== 'undefined';
 }
 
 function extendKeyPairOptions(options) {
@@ -126,6 +145,41 @@ function decryptRSAPrivateKey(context, key) {
     return content;
 }
 
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function wrapPem(type, input) {
+    if (typeof input !== 'string') {
+        input = Buffer.from(input).toString('base64');
+    }
+    return `-----BEGIN ${type}-----\n${input}\n-----END ${type}-----`;
+}
+function wrapPrivateKeyPem(input) {
+    return wrapPem('PRIVATE KEY', input);
+}
+function wrapPublicKeyPem(input) {
+    return wrapPem('PUBLIC KEY', input);
+}
+// ------------------------------------------------------------
+function unwrapPem(type, input) {
+    if (typeof input !== 'string') {
+        input = Buffer.from(input).toString('base64');
+    }
+    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 unwrapPrivateKeyPem(input) {
+    return unwrapPem('PRIVATE KEY', input);
+}
+function unwrapPublicKeyPem(input) {
+    return unwrapPem('PUBLIC KEY', input);
+}
+
 async function saveKeyPair(keyPair, context) {
     context = extendKeyPairOptions(context);
     await fs.promises.mkdir(context.directory, {
@@ -264,130 +318,232 @@ async function useKeyPair(value) {
     return keyPair;
 }
 
+/**
+ * Decode a JWT token with no verification.
+ *
+ * @param token
+ *
+ * @throws TokenError
+ */ function extractTokenHeader(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+        throw kit.TokenError.payloadInvalid('The token format is not valid.');
+    }
+    const [headerBase64] = parts;
+    try {
+        const payload = atob(headerBase64);
+        return JSON.parse(payload);
+    /*
+        return {
+            typ: 'JWT',
+            alg: transformInternalToJWTAlgorithm(header.algorithm),
+            cty: header.contentType,
+            jku: header.jsonKeyUrl,
+            kid: header.keyId,
+            x5u: header.x5Url,
+            x5c: header.x5CertChain,
+            x5t: header.x5CertThumbprint,
+            'x5t#S256': header.x5TS256CertThumbprint,
+        };
+         */ } catch (e) {
+        throw kit.TokenError.headerInvalid('The token header could not be extracted.');
+    }
+}
+function extractTokenPayload(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+        throw kit.TokenError.payloadInvalid('The token format is not valid.');
+    }
+    const [, payloadBase64] = parts;
+    try {
+        const payload = atob(payloadBase64);
+        return JSON.parse(payload);
+    } catch (e) {
+        throw kit.TokenError.payloadInvalid('The token payload could not be extracted.');
+    }
+}
+
 function createErrorForJWTError(e) {
-    if (smob.isObject(e) && typeof e.name === 'string') {
-        switch(e.name){
-            case 'TokenExpiredError':
+    if (smob.isObject(e)) {
+        if (typeof e.name === 'string') {
+            switch(e.name){
+                case 'TokenExpiredError':
+                    {
+                        return kit.TokenError.expired();
+                    }
+                case 'NotBeforeError':
+                    {
+                        if (typeof e.date === 'string' || e.date instanceof Date) {
+                            return kit.TokenError.notActiveBefore(e.date);
+                        }
+                        break;
+                    }
+                case 'JsonWebTokenError':
+                    {
+                        if (typeof e.message === 'string') {
+                            return kit.TokenError.payloadInvalid(e.message);
+                        }
+                        break;
+                    }
+            }
+        }
+        // @see https://github.com/Keats/jsonwebtoken/blob/master/src/errors.rs
+        switch(e.message){
+            case 'ExpiredSignature':
                 {
-                    return core.TokenError.expired();
+                    return kit.TokenError.expired();
                 }
-            case 'NotBeforeError':
+            case 'ImmatureSignature':
                 {
-                    if (typeof e.date === 'string' || e.date instanceof Date) {
-                        return core.TokenError.notActiveBefore(e.date);
-                    }
-                    break;
+                    return kit.TokenError.notActiveBefore();
                 }
-            case 'JsonWebTokenError':
+            case 'InvalidToken':
+            case 'InvalidSignature':
                 {
-                    if (typeof e.message === 'string') {
-                        return core.TokenError.payloadInvalid(e.message);
-                    }
-                    break;
+                    return kit.TokenError.payloadInvalid();
                 }
         }
     }
-    return new core.TokenError({
+    return new kit.TokenError({
         cause: e,
         logMessage: true,
         message: 'The JWT error could not be determined.'
     });
 }
-
-function decodeToken(token, options) {
-    options ?? (options = {});
-    let output;
-    try {
-        output = jsonwebtoken.decode(token, {
-            ...options
-        });
-    } catch (e) {
-        throw createErrorForJWTError(e);
-    }
-    if (output === null) {
-        throw core.TokenError.payloadInvalid('The token could not be decoded.');
+function transformJWTAlgorithmToInternal(algorithm) {
+    switch(algorithm){
+        case kit.JWTAlgorithm.HS256:
+            {
+                return jsonwebtoken.Algorithm.HS256;
+            }
+        case kit.JWTAlgorithm.HS384:
+            {
+                return jsonwebtoken.Algorithm.HS384;
+            }
+        case kit.JWTAlgorithm.HS512:
+            {
+                return jsonwebtoken.Algorithm.HS512;
+            }
+        case kit.JWTAlgorithm.RS256:
+            {
+                return jsonwebtoken.Algorithm.RS256;
+            }
+        case kit.JWTAlgorithm.RS384:
+            {
+                return jsonwebtoken.Algorithm.RS384;
+            }
+        case kit.JWTAlgorithm.RS512:
+            {
+                return jsonwebtoken.Algorithm.RS512;
+            }
+        case kit.JWTAlgorithm.ES256:
+            {
+                return jsonwebtoken.Algorithm.ES256;
+            }
+        case kit.JWTAlgorithm.ES384:
+            {
+                return jsonwebtoken.Algorithm.ES384;
+            }
+        case kit.JWTAlgorithm.PS256:
+            {
+                return jsonwebtoken.Algorithm.PS256;
+            }
+        case kit.JWTAlgorithm.PS384:
+            {
+                return jsonwebtoken.Algorithm.PS384;
+            }
+        case kit.JWTAlgorithm.PS512:
+            {
+                return jsonwebtoken.Algorithm.PS512;
+            }
     }
-    return output;
+    throw new Error(`The algorithm ${algorithm} is not supported.`);
 }
 
-async function signToken(payload, context) {
-    context.expiresIn = context.expiresIn || 3600;
+const getUtcTimestamp = ()=>Math.floor(new Date().getTime() / 1000);
+async function signToken(claims, context) {
+    if (typeof claims.exp !== 'number') {
+        claims.exp = getUtcTimestamp() + 3600;
+    }
+    if (typeof claims.iat !== 'number') {
+        claims.iat = getUtcTimestamp();
+    }
     switch(context.type){
-        case core.KeyType.RSA:
-        case core.KeyType.EC:
+        case kit.JWKType.RSA:
+        case kit.JWKType.EC:
             {
-                const { type, keyPair, ...options } = context;
-                const { privateKey } = isKeyPair(keyPair) ? keyPair : await useKeyPair(keyPair);
-                if (type === core.KeyType.RSA) {
-                    options.algorithm = options.algorithm || 'RS256';
+                const { privateKey } = isKeyPair(context.keyPair) ? context.keyPair : await useKeyPair(context.keyPair);
+                let algorithm;
+                if (context.type === kit.JWKType.RSA) {
+                    algorithm = context.algorithm ? transformJWTAlgorithmToInternal(context.algorithm) : jsonwebtoken.Algorithm.RS256;
                 } else {
-                    options.algorithm = options.algorithm || 'ES256';
+                    algorithm = context.algorithm ? transformJWTAlgorithmToInternal(context.algorithm) : jsonwebtoken.Algorithm.ES256;
                 }
-                return jsonwebtoken.sign(payload, privateKey, options);
+                return jsonwebtoken.sign(claims, privateKey, {
+                    algorithm,
+                    keyId: context.keyId
+                });
             }
-        case core.KeyType.OCT:
+        case kit.JWKType.OCT:
             {
-                const { type, secret, ...options } = context;
-                options.algorithm = options.algorithm || 'HS256';
-                return jsonwebtoken.sign(payload, secret, options);
+                const algorithm = context.algorithm ? transformJWTAlgorithmToInternal(context.algorithm) : jsonwebtoken.Algorithm.HS256;
+                return jsonwebtoken.sign(claims, context.key, {
+                    algorithm,
+                    keyId: context.keyId
+                });
             }
     }
-    throw new core.TokenError();
+    throw new kit.TokenError();
 }
 
-async function verifyToken(token, context) {
+/**
+ * Verify JWT.
+ *
+ * @param token
+ * @param context
+ *
+ * @throws TokenError
+ */ async function verifyToken(token, context) {
     let promise;
     let output;
     try {
         switch(context.type){
-            case core.KeyType.RSA:
-            case core.KeyType.EC:
+            case kit.JWKType.RSA:
+            case kit.JWKType.EC:
                 {
-                    const { type, keyPair, ...options } = context;
-                    const { publicKey } = isKeyPairWithPublicKey(keyPair) ? keyPair : await useKeyPair(keyPair);
-                    if (type === core.KeyType.RSA) {
-                        options.algorithms = options.algorithms || [
-                            'RS256',
-                            'RS384',
-                            'RS512',
-                            'PS256',
-                            'PS384',
-                            'PS512'
+                    const { publicKey } = isKeyPairWithPublicKey(context.keyPair) ? context.keyPair : await useKeyPair(context.keyPair);
+                    let algorithms;
+                    if (context.type === kit.JWKType.RSA) {
+                        algorithms = context.algorithms ? context.algorithms.map((algorithm)=>transformJWTAlgorithmToInternal(algorithm)) : [
+                            jsonwebtoken.Algorithm.RS256,
+                            jsonwebtoken.Algorithm.RS384,
+                            jsonwebtoken.Algorithm.RS512,
+                            jsonwebtoken.Algorithm.PS256,
+                            jsonwebtoken.Algorithm.PS384,
+                            jsonwebtoken.Algorithm.PS512
                         ];
                     } else {
-                        options.algorithms = options.algorithms || [
-                            'ES256',
-                            'ES384',
-                            'ES512'
+                        algorithms = context.algorithms ? context.algorithms.map((algorithm)=>transformJWTAlgorithmToInternal(algorithm)) : [
+                            jsonwebtoken.Algorithm.ES256,
+                            jsonwebtoken.Algorithm.ES384
                         ];
                     }
-                    promise = new Promise((resolve, reject)=>{
-                        jsonwebtoken.verify(token, publicKey, options, (err, decoded)=>{
-                            if (err) {
-                                reject(err);
-                                return;
-                            }
-                            resolve(decoded);
-                        });
+                    promise = jsonwebtoken.verify(token, publicKey, {
+                        algorithms,
+                        validateNbf: true
                     });
                     break;
                 }
-            case core.KeyType.OCT:
+            case kit.JWKType.OCT:
                 {
-                    const { type, secret, ...options } = context;
-                    options.algorithms = options.algorithms || [
-                        'HS256',
-                        'HS384',
-                        'HS512'
+                    const algorithms = context.algorithms ? context.algorithms.map((algorithm)=>transformJWTAlgorithmToInternal(algorithm)) : [
+                        jsonwebtoken.Algorithm.HS256,
+                        jsonwebtoken.Algorithm.HS384,
+                        jsonwebtoken.Algorithm.HS512
                     ];
-                    promise = new Promise((resolve, reject)=>{
-                        jsonwebtoken.verify(token, secret, options, (err, decoded)=>{
-                            if (err) {
-                                reject(err);
-                                return;
-                            }
-                            resolve(decoded);
-                        });
+                    promise = jsonwebtoken.verify(token, context.key, {
+                        algorithms,
+                        validateNbf: true
                     });
                 }
         }
@@ -396,15 +552,94 @@ async function verifyToken(token, context) {
         throw createErrorForJWTError(e);
     }
     if (typeof output === 'undefined') {
-        throw new core.TokenError({
+        throw new kit.TokenError({
             message: 'Invalid type.'
         });
     }
     return output;
 }
 
+function createLogger(context) {
+    let items;
+    const cwd = context.directory || process__namespace.cwd();
+    if (context.env === 'production') {
+        items = [
+            new winston.transports.Console({
+                level: 'info'
+            }),
+            new winston.transports.File({
+                filename: path.join(cwd, 'access.log'),
+                level: 'http',
+                maxsize: 10 * 1024 * 1024,
+                maxFiles: 5
+            }),
+            new winston.transports.File({
+                filename: path.join(cwd, 'error.log'),
+                level: 'warn',
+                maxsize: 10 * 1024 * 1024,
+                maxFiles: 5
+            })
+        ];
+    } else {
+        items = [
+            new winston.transports.Console({
+                level: 'debug'
+            })
+        ];
+    }
+    return winston.createLogger({
+        format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
+        transports: items
+    });
+}
+
+const instance$2 = singa.singa({
+    name: 'logger'
+});
+function setLoggerFactory(factory) {
+    instance$2.setFactory(factory);
+}
+function isLoggerUsable() {
+    return instance$2.has() || instance$2.hasFactory();
+}
+function setLogger(input) {
+    instance$2.set(input);
+}
+function useLogger() {
+    return instance$2.use();
+}
+
+const instance$1 = singa.singa({
+    name: 'redis'
+});
+function setRedisFactory(factory) {
+    instance$1.setFactory(factory);
+}
+function isRedisClientUsable() {
+    return instance$1.has() || instance$1.hasFactory();
+}
+function setRedisClient(input) {
+    instance$1.set(input);
+}
+function useRedisClient() {
+    return instance$1.use();
+}
+
+const instance = singa.singa({
+    name: 'vault'
+});
+function setVaultFactory(factory) {
+    instance.setFactory(factory);
+}
+function isVaultClientUsable() {
+    return instance.has() || instance.hasFactory();
+}
+function useVaultClient() {
+    return instance.use();
+}
+
 function transformDomainEventData(input) {
-    if (core.isObject(input)) {
+    if (kit.isObject(input)) {
         const keys = Object.keys(input);
         for(let i = 0; i < keys.length; i++){
             const value = input[keys[i]];
@@ -422,255 +657,81 @@ function buildDomainEventChannelName(input, id) {
     return input(id);
 }
 
-async function publishDomainRedisEvent(context, destinations) {
-    if (!redisExtension.hasClient() && !redisExtension.hasConfig()) {
-        return Promise.resolve();
-    }
-    context = transformDomainEventData(context);
-    const json = JSON.stringify(context);
-    const client = redisExtension.useClient();
-    const pipeline = client.pipeline();
-    for(let i = 0; i < destinations.length; i++){
-        const { namespace } = destinations[i];
-        const keyPrefix = namespace ? `${namespace}:` : '';
-        let key = keyPrefix + buildDomainEventChannelName(destinations[i].channel);
-        pipeline.publish(key, json);
-        if (context.event !== core.DomainEventName.CREATED && typeof destinations[i].channel === 'function') {
-            key = keyPrefix + buildDomainEventChannelName(destinations[i].channel, context.data.id);
-            pipeline.publish(key, json);
+class DomainEventRedisPublisher {
+    async publish(ctx) {
+        const data = JSON.stringify(transformDomainEventData(ctx.content));
+        const pipeline = this.driver.pipeline();
+        for(let i = 0; i < ctx.destinations.length; i++){
+            const { namespace } = ctx.destinations[i];
+            const keyPrefix = namespace ? `${namespace}:` : '';
+            let key = keyPrefix + buildDomainEventChannelName(ctx.destinations[i].channel);
+            pipeline.publish(key, data);
+            if (typeof ctx.destinations[i].channel === 'function') {
+                key = keyPrefix + buildDomainEventChannelName(ctx.destinations[i].channel, ctx.content.data.id);
+                pipeline.publish(key, data);
+            }
         }
+        await pipeline.exec();
     }
-    return pipeline.exec();
-}
-
-let instance$3;
-function useSocketEmitter() {
-    if (typeof instance$3 !== 'undefined') {
-        return instance$3;
+    constructor(client){
+        this.driver = client;
     }
-    instance$3 = new redisEmitter.Emitter(redisExtension.useClient());
-    return instance$3;
 }
 
-function publishDomainSocketEvent(context, destinations) {
-    if (!redisExtension.hasClient() && !redisExtension.hasConfig()) {
-        return;
-    }
-    context = transformDomainEventData(context);
-    for(let i = 0; i < destinations.length; i++){
-        let emitter = useSocketEmitter();
-        if (destinations[i].namespace) {
-            emitter = emitter.of(destinations[i].namespace);
-        }
-        let roomName = buildDomainEventChannelName(destinations[i].channel);
-        const fullEventName = core.buildDomainEventFullName(context.type, context.event);
-        emitter.in(roomName)// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        .emit(fullEventName, {
-            ...context,
-            meta: {
-                roomName
+class DomainEventSocketPublisher {
+    async publish(ctx) {
+        ctx.content = transformDomainEventData(ctx.content);
+        for(let i = 0; i < ctx.destinations.length; i++){
+            let emitter;
+            if (ctx.destinations[i].namespace) {
+                emitter = this.driver.of(ctx.destinations[i].namespace);
+            } else {
+                emitter = this.driver;
             }
-        });
-        if (context.event !== core.DomainEventName.CREATED && typeof destinations[i].channel === 'function') {
-            roomName = buildDomainEventChannelName(destinations[i].channel, context.data.id);
-            emitter.in(roomName)// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            .emit(fullEventName, {
-                ...context,
+            let roomName = buildDomainEventChannelName(ctx.destinations[i].channel);
+            const fullEventName = kit.buildEventFullName(ctx.content.type, ctx.content.event);
+            emitter.in(roomName).emit(fullEventName, {
+                ...ctx.content,
                 meta: {
-                    roomName,
-                    roomId: context.data.id
+                    roomName
                 }
             });
+            if (typeof ctx.destinations[i].channel === 'function') {
+                roomName = buildDomainEventChannelName(ctx.destinations[i].channel, ctx.content.data.id);
+                emitter.in(roomName).emit(fullEventName, {
+                    ...ctx.content,
+                    meta: {
+                        roomName,
+                        roomId: ctx.content.data.id
+                    }
+                });
+            }
         }
     }
-}
-
-async function publishDomainEvent(context, destinations) {
-    await publishDomainRedisEvent(context, destinations);
-    publishDomainSocketEvent(context, destinations);
-}
-
-/*
- * Copyright (c) 2022.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ class VoidLogger {
-    error() {
-        return this;
-    }
-    warn() {
-        return this;
-    }
-    info() {
-        return this;
-    }
-    http() {
-        return this;
-    }
-    verbose() {
-        return this;
-    }
-    debug() {
-        return this;
+    constructor(client){
+        this.driver = new redisEmitter.Emitter(client);
     }
 }
 
-let instance$2;
-function useLogger() {
-    if (typeof instance$2 !== 'undefined') {
-        return instance$2;
-    }
-    instance$2 = new VoidLogger();
-    return instance$2;
-}
-function setLogger(logger) {
-    instance$2 = logger;
-}
-
-class ProxyClient {
-    /**
-     * Create a http agent for an url.
-     *
-     * @param input
-     */ async createAgent(input) {
-        return new Promise((resolve, reject)=>{
-            const headers = {};
-            if (this.options.user && this.options.password) {
-                headers['Proxy-Authorization'] = `Basic ${Buffer.from(`${this.options.user}:${this.options.password}`).toString('base64')}`;
+class DomainEventPublisher {
+    async publish(ctx) {
+        const publishers = this.publishers.values();
+        while(true){
+            const it = publishers.next();
+            if (it.done) {
+                return;
             }
-            const urlParsed = new URL(input);
-            const request = http.request({
-                host: this.options.host,
-                port: this.options.port,
-                method: 'CONNECT',
-                path: `${urlParsed.hostname}:443`,
-                headers
-            });
-            request.on('connect', (res, socket)=>{
-                if (res.statusCode >= 200 && res.statusCode < 300) {
-                    resolve(new https.Agent({
-                        socket,
-                        ...this.agentOptions
-                    }));
-                } else {
-                    reject(new Error('Could not connect to proxy!'));
-                }
-            });
-            request.on('error', (err)=>{
-                reject(err);
-            });
-            request.on('timeout', (err)=>{
-                reject(err);
-            });
-            request.end();
-        });
-    }
-    constructor(options, agentOptions){
-        this.options = options;
-        this.agentOptions = smob.merge(agentOptions || {}, {
-            keepAlive: false
-        });
-    }
-}
-
-async function buildHTTPClientConfigForProxy(url) {
-    const connectionString = proxyFromEnv.getProxyForUrl(url);
-    if (connectionString) {
-        const connectionDetails = core.parseProxyConnectionString(connectionString);
-        const proxyClient = new ProxyClient({
-            host: connectionDetails.host,
-            port: connectionDetails.port || 3128,
-            ...connectionDetails.auth.username ? {
-                user: connectionDetails.auth.username
-            } : {},
-            ...connectionDetails.auth.password ? {
-                password: connectionDetails.auth.password
-            } : {}
-        });
-        const agent = await proxyClient.createAgent(url);
-        return {
-            agent
-        };
-    }
-    return {};
-}
-
-/*
- * Copyright (c) 2022.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ let instance$1;
-function hasSmtpConfig() {
-    return !!instance$1;
-}
-function setSmtpConfig(value) {
-    instance$1 = value;
-}
-function useSmtpConfig() {
-    if (typeof instance$1 !== 'undefined') {
-        return instance$1;
-    }
-    instance$1 = {};
-    return instance$1;
-}
-
-function createSmtpClient(options) {
-    let transport;
-    options = options || {};
-    if (typeof options === 'string') {
-        transport = nodemailer.createTransport(options);
-    } else if (options.connectionString) {
-        transport = nodemailer.createTransport(options.connectionString);
-    } else {
-        let auth;
-        if (options.user && options.password) {
-            auth = {
-                type: 'login',
-                user: options.user,
-                pass: options.password
-            };
+            await it.value.publish(ctx);
         }
-        transport = nodemailer.createTransport({
-            host: options.host,
-            port: options.port,
-            auth,
-            secure: options.ssl,
-            opportunisticTLS: options.starttls,
-            tls: {
-                rejectUnauthorized: false
-            }
-        });
-    }
-    transport.on('error', (e)=>{
-        useLogger().error(e.message);
-    });
-    return transport;
-}
-
-let instance;
-async function useSMTPClient() {
-    if (typeof instance !== 'undefined') {
-        return instance;
     }
-    let options;
-    if (process.env.NODE_ENV === 'test') {
-        const testAccount = await nodemailer.createTestAccount();
-        options = {
-            host: 'smtp.ethereal.email',
-            port: 587,
-            ssl: false,
-            user: testAccount.user,
-            password: testAccount.pass
-        };
-    } else {
-        options = useSmtpConfig();
+    constructor(){
+        this.publishers = new Set();
+        if (isRedisClientUsable()) {
+            const client = useRedisClient();
+            this.publishers.add(new DomainEventRedisPublisher(client));
+            this.publishers.add(new DomainEventSocketPublisher(client));
+        }
     }
-    instance = createSmtpClient(options);
-    return instance;
 }
 
 /*
@@ -682,34 +743,76 @@ async function useSMTPClient() {
     return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
-exports.ProxyClient = ProxyClient;
-exports.VoidLogger = VoidLogger;
-exports.buildHTTPClientConfigForProxy = buildHTTPClientConfigForProxy;
+Object.defineProperty(exports, "Logger", {
+    enumerable: true,
+    get: function () { return winston.Logger; }
+});
+Object.defineProperty(exports, "RedisCache", {
+    enumerable: true,
+    get: function () { return redisExtension.Cache; }
+});
+Object.defineProperty(exports, "RedisClient", {
+    enumerable: true,
+    get: function () { return redisExtension.Client; }
+});
+Object.defineProperty(exports, "RedisClientOptions", {
+    enumerable: true,
+    get: function () { return redisExtension.ClientOptions; }
+});
+Object.defineProperty(exports, "RedisKeyPathID", {
+    enumerable: true,
+    get: function () { return redisExtension.KeyPathID; }
+});
+Object.defineProperty(exports, "buildRedisKeyPath", {
+    enumerable: true,
+    get: function () { return redisExtension.buildKeyPath; }
+});
+Object.defineProperty(exports, "createRedisClient", {
+    enumerable: true,
+    get: function () { return redisExtension.createClient; }
+});
+Object.defineProperty(exports, "VaultClient", {
+    enumerable: true,
+    get: function () { return vault.VaultClient; }
+});
+Object.defineProperty(exports, "createVaultClient", {
+    enumerable: true,
+    get: function () { return vault.createClient; }
+});
+exports.DomainEventPublisher = DomainEventPublisher;
+exports.DomainEventRedisPublisher = DomainEventRedisPublisher;
+exports.DomainEventSocketPublisher = DomainEventSocketPublisher;
 exports.buildKeyFileName = buildKeyFileName;
 exports.compare = compare;
 exports.createKeyPair = createKeyPair;
-exports.createSmtpClient = createSmtpClient;
-exports.decodeToken = decodeToken;
+exports.createLogger = createLogger;
 exports.decryptRSAPrivateKey = decryptRSAPrivateKey;
 exports.deleteKeyPair = deleteKeyPair;
 exports.extendKeyPairOptions = extendKeyPairOptions;
+exports.extractTokenHeader = extractTokenHeader;
+exports.extractTokenPayload = extractTokenPayload;
 exports.hasOwnProperty = hasOwnProperty;
-exports.hasSmtpConfig = hasSmtpConfig;
 exports.hash = hash;
 exports.isKeyPair = isKeyPair;
 exports.isKeyPairWithPublicKey = isKeyPairWithPublicKey;
+exports.isLoggerUsable = isLoggerUsable;
+exports.isRedisClientUsable = isRedisClientUsable;
+exports.isVaultClientUsable = isVaultClientUsable;
 exports.loadKeyPair = loadKeyPair;
-exports.publishDomainEvent = publishDomainEvent;
-exports.publishDomainRedisEvent = publishDomainRedisEvent;
-exports.publishDomainSocketEvent = publishDomainSocketEvent;
 exports.saveKeyPair = saveKeyPair;
 exports.setLogger = setLogger;
-exports.setSmtpConfig = setSmtpConfig;
+exports.setLoggerFactory = setLoggerFactory;
+exports.setRedisClient = setRedisClient;
+exports.setRedisFactory = setRedisFactory;
+exports.setVaultFactory = setVaultFactory;
 exports.signToken = signToken;
+exports.unwrapPrivateKeyPem = unwrapPrivateKeyPem;
+exports.unwrapPublicKeyPem = unwrapPublicKeyPem;
 exports.useKeyPair = useKeyPair;
 exports.useLogger = useLogger;
-exports.useSMTPClient = useSMTPClient;
-exports.useSmtpConfig = useSmtpConfig;
-exports.useSocketEmitter = useSocketEmitter;
+exports.useRedisClient = useRedisClient;
+exports.useVaultClient = useVaultClient;
 exports.verifyToken = verifyToken;
+exports.wrapPrivateKeyPem = wrapPrivateKeyPem;
+exports.wrapPublicKeyPem = wrapPublicKeyPem;
 //# sourceMappingURL=index.cjs.map