@lakutata/cache 3.0.0-beta.0

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

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDriver = loadDriver;
+const CacheDriverNotFoundException_js_1 = require("../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
+ */
+async function loadDriver(member, ...packageNames) {
+    for (const packageName of packageNames) {
+        try {
+            const driver = await Promise.resolve(`${packageName}`).then(s => __importStar(require(s)));
+            return (driver[member] === undefined && driver.default ? driver.default : driver);
+        }
+        catch (e) {
+            if (!isPackageMissing(e, packageName))
+                throw e;
+        }
+    }
+    throw new CacheDriverNotFoundException_js_1.CacheDriverNotFoundException('Package "{packageName}" is required for this driver. Run "npm install {packageName}".', { packageName: packageNames[0] });
+}

package/dist/cjs/cache/lib/Serializer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The stored form of a cache entry
+ * The strings starting with a colon get one more colon, the buffers are written as ":base64:" strings (the format of 2.x)
+ */
+export type CacheEntry<T = unknown> = {
+    value: T;
+    expires?: number;
+};
+/**
+ * Serialize data
+ * @param data
+ */
+export declare function serialize(data: unknown): string;
+/**
+ * Deserialize data
+ * @param text
+ */
+export declare function deserialize<T = unknown>(text: string): T;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialize = serialize;
+exports.deserialize = deserialize;
+const node_buffer_1 = require("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' && node_buffer_1.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) ? node_buffer_1.Buffer.from(value.slice(BASE64_PREFIX.length), 'base64') : value.slice(1);
+}
+/**
+ * Serialize data
+ * @param data
+ */
+function serialize(data) {
+    return JSON.stringify(data, replacer) ?? 'null';
+}
+/**
+ * Deserialize data
+ * @param text
+ */
+function deserialize(text) {
+    return ESCAPED_STRING.test(text) ? JSON.parse(text, reviver) : JSON.parse(text);
+}

package/dist/cjs/cache/lib/WithTimeout.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reject a promise which does not settle in time
+ * @param promise
+ * @param timeout ms
+ * @param message
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeout: number, message: string): Promise<T>;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = withTimeout;
+/**
+ * Reject a promise which does not settle in time
+ * @param promise
+ * @param timeout ms
+ * @param message
+ */
+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);
+    }
+}

package/dist/cjs/cache/options/FileCacheOptions.d.ts

@@ -0,0 +1,54 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the file store: the entries are kept in memory and saved to one JSON file (loaded when the cache
+ * starts, written in batches, flushed when the cache is destroyed), so they survive a restart. It needs no optional
+ * dependency.
+ *
+ * The file is rewritten whole on each save (through a temporary file renamed over it), so it suits small caches;
+ * the processes sharing one file overwrite each other's entries. An unreadable file (not JSON) fails the cache's
+ * creation; a failed save is emitted as an `'error'` event of the cache. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'file-cache.app',
+ *     name: 'FileCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {type: 'file', filename: './cache/data.json', namespace: 'app', writeDelay: 500},
+ *             ttl: 3600000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare class FileCacheOptions extends DTO {
+    /**
+     * The store type: `'file'`.
+     */
+    type: 'file';
+    /**
+     * The path of the file, relative to the working directory; created (with its directories) at the first save.
+     */
+    filename: string;
+    /**
+     * The minimum interval, in milliseconds, between two purges of the expired entries from the file (done at a save).
+     * An expired entry is a miss anyway, and is removed when read.
+     * @default 3600000
+     */
+    expiredCheckDelay?: number;
+    /**
+     * The delay, in milliseconds, between a change and the save of the file: the changes made meanwhile are saved
+     * together. `0` saves at the next turn of the event loop.
+     * @default 100
+     */
+    writeDelay?: number;
+    /**
+     * The namespace of the entries: the keys are saved as `{namespace}:{key}`, and `clear()` deletes only the
+     * namespace's entries. Without it, `clear()` deletes all the file's entries.
+     * @default none
+     */
+    namespace?: string;
+}

package/dist/cjs/cache/options/FileCacheOptions.js

