@lakutata/cache 3.0.0-beta.0

package/dist/esm/cache/stores/FileStore.js

@@ -0,0 +1,136 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { SerializedCacheStore } from './SerializedCacheStore.js';
+import { deserialize, serialize } from '../lib/Serializer.js';
+/**
+ * The file store, the entries are kept in memory and written to the file in batches
+ * File format: {"cache":[[key,{"expire":ms,"value":serialized entry}]],"lastExpire":ms}
+ */
+export class FileStore extends SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.records = new Map();
+        this.lastExpire = Date.now();
+        this.saving = Promise.resolve();
+        this.filename = path.resolve(options.filename);
+        this.expiredCheckDelay = options.expiredCheckDelay ?? 3600000;
+        this.writeDelay = options.writeDelay ?? 100;
+    }
+    /**
+     * Whether a record has expired
+     * @param record
+     * @protected
+     */
+    isExpired(record) {
+        return typeof record.expire === 'number' && record.expire <= Date.now();
+    }
+    /**
+     * Remove the expired records, at most once in each expiredCheckDelay
+     * @protected
+     */
+    removeExpired() {
+        const now = Date.now();
+        if (now - this.lastExpire <= this.expiredCheckDelay)
+            return;
+        this.lastExpire = now;
+        for (const [key, record] of this.records)
+            if (this.isExpired(record))
+                this.records.delete(key);
+    }
+    /**
+     * Save the records after the write delay
+     * @protected
+     */
+    scheduleSave() {
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = undefined;
+            this.saving = this.saving.then(() => this.save()).catch((error) => this.onError(error));
+        }, this.writeDelay);
+    }
+    /**
+     * Write the records to the file, through a temporary file
+     * @protected
+     */
+    async save() {
+        this.removeExpired();
+        const content = serialize({ cache: [...this.records], lastExpire: this.lastExpire });
+        const temporary = `${this.filename}.${process.pid}.tmp`;
+        await mkdir(path.dirname(this.filename), { recursive: true });
+        await writeFile(temporary, content);
+        await rename(temporary, this.filename);
+    }
+    async connect() {
+        let text;
+        try {
+            text = await readFile(this.filename, 'utf8');
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return;
+            throw e;
+        }
+        const content = deserialize(text);
+        this.records = new Map(Array.isArray(content.cache) ? content.cache : Object.entries(content.cache));
+        if (typeof content.lastExpire === 'number')
+            this.lastExpire = content.lastExpire;
+    }
+    async disconnect() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = undefined;
+            this.saving = this.saving.then(() => this.save());
+        }
+        await this.saving;
+    }
+    async read(key) {
+        const record = this.records.get(key);
+        if (record === undefined)
+            return undefined;
+        if (this.isExpired(record)) {
+            await this.remove(key);
+            return undefined;
+        }
+        return record.value;
+    }
+    async readMany(keys) {
+        return Promise.all(keys.map((key) => this.read(key)));
+    }
+    async write(entry) {
+        this.records.set(entry.key, { expire: entry.expires, value: entry.data });
+        this.scheduleSave();
+    }
+    async writeMany(entries) {
+        for (const entry of entries)
+            this.records.set(entry.key, { expire: entry.expires, value: entry.data });
+        this.scheduleSave();
+    }
+    async remove(key) {
+        if (!this.records.delete(key))
+            return false;
+        this.scheduleSave();
+        return true;
+    }
+    async removeMany(keys) {
+        let removed = false;
+        for (const key of keys)
+            removed = this.records.delete(key) || removed;
+        if (removed)
+            this.scheduleSave();
+        return removed;
+    }
+    async clear() {
+        if (this.namespace) {
+            const prefix = `${this.namespace}:`;
+            for (const key of this.records.keys())
+                if (key.startsWith(prefix))
+                    this.records.delete(key);
+        }
+        else {
+            this.records.clear();
+        }
+        this.lastExpire = Date.now();
+        this.scheduleSave();
+    }
+}

package/dist/esm/cache/stores/MemcacheStore.js

