@quanticjs/core 1.1.1

package/dist/guards/RolesGuard.js

@@ -0,0 +1,52 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RolesGuard = exports.Roles = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const ROLES_KEY = 'roles';
+const Roles = (...roles) => (target, _key, descriptor) => {
+    if (descriptor) {
+        Reflect.defineMetadata(ROLES_KEY, roles, descriptor.value);
+    }
+    else {
+        Reflect.defineMetadata(ROLES_KEY, roles, target);
+    }
+};
+exports.Roles = Roles;
+let RolesGuard = class RolesGuard {
+    reflector;
+    constructor(reflector) {
+        this.reflector = reflector;
+    }
+    canActivate(context) {
+        const requiredRoles = this.reflector.getAllAndOverride(ROLES_KEY, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
+        if (!requiredRoles || requiredRoles.length === 0)
+            return true;
+        const request = context.switchToHttp().getRequest();
+        const userRoles = request.user?.roles || [];
+        const hasRole = requiredRoles.some((role) => userRoles.includes(role));
+        if (!hasRole) {
+            throw new common_1.ForbiddenException({
+                error: { code: 'FORBIDDEN', message: 'Insufficient permissions' },
+            });
+        }
+        return true;
+    }
+};
+exports.RolesGuard = RolesGuard;
+exports.RolesGuard = RolesGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector])
+], RolesGuard);

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+export { Result, ErrorType } from './result/Result';
+export { BaseEntity } from './entities/BaseEntity';
+export { TenantBaseEntity } from './entities/TenantBaseEntity';
+export { CorrelationIdMiddleware } from './middleware/CorrelationIdMiddleware';
+export { correlationStore } from './middleware/CorrelationStore';
+export type { CorrelationStoreData } from './middleware/CorrelationStore';
+export { TenantContextMiddleware, TenantContext } from './middleware/TenantContextMiddleware';
+export { tenantStore } from './middleware/TenantStore';
+export type { TenantStoreData } from './middleware/TenantStore';
+export { GlobalExceptionFilter } from './filters/GlobalExceptionFilter';
+export { ResultInterceptor } from './interceptors/ResultInterceptor';
+export { JwtAuthGuard, Public } from './guards/JwtAuthGuard';
+export { JwtStrategy, JwtPayload } from './guards/JwtStrategy';
+export { RolesGuard, Roles } from './guards/RolesGuard';
+export { TenantSubscriber } from './subscribers/TenantSubscriber';
+export { createCircuitBreaker } from './resilience/CircuitBreakerFactory';
+export type { CircuitBreakerOptions } from './resilience/CircuitBreakerFactory';
+export { bootstrapService } from './bootstrap/bootstrapService';
+export type { BootstrapOptions } from './bootstrap/bootstrapService';
+export { createPinoConfig } from './logging/pino-config';
+export { REDIS_CLIENT } from './cqrs/constants';
+export { FeatureFlag, getFeatureFlagMetadata } from './cqrs/decorators/FeatureFlag.decorator';
+export type { FeatureFlagOptions } from './cqrs/decorators/FeatureFlag.decorator';
+export { Log, getLogMetadata } from './cqrs/decorators/Log.decorator';
+export type { LogOptions } from './cqrs/decorators/Log.decorator';
+export { Validate, shouldValidate, getValidatorClass } from './cqrs/decorators/Validate.decorator';
+export type { ICommandValidator } from './cqrs/validation/ICommandValidator';
+export { validateCommand } from './cqrs/validation/ICommandValidator';
+export { Cache, getCacheMetadata } from './cqrs/decorators/Cache.decorator';
+export type { CacheOptions } from './cqrs/decorators/Cache.decorator';
+export { InvalidateCache, getInvalidateCacheMetadata } from './cqrs/decorators/InvalidateCache.decorator';
+export type { InvalidateCacheOptions } from './cqrs/decorators/InvalidateCache.decorator';
+export { DistributedLock, getDistributedLockMetadata } from './cqrs/decorators/DistributedLock.decorator';
+export type { DistributedLockOptions } from './cqrs/decorators/DistributedLock.decorator';
+export { IsolatedTransaction, isIsolatedTransaction } from './cqrs/decorators/IsolatedTransaction.decorator';
+export { Workflow, getWorkflowMetadata } from './cqrs/decorators/Workflow.decorator';
+export type { WorkflowOptions } from './cqrs/decorators/Workflow.decorator';
+export { WORKFLOW_ENGINE } from './cqrs/interfaces/WorkflowEngine';
+export type { WorkflowEngine, WorkflowStartResult } from './cqrs/interfaces/WorkflowEngine';
+export { TransactionContext } from './cqrs/transaction/TransactionContext';
+export { getTransactionalRepo } from './cqrs/transaction/getTransactionalRepo';
+export { MetricsService } from './metrics/MetricsService';
+export { MetricsController } from './metrics/MetricsController';
+export { LogBehavior } from './cqrs/behaviors/LogBehavior';
+export { FeatureFlagBehavior } from './cqrs/behaviors/FeatureFlagBehavior';
+export { ValidationBehavior } from './cqrs/behaviors/ValidationBehavior';
+export { CacheBehavior } from './cqrs/behaviors/CacheBehavior';
+export { InvalidateCacheBehavior } from './cqrs/behaviors/InvalidateCacheBehavior';
+export { DistributedLockBehavior } from './cqrs/behaviors/DistributedLockBehavior';
+export { TransactionalBehavior } from './cqrs/behaviors/TransactionalBehavior';
+export { PerformanceBehavior } from './cqrs/behaviors/PerformanceBehavior';
+export { WorkflowBehavior } from './cqrs/behaviors/WorkflowBehavior';
+export { QuanticCommandBus } from './cqrs/pipeline/QuanticCommandBus';
+export { QuanticQueryBus } from './cqrs/pipeline/QuanticQueryBus';
+export { type BehaviorFn } from './cqrs/pipeline/runPipeline';
+export { RedisModule } from './redis/redis.module';
+export type { RedisModuleOptions } from './redis/redis.module';
+export { DomainEvent } from './events/DomainEvent';
+export type { DomainEventPayload } from './events/DomainEvent';
+export { OutboxEvent, OutboxEventStatus } from './events/OutboxEvent.entity';
+export { RedisStreamPublisher } from './events/RedisStreamPublisher';
+export { RedisStreamConsumer } from './events/RedisStreamConsumer';
+export { OutboxPublisherService } from './events/OutboxPublisherService';
+export { UnleashModule } from './unleash/unleash.module';
+export type { UnleashModuleOptions } from './unleash/unleash.module';
+export { GracefulShutdownService } from './lifecycle/GracefulShutdownService';
+export { QuanticModule, SharedKernelModule } from './shared-kernel.module';
+export type { QuanticModuleOptions, SharedKernelModuleOptions } from './shared-kernel.module';
+export { createMockRepository, createMockRedisClient } from './testing/mocks';

