@quanticjs/core 1.1.1

package/dist/metrics/MetricsController.js

@@ -0,0 +1,42 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsController = void 0;
+const common_1 = require("@nestjs/common");
+const JwtAuthGuard_1 = require("../guards/JwtAuthGuard");
+const MetricsService_1 = require("./MetricsService");
+let MetricsController = class MetricsController {
+    metrics;
+    constructor(metrics) {
+        this.metrics = metrics;
+    }
+    async getMetrics(res) {
+        const metricsOutput = await this.metrics.getMetrics();
+        res.set('Content-Type', this.metrics.getContentType());
+        res.end(metricsOutput);
+    }
+};
+exports.MetricsController = MetricsController;
+__decorate([
+    (0, common_1.Get)('metrics'),
+    __param(0, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MetricsController.prototype, "getMetrics", null);
+exports.MetricsController = MetricsController = __decorate([
+    (0, JwtAuthGuard_1.Public)(),
+    (0, common_1.Controller)(),
+    __metadata("design:paramtypes", [MetricsService_1.MetricsService])
+], MetricsController);

package/dist/metrics/MetricsService.d.ts

@@ -0,0 +1,13 @@
+import { OnModuleInit } from '@nestjs/common';
+import { Registry, Counter, Histogram, Gauge } from 'prom-client';
+export declare class MetricsService implements OnModuleInit {
+    readonly registry: Registry<"text/plain; version=0.0.4; charset=utf-8">;
+    readonly buildTotal: Counter<"status" | "tech_stack">;
+    readonly stageDuration: Histogram<"status" | "stage_type">;
+    readonly promptCacheHits: Counter<string>;
+    readonly queueDepth: Gauge<"queue">;
+    readonly handlerDuration: Histogram<"handler" | "result">;
+    onModuleInit(): void;
+    getMetrics(): Promise<string>;
+    getContentType(): string;
+}

package/dist/metrics/MetricsService.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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsService = void 0;
+const common_1 = require("@nestjs/common");
+const prom_client_1 = require("prom-client");
+let MetricsService = class MetricsService {
+    registry = new prom_client_1.Registry();
+    buildTotal = new prom_client_1.Counter({
+        name: 'arex_build_total',
+        help: 'Total number of builds',
+        labelNames: ['status', 'tech_stack'],
+        registers: [this.registry],
+    });
+    stageDuration = new prom_client_1.Histogram({
+        name: 'arex_stage_duration_seconds',
+        help: 'Duration of pipeline stages in seconds',
+        labelNames: ['stage_type', 'status'],
+        buckets: [0.5, 1, 2, 5, 10, 30, 60, 120, 300],
+        registers: [this.registry],
+    });
+    promptCacheHits = new prom_client_1.Counter({
+        name: 'arex_prompt_cache_hits_total',
+        help: 'Total prompt cache hits',
+        registers: [this.registry],
+    });
+    queueDepth = new prom_client_1.Gauge({
+        name: 'arex_queue_depth',
+        help: 'Current depth of Bull job queue',
+        labelNames: ['queue'],
+        registers: [this.registry],
+    });
+    handlerDuration = new prom_client_1.Histogram({
+        name: 'arex_handler_duration_seconds',
+        help: 'Duration of command/query handlers in seconds',
+        labelNames: ['handler', 'result'],
+        buckets: [0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5],
+        registers: [this.registry],
+    });
+    onModuleInit() {
+        (0, prom_client_1.collectDefaultMetrics)({ register: this.registry });
+    }
+    async getMetrics() {
+        return this.registry.metrics();
+    }
+    getContentType() {
+        return this.registry.contentType;
+    }
+};
+exports.MetricsService = MetricsService;
+exports.MetricsService = MetricsService = __decorate([
+    (0, common_1.Injectable)()
+], MetricsService);

package/dist/middleware/CorrelationIdMiddleware.d.ts

@@ -0,0 +1,4 @@
+import { NestMiddleware } from '@nestjs/common';
+export declare class CorrelationIdMiddleware implements NestMiddleware {
+    use(req: any, res: any, next: () => void): void;
+}

package/dist/middleware/CorrelationIdMiddleware.js

@@ -0,0 +1,33 @@
+"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.CorrelationIdMiddleware = void 0;
+const common_1 = require("@nestjs/common");
+const uuid_1 = require("uuid");
+const CorrelationStore_1 = require("./CorrelationStore");
+const CORRELATION_ID_HEADER = 'X-Correlation-ID';
+let CorrelationIdMiddleware = class CorrelationIdMiddleware {
+    use(req, res, next) {
+        const correlationId = req.headers[CORRELATION_ID_HEADER.toLowerCase()] || (0, uuid_1.v4)();
+        req.correlationId = correlationId;
+        req.headers[CORRELATION_ID_HEADER.toLowerCase()] = correlationId;
+        res.setHeader(CORRELATION_ID_HEADER, correlationId);
+        const storeData = {
+            correlationId,
+            userId: req.user?.keycloakId,
+            organizationId: req.user?.organizationId,
+        };
+        CorrelationStore_1.correlationStore.run(storeData, () => {
+            next();
+        });
+    }
+};
+exports.CorrelationIdMiddleware = CorrelationIdMiddleware;
+exports.CorrelationIdMiddleware = CorrelationIdMiddleware = __decorate([
+    (0, common_1.Injectable)()
+], CorrelationIdMiddleware);

package/dist/middleware/CorrelationStore.d.ts

@@ -0,0 +1,11 @@
+import { AsyncLocalStorage } from 'async_hooks';
+export interface CorrelationStoreData {
+    correlationId: string;
+    userId?: string;
+    organizationId?: string;
+}
+/**
+ * Request-scoped async local storage for correlation context.
+ * Set by CorrelationIdMiddleware, read by LogBehavior and error filters.
+ */
+export declare const correlationStore: AsyncLocalStorage<CorrelationStoreData>;

package/dist/middleware/CorrelationStore.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.correlationStore = void 0;
+const async_hooks_1 = require("async_hooks");
+/**
+ * Request-scoped async local storage for correlation context.
+ * Set by CorrelationIdMiddleware, read by LogBehavior and error filters.
+ */
+exports.correlationStore = new async_hooks_1.AsyncLocalStorage();

package/dist/middleware/TenantContextMiddleware.d.ts

@@ -0,0 +1,7 @@
+import { NestMiddleware } from '@nestjs/common';
+export interface TenantContext {
+    organizationId: string | null;
+}
+export declare class TenantContextMiddleware implements NestMiddleware {
+    use(req: any, _res: any, next: () => void): void;
+}

package/dist/middleware/TenantContextMiddleware.js

@@ -0,0 +1,27 @@
+"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.TenantContextMiddleware = void 0;
+const common_1 = require("@nestjs/common");
+const TenantStore_1 = require("./TenantStore");
+let TenantContextMiddleware = class TenantContextMiddleware {
+    use(req, _res, next) {
+        // Extract org_id from JWT payload (set by JwtAuthGuard)
+        const orgId = req.user?.organizationId || req.headers['x-tenant-id'] || null;
+        req.tenantId = orgId;
+        req.tenantContext = { organizationId: orgId };
+        // Store in AsyncLocalStorage so TenantSubscriber can access it
+        TenantStore_1.tenantStore.run({ organizationId: orgId }, () => {
+            next();
+        });
+    }
+};
+exports.TenantContextMiddleware = TenantContextMiddleware;
+exports.TenantContextMiddleware = TenantContextMiddleware = __decorate([
+    (0, common_1.Injectable)()
+], TenantContextMiddleware);

package/dist/middleware/TenantStore.d.ts

@@ -0,0 +1,9 @@
+import { AsyncLocalStorage } from 'async_hooks';
+export interface TenantStoreData {
+    organizationId: string | null;
+}
+/**
+ * Request-scoped async local storage for tenant context.
+ * Set by TenantContextMiddleware, read by TenantSubscriber.
+ */
+export declare const tenantStore: AsyncLocalStorage<TenantStoreData>;

package/dist/middleware/TenantStore.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tenantStore = void 0;
+const async_hooks_1 = require("async_hooks");
+/**
+ * Request-scoped async local storage for tenant context.
+ * Set by TenantContextMiddleware, read by TenantSubscriber.
+ */
+exports.tenantStore = new async_hooks_1.AsyncLocalStorage();

package/dist/redis/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/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 constants_1 = require("../cqrs/constants");
+let RedisModule = class RedisModule {
+    static { RedisModule_1 = this; }
+    static logger = new common_1.Logger('RedisModule');
+    static forRoot(options = {}) {
+        const redisProvider = {
+            provide: constants_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: [constants_1.REDIS_CLIENT],
+        };
+    }
+};
+exports.RedisModule = RedisModule;
+exports.RedisModule = RedisModule = RedisModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], RedisModule);

