@authup/server-kit 1.0.0-beta.20 → 1.0.0-beta.22

package/dist/index.cjs

@@ -7,10 +7,11 @@ var path = require('node:path');
 var fs = require('node:fs');
 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 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');
 
@@ -46,11 +47,11 @@ async function hash(str, rounds = 10) {
  * Author Peter Placzek (tada5hi)
  * For the full copyright and license information,
  * view the LICENSE file that was distributed with this source code.
- */ exports.KeyPairKind = void 0;
-(function(KeyPairKind) {
+ */ var KeyPairKind = /*#__PURE__*/ function(KeyPairKind) {
     KeyPairKind["PRIVATE"] = "private";
     KeyPairKind["PUBLIC"] = "public";
-})(exports.KeyPairKind || (exports.KeyPairKind = {}));
+    return KeyPairKind;
+}({});
 
 function isKeyPair(data) {
     return kit.isObject(data) && typeof data.privateKey !== 'undefined' && typeof data.publicKey !== 'undefined';
@@ -90,7 +91,7 @@ function buildKeyFileName(type, context) {
     const options = extendKeyPairOptions(context);
     const parts = [];
     switch(type){
-        case exports.KeyPairKind.PRIVATE:
+        case KeyPairKind.PRIVATE:
             {
                 if (options.privateName) {
                     parts.push(options.privateName);
@@ -107,7 +108,7 @@ function buildKeyFileName(type, context) {
                 }
                 break;
             }
-        case exports.KeyPairKind.PUBLIC:
+        case KeyPairKind.PUBLIC:
             {
                 if (options.publicName) {
                     parts.push(options.publicName);
@@ -187,11 +188,11 @@ async function saveKeyPair(keyPair, context) {
     });
     await Promise.all([
         {
-            path: path.resolve(context.directory, buildKeyFileName(exports.KeyPairKind.PRIVATE, context)),
+            path: path.resolve(context.directory, buildKeyFileName(KeyPairKind.PRIVATE, context)),
             content: keyPair.privateKey
         },
         {
-            path: path.resolve(context.directory, buildKeyFileName(exports.KeyPairKind.PUBLIC, context)),
+            path: path.resolve(context.directory, buildKeyFileName(KeyPairKind.PUBLIC, context)),
             content: keyPair.publicKey
         }
     ].map((file)=>fs.promises.writeFile(file.path, file.content)));
@@ -234,8 +235,8 @@ async function createKeyPair(context) {
 
 async function deleteKeyPair(context) {
     const options = extendKeyPairOptions(context);
-    const privateKeyPath = path.resolve(options.directory, buildKeyFileName(exports.KeyPairKind.PRIVATE, options));
-    const publicKeyPath = path.resolve(options.directory, buildKeyFileName(exports.KeyPairKind.PUBLIC, options));
+    const privateKeyPath = path.resolve(options.directory, buildKeyFileName(KeyPairKind.PRIVATE, options));
+    const publicKeyPath = path.resolve(options.directory, buildKeyFileName(KeyPairKind.PUBLIC, options));
     try {
         await Promise.all([
             privateKeyPath,
@@ -252,7 +253,7 @@ async function deleteKeyPair(context) {
 
 async function loadKeyPair(context) {
     const options = extendKeyPairOptions(context);
-    const privateKeyPath = path.resolve(options.directory, buildKeyFileName(exports.KeyPairKind.PRIVATE, options));
+    const privateKeyPath = path.resolve(options.directory, buildKeyFileName(KeyPairKind.PRIVATE, options));
     try {
         await fs.promises.stat(privateKeyPath);
     } catch (e) {
@@ -263,7 +264,7 @@ async function loadKeyPair(context) {
     if (options.passphrase || options.privateKeyEncoding.passphrase) {
         privateKey = decryptRSAPrivateKey(options, privateKey);
     }
-    const publicKeyPath = path.resolve(options.directory, buildKeyFileName(exports.KeyPairKind.PUBLIC, options));
+    const publicKeyPath = path.resolve(options.directory, buildKeyFileName(KeyPairKind.PUBLIC, options));
     let publicKey;
     try {
         await fs.promises.stat(publicKeyPath);
@@ -559,6 +560,152 @@ async function signToken(claims, context) {
     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 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 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.
+ * 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__namespace.cwd();
@@ -595,35 +742,19 @@ function createLogger(context) {
     });
 }
 
-const instance$2 = singa.singa({
+const instance$1 = 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() {
+function isLoggerUsable() {
     return instance$1.has() || instance$1.hasFactory();
 }
-function setRedisClient(input) {
+function setLogger(input) {
     instance$1.set(input);
 }
-function useRedisClient() {
+function useLogger() {
     return instance$1.use();
 }
 
@@ -745,10 +876,6 @@ class DomainEventPublisher {
     return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
-Object.defineProperty(exports, "Logger", {
-    enumerable: true,
-    get: function () { return winston.Logger; }
-});
 Object.defineProperty(exports, "RedisClient", {
     enumerable: true,
     get: function () { return redisExtension.Client; }
@@ -781,6 +908,10 @@ 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; }
@@ -789,11 +920,17 @@ Object.defineProperty(exports, "createVaultClient", {
     enumerable: true,
     get: function () { return vault.createClient; }
 });
+exports.Cache = Cache;
 exports.DomainEventPublisher = DomainEventPublisher;
 exports.DomainEventRedisPublisher = DomainEventRedisPublisher;
 exports.DomainEventSocketPublisher = DomainEventSocketPublisher;
+exports.KeyPairKind = KeyPairKind;
+exports.MemoryCacheAdapter = MemoryCacheAdapter;
+exports.RedisCacheAdapter = RedisCacheAdapter;
+exports.buildCacheKey = buildCacheKey;
 exports.buildKeyFileName = buildKeyFileName;
 exports.compare = compare;
+exports.createCacheAdapter = createCacheAdapter;
 exports.createKeyPair = createKeyPair;
 exports.createLogger = createLogger;
 exports.decryptRSAPrivateKey = decryptRSAPrivateKey;
@@ -818,6 +955,7 @@ exports.setVaultFactory = setVaultFactory;
 exports.signToken = signToken;
 exports.unwrapPrivateKeyPem = unwrapPrivateKeyPem;
 exports.unwrapPublicKeyPem = unwrapPublicKeyPem;
+exports.useCache = useCache;
 exports.useKeyPair = useKeyPair;
 exports.useLogger = useLogger;
 exports.useRedisClient = useRedisClient;