@lakutata/cache 3.0.0-beta.0

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteStore = void 0;
+const SerializedCacheStore_js_1 = require("./SerializedCacheStore.js");
+const LoadDriver_js_1 = require("../lib/LoadDriver.js");
+/**
+ * The table name of 2.x: the alphanumeric characters, starting with a letter
+ * @param name
+ */
+function tableName(name) {
+    const sanitized = name.replace(/[^a-zA-Z0-9_]/g, '');
+    if (!sanitized)
+        throw new Error('Invalid table name: must contain alphanumeric characters');
+    return /^[a-zA-Z]/.test(sanitized) ? sanitized : `_${sanitized}`;
+}
+/**
+ * The SQLite store
+ * Table format: (key VARCHAR(255) PRIMARY KEY, value TEXT), with "{namespace}:{key}" keys
+ */
+class SqliteStore extends SerializedCacheStore_js_1.SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+        this.table = tableName(options.table);
+    }
+    /**
+     * Query the rows
+     * @param sql
+     * @param params
+     * @protected
+     */
+    all(sql, params) {
+        return new Promise((resolve, reject) => this.database.all(sql, params, (error, rows) => error ? reject(error) : resolve(rows)));
+    }
+    /**
+     * Run a statement, resolve the number of changed rows
+     * @param sql
+     * @param params
+     * @protected
+     */
+    run(sql, params = []) {
+        return new Promise((resolve, reject) => this.database.run(sql, params, function (error) {
+            error ? reject(error) : resolve(this.changes);
+        }));
+    }
+    async connect() {
+        const driver = await (0, LoadDriver_js_1.loadDriver)('Database', 'sqlite3');
+        await new Promise((resolve, reject) => {
+            this.database = new driver.Database(this.options.database, (error) => error ? reject(error) : resolve());
+        });
+        this.database.configure('busyTimeout', this.options.busyTimeout ?? 10000);
+        await this.run(`CREATE TABLE IF NOT EXISTS ${this.table}(key VARCHAR(255) PRIMARY KEY, value TEXT)`);
+    }
+    async disconnect() {
+        if (!this.database)
+            return;
+        await new Promise((resolve, reject) => this.database.close((error) => error ? reject(error) : resolve()));
+    }
+    async read(key) {
+        const rows = await this.all(`SELECT value FROM ${this.table} WHERE key = ?`, [key]);
+        return rows[0]?.value;
+    }
+    async readMany(keys) {
+        const rows = await this.all(`SELECT key, value FROM ${this.table} WHERE key IN (SELECT value FROM json_each(?))`, [JSON.stringify(keys)]);
+        const values = new Map(rows.map((row) => [row.key, row.value]));
+        return keys.map((key) => values.get(key));
+    }
+    async write(entry) {
+        await this.run(`INSERT INTO ${this.table} (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value`, [entry.key, entry.data]);
+    }
+    async writeMany(entries) {
+        await this.run(`INSERT INTO ${this.table} (key, value) SELECT json_extract(value, '$[0]'), json_extract(value, '$[1]') FROM json_each(?) WHERE 1 ON CONFLICT (key) DO UPDATE SET value = excluded.value`, [JSON.stringify(entries.map((entry) => [entry.key, entry.data]))]);
+    }
+    async remove(key) {
+        return (await this.run(`DELETE FROM ${this.table} WHERE key = ?`, [key])) > 0;
+    }
+    async removeMany(keys) {
+        return (await this.run(`DELETE FROM ${this.table} WHERE key IN (SELECT value FROM json_each(?))`, [JSON.stringify(keys)])) > 0;
+    }
+    async clear() {
+        if (this.namespace) {
+            //LIKE ignores the case in SQLite
+            const prefix = `${this.namespace}:`;
+            await this.run(`DELETE FROM ${this.table} WHERE substr(key, 1, length(?1)) = ?1`, [prefix]);
+        }
+        else {
+            await this.run(`DELETE FROM ${this.table}`);
+        }
+    }
+}
+exports.SqliteStore = SqliteStore;