package/dist/resilience/CircuitBreakerFactory.d.ts

@@ -0,0 +1,12 @@
+export interface CircuitBreakerOptions {
+    halfOpenAfterMs?: number;
+    consecutiveFailures?: number;
+    maxRetries?: number;
+}
+/**
+ * Creates a resilience policy combining retry + circuit breaker.
+ * Usage:
+ *   const policy = createCircuitBreaker({ consecutiveFailures: 5 });
+ *   const result = await policy.execute(() => httpCall());
+ */
+export declare function createCircuitBreaker(options?: CircuitBreakerOptions): import("cockatiel").IMergedPolicy<import("cockatiel").IRetryContext & import("cockatiel").IDefaultPolicyContext, never, [import("cockatiel").RetryPolicy, import("cockatiel").CircuitBreakerPolicy]>;

package/dist/resilience/CircuitBreakerFactory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCircuitBreaker = createCircuitBreaker;
+const cockatiel_1 = require("cockatiel");
+/**
+ * Creates a resilience policy combining retry + circuit breaker.
+ * Usage:
+ *   const policy = createCircuitBreaker({ consecutiveFailures: 5 });
+ *   const result = await policy.execute(() => httpCall());
+ */
+function createCircuitBreaker(options = {}) {
+    const { halfOpenAfterMs = 30_000, consecutiveFailures = 5, maxRetries = 2, } = options;
+    const retryPolicy = (0, cockatiel_1.retry)(cockatiel_1.handleAll, {
+        maxAttempts: maxRetries,
+        backoff: new cockatiel_1.ExponentialBackoff(),
+    });
+    const breaker = (0, cockatiel_1.circuitBreaker)(cockatiel_1.handleAll, {
+        halfOpenAfter: halfOpenAfterMs,
+        breaker: new cockatiel_1.ConsecutiveBreaker(consecutiveFailures),
+    });
+    return (0, cockatiel_1.wrap)(retryPolicy, breaker);
+}