@@ -0,0 +1,62 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCacheOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the file store: the entries are kept in memory and saved to one JSON file (loaded when the cache
+ * starts, written in batches, flushed when the cache is destroyed), so they survive a restart. It needs no optional
+ * dependency.
+ *
+ * The file is rewritten whole on each save (through a temporary file renamed over it), so it suits small caches;
+ * the processes sharing one file overwrite each other's entries. An unreadable file (not JSON) fails the cache's
+ * creation; a failed save is emitted as an `'error'` event of the cache. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'file-cache.app',
+ *     name: 'FileCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {type: 'file', filename: './cache/data.json', namespace: 'app', writeDelay: 500},
+ *             ttl: 3600000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+class FileCacheOptions extends core_1.DTO {
+}
+exports.FileCacheOptions = FileCacheOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('file').only().required()),
+    __metadata("design:type", String)
+], FileCacheOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], FileCacheOptions.prototype, "filename", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().optional().default(3600 * 1000)),
+    __metadata("design:type", Number)
+], FileCacheOptions.prototype, "expiredCheckDelay", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().allow(0).optional().default(100)),
+    __metadata("design:type", Number)
+], FileCacheOptions.prototype, "writeDelay", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], FileCacheOptions.prototype, "namespace", void 0);

package/dist/cjs/cache/options/MemcacheCacheOptions.d.ts

@@ -0,0 +1,57 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the Memcache store, a memcached server. It needs the optional peer dependency `memjs`
+ * (`npm install memjs`): without it, the cache's creation fails with `CacheDriverNotFoundException`.
+ *
+ * The client connects on its first command, so an unreachable server does not fail the cache's creation: its reads
+ * are misses (emitted as `'error'` events), its writes reject. The TTLs are rounded up to the second by memcached
+ * (an entry is a miss once its TTL in milliseconds has passed). memcached cannot list its keys: `clear()` flushes the
+ * whole server, the entries of the other namespaces and applications included. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'memcache.app',
+ *     name: 'Memcache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {type: 'memcache', host: '127.0.0.1', port: 11211, namespace: 'app'},
+ *             ttl: 60000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare class MemcacheCacheOptions extends DTO {
+    /**
+     * The store type: `'memcache'`.
+     */
+    type: 'memcache';
+    /**
+     * The host name or IP address of the memcached server.
+     */
+    host: string;
+    /**
+     * The port of the memcached server.
+     * @default 11211
+     */
+    port?: number;
+    /**
+     * The SASL user name, for a server requiring authentication.
+     * @default none
+     */
+    username?: string;
+    /**
+     * The SASL password, for a server requiring authentication.
+     * @default none
+     */
+    password?: string;
+    /**
+     * The namespace of the entries: the keys are stored as `{namespace}:{namespace}:{key}` (the format of lakutata 2.x).
+     * It does not limit `clear()`, which flushes the whole server.
+     * @default none
+     */
+    namespace?: string;
+}

package/dist/cjs/cache/options/MemcacheCacheOptions.js

@@ -0,0 +1,66 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemcacheCacheOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the Memcache store, a memcached server. It needs the optional peer dependency `memjs`
+ * (`npm install memjs`): without it, the cache's creation fails with `CacheDriverNotFoundException`.
+ *
+ * The client connects on its first command, so an unreachable server does not fail the cache's creation: its reads
+ * are misses (emitted as `'error'` events), its writes reject. The TTLs are rounded up to the second by memcached
+ * (an entry is a miss once its TTL in milliseconds has passed). memcached cannot list its keys: `clear()` flushes the
+ * whole server, the entries of the other namespaces and applications included. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'memcache.app',
+ *     name: 'Memcache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {type: 'memcache', host: '127.0.0.1', port: 11211, namespace: 'app'},
+ *             ttl: 60000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+class MemcacheCacheOptions extends core_1.DTO {
+}
+exports.MemcacheCacheOptions = MemcacheCacheOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('memcache').only().required()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "host", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().port().optional().default(11211)),
+    __metadata("design:type", Number)
+], MemcacheCacheOptions.prototype, "port", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "username", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "password", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "namespace", void 0);

package/dist/cjs/cache/options/MemoryCacheOptions.d.ts