package/dist/cjs/cache/types/CacheStoreOptions.d.ts

@@ -0,0 +1,15 @@
+import { FileCacheOptions } from '../options/FileCacheOptions.js';
+import { MemoryCacheOptions } from '../options/MemoryCacheOptions.js';
+import { RedisCacheOptions } from '../options/RedisCacheOptions.js';
+import { SqliteCacheOptions } from '../options/SqliteCacheOptions.js';
+import { PostgresCacheOptions } from '../options/PostgresCacheOptions.js';
+import { MysqlCacheOptions } from '../options/MysqlCacheOptions.js';
+import { MongoCacheOptions } from '../options/MongoCacheOptions.js';
+import { MemcacheCacheOptions } from '../options/MemcacheCacheOptions.js';
+/**
+ * The options of one store of a `Cacher`, told apart by their `type`: `'memory'` ({@link MemoryCacheOptions}, the
+ * store of a cache without stores), `'file'` ({@link FileCacheOptions}), `'redis'` ({@link RedisCacheOptions}),
+ * `'memcache'` ({@link MemcacheCacheOptions}), `'mongo'` ({@link MongoCacheOptions}), `'sqlite'`
+ * ({@link SqliteCacheOptions}), `'postgres'` ({@link PostgresCacheOptions}) or `'mysql'` ({@link MysqlCacheOptions}).
+ */
+export type CacheStoreOptions = MemoryCacheOptions | FileCacheOptions | RedisCacheOptions | MemcacheCacheOptions | MongoCacheOptions | SqliteCacheOptions | PostgresCacheOptions | MysqlCacheOptions;

package/dist/cjs/cache/types/CacheStoreOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/exports/Cache.d.ts

@@ -0,0 +1,12 @@
+export * from '../cache/Cacher.js';
+export * from '../cache/interfaces/CacherOptions.js';
+export * from '../cache/options/FileCacheOptions.js';
+export * from '../cache/options/MemoryCacheOptions.js';
+export * from '../cache/options/MemcacheCacheOptions.js';
+export * from '../cache/options/MongoCacheOptions.js';
+export * from '../cache/options/MysqlCacheOptions.js';
+export * from '../cache/options/PostgresCacheOptions.js';
+export * from '../cache/options/RedisCacheOptions.js';
+export * from '../cache/options/SqliteCacheOptions.js';
+export * from '../cache/types/CacheStoreOptions.js';
+export * from '../cache/exceptions/CacheDriverNotFoundException.js';

package/dist/cjs/exports/Cache.js

@@ -0,0 +1,31 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../cache/Cacher.js"), exports);
+__exportStar(require("../cache/interfaces/CacherOptions.js"), exports);
+__exportStar(require("../cache/options/FileCacheOptions.js"), exports);
+__exportStar(require("../cache/options/MemoryCacheOptions.js"), exports);
+__exportStar(require("../cache/options/MemcacheCacheOptions.js"), exports);
+__exportStar(require("../cache/options/MongoCacheOptions.js"), exports);
+__exportStar(require("../cache/options/MysqlCacheOptions.js"), exports);
+__exportStar(require("../cache/options/PostgresCacheOptions.js"), exports);
+__exportStar(require("../cache/options/RedisCacheOptions.js"), exports);
+__exportStar(require("../cache/options/SqliteCacheOptions.js"), exports);
+__exportStar(require("../cache/types/CacheStoreOptions.js"), exports);
+__exportStar(require("../cache/exceptions/CacheDriverNotFoundException.js"), exports);
+
+//The default of the entry: the entry itself (scripts/package-build/cjs-package.mjs)
+if (!Object.prototype.hasOwnProperty.call(exports, 'default')) Object.defineProperty(exports, 'default', {value: exports})

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}