package/dist/result/Result.d.ts

@@ -0,0 +1,26 @@
+export declare enum ErrorType {
+    NotFound = "NOT_FOUND",
+    Forbidden = "FORBIDDEN",
+    Conflict = "CONFLICT",
+    ValidationError = "VALIDATION_ERROR",
+    InternalError = "INTERNAL_ERROR",
+    Unauthorized = "UNAUTHORIZED",
+    UnprocessableEntity = "UNPROCESSABLE_ENTITY"
+}
+export declare class Result<T> {
+    readonly isSuccess: boolean;
+    readonly value?: T | undefined;
+    readonly errorType?: ErrorType | undefined;
+    readonly errorMessage?: string | undefined;
+    private constructor();
+    static success<T>(value: T): Result<T>;
+    static failure<T>(errorType: ErrorType, message: string): Result<T>;
+    static notFound<T>(message: string): Result<T>;
+    static forbidden<T>(message: string): Result<T>;
+    static conflict<T>(message: string): Result<T>;
+    static validationError<T>(message: string): Result<T>;
+    static unauthorized<T>(message: string): Result<T>;
+    static unprocessableEntity<T>(message: string): Result<T>;
+    unwrap(): T;
+    map<U>(fn: (value: T) => U): Result<U>;
+}

package/dist/result/Result.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = exports.ErrorType = void 0;
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["NotFound"] = "NOT_FOUND";
+    ErrorType["Forbidden"] = "FORBIDDEN";
+    ErrorType["Conflict"] = "CONFLICT";
+    ErrorType["ValidationError"] = "VALIDATION_ERROR";
+    ErrorType["InternalError"] = "INTERNAL_ERROR";
+    ErrorType["Unauthorized"] = "UNAUTHORIZED";
+    ErrorType["UnprocessableEntity"] = "UNPROCESSABLE_ENTITY";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));
+class Result {
+    isSuccess;
+    value;
+    errorType;
+    errorMessage;
+    constructor(isSuccess, value, errorType, errorMessage) {
+        this.isSuccess = isSuccess;
+        this.value = value;
+        this.errorType = errorType;
+        this.errorMessage = errorMessage;
+    }
+    static success(value) {
+        return new Result(true, value);
+    }
+    static failure(errorType, message) {
+        return new Result(false, undefined, errorType, message);
+    }
+    static notFound(message) {
+        return Result.failure(ErrorType.NotFound, message);
+    }
+    static forbidden(message) {
+        return Result.failure(ErrorType.Forbidden, message);
+    }
+    static conflict(message) {
+        return Result.failure(ErrorType.Conflict, message);
+    }
+    static validationError(message) {
+        return Result.failure(ErrorType.ValidationError, message);
+    }
+    static unauthorized(message) {
+        return Result.failure(ErrorType.Unauthorized, message);
+    }
+    static unprocessableEntity(message) {
+        return Result.failure(ErrorType.UnprocessableEntity, message);
+    }
+    unwrap() {
+        if (!this.isSuccess || this.value === undefined) {
+            throw new Error(`Cannot unwrap failed Result: ${this.errorType} - ${this.errorMessage}`);
+        }
+        return this.value;
+    }
+    map(fn) {
+        if (this.isSuccess && this.value !== undefined) {
+            return Result.success(fn(this.value));
+        }
+        return Result.failure(this.errorType, this.errorMessage);
+    }
+}
+exports.Result = Result;