@@ -0,0 +1,39 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the in-memory store: the entries are kept in the process (lost when it ends, not shared with the
+ * other processes), the values as they are (not copied, not converted to JSON). It needs no optional dependency.
+ *
+ * It is the store of a cache without `stores`; declared, it is a tier in front of a slower store (the first store of
+ * the list is read first, the hits of a later store are written back to the earlier ones).
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'tiered-cache.app',
+ *     name: 'TieredCache',
+ *     components: {
+ *         //A memory tier in front of Redis
+ *         cache: buildCacherOptions({
+ *             stores: [
+ *                 {type: 'memory', sweepInterval: 30000},
+ *                 {type: 'redis', host: '127.0.0.1', namespace: 'app'}
+ *             ],
+ *             ttl: 60000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare class MemoryCacheOptions extends DTO {
+    /**
+     * The store type: `'memory'`.
+     */
+    type: 'memory';
+    /**
+     * The interval, in milliseconds, between two removals of the expired entries (an expired entry is a miss anyway).
+     * @default 60000
+     */
+    sweepInterval?: number;
+}

package/dist/cjs/cache/options/MemoryCacheOptions.js

@@ -0,0 +1,52 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCacheOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the in-memory store: the entries are kept in the process (lost when it ends, not shared with the
+ * other processes), the values as they are (not copied, not converted to JSON). It needs no optional dependency.
+ *
+ * It is the store of a cache without `stores`; declared, it is a tier in front of a slower store (the first store of
+ * the list is read first, the hits of a later store are written back to the earlier ones).
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'tiered-cache.app',
+ *     name: 'TieredCache',
+ *     components: {
+ *         //A memory tier in front of Redis
+ *         cache: buildCacherOptions({
+ *             stores: [
+ *                 {type: 'memory', sweepInterval: 30000},
+ *                 {type: 'redis', host: '127.0.0.1', namespace: 'app'}
+ *             ],
+ *             ttl: 60000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+class MemoryCacheOptions extends core_1.DTO {
+}
+exports.MemoryCacheOptions = MemoryCacheOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('memory').only().required()),
+    __metadata("design:type", String)
+], MemoryCacheOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().optional().default(60000)),
+    __metadata("design:type", Number)
+], MemoryCacheOptions.prototype, "sweepInterval", void 0);

package/dist/cjs/cache/options/MongoCacheOptions.d.ts

@@ -0,0 +1,72 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the MongoDB store: one document per entry in a collection. It needs the optional peer dependency
+ * `mongodb` (`npm install mongodb`): without it, the cache's creation fails with `CacheDriverNotFoundException`.
+ *
+ * When the cache starts, it connects to `mongodb://{username}:{password}@{host}:{port}` (the user authenticated
+ * against the `admin` database; `mongodb://{host}:{port}` without a username) and creates the collection's
+ * indexes: a unique one on `key`, and a TTL index on
+ * `expiresAt` by which MongoDB deletes the expired documents (its TTL monitor runs about once a minute; an expired
+ * document is a miss before). A failed connection fails the cache's creation. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'mongo-cache.app',
+ *     name: 'MongoCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {
+ *                 type: 'mongo',
+ *                 host: '127.0.0.1',
+ *                 database: 'app',
+ *                 collection: 'cache',
+ *                 username: 'app',
+ *                 password: process.env.MONGO_PASSWORD ?? ''
+ *             }
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare class MongoCacheOptions extends DTO {
+    /**
+     * The store type: `'mongo'`.
+     */
+    type: 'mongo';
+    /**
+     * The host name or IP address of the MongoDB server.
+     */
+    host: string;
+    /**
+     * The database holding the collection.
+     */
+    database: string;
+    /**
+     * The collection of the entries, created when missing.
+     */
+    collection: string;
+    /**
+     * The port of the MongoDB server.
+     * @default 27017
+     */
+    port?: number;
+    /**
+     * The user name; without it, no authentication.
+     * @default none (no authentication)
+     */
+    username?: string;
+    /**
+     * The user's password; empty or omitted for a user without password (trust authentication).
+     * @default none
+     */
+    password?: string;
+    /**
+     * The namespace of the entries: the keys are stored as `{namespace}:{key}`, and `clear()` deletes only the
+     * namespace's documents. Without it, `clear()` deletes all the collection's documents.
+     * @default none
+     */
+    namespace?: string;
+}

package/dist/cjs/cache/options/MongoCacheOptions.js

@@ -0,0 +1,81 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoCacheOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the MongoDB store: one document per entry in a collection. It needs the optional peer dependency
+ * `mongodb` (`npm install mongodb`): without it, the cache's creation fails with `CacheDriverNotFoundException`.
+ *
+ * When the cache starts, it connects to `mongodb://{username}:{password}@{host}:{port}` (the user authenticated
+ * against the `admin` database; `mongodb://{host}:{port}` without a username) and creates the collection's
+ * indexes: a unique one on `key`, and a TTL index on
+ * `expiresAt` by which MongoDB deletes the expired documents (its TTL monitor runs about once a minute; an expired
+ * document is a miss before). A failed connection fails the cache's creation. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'mongo-cache.app',
+ *     name: 'MongoCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {
+ *                 type: 'mongo',
+ *                 host: '127.0.0.1',
+ *                 database: 'app',
+ *                 collection: 'cache',
+ *                 username: 'app',
+ *                 password: process.env.MONGO_PASSWORD ?? ''
+ *             }
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+class MongoCacheOptions extends core_1.DTO {
+}
+exports.MongoCacheOptions = MongoCacheOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('mongo').only().required()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "host", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "database", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "collection", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().port().optional().default(27017)),
+    __metadata("design:type", Number)
+], MongoCacheOptions.prototype, "port", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "username", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').optional()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "password", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "namespace", void 0);