@quanticjs/redis 2.0.0

package/dist/CacheBehavior.d.ts

@@ -0,0 +1,11 @@
+import { Result, PipelineBehavior, PipelineScope } from '@quanticjs/core';
+import type { Redis } from 'ioredis';
+export declare class CacheBehavior implements PipelineBehavior {
+    private readonly redis?;
+    readonly order: 60;
+    readonly scope: PipelineScope;
+    private readonly logger;
+    constructor(redis?: Redis | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+    private interpolateKey;
+}

package/dist/CacheBehavior.js

@@ -0,0 +1,68 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var CacheBehavior_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@quanticjs/core");
+let CacheBehavior = CacheBehavior_1 = class CacheBehavior {
+    redis;
+    order = core_1.BehaviorOrder.CACHE;
+    scope = 'both';
+    logger = new common_1.Logger(CacheBehavior_1.name);
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async execute(command, next) {
+        const metadata = (0, core_1.getCacheMetadata)(command.constructor);
+        if (!metadata || !this.redis) {
+            return next();
+        }
+        const cacheKey = this.interpolateKey(metadata.key, command);
+        try {
+            const cached = await this.redis.get(cacheKey);
+            if (cached) {
+                this.logger.debug(`Cache hit: ${cacheKey}`);
+                return core_1.Result.success(JSON.parse(cached));
+            }
+        }
+        catch {
+            this.logger.warn(`Cache read failed for key: ${cacheKey}`);
+        }
+        const result = await next();
+        if (result.isSuccess && result.value !== undefined) {
+            try {
+                await this.redis.set(cacheKey, JSON.stringify(result.value), 'EX', metadata.ttlSeconds);
+                this.logger.debug(`Cache set: ${cacheKey} (TTL: ${metadata.ttlSeconds}s)`);
+            }
+            catch {
+                this.logger.warn(`Cache write failed for key: ${cacheKey}`);
+            }
+        }
+        return result;
+    }
+    interpolateKey(template, command) {
+        return template.replace(/\{(\w+)\}/g, (_, prop) => {
+            const value = command[prop];
+            return value != null ? String(value) : '';
+        });
+    }
+};
+exports.CacheBehavior = CacheBehavior;
+exports.CacheBehavior = CacheBehavior = CacheBehavior_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(core_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], CacheBehavior);

package/dist/DistributedLockBehavior.d.ts

@@ -0,0 +1,14 @@
+import { Result, PipelineBehavior, PipelineScope } from '@quanticjs/core';
+import type { Redis } from 'ioredis';
+export declare class DistributedLockBehavior implements PipelineBehavior {
+    private readonly redis?;
+    readonly order: 70;
+    readonly scope: PipelineScope;
+    private readonly logger;
+    constructor(redis?: Redis | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+    private tryAcquire;
+    private release;
+    private sleep;
+    private interpolateKey;
+}

package/dist/DistributedLockBehavior.js

@@ -0,0 +1,89 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var DistributedLockBehavior_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedLockBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@quanticjs/core");
+const uuid_1 = require("uuid");
+let DistributedLockBehavior = DistributedLockBehavior_1 = class DistributedLockBehavior {
+    redis;
+    order = core_1.BehaviorOrder.DISTRIBUTED_LOCK;
+    scope = 'command';
+    logger = new common_1.Logger(DistributedLockBehavior_1.name);
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async execute(command, next) {
+        const metadata = (0, core_1.getDistributedLockMetadata)(command.constructor);
+        if (!metadata || !this.redis) {
+            return next();
+        }
+        const lockKey = `lock:${this.interpolateKey(metadata.key, command)}`;
+        const lockValue = (0, uuid_1.v4)();
+        const acquired = await this.tryAcquire(lockKey, lockValue, metadata.lockTtlSeconds, metadata.acquireTimeoutSeconds);
+        if (!acquired) {
+            this.logger.warn(`Failed to acquire lock: ${lockKey}`);
+            return core_1.Result.failure(core_1.ErrorType.Conflict, `Resource is locked: ${metadata.key}`);
+        }
+        try {
+            return await next();
+        }
+        finally {
+            await this.release(lockKey, lockValue);
+        }
+    }
+    async tryAcquire(key, value, ttlSeconds, timeoutSeconds) {
+        const deadline = Date.now() + timeoutSeconds * 1000;
+        const retryDelay = 50;
+        while (Date.now() < deadline) {
+            const result = await this.redis.set(key, value, 'EX', ttlSeconds, 'NX');
+            if (result === 'OK')
+                return true;
+            await this.sleep(retryDelay);
+        }
+        return false;
+    }
+    async release(key, value) {
+        const script = `
+      if redis.call("get", KEYS[1]) == ARGV[1] then
+        return redis.call("del", KEYS[1])
+      else
+        return 0
+      end
+    `;
+        try {
+            await this.redis.eval(script, 1, key, value);
+        }
+        catch {
+            this.logger.warn(`Failed to release lock: ${key}`);
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    interpolateKey(template, command) {
+        return template.replace(/\{(\w+)\}/g, (_, prop) => {
+            const value = command[prop];
+            return value != null ? String(value) : '';
+        });
+    }
+};
+exports.DistributedLockBehavior = DistributedLockBehavior;
+exports.DistributedLockBehavior = DistributedLockBehavior = DistributedLockBehavior_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(core_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], DistributedLockBehavior);

package/dist/InvalidateCacheBehavior.d.ts

@@ -0,0 +1,11 @@
+import { Result, PipelineBehavior, PipelineScope } from '@quanticjs/core';
+import type { Redis } from 'ioredis';
+export declare class InvalidateCacheBehavior implements PipelineBehavior {
+    private readonly redis?;
+    readonly order: 5;
+    readonly scope: PipelineScope;
+    private readonly logger;
+    constructor(redis?: Redis | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+    private interpolateKey;
+}

package/dist/InvalidateCacheBehavior.js

@@ -0,0 +1,62 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var InvalidateCacheBehavior_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidateCacheBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@quanticjs/core");
+let InvalidateCacheBehavior = InvalidateCacheBehavior_1 = class InvalidateCacheBehavior {
+    redis;
+    order = core_1.BehaviorOrder.INVALIDATE_CACHE;
+    scope = 'command';
+    logger = new common_1.Logger(InvalidateCacheBehavior_1.name);
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async execute(command, next) {
+        const metadata = (0, core_1.getInvalidateCacheMetadata)(command.constructor);
+        if (!metadata || !this.redis) {
+            return next();
+        }
+        const result = await next();
+        if (!result.isSuccess) {
+            return result;
+        }
+        const resolvedKeys = metadata.keys.map((key) => this.interpolateKey(key, command));
+        if (resolvedKeys.length === 0) {
+            return result;
+        }
+        try {
+            await this.redis.del(...resolvedKeys);
+            this.logger.debug(`Cache invalidated: ${resolvedKeys.join(', ')}`);
+        }
+        catch {
+            this.logger.warn(`Cache invalidation failed for keys: ${resolvedKeys.join(', ')}`);
+        }
+        return result;
+    }
+    interpolateKey(template, command) {
+        return template.replace(/\{(\w+)\}/g, (_, prop) => {
+            const value = command[prop];
+            return value != null ? String(value) : '';
+        });
+    }
+};
+exports.InvalidateCacheBehavior = InvalidateCacheBehavior;
+exports.InvalidateCacheBehavior = InvalidateCacheBehavior = InvalidateCacheBehavior_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(core_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], InvalidateCacheBehavior);

package/dist/QuanticRedisModule.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { RedisModuleOptions } from './redis.module';
+export declare class QuanticRedisModule {
+    static forRoot(options?: RedisModuleOptions): DynamicModule;
+}

package/dist/QuanticRedisModule.js

@@ -0,0 +1,43 @@
+"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 QuanticRedisModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticRedisModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@quanticjs/core");
+const redis_module_1 = require("./redis.module");
+const CacheBehavior_1 = require("./CacheBehavior");
+const InvalidateCacheBehavior_1 = require("./InvalidateCacheBehavior");
+const DistributedLockBehavior_1 = require("./DistributedLockBehavior");
+let QuanticRedisModule = QuanticRedisModule_1 = class QuanticRedisModule {
+    static forRoot(options = {}) {
+        return {
+            module: QuanticRedisModule_1,
+            imports: [redis_module_1.RedisModule.forRoot(options)],
+            providers: [
+                CacheBehavior_1.CacheBehavior,
+                { provide: core_1.PIPELINE_BEHAVIOR, useExisting: CacheBehavior_1.CacheBehavior, multi: true },
+                InvalidateCacheBehavior_1.InvalidateCacheBehavior,
+                { provide: core_1.PIPELINE_BEHAVIOR, useExisting: InvalidateCacheBehavior_1.InvalidateCacheBehavior, multi: true },
+                DistributedLockBehavior_1.DistributedLockBehavior,
+                { provide: core_1.PIPELINE_BEHAVIOR, useExisting: DistributedLockBehavior_1.DistributedLockBehavior, multi: true },
+            ],
+            exports: [
+                redis_module_1.RedisModule,
+                CacheBehavior_1.CacheBehavior,
+                InvalidateCacheBehavior_1.InvalidateCacheBehavior,
+                DistributedLockBehavior_1.DistributedLockBehavior,
+            ],
+        };
+    }
+};
+exports.QuanticRedisModule = QuanticRedisModule;
+exports.QuanticRedisModule = QuanticRedisModule = QuanticRedisModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], QuanticRedisModule);

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { RedisModule } from './redis.module';
+export type { RedisModuleOptions } from './redis.module';
+export { CacheBehavior } from './CacheBehavior';
+export { InvalidateCacheBehavior } from './InvalidateCacheBehavior';
+export { DistributedLockBehavior } from './DistributedLockBehavior';
+export { QuanticRedisModule } from './QuanticRedisModule';

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticRedisModule = exports.DistributedLockBehavior = exports.InvalidateCacheBehavior = exports.CacheBehavior = exports.RedisModule = void 0;
+var redis_module_1 = require("./redis.module");
+Object.defineProperty(exports, "RedisModule", { enumerable: true, get: function () { return redis_module_1.RedisModule; } });
+var CacheBehavior_1 = require("./CacheBehavior");
+Object.defineProperty(exports, "CacheBehavior", { enumerable: true, get: function () { return CacheBehavior_1.CacheBehavior; } });
+var InvalidateCacheBehavior_1 = require("./InvalidateCacheBehavior");
+Object.defineProperty(exports, "InvalidateCacheBehavior", { enumerable: true, get: function () { return InvalidateCacheBehavior_1.InvalidateCacheBehavior; } });
+var DistributedLockBehavior_1 = require("./DistributedLockBehavior");
+Object.defineProperty(exports, "DistributedLockBehavior", { enumerable: true, get: function () { return DistributedLockBehavior_1.DistributedLockBehavior; } });
+var QuanticRedisModule_1 = require("./QuanticRedisModule");
+Object.defineProperty(exports, "QuanticRedisModule", { enumerable: true, get: function () { return QuanticRedisModule_1.QuanticRedisModule; } });

package/dist/redis.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+export interface RedisModuleOptions {
+    url?: string;
+}
+export declare class RedisModule {
+    private static readonly logger;
+    static forRoot(options?: RedisModuleOptions): DynamicModule;
+}

package/dist/redis.module.js

@@ -0,0 +1,49 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var RedisModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisModule = void 0;
+const common_1 = require("@nestjs/common");
+const ioredis_1 = __importDefault(require("ioredis"));
+const core_1 = require("@quanticjs/core");
+let RedisModule = class RedisModule {
+    static { RedisModule_1 = this; }
+    static logger = new common_1.Logger('RedisModule');
+    static forRoot(options = {}) {
+        const redisProvider = {
+            provide: core_1.REDIS_CLIENT,
+            useFactory: () => {
+                const url = options.url || process.env.REDIS_URL || 'redis://localhost:6379';
+                const client = new ioredis_1.default(url, {
+                    maxRetriesPerRequest: 3,
+                    retryStrategy(times) {
+                        const delay = Math.min(times * 200, 5000);
+                        RedisModule_1.logger.warn(`Redis reconnecting (attempt ${times}, delay ${delay}ms)`);
+                        return delay;
+                    },
+                });
+                client.on('connect', () => RedisModule_1.logger.log('Redis connected'));
+                client.on('error', (err) => RedisModule_1.logger.error('Redis error', err.message));
+                return client;
+            },
+        };
+        return {
+            module: RedisModule_1,
+            providers: [redisProvider],
+            exports: [core_1.REDIS_CLIENT],
+        };
+    }
+};
+exports.RedisModule = RedisModule;
+exports.RedisModule = RedisModule = RedisModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], RedisModule);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@quanticjs/redis",
+  "version": "2.0.0",
+  "description": "Redis integration for quanticjs — cache, invalidation, distributed locks",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest --passWithNoTests",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@quanticjs/core": "^2.0.0",
+    "uuid": "^11.1.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "ioredis": "^5.0.0",
+    "reflect-metadata": ">=0.1.0"
+  }
+}