package/dist/shared-kernel.module.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule } from '@nestjs/common';
+import { type RedisModuleOptions } from './redis/redis.module';
+import { type UnleashModuleOptions } from './unleash/unleash.module';
+export type SharedKernelModuleOptions = QuanticModuleOptions;
+export interface QuanticModuleOptions {
+    redis?: RedisModuleOptions;
+    unleash?: UnleashModuleOptions | false;
+}
+export declare class QuanticModule {
+    static forRoot(options?: QuanticModuleOptions): DynamicModule;
+}
+/** @deprecated Use QuanticModule instead */
+export declare const SharedKernelModule: typeof QuanticModule;

package/dist/shared-kernel.module.js

@@ -0,0 +1,87 @@
+"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 QuanticModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedKernelModule = exports.QuanticModule = void 0;
+const common_1 = require("@nestjs/common");
+const cqrs_1 = require("@nestjs/cqrs");
+const QuanticCommandBus_1 = require("./cqrs/pipeline/QuanticCommandBus");
+const QuanticQueryBus_1 = require("./cqrs/pipeline/QuanticQueryBus");
+const LogBehavior_1 = require("./cqrs/behaviors/LogBehavior");
+const ValidationBehavior_1 = require("./cqrs/behaviors/ValidationBehavior");
+const CacheBehavior_1 = require("./cqrs/behaviors/CacheBehavior");
+const DistributedLockBehavior_1 = require("./cqrs/behaviors/DistributedLockBehavior");
+const TransactionalBehavior_1 = require("./cqrs/behaviors/TransactionalBehavior");
+const PerformanceBehavior_1 = require("./cqrs/behaviors/PerformanceBehavior");
+const WorkflowBehavior_1 = require("./cqrs/behaviors/WorkflowBehavior");
+const InvalidateCacheBehavior_1 = require("./cqrs/behaviors/InvalidateCacheBehavior");
+const MetricsService_1 = require("./metrics/MetricsService");
+const MetricsController_1 = require("./metrics/MetricsController");
+const GracefulShutdownService_1 = require("./lifecycle/GracefulShutdownService");
+const RedisStreamPublisher_1 = require("./events/RedisStreamPublisher");
+const redis_module_1 = require("./redis/redis.module");
+const unleash_module_1 = require("./unleash/unleash.module");
+let QuanticModule = QuanticModule_1 = class QuanticModule {
+    static forRoot(options = {}) {
+        const imports = [
+            cqrs_1.CqrsModule.forRoot(),
+            redis_module_1.RedisModule.forRoot(options.redis),
+        ];
+        if (options.unleash !== false) {
+            imports.push(unleash_module_1.UnleashModule.forRoot(options.unleash));
+        }
+        const exports = [
+            cqrs_1.CqrsModule,
+            redis_module_1.RedisModule,
+            RedisStreamPublisher_1.RedisStreamPublisher,
+            LogBehavior_1.LogBehavior,
+            ValidationBehavior_1.ValidationBehavior,
+            CacheBehavior_1.CacheBehavior,
+            InvalidateCacheBehavior_1.InvalidateCacheBehavior,
+            DistributedLockBehavior_1.DistributedLockBehavior,
+            TransactionalBehavior_1.TransactionalBehavior,
+            PerformanceBehavior_1.PerformanceBehavior,
+            WorkflowBehavior_1.WorkflowBehavior,
+            MetricsService_1.MetricsService,
+            GracefulShutdownService_1.GracefulShutdownService,
+            QuanticCommandBus_1.QuanticCommandBus,
+            QuanticQueryBus_1.QuanticQueryBus,
+        ];
+        if (options.unleash !== false) {
+            exports.push(unleash_module_1.UnleashModule);
+        }
+        return {
+            module: QuanticModule_1,
+            imports,
+            controllers: [MetricsController_1.MetricsController],
+            providers: [
+                LogBehavior_1.LogBehavior,
+                ValidationBehavior_1.ValidationBehavior,
+                CacheBehavior_1.CacheBehavior,
+                InvalidateCacheBehavior_1.InvalidateCacheBehavior,
+                DistributedLockBehavior_1.DistributedLockBehavior,
+                TransactionalBehavior_1.TransactionalBehavior,
+                PerformanceBehavior_1.PerformanceBehavior,
+                WorkflowBehavior_1.WorkflowBehavior,
+                MetricsService_1.MetricsService,
+                GracefulShutdownService_1.GracefulShutdownService,
+                RedisStreamPublisher_1.RedisStreamPublisher,
+                QuanticCommandBus_1.QuanticCommandBus,
+                QuanticQueryBus_1.QuanticQueryBus,
+            ],
+            exports,
+        };
+    }
+};
+exports.QuanticModule = QuanticModule;
+exports.QuanticModule = QuanticModule = QuanticModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], QuanticModule);
+/** @deprecated Use QuanticModule instead */
+exports.SharedKernelModule = QuanticModule;