@@ -0,0 +1,65 @@
+import { SerializedCacheStore } from './SerializedCacheStore.js';
+import { loadDriver } from '../lib/LoadDriver.js';
+//Larger expiration times are unix timestamps for memcached
+const MAX_RELATIVE_EXPIRATION = 60 * 60 * 24 * 30;
+/**
+ * The Memcache store
+ * Key format: "{namespace}:{namespace}:{key}", or "{key}" without namespace
+ */
+export class MemcacheStore extends SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+    }
+    storeKey(key) {
+        return this.namespace ? `${this.namespace.trim()}:${`${this.namespace}:${key}`.trim()}` : key;
+    }
+    /**
+     * The memcached expiration of an entry, the entries expire after their expiration time
+     * @param entry
+     * @protected
+     */
+    expiration(entry) {
+        if (!entry.ttl || !entry.expires)
+            return 0;
+        const seconds = Math.ceil(entry.ttl / 1000) + 1;
+        return seconds > MAX_RELATIVE_EXPIRATION ? Math.ceil(entry.expires / 1000) + 1 : seconds;
+    }
+    async connect() {
+        const driver = await loadDriver('Client', 'memjs');
+        const options = this.options;
+        this.client = driver.Client.create(`${options.host}:${options.port ?? 11211}`, {
+            username: options.username,
+            password: options.password
+        });
+    }
+    async disconnect() {
+        this.client?.close();
+    }
+    async read(key) {
+        const { value } = await this.client.get(key);
+        return value === null ? undefined : value.toString();
+    }
+    async readMany(keys) {
+        return Promise.all(keys.map((key) => this.read(key)));
+    }
+    async write(entry) {
+        await this.client.set(entry.key, entry.data, { expires: this.expiration(entry) });
+    }
+    async writeMany(entries) {
+        await Promise.all(entries.map((entry) => this.write(entry)));
+    }
+    async remove(key) {
+        return await this.client.delete(key);
+    }
+    async removeMany(keys) {
+        const removed = await Promise.all(keys.map((key) => this.remove(key)));
+        return removed.some((result) => result);
+    }
+    /**
+     * Memcached cannot list the keys, all the entries are flushed
+     */
+    async clear() {
+        await this.client.flush();
+    }
+}

package/dist/esm/cache/stores/MemoryStore.js

@@ -0,0 +1,71 @@
+import { CacheStore, expiresOf, isExpired } from './CacheStore.js';
+/**
+ * The in-memory store, the values are kept by reference
+ */
+export class MemoryStore extends CacheStore {
+    /**
+     * @param sweepInterval ms, remove the expired entries in each interval
+     */
+    constructor(sweepInterval = 60000) {
+        super();
+        this.sweepInterval = sweepInterval;
+        this.entries = new Map();
+    }
+    /**
+     * Remove the expired entries
+     * @protected
+     */
+    sweep() {
+        const now = Date.now();
+        for (const [key, entry] of this.entries)
+            if (typeof entry.expires === 'number' && now > entry.expires)
+                this.entries.delete(key);
+    }
+    async connect() {
+        this.sweeper = setInterval(() => this.sweep(), this.sweepInterval);
+        this.sweeper.unref();
+    }
+    async disconnect() {
+        clearInterval(this.sweeper);
+    }
+    /**
+     * Read an entry, the expired entries are removed
+     * @param key
+     * @protected
+     */
+    read(key) {
+        const entry = this.entries.get(key);
+        if (entry === undefined)
+            return undefined;
+        if (isExpired(entry)) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return entry;
+    }
+    async get(key) {
+        return this.read(key);
+    }
+    async getMany(keys) {
+        return keys.map((key) => this.read(key));
+    }
+    async set(key, value, ttl) {
+        this.entries.set(key, { value: value, expires: expiresOf(ttl) });
+    }
+    async setMany(entries) {
+        for (const entry of entries)
+            this.entries.set(entry.key, { value: entry.value, expires: expiresOf(entry.ttl) });
+    }
+    async delete(key) {
+        return this.entries.delete(key);
+    }
+    async deleteMany(keys) {
+        let deleted = false;
+        for (const key of keys)
+            deleted = this.entries.delete(key) || deleted;
+        return deleted;
+    }
+    async clear() {
+        this.entries.clear();
+    }
+}