package/dist/index.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionalBehavior = exports.DistributedLockBehavior = exports.InvalidateCacheBehavior = exports.CacheBehavior = exports.ValidationBehavior = exports.FeatureFlagBehavior = exports.LogBehavior = exports.MetricsController = exports.MetricsService = exports.getTransactionalRepo = exports.TransactionContext = exports.WORKFLOW_ENGINE = exports.getWorkflowMetadata = exports.Workflow = exports.isIsolatedTransaction = exports.IsolatedTransaction = exports.getDistributedLockMetadata = exports.DistributedLock = exports.getInvalidateCacheMetadata = exports.InvalidateCache = exports.getCacheMetadata = exports.Cache = exports.validateCommand = exports.getValidatorClass = exports.shouldValidate = exports.Validate = exports.getLogMetadata = exports.Log = exports.getFeatureFlagMetadata = exports.FeatureFlag = exports.REDIS_CLIENT = exports.createPinoConfig = exports.bootstrapService = exports.createCircuitBreaker = exports.TenantSubscriber = exports.Roles = exports.RolesGuard = exports.JwtStrategy = exports.Public = exports.JwtAuthGuard = exports.ResultInterceptor = exports.GlobalExceptionFilter = exports.tenantStore = exports.TenantContextMiddleware = exports.correlationStore = exports.CorrelationIdMiddleware = exports.TenantBaseEntity = exports.BaseEntity = exports.ErrorType = exports.Result = void 0;
+exports.createMockRedisClient = exports.createMockRepository = exports.SharedKernelModule = exports.QuanticModule = exports.GracefulShutdownService = exports.UnleashModule = exports.OutboxPublisherService = exports.RedisStreamConsumer = exports.RedisStreamPublisher = exports.OutboxEventStatus = exports.OutboxEvent = exports.DomainEvent = exports.RedisModule = exports.QuanticQueryBus = exports.QuanticCommandBus = exports.WorkflowBehavior = exports.PerformanceBehavior = void 0;
+// Result
+var Result_1 = require("./result/Result");
+Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return Result_1.Result; } });
+Object.defineProperty(exports, "ErrorType", { enumerable: true, get: function () { return Result_1.ErrorType; } });
+// Entities
+var BaseEntity_1 = require("./entities/BaseEntity");
+Object.defineProperty(exports, "BaseEntity", { enumerable: true, get: function () { return BaseEntity_1.BaseEntity; } });
+var TenantBaseEntity_1 = require("./entities/TenantBaseEntity");
+Object.defineProperty(exports, "TenantBaseEntity", { enumerable: true, get: function () { return TenantBaseEntity_1.TenantBaseEntity; } });
+// Middleware
+var CorrelationIdMiddleware_1 = require("./middleware/CorrelationIdMiddleware");
+Object.defineProperty(exports, "CorrelationIdMiddleware", { enumerable: true, get: function () { return CorrelationIdMiddleware_1.CorrelationIdMiddleware; } });
+var CorrelationStore_1 = require("./middleware/CorrelationStore");
+Object.defineProperty(exports, "correlationStore", { enumerable: true, get: function () { return CorrelationStore_1.correlationStore; } });
+var TenantContextMiddleware_1 = require("./middleware/TenantContextMiddleware");
+Object.defineProperty(exports, "TenantContextMiddleware", { enumerable: true, get: function () { return TenantContextMiddleware_1.TenantContextMiddleware; } });
+var TenantStore_1 = require("./middleware/TenantStore");
+Object.defineProperty(exports, "tenantStore", { enumerable: true, get: function () { return TenantStore_1.tenantStore; } });
+// Filters
+var GlobalExceptionFilter_1 = require("./filters/GlobalExceptionFilter");
+Object.defineProperty(exports, "GlobalExceptionFilter", { enumerable: true, get: function () { return GlobalExceptionFilter_1.GlobalExceptionFilter; } });
+// Interceptors
+var ResultInterceptor_1 = require("./interceptors/ResultInterceptor");
+Object.defineProperty(exports, "ResultInterceptor", { enumerable: true, get: function () { return ResultInterceptor_1.ResultInterceptor; } });
+// Guards
+var JwtAuthGuard_1 = require("./guards/JwtAuthGuard");
+Object.defineProperty(exports, "JwtAuthGuard", { enumerable: true, get: function () { return JwtAuthGuard_1.JwtAuthGuard; } });
+Object.defineProperty(exports, "Public", { enumerable: true, get: function () { return JwtAuthGuard_1.Public; } });
+var JwtStrategy_1 = require("./guards/JwtStrategy");
+Object.defineProperty(exports, "JwtStrategy", { enumerable: true, get: function () { return JwtStrategy_1.JwtStrategy; } });
+var RolesGuard_1 = require("./guards/RolesGuard");
+Object.defineProperty(exports, "RolesGuard", { enumerable: true, get: function () { return RolesGuard_1.RolesGuard; } });
+Object.defineProperty(exports, "Roles", { enumerable: true, get: function () { return RolesGuard_1.Roles; } });
+// Subscribers
+var TenantSubscriber_1 = require("./subscribers/TenantSubscriber");
+Object.defineProperty(exports, "TenantSubscriber", { enumerable: true, get: function () { return TenantSubscriber_1.TenantSubscriber; } });
+// Resilience
+var CircuitBreakerFactory_1 = require("./resilience/CircuitBreakerFactory");
+Object.defineProperty(exports, "createCircuitBreaker", { enumerable: true, get: function () { return CircuitBreakerFactory_1.createCircuitBreaker; } });
+// Bootstrap
+var bootstrapService_1 = require("./bootstrap/bootstrapService");
+Object.defineProperty(exports, "bootstrapService", { enumerable: true, get: function () { return bootstrapService_1.bootstrapService; } });
+// Logging
+var pino_config_1 = require("./logging/pino-config");
+Object.defineProperty(exports, "createPinoConfig", { enumerable: true, get: function () { return pino_config_1.createPinoConfig; } });
+// CQRS Constants
+var constants_1 = require("./cqrs/constants");
+Object.defineProperty(exports, "REDIS_CLIENT", { enumerable: true, get: function () { return constants_1.REDIS_CLIENT; } });
+// CQRS Decorators
+var FeatureFlag_decorator_1 = require("./cqrs/decorators/FeatureFlag.decorator");
+Object.defineProperty(exports, "FeatureFlag", { enumerable: true, get: function () { return FeatureFlag_decorator_1.FeatureFlag; } });
+Object.defineProperty(exports, "getFeatureFlagMetadata", { enumerable: true, get: function () { return FeatureFlag_decorator_1.getFeatureFlagMetadata; } });
+var Log_decorator_1 = require("./cqrs/decorators/Log.decorator");
+Object.defineProperty(exports, "Log", { enumerable: true, get: function () { return Log_decorator_1.Log; } });
+Object.defineProperty(exports, "getLogMetadata", { enumerable: true, get: function () { return Log_decorator_1.getLogMetadata; } });
+var Validate_decorator_1 = require("./cqrs/decorators/Validate.decorator");
+Object.defineProperty(exports, "Validate", { enumerable: true, get: function () { return Validate_decorator_1.Validate; } });
+Object.defineProperty(exports, "shouldValidate", { enumerable: true, get: function () { return Validate_decorator_1.shouldValidate; } });
+Object.defineProperty(exports, "getValidatorClass", { enumerable: true, get: function () { return Validate_decorator_1.getValidatorClass; } });
+var ICommandValidator_1 = require("./cqrs/validation/ICommandValidator");
+Object.defineProperty(exports, "validateCommand", { enumerable: true, get: function () { return ICommandValidator_1.validateCommand; } });
+var Cache_decorator_1 = require("./cqrs/decorators/Cache.decorator");
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return Cache_decorator_1.Cache; } });
+Object.defineProperty(exports, "getCacheMetadata", { enumerable: true, get: function () { return Cache_decorator_1.getCacheMetadata; } });
+var InvalidateCache_decorator_1 = require("./cqrs/decorators/InvalidateCache.decorator");
+Object.defineProperty(exports, "InvalidateCache", { enumerable: true, get: function () { return InvalidateCache_decorator_1.InvalidateCache; } });
+Object.defineProperty(exports, "getInvalidateCacheMetadata", { enumerable: true, get: function () { return InvalidateCache_decorator_1.getInvalidateCacheMetadata; } });
+var DistributedLock_decorator_1 = require("./cqrs/decorators/DistributedLock.decorator");
+Object.defineProperty(exports, "DistributedLock", { enumerable: true, get: function () { return DistributedLock_decorator_1.DistributedLock; } });
+Object.defineProperty(exports, "getDistributedLockMetadata", { enumerable: true, get: function () { return DistributedLock_decorator_1.getDistributedLockMetadata; } });
+var IsolatedTransaction_decorator_1 = require("./cqrs/decorators/IsolatedTransaction.decorator");
+Object.defineProperty(exports, "IsolatedTransaction", { enumerable: true, get: function () { return IsolatedTransaction_decorator_1.IsolatedTransaction; } });
+Object.defineProperty(exports, "isIsolatedTransaction", { enumerable: true, get: function () { return IsolatedTransaction_decorator_1.isIsolatedTransaction; } });
+var Workflow_decorator_1 = require("./cqrs/decorators/Workflow.decorator");
+Object.defineProperty(exports, "Workflow", { enumerable: true, get: function () { return Workflow_decorator_1.Workflow; } });
+Object.defineProperty(exports, "getWorkflowMetadata", { enumerable: true, get: function () { return Workflow_decorator_1.getWorkflowMetadata; } });
+// Workflow Engine Interface
+var WorkflowEngine_1 = require("./cqrs/interfaces/WorkflowEngine");
+Object.defineProperty(exports, "WORKFLOW_ENGINE", { enumerable: true, get: function () { return WorkflowEngine_1.WORKFLOW_ENGINE; } });
+// Transaction (UnitOfWork)
+var TransactionContext_1 = require("./cqrs/transaction/TransactionContext");
+Object.defineProperty(exports, "TransactionContext", { enumerable: true, get: function () { return TransactionContext_1.TransactionContext; } });
+var getTransactionalRepo_1 = require("./cqrs/transaction/getTransactionalRepo");
+Object.defineProperty(exports, "getTransactionalRepo", { enumerable: true, get: function () { return getTransactionalRepo_1.getTransactionalRepo; } });
+// Metrics
+var MetricsService_1 = require("./metrics/MetricsService");
+Object.defineProperty(exports, "MetricsService", { enumerable: true, get: function () { return MetricsService_1.MetricsService; } });
+var MetricsController_1 = require("./metrics/MetricsController");
+Object.defineProperty(exports, "MetricsController", { enumerable: true, get: function () { return MetricsController_1.MetricsController; } });
+// CQRS Behaviors
+var LogBehavior_1 = require("./cqrs/behaviors/LogBehavior");
+Object.defineProperty(exports, "LogBehavior", { enumerable: true, get: function () { return LogBehavior_1.LogBehavior; } });
+var FeatureFlagBehavior_1 = require("./cqrs/behaviors/FeatureFlagBehavior");
+Object.defineProperty(exports, "FeatureFlagBehavior", { enumerable: true, get: function () { return FeatureFlagBehavior_1.FeatureFlagBehavior; } });
+var ValidationBehavior_1 = require("./cqrs/behaviors/ValidationBehavior");
+Object.defineProperty(exports, "ValidationBehavior", { enumerable: true, get: function () { return ValidationBehavior_1.ValidationBehavior; } });
+var CacheBehavior_1 = require("./cqrs/behaviors/CacheBehavior");
+Object.defineProperty(exports, "CacheBehavior", { enumerable: true, get: function () { return CacheBehavior_1.CacheBehavior; } });
+var InvalidateCacheBehavior_1 = require("./cqrs/behaviors/InvalidateCacheBehavior");
+Object.defineProperty(exports, "InvalidateCacheBehavior", { enumerable: true, get: function () { return InvalidateCacheBehavior_1.InvalidateCacheBehavior; } });
+var DistributedLockBehavior_1 = require("./cqrs/behaviors/DistributedLockBehavior");
+Object.defineProperty(exports, "DistributedLockBehavior", { enumerable: true, get: function () { return DistributedLockBehavior_1.DistributedLockBehavior; } });
+var TransactionalBehavior_1 = require("./cqrs/behaviors/TransactionalBehavior");
+Object.defineProperty(exports, "TransactionalBehavior", { enumerable: true, get: function () { return TransactionalBehavior_1.TransactionalBehavior; } });
+var PerformanceBehavior_1 = require("./cqrs/behaviors/PerformanceBehavior");
+Object.defineProperty(exports, "PerformanceBehavior", { enumerable: true, get: function () { return PerformanceBehavior_1.PerformanceBehavior; } });
+var WorkflowBehavior_1 = require("./cqrs/behaviors/WorkflowBehavior");
+Object.defineProperty(exports, "WorkflowBehavior", { enumerable: true, get: function () { return WorkflowBehavior_1.WorkflowBehavior; } });
+// CQRS Pipeline
+var QuanticCommandBus_1 = require("./cqrs/pipeline/QuanticCommandBus");
+Object.defineProperty(exports, "QuanticCommandBus", { enumerable: true, get: function () { return QuanticCommandBus_1.QuanticCommandBus; } });
+var QuanticQueryBus_1 = require("./cqrs/pipeline/QuanticQueryBus");
+Object.defineProperty(exports, "QuanticQueryBus", { enumerable: true, get: function () { return QuanticQueryBus_1.QuanticQueryBus; } });
+// Redis
+var redis_module_1 = require("./redis/redis.module");
+Object.defineProperty(exports, "RedisModule", { enumerable: true, get: function () { return redis_module_1.RedisModule; } });
+// Events
+var DomainEvent_1 = require("./events/DomainEvent");
+Object.defineProperty(exports, "DomainEvent", { enumerable: true, get: function () { return DomainEvent_1.DomainEvent; } });
+var OutboxEvent_entity_1 = require("./events/OutboxEvent.entity");
+Object.defineProperty(exports, "OutboxEvent", { enumerable: true, get: function () { return OutboxEvent_entity_1.OutboxEvent; } });
+Object.defineProperty(exports, "OutboxEventStatus", { enumerable: true, get: function () { return OutboxEvent_entity_1.OutboxEventStatus; } });
+var RedisStreamPublisher_1 = require("./events/RedisStreamPublisher");
+Object.defineProperty(exports, "RedisStreamPublisher", { enumerable: true, get: function () { return RedisStreamPublisher_1.RedisStreamPublisher; } });
+var RedisStreamConsumer_1 = require("./events/RedisStreamConsumer");
+Object.defineProperty(exports, "RedisStreamConsumer", { enumerable: true, get: function () { return RedisStreamConsumer_1.RedisStreamConsumer; } });
+var OutboxPublisherService_1 = require("./events/OutboxPublisherService");
+Object.defineProperty(exports, "OutboxPublisherService", { enumerable: true, get: function () { return OutboxPublisherService_1.OutboxPublisherService; } });
+// Unleash
+var unleash_module_1 = require("./unleash/unleash.module");
+Object.defineProperty(exports, "UnleashModule", { enumerable: true, get: function () { return unleash_module_1.UnleashModule; } });
+// Lifecycle
+var GracefulShutdownService_1 = require("./lifecycle/GracefulShutdownService");
+Object.defineProperty(exports, "GracefulShutdownService", { enumerable: true, get: function () { return GracefulShutdownService_1.GracefulShutdownService; } });
+// QuanticModule
+var shared_kernel_module_1 = require("./shared-kernel.module");
+Object.defineProperty(exports, "QuanticModule", { enumerable: true, get: function () { return shared_kernel_module_1.QuanticModule; } });
+Object.defineProperty(exports, "SharedKernelModule", { enumerable: true, get: function () { return shared_kernel_module_1.SharedKernelModule; } });
+// Testing mock helpers (safe for prod — no @nestjs/testing dependency)
+var mocks_1 = require("./testing/mocks");
+Object.defineProperty(exports, "createMockRepository", { enumerable: true, get: function () { return mocks_1.createMockRepository; } });
+Object.defineProperty(exports, "createMockRedisClient", { enumerable: true, get: function () { return mocks_1.createMockRedisClient; } });

