cache-layer/providers/memcached-provider.js

An abstraction for cache providers, it exposes a common interface for diferente ways of cache

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const memcached_1 = __importDefault(require("memcached"));
const ms_1 = __importDefault(require("ms"));
class MemCachedProvider {
    constructor(options) {
        if (options.ttl) {
            const ttlNormalize = this.getTTL(options.ttl);
            this.defaultTTL = ttlNormalize;
            options.ttl = ttlNormalize;
        }
        this.client = new memcached_1.default(options.host || 'localhost', options);
    }
    async get(key) {
        const value = (await new Promise((resolve, reject) => {
            this.client.get(key, (err, info) => {
                if (err) {
                    reject(err);
                }
                resolve(info);
            });
        }));
        return value ? JSON.parse(value) : null;
    }
    async has(key) {
        const value = await this.get(key);
        return !!value;
    }
    async delete(key) {
        const deleted = await new Promise((resolve, reject) => {
            this.client.del(`${key}`, (err, info) => {
                if (err) {
                    reject(err);
                }
                resolve(info);
            });
        });
        return !!deleted;
    }
    async add(key, data, ttl) {
        const saved = await new Promise((resolve, reject) => {
            this.client.set(`${key}`, JSON.stringify(data || {}), this.getTTL(ttl) || this.defaultTTL, (err, info) => {
                if (err) {
                    reject(err);
                }
                resolve(info);
            });
        });
        return !!saved;
    }
    getTTL(ttl) {
        let seconds;
        if (typeof ttl === 'string') {
            seconds = ms_1.default(ttl) / 1000;
        }
        else {
            seconds = ttl / 1000;
        }
        return seconds <= 1 ? 1 : seconds;
    }
}
exports.default = MemCachedProvider;
//# sourceMappingURL=memcached-provider.js.map