ts-packages 1.0.0 → 2.0.0

package/packages/cache/dist/cjs/adapters/memory/MemoryCache.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCache = void 0;
+const BaseCache_1 = require("../../core/BaseCache");
+const errors_1 = require("../../errors");
+/**
+ * In-memory cache adapter for development and testing
+ */
+class MemoryCache extends BaseCache_1.BaseCache {
+    constructor(memoryCacheConfig) {
+        super(memoryCacheConfig);
+        this.memoryCacheConfig = memoryCacheConfig;
+        this.store = new Map();
+        this.cleanupInterval = null;
+        this.startCleanup();
+    }
+    /**
+     * Start periodic cleanup of expired items
+     */
+    startCleanup() {
+        if (this.cleanupInterval)
+            return;
+        this.cleanupInterval = setInterval(() => {
+            const now = Date.now();
+            for (const [key, entry] of this.store.entries()) {
+                if (entry.expiresAt && entry.expiresAt < now) {
+                    this.store.delete(key);
+                }
+            }
+        }, 30000); // Cleanup every 30 seconds
+    }
+    /**
+     * Get a value from memory
+     */
+    async get(key) {
+        try {
+            const fullKey = this.buildKey(key);
+            const entry = this.store.get(fullKey);
+            if (!entry) {
+                this.recordMiss();
+                return null;
+            }
+            // Check if expired
+            if (entry.expiresAt && entry.expiresAt < Date.now()) {
+                this.store.delete(fullKey);
+                this.recordMiss();
+                return null;
+            }
+            this.recordHit();
+            return entry.value;
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to get key "${key}" from memory cache`, 'MEMORY_GET_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Set a value in memory
+     */
+    async set(key, value, ttl) {
+        try {
+            const fullKey = this.buildKey(key);
+            const expiry = ttl ?? this.ttl;
+            const expiresAt = expiry > 0 ? Date.now() + expiry * 1000 : undefined;
+            // Check max size
+            const maxSize = this.memoryCacheConfig.maxSize;
+            if (maxSize && this.store.size >= maxSize && !this.store.has(fullKey)) {
+                // Remove oldest entry
+                const firstKey = this.store.keys().next().value;
+                if (firstKey) {
+                    this.store.delete(firstKey);
+                }
+            }
+            this.store.set(fullKey, { value, expiresAt });
+            this.recordSet();
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to set key "${key}" in memory cache`, 'MEMORY_SET_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Delete a key from memory
+     */
+    async delete(key) {
+        try {
+            const fullKey = this.buildKey(key);
+            const deleted = this.store.delete(fullKey);
+            if (deleted) {
+                this.recordDelete();
+            }
+            return deleted;
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to delete key "${key}" from memory cache`, 'MEMORY_DELETE_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Check if key exists
+     */
+    async exists(key) {
+        try {
+            const fullKey = this.buildKey(key);
+            const entry = this.store.get(fullKey);
+            if (!entry) {
+                return false;
+            }
+            // Check if expired
+            if (entry.expiresAt && entry.expiresAt < Date.now()) {
+                this.store.delete(fullKey);
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to check existence of key "${key}" in memory cache`, 'MEMORY_EXISTS_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Clear all keys with current namespace
+     */
+    async clear() {
+        try {
+            if (this.namespace) {
+                // Clear only keys with current namespace
+                for (const key of this.store.keys()) {
+                    if (key.startsWith(this.namespace)) {
+                        this.store.delete(key);
+                    }
+                }
+            }
+            else {
+                // Clear all
+                this.store.clear();
+            }
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to clear memory cache', 'MEMORY_CLEAR_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Get multiple values at once
+     */
+    async getMultiple(keys) {
+        try {
+            const result = {};
+            const now = Date.now();
+            for (const key of keys) {
+                const fullKey = this.buildKey(key);
+                const entry = this.store.get(fullKey);
+                if (!entry) {
+                    this.recordMiss();
+                    result[key] = null;
+                    continue;
+                }
+                // Check if expired
+                if (entry.expiresAt && entry.expiresAt < now) {
+                    this.store.delete(fullKey);
+                    this.recordMiss();
+                    result[key] = null;
+                }
+                else {
+                    this.recordHit();
+                    result[key] = entry.value;
+                }
+            }
+            return result;
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to get multiple keys from memory cache', 'MEMORY_GET_MULTIPLE_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Set multiple values at once
+     */
+    async setMultiple(data, ttl) {
+        try {
+            const expiry = ttl ?? this.ttl;
+            const expiresAt = expiry > 0 ? Date.now() + expiry * 1000 : undefined;
+            for (const [key, value] of Object.entries(data)) {
+                const fullKey = this.buildKey(key);
+                this.store.set(fullKey, { value, expiresAt });
+            }
+            this.stats.sets += Object.keys(data).length;
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to set multiple keys in memory cache', 'MEMORY_SET_MULTIPLE_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Delete multiple keys at once
+     */
+    async deleteMultiple(keys) {
+        try {
+            let count = 0;
+            for (const key of keys) {
+                const fullKey = this.buildKey(key);
+                if (this.store.delete(fullKey)) {
+                    count++;
+                }
+            }
+            this.stats.deletes += count;
+            return count;
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to delete multiple keys from memory cache', 'MEMORY_DELETE_MULTIPLE_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Increment a numeric value
+     */
+    async increment(key, amount = 1) {
+        try {
+            const fullKey = this.buildKey(key);
+            const entry = this.store.get(fullKey);
+            const current = entry && (!entry.expiresAt || entry.expiresAt >= Date.now())
+                ? typeof entry.value === 'number'
+                    ? entry.value
+                    : 0
+                : 0;
+            const value = current + amount;
+            const expiry = this.ttl;
+            const expiresAt = expiry > 0 ? Date.now() + expiry * 1000 : undefined;
+            this.store.set(fullKey, { value: value, expiresAt });
+            return value;
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to increment key "${key}" in memory cache`, 'MEMORY_INCREMENT_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Decrement a numeric value
+     */
+    async decrement(key, amount = 1) {
+        try {
+            const fullKey = this.buildKey(key);
+            const entry = this.store.get(fullKey);
+            const current = entry && (!entry.expiresAt || entry.expiresAt >= Date.now())
+                ? typeof entry.value === 'number'
+                    ? entry.value
+                    : 0
+                : 0;
+            const value = current - amount;
+            const expiry = this.ttl;
+            const expiresAt = expiry > 0 ? Date.now() + expiry * 1000 : undefined;
+            this.store.set(fullKey, { value: value, expiresAt });
+            return value;
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to decrement key "${key}" in memory cache`, 'MEMORY_DECREMENT_ERROR', 'memory', err);
+        }
+    }
+    /**
+     * Check if memory cache is alive
+     */
+    async isAlive() {
+        return {
+            isAlive: true,
+            adapter: 'memory',
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Close memory cache
+     */
+    async close() {
+        try {
+            if (this.cleanupInterval) {
+                clearInterval(this.cleanupInterval);
+                this.cleanupInterval = null;
+            }
+            this.store.clear();
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to close memory cache', 'MEMORY_CLOSE_ERROR', 'memory', err);
+        }
+    }
+}
+exports.MemoryCache = MemoryCache;

package/packages/cache/dist/cjs/adapters/memory/index.d.ts

@@ -0,0 +1 @@
+export { MemoryCache } from './MemoryCache';

package/packages/cache/dist/cjs/adapters/memory/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCache = void 0;
+var MemoryCache_1 = require("./MemoryCache");
+Object.defineProperty(exports, "MemoryCache", { enumerable: true, get: function () { return MemoryCache_1.MemoryCache; } });

package/packages/cache/dist/cjs/adapters/redis/RedisCache.d.ts

@@ -0,0 +1,67 @@
+import { BaseCache } from '../../core/BaseCache';
+import type { HealthCheckResponse, RedisCacheConfig } from '../../types';
+/**
+ * Redis cache adapter
+ */
+export declare class RedisCache<T = unknown> extends BaseCache<T> {
+    private redisConfig;
+    private client;
+    private isConnected;
+    constructor(redisConfig: RedisCacheConfig);
+    /**
+     * Connect to Redis
+     */
+    connect(): Promise<void>;
+    /**
+     * Ensure client is connected
+     */
+    private ensureConnected;
+    /**
+     * Get a value from Redis
+     */
+    get(key: string): Promise<T | null>;
+    /**
+     * Set a value in Redis
+     */
+    set(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Delete a key from Redis
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Check if key exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Clear all keys with current namespace
+     */
+    clear(): Promise<void>;
+    /**
+     * Get multiple values at once
+     */
+    getMultiple(keys: string[]): Promise<Record<string, T | null>>;
+    /**
+     * Set multiple values at once
+     */
+    setMultiple(data: Record<string, T>, ttl?: number): Promise<void>;
+    /**
+     * Delete multiple keys at once
+     */
+    deleteMultiple(keys: string[]): Promise<number>;
+    /**
+     * Increment a numeric value
+     */
+    increment(key: string, amount?: number): Promise<number>;
+    /**
+     * Decrement a numeric value
+     */
+    decrement(key: string, amount?: number): Promise<number>;
+    /**
+     * Check if Redis is alive
+     */
+    isAlive(): Promise<HealthCheckResponse>;
+    /**
+     * Close Redis connection
+     */
+    close(): Promise<void>;
+}

package/packages/cache/dist/cjs/adapters/redis/RedisCache.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCache = void 0;
+const redis_1 = require("redis");
+const BaseCache_1 = require("../../core/BaseCache");
+const errors_1 = require("../../errors");
+/**
+ * Redis cache adapter
+ */
+class RedisCache extends BaseCache_1.BaseCache {
+    constructor(redisConfig) {
+        super(redisConfig);
+        this.redisConfig = redisConfig;
+        this.client = null;
+        this.isConnected = false;
+    }
+    /**
+     * Connect to Redis
+     */
+    async connect() {
+        try {
+            const cluster = this.redisConfig.cluster;
+            const hasCluster = cluster &&
+                (Array.isArray(cluster)
+                    ? cluster.length > 0
+                    : cluster.nodes?.length > 0);
+            if (hasCluster && cluster) {
+                // Cluster mode
+                let nodes = [];
+                if (Array.isArray(cluster)) {
+                    nodes = cluster;
+                }
+                else {
+                    nodes = cluster.nodes;
+                }
+                this.client = (0, redis_1.createCluster)({
+                    rootNodes: nodes.map((node) => ({
+                        url: `redis://${node.host}:${node.port}`,
+                    })),
+                });
+            }
+            else {
+                // Single instance mode
+                const options = {
+                    host: this.redisConfig.host ?? 'localhost',
+                    port: this.redisConfig.port ?? 6379,
+                    db: this.redisConfig.db ?? 0,
+                };
+                if (this.redisConfig.username) {
+                    options.username = this.redisConfig.username;
+                }
+                if (this.redisConfig.password) {
+                    options.password = this.redisConfig.password;
+                }
+                if (this.redisConfig.tls) {
+                    options.tls = true;
+                }
+                this.client = (0, redis_1.createClient)(options);
+            }
+            if (this.client) {
+                this.client.on('error', (err) => {
+                    this.isConnected = false;
+                    console.error('Redis connection error:', err);
+                });
+                this.client.on('connect', () => {
+                    this.isConnected = true;
+                });
+                await this.client.connect();
+                this.isConnected = true;
+            }
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to connect to Redis', 'REDIS_CONNECTION_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Ensure client is connected
+     */
+    async ensureConnected() {
+        if (!this.client) {
+            await this.connect();
+        }
+    }
+    /**
+     * Get a value from Redis
+     */
+    async get(key) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            const value = await this.client.get(fullKey);
+            if (value === null) {
+                this.recordMiss();
+                return null;
+            }
+            this.recordHit();
+            return this.deserialize(value);
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to get key "${key}" from Redis`, 'REDIS_GET_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Set a value in Redis
+     */
+    async set(key, value, ttl) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            const serialized = this.serialize(value);
+            const expiry = ttl ?? this.ttl;
+            if (expiry > 0) {
+                await this.client.setEx(fullKey, expiry, serialized);
+            }
+            else {
+                await this.client.set(fullKey, serialized);
+            }
+            this.recordSet();
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to set key "${key}" in Redis`, 'REDIS_SET_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Delete a key from Redis
+     */
+    async delete(key) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            const result = await this.client.del(fullKey);
+            this.recordDelete();
+            return result > 0;
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to delete key "${key}" from Redis`, 'REDIS_DELETE_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Check if key exists
+     */
+    async exists(key) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            const result = await this.client.exists(fullKey);
+            return result > 0;
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to check existence of key "${key}" in Redis`, 'REDIS_EXISTS_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Clear all keys with current namespace
+     */
+    async clear() {
+        try {
+            await this.ensureConnected();
+            if (this.namespace) {
+                // For cluster mode, we can't use FLUSHDB, so we skip clearing in cluster
+                // In production, use explicit key tracking or Redis ACL scoping
+                console.warn('Cluster mode: namespace clear requires explicit key tracking');
+            }
+            else {
+                // Clear all keys only in single-instance mode
+                const client = this.client;
+                if (client && typeof client.flushDb === 'function') {
+                    await client.flushDb();
+                }
+                else {
+                    console.warn('Clear operation not supported in cluster mode');
+                }
+            }
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to clear Redis cache', 'REDIS_CLEAR_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Get multiple values at once
+     */
+    async getMultiple(keys) {
+        try {
+            await this.ensureConnected();
+            const fullKeys = keys.map((k) => this.buildKey(k));
+            const values = await this.client.mGet(fullKeys);
+            const result = {};
+            keys.forEach((key, index) => {
+                const value = values[index];
+                if (value === null) {
+                    this.recordMiss();
+                    result[key] = null;
+                }
+                else {
+                    this.recordHit();
+                    result[key] = this.deserialize(value);
+                }
+            });
+            return result;
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to get multiple keys from Redis', 'REDIS_GET_MULTIPLE_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Set multiple values at once
+     */
+    async setMultiple(data, ttl) {
+        try {
+            await this.ensureConnected();
+            const expiry = ttl ?? this.ttl;
+            if (expiry > 0) {
+                // Use pipeline for batch operations with TTL
+                const pipeline = this.client.multi();
+                for (const [key, value] of Object.entries(data)) {
+                    const fullKey = this.buildKey(key);
+                    const serialized = this.serialize(value);
+                    pipeline.setEx(fullKey, expiry, serialized);
+                }
+                await pipeline.exec();
+            }
+            else {
+                // Use mSet for batch operations without TTL
+                const flatData = {};
+                for (const [key, value] of Object.entries(data)) {
+                    const fullKey = this.buildKey(key);
+                    flatData[fullKey] = this.serialize(value);
+                }
+                await this.client.mSet(flatData);
+            }
+            this.stats.sets += Object.keys(data).length;
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to set multiple keys in Redis', 'REDIS_SET_MULTIPLE_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Delete multiple keys at once
+     */
+    async deleteMultiple(keys) {
+        try {
+            await this.ensureConnected();
+            const fullKeys = keys.map((k) => this.buildKey(k));
+            const result = await this.client.del(fullKeys);
+            this.stats.deletes += result;
+            return result;
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to delete multiple keys from Redis', 'REDIS_DELETE_MULTIPLE_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Increment a numeric value
+     */
+    async increment(key, amount = 1) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            return await this.client.incrBy(fullKey, amount);
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to increment key "${key}" in Redis`, 'REDIS_INCREMENT_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Decrement a numeric value
+     */
+    async decrement(key, amount = 1) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            return await this.client.decrBy(fullKey, amount);
+        }
+        catch (err) {
+            throw new errors_1.CacheError(`Failed to decrement key "${key}" in Redis`, 'REDIS_DECREMENT_ERROR', 'redis', err);
+        }
+    }
+    /**
+     * Check if Redis is alive
+     */
+    async isAlive() {
+        try {
+            await this.ensureConnected();
+            // Use sendCommand which works for both single and cluster
+            // `sendCommand` exists on both single and cluster clients in runtime; cast narrowly for the call
+            if (this.client &&
+                typeof this.client.sendCommand === 'function') {
+                await this.client.sendCommand(['PING']);
+            }
+            else if (this.client &&
+                typeof this.client.ping === 'function') {
+                await this.client.ping();
+            }
+            return {
+                isAlive: true,
+                adapter: 'redis',
+                timestamp: new Date(),
+            };
+        }
+        catch (err) {
+            return {
+                isAlive: false,
+                adapter: 'redis',
+                timestamp: new Date(),
+                error: err.message,
+            };
+        }
+    }
+    /**
+     * Close Redis connection
+     */
+    async close() {
+        try {
+            if (this.client && this.isConnected) {
+                await this.client.quit();
+                this.isConnected = false;
+                this.client = null;
+            }
+        }
+        catch (err) {
+            throw new errors_1.CacheError('Failed to close Redis connection', 'REDIS_CLOSE_ERROR', 'redis', err);
+        }
+    }
+}
+exports.RedisCache = RedisCache;

package/packages/cache/dist/cjs/adapters/redis/index.d.ts

@@ -0,0 +1 @@
+export { RedisCache } from './RedisCache';

package/packages/cache/dist/cjs/adapters/redis/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCache = void 0;
+var RedisCache_1 = require("./RedisCache");
+Object.defineProperty(exports, "RedisCache", { enumerable: true, get: function () { return RedisCache_1.RedisCache; } });