@quanticjs/core 1.1.1

package/dist/cqrs/behaviors/PerformanceBehavior.js

@@ -0,0 +1,56 @@
+"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.PerformanceBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const MetricsService_1 = require("../../metrics/MetricsService");
+const SLOW_THRESHOLD_MS = 500;
+/**
+ * PerformanceBehavior logs a warning when a handler exceeds 500ms
+ * and records handler duration in Prometheus histogram.
+ */
+let PerformanceBehavior = class PerformanceBehavior {
+    metrics;
+    logger = new common_1.Logger('PerformanceBehavior');
+    constructor(metrics) {
+        this.metrics = metrics;
+    }
+    async execute(command, next) {
+        const handlerName = command.constructor.name;
+        const startTime = Date.now();
+        const result = await next();
+        const durationMs = Date.now() - startTime;
+        const durationSec = durationMs / 1000;
+        const resultLabel = result.isSuccess ? 'success' : 'failure';
+        // Record metrics
+        this.metrics?.handlerDuration
+            .labels(handlerName, resultLabel)
+            .observe(durationSec);
+        // Warn on slow handlers
+        if (durationMs > SLOW_THRESHOLD_MS) {
+            this.logger.warn({
+                msg: `Slow handler detected: ${handlerName} took ${durationMs}ms`,
+                handler: handlerName,
+                durationMs,
+            });
+        }
+        return result;
+    }
+};
+exports.PerformanceBehavior = PerformanceBehavior;
+exports.PerformanceBehavior = PerformanceBehavior = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [MetricsService_1.MetricsService])
+], PerformanceBehavior);

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

@@ -0,0 +1,18 @@
+import { DataSource } from 'typeorm';
+import { Result } from '../../result/Result';
+/**
+ * TransactionalBehavior — UnitOfWork pattern via AsyncLocalStorage.
+ *
+ * Every command is transactional by default (no decorator needed):
+ * - If no ambient transaction exists → CREATE one, own commit/rollback
+ * - If an ambient transaction exists → JOIN it (pass through, outer scope owns lifecycle)
+ * - If command is @IsolatedTransaction() → always CREATE a new one, even if context exists
+ *
+ * Queries skip this behavior entirely (separate pipeline chain in QuanticQueryBus).
+ */
+export declare class TransactionalBehavior {
+    private readonly dataSource?;
+    private readonly logger;
+    constructor(dataSource?: DataSource | undefined);
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+}

package/dist/cqrs/behaviors/TransactionalBehavior.js

@@ -0,0 +1,77 @@
+"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 TransactionalBehavior_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionalBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const Result_1 = require("../../result/Result");
+const TransactionContext_1 = require("../transaction/TransactionContext");
+const IsolatedTransaction_decorator_1 = require("../decorators/IsolatedTransaction.decorator");
+/**
+ * TransactionalBehavior — UnitOfWork pattern via AsyncLocalStorage.
+ *
+ * Every command is transactional by default (no decorator needed):
+ * - If no ambient transaction exists → CREATE one, own commit/rollback
+ * - If an ambient transaction exists → JOIN it (pass through, outer scope owns lifecycle)
+ * - If command is @IsolatedTransaction() → always CREATE a new one, even if context exists
+ *
+ * Queries skip this behavior entirely (separate pipeline chain in QuanticQueryBus).
+ */
+let TransactionalBehavior = TransactionalBehavior_1 = class TransactionalBehavior {
+    dataSource;
+    logger = new common_1.Logger(TransactionalBehavior_1.name);
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+    }
+    async execute(command, next) {
+        if (!this.dataSource) {
+            return next();
+        }
+        const existing = TransactionContext_1.TransactionContext.get();
+        const isolated = (0, IsolatedTransaction_decorator_1.isIsolatedTransaction)(command.constructor);
+        // JOIN — ambient transaction exists and command does not demand isolation
+        if (existing && !isolated) {
+            return next();
+        }
+        // CREATE — we are the outermost scope (or isolated); we own the lifecycle
+        const queryRunner = this.dataSource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            const result = await TransactionContext_1.TransactionContext.run(queryRunner, () => next());
+            if (result.isSuccess) {
+                await queryRunner.commitTransaction();
+            }
+            else {
+                await queryRunner.rollbackTransaction();
+                this.logger.warn(`Transaction rolled back for ${command.constructor.name}: ${result.errorMessage}`);
+            }
+            return result;
+        }
+        catch (error) {
+            await queryRunner.rollbackTransaction();
+            return Result_1.Result.failure(Result_1.ErrorType.InternalError, `Transaction failed for ${command.constructor.name}: ${error.message}`);
+        }
+        finally {
+            await queryRunner.release();
+        }
+    }
+};
+exports.TransactionalBehavior = TransactionalBehavior;
+exports.TransactionalBehavior = TransactionalBehavior = TransactionalBehavior_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], TransactionalBehavior);

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

