ts-server-lib 0.0.17

package/db/TSRedis.js

@@ -0,0 +1,602 @@
+"use strict";
+/**
+ * TSRedis – Single file for Redis: connection (standalone/Sentinel), events (pub/sub), operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSRedis = void 0;
+const events_1 = require("events");
+const redis_1 = require("redis");
+const TSRequest_1 = require("../utils/TSRequest");
+// ═══════════════════════════════════════════════════════════════════
+// Connection – module state
+// ═══════════════════════════════════════════════════════════════════
+const ERR_PREFIX = 'TSRedis:ERROR';
+function errMsg(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+let client = null;
+let readClient = null;
+/**
+ * Active cluster client. Set ONLY after `clusterClient.connect()` fully resolves —
+ * callers that check this are guaranteed to get a ready, slot-mapped client.
+ */
+let clusterClient = null;
+/** Dedup promise: concurrent calls to connectRedisImpl share one cluster-connect attempt. */
+let _clusterConnectPromise = null;
+const DEFAULT_CONFIG = {
+    connectTimeout: 5000,
+    socketTimeout: 0,
+    autoReconnect: true,
+    maxReconnectRetries: 10,
+    reconnectDelay: 1000,
+    disableOfflineQueue: false,
+};
+function parseRedisUrl(url, envPassword) {
+    const urlMatch = url.match(/^redis:\/\/:([^@]+)@(.+)$/);
+    if (urlMatch) {
+        return { url: `redis://${urlMatch[2]}`, password: urlMatch[1] };
+    }
+    return { url, password: envPassword };
+}
+function buildStandaloneClientOptions(cfg, redisUrl, password) {
+    const clientOptions = {
+        url: redisUrl,
+        socket: {
+            connectTimeout: cfg.connectTimeout,
+            socketTimeout: cfg.socketTimeout || undefined,
+            keepAlive: true,
+            keepAliveInitialDelay: 5000,
+            noDelay: true,
+            reconnectStrategy: cfg.autoReconnect
+                ? (retries) => {
+                    if (retries > cfg.maxReconnectRetries) {
+                        console.error(ERR_PREFIX, 'max reconnect attempts reached');
+                        return new Error('Max reconnect attempts reached');
+                    }
+                    const jitter = Math.floor(Math.random() * 200);
+                    const delay = Math.min(Math.pow(2, retries) * 50, cfg.reconnectDelay || 2000);
+                    return delay + jitter;
+                }
+                : false,
+        },
+        disableOfflineQueue: cfg.disableOfflineQueue,
+    };
+    if (cfg.clientName)
+        clientOptions.name = cfg.clientName;
+    if (cfg.pingInterval)
+        clientOptions.pingInterval = cfg.pingInterval;
+    if (cfg.commandsQueueMaxLength)
+        clientOptions.commandsQueueMaxLength = cfg.commandsQueueMaxLength;
+    if (password)
+        clientOptions.password = password;
+    return clientOptions;
+}
+// ═══════════════════════════════════════════════════════════════════
+// Connection – connect logic (standalone, Sentinel, read replicas)
+// ═══════════════════════════════════════════════════════════════════
+async function connectRedisSentinel(sentinel, cfg) {
+    const sentinelOptions = {
+        sentinels: sentinel.hosts,
+        name: sentinel.name,
+        socket: {
+            connectTimeout: cfg.connectTimeout,
+            reconnectStrategy: cfg.autoReconnect
+                ? (retries) => {
+                    if (retries > cfg.maxReconnectRetries) {
+                        console.error(ERR_PREFIX, 'Sentinel max reconnect attempts reached');
+                        return new Error('Max reconnect attempts reached');
+                    }
+                    return cfg.reconnectDelay;
+                }
+                : false,
+        },
+    };
+    if (sentinel.password)
+        sentinelOptions.sentinelPassword = sentinel.password;
+    const urlMatch = cfg.url.match(/^redis:\/\/:([^@]+)@/);
+    if (urlMatch)
+        sentinelOptions.password = urlMatch[1];
+    else if (process.env.REDIS_PASSWORD)
+        sentinelOptions.password = process.env.REDIS_PASSWORD;
+    client = (0, redis_1.createClient)(sentinelOptions);
+    client.on('error', (err) => console.error(ERR_PREFIX, errMsg(err)));
+    await client.connect();
+    return client;
+}
+async function connectReadReplicas(replicaConfig, cfg) {
+    if (!replicaConfig.urls?.length)
+        return;
+    const { url, password } = parseRedisUrl(replicaConfig.urls[0]);
+    const options = {
+        url,
+        socket: {
+            connectTimeout: cfg.connectTimeout,
+            reconnectStrategy: cfg.autoReconnect
+                ? (retries) => {
+                    if (retries > cfg.maxReconnectRetries)
+                        return new Error('Max reconnect attempts');
+                    return cfg.reconnectDelay;
+                }
+                : false,
+        },
+        readonly: true,
+    };
+    if (password)
+        options.password = password;
+    readClient = (0, redis_1.createClient)(options);
+    readClient.on('error', (err) => console.error(ERR_PREFIX, 'read replica', errMsg(err)));
+    await readClient.connect();
+}
+// ═══════════════════════════════════════════════════════════════════
+// Connection – internal helpers (used by TSRedis static API)
+// ═══════════════════════════════════════════════════════════════════
+async function connectRedisCluster(clusterConfig, cfg) {
+    // Password resolution order: explicit clusterConfig.password → URL-embedded in cfg.url → env var.
+    let password = clusterConfig.password;
+    if (!password) {
+        const urlMatch = cfg.url.match(/^redis:\/\/:([^@]+)@/);
+        if (urlMatch)
+            password = urlMatch[1];
+        else if (process.env.REDIS_PASSWORD)
+            password = process.env.REDIS_PASSWORD;
+    }
+    const reconnectStrategy = cfg.autoReconnect
+        ? (retries) => {
+            if (retries > cfg.maxReconnectRetries) {
+                console.error(ERR_PREFIX, 'Cluster max reconnect attempts reached');
+                return new Error('Max reconnect attempts reached');
+            }
+            const jitter = Math.floor(Math.random() * 200);
+            const delay = Math.min(Math.pow(2, retries) * 50, cfg.reconnectDelay || 2000);
+            return delay + jitter;
+        }
+        : false;
+    // `nodeAddressMap` is passed through verbatim so callers (e.g. host-side validators) can
+    // rewrite cluster-discovered hostnames to client-reachable addresses without touching docker DNS.
+    // Build inline so node-redis's RedisClusterOptions generic stays satisfied (the type
+    // inference depends on the literal object shape — extracting to a typed variable widens it).
+    // Use a local variable: module-level `clusterClient` is set ONLY after connect() resolves
+    // so concurrent callers that check `clusterClient !== null` always get a ready client.
+    const cluster = (0, redis_1.createCluster)({
+        rootNodes: clusterConfig.nodes.map((n) => ({
+            socket: { host: n.host, port: n.port },
+        })),
+        useReplicas: clusterConfig.useReplicas ?? false,
+        defaults: {
+            socket: {
+                connectTimeout: cfg.connectTimeout,
+                keepAlive: true,
+                keepAliveInitialDelay: 5000,
+                noDelay: true,
+                reconnectStrategy,
+            },
+            ...(password ? { password } : {}),
+        },
+        ...(clusterConfig.nodeAddressMap !== undefined
+            ? { nodeAddressMap: clusterConfig.nodeAddressMap }
+            : {}),
+    });
+    cluster.on('error', (err) => console.error(ERR_PREFIX, 'cluster', errMsg(err)));
+    await cluster.connect();
+    clusterClient = cluster; // assign only after full connection + slot discovery
+    return clusterClient;
+}
+async function connectRedisImpl(urlOrConfig) {
+    if (client)
+        return client;
+    if (clusterClient) {
+        // Already connected in cluster mode. Be idempotent: callers like `configureRedisStrategy`
+        // re-invoke `connect()` defensively to ensure a client exists, and we shouldn't punish
+        // legitimate re-entry. The function signature promises `RedisClientType` but `RedisClusterType`
+        // is API-compatible for the basic command surface (set/get/publish/etc.) used by callers
+        // that don't need typed cluster access. Callers needing typed cluster operations should use
+        // `getCluster()` / `getActiveClient()`.
+        return clusterClient;
+    }
+    const config = typeof urlOrConfig === 'string' ? { url: urlOrConfig } : urlOrConfig;
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    if (config.cluster) {
+        // Dedup: concurrent callers share one connect attempt; clusterClient is only set after
+        // connect() fully resolves so nobody gets a not-yet-ready client.
+        if (!_clusterConnectPromise) {
+            _clusterConnectPromise = connectRedisCluster(config.cluster, cfg)
+                .finally(() => { _clusterConnectPromise = null; });
+        }
+        await _clusterConnectPromise;
+        return clusterClient;
+    }
+    if (config.sentinel) {
+        return connectRedisSentinel(config.sentinel, cfg);
+    }
+    const { url: redisUrl, password } = parseRedisUrl(cfg.url, process.env.REDIS_PASSWORD);
+    const clientOptions = buildStandaloneClientOptions(cfg, redisUrl, password);
+    client = (0, redis_1.createClient)(clientOptions);
+    client.on('error', (err) => console.error(ERR_PREFIX, errMsg(err)));
+    await client.connect();
+    if (config.readReplicas?.enabled && config.readReplicas.urls?.length) {
+        await connectReadReplicas(config.readReplicas, cfg);
+    }
+    return client;
+}
+function getRedisImpl() {
+    return client;
+}
+/**
+/** Returns the active cluster client when `connectRedisImpl` was called with `config.cluster`, else null. */
+function getRedisClusterImpl() {
+    return clusterClient;
+}
+/**
+ * Returns whichever client backs the active singleton: standalone, sentinel, or cluster.
+ * Use this when the code path is topology-agnostic (e.g. health checks, GET/SET on a single key).
+ * For multi-key ops you still need to know cluster mode to enforce hash-tag co-location.
+ */
+function getActiveClientImpl() {
+    return clusterClient ?? client;
+}
+function getRedisForReadImpl() {
+    return readClient ?? client;
+}
+function hasReadReplicaImpl() {
+    return readClient !== null;
+}
+async function checkRedisHealthImpl() {
+    const active = clusterClient ?? client;
+    if (!active)
+        return { healthy: false, latencyMs: -1 };
+    const start = Date.now();
+    try {
+        // Both `RedisClientType.ping()` and `RedisClusterType.ping()` exist; cluster pings one node.
+        await active.ping();
+        return { healthy: true, latencyMs: Date.now() - start };
+    }
+    catch {
+        return { healthy: false, latencyMs: -1 };
+    }
+}
+// ═══════════════════════════════════════════════════════════════════
+// Events – pub/sub (internal)
+// ═══════════════════════════════════════════════════════════════════
+async function publishImpl(channel, message) {
+    const active = clusterClient ?? client;
+    if (!active) {
+        console.error(ERR_PREFIX, 'not connected, message not published', channel);
+        return false;
+    }
+    try {
+        // Cluster pub/sub: classic PUBLISH broadcasts to every node (bandwidth amplification).
+        // For per-slot delivery use SPUBLISH/SSUBSCRIBE (Redis 7+, sharded pub/sub).
+        await active.publish(channel, message);
+        return true;
+    }
+    catch (error) {
+        console.error(ERR_PREFIX, 'publish failed', channel, errMsg(error));
+        return false;
+    }
+}
+async function subscribeImpl(channel, handler) {
+    const active = clusterClient ?? client;
+    if (!active)
+        throw new Error('Redis not connected');
+    if (clusterClient) {
+        // Cluster pub/sub: node-redis v4 cluster client manages its own internal subscriber
+        // pool per cluster node. Call subscribe() directly — no duplicate() needed.
+        // Classic PUBLISH broadcasts to all cluster nodes, so the subscriber is reachable
+        // regardless of which node it lands on.
+        await clusterClient.subscribe(channel, handler);
+        return async () => {
+            await clusterClient.unsubscribe(channel);
+        };
+    }
+    // Standalone / sentinel: dedicate a duplicate connection to avoid blocking the main client.
+    const subscriber = client.duplicate();
+    await subscriber.connect();
+    await subscriber.subscribe(channel, handler);
+    return async () => {
+        await subscriber.unsubscribe(channel);
+        await subscriber.quit();
+    };
+}
+// ═══════════════════════════════════════════════════════════════════
+// Scan utilities (internal)
+// ═══════════════════════════════════════════════════════════════════
+/** Drain a single node's scanIterator into the generator, respecting maxKeys cap. */
+async function* _yieldBatches(iterator, maxKeys, yielded) {
+    for await (const keysBatch of iterator) {
+        for (const key of keysBatch) {
+            if (maxKeys > 0 && yielded.count >= maxKeys)
+                return;
+            yield key;
+            yielded.count++;
+        }
+    }
+}
+async function* scanKeysIteratorImpl(options = {}) {
+    const { pattern = '*', maxKeys = 10000, batchSize = 100 } = options;
+    const yielded = { count: 0 };
+    if (clusterClient && !client) {
+        for (const master of clusterClient.masters) {
+            const nodeClient = master.client;
+            if (!nodeClient || !nodeClient.isReady)
+                continue;
+            try {
+                yield* _yieldBatches(nodeClient.scanIterator({ MATCH: pattern, COUNT: batchSize }), maxKeys, yielded);
+            }
+            catch {
+                // Shard unreachable — skip; L1 cleared, TTL handles L2 expiry.
+            }
+            if (maxKeys > 0 && yielded.count >= maxKeys)
+                return;
+        }
+        return;
+    }
+    // Standalone / sentinel: scanIterator yields string[] batches (one array per SCAN cursor step).
+    if (!client)
+        return;
+    yield* _yieldBatches(client.scanIterator({ MATCH: pattern, COUNT: batchSize }), maxKeys, yielded);
+}
+async function batchGetValuesImpl(keys) {
+    // Per-key GET so keys can span different cluster slots.
+    const redis = getActiveClientImpl();
+    if (!redis || keys.length === 0)
+        return {};
+    const values = await Promise.all(keys.map(k => redis.get(k)));
+    const result = {};
+    for (let i = 0; i < keys.length; i++)
+        result[keys[i]] = values[i] ?? null;
+    return result;
+}
+// ═══════════════════════════════════════════════════════════════════
+// Lifecycle (internal)
+// ═══════════════════════════════════════════════════════════════════
+async function closeRedisImpl() {
+    if (readClient) {
+        try {
+            await readClient.quit();
+            readClient = null;
+        }
+        catch (error) {
+            console.error(ERR_PREFIX, 'close read replica', errMsg(error));
+        }
+    }
+    if (clusterClient) {
+        try {
+            await clusterClient.quit();
+        }
+        catch (error) {
+            console.error(ERR_PREFIX, 'close cluster', errMsg(error));
+        }
+        clusterClient = null;
+    }
+    if (client) {
+        await client.quit();
+        client = null;
+    }
+}
+function getRedisConnectionStatsImpl() {
+    if (clusterClient) {
+        // Cluster mode: replica routing is handled internally by node-redis when `useReplicas`
+        // is true; we surface `hasReadReplica = true` to keep observability uniform with the
+        // standalone+readClient story. Per-node connection counts would require introspecting
+        // the cluster's slot map and are intentionally left out of this lightweight snapshot.
+        return {
+            connected: true,
+            mode: 'cluster',
+            hasReadReplica: true,
+            master: { connected: true },
+            replica: { connected: true, count: 1 },
+        };
+    }
+    return {
+        connected: client !== null,
+        mode: 'standalone',
+        hasReadReplica: readClient !== null,
+        master: { connected: client !== null },
+        replica: { connected: readClient !== null, count: readClient ? 1 : 0 },
+    };
+}
+// ═══════════════════════════════════════════════════════════════════
+// TSRedis – static API (connect, pub/sub, scan) + instance ops
+// ═══════════════════════════════════════════════════════════════════
+class TSRedis extends events_1.EventEmitter {
+    redis;
+    constructor(instance) {
+        super();
+        this.redis = instance;
+    }
+    /** Connect (standalone, Sentinel, Cluster, or with read replicas). Cluster is selected
+     * when the supplied `RedisConfig.cluster` is set; otherwise sentinel / standalone per
+     * the existing precedence rules. */
+    static connect = connectRedisImpl;
+    /** Standalone / sentinel client singleton. Returns null in cluster mode — use {@link getCluster}. */
+    static getClient = getRedisImpl;
+    /** Active cluster client. Returns null when not in cluster mode. */
+    static getCluster = getRedisClusterImpl;
+    /** Topology-agnostic accessor — returns the active client (standalone / sentinel / cluster). */
+    static getActiveClient = getActiveClientImpl;
+    static getClientForRead = getRedisForReadImpl;
+    static hasReadReplica = hasReadReplicaImpl;
+    static close = closeRedisImpl;
+    static checkHealth = checkRedisHealthImpl;
+    static getConnectionStats = getRedisConnectionStatsImpl;
+    static publish = publishImpl;
+    static subscribe = subscribeImpl;
+    static scanKeysIterator = scanKeysIteratorImpl;
+    static batchGetValues = batchGetValuesImpl;
+    async cachedRequest(options, defaultValue = {}, debug) {
+        if (!options.getData) {
+            options.getData = (response) => response;
+        }
+        const { url, key, ...requestOptions } = options;
+        const result = await this.redis.get(key);
+        if (result) {
+            return JSON.parse(result);
+        }
+        else {
+            const response = await TSRequest_1.TSRequest.json(url, { ...requestOptions, method: (options.method || 'post') }, debug);
+            const data = options.getData(response);
+            if (data) {
+                let value = this.pathToStore(options.pathValue || [], data);
+                value = options.format && typeof options.format === 'function'
+                    ? options.format(value)
+                    : value;
+                if (value) {
+                    await this.redis.setEx(key, options.expire || 300, JSON.stringify(value));
+                    return value;
+                }
+                else {
+                    return defaultValue;
+                }
+            }
+            else {
+                console.error(response);
+                return defaultValue;
+            }
+        }
+    }
+    pathToStore(keys = [], object) {
+        let current = object;
+        let value = object;
+        for (const i in keys) {
+            if (Object.prototype.hasOwnProperty.call(keys, i) && current && typeof current === 'object' && current[keys[i]]) {
+                value = current[keys[i]];
+                current = value;
+            }
+            else {
+                value = undefined;
+                break;
+            }
+        }
+        return value;
+    }
+    cached = async (path, options) => {
+        const result = await this.redis.get(path);
+        if (result)
+            return result;
+        if (options?.value) {
+            await this.redis.setEx(path, options.expire || 3600, options.value);
+            return options.value;
+        }
+    };
+    load = async (entity) => {
+        const result = await this.redis.hGetAll(entity);
+        const mappedResult = [];
+        Object.keys(result || {}).map((k) => mappedResult.push(JSON.parse(result[k])));
+        return mappedResult;
+    };
+    get = async (key, cb) => {
+        const result = await this.redis.get(key);
+        return cb ? cb(result) : result;
+    };
+    set = async (key, data) => (await this.redis.set(key, String(data))) === 'OK';
+    hget = async (key, field) => {
+        const result = await this.redis.hGet(key, field);
+        return result ? JSON.parse(result) : null;
+    };
+    getM = async (entity, keys) => this.redis.hmGet(entity, keys);
+    hgetall = async (key, cb) => {
+        const result = await this.redis.hGetAll(key);
+        return cb ? cb(result) : result;
+    };
+    hset = async (key, field, data) => {
+        if (typeof data !== 'undefined' && data !== null && String(data).length > 0) {
+            return (await this.redis.hSet(key, field, JSON.stringify(data))) >= 0;
+        }
+        return false;
+    };
+    hdel = async (key, fields) => (await this.redis.hDel(key, fields)) > 0;
+    del = async (keys) => {
+        const ks = Array.isArray(keys) ? keys : [keys];
+        if (ks.length === 0)
+            return false;
+        // Per-key DEL: cluster mode rejects multi-key DEL across slots (CROSSSLOT).
+        const counts = await Promise.all(ks.map(k => this.redis.del(k)));
+        return counts.some(c => c > 0);
+    };
+    loadLists = async (pattern = '*') => {
+        const list = await this.scanr({ pattern });
+        const result = {};
+        if (list.length === 0)
+            return result;
+        // Per-key TYPE: cluster multi() across different slots causes CROSSSLOT.
+        const types = await Promise.all(list.map(k => this.redis.type(k).catch(() => 'none')));
+        const hashKeys = [];
+        const hashScopes = [];
+        for (let i = 0; i < list.length; i++) {
+            if (String(types[i]) === 'hash') {
+                hashKeys.push(list[i]);
+                hashScopes.push(list[i].split(':').pop());
+            }
+        }
+        if (hashKeys.length === 0)
+            return result;
+        // Per-key hGetAll: cluster multi() across slots causes CROSSSLOT.
+        const hashResults = await Promise.all(hashKeys.map(k => this.redis.hGetAll(k).catch(() => ({}))));
+        for (let j = 0; j < hashScopes.length; j++) {
+            const val = hashResults[j];
+            result[hashScopes[j]] = (val != null && typeof val === 'object') ? val : {};
+        }
+        return result;
+    };
+    hscanr = async (entity, { pattern, COUNT = 200 }, cb) => {
+        const MATCH = this.match(pattern ?? '*');
+        const results = {};
+        let cursor = '0';
+        let entries;
+        do {
+            ({ cursor, entries } = await this.redis.hScan(entity, cursor, { COUNT, MATCH }));
+            for (let i = 0; i < entries.length; i++) {
+                if (this.check(entries[i].value, pattern ?? '*')) {
+                    if (cb)
+                        cb(JSON.parse(entries[i].value), entries[i].field);
+                    else
+                        results[entries[i].field] = JSON.parse(entries[i].value);
+                }
+            }
+        } while (cursor !== '0');
+        return results;
+    };
+    zscanr = async (entity, { pattern, COUNT = 200 }, cb = (value, score) => ({ value, score })) => {
+        const MATCH = this.match(pattern ?? '*');
+        const results = [];
+        let cursor = '0';
+        let members;
+        do {
+            ({ cursor, members } = await this.redis.zScan(entity, cursor, { COUNT, MATCH }));
+            for (let i = 0; i < members.length; i++) {
+                if (this.check(members[i].value, pattern ?? '*')) {
+                    const data = cb(members[i].value, String(members[i].score));
+                    if (typeof data !== 'undefined')
+                        results.push(data);
+                }
+            }
+        } while (cursor !== '0');
+        return results;
+    };
+    scanr = async ({ pattern, COUNT = 200 }, cb) => {
+        // Use the cluster-aware scanKeysIterator so all shards are covered.
+        const results = [];
+        for await (const key of scanKeysIteratorImpl({ pattern: this.match(pattern ?? '*'), maxKeys: COUNT * 500 })) {
+            if (!this.check(key, pattern ?? '*'))
+                continue;
+            if (cb)
+                cb([key]);
+            else
+                results.push(key);
+        }
+        return results;
+    };
+    static _regexCache = new Map();
+    check = (value, pattern) => {
+        if (typeof pattern !== 'object' || !pattern.text)
+            return true;
+        let re = TSRedis._regexCache.get(pattern.text);
+        if (!re) {
+            re = new RegExp(pattern.text, 'i');
+            TSRedis._regexCache.set(pattern.text, re);
+        }
+        return value.search(re) > -1;
+    };
+    match = (pattern) => (typeof pattern === 'string' ? pattern : (pattern.match ?? '*'));
+}
+exports.TSRedis = TSRedis;

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "ts-server-lib",
+  "version": "0.0.17",
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "postpublish": "npm run clean:artifacts",
+    "build": "tsc --declaration -p .",
+    "watch": "tsc -w --declaration -p .",
+    "clean:artifacts": "node -e \"const fs=require('fs'),path=require('path');const root=process.cwd();for(const rel of ['db','ussd','ussd/providers','utils','ws']){const dir=path.join(root,rel);let n;try{n=fs.readdirSync(dir)}catch{continue}for(const name of n){if(!name.endsWith('.d.ts')&&path.extname(name)!=='.js')continue;const fp=path.join(dir,name);try{if(fs.statSync(fp).isFile())fs.unlinkSync(fp)}catch{}}}\"",
+    "clean:deps": "node -e \"for(const p of ['coverage','node_modules','package-lock.json'])try{require('fs').rmSync(p,{recursive:true,force:true})}catch{}\"",
+    "clean": "npm run clean:artifacts && npm run clean:deps",
+    "lint": "eslint . --fix --ignore-pattern \"**/*.d.ts\"",
+    "test": "npm run build && vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/onalbi/ts-server-lib"
+  },
+  "author": {
+    "name": "Albion Liçi",
+    "email": "lici.albion@gmail.com"
+  },
+  "keywords": [
+    "typescript",
+    "server"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/onalbi/ts-server-lib/issues"
+  },
+  "files": [
+    "db/**/*.{js,d.ts}",
+    "utils/**/*.{js,d.ts}",
+    "ussd/**/*.{js,d.ts}",
+    "utils/mime.json"
+  ],
+  "dependencies": {
+    "cron": "^4.4.0",
+    "fast-xml-parser": "^5.8.0",
+    "i18n": "^0.15.3",
+    "mongodb": "^7.2.0",
+    "redis": "^6.0.0",
+    "ts-common-lib": "^0.0.6"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "vitest": {
+    "globals": true,
+    "environment": "node",
+    "include": [
+      "test/**/*.spec.ts"
+    ],
+    "exclude": [
+      "**/*.spec.js",
+      "**/node_modules/**"
+    ],
+    "resolve": {
+      "extensions": [
+        ".ts",
+        ".tsx",
+        ".mts",
+        ".cts",
+        ".js",
+        ".mjs",
+        ".jsx",
+        ".json"
+      ]
+    },
+    "coverage": {
+      "provider": "v8",
+      "include": [
+        "db/**/*.ts",
+        "ussd/**/*.ts",
+        "utils/**/*.ts"
+      ],
+      "reporter": [
+        "text",
+        "lcov"
+      ]
+    }
+  }
+}