@lakutata/cache 3.0.0-beta.0

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

@@ -0,0 +1,58 @@
+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 { DTO } from '@lakutata/core';
+import { Expect } from '@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
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class FileCacheOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().allow('file').only().required()),
+    __metadata("design:type", String)
+], FileCacheOptions.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], FileCacheOptions.prototype, "filename", void 0);
+__decorate([
+    Expect(DTO.Number().positive().optional().default(3600 * 1000)),
+    __metadata("design:type", Number)
+], FileCacheOptions.prototype, "expiredCheckDelay", void 0);
+__decorate([
+    Expect(DTO.Number().positive().allow(0).optional().default(100)),
+    __metadata("design:type", Number)
+], FileCacheOptions.prototype, "writeDelay", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], FileCacheOptions.prototype, "namespace", void 0);

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

@@ -0,0 +1,62 @@
+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 { DTO } from '@lakutata/core';
+import { Expect } from '@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
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class MemcacheCacheOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().allow('memcache').only().required()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "host", void 0);
+__decorate([
+    Expect(DTO.Number().positive().port().optional().default(11211)),
+    __metadata("design:type", Number)
+], MemcacheCacheOptions.prototype, "port", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "username", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "password", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], MemcacheCacheOptions.prototype, "namespace", void 0);

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

@@ -0,0 +1,48 @@
+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 { DTO } from '@lakutata/core';
+import { Expect } from '@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
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class MemoryCacheOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().allow('memory').only().required()),
+    __metadata("design:type", String)
+], MemoryCacheOptions.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.Number().positive().optional().default(60000)),
+    __metadata("design:type", Number)
+], MemoryCacheOptions.prototype, "sweepInterval", void 0);

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

@@ -0,0 +1,77 @@
+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 { DTO } from '@lakutata/core';
+import { Expect } from '@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 ?? ''
+ *             }
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class MongoCacheOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().allow('mongo').only().required()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "host", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "database", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "collection", void 0);
+__decorate([
+    Expect(DTO.Number().positive().port().optional().default(27017)),
+    __metadata("design:type", Number)
+], MongoCacheOptions.prototype, "port", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "username", void 0);
+__decorate([
+    Expect(DTO.String().allow('').optional()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "password", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], MongoCacheOptions.prototype, "namespace", void 0);

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

@@ -0,0 +1,78 @@
+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 { DTO } from '@lakutata/core';
+import { Expect } from '@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 ?? ''
+ *             }
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class MysqlCacheOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().allow('mysql').only().required()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "host", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "database", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "table", void 0);
+__decorate([
+    Expect(DTO.Number().positive().port().optional().default(3306)),
+    __metadata("design:type", Number)
+], MysqlCacheOptions.prototype, "port", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "username", void 0);
+__decorate([
+    Expect(DTO.String().allow('').optional()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "password", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], MysqlCacheOptions.prototype, "namespace", void 0);

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

@@ -0,0 +1,88 @@
+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 { DTO } from '@lakutata/core';
+import { Expect } from '@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
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class PostgresCacheOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().allow('postgres').only().required()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "host", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "database", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "table", void 0);
+__decorate([
+    Expect(DTO.Number().positive().port().optional().default(5432)),
+    __metadata("design:type", Number)
+], PostgresCacheOptions.prototype, "port", void 0);
+__decorate([
+    Expect(DTO.String().optional().default('public')),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "schema", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "username", void 0);
+__decorate([
+    Expect(DTO.String().allow('').optional()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "password", void 0);
+__decorate([
+    Expect(DTO.Number().positive().integer().optional()),
+    __metadata("design:type", Number)
+], PostgresCacheOptions.prototype, "maxPoolSize", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], PostgresCacheOptions.prototype, "namespace", void 0);

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

@@ -0,0 +1,109 @@
+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 { DTO } from '@lakutata/core';
+import { Expect } from '@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
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class RedisCacheOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().allow('redis').only().required()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "host", void 0);
+__decorate([
+    Expect(DTO.Number().positive().port().optional().default(6379)),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "port", void 0);
+__decorate([
+    Expect(DTO.Number().positive().allow(0).default(0).optional()),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "database", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "tls", void 0);
+__decorate([
+    Expect(DTO.Number().positive().allow(0).optional()),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "keepAlive", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "username", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "password", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "reconnect", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "namespace", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], RedisCacheOptions.prototype, "keyPrefixSeparator", void 0);
+__decorate([
+    Expect(DTO.Number().positive().allow(0).optional()),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "clearBatchSize", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "useUnlink", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "noNamespaceAffectsAll", void 0);
+__decorate([
+    Expect(DTO.Number().positive().optional()),
+    __metadata("design:type", Number)
+], RedisCacheOptions.prototype, "connectTimeout", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], RedisCacheOptions.prototype, "throwOnConnectError", void 0);

package/dist/esm/cache/options/SqliteCacheOptions.js

@@ -0,0 +1,57 @@
+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 { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * 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 class SqliteCacheOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().allow('sqlite').only().required()),
+    __metadata("design:type", String)
+], SqliteCacheOptions.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], SqliteCacheOptions.prototype, "database", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], SqliteCacheOptions.prototype, "table", void 0);
+__decorate([
+    Expect(DTO.Number().positive().integer().optional().default(10000)),
+    __metadata("design:type", Number)
+], SqliteCacheOptions.prototype, "busyTimeout", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], SqliteCacheOptions.prototype, "namespace", void 0);

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

@@ -0,0 +1,36 @@
+/**
+ * Whether an entry has expired
+ * @param entry
+ */
+export function isExpired(entry) {
+    return typeof entry.expires === 'number' && Date.now() > entry.expires;
+}
+/**
+ * The expiration time of a ttl
+ * @param ttl
+ */
+export function expiresOf(ttl) {
+    return ttl ? Date.now() + ttl : undefined;
+}
+/**
+ * A cache store
+ * The ttls are in milliseconds, a missing or zero ttl never expires
+ */
+export class CacheStore {
+    constructor() {
+        /**
+         * Report the errors of the background operations
+         */
+        this.onError = () => undefined;
+    }
+    /**
+     * Connect to the backend
+     */
+    async connect() {
+    }
+    /**
+     * Disconnect from the backend
+     */
+    async disconnect() {
+    }
+}

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

@@ -0,0 +1,34 @@
+import { FileStore } from './FileStore.js';
+import { MemoryStore } from './MemoryStore.js';
+import { RedisStore } from './RedisStore.js';
+import { MemcacheStore } from './MemcacheStore.js';
+import { MongoStore } from './MongoStore.js';
+import { SqliteStore } from './SqliteStore.js';
+import { PostgresStore } from './PostgresStore.js';
+import { MysqlStore } from './MysqlStore.js';
+/**
+ * Create the store of the options
+ * @param options
+ */
+export function createCacheStore(options) {
+    switch (options.type) {
+        case 'memory':
+            return new MemoryStore(options.sweepInterval);
+        case 'file':
+            return new FileStore(options);
+        case 'redis':
+            return new RedisStore(options);
+        case 'memcache':
+            return new MemcacheStore(options);
+        case 'mongo':
+            return new MongoStore(options);
+        case 'sqlite':
+            return new SqliteStore(options);
+        case 'postgres':
+            return new PostgresStore(options);
+        case 'mysql':
+            return new MysqlStore(options);
+        default:
+            return undefined;
+    }
+}