package/dist/subscribers/TenantSubscriber.d.ts

@@ -0,0 +1,20 @@
+import { EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
+import { TenantBaseEntity } from '../entities/TenantBaseEntity';
+/**
+ * TypeORM subscriber that sets PostgreSQL session variable `app.current_org_id`
+ * before write operations on tenant-scoped entities. This enables RLS policies.
+ *
+ * For SELECT queries, RLS is enforced via the session variable set by the
+ * TransactionalBehavior or manually via `SET LOCAL app.current_org_id`.
+ *
+ * Register this subscriber in each service's TypeORM DataSource config:
+ *   subscribers: [TenantSubscriber]
+ */
+export declare class TenantSubscriber implements EntitySubscriberInterface<TenantBaseEntity> {
+    listenTo(): typeof TenantBaseEntity;
+    beforeInsert(event: InsertEvent<TenantBaseEntity>): Promise<void>;
+    beforeUpdate(event: UpdateEvent<TenantBaseEntity>): Promise<void>;
+    beforeRemove(event: RemoveEvent<TenantBaseEntity>): Promise<void>;
+    private getOrgIdFromStore;
+    private setTenantId;
+}

package/dist/subscribers/TenantSubscriber.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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantSubscriber = void 0;
+const typeorm_1 = require("typeorm");
+const TenantBaseEntity_1 = require("../entities/TenantBaseEntity");
+const TenantStore_1 = require("../middleware/TenantStore");
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * TypeORM subscriber that sets PostgreSQL session variable `app.current_org_id`
+ * before write operations on tenant-scoped entities. This enables RLS policies.
+ *
+ * For SELECT queries, RLS is enforced via the session variable set by the
+ * TransactionalBehavior or manually via `SET LOCAL app.current_org_id`.
+ *
+ * Register this subscriber in each service's TypeORM DataSource config:
+ *   subscribers: [TenantSubscriber]
+ */
+let TenantSubscriber = class TenantSubscriber {
+    listenTo() {
+        return TenantBaseEntity_1.TenantBaseEntity;
+    }
+    async beforeInsert(event) {
+        const orgId = event.entity?.organizationId ?? this.getOrgIdFromStore();
+        await this.setTenantId(event.queryRunner, orgId);
+    }
+    async beforeUpdate(event) {
+        const orgId = event.entity?.organizationId ?? this.getOrgIdFromStore();
+        await this.setTenantId(event.queryRunner, orgId);
+    }
+    async beforeRemove(event) {
+        const orgId = event.entity?.organizationId ?? this.getOrgIdFromStore();
+        await this.setTenantId(event.queryRunner, orgId);
+    }
+    getOrgIdFromStore() {
+        return TenantStore_1.tenantStore.getStore()?.organizationId ?? null;
+    }
+    async setTenantId(queryRunner, organizationId) {
+        if (organizationId && UUID_REGEX.test(organizationId)) {
+            await queryRunner.query(`SET LOCAL app.current_org_id = '${organizationId}'`);
+        }
+    }
+};
+exports.TenantSubscriber = TenantSubscriber;
+exports.TenantSubscriber = TenantSubscriber = __decorate([
+    (0, typeorm_1.EventSubscriber)()
+], TenantSubscriber);

package/dist/testing/TestingModuleFactory.d.ts

@@ -0,0 +1,23 @@
+import { TestingModuleBuilder } from '@nestjs/testing';
+import { createMockRepository, createMockRedisClient } from './mocks';
+export { createMockRepository, createMockRedisClient };
+export interface TestingModuleOptions {
+    /** Providers to register (handlers, services, etc.) */
+    providers?: any[];
+    /** Entity classes to auto-mock their repositories */
+    entities?: any[];
+    /** Additional overrides to apply to the TestingModule builder */
+    overrides?: Array<{
+        provide: any;
+        useValue: any;
+    }>;
+    /** Whether to include the full CQRS pipeline behaviors (default: false) */
+    withPipeline?: boolean;
+}
+/**
+ * Factory for bootstrapping a NestJS TestingModule preconfigured
+ * with mocked repositories, Redis, and optionally the CQRS pipeline.
+ */
+export declare class TestingModuleFactory {
+    static create(options?: TestingModuleOptions): TestingModuleBuilder;
+}