@lakutata/cache 3.0.0-beta.0

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

@@ -0,0 +1,73 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the MySQL store (MySQL or MariaDB): one row per entry in a table. It needs the optional peer
+ * dependency `mysql2` (`npm install mysql2`): without it, the cache's creation fails with
+ * `CacheDriverNotFoundException`.
+ *
+ * When the cache starts, it creates the table when missing: `(id VARCHAR(255) PRIMARY KEY, value MEDIUMTEXT)`, the
+ * keys case sensitive (`utf8mb4_bin`); a failure (an unreachable server, a denied creation) fails the cache's
+ * creation. A key longer than 255 characters, its namespace prefix included, fails its write (in the strict SQL mode,
+ * the default), and a value is limited to 16 MB of JSON. An expired row is a miss; it stays in the table until it is read, overwritten or cleared. The
+ * values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'mysql-cache.app',
+ *     name: 'MysqlCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {
+ *                 type: 'mysql',
+ *                 host: '127.0.0.1',
+ *                 database: 'app',
+ *                 table: 'cache',
+ *                 username: 'app',
+ *                 password: process.env.MYSQL_PASSWORD ?? ''
+ *             }
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare class MysqlCacheOptions extends DTO {
+    /**
+     * The store type: `'mysql'`.
+     */
+    type: 'mysql';
+    /**
+     * The host name or IP address of the MySQL server.
+     */
+    host: string;
+    /**
+     * The database holding the table.
+     */
+    database: string;
+    /**
+     * The table of the entries, created when missing (the name is quoted: kept as written).
+     */
+    table: string;
+    /**
+     * The port of the MySQL server.
+     * @default 3306
+     */
+    port?: number;
+    /**
+     * The user name; without it, the driver's default.
+     * @default the driver's default
+     */
+    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 rows. Without it, `clear()` deletes all the table's rows.
+     * @default none
+     */
+    namespace?: string;
+}

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

@@ -0,0 +1,82 @@
+"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.MysqlCacheOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the MySQL store (MySQL or MariaDB): one row per entry in a table. It needs the optional peer
+ * dependency `mysql2` (`npm install mysql2`): without it, the cache's creation fails with
+ * `CacheDriverNotFoundException`.
+ *
+ * When the cache starts, it creates the table when missing: `(id VARCHAR(255) PRIMARY KEY, value MEDIUMTEXT)`, the
+ * keys case sensitive (`utf8mb4_bin`); a failure (an unreachable server, a denied creation) fails the cache's
+ * creation. A key longer than 255 characters, its namespace prefix included, fails its write (in the strict SQL mode,
+ * the default), and a value is limited to 16 MB of JSON. An expired row is a miss; it stays in the table until it is read, overwritten or cleared. The
+ * values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'mysql-cache.app',
+ *     name: 'MysqlCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {
+ *                 type: 'mysql',
+ *                 host: '127.0.0.1',
+ *                 database: 'app',
+ *                 table: 'cache',
+ *                 username: 'app',
+ *                 password: process.env.MYSQL_PASSWORD ?? ''
+ *             }
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+class MysqlCacheOptions extends core_1.DTO {
+}
+exports.MysqlCacheOptions = MysqlCacheOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('mysql').only().required()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "host", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "database", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "table", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().port().optional().default(3306)),
+    __metadata("design:type", Number)
+], MysqlCacheOptions.prototype, "port", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "username", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').optional()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "password", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "namespace", void 0);

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

@@ -0,0 +1,87 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the PostgreSQL store: one row per entry in a table. It needs the optional peer dependency `pg`
+ * (`npm install pg`): without it, the cache's creation fails with `CacheDriverNotFoundException`.
+ *
+ * When the cache starts, it creates the schema (other than `public`) and the table when missing:
+ * `(key VARCHAR(255) PRIMARY KEY, value TEXT)`; a failure (an unreachable server, a denied creation) fails the cache's
+ * creation. A key longer than 255 characters, its namespace prefix included, fails its write. An expired row is a
+ * miss; it stays in the table until it is read, overwritten or cleared. The errors of the idle connections are emitted
+ * as `'error'` events of the cache. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'postgres-cache.app',
+ *     name: 'PostgresCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {
+ *                 type: 'postgres',
+ *                 host: '127.0.0.1',
+ *                 database: 'app',
+ *                 schema: 'cache',
+ *                 table: 'entries',
+ *                 username: 'app',
+ *                 password: process.env.PGPASSWORD ?? '',
+ *                 maxPoolSize: 5
+ *             },
+ *             ttl: 600000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare class PostgresCacheOptions extends DTO {
+    /**
+     * The store type: `'postgres'`.
+     */
+    type: 'postgres';
+    /**
+     * The host name or IP address of the PostgreSQL server.
+     */
+    host: string;
+    /**
+     * The database holding the table.
+     */
+    database: string;
+    /**
+     * The table of the entries, created when missing. A plain name (letters, digits, `_`, `$`) is folded to lower
+     * case by PostgreSQL; any other name is quoted and kept as written.
+     */
+    table: string;
+    /**
+     * The port of the PostgreSQL server.
+     * @default 5432
+     */
+    port?: number;
+    /**
+     * The schema of the table, created when missing. Named as the table (a plain name folded to lower case).
+     * @default 'public'
+     */
+    schema?: string;
+    /**
+     * The user name; without it, the driver's default: the `PGUSER` environment variable, else the user of the
+     * process.
+     * @default the driver's default
+     */
+    username?: string;
+    /**
+     * The user's password; empty or omitted for a user without password (trust authentication).
+     * @default none
+     */
+    password?: string;
+    /**
+     * The maximum number of connections of the pool (a positive integer).
+     * @default 10 (the default of `pg`)
+     */
+    maxPoolSize?: number;
+    /**
+     * The namespace of the entries: the keys are stored as `{namespace}:{key}`, and `clear()` deletes only the
+     * namespace's rows. Without it, `clear()` deletes all the table's rows.
+     * @default none
+     */
+    namespace?: string;
+}

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

