@lakutata/cache 3.0.0-beta.0

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStore = void 0;
+const SerializedCacheStore_js_1 = require("./SerializedCacheStore.js");
+const LoadDriver_js_1 = require("../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
+ */
+class MongoStore extends SerializedCacheStore_js_1.SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+    }
+    async connect() {
+        const driver = await (0, LoadDriver_js_1.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)}:` } } : {});
+    }
+}
+exports.MongoStore = MongoStore;

package/dist/cjs/cache/stores/MysqlStore.d.ts

@@ -0,0 +1,27 @@
+import { SerializedCacheStore, SerializedEntry } from './SerializedCacheStore.js';
+import { MysqlCacheOptions } from '../options/MysqlCacheOptions.js';
+interface MysqlPool {
+    query(sql: string, values?: unknown[]): Promise<[any, unknown]>;
+    escapeId(identifier: string): string;
+    end(): Promise<void>;
+}
+/**
+ * The MySQL store
+ * Table format: (id VARCHAR(255) PRIMARY KEY, value TEXT), with "{namespace}:{key}" ids
+ */
+export declare class MysqlStore extends SerializedCacheStore {
+    protected readonly options: MysqlCacheOptions;
+    protected pool: MysqlPool;
+    protected table: string;
+    constructor(options: MysqlCacheOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    protected read(key: string): Promise<string | undefined>;
+    protected readMany(keys: string[]): Promise<(string | undefined)[]>;
+    protected write(entry: SerializedEntry): Promise<void>;
+    protected writeMany(entries: SerializedEntry[]): Promise<void>;
+    protected remove(key: string): Promise<boolean>;
+    protected removeMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlStore = void 0;
+const SerializedCacheStore_js_1 = require("./SerializedCacheStore.js");
+const LoadDriver_js_1 = require("../lib/LoadDriver.js");
+const LikePrefix_js_1 = require("../lib/LikePrefix.js");
+/**
+ * The MySQL store
+ * Table format: (id VARCHAR(255) PRIMARY KEY, value TEXT), with "{namespace}:{key}" ids
+ */
+class MysqlStore extends SerializedCacheStore_js_1.SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+    }
+    async connect() {
+        const driver = await (0, LoadDriver_js_1.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 '!'`, [(0, LikePrefix_js_1.likePrefix)(this.namespace)]);
+        }
+        else {
+            await this.pool.query(`DELETE FROM ${this.table}`);
+        }
+    }
+}
+exports.MysqlStore = MysqlStore;

package/dist/cjs/cache/stores/PostgresStore.d.ts

@@ -0,0 +1,30 @@
+import { SerializedCacheStore, SerializedEntry } from './SerializedCacheStore.js';
+import { PostgresCacheOptions } from '../options/PostgresCacheOptions.js';
+interface PostgresPool {
+    query(sql: string, values?: unknown[]): Promise<{
+        rows: any[];
+        rowCount: number | null;
+    }>;
+    on(event: string, listener: (...args: any[]) => void): unknown;
+    end(): Promise<void>;
+}
+/**
+ * The PostgreSQL store
+ * Table format: (key VARCHAR(255) PRIMARY KEY, value TEXT), with "{namespace}:{key}" keys
+ */
+export declare class PostgresStore extends SerializedCacheStore {
+    protected readonly options: PostgresCacheOptions;
+    protected pool: PostgresPool;
+    protected table: string;
+    constructor(options: PostgresCacheOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    protected read(key: string): Promise<string | undefined>;
+    protected readMany(keys: string[]): Promise<(string | undefined)[]>;
+    protected write(entry: SerializedEntry): Promise<void>;
+    protected writeMany(entries: SerializedEntry[]): Promise<void>;
+    protected remove(key: string): Promise<boolean>;
+    protected removeMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresStore = void 0;
+const SerializedCacheStore_js_1 = require("./SerializedCacheStore.js");
+const LoadDriver_js_1 = require("../lib/LoadDriver.js");
+const LikePrefix_js_1 = require("../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
+ */
+class PostgresStore extends SerializedCacheStore_js_1.SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+    }
+    async connect() {
+        const driver = await (0, LoadDriver_js_1.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 '!'`, [(0, LikePrefix_js_1.likePrefix)(this.namespace)]);
+        }
+        else {
+            await this.pool.query(`DELETE FROM ${this.table}`);
+        }
+    }
+}
+exports.PostgresStore = PostgresStore;

package/dist/cjs/cache/stores/RedisStore.d.ts

@@ -0,0 +1,58 @@
+import { SerializedCacheStore, SerializedEntry } from './SerializedCacheStore.js';
+import { RedisCacheOptions } from '../options/RedisCacheOptions.js';
+interface RedisCommands<R> {
+    set(key: string, value: string): R;
+    pSetEx(key: string, milliseconds: number, value: string): R;
+}
+interface RedisMulti extends RedisCommands<RedisMulti> {
+    exec(): Promise<unknown[]>;
+}
+interface RedisClient extends RedisCommands<Promise<unknown>> {
+    isOpen: boolean;
+    isReady: boolean;
+    on(event: string, listener: (...args: any[]) => void): unknown;
+    connect(): Promise<unknown>;
+    disconnect(): Promise<unknown>;
+    quit?(): Promise<unknown>;
+    close?(): Promise<unknown>;
+    destroy?(): void;
+    get(key: string): Promise<string | null>;
+    mGet(keys: string[]): Promise<(string | null)[]>;
+    del(keys: string | string[]): Promise<number>;
+    unlink(keys: string | string[]): Promise<number>;
+    flushDb(): Promise<unknown>;
+    multi(): RedisMulti;
+    scanIterator(options: {
+        MATCH?: string;
+        COUNT?: number;
+        TYPE?: string;
+    }): AsyncIterable<string | string[]>;
+}
+/**
+ * The Redis store
+ * Key format: "{namespace}{keyPrefixSeparator}{namespace}:{key}", or "{key}" without namespace
+ */
+export declare class RedisStore extends SerializedCacheStore {
+    protected readonly options: RedisCacheOptions;
+    protected readonly separator: string;
+    protected readonly clearBatchSize: number;
+    protected client: RedisClient;
+    constructor(options: RedisCacheOptions);
+    protected storeKey(key: string): string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    protected read(key: string): Promise<string | undefined>;
+    protected readMany(keys: string[]): Promise<(string | undefined)[]>;
+    protected write(entry: SerializedEntry): Promise<void>;
+    protected writeMany(entries: SerializedEntry[]): Promise<void>;
+    /**
+     * Delete keys
+     * @param keys
+     * @protected
+     */
+    protected unlink(keys: string | string[]): Promise<number>;
+    protected remove(key: string): Promise<boolean>;
+    protected removeMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStore = void 0;
+const SerializedCacheStore_js_1 = require("./SerializedCacheStore.js");
+const LoadDriver_js_1 = require("../lib/LoadDriver.js");
+const WithTimeout_js_1 = require("../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
+ */
+class RedisStore extends SerializedCacheStore_js_1.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 (0, LoadDriver_js_1.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 (0, WithTimeout_js_1.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);
+    }
+}
+exports.RedisStore = RedisStore;

package/dist/cjs/cache/stores/SerializedCacheStore.d.ts

@@ -0,0 +1,48 @@
+import { CacheStore, CacheStoreSetEntry } from './CacheStore.js';
+import { CacheEntry } from '../lib/Serializer.js';
+export type SerializedEntry = {
+    key: string;
+    data: string;
+    ttl?: number;
+    expires?: number;
+};
+/**
+ * A store keeping the entries serialized, under namespaced keys
+ */
+export declare abstract class SerializedCacheStore extends CacheStore {
+    protected readonly namespace?: string;
+    protected constructor(namespace?: string);
+    /**
+     * The key of an entry in the backend
+     * @param key
+     * @protected
+     */
+    protected storeKey(key: string): string;
+    protected abstract read(key: string): Promise<string | undefined>;
+    protected abstract readMany(keys: string[]): Promise<(string | undefined)[]>;
+    protected abstract write(entry: SerializedEntry): Promise<void>;
+    protected abstract writeMany(entries: SerializedEntry[]): Promise<void>;
+    protected abstract remove(key: string): Promise<boolean>;
+    protected abstract removeMany(keys: string[]): Promise<boolean>;
+    /**
+     * Parse an entry read from the backend, the expired entries are removed
+     * @param storeKey
+     * @param data
+     * @protected
+     */
+    protected parse(storeKey: string, data: string | undefined): CacheEntry | undefined;
+    /**
+     * Serialize an entry
+     * @param key
+     * @param value
+     * @param ttl
+     * @protected
+     */
+    protected serialize(key: string, value: unknown, ttl?: number): SerializedEntry;
+    get(key: string): Promise<CacheEntry | undefined>;
+    getMany(keys: string[]): Promise<(CacheEntry | undefined)[]>;
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    setMany(entries: CacheStoreSetEntry[]): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<boolean>;
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedCacheStore = void 0;
+const CacheStore_js_1 = require("./CacheStore.js");
+const Serializer_js_1 = require("../lib/Serializer.js");
+/**
+ * A store keeping the entries serialized, under namespaced keys
+ */
+class SerializedCacheStore extends CacheStore_js_1.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 = (0, Serializer_js_1.deserialize)(data);
+        if (entry === null || typeof entry !== 'object')
+            return undefined;
+        if ((0, CacheStore_js_1.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 = (0, CacheStore_js_1.expiresOf)(ttl);
+        return { key: this.storeKey(key), data: (0, Serializer_js_1.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)));
+    }
+}
+exports.SerializedCacheStore = SerializedCacheStore;

package/dist/cjs/cache/stores/SqliteStore.d.ts

@@ -0,0 +1,44 @@
+import { SerializedCacheStore, SerializedEntry } from './SerializedCacheStore.js';
+import { SqliteCacheOptions } from '../options/SqliteCacheOptions.js';
+interface SqliteDatabase {
+    configure(option: 'busyTimeout', value: number): void;
+    all(sql: string, params: unknown[], callback: (error: Error | null, rows: any[]) => void): void;
+    run(sql: string, params: unknown[], callback: (this: {
+        changes: number;
+    }, error: Error | null) => void): void;
+    close(callback: (error: Error | null) => void): void;
+}
+/**
+ * The SQLite store
+ * Table format: (key VARCHAR(255) PRIMARY KEY, value TEXT), with "{namespace}:{key}" keys
+ */
+export declare class SqliteStore extends SerializedCacheStore {
+    protected readonly options: SqliteCacheOptions;
+    protected database: SqliteDatabase;
+    protected readonly table: string;
+    constructor(options: SqliteCacheOptions);
+    /**
+     * Query the rows
+     * @param sql
+     * @param params
+     * @protected
+     */
+    protected all(sql: string, params: unknown[]): Promise<any[]>;
+    /**
+     * Run a statement, resolve the number of changed rows
+     * @param sql
+     * @param params
+     * @protected
+     */
+    protected run(sql: string, params?: unknown[]): Promise<number>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    protected read(key: string): Promise<string | undefined>;
+    protected readMany(keys: string[]): Promise<(string | undefined)[]>;
+    protected write(entry: SerializedEntry): Promise<void>;
+    protected writeMany(entries: SerializedEntry[]): Promise<void>;
+    protected remove(key: string): Promise<boolean>;
+    protected removeMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+}
+export {};