@@ -0,0 +1,4 @@
+import { Result } from '../../result/Result';
+export declare class ValidationBehavior {
+    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
+}

package/dist/cqrs/behaviors/ValidationBehavior.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.ValidationBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const Validate_decorator_1 = require("../decorators/Validate.decorator");
+const Result_1 = require("../../result/Result");
+let ValidationBehavior = class ValidationBehavior {
+    async execute(command, next) {
+        if (!(0, Validate_decorator_1.shouldValidate)(command.constructor)) {
+            return next();
+        }
+        const ValidatorClass = (0, Validate_decorator_1.getValidatorClass)(command.constructor);
+        if (!ValidatorClass) {
+            return next();
+        }
+        const validator = new ValidatorClass();
+        const validationResult = validator.validate(command);
+        if (!validationResult.isSuccess) {
+            return Result_1.Result.failure(validationResult.errorType ?? Result_1.ErrorType.ValidationError, validationResult.errorMessage ?? 'Validation failed');
+        }
+        return next();
+    }
+};
+exports.ValidationBehavior = ValidationBehavior;
+exports.ValidationBehavior = ValidationBehavior = __decorate([
+    (0, common_1.Injectable)()
+], ValidationBehavior);

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

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

package/dist/cqrs/behaviors/WorkflowBehavior.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 WorkflowBehavior_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const Workflow_decorator_1 = require("../decorators/Workflow.decorator");
+const WorkflowEngine_1 = require("../interfaces/WorkflowEngine");
+const Result_1 = require("../../result/Result");
+let WorkflowBehavior = WorkflowBehavior_1 = class WorkflowBehavior {
+    engine;
+    logger = new common_1.Logger(WorkflowBehavior_1.name);
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async execute(command, next) {
+        const metadata = (0, Workflow_decorator_1.getWorkflowMetadata)(command.constructor);
+        if (!metadata) {
+            return next();
+        }
+        if (!this.engine) {
+            this.logger.debug('No WorkflowEngine provided, skipping workflow behavior');
+            return next();
+        }
+        try {
+            const result = await this.engine.startProcess(metadata.processDefinitionId, command, { commandType: command.constructor.name });
+            return Result_1.Result.success(result);
+        }
+        catch (error) {
+            const fallback = metadata.fallback ?? 'throw';
+            this.logger.warn(`Workflow start failed for "${metadata.processDefinitionId}", applying fallback: ${fallback}`, error.message);
+            switch (fallback) {
+                case 'skip':
+                    return next();
+                case 'queue':
+                    return Result_1.Result.failure(Result_1.ErrorType.InternalError, `Workflow queuing not available without companion package: ${error.message}`);
+                case 'throw':
+                default:
+                    return Result_1.Result.failure(Result_1.ErrorType.InternalError, `Workflow start failed: ${error.message}`);
+            }
+        }
+    }
+};
+exports.WorkflowBehavior = WorkflowBehavior;
+exports.WorkflowBehavior = WorkflowBehavior = WorkflowBehavior_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(WorkflowEngine_1.WORKFLOW_ENGINE)),
+    __metadata("design:paramtypes", [Object])
+], WorkflowBehavior);

package/dist/cqrs/constants.d.ts

@@ -0,0 +1,2 @@
+/** Injection token for the Redis client (ioredis) */
+export declare const REDIS_CLIENT = "REDIS_CLIENT";

package/dist/cqrs/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDIS_CLIENT = void 0;
+/** Injection token for the Redis client (ioredis) */
+exports.REDIS_CLIENT = 'REDIS_CLIENT';

package/dist/cqrs/decorators/Cache.decorator.d.ts

@@ -0,0 +1,13 @@
+import 'reflect-metadata';
+export interface CacheOptions {
+    /** Cache key template — use {propName} for interpolation, e.g. 'user:{id}' */
+    key: string;
+    /** TTL in seconds (default: 60) */
+    ttlSeconds?: number;
+}
+/**
+ * @Cache('key:{prop}', { ttlSeconds: 60 }) — caches query results in Redis.
+ * Reads from cache on hit; sets on miss with TTL.
+ */
+export declare function Cache(key: string, options?: Omit<CacheOptions, 'key'>): ClassDecorator;
+export declare function getCacheMetadata(target: object): CacheOptions | undefined;

package/dist/cqrs/decorators/Cache.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = Cache;
+exports.getCacheMetadata = getCacheMetadata;
+require("reflect-metadata");
+const CACHE_KEY = 'arex:cache';
+/**
+ * @Cache('key:{prop}', { ttlSeconds: 60 }) — caches query results in Redis.
+ * Reads from cache on hit; sets on miss with TTL.
+ */
+function Cache(key, options = {}) {
+    return (target) => {
+        Reflect.defineMetadata(CACHE_KEY, { key, ttlSeconds: 60, ...options }, target);
+    };
+}
+function getCacheMetadata(target) {
+    return Reflect.getMetadata(CACHE_KEY, target);
+}

package/dist/cqrs/decorators/DistributedLock.decorator.d.ts

@@ -0,0 +1,15 @@
+import 'reflect-metadata';
+export interface DistributedLockOptions {
+    /** Lock key template — use {propName} for interpolation */
+    key: string;
+    /** Max time to wait for lock acquisition in seconds (default: 5) */
+    acquireTimeoutSeconds?: number;
+    /** Lock auto-release time in seconds (default: 30) */
+    lockTtlSeconds?: number;
+}
+/**
+ * @DistributedLock('key:{prop}') — acquires a Redis distributed lock before execution.
+ * Throws ConflictException on timeout.
+ */
+export declare function DistributedLock(key: string, options?: Omit<DistributedLockOptions, 'key'>): ClassDecorator;
+export declare function getDistributedLockMetadata(target: object): DistributedLockOptions | undefined;

package/dist/cqrs/decorators/DistributedLock.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedLock = DistributedLock;
+exports.getDistributedLockMetadata = getDistributedLockMetadata;
+require("reflect-metadata");
+const LOCK_KEY = 'arex:distributed-lock';
+/**
+ * @DistributedLock('key:{prop}') — acquires a Redis distributed lock before execution.
+ * Throws ConflictException on timeout.
+ */
+function DistributedLock(key, options = {}) {
+    return (target) => {
+        Reflect.defineMetadata(LOCK_KEY, {
+            key,
+            acquireTimeoutSeconds: 5,
+            lockTtlSeconds: 30,
+            ...options,
+        }, target);
+    };
+}
+function getDistributedLockMetadata(target) {
+    return Reflect.getMetadata(LOCK_KEY, target);
+}

package/dist/cqrs/decorators/FeatureFlag.decorator.d.ts

@@ -0,0 +1,9 @@
+import 'reflect-metadata';
+export interface FeatureFlagOptions {
+    fallback?: 'throw' | 'skip' | 'default';
+    defaultValue?: unknown;
+}
+export declare function FeatureFlag(flagName: string, options?: FeatureFlagOptions): ClassDecorator;
+export declare function getFeatureFlagMetadata(target: object): {
+    flagName: string;
+} & FeatureFlagOptions | undefined;

package/dist/cqrs/decorators/FeatureFlag.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlag = FeatureFlag;
+exports.getFeatureFlagMetadata = getFeatureFlagMetadata;
+require("reflect-metadata");
+const FEATURE_FLAG_KEY = 'arex:feature-flag';
+function FeatureFlag(flagName, options = { fallback: 'throw' }) {
+    return (target) => {
+        Reflect.defineMetadata(FEATURE_FLAG_KEY, { flagName, ...options }, target);
+    };
+}
+function getFeatureFlagMetadata(target) {
+    return Reflect.getMetadata(FEATURE_FLAG_KEY, target);
+}

package/dist/cqrs/decorators/InvalidateCache.decorator.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export interface InvalidateCacheOptions {
+    keys: string[];
+}
+export declare function InvalidateCache(keys: string[]): ClassDecorator;
+export declare function getInvalidateCacheMetadata(target: object): InvalidateCacheOptions | undefined;

package/dist/cqrs/decorators/InvalidateCache.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidateCache = InvalidateCache;
+exports.getInvalidateCacheMetadata = getInvalidateCacheMetadata;
+require("reflect-metadata");
+const INVALIDATE_CACHE_KEY = 'arex:invalidate-cache';
+function InvalidateCache(keys) {
+    return (target) => {
+        Reflect.defineMetadata(INVALIDATE_CACHE_KEY, { keys }, target);
+    };
+}
+function getInvalidateCacheMetadata(target) {
+    return Reflect.getMetadata(INVALIDATE_CACHE_KEY, target);
+}

package/dist/cqrs/decorators/IsolatedTransaction.decorator.d.ts

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+/**
+ * @IsolatedTransaction() — forces a command to run in its own dedicated transaction,
+ * even when an outer transaction scope already exists.
+ *
+ * Use for operations that must commit independently of the parent flow:
+ * - Audit logging (must persist even if the business operation rolls back)
+ * - Notifications / side-effects that should not be lost on rollback
+ *
+ * By default all commands share the ambient transaction (UnitOfWork pattern).
+ * This decorator opts out of that behavior.
+ */
+export declare function IsolatedTransaction(): ClassDecorator;
+export declare function isIsolatedTransaction(target: object): boolean;

package/dist/cqrs/decorators/IsolatedTransaction.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsolatedTransaction = IsolatedTransaction;
+exports.isIsolatedTransaction = isIsolatedTransaction;
+require("reflect-metadata");
+const ISOLATED_TRANSACTION_KEY = 'arex:isolated-transaction';
+/**
+ * @IsolatedTransaction() — forces a command to run in its own dedicated transaction,
+ * even when an outer transaction scope already exists.
+ *
+ * Use for operations that must commit independently of the parent flow:
+ * - Audit logging (must persist even if the business operation rolls back)
+ * - Notifications / side-effects that should not be lost on rollback
+ *
+ * By default all commands share the ambient transaction (UnitOfWork pattern).
+ * This decorator opts out of that behavior.
+ */
+function IsolatedTransaction() {
+    return (target) => {
+        Reflect.defineMetadata(ISOLATED_TRANSACTION_KEY, true, target);
+    };
+}
+function isIsolatedTransaction(target) {
+    return Reflect.getMetadata(ISOLATED_TRANSACTION_KEY, target) === true;
+}

package/dist/cqrs/decorators/Log.decorator.d.ts

@@ -0,0 +1,11 @@
+import 'reflect-metadata';
+export interface LogOptions {
+    /** Whether to log the command/query payload (default: true) */
+    logPayload?: boolean;
+}
+/**
+ * @Log() — marks a command/query for automatic entry/exit logging.
+ * Applied globally by QuanticCommandBus/QuanticQueryBus when no explicit decorator is present.
+ */
+export declare function Log(options?: LogOptions): ClassDecorator;
+export declare function getLogMetadata(target: object): LogOptions | undefined;

package/dist/cqrs/decorators/Log.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = Log;
+exports.getLogMetadata = getLogMetadata;
+require("reflect-metadata");
+const LOG_KEY = 'arex:log';
+/**
+ * @Log() — marks a command/query for automatic entry/exit logging.
+ * Applied globally by QuanticCommandBus/QuanticQueryBus when no explicit decorator is present.
+ */
+function Log(options = {}) {
+    return (target) => {
+        Reflect.defineMetadata(LOG_KEY, { logPayload: true, ...options }, target);
+    };
+}
+function getLogMetadata(target) {
+    return Reflect.getMetadata(LOG_KEY, target);
+}

package/dist/cqrs/decorators/Validate.decorator.d.ts

@@ -0,0 +1,24 @@
+import 'reflect-metadata';
+import type { ICommandValidator } from '../validation/ICommandValidator';
+type ValidatorClass = new () => ICommandValidator;
+/**
+ * @Validate(ValidatorClass) — links a command/query to its Zod-based validator.
+ *
+ * The ValidationBehavior instantiates the validator and calls validate()
+ * before the handler runs. Returns Result.validationError() on failure.
+ *
+ * Usage:
+ * ```typescript
+ * @Validate(BlockUserValidator)
+ * export class BlockUserCommand {
+ *   constructor(
+ *     public readonly blockerId: string,
+ *     public readonly blockedUserId: string,
+ *   ) {}
+ * }
+ * ```
+ */
+export declare function Validate(validatorClass: ValidatorClass): ClassDecorator;
+export declare function shouldValidate(target: object): boolean;
+export declare function getValidatorClass(target: object): ValidatorClass | undefined;
+export {};

package/dist/cqrs/decorators/Validate.decorator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validate = Validate;
+exports.shouldValidate = shouldValidate;
+exports.getValidatorClass = getValidatorClass;
+require("reflect-metadata");
+const VALIDATE_KEY = 'arex:validate';
+const VALIDATOR_CLASS_KEY = 'arex:validator-class';
+/**
+ * @Validate(ValidatorClass) — links a command/query to its Zod-based validator.
+ *
+ * The ValidationBehavior instantiates the validator and calls validate()
+ * before the handler runs. Returns Result.validationError() on failure.
+ *
+ * Usage:
+ * ```typescript
+ * @Validate(BlockUserValidator)
+ * export class BlockUserCommand {
+ *   constructor(
+ *     public readonly blockerId: string,
+ *     public readonly blockedUserId: string,
+ *   ) {}
+ * }
+ * ```
+ */
+function Validate(validatorClass) {
+    return (target) => {
+        Reflect.defineMetadata(VALIDATE_KEY, true, target);
+        Reflect.defineMetadata(VALIDATOR_CLASS_KEY, validatorClass, target);
+    };
+}
+function shouldValidate(target) {
+    return Reflect.getMetadata(VALIDATE_KEY, target) === true;
+}
+function getValidatorClass(target) {
+    return Reflect.getMetadata(VALIDATOR_CLASS_KEY, target);
+}

package/dist/cqrs/decorators/Workflow.decorator.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+export interface WorkflowOptions {
+    fallback?: 'throw' | 'skip' | 'queue';
+}
+export declare function Workflow(processDefinitionId: string, options?: WorkflowOptions): ClassDecorator;
+export declare function getWorkflowMetadata(target: object): {
+    processDefinitionId: string;
+} & WorkflowOptions | undefined;

package/dist/cqrs/decorators/Workflow.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workflow = Workflow;
+exports.getWorkflowMetadata = getWorkflowMetadata;
+require("reflect-metadata");
+const WORKFLOW_KEY = 'arex:workflow';
+function Workflow(processDefinitionId, options) {
+    return (target) => {
+        Reflect.defineMetadata(WORKFLOW_KEY, { processDefinitionId, ...options }, target);
+    };
+}
+function getWorkflowMetadata(target) {
+    return Reflect.getMetadata(WORKFLOW_KEY, target);
+}

package/dist/cqrs/interfaces/WorkflowEngine.d.ts

@@ -0,0 +1,14 @@
+export declare const WORKFLOW_ENGINE: unique symbol;
+export interface WorkflowStartResult {
+    workflowInstanceId: string;
+    processInstanceId: string;
+    status: 'STARTED';
+}
+export interface WorkflowEngine {
+    startProcess(processDefinitionId: string, command: object, metadata: {
+        commandType: string;
+        correlationId?: string;
+    }): Promise<WorkflowStartResult>;
+    signalProcess(processInstanceId: string, signal: string, data?: unknown): Promise<void>;
+    abortProcess(processInstanceId: string): Promise<void>;
+}

package/dist/cqrs/interfaces/WorkflowEngine.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKFLOW_ENGINE = void 0;
+exports.WORKFLOW_ENGINE = Symbol('WORKFLOW_ENGINE');

package/dist/cqrs/pipeline/QuanticCommandBus.d.ts

@@ -0,0 +1,37 @@
+import { OnModuleInit } from '@nestjs/common';
+import { CommandBus } 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';
+import { InvalidateCacheBehavior } from '../behaviors/InvalidateCacheBehavior';
+/**
+ * QuanticCommandBus — wraps the @nestjs/cqrs CommandBus with a behavior pipeline.
+ *
+ * Pipeline order:
+ *   InvalidateCache → Log → Performance → FeatureFlag → Validate → Workflow → Cache → DistributedLock → Transactional → Handler
+ *
+ * Controllers inject the standard CommandBus from @nestjs/cqrs.
+ * This class patches its execute() in onModuleInit so the pipeline is transparent.
+ */
+export declare class QuanticCommandBus implements OnModuleInit {
+    private readonly commandBus;
+    private readonly logBehavior;
+    private readonly performanceBehavior;
+    private readonly featureFlagBehavior;
+    private readonly validationBehavior;
+    private readonly workflowBehavior;
+    private readonly cacheBehavior;
+    private readonly distributedLockBehavior;
+    private readonly transactionalBehavior;
+    private readonly invalidateCacheBehavior;
+    private readonly logger;
+    private behaviors;
+    private originalExecute;
+    constructor(commandBus: CommandBus, logBehavior: LogBehavior, performanceBehavior: PerformanceBehavior, featureFlagBehavior: FeatureFlagBehavior | undefined, validationBehavior: ValidationBehavior, workflowBehavior: WorkflowBehavior | undefined, cacheBehavior: CacheBehavior, distributedLockBehavior: DistributedLockBehavior, transactionalBehavior: TransactionalBehavior, invalidateCacheBehavior: InvalidateCacheBehavior);
+    onModuleInit(): void;
+}