@@ -0,0 +1,92 @@
+"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.PostgresCacheOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the PostgreSQL store: one row per entry in a table. It needs the optional peer dependency `pg`
+ * (`npm install pg`): without it, the cache's creation fails with `CacheDriverNotFoundException`.
+ *
+ * When the cache starts, it creates the schema (other than `public`) and the table when missing:
+ * `(key VARCHAR(255) PRIMARY KEY, value TEXT)`; a failure (an unreachable server, a denied creation) fails the cache's
+ * creation. A key longer than 255 characters, its namespace prefix included, fails its write. An expired row is a
+ * miss; it stays in the table until it is read, overwritten or cleared. The errors of the idle connections are emitted
+ * as `'error'` events of the cache. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'postgres-cache.app',
+ *     name: 'PostgresCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {
+ *                 type: 'postgres',
+ *                 host: '127.0.0.1',
+ *                 database: 'app',
+ *                 schema: 'cache',
+ *                 table: 'entries',
+ *                 username: 'app',
+ *                 password: process.env.PGPASSWORD ?? '',
+ *                 maxPoolSize: 5
+ *             },
+ *             ttl: 600000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+class PostgresCacheOptions extends core_1.DTO {
+}
+exports.PostgresCacheOptions = PostgresCacheOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('postgres').only().required()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "host", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "database", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "table", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().port().optional().default(5432)),
+    __metadata("design:type", Number)
+], PostgresCacheOptions.prototype, "port", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional().default('public')),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "schema", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "username", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').optional()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "password", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().integer().optional()),
+    __metadata("design:type", Number)
+], PostgresCacheOptions.prototype, "maxPoolSize", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "namespace", void 0);

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

@@ -0,0 +1,120 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the Redis store (Redis, Valkey or a compatible server). It needs the optional peer dependency
+ * `redis` (`npm install redis`, version 4 or 5; `@redis/client` is used when `redis` is not installed): without it,
+ * the cache's creation fails with `CacheDriverNotFoundException`.
+ *
+ * The store connects when the cache starts. While it is disconnected, its commands fail at once instead of waiting:
+ * the reads are misses (emitted as `'error'` events), the writes reject. The connection errors are emitted as
+ * `'error'` events of the cache. The entries expire in Redis (`PSETEX`). The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'redis-cache.app',
+ *     name: 'RedisCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {
+ *                 type: 'redis',
+ *                 host: '127.0.0.1',
+ *                 password: process.env.REDIS_PASSWORD,
+ *                 namespace: 'app',
+ *                 //Start even when Redis is down, and keep reconnecting
+ *                 throwOnConnectError: false
+ *             },
+ *             ttl: 60000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare class RedisCacheOptions extends DTO {
+    /**
+     * The store type: `'redis'`.
+     */
+    type: 'redis';
+    /**
+     * The host name or IP address of the Redis server.
+     */
+    host: string;
+    /**
+     * The port of the Redis server.
+     * @default 6379
+     */
+    port?: number;
+    /**
+     * The index of the Redis database.
+     * @default 0
+     */
+    database?: number;
+    /**
+     * Whether to connect with TLS (with the system's certificate authorities).
+     * @default false
+     */
+    tls?: boolean;
+    /**
+     * The delay, in milliseconds, before the first TCP keep-alive probe of the idle connection.
+     * @default the driver's default
+     */
+    keepAlive?: number;
+    /**
+     * The user name (Redis 6 ACL).
+     * @default none (the default user)
+     */
+    username?: string;
+    /**
+     * The password.
+     * @default none
+     */
+    password?: string;
+    /**
+     * Whether to reconnect after the connection is lost, after `100 ms × attempt` (3 seconds at most). When false, the
+     * store stays disconnected.
+     * @default true
+     */
+    reconnect?: boolean;
+    /**
+     * The namespace of the entries: the keys are stored as `{namespace}{keyPrefixSeparator}{namespace}:{key}` (the
+     * format of lakutata 2.x), and `clear()` deletes only the namespace's keys. Without it, the keys are stored as
+     * they are, and `clear()` deletes all the database's string keys except the ones containing the
+     * `keyPrefixSeparator` (unless `noNamespaceAffectsAll`).
+     * @default none
+     */
+    namespace?: string;
+    /**
+     * The separator between the namespace and the rest of a key.
+     * @default '::'
+     */
+    keyPrefixSeparator?: string;
+    /**
+     * The number of keys `clear()` scans and deletes per batch; `0` for the default.
+     * @default 1000
+     */
+    clearBatchSize?: number;
+    /**
+     * Whether to delete with `UNLINK` (the memory reclaimed in the background) rather than `DEL`.
+     * @default true
+     */
+    useUnlink?: boolean;
+    /**
+     * Whether `clear()` without namespace flushes the whole Redis database (`FLUSHDB`, every key of every type and
+     * namespace included), instead of scanning for its string keys outside the namespaces.
+     * @default false
+     */
+    noNamespaceAffectsAll?: boolean;
+    /**
+     * How long, in milliseconds, the first connection may take before it fails.
+     * @default 5000
+     */
+    connectTimeout?: number;
+    /**
+     * Whether a failed first connection fails the cache's creation (and so the application's start). When false, the
+     * failure is emitted as an `'error'` event of the cache and the store keeps trying to connect in the background
+     * (as `reconnect` allows), its commands failing meanwhile.
+     * @default true
+     */
+    throwOnConnectError?: boolean;
+}

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