package/dist/esm/cache/stores/MongoStore.js

@@ -0,0 +1,68 @@
+import { SerializedCacheStore } from './SerializedCacheStore.js';
+import { loadDriver } from '../lib/LoadDriver.js';
+/**
+ * Escape the regular expression characters
+ * @param text
+ */
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * The MongoDB store
+ * Document format: {key: "{namespace}:{key}", value: serialized entry, expiresAt: Date | null}, removed by a TTL index
+ */
+export class MongoStore extends SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+    }
+    async connect() {
+        const driver = await loadDriver('MongoClient', 'mongodb');
+        const options = this.options;
+        const auth = options.username ? `${encodeURIComponent(options.username)}:${encodeURIComponent(options.password ?? '')}@` : '';
+        this.client = new driver.MongoClient(`mongodb://${auth}${options.host}:${options.port ?? 27017}`);
+        await this.client.connect();
+        this.collection = this.client.db(options.database).collection(options.collection);
+        await this.collection.createIndex({ key: 1 }, { unique: true, background: true });
+        await this.collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0, background: true });
+    }
+    async disconnect() {
+        await this.client?.close();
+    }
+    async read(key) {
+        const document = await this.collection.findOne({ key: { $eq: key } }, { projection: { _id: 0, value: 1 } });
+        return document ? document.value : undefined;
+    }
+    async readMany(keys) {
+        const documents = await this.collection.find({ key: { $in: keys } }, { projection: { _id: 0, key: 1, value: 1 } }).toArray();
+        const values = new Map(documents.map((document) => [document.key, document.value]));
+        return keys.map((key) => values.get(key));
+    }
+    /**
+     * The upsert of an entry
+     * @param entry
+     * @protected
+     */
+    update(entry) {
+        return [{ key: { $eq: entry.key } }, { $set: { key: entry.key, value: entry.data, expiresAt: entry.expires ? new Date(entry.expires) : null } }];
+    }
+    async write(entry) {
+        const [filter, update] = this.update(entry);
+        await this.collection.updateOne(filter, update, { upsert: true });
+    }
+    async writeMany(entries) {
+        await this.collection.bulkWrite(entries.map((entry) => {
+            const [filter, update] = this.update(entry);
+            return { updateOne: { filter: filter, update: update, upsert: true } };
+        }), { ordered: false });
+    }
+    async remove(key) {
+        return (await this.collection.deleteOne({ key: { $eq: key } })).deletedCount > 0;
+    }
+    async removeMany(keys) {
+        return (await this.collection.deleteMany({ key: { $in: keys } })).deletedCount > 0;
+    }
+    async clear() {
+        await this.collection.deleteMany(this.namespace ? { key: { $regex: `^${escapeRegExp(this.namespace)}:` } } : {});
+    }
+}

package/dist/esm/cache/stores/MysqlStore.js