package/dist/interceptors/ResultInterceptor.d.ts

@@ -0,0 +1,7 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class ResultInterceptor implements NestInterceptor {
+    private readonly logger;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    private sendResultError;
+}

package/dist/interceptors/ResultInterceptor.js

@@ -0,0 +1,88 @@
+"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 ResultInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const Result_1 = require("../result/Result");
+const CorrelationStore_1 = require("../middleware/CorrelationStore");
+const ERROR_TYPE_TO_STATUS = {
+    [Result_1.ErrorType.NotFound]: 404,
+    [Result_1.ErrorType.Forbidden]: 403,
+    [Result_1.ErrorType.Unauthorized]: 401,
+    [Result_1.ErrorType.Conflict]: 409,
+    [Result_1.ErrorType.ValidationError]: 400,
+    [Result_1.ErrorType.UnprocessableEntity]: 422,
+    [Result_1.ErrorType.InternalError]: 500,
+};
+const ERROR_TYPE_TO_TITLE = {
+    [Result_1.ErrorType.NotFound]: 'Not Found',
+    [Result_1.ErrorType.Forbidden]: 'Forbidden',
+    [Result_1.ErrorType.Unauthorized]: 'Unauthorized',
+    [Result_1.ErrorType.Conflict]: 'Conflict',
+    [Result_1.ErrorType.ValidationError]: 'Validation Error',
+    [Result_1.ErrorType.UnprocessableEntity]: 'Unprocessable Entity',
+    [Result_1.ErrorType.InternalError]: 'Internal Server Error',
+};
+let ResultInterceptor = ResultInterceptor_1 = class ResultInterceptor {
+    logger = new common_1.Logger(ResultInterceptor_1.name);
+    intercept(context, next) {
+        return next.handle().pipe((0, rxjs_1.switchMap)((data) => {
+            if (data instanceof Result_1.Result && !data.isSuccess) {
+                this.sendResultError(context, data);
+                return rxjs_1.EMPTY;
+            }
+            return (0, rxjs_1.of)(data);
+        }), (0, rxjs_1.catchError)((error) => {
+            if (error instanceof Result_1.Result) {
+                this.sendResultError(context, error);
+                return rxjs_1.EMPTY;
+            }
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({
+                msg: 'Unhandled exception before CQRS pipeline',
+                error: err.message,
+                stack: err.stack,
+            });
+            this.sendResultError(context, Result_1.Result.failure(Result_1.ErrorType.InternalError, err.message));
+            return rxjs_1.EMPTY;
+        }));
+    }
+    sendResultError(context, result) {
+        const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
+        const correlationId = CorrelationStore_1.correlationStore.getStore()?.correlationId;
+        const status = ERROR_TYPE_TO_STATUS[result.errorType] ?? 500;
+        const title = ERROR_TYPE_TO_TITLE[result.errorType] ?? 'Unknown Error';
+        if (correlationId) {
+            response.setHeader('X-Correlation-ID', correlationId);
+        }
+        this.logger.warn({
+            msg: `${status} ${result.errorType}`,
+            correlationId,
+            status,
+            detail: result.errorMessage,
+        });
+        response
+            .status(status)
+            .setHeader('Content-Type', 'application/problem+json')
+            .json({
+            type: `https://arex.dev/errors/${result.errorType}`,
+            title,
+            status,
+            detail: result.errorMessage,
+            instance: request.originalUrl,
+            correlationId,
+        });
+    }
+};
+exports.ResultInterceptor = ResultInterceptor;
+exports.ResultInterceptor = ResultInterceptor = ResultInterceptor_1 = __decorate([
+    (0, common_1.Injectable)()
+], ResultInterceptor);