@@ -0,0 +1,113 @@
+"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.RedisCacheOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the Redis store (Redis, Valkey or a compatible server). It needs the optional peer dependency
+ * `redis` (`npm install redis`, version 4 or 5; `@redis/client` is used when `redis` is not installed): without it,
+ * the cache's creation fails with `CacheDriverNotFoundException`.
+ *
+ * The store connects when the cache starts. While it is disconnected, its commands fail at once instead of waiting:
+ * the reads are misses (emitted as `'error'` events), the writes reject. The connection errors are emitted as
+ * `'error'` events of the cache. The entries expire in Redis (`PSETEX`). The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'redis-cache.app',
+ *     name: 'RedisCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {
+ *                 type: 'redis',
+ *                 host: '127.0.0.1',
+ *                 password: process.env.REDIS_PASSWORD,
+ *                 namespace: 'app',
+ *                 //Start even when Redis is down, and keep reconnecting
+ *                 throwOnConnectError: false
+ *             },
+ *             ttl: 60000
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+class RedisCacheOptions extends core_1.DTO {
+}
+exports.RedisCacheOptions = RedisCacheOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('redis').only().required()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "host", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().port().optional().default(6379)),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "port", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().allow(0).default(0).optional()),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "database", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "tls", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().allow(0).optional()),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "keepAlive", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "username", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "password", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "reconnect", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "namespace", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "keyPrefixSeparator", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().allow(0).optional()),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "clearBatchSize", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "useUnlink", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "noNamespaceAffectsAll", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().optional()),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "connectTimeout", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "throwOnConnectError", void 0);

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

@@ -0,0 +1,53 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the SQLite store: one row per entry in a table of a SQLite database file. It needs the optional peer
+ * dependency `sqlite3` (`npm install sqlite3`): without it, the cache's creation fails with
+ * `CacheDriverNotFoundException`.
+ *
+ * When the cache starts, it opens the database (creating the file) and creates the table when missing:
+ * `(key VARCHAR(255) PRIMARY KEY, value TEXT)`. An expired row is a miss; it stays in the table until it is read,
+ * overwritten or cleared. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'sqlite-cache.app',
+ *     name: 'SqliteCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {type: 'sqlite', database: './cache.db', table: 'cache', namespace: 'app'}
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export declare class SqliteCacheOptions extends DTO {
+    /**
+     * The store type: `'sqlite'`.
+     */
+    type: 'sqlite';
+    /**
+     * The path of the database file, relative to the working directory (its directory must exist), or `':memory:'`
+     * for a database in memory.
+     */
+    database: string;
+    /**
+     * The table of the entries, created when missing. The characters other than letters, digits and `_` are removed
+     * from the name, and `_` is prefixed when it does not start with a letter; a name left empty fails the cache's
+     * creation.
+     */
+    table: string;
+    /**
+     * How long a statement waits for a database locked by another connection, in milliseconds, before failing.
+     * @default 10000
+     */
+    busyTimeout?: number;
+    /**
+     * The namespace of the entries: the keys are stored as `{namespace}:{key}`, and `clear()` deletes only the
+     * namespace's rows. Without it, `clear()` deletes all the table's rows.
+     * @default none
+     */
+    namespace?: string;
+}