@@ -0,0 +1,67 @@
+import { SerializedCacheStore } from './SerializedCacheStore.js';
+import { loadDriver } from '../lib/LoadDriver.js';
+import { likePrefix } from '../lib/LikePrefix.js';
+/**
+ * The MySQL store
+ * Table format: (id VARCHAR(255) PRIMARY KEY, value TEXT), with "{namespace}:{key}" ids
+ */
+export class MysqlStore extends SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+    }
+    async connect() {
+        const driver = await loadDriver('createPool', 'mysql2');
+        const options = this.options;
+        this.pool = driver.createPool({
+            host: options.host,
+            port: options.port,
+            user: options.username,
+            password: options.password,
+            database: options.database
+        }).promise();
+        this.table = this.pool.escapeId(options.table);
+        try {
+            //The binary collation keeps the keys case sensitive, the tables of 2.x are used as they are
+            await this.pool.query(`CREATE TABLE IF NOT EXISTS ${this.table}(id VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin PRIMARY KEY, value MEDIUMTEXT)`);
+        }
+        catch (e) {
+            await this.pool.end().catch(() => undefined);
+            throw e;
+        }
+    }
+    async disconnect() {
+        await this.pool?.end();
+    }
+    async read(key) {
+        const [rows] = await this.pool.query(`SELECT value FROM ${this.table} WHERE id = ?`, [key]);
+        return rows[0]?.value;
+    }
+    async readMany(keys) {
+        const [rows] = await this.pool.query(`SELECT id, value FROM ${this.table} WHERE id IN (?)`, [keys]);
+        const values = new Map(rows.map((row) => [row.id, row.value]));
+        return keys.map((key) => values.get(key));
+    }
+    async write(entry) {
+        await this.pool.query(`INSERT INTO ${this.table} (id, value) VALUES (?, ?) ON DUPLICATE KEY UPDATE value = VALUES(value)`, [entry.key, entry.data]);
+    }
+    async writeMany(entries) {
+        await this.pool.query(`INSERT INTO ${this.table} (id, value) VALUES ? ON DUPLICATE KEY UPDATE value = VALUES(value)`, [entries.map((entry) => [entry.key, entry.data])]);
+    }
+    async remove(key) {
+        const [result] = await this.pool.query(`DELETE FROM ${this.table} WHERE id = ?`, [key]);
+        return result.affectedRows > 0;
+    }
+    async removeMany(keys) {
+        const [result] = await this.pool.query(`DELETE FROM ${this.table} WHERE id IN (?)`, [keys]);
+        return result.affectedRows > 0;
+    }
+    async clear() {
+        if (this.namespace) {
+            await this.pool.query(`DELETE FROM ${this.table} WHERE id LIKE ? ESCAPE '!'`, [likePrefix(this.namespace)]);
+        }
+        else {
+            await this.pool.query(`DELETE FROM ${this.table}`);
+        }
+    }
+}

package/dist/esm/cache/stores/PostgresStore.js

@@ -0,0 +1,81 @@
+import { SerializedCacheStore } from './SerializedCacheStore.js';
+import { loadDriver } from '../lib/LoadDriver.js';
+import { likePrefix } from '../lib/LikePrefix.js';
+/**
+ * An identifier of the SQL text, the plain names are kept unquoted as in 2.x (and so folded to lower case)
+ * @param name
+ */
+function identifier(name) {
+    return /^[A-Za-z_][A-Za-z0-9_$]*$/.test(name) ? name : `"${name.replace(/"/g, '""')}"`;
+}
+/**
+ * The PostgreSQL store
+ * Table format: (key VARCHAR(255) PRIMARY KEY, value TEXT), with "{namespace}:{key}" keys
+ */
+export class PostgresStore extends SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+    }
+    async connect() {
+        const driver = await loadDriver('Pool', 'pg');
+        const options = this.options;
+        this.pool = new driver.Pool({
+            host: options.host,
+            port: options.port,
+            user: options.username,
+            password: options.password,
+            database: options.database,
+            max: options.maxPoolSize
+        });
+        this.pool.on('error', (error) => this.onError(error));
+        const schema = identifier(options.schema ?? 'public');
+        this.table = `${schema}.${identifier(options.table)}`;
+        try {
+            if (schema !== 'public')
+                await this.pool.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+            await this.pool.query(`CREATE TABLE IF NOT EXISTS ${this.table}(key VARCHAR(255) PRIMARY KEY, value TEXT)`);
+        }
+        catch (e) {
+            //A concurrent creation of the same table
+            if (e.code !== '23505') {
+                await this.pool.end().catch(() => undefined);
+                throw e;
+            }
+        }
+    }
+    async disconnect() {
+        await this.pool?.end();
+    }
+    async read(key) {
+        const { rows } = await this.pool.query(`SELECT value FROM ${this.table} WHERE key = $1`, [key]);
+        return rows[0]?.value;
+    }
+    async readMany(keys) {
+        const { rows } = await this.pool.query(`SELECT key, value FROM ${this.table} WHERE key = ANY($1)`, [keys]);
+        const values = new Map(rows.map((row) => [row.key, row.value]));
+        return keys.map((key) => values.get(key));
+    }
+    async write(entry) {
+        await this.pool.query(`INSERT INTO ${this.table} (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = excluded.value`, [entry.key, entry.data]);
+    }
+    async writeMany(entries) {
+        //The last of the duplicate keys wins, one statement cannot update a row twice
+        const latest = new Map(entries.map((entry) => [entry.key, entry.data]));
+        await this.pool.query(`INSERT INTO ${this.table} (key, value) SELECT * FROM UNNEST($1::text[], $2::text[]) ON CONFLICT (key) DO UPDATE SET value = excluded.value`, [[...latest.keys()], [...latest.values()]]);
+    }
+    async remove(key) {
+        return !!(await this.pool.query(`DELETE FROM ${this.table} WHERE key = $1`, [key])).rowCount;
+    }
+    async removeMany(keys) {
+        return !!(await this.pool.query(`DELETE FROM ${this.table} WHERE key = ANY($1)`, [keys])).rowCount;
+    }
+    async clear() {
+        if (this.namespace) {
+            await this.pool.query(`DELETE FROM ${this.table} WHERE key LIKE $1 ESCAPE '!'`, [likePrefix(this.namespace)]);
+        }
+        else {
+            await this.pool.query(`DELETE FROM ${this.table}`);
+        }
+    }
+}