package/dist/lifecycle/GracefulShutdownService.d.ts

@@ -0,0 +1,24 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import type { Redis } from 'ioredis';
+/**
+ * GracefulShutdownService ensures clean resource teardown on SIGTERM/SIGINT.
+ *
+ * Shutdown order:
+ * 1. Wait for in-flight work (subclasses can override `drainWork`)
+ * 2. Close database connections
+ * 3. Quit Redis
+ */
+export declare class GracefulShutdownService implements OnModuleDestroy {
+    private readonly dataSource?;
+    private readonly redis?;
+    private readonly logger;
+    constructor(dataSource?: DataSource | undefined, redis?: Redis | undefined);
+    onModuleDestroy(): Promise<void>;
+    /**
+     * Override in service-specific subclasses to drain Bull queues,
+     * close Socket.IO servers, etc.
+     */
+    protected drainWork(): Promise<void>;
+    private withTimeout;
+}

package/dist/lifecycle/GracefulShutdownService.js

@@ -0,0 +1,93 @@
+"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 GracefulShutdownService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GracefulShutdownService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const constants_1 = require("../cqrs/constants");
+const SHUTDOWN_TIMEOUT_MS = 30_000;
+/**
+ * GracefulShutdownService ensures clean resource teardown on SIGTERM/SIGINT.
+ *
+ * Shutdown order:
+ * 1. Wait for in-flight work (subclasses can override `drainWork`)
+ * 2. Close database connections
+ * 3. Quit Redis
+ */
+let GracefulShutdownService = GracefulShutdownService_1 = class GracefulShutdownService {
+    dataSource;
+    redis;
+    logger = new common_1.Logger(GracefulShutdownService_1.name);
+    constructor(dataSource, redis) {
+        this.dataSource = dataSource;
+        this.redis = redis;
+    }
+    async onModuleDestroy() {
+        this.logger.log('Graceful shutdown initiated...');
+        // 1. Drain in-flight work with timeout
+        try {
+            await this.withTimeout(this.drainWork(), SHUTDOWN_TIMEOUT_MS, 'Work drain');
+        }
+        catch (err) {
+            this.logger.warn(`Work drain timeout or error: ${err.message}`);
+        }
+        // 2. Close database connections
+        if (this.dataSource?.isInitialized) {
+            try {
+                await this.dataSource.destroy();
+                this.logger.log('Database connections closed');
+            }
+            catch (err) {
+                this.logger.warn(`Database close error: ${err.message}`);
+            }
+        }
+        // 3. Quit Redis
+        if (this.redis) {
+            try {
+                await this.redis.quit();
+                this.logger.log('Redis connection closed');
+            }
+            catch (err) {
+                this.logger.warn(`Redis quit error: ${err.message}`);
+            }
+        }
+        this.logger.log('Graceful shutdown complete');
+    }
+    /**
+     * Override in service-specific subclasses to drain Bull queues,
+     * close Socket.IO servers, etc.
+     */
+    async drainWork() {
+        // Base implementation — no-op
+    }
+    withTimeout(promise, ms, label) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`${label} timed out after ${ms}ms`));
+            }, ms);
+            promise
+                .then(() => { clearTimeout(timer); resolve(); })
+                .catch((err) => { clearTimeout(timer); reject(err); });
+        });
+    }
+};
+exports.GracefulShutdownService = GracefulShutdownService;
+exports.GracefulShutdownService = GracefulShutdownService = GracefulShutdownService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)(constants_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [typeorm_1.DataSource, Function])
+], GracefulShutdownService);

