@lakutata/cache 3.0.0-beta.0

package/dist/esm/cache/Cacher.js

@@ -0,0 +1,518 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Component, DTO } from '@lakutata/core';
+import { Configurable } from '@lakutata/core/decorator/di';
+import { As } from '@lakutata/utils';
+import { FileCacheOptions } from './options/FileCacheOptions.js';
+import { MemoryCacheOptions } from './options/MemoryCacheOptions.js';
+import { RedisCacheOptions } from './options/RedisCacheOptions.js';
+import { MemcacheCacheOptions } from './options/MemcacheCacheOptions.js';
+import { MongoCacheOptions } from './options/MongoCacheOptions.js';
+import { SqliteCacheOptions } from './options/SqliteCacheOptions.js';
+import { PostgresCacheOptions } from './options/PostgresCacheOptions.js';
+import { MysqlCacheOptions } from './options/MysqlCacheOptions.js';
+import { MemoryStore } from './stores/MemoryStore.js';
+import { createCacheStore } from './stores/CreateCacheStore.js';
+/**
+ * Build the component options of a {@link Cacher}, to register it in the `components` of an application (or a module)
+ * under the name of your choice. The options are validated when the component is created, not here.
+ * @param options The cache options: its stores, its default TTL, its refresh and write behavior. Without options, one
+ * in-memory store whose entries never expire.
+ * @returns The component options (`{class: Cacher, ...options}`).
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions, type Cacher} from 'lakutata/com/cacher'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'cache.app',
+ *         name: 'Cache',
+ *         components: {
+ *             //An in-memory cache whose entries expire after one minute
+ *             cache: buildCacherOptions({ttl: 60000})
+ *         }
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const cache: Cacher = await app.getObject('cache')
+ *         await cache.set('greeting', 'Hello')
+ *         console.log(await cache.get<string>('greeting')) //Hello
+ *     })
+ * ```
+ */
+export const buildCacherOptions = (options) => ({
+    class: Cacher,
+    stores: options?.stores,
+    ttl: options?.ttl,
+    refreshThreshold: options?.refreshThreshold,
+    refreshAllStores: options?.refreshAllStores,
+    nonBlocking: options?.nonBlocking,
+    cacheId: options?.cacheId
+});
+/**
+ * Resolve with the first defined result, or undefined when none is
+ * @param promises
+ */
+function firstDefined(promises) {
+    return new Promise((resolve) => {
+        let remaining = promises.length;
+        if (!remaining)
+            return resolve(undefined);
+        for (const promise of promises) {
+            //A rejected promise gives no value
+            promise.then((value) => {
+                if (value !== undefined)
+                    return resolve(value);
+                if (!--remaining)
+                    resolve(undefined);
+            }, () => {
+                if (!--remaining)
+                    resolve(undefined);
+            });
+        }
+    });
+}
+/**
+ * The cache component: a key-value cache with expiration, backed by one or more stores (memory, file, Redis,
+ * Memcache, MongoDB, SQLite, PostgreSQL, MySQL). Register it in the `components` of an application with
+ * {@link buildCacherOptions} (or `{class: Cacher, ...options}`) and get it with `getObject()` or `@Inject`; it is a
+ * singleton. Without stores, it caches in memory.
+ *
+ * The stores connect when the component is created: when one fails to connect, the others are disconnected and the
+ * creation fails with its error (the application does not start). A store whose driver package is not installed
+ * fails with {@link CacheDriverNotFoundException}. The stores disconnect when the component is destroyed, after the
+ * background refreshes in progress and the file store's pending writes.
+ *
+ * With several stores, they are tiers, the first one the fastest: a read returns the entry of the first store holding
+ * it, a write or a deletion goes to all of them. Only {@link Cacher.wrap} copies an entry found in a lower store to
+ * the stores above it.
+ *
+ * The TTLs are in milliseconds: an entry whose TTL is `0` or unset (without the `ttl` option) never expires; an expired
+ * entry is a miss. The memory store keeps the values by reference (a cached object changed afterwards is changed in the
+ * cache); the other stores keep them as JSON: the `Buffer`s are kept, but a `Date` comes back as its ISO string, a
+ * class instance as a plain object, a `Map` or a `Set` as `{}`, and a `bigint` fails the write.
+ *
+ * A store failing to read is a miss (its error is emitted as an `'error'` event); a store failing to write or delete
+ * rejects the call, unless the `nonBlocking` option is set.
+ * @example
+ * ```typescript
+ * import {Application, Component} from 'lakutata'
+ * import {Inject} from 'lakutata/decorator/di'
+ * import {buildCacherOptions, type Cacher} from 'lakutata/com/cacher'
+ *
+ * type Product = {id: number, name: string}
+ *
+ * class Catalog extends Component {
+ *     @Inject('cache')
+ *     protected readonly cache: Cacher
+ *
+ *     public async product(id: number): Promise<Product> {
+ *         //Computed once, then read from the cache for 5 minutes (recomputed in the background in its last minute)
+ *         return this.cache.wrap(`product:${id}`, async (): Promise<Product> => ({id: id, name: `Product ${id}`}), {
+ *             ttl: 300000,
+ *             refreshThreshold: 60000
+ *         })
+ *     }
+ *
+ *     public async rename(id: number, name: string): Promise<void> {
+ *         await this.cache.set(`product:${id}`, {id: id, name: name}, 300000)
+ *     }
+ *
+ *     public async remove(id: number): Promise<void> {
+ *         await this.cache.del(`product:${id}`)
+ *     }
+ * }
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'catalog.app',
+ *         name: 'Catalog',
+ *         components: {
+ *             //A local file tier in front of Redis (the "redis" package installed)
+ *             cache: buildCacherOptions({
+ *                 stores: [
+ *                     {type: 'file', filename: './cache/catalog.json'},
+ *                     {type: 'redis', host: '127.0.0.1', namespace: 'catalog'}
+ *                 ],
+ *                 ttl: 600000
+ *             }),
+ *             catalog: {class: Catalog}
+ *         }
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const cache: Cacher = await app.getObject('cache')
+ *         cache.on('error', (error: Error): void => console.error('Cache store error', error))
+ *         const catalog: Catalog = await app.getObject('catalog')
+ *         console.log(await catalog.product(1))
+ *     })
+ * ```
+ */
+export class Cacher extends Component {
+    #stores = [];
+    #wrapping = new Map();
+    #refreshing = new Map();
+    async init() {
+        const storeConfigs = this.stores ? Array.isArray(this.stores) ? this.stores : [this.stores] : [];
+        const stores = storeConfigs
+            .map((storeOptions) => createCacheStore(storeOptions))
+            .filter((store) => !!store);
+        if (!stores.length)
+            stores.push(new MemoryStore());
+        for (const store of stores)
+            store.onError = (error) => this.report(error);
+        const connections = await Promise.allSettled(stores.map((store) => store.connect()));
+        const failure = connections.find((connection) => connection.status === 'rejected');
+        if (failure) {
+            await Promise.allSettled(stores.map((store) => store.disconnect()));
+            throw failure.reason;
+        }
+        this.#stores = stores;
+    }
+    async destroy() {
+        await Promise.allSettled(this.#refreshing.values());
+        await Promise.all(this.#stores.map((store) => store.disconnect()));
+    }
+    /**
+     * Emit a store error as an `'error'` event; dropped when the event has no listener.
+     * @param error The error.
+     * @protected
+     */
+    report(error) {
+        if (this.listenerCount('error'))
+            this.emit('error', error);
+    }
+    /**
+     * Resolve the time to live of a value.
+     * @param ttl The TTL in milliseconds, a function of the value returning it, or undefined for the cache's `ttl`
+     * option.
+     * @param value The value cached.
+     * @returns The TTL in milliseconds, undefined when the entry never expires.
+     * @protected
+     */
+    resolveTTL(ttl, value) {
+        return (typeof ttl === 'function' ? ttl(value) : ttl) ?? this.ttl;
+    }
+    /**
+     * Read an entry from one store; a failing store is a miss, its error emitted as an `'error'` event.
+     * @param store The store.
+     * @param key The key.
+     * @returns The entry, undefined when it is missing, expired or the store failed.
+     * @protected
+     */
+    async readStore(store, key) {
+        try {
+            return await store.get(key);
+        }
+        catch (e) {
+            this.report(e);
+            return undefined;
+        }
+    }
+    /**
+     * Read an entry from the first store holding it, in the stores' order; with `nonBlocking` and several stores, from
+     * the first store answering with it.
+     * @param key The key.
+     * @returns The entry and the index of its store, undefined on a miss.
+     * @protected
+     */
+    async read(key) {
+        const stores = this.#stores;
+        if (this.nonBlocking && stores.length > 1)
+            return firstDefined(stores.map(async (store, index) => {
+                const entry = await this.readStore(store, key);
+                return entry ? { entry: entry, index: index } : undefined;
+            }));
+        for (let index = 0; index < stores.length; index++) {
+            const entry = await this.readStore(stores[index], key);
+            if (entry)
+                return { entry: entry, index: index };
+        }
+        return undefined;
+    }
+    /**
+     * Run an operation on stores, in parallel. With `nonBlocking`, it resolves at once and a failure is only passed to
+     * `onError`.
+     * @param stores The stores.
+     * @param operation The operation run on each store.
+     * @param onError Called with the first failure.
+     * @throws {Error} The first failure of the operation, without `nonBlocking`.
+     * @protected
+     */
+    async runOnStores(stores, operation, onError) {
+        const promise = stores.length === 1 ? operation(stores[0]) : Promise.all(stores.map(operation));
+        if (this.nonBlocking) {
+            promise.catch(onError);
+            return;
+        }
+        try {
+            await promise;
+        }
+        catch (e) {
+            onError(e);
+            throw e;
+        }
+    }
+    /**
+     * Cache a value under a key, in all the stores, replacing the previous one. A `'set'` event is emitted once
+     * written; when a store fails, a `'set'` event carrying the error is emitted and the call rejects.
+     *
+     * With `nonBlocking`, the call resolves and the `'set'` event is emitted before the stores are written; a failure
+     * then emits a second `'set'` event carrying the error.
+     * @param key The key.
+     * @param value The value. The stores other than the memory one keep it as JSON.
+     * @param ttl The time to live, in milliseconds; `0` never expires. Defaults to the cache's `ttl` option (never
+     * expires without it).
+     * @returns The value given.
+     * @throws {Error} The failure of a store (its driver's error, or a `TypeError` for a value JSON cannot write),
+     * without `nonBlocking`.
+     */
+    async set(key, value, ttl) {
+        ttl = ttl ?? this.ttl;
+        await this.runOnStores(this.#stores, (store) => store.set(key, value, ttl), (error) => this.emit('set', { key: key, value: value, error: error }));
+        this.emit('set', { key: key, value: value });
+        return value;
+    }
+    /**
+     * Cache several values, in all the stores (in one batch per store where the store allows it). No `'set'` event is
+     * emitted; a failure is emitted as an `'error'` event and rejects the call (unless `nonBlocking`).
+     * @param options The entries; an entry without `ttl` gets the cache's `ttl` option.
+     * @returns The entries written, their TTL resolved.
+     * @throws {Error} The failure of a store, without `nonBlocking`.
+     */
+    async multipleSet(options) {
+        const list = options.map((option) => ({ key: option.key, value: option.value, ttl: option.ttl ?? this.ttl }));
+        await this.runOnStores(this.#stores, (store) => store.setMany(list), (error) => this.report(error));
+        return list;
+    }
+    /**
+     * Read the value of a key, from the first store holding it. It does not copy the value to the stores above (see
+     * {@link Cacher.wrap}). A failing store is a miss (its error emitted as an `'error'` event): it never rejects.
+     * @param key The key.
+     * @returns The value; undefined when the key is missing or expired (or when undefined was cached).
+     */
+    async get(key) {
+        if (this.#stores.length === 1)
+            return As((await this.readStore(this.#stores[0], key))?.value);
+        return As((await this.read(key))?.entry.value);
+    }
+    /**
+     * Read the values of several keys; each key from the first store holding it (the missing keys only are asked to
+     * the next store). A failing store misses all its keys (its error emitted as an `'error'` event): it never rejects.
+     * @param keys The keys.
+     * @returns The values, in the order of the keys: undefined for the missing and expired ones.
+     */
+    async multipleGet(keys) {
+        const readMany = async (store, storeKeys) => {
+            try {
+                return await store.getMany(storeKeys);
+            }
+            catch (e) {
+                this.report(e);
+                return [];
+            }
+        };
+        const stores = this.#stores;
+        if (this.nonBlocking && stores.length > 1) {
+            const results = stores.map((store) => readMany(store, keys));
+            return Promise.all(keys.map(async (key, index) => (await firstDefined(results.map(async (result) => (await result)[index])))?.value));
+        }
+        const values = new Array(keys.length).fill(undefined);
+        let missing = keys.map((key, index) => index);
+        for (const store of stores) {
+            const entries = await readMany(store, missing.map((index) => keys[index]));
+            missing = missing.filter((index, position) => {
+                if (!entries[position])
+                    return true;
+                values[index] = entries[position].value;
+                return false;
+            });
+            if (!missing.length)
+                break;
+        }
+        return values;
+    }
+    /**
+     * Read when a key expires. Despite its name, it returns a point in time, not a remaining duration: compute the
+     * time left with `expires - Date.now()`.
+     * @param key The key.
+     * @returns The expiration time, in milliseconds since the epoch; `-1` when the key is missing, expired or never
+     * expires.
+     */
+    async getTTL(key) {
+        return (await this.read(key))?.entry.expires ?? -1;
+    }
+    /**
+     * Read the value of a key, or compute it and cache it when it is missing or expired (the cache-aside pattern).
+     *
+     * - The concurrent calls on the same key share one call and its result, whatever their `fn` and options.
+     * - A value found in a lower store is copied to the stores above it, with the time it has left (or the `ttl` of
+     *   the call when it never expires).
+     * - With a refresh threshold, a cached value with less time to live than the threshold is returned at once and
+     *   recomputed in the background (one refresh per key at a time), then written to its store and the stores above
+     *   (to all the stores with `refreshAllStores`); a `'refresh'` event reports the new value or the failure, the
+     *   cached value kept then. A threshold higher than the TTL refreshes the value on each call.
+     * - A computed value is written with {@link Cacher.set} (a `'set'` event); `undefined` is cached too.
+     * @param key The key.
+     * @param fn Computes the value when it is missing; its failure rejects the call and nothing is cached.
+     * @param options The time to live in milliseconds (`0` never expires), or the TTL and the refresh threshold.
+     * Default to the cache's `ttl` and `refreshThreshold` options.
+     * @returns The cached or computed value.
+     * @throws {Error} The error thrown by `fn`, or the failure of a store writing the computed value (without
+     * `nonBlocking`).
+     * @example
+     * ```typescript
+     * import type {Cacher} from 'lakutata/com/cacher'
+     *
+     * declare const cache: Cacher
+     * declare function loadRates(): Promise<Record<string, number>>
+     *
+     * //Loaded at most once per hour; in its last 5 minutes, served while reloaded in the background
+     * const rates: Record<string, number> = await cache.wrap('rates', loadRates, {ttl: 3600000, refreshThreshold: 300000})
+     * //A TTL depending on the value
+     * const user: {id: number, guest: boolean} = await cache.wrap('user:1', async () => ({id: 1, guest: true}), {
+     *     ttl: (value: {id: number, guest: boolean}): number => value.guest ? 60000 : 3600000
+     * })
+     * ```
+     */
+    async wrap(key, fn, options) {
+        const pending = this.#wrapping.get(key);
+        if (pending)
+            return pending;
+        const promise = this.computeWrap(key, fn, typeof options === 'object' ? options : { ttl: options })
+            .finally(() => this.#wrapping.delete(key));
+        this.#wrapping.set(key, promise);
+        return promise;
+    }
+    /**
+     * Run one {@link Cacher.wrap} call: read the key, compute and write it on a miss, copy it to the stores above or
+     * start its background refresh on a hit.
+     * @param key The key.
+     * @param fn Computes the value.
+     * @param options The TTL and the refresh threshold.
+     * @returns The cached or computed value.
+     * @throws {Error} The error thrown by `fn`, or the failure of a store writing the computed value.
+     * @protected
+     */
+    async computeWrap(key, fn, options) {
+        const hit = await this.read(key);
+        if (!hit) {
+            const value = await fn();
+            return await this.set(key, value, this.resolveTTL(options.ttl, value));
+        }
+        const value = hit.entry.value;
+        const remaining = typeof hit.entry.expires === 'number' ? Math.max(1, hit.entry.expires - Date.now()) : undefined;
+        const threshold = (typeof options.refreshThreshold === 'function' ? options.refreshThreshold(value) : options.refreshThreshold) ?? this.refreshThreshold;
+        if (remaining !== undefined && threshold !== undefined && remaining < threshold) {
+            this.refresh(key, fn, options, value, hit.index);
+        }
+        else if (hit.index > 0) {
+            //The upper stores keep the value until it expires in the lower one
+            const ttl = remaining ?? this.resolveTTL(options.ttl, value);
+            await Promise.all(this.#stores.slice(0, hit.index).map((store) => store.set(key, value, ttl)))
+                .catch((error) => this.report(error));
+        }
+        return value;
+    }
+    /**
+     * Recompute a value in the background, unless the key is being refreshed already, and emit a `'refresh'` event
+     * with the new value or the failure. The component's destruction waits for it.
+     * @param key The key.
+     * @param fn Computes the value.
+     * @param options The TTL of the new value.
+     * @param current The value cached, reported by the event when the refresh fails.
+     * @param index The index of the store holding the value: the new value is written to it and to the stores above
+     * (to all the stores with `refreshAllStores`).
+     * @protected
+     */
+    refresh(key, fn, options, current, index) {
+        if (this.#refreshing.has(key))
+            return;
+        const stores = this.refreshAllStores ? this.#stores : this.#stores.slice(0, index + 1);
+        this.#refreshing.set(key, (async () => {
+            try {
+                const value = await fn();
+                const ttl = this.resolveTTL(options.ttl, value);
+                await Promise.all(stores.map((store) => store.set(key, value, ttl)));
+                this.emit('refresh', { key: key, value: value });
+            }
+            catch (e) {
+                this.emit('refresh', { key: key, value: current, error: e });
+            }
+            finally {
+                this.#refreshing.delete(key);
+            }
+        })());
+    }
+    /**
+     * Delete a key from all the stores. A `'del'` event is emitted once deleted; when a store fails, a `'del'` event
+     * carrying the error is emitted and the call rejects. With `nonBlocking`, it resolves and emits the `'del'` event
+     * before the stores are done, a failure emitting a second `'del'` event carrying the error.
+     * @param key The key; a missing key is not an error.
+     * @returns Always true, whether the key existed or not.
+     * @throws {Error} The failure of a store, without `nonBlocking`.
+     */
+    async del(key) {
+        await this.runOnStores(this.#stores, (store) => store.delete(key), (error) => this.emit('del', { key: key, error: error }));
+        this.emit('del', { key: key });
+        return true;
+    }
+    /**
+     * Delete several keys from all the stores. No `'del'` event is emitted; a failure is emitted as an `'error'` event
+     * and rejects the call (unless `nonBlocking`).
+     * @param keys The keys; the missing ones are not an error.
+     * @returns Always true, whether the keys existed or not.
+     * @throws {Error} The failure of a store, without `nonBlocking`.
+     */
+    async multipleDel(keys) {
+        await this.runOnStores(this.#stores, (store) => store.deleteMany(keys), (error) => this.report(error));
+        return true;
+    }
+    /**
+     * Delete all the entries of each store: the entries of its namespace when it has one, otherwise all its entries
+     * (except, in Redis, the keys containing the `keyPrefixSeparator`, which belong to the namespaces). A Memcache
+     * store flushes the whole server, its namespace ignored. A `'clear'` event is emitted once done; when a store fails,
+     * a `'clear'` event carrying the error is emitted and the call rejects (unless `nonBlocking`, which resolves and
+     * emits the event at once).
+     * @returns Always true.
+     * @throws {Error} The failure of a store, without `nonBlocking`.
+     */
+    async clear() {
+        await this.runOnStores(this.#stores, (store) => store.clear(), (error) => this.emit('clear', error));
+        this.emit('clear');
+        return true;
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+}
+__decorate([
+    Configurable(DTO.Alternatives(DTO.Array(DTO.Alternatives(MemoryCacheOptions.Schema(), FileCacheOptions.Schema(), RedisCacheOptions.Schema(), MemcacheCacheOptions.Schema(), MongoCacheOptions.Schema(), SqliteCacheOptions.Schema(), PostgresCacheOptions.Schema(), MysqlCacheOptions.Schema())), MemoryCacheOptions.Schema(), FileCacheOptions.Schema(), RedisCacheOptions.Schema(), MemcacheCacheOptions.Schema(), MongoCacheOptions.Schema(), SqliteCacheOptions.Schema(), PostgresCacheOptions.Schema(), MysqlCacheOptions.Schema()).optional()),
+    __metadata("design:type", Object)
+], Cacher.prototype, "stores", void 0);
+__decorate([
+    Configurable(DTO.Number().positive().integer().optional()),
+    __metadata("design:type", Number)
+], Cacher.prototype, "ttl", void 0);
+__decorate([
+    Configurable(DTO.Number().positive().integer().optional()),
+    __metadata("design:type", Number)
+], Cacher.prototype, "refreshThreshold", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], Cacher.prototype, "refreshAllStores", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], Cacher.prototype, "nonBlocking", void 0);
+__decorate([
+    Configurable(DTO.String().optional()),
+    __metadata("design:type", String)
+], Cacher.prototype, "cacheId", void 0);

package/dist/esm/cache/exceptions/CacheDriverNotFoundException.js

@@ -0,0 +1,13 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the cache starts, by a store whose driver package is not installed: `redis` (or `@redis/client`) for
+ * Redis, `memjs` for Memcache, `mongodb` for MongoDB, `sqlite3` for SQLite, `pg` for PostgreSQL, `mysql2` for MySQL.
+ * Its message names the package to install. It fails the cache component's creation (and so the application's
+ * start). Its `errno` is `'E_CACHE_DRIVER_NOT_FOUND'`.
+ */
+export class CacheDriverNotFoundException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_CACHE_DRIVER_NOT_FOUND';
+    }
+}

package/dist/esm/cache/interfaces/CacherOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/cache/lib/LikePrefix.js

@@ -0,0 +1,7 @@
+/**
+ * The LIKE pattern (with the "!" escape character) of the keys in a namespace
+ * @param namespace
+ */
+export function likePrefix(namespace) {
+    return `${namespace.replace(/[!%_]/g, '!$&')}:%`;
+}

package/dist/esm/cache/lib/LoadDriver.js

@@ -0,0 +1,30 @@
+import { CacheDriverNotFoundException } from '../exceptions/CacheDriverNotFoundException.js';
+/**
+ * Whether an error reports the package itself as missing
+ * @param error
+ * @param packageName
+ */
+function isPackageMissing(error, packageName) {
+    const { code, message } = error;
+    if (code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND')
+        return false;
+    return !!message && (message.includes(`'${packageName}'`) || message.includes(`"${packageName}"`));
+}
+/**
+ * Load the driver package of a store, the first installed of the candidates
+ * @param member a member of the driver API, to find it in the ESM namespace or the CommonJS exports
+ * @param packageNames
+ */
+export async function loadDriver(member, ...packageNames) {
+    for (const packageName of packageNames) {
+        try {
+            const driver = await import(packageName);
+            return (driver[member] === undefined && driver.default ? driver.default : driver);
+        }
+        catch (e) {
+            if (!isPackageMissing(e, packageName))
+                throw e;
+        }
+    }
+    throw new CacheDriverNotFoundException('Package "{packageName}" is required for this driver. Run "npm install {packageName}".', { packageName: packageNames[0] });
+}

package/dist/esm/cache/lib/Serializer.js

@@ -0,0 +1,42 @@
+import { Buffer } from 'node:buffer';
+const COLON = 58;
+const BASE64_PREFIX = ':base64:';
+//A string value starting with a colon follows an unquoted ":", "[" or ","
+const ESCAPED_STRING = /[:[,]\s*":/;
+/**
+ * Encode the values the JSON form cannot keep
+ * @param this
+ * @param key
+ * @param value
+ */
+function replacer(key, value) {
+    if (typeof value === 'string')
+        return value.charCodeAt(0) === COLON ? `:${value}` : value;
+    if (value !== null && typeof value === 'object' && Buffer.isBuffer(this[key]))
+        return `${BASE64_PREFIX}${this[key].toString('base64')}`;
+    return value;
+}
+/**
+ * Decode the values encoded by the replacer
+ * @param key
+ * @param value
+ */
+function reviver(key, value) {
+    if (typeof value !== 'string' || value.charCodeAt(0) !== COLON)
+        return value;
+    return value.startsWith(BASE64_PREFIX) ? Buffer.from(value.slice(BASE64_PREFIX.length), 'base64') : value.slice(1);
+}
+/**
+ * Serialize data
+ * @param data
+ */
+export function serialize(data) {
+    return JSON.stringify(data, replacer) ?? 'null';
+}
+/**
+ * Deserialize data
+ * @param text
+ */
+export function deserialize(text) {
+    return ESCAPED_STRING.test(text) ? JSON.parse(text, reviver) : JSON.parse(text);
+}

package/dist/esm/cache/lib/WithTimeout.js

@@ -0,0 +1,20 @@
+/**
+ * Reject a promise which does not settle in time
+ * @param promise
+ * @param timeout ms
+ * @param message
+ */
+export async function withTimeout(promise, timeout, message) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), timeout);
+            })
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}