package/dist/esm/cache/stores/RedisStore.js

@@ -0,0 +1,127 @@
+import { SerializedCacheStore } from './SerializedCacheStore.js';
+import { loadDriver } from '../lib/LoadDriver.js';
+import { withTimeout } from '../lib/WithTimeout.js';
+/**
+ * Escape the glob pattern characters of a SCAN match
+ * @param text
+ */
+function escapeGlob(text) {
+    return text.replace(/[*?[\]\\]/g, '\\$&');
+}
+/**
+ * The Redis store
+ * Key format: "{namespace}{keyPrefixSeparator}{namespace}:{key}", or "{key}" without namespace
+ */
+export class RedisStore extends SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+        this.separator = options.keyPrefixSeparator ?? '::';
+        this.clearBatchSize = options.clearBatchSize || 1000;
+    }
+    storeKey(key) {
+        return this.namespace ? `${this.namespace}${this.separator}${this.namespace}:${key}` : key;
+    }
+    async connect() {
+        const driver = await loadDriver('createClient', 'redis', '@redis/client');
+        const options = this.options;
+        const throwOnConnectError = options.throwOnConnectError !== false;
+        let connected = false;
+        this.client = driver.createClient({
+            username: options.username,
+            password: options.password,
+            database: options.database,
+            //Fail the commands while disconnected, a cache miss is better than a wait
+            disableOfflineQueue: true,
+            socket: {
+                host: options.host,
+                port: options.port,
+                tls: options.tls || undefined,
+                keepAlive: options.keepAlive,
+                keepAliveInitialDelay: options.keepAlive,
+                connectTimeout: options.connectTimeout,
+                reconnectStrategy: (retries, cause) => {
+                    //The first connection fails at once when its errors are thrown
+                    if (!connected && throwOnConnectError)
+                        return cause;
+                    return options.reconnect === false ? false : Math.min(retries * 100, 3000);
+                }
+            }
+        });
+        this.client.on('error', (error) => this.onError(error));
+        this.client.on('ready', () => {
+            connected = true;
+        });
+        try {
+            await withTimeout(this.client.connect(), options.connectTimeout ?? 5000, `Redis connection timed out after ${options.connectTimeout ?? 5000}ms`);
+        }
+        catch (e) {
+            if (!throwOnConnectError)
+                return this.onError(e);
+            await this.disconnect();
+            throw e;
+        }
+    }
+    async disconnect() {
+        const client = this.client;
+        if (!client?.isOpen)
+            return;
+        //An offline client cannot quit gracefully
+        if (!client.isReady)
+            return client.destroy ? client.destroy() : void await client.disconnect().catch(() => undefined);
+        await (client.quit ? client.quit() : client.close());
+    }
+    async read(key) {
+        return (await this.client.get(key)) ?? undefined;
+    }
+    async readMany(keys) {
+        return (await this.client.mGet(keys)).map((data) => data ?? undefined);
+    }
+    async write(entry) {
+        entry.ttl ? await this.client.pSetEx(entry.key, Math.ceil(entry.ttl), entry.data) : await this.client.set(entry.key, entry.data);
+    }
+    async writeMany(entries) {
+        const multi = this.client.multi();
+        for (const entry of entries)
+            entry.ttl ? multi.pSetEx(entry.key, Math.ceil(entry.ttl), entry.data) : multi.set(entry.key, entry.data);
+        await multi.exec();
+    }
+    /**
+     * Delete keys
+     * @param keys
+     * @protected
+     */
+    async unlink(keys) {
+        return this.options.useUnlink === false ? await this.client.del(keys) : await this.client.unlink(keys);
+    }
+    async remove(key) {
+        return (await this.unlink(key)) > 0;
+    }
+    async removeMany(keys) {
+        return (await this.unlink(keys)) > 0;
+    }
+    async clear() {
+        if (!this.namespace && this.options.noNamespaceAffectsAll) {
+            await this.client.flushDb();
+            return;
+        }
+        const match = this.namespace ? `${escapeGlob(this.namespace + this.separator)}*` : '*';
+        let batch = [];
+        const deletions = [];
+        for await (const scanned of this.client.scanIterator({ MATCH: match, COUNT: this.clearBatchSize, TYPE: 'string' })) {
+            for (const key of Array.isArray(scanned) ? scanned : [scanned]) {
+                //Without namespace, the namespaced keys are kept
+                if (!this.namespace && key.includes(this.separator))
+                    continue;
+                batch.push(key);
+                if (batch.length >= this.clearBatchSize) {
+                    deletions.push(this.unlink(batch));
+                    batch = [];
+                }
+            }
+        }
+        if (batch.length)
+            deletions.push(this.unlink(batch));
+        await Promise.all(deletions);
+    }
+}

package/dist/esm/cache/stores/SerializedCacheStore.js

@@ -0,0 +1,76 @@
+import { CacheStore, expiresOf, isExpired } from './CacheStore.js';
+import { deserialize, serialize } from '../lib/Serializer.js';
+/**
+ * A store keeping the entries serialized, under namespaced keys
+ */
+export class SerializedCacheStore extends CacheStore {
+    constructor(namespace) {
+        super();
+        this.namespace = namespace || undefined;
+    }
+    /**
+     * The key of an entry in the backend
+     * @param key
+     * @protected
+     */
+    storeKey(key) {
+        return this.namespace ? `${this.namespace}:${key}` : key;
+    }
+    /**
+     * Parse an entry read from the backend, the expired entries are removed
+     * @param storeKey
+     * @param data
+     * @protected
+     */
+    parse(storeKey, data) {
+        if (data === undefined)
+            return undefined;
+        const entry = deserialize(data);
+        if (entry === null || typeof entry !== 'object')
+            return undefined;
+        if (isExpired(entry)) {
+            this.remove(storeKey).catch(() => undefined);
+            return undefined;
+        }
+        return entry;
+    }
+    /**
+     * Serialize an entry
+     * @param key
+     * @param value
+     * @param ttl
+     * @protected
+     */
+    serialize(key, value, ttl) {
+        ttl = ttl || undefined;
+        const expires = expiresOf(ttl);
+        return { key: this.storeKey(key), data: serialize({ value: value, expires: expires }), ttl: ttl, expires: expires };
+    }
+    async get(key) {
+        const storeKey = this.storeKey(key);
+        return this.parse(storeKey, await this.read(storeKey));
+    }
+    async getMany(keys) {
+        if (!keys.length)
+            return [];
+        const storeKeys = keys.map((key) => this.storeKey(key));
+        const data = await this.readMany(storeKeys);
+        return storeKeys.map((storeKey, index) => this.parse(storeKey, data[index]));
+    }
+    async set(key, value, ttl) {
+        await this.write(this.serialize(key, value, ttl));
+    }
+    async setMany(entries) {
+        if (!entries.length)
+            return;
+        await this.writeMany(entries.map((entry) => this.serialize(entry.key, entry.value, entry.ttl)));
+    }
+    async delete(key) {
+        return await this.remove(this.storeKey(key));
+    }
+    async deleteMany(keys) {
+        if (!keys.length)
+            return false;
+        return await this.removeMany(keys.map((key) => this.storeKey(key)));
+    }
+}