package/dist/logging/pino-config.d.ts

@@ -0,0 +1,35 @@
+export declare function createPinoConfig(serviceName: string): {
+    pinoHttp: {
+        level: string;
+        transport: {
+            target: string;
+            options: {
+                serverUrl: string;
+                logOtherAs: string;
+            };
+            targets?: undefined;
+        } | {
+            targets: any[];
+            target?: undefined;
+            options?: undefined;
+        };
+        serializers: {
+            req(req: any): {
+                id: any;
+                method: any;
+                url: any;
+                correlationId: any;
+            };
+            res(res: any): {
+                statusCode: any;
+            };
+            email(value: string): string;
+            token(_value: string): string;
+            brd(value: string): string;
+        };
+        customProps(req: any): {
+            correlationId: any;
+            service: string;
+        };
+    };
+};

package/dist/logging/pino-config.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPinoConfig = createPinoConfig;
+function canResolvePinoSeq() {
+    try {
+        require.resolve('pino-seq');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildTransport(logLevel) {
+    const seqUrl = process.env['SEQ_URL'];
+    const useSeq = seqUrl && canResolvePinoSeq();
+    if (process.env['NODE_ENV'] === 'production' && useSeq) {
+        return {
+            target: 'pino-seq',
+            options: { serverUrl: seqUrl, logOtherAs: 'Verbose' },
+        };
+    }
+    const targets = [
+        { target: 'pino/file', options: { destination: 1 }, level: logLevel },
+    ];
+    if (useSeq) {
+        targets.push({
+            target: 'pino-seq',
+            options: { serverUrl: seqUrl, logOtherAs: 'Verbose' },
+            level: logLevel,
+        });
+    }
+    return { targets };
+}
+function createPinoConfig(serviceName) {
+    const logLevel = process.env['LOG_LEVEL'] || 'info';
+    return {
+        pinoHttp: {
+            level: logLevel,
+            transport: buildTransport(logLevel),
+            serializers: {
+                req(req) {
+                    return {
+                        id: req.id,
+                        method: req.method,
+                        url: req.url,
+                        correlationId: req.raw?.correlationId || req.headers?.['x-correlation-id'],
+                    };
+                },
+                res(res) {
+                    return {
+                        statusCode: res.statusCode,
+                    };
+                },
+                email(value) {
+                    if (!value || typeof value !== 'string')
+                        return value;
+                    const [local, domain] = value.split('@');
+                    if (!domain)
+                        return value;
+                    return `${local[0]}***@${domain}`;
+                },
+                token(_value) {
+                    return '[REDACTED]';
+                },
+                brd(value) {
+                    if (!value || typeof value !== 'string')
+                        return value;
+                    return value.length > 50 ? `${value.substring(0, 50)}...` : value;
+                },
+            },
+            customProps(req) {
+                return {
+                    correlationId: req.correlationId || req.headers?.['x-correlation-id'],
+                    service: serviceName,
+                };
+            },
+        },
+    };
+}

package/dist/metrics/MetricsController.d.ts

@@ -0,0 +1,7 @@
+import { Response } from 'express';
+import { MetricsService } from './MetricsService';
+export declare class MetricsController {
+    private readonly metrics;
+    constructor(metrics: MetricsService);
+    getMetrics(res: Response): Promise<void>;
+}