@quanticjs/core 1.1.1

package/dist/bootstrap/bootstrapService.d.ts

@@ -0,0 +1,8 @@
+import { INestApplication } from '@nestjs/common';
+export interface BootstrapOptions {
+    module: any;
+    port: number;
+    serviceName: string;
+    rawBody?: boolean;
+}
+export declare function bootstrapService(options: BootstrapOptions): Promise<INestApplication>;

package/dist/bootstrap/bootstrapService.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapService = bootstrapService;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const swagger_1 = require("@nestjs/swagger");
+const nestjs_pino_1 = require("nestjs-pino");
+const helmet_1 = __importDefault(require("helmet"));
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+const GlobalExceptionFilter_1 = require("../filters/GlobalExceptionFilter");
+async function bootstrapService(options) {
+    const { module, port, serviceName, rawBody } = options;
+    const app = await core_1.NestFactory.create(module, {
+        bufferLogs: true,
+        ...(rawBody ? { rawBody: true } : {}),
+    });
+    app.useLogger(app.get(nestjs_pino_1.Logger));
+    // Security headers
+    app.use((0, helmet_1.default)());
+    // Cookie parsing (required for OAuth flows)
+    app.use((0, cookie_parser_1.default)());
+    // CORS
+    const allowedOrigins = (process.env.CORS_ORIGINS || 'http://localhost:5173').split(',');
+    app.enableCors({
+        origin: allowedOrigins,
+        credentials: true,
+        methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Authorization', 'X-Tenant-ID', 'X-Correlation-ID'],
+        exposedHeaders: ['X-Correlation-ID'],
+        maxAge: 86400,
+    });
+    // Global exception filter
+    app.useGlobalFilters(new GlobalExceptionFilter_1.GlobalExceptionFilter());
+    // Global validation pipe
+    app.useGlobalPipes(new common_1.ValidationPipe({
+        whitelist: true,
+        forbidNonWhitelisted: true,
+        transform: true,
+    }));
+    // Swagger — disabled in production
+    if (process.env.NODE_ENV !== 'production') {
+        const config = new swagger_1.DocumentBuilder()
+            .setTitle(`AREX — ${serviceName}`)
+            .setDescription(`OpenAPI spec for ${serviceName}`)
+            .setVersion('1.0.0')
+            .addBearerAuth()
+            .build();
+        const document = swagger_1.SwaggerModule.createDocument(app, config);
+        swagger_1.SwaggerModule.setup('swagger', app, document);
+    }
+    // Enable graceful shutdown hooks (SIGTERM, SIGINT)
+    app.enableShutdownHooks();
+    await app.listen(port);
+    return app;
+}

package/dist/cqrs/PipelineExecutor.d.ts

@@ -0,0 +1,31 @@
+import { OnModuleInit } from '@nestjs/common';
+import { CommandBus, QueryBus } from '@nestjs/cqrs';
+import { LogBehavior } from './behaviors/LogBehavior';
+import { FeatureFlagBehavior } from './behaviors/FeatureFlagBehavior';
+import { ValidationBehavior } from './behaviors/ValidationBehavior';
+import { CacheBehavior } from './behaviors/CacheBehavior';
+import { DistributedLockBehavior } from './behaviors/DistributedLockBehavior';
+import { TransactionalBehavior } from './behaviors/TransactionalBehavior';
+import { PerformanceBehavior } from './behaviors/PerformanceBehavior';
+import { WorkflowBehavior } from './behaviors/WorkflowBehavior';
+/**
+ * @deprecated Use QuanticCommandBus and QuanticQueryBus instead.
+ * This class is kept for backwards compatibility only.
+ */
+export declare class PipelineExecutor implements OnModuleInit {
+    private readonly commandBus;
+    private readonly queryBus;
+    private readonly logBehavior;
+    private readonly featureFlagBehavior;
+    private readonly validationBehavior;
+    private readonly cacheBehavior;
+    private readonly distributedLockBehavior;
+    private readonly transactionalBehavior;
+    private readonly performanceBehavior;
+    private readonly workflowBehavior;
+    private readonly logger;
+    private readonly quanticCommandBus;
+    private readonly quanticQueryBus;
+    constructor(commandBus: CommandBus, queryBus: QueryBus, logBehavior: LogBehavior, featureFlagBehavior: FeatureFlagBehavior | undefined, validationBehavior: ValidationBehavior, cacheBehavior: CacheBehavior, distributedLockBehavior: DistributedLockBehavior, transactionalBehavior: TransactionalBehavior, performanceBehavior: PerformanceBehavior, workflowBehavior: WorkflowBehavior | undefined);
+    onModuleInit(): void;
+}

package/dist/cqrs/PipelineExecutor.js

@@ -0,0 +1,81 @@
+"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 PipelineExecutor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineExecutor = void 0;
+const common_1 = require("@nestjs/common");
+const cqrs_1 = require("@nestjs/cqrs");
+const LogBehavior_1 = require("./behaviors/LogBehavior");
+const FeatureFlagBehavior_1 = require("./behaviors/FeatureFlagBehavior");
+const ValidationBehavior_1 = require("./behaviors/ValidationBehavior");
+const CacheBehavior_1 = require("./behaviors/CacheBehavior");
+const DistributedLockBehavior_1 = require("./behaviors/DistributedLockBehavior");
+const TransactionalBehavior_1 = require("./behaviors/TransactionalBehavior");
+const PerformanceBehavior_1 = require("./behaviors/PerformanceBehavior");
+const WorkflowBehavior_1 = require("./behaviors/WorkflowBehavior");
+const QuanticCommandBus_1 = require("./pipeline/QuanticCommandBus");
+const QuanticQueryBus_1 = require("./pipeline/QuanticQueryBus");
+/**
+ * @deprecated Use QuanticCommandBus and QuanticQueryBus instead.
+ * This class is kept for backwards compatibility only.
+ */
+let PipelineExecutor = PipelineExecutor_1 = class PipelineExecutor {
+    commandBus;
+    queryBus;
+    logBehavior;
+    featureFlagBehavior;
+    validationBehavior;
+    cacheBehavior;
+    distributedLockBehavior;
+    transactionalBehavior;
+    performanceBehavior;
+    workflowBehavior;
+    logger = new common_1.Logger(PipelineExecutor_1.name);
+    quanticCommandBus;
+    quanticQueryBus;
+    constructor(commandBus, queryBus, logBehavior, featureFlagBehavior, validationBehavior, cacheBehavior, distributedLockBehavior, transactionalBehavior, performanceBehavior, workflowBehavior) {
+        this.commandBus = commandBus;
+        this.queryBus = queryBus;
+        this.logBehavior = logBehavior;
+        this.featureFlagBehavior = featureFlagBehavior;
+        this.validationBehavior = validationBehavior;
+        this.cacheBehavior = cacheBehavior;
+        this.distributedLockBehavior = distributedLockBehavior;
+        this.transactionalBehavior = transactionalBehavior;
+        this.performanceBehavior = performanceBehavior;
+        this.workflowBehavior = workflowBehavior;
+        this.quanticCommandBus = new QuanticCommandBus_1.QuanticCommandBus(commandBus, logBehavior, performanceBehavior, featureFlagBehavior, validationBehavior, workflowBehavior, cacheBehavior, distributedLockBehavior, transactionalBehavior);
+        this.quanticQueryBus = new QuanticQueryBus_1.QuanticQueryBus(queryBus, logBehavior, performanceBehavior, featureFlagBehavior, validationBehavior, cacheBehavior);
+    }
+    onModuleInit() {
+        this.logger.warn('PipelineExecutor is deprecated. Use QuanticCommandBus and QuanticQueryBus instead.');
+        this.quanticCommandBus.onModuleInit();
+        this.quanticQueryBus.onModuleInit();
+    }
+};
+exports.PipelineExecutor = PipelineExecutor;
+exports.PipelineExecutor = PipelineExecutor = PipelineExecutor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Inject)(FeatureFlagBehavior_1.FeatureFlagBehavior)),
+    __param(9, (0, common_1.Optional)()),
+    __param(9, (0, common_1.Inject)(WorkflowBehavior_1.WorkflowBehavior)),
+    __metadata("design:paramtypes", [cqrs_1.CommandBus,
+        cqrs_1.QueryBus,
+        LogBehavior_1.LogBehavior, Object, ValidationBehavior_1.ValidationBehavior,
+        CacheBehavior_1.CacheBehavior,
+        DistributedLockBehavior_1.DistributedLockBehavior,
+        TransactionalBehavior_1.TransactionalBehavior,
+        PerformanceBehavior_1.PerformanceBehavior, Object])
+], PipelineExecutor);

package/dist/cqrs/behaviors/CacheBehavior.d.ts

@@ -0,0 +1,9 @@
+import { Result } from '../../result/Result';
+import type { Redis } from 'ioredis';
+export declare class CacheBehavior {
+    private readonly redis?;
+    private readonly logger;
+    constructor(redis?: Redis | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+    private interpolateKey;
+}

package/dist/cqrs/behaviors/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 Cache_decorator_1 = require("../decorators/Cache.decorator");
+const Result_1 = require("../../result/Result");
+const constants_1 = require("../constants");
+let CacheBehavior = CacheBehavior_1 = class CacheBehavior {
+    redis;
+    logger = new common_1.Logger(CacheBehavior_1.name);
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async execute(command, next) {
+        const metadata = (0, Cache_decorator_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 Result_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)(constants_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], CacheBehavior);

package/dist/cqrs/behaviors/DistributedLockBehavior.d.ts

@@ -0,0 +1,12 @@
+import { Result } from '../../result/Result';
+import type { Redis } from 'ioredis';
+export declare class DistributedLockBehavior {
+    private readonly redis?;
+    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/cqrs/behaviors/DistributedLockBehavior.js

@@ -0,0 +1,90 @@
+"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 DistributedLock_decorator_1 = require("../decorators/DistributedLock.decorator");
+const Result_1 = require("../../result/Result");
+const constants_1 = require("../constants");
+const uuid_1 = require("uuid");
+let DistributedLockBehavior = DistributedLockBehavior_1 = class DistributedLockBehavior {
+    redis;
+    logger = new common_1.Logger(DistributedLockBehavior_1.name);
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async execute(command, next) {
+        const metadata = (0, DistributedLock_decorator_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 Result_1.Result.failure(Result_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) {
+        // Lua script ensures only the owner releases the lock
+        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)(constants_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], DistributedLockBehavior);

package/dist/cqrs/behaviors/FeatureFlagBehavior.d.ts

@@ -0,0 +1,8 @@
+import { Unleash } from 'unleash-client';
+import { Result } from '../../result/Result';
+export declare class FeatureFlagBehavior {
+    private readonly unleash?;
+    private readonly logger;
+    constructor(unleash?: Unleash | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+}

package/dist/cqrs/behaviors/FeatureFlagBehavior.js

@@ -0,0 +1,58 @@
+"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 FeatureFlagBehavior_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const unleash_client_1 = require("unleash-client");
+const FeatureFlag_decorator_1 = require("../decorators/FeatureFlag.decorator");
+const Result_1 = require("../../result/Result");
+let FeatureFlagBehavior = FeatureFlagBehavior_1 = class FeatureFlagBehavior {
+    unleash;
+    logger = new common_1.Logger(FeatureFlagBehavior_1.name);
+    constructor(unleash) {
+        this.unleash = unleash;
+    }
+    async execute(command, next) {
+        const metadata = (0, FeatureFlag_decorator_1.getFeatureFlagMetadata)(command.constructor);
+        if (!metadata) {
+            return next();
+        }
+        if (!this.unleash) {
+            this.logger.debug('Unleash not configured, skipping feature flag check');
+            return next();
+        }
+        const { flagName, fallback, defaultValue } = metadata;
+        const isEnabled = this.unleash.isEnabled(flagName);
+        if (isEnabled) {
+            return next();
+        }
+        this.logger.warn(`Feature flag "${flagName}" is disabled, applying fallback: ${fallback}`);
+        switch (fallback) {
+            case 'skip':
+                return Result_1.Result.success(undefined);
+            case 'default':
+                return Result_1.Result.success(defaultValue);
+            case 'throw':
+            default:
+                return Result_1.Result.failure(Result_1.ErrorType.Forbidden, `Feature "${flagName}" is currently disabled`);
+        }
+    }
+};
+exports.FeatureFlagBehavior = FeatureFlagBehavior;
+exports.FeatureFlagBehavior = FeatureFlagBehavior = FeatureFlagBehavior_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [unleash_client_1.Unleash])
+], FeatureFlagBehavior);

package/dist/cqrs/behaviors/InvalidateCacheBehavior.d.ts

@@ -0,0 +1,9 @@
+import { Result } from '../../result/Result';
+import type { Redis } from 'ioredis';
+export declare class InvalidateCacheBehavior {
+    private readonly redis?;
+    private readonly logger;
+    constructor(redis?: Redis | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+    private interpolateKey;
+}

package/dist/cqrs/behaviors/InvalidateCacheBehavior.js

@@ -0,0 +1,61 @@
+"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 InvalidateCache_decorator_1 = require("../decorators/InvalidateCache.decorator");
+const constants_1 = require("../constants");
+let InvalidateCacheBehavior = InvalidateCacheBehavior_1 = class InvalidateCacheBehavior {
+    redis;
+    logger = new common_1.Logger(InvalidateCacheBehavior_1.name);
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async execute(command, next) {
+        const metadata = (0, InvalidateCache_decorator_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)(constants_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], InvalidateCacheBehavior);

package/dist/cqrs/behaviors/LogBehavior.d.ts

@@ -0,0 +1,9 @@
+import { Result } from '../../result/Result';
+export declare class LogBehavior {
+    private readonly logger;
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+    private maskPayload;
+    private getExcludeFields;
+    private sanitize;
+    private extractBuildId;
+}

package/dist/cqrs/behaviors/LogBehavior.js

@@ -0,0 +1,125 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const Result_1 = require("../../result/Result");
+const CorrelationStore_1 = require("../../middleware/CorrelationStore");
+const PII_FIELDS = new Set(['email', 'githubAccessToken', 'accessToken', 'token', 'secretKey', 'password']);
+const MAX_STRING_LENGTH = 200;
+const MAX_ARRAY_LENGTH = 5;
+const MAX_DEPTH = 2;
+let LogBehavior = class LogBehavior {
+    logger = new common_1.Logger('PipelineBehavior');
+    async execute(command, next) {
+        const commandName = command.constructor.name;
+        const startTime = Date.now();
+        const ctx = CorrelationStore_1.correlationStore.getStore();
+        const logContext = {
+            command: commandName,
+            correlationId: ctx?.correlationId,
+            userId: ctx?.userId,
+            orgId: ctx?.organizationId,
+            ...(this.extractBuildId(command)),
+            payload: this.maskPayload(command),
+        };
+        try {
+            const result = await next();
+            const durationMs = Date.now() - startTime;
+            if (result.isSuccess) {
+                this.logger.log({
+                    msg: `${commandName} completed`,
+                    ...logContext,
+                    durationMs,
+                    result: 'success',
+                });
+            }
+            else {
+                this.logger.warn({
+                    msg: `${commandName} completed`,
+                    ...logContext,
+                    durationMs,
+                    result: 'failure',
+                    errorType: result.errorType ?? 'Unknown',
+                    errorMessage: result.errorMessage,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            const durationMs = Date.now() - startTime;
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({
+                msg: `${commandName} failed`,
+                ...logContext,
+                durationMs,
+                result: 'exception',
+                error: err.message,
+                stack: err.stack,
+            });
+            return Result_1.Result.failure(Result_1.ErrorType.InternalError, err.message);
+        }
+    }
+    maskPayload(command) {
+        const excludeFields = this.getExcludeFields(command);
+        return this.sanitize(command, 0, excludeFields);
+    }
+    getExcludeFields(command) {
+        const ctor = command.constructor;
+        return new Set(ctor.logExclude ?? []);
+    }
+    sanitize(value, depth, excludeFields) {
+        if (value === null || value === undefined)
+            return value;
+        if (typeof value === 'string') {
+            return value.length > MAX_STRING_LENGTH
+                ? `${value.substring(0, MAX_STRING_LENGTH)}... (${value.length} chars)`
+                : value;
+        }
+        if (typeof value !== 'object')
+            return value;
+        if (depth >= MAX_DEPTH)
+            return '[nested]';
+        if (Array.isArray(value)) {
+            if (value.length > MAX_ARRAY_LENGTH) {
+                return [
+                    ...value.slice(0, MAX_ARRAY_LENGTH).map((v) => this.sanitize(v, depth + 1)),
+                    `... +${value.length - MAX_ARRAY_LENGTH} more`,
+                ];
+            }
+            return value.map((v) => this.sanitize(v, depth + 1));
+        }
+        const masked = {};
+        for (const [key, val] of Object.entries(value)) {
+            if (excludeFields?.has(key)) {
+                masked[key] = '[excluded]';
+            }
+            else if (PII_FIELDS.has(key)) {
+                if (key === 'email' && typeof val === 'string') {
+                    const [local, domain] = val.split('@');
+                    masked[key] = domain ? `${local?.[0]}***@${domain}` : '[REDACTED]';
+                }
+                else {
+                    masked[key] = '[REDACTED]';
+                }
+            }
+            else {
+                masked[key] = this.sanitize(val, depth + 1);
+            }
+        }
+        return masked;
+    }
+    extractBuildId(command) {
+        const buildId = command['buildId'];
+        return typeof buildId === 'string' ? { buildId } : {};
+    }
+};
+exports.LogBehavior = LogBehavior;
+exports.LogBehavior = LogBehavior = __decorate([
+    (0, common_1.Injectable)()
+], LogBehavior);

package/dist/cqrs/behaviors/PerformanceBehavior.d.ts

@@ -0,0 +1,12 @@
+import { Result } from '../../result/Result';
+import { MetricsService } from '../../metrics/MetricsService';
+/**
+ * PerformanceBehavior logs a warning when a handler exceeds 500ms
+ * and records handler duration in Prometheus histogram.
+ */
+export declare class PerformanceBehavior {
+    private readonly metrics?;
+    private readonly logger;
+    constructor(metrics?: MetricsService | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+}