@melchyore/adonis-cache/build/src/Stores/InMemory.js

Cache package for AdonisJS V5

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const BaseStore_1 = __importDefault(require("./BaseStore"));
const luxon_1 = require("luxon");
class InMemory extends BaseStore_1.default {
    constructor(store = new Map()) {
        super();
        this.store = store;
    }
    async get(key) {
        const record = this.store.get(this.buildKey(key));
        if (record) {
            if (this.isStaleRecord(record)) {
                await this.forget(key);
                return null;
            }
            return this.deserialize(record.value);
        }
        return null;
    }
    async many(keys) {
        const records = {};
        const values = await Promise.all(keys.map((key) => this.get(key)));
        for (let i = 0; i < values.length; ++i) {
            const value = values[i];
            records[keys[i]] = value ? value : null;
        }
        return records;
    }
    async has(key) {
        return (await this.get(key)) && this.store.has(this.buildKey(key));
    }
    async put(key, value, ttl) {
        return this.set(key, value, luxon_1.DateTime.local().toMillis() + ttl);
    }
    async putMany(list, ttl) {
        const promiseArray = [];
        for (const [key, value] of Object.entries(list)) {
            promiseArray.push(this.put(key, value, ttl));
        }
        return Promise.all(promiseArray);
    }
    async increment(key, value) {
        return await this.incrementOrDecrement(key, (currentValue) => {
            return currentValue + value;
        });
    }
    async decrement(key, value) {
        return this.incrementOrDecrement(key, (currentValue) => {
            return currentValue - value;
        });
    }
    async forever(key, value) {
        return this.set(key, value, 0);
    }
    async putManyForever(list) {
        const promiseArray = [];
        for (const [key, value] of Object.entries(list)) {
            promiseArray.push(this.forever(key, value));
        }
        return Promise.all(promiseArray);
    }
    async forget(_key) {
        const key = this.buildKey(_key);
        if (this.store.has(key)) {
            this.store.delete(key);
            return true;
        }
        return false;
    }
    async flush() {
        this.store.clear();
        return true;
    }
    async incrementOrDecrement(_key, callback) {
        if (await this.get(_key)) {
            const key = this.buildKey(_key);
            const record = this.store.get(key);
            if (record) {
                const currentValue = parseInt(this.deserialize(record.value));
                if (isNaN(currentValue)) {
                    return false;
                }
                const newValue = callback(currentValue);
                record.value = this.serialize(newValue);
                this.store.set(key, record);
                return newValue;
            }
        }
        return false;
    }
    set(key, value, ttl) {
        this.store.set(this.buildKey(key), {
            expiration: ttl,
            value: this.serialize(value)
        });
        return true;
    }
}
exports.default = InMemory;