@authup/server-kit 1.0.0-beta.27 → 1.0.0-beta.29

package/dist/index.cjs

@@ -1,1005 +0,0 @@
-'use strict';
-
-var bcrypt = require('@node-rs/bcrypt');
-var uncrypto = require('uncrypto');
-var kit = require('@authup/kit');
-var specs = require('@authup/specs');
-var jsonwebtoken = require('@node-rs/jsonwebtoken');
-var smob = require('smob');
-var redisExtension = require('redis-extension');
-var singa = require('singa');
-var TTLCache = require('@isaacs/ttlcache');
-var path = require('node:path');
-var process = require('node:process');
-var winston = require('winston');
-var vault = require('@hapic/vault');
-var coreRealtimeKit = require('@authup/core-realtime-kit');
-var redisEmitter = require('@socket.io/redis-emitter');
-
-async function compare(value, hashedValue) {
-    return bcrypt.compare(value, hashedValue);
-}
-
-async function hash(str, rounds = 10) {
-    return bcrypt.hash(str, rounds);
-}
-
-/*
- * 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.
- */ var CryptoAsymmetricAlgorithm = /*#__PURE__*/ function(CryptoAsymmetricAlgorithm) {
-    CryptoAsymmetricAlgorithm["RSA_PSS"] = "RSA-PSS";
-    CryptoAsymmetricAlgorithm["RSASSA_PKCS1_V1_5"] = "RSASSA-PKCS1-v1_5";
-    CryptoAsymmetricAlgorithm["RSA_OAEP"] = "RSA-OAEP";
-    CryptoAsymmetricAlgorithm["ECDSA"] = "ECDSA";
-    CryptoAsymmetricAlgorithm["ECDH"] = "ECDH";
-    return CryptoAsymmetricAlgorithm;
-}({});
-
-function isAsymmetricAlgorithm(input) {
-    return Object.values(CryptoAsymmetricAlgorithm).indexOf(input) !== -1;
-}
-
-/**
- * @see https://nodejs.org/api/webcrypto.html#cryptokeyusages
- */ function getKeyUsagesForAsymmetricAlgorithm(name, format) {
-    if (name === CryptoAsymmetricAlgorithm.RSA_PSS || name === CryptoAsymmetricAlgorithm.ECDSA || name === CryptoAsymmetricAlgorithm.RSASSA_PKCS1_V1_5) {
-        if (format === 'spki') {
-            return [
-                'verify'
-            ];
-        }
-        if (format === 'pkcs8') {
-            return [
-                'sign'
-            ];
-        }
-        return [
-            'sign',
-            'verify'
-        ];
-    }
-    if (name === CryptoAsymmetricAlgorithm.ECDH) {
-        if (format === 'spki') {
-            return [];
-        }
-        return [
-            'deriveKey',
-            'deriveBits'
-        ];
-    }
-    if (name === CryptoAsymmetricAlgorithm.RSA_OAEP) {
-        if (format === 'spki') {
-            return [
-                'encrypt'
-            ];
-        }
-        if (format === 'pkcs8') {
-            return [
-                'decrypt'
-            ];
-        }
-        return [
-            'encrypt',
-            'decrypt'
-        ];
-    }
-    throw new SyntaxError(`Key usages can not be determined for asymmetric algorithm: ${name}`);
-}
-
-function normalizeAsymmetricKeyPairCreateOptions(options) {
-    let optionsNormalized;
-    switch(options.name){
-        case CryptoAsymmetricAlgorithm.RSASSA_PKCS1_V1_5:
-        case CryptoAsymmetricAlgorithm.RSA_PSS:
-        case CryptoAsymmetricAlgorithm.RSA_OAEP:
-            {
-                optionsNormalized = {
-                    modulusLength: 2048,
-                    publicExponent: new Uint8Array([
-                        0x01,
-                        0x00,
-                        0x01
-                    ]),
-                    hash: 'SHA-256',
-                    ...options
-                };
-                break;
-            }
-        case CryptoAsymmetricAlgorithm.ECDSA:
-        case CryptoAsymmetricAlgorithm.ECDH:
-            {
-                optionsNormalized = {
-                    namedCurve: 'P-256',
-                    ...options
-                };
-            }
-    }
-    return optionsNormalized;
-}
-function normalizeAsymmetricKeyImportOptions(options) {
-    let optionsNormalized;
-    switch(options.name){
-        case CryptoAsymmetricAlgorithm.RSASSA_PKCS1_V1_5:
-        case CryptoAsymmetricAlgorithm.RSA_PSS:
-        case CryptoAsymmetricAlgorithm.RSA_OAEP:
-            {
-                optionsNormalized = {
-                    hash: 'SHA-256',
-                    ...options
-                };
-                break;
-            }
-        case CryptoAsymmetricAlgorithm.ECDSA:
-        case CryptoAsymmetricAlgorithm.ECDH:
-            {
-                optionsNormalized = {
-                    namedCurve: 'P-256',
-                    ...options
-                };
-            }
-    }
-    return optionsNormalized;
-}
-
-async function createAsymmetricKeyPair(options) {
-    const optionsNormalized = normalizeAsymmetricKeyPairCreateOptions(options);
-    return uncrypto.subtle.generateKey(optionsNormalized, true, getKeyUsagesForAsymmetricAlgorithm(optionsNormalized.name));
-}
-
-/*
- * 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);
-}
-
-/*
- * 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.
- */ var SymmetricAlgorithm = /*#__PURE__*/ function(SymmetricAlgorithm) {
-    SymmetricAlgorithm["HMAC"] = "HMAC";
-    SymmetricAlgorithm["AES_CTR"] = "AES-CTR";
-    SymmetricAlgorithm["AES_CBC"] = "AES-CBC";
-    SymmetricAlgorithm["AES_GCM"] = "AES-GCM";
-    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;
-}
-
-function getKeyUsagesForSymmetricAlgorithm(name) {
-    /**
-     * @see https://nodejs.org/api/webcrypto.html#cryptokeyusages
-     */ if (name === SymmetricAlgorithm.HMAC) {
-        return [
-            'sign',
-            'verify'
-        ];
-    }
-    if (name === SymmetricAlgorithm.AES_CBC || name === SymmetricAlgorithm.AES_GCM || name === SymmetricAlgorithm.AES_CTR) {
-        return [
-            'encrypt',
-            'decrypt'
-        ];
-    }
-    throw new SyntaxError(`Key usages can not be determined for symmetric algorithm: ${name}`);
-}
-
-async function createSymmetricKey(input) {
-    const optionsNormalized = normalizeSymmetricKeyCreateOptions(input);
-    return uncrypto.subtle.generateKey(optionsNormalized, true, getKeyUsagesForSymmetricAlgorithm(optionsNormalized.name));
-}
-
-function getKeyUsagesForAlgorithm(name, format) {
-    if (isAsymmetricAlgorithm(name)) {
-        return getKeyUsagesForAsymmetricAlgorithm(name, format);
-    }
-    if (isSymmetricAlgorithm(name)) {
-        return getKeyUsagesForSymmetricAlgorithm(name);
-    }
-    throw new SyntaxError(`Key usages can not be determined for algorithm: ${name}`);
-}
-
-class CryptoKeyContainer {
-    // ----------------------------------------------
-    async toArrayBuffer() {
-        if (this.key.type === 'private') {
-            return uncrypto.subtle.exportKey('pkcs8', this.key);
-        }
-        if (this.key.type === 'public') {
-            return uncrypto.subtle.exportKey('spki', this.key);
-        }
-        return uncrypto.subtle.exportKey('raw', this.key);
-    }
-    async toUint8Array() {
-        const arrayBuffer = await this.toArrayBuffer();
-        return new Uint8Array(arrayBuffer);
-    }
-    async toBase64() {
-        const arrayBuffer = await this.toArrayBuffer();
-        return kit.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 uncrypto.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)
-        });
-    }
-    static async fromBase64(ctx) {
-        const arrayBuffer = kit.base64ToArrayBuffer(ctx.key);
-        return CryptoKeyContainer.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 cryptoKey = await uncrypto.subtle.importKey(ctx.format, ctx.key, normalizedOptions, true, getKeyUsagesForAlgorithm(normalizedOptions.name, ctx.format));
-        return new CryptoKeyContainer(cryptoKey);
-    }
-    constructor(cryptoKey){
-        this.key = cryptoKey;
-    }
-}
-
-/**
- * Decode a JWT token with no verification.
- *
- * @param token
- *
- * @throws JWTError
- */ function extractTokenHeader(token) {
-    const parts = token.split('.');
-    if (parts.length !== 3) {
-        throw specs.JWTError.invalid();
-    }
-    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 specs.JWTError.headerInvalid('The token header could not be extracted.');
-    }
-}
-/**
- * @param token
- *
- * @throws JWTError
- */ function extractTokenPayload(token) {
-    const parts = token.split('.');
-    if (parts.length !== 3) {
-        throw specs.JWTError.invalid();
-    }
-    const [, payloadBase64] = parts;
-    try {
-        const payload = atob(payloadBase64);
-        return JSON.parse(payload);
-    } catch (e) {
-        throw specs.JWTError.payloadInvalid('The token payload could not be extracted.');
-    }
-}
-
-function createErrorForJWTError(e) {
-    if (smob.isObject(e)) {
-        if (typeof e.name === 'string') {
-            switch(e.name){
-                case 'TokenExpiredError':
-                    {
-                        return specs.JWTError.expired();
-                    }
-                case 'NotBeforeError':
-                    {
-                        if (typeof e.date === 'string' || e.date instanceof Date) {
-                            return specs.JWTError.notActiveBefore(e.date);
-                        }
-                        break;
-                    }
-                case 'JsonWebTokenError':
-                    {
-                        if (typeof e.message === 'string') {
-                            return specs.JWTError.payloadInvalid(e.message);
-                        }
-                        break;
-                    }
-            }
-        }
-        // @see https://github.com/Keats/jsonwebtoken/blob/master/src/errors.rs
-        switch(e.message){
-            case 'ExpiredSignature':
-                {
-                    return specs.JWTError.expired();
-                }
-            case 'ImmatureSignature':
-                {
-                    return specs.JWTError.notActiveBefore();
-                }
-            case 'InvalidToken':
-            case 'InvalidSignature':
-                {
-                    return specs.JWTError.payloadInvalid();
-                }
-        }
-    }
-    return new specs.JWTError({
-        cause: e,
-        logMessage: true,
-        message: 'The JWT error could not be determined.'
-    });
-}
-function transformJWTAlgorithmToInternal(algorithm) {
-    switch(algorithm){
-        case specs.JWTAlgorithm.HS256:
-            {
-                return jsonwebtoken.Algorithm.HS256;
-            }
-        case specs.JWTAlgorithm.HS384:
-            {
-                return jsonwebtoken.Algorithm.HS384;
-            }
-        case specs.JWTAlgorithm.HS512:
-            {
-                return jsonwebtoken.Algorithm.HS512;
-            }
-        case specs.JWTAlgorithm.RS256:
-            {
-                return jsonwebtoken.Algorithm.RS256;
-            }
-        case specs.JWTAlgorithm.RS384:
-            {
-                return jsonwebtoken.Algorithm.RS384;
-            }
-        case specs.JWTAlgorithm.RS512:
-            {
-                return jsonwebtoken.Algorithm.RS512;
-            }
-        case specs.JWTAlgorithm.ES256:
-            {
-                return jsonwebtoken.Algorithm.ES256;
-            }
-        case specs.JWTAlgorithm.ES384:
-            {
-                return jsonwebtoken.Algorithm.ES384;
-            }
-        case specs.JWTAlgorithm.PS256:
-            {
-                return jsonwebtoken.Algorithm.PS256;
-            }
-        case specs.JWTAlgorithm.PS384:
-            {
-                return jsonwebtoken.Algorithm.PS384;
-            }
-        case specs.JWTAlgorithm.PS512:
-            {
-                return jsonwebtoken.Algorithm.PS512;
-            }
-    }
-    throw new Error(`The algorithm ${algorithm} is not supported.`);
-}
-
-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 specs.JWKType.RSA:
-        case specs.JWKType.EC:
-            {
-                let algorithm;
-                let key;
-                if (typeof context.key === 'string') {
-                    key = encodePKCS8ToPEM(context.key);
-                } else {
-                    const keyContainer = new CryptoKeyContainer(context.key);
-                    key = await keyContainer.toPem();
-                }
-                if (context.type === specs.JWKType.RSA) {
-                    algorithm = context.algorithm ? transformJWTAlgorithmToInternal(context.algorithm) : jsonwebtoken.Algorithm.RS256;
-                } else {
-                    algorithm = context.algorithm ? transformJWTAlgorithmToInternal(context.algorithm) : jsonwebtoken.Algorithm.ES256;
-                }
-                return jsonwebtoken.sign(claims, key, {
-                    algorithm,
-                    keyId: context.keyId
-                });
-            }
-        case specs.JWKType.OCT:
-            {
-                const algorithm = context.algorithm ? transformJWTAlgorithmToInternal(context.algorithm) : jsonwebtoken.Algorithm.HS256;
-                let key;
-                if (typeof context.key === 'string') {
-                    key = context.key;
-                } else {
-                    const keyContainer = new CryptoKeyContainer(context.key);
-                    key = await keyContainer.toUint8Array();
-                }
-                return jsonwebtoken.sign(claims, key, {
-                    algorithm,
-                    keyId: context.keyId
-                });
-            }
-    }
-    throw new specs.OAuth2Error();
-}
-
-/**
- * Verify JWT.
- *
- * @param token
- * @param context
- *
- * @throws OAuth2Error
- */ async function verifyToken(token, context) {
-    let promise;
-    let output;
-    try {
-        switch(context.type){
-            case specs.JWKType.RSA:
-            case specs.JWKType.EC:
-                {
-                    let algorithms;
-                    if (context.type === specs.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 {
-                        algorithms = context.algorithms ? context.algorithms.map((algorithm)=>transformJWTAlgorithmToInternal(algorithm)) : [
-                            jsonwebtoken.Algorithm.ES256,
-                            jsonwebtoken.Algorithm.ES384
-                        ];
-                    }
-                    let key;
-                    if (typeof context.key === 'string') {
-                        key = encodeSPKIToPem(context.key);
-                    } else {
-                        const keyContainer = new CryptoKeyContainer(context.key);
-                        key = await keyContainer.toPem();
-                    }
-                    promise = jsonwebtoken.verify(token, key, {
-                        algorithms,
-                        validateNbf: true
-                    });
-                    break;
-                }
-            case specs.JWKType.OCT:
-                {
-                    const algorithms = context.algorithms ? context.algorithms.map((algorithm)=>transformJWTAlgorithmToInternal(algorithm)) : [
-                        jsonwebtoken.Algorithm.HS256,
-                        jsonwebtoken.Algorithm.HS384,
-                        jsonwebtoken.Algorithm.HS512
-                    ];
-                    let key;
-                    if (typeof context.key === 'string') {
-                        key = context.key;
-                    } else {
-                        const keyContainer = new CryptoKeyContainer(context.key);
-                        key = await keyContainer.toUint8Array();
-                    }
-                    promise = jsonwebtoken.verify(token, key, {
-                        algorithms,
-                        validateNbf: true
-                    });
-                }
-        }
-        output = await promise;
-    } catch (e) {
-        throw createErrorForJWTError(e);
-    }
-    if (typeof output === 'undefined') {
-        throw new specs.OAuth2Error({
-            message: 'Invalid type.'
-        });
-    }
-    return output;
-}
-
-const instance$3 = singa.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();
-}
-
-class MemoryCacheAdapter {
-    async has(key) {
-        return this.instance.has(key);
-    }
-    async get(key) {
-        return this.instance.get(key);
-    }
-    async set(key, value, options) {
-        this.instance.set(key, value, {
-            ttl: options.ttl
-        });
-    }
-    async drop(key) {
-        this.instance.delete(key);
-    }
-    async dropMany(keys) {
-        for(let i = 0; i < keys.length; i++){
-            this.instance.delete(keys[i]);
-        }
-    }
-    async clear(options = {}) {
-        if (options.prefix) {
-            const keys = this.instance.keys();
-            let iterator = keys.next();
-            while(!iterator.done){
-                if (iterator.value.startsWith(options.prefix)) {
-                    this.instance.delete(iterator.value);
-                }
-                iterator = keys.next();
-            }
-            return;
-        }
-        this.instance.clear();
-    }
-    constructor(options = {}){
-        this.instance = new TTLCache({
-            checkAgeOnGet: true,
-            ttl: Infinity,
-            ...options || {}
-        });
-    }
-}
-
-class RedisCacheAdapter {
-    async get(key) {
-        return this.instance.get(key);
-    }
-    async has(key) {
-        const output = await this.get(key);
-        return typeof output !== 'undefined';
-    }
-    async set(key, value, options) {
-        await this.instance.set(key, value, {
-            milliseconds: options.ttl
-        });
-    }
-    async drop(key) {
-        await this.instance.drop(key);
-    }
-    async dropMany(keys) {
-        const pipeline = this.client.pipeline();
-        for(let i = 0; i < keys.length; i++){
-            pipeline.del(keys[i]);
-        }
-        await pipeline.exec();
-    }
-    async clear(options = {}) {
-        if (options.prefix) {
-            const pipeline = this.client.pipeline();
-            const keys = await this.client.keys(`${options.prefix}*`);
-            for(let i = 0; i < keys.length; i++){
-                pipeline.del(keys[i]);
-            }
-            await pipeline.exec();
-            return;
-        }
-        await this.client.flushdb();
-    }
-    constructor(){
-        this.client = useRedisClient();
-        this.instance = new redisExtension.JsonAdapter(this.client);
-    }
-}
-
-function createCacheAdapter() {
-    if (isRedisClientUsable()) {
-        return new RedisCacheAdapter();
-    }
-    return new MemoryCacheAdapter();
-}
-
-function buildCacheKey(options) {
-    return redisExtension.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.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();
-    if (context.env === 'production') {
-        items = [
-            new winston.transports.Console({
-                level: 'info'
-            }),
-            new winston.transports.File({
-                filename: path.join(cwd, 'http.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'
-            })
-        ];
-    }
-    // @see https://github.com/winstonjs/triple-beam/blob/master/config/npm.js
-    return winston.createLogger({
-        format: winston.format.combine(winston.format.errors({
-            stack: true
-        }), winston.format.timestamp(), winston.format.colorize(), winston.format.simple()),
-        transports: items
-    });
-}
-
-const instance$1 = singa.singa({
-    name: 'logger'
-});
-function setLoggerFactory(factory) {
-    instance$1.setFactory(factory);
-}
-function isLoggerUsable() {
-    return instance$1.has() || instance$1.hasFactory();
-}
-function setLogger(input) {
-    instance$1.set(input);
-}
-function useLogger() {
-    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 (kit.isObject(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();
-            }
-        }
-    }
-    return input;
-}
-function buildDomainEventChannelName(input, id) {
-    if (typeof input === 'string') {
-        return input;
-    }
-    return input(id);
-}
-
-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();
-    }
-    constructor(client){
-        this.driver = client;
-    }
-}
-
-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;
-            }
-            let roomName = buildDomainEventChannelName(ctx.destinations[i].channel);
-            const fullEventName = coreRealtimeKit.buildEventFullName(ctx.content.type, ctx.content.event);
-            emitter.in(roomName).emit(fullEventName, {
-                ...ctx.content,
-                meta: {
-                    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
-                    }
-                });
-            }
-        }
-    }
-    constructor(client){
-        this.driver = new redisEmitter.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));
-        }
-    }
-}
-
-/*
- * 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, "RedisClient", {
-    enumerable: true,
-    get: function () { return redisExtension.Client; }
-});
-Object.defineProperty(exports, "RedisClientOptions", {
-    enumerable: true,
-    get: function () { return redisExtension.ClientOptions; }
-});
-Object.defineProperty(exports, "RedisJsonAdapter", {
-    enumerable: true,
-    get: function () { return redisExtension.JsonAdapter; }
-});
-Object.defineProperty(exports, "RedisWatcher", {
-    enumerable: true,
-    get: function () { return redisExtension.Watcher; }
-});
-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, "escapeRedisKey", {
-    enumerable: true,
-    get: function () { return redisExtension.escapeKey; }
-});
-Object.defineProperty(exports, "parseRedisKeyPath", {
-    enumerable: true,
-    get: function () { return redisExtension.parseKeyPath; }
-});
-Object.defineProperty(exports, "Logger", {
-    enumerable: true,
-    get: function () { return winston.Logger; }
-});
-Object.defineProperty(exports, "VaultClient", {
-    enumerable: true,
-    get: function () { return vault.VaultClient; }
-});
-Object.defineProperty(exports, "createVaultClient", {
-    enumerable: true,
-    get: function () { return vault.createClient; }
-});
-exports.Cache = Cache;
-exports.CryptoAsymmetricAlgorithm = CryptoAsymmetricAlgorithm;
-exports.CryptoKeyContainer = CryptoKeyContainer;
-exports.DomainEventPublisher = DomainEventPublisher;
-exports.DomainEventRedisPublisher = DomainEventRedisPublisher;
-exports.DomainEventSocketPublisher = DomainEventSocketPublisher;
-exports.MemoryCacheAdapter = MemoryCacheAdapter;
-exports.RedisCacheAdapter = RedisCacheAdapter;
-exports.SymmetricAlgorithm = SymmetricAlgorithm;
-exports.buildCacheKey = buildCacheKey;
-exports.compare = compare;
-exports.createAsymmetricKeyPair = createAsymmetricKeyPair;
-exports.createCacheAdapter = createCacheAdapter;
-exports.createLogger = createLogger;
-exports.createSymmetricKey = createSymmetricKey;
-exports.decodePemToPKCS8 = decodePemToPKCS8;
-exports.decodePemToSpki = decodePemToSpki;
-exports.encodePKCS8ToPEM = encodePKCS8ToPEM;
-exports.encodeSPKIToPem = encodeSPKIToPem;
-exports.extractTokenHeader = extractTokenHeader;
-exports.extractTokenPayload = extractTokenPayload;
-exports.getKeyUsagesForAlgorithm = getKeyUsagesForAlgorithm;
-exports.getKeyUsagesForAsymmetricAlgorithm = getKeyUsagesForAsymmetricAlgorithm;
-exports.getKeyUsagesForSymmetricAlgorithm = getKeyUsagesForSymmetricAlgorithm;
-exports.hasOwnProperty = hasOwnProperty;
-exports.hash = hash;
-exports.isAsymmetricAlgorithm = isAsymmetricAlgorithm;
-exports.isLoggerUsable = isLoggerUsable;
-exports.isRedisClientUsable = isRedisClientUsable;
-exports.isSymmetricAlgorithm = isSymmetricAlgorithm;
-exports.isVaultClientUsable = isVaultClientUsable;
-exports.normalizeAsymmetricKeyImportOptions = normalizeAsymmetricKeyImportOptions;
-exports.normalizeAsymmetricKeyPairCreateOptions = normalizeAsymmetricKeyPairCreateOptions;
-exports.setLogger = setLogger;
-exports.setLoggerFactory = setLoggerFactory;
-exports.setRedisClient = setRedisClient;
-exports.setRedisFactory = setRedisFactory;
-exports.setVaultFactory = setVaultFactory;
-exports.signToken = signToken;
-exports.useCache = useCache;
-exports.useLogger = useLogger;
-exports.useRedisClient = useRedisClient;
-exports.useVaultClient = useVaultClient;
-exports.verifyToken = verifyToken;
-//# sourceMappingURL=index.cjs.map