@quanticjs/core 1.1.1

package/dist/cqrs/pipeline/QuanticCommandBus.js

@@ -0,0 +1,99 @@
+"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 QuanticCommandBus_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticCommandBus = void 0;
+const common_1 = require("@nestjs/common");
+const cqrs_1 = require("@nestjs/cqrs");
+const LogBehavior_1 = require("../behaviors/LogBehavior");
+const FeatureFlagBehavior_1 = require("../behaviors/FeatureFlagBehavior");
+const ValidationBehavior_1 = require("../behaviors/ValidationBehavior");
+const CacheBehavior_1 = require("../behaviors/CacheBehavior");
+const DistributedLockBehavior_1 = require("../behaviors/DistributedLockBehavior");
+const TransactionalBehavior_1 = require("../behaviors/TransactionalBehavior");
+const PerformanceBehavior_1 = require("../behaviors/PerformanceBehavior");
+const WorkflowBehavior_1 = require("../behaviors/WorkflowBehavior");
+const InvalidateCacheBehavior_1 = require("../behaviors/InvalidateCacheBehavior");
+const runPipeline_1 = require("./runPipeline");
+/**
+ * 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.
+ */
+let QuanticCommandBus = QuanticCommandBus_1 = class QuanticCommandBus {
+    commandBus;
+    logBehavior;
+    performanceBehavior;
+    featureFlagBehavior;
+    validationBehavior;
+    workflowBehavior;
+    cacheBehavior;
+    distributedLockBehavior;
+    transactionalBehavior;
+    invalidateCacheBehavior;
+    logger = new common_1.Logger(QuanticCommandBus_1.name);
+    behaviors = [];
+    originalExecute;
+    constructor(commandBus, logBehavior, performanceBehavior, featureFlagBehavior, validationBehavior, workflowBehavior, cacheBehavior, distributedLockBehavior, transactionalBehavior, invalidateCacheBehavior) {
+        this.commandBus = commandBus;
+        this.logBehavior = logBehavior;
+        this.performanceBehavior = performanceBehavior;
+        this.featureFlagBehavior = featureFlagBehavior;
+        this.validationBehavior = validationBehavior;
+        this.workflowBehavior = workflowBehavior;
+        this.cacheBehavior = cacheBehavior;
+        this.distributedLockBehavior = distributedLockBehavior;
+        this.transactionalBehavior = transactionalBehavior;
+        this.invalidateCacheBehavior = invalidateCacheBehavior;
+    }
+    onModuleInit() {
+        const optional = (behavior) => behavior ? [(cmd, next) => behavior.execute(cmd, next)] : [];
+        this.behaviors = [
+            (cmd, next) => this.invalidateCacheBehavior.execute(cmd, next),
+            (cmd, next) => this.logBehavior.execute(cmd, next),
+            (cmd, next) => this.performanceBehavior.execute(cmd, next),
+            ...optional(this.featureFlagBehavior),
+            (cmd, next) => this.validationBehavior.execute(cmd, next),
+            ...optional(this.workflowBehavior),
+            (cmd, next) => this.cacheBehavior.execute(cmd, next),
+            (cmd, next) => this.distributedLockBehavior.execute(cmd, next),
+            (cmd, next) => this.transactionalBehavior.execute(cmd, next),
+        ];
+        this.originalExecute = this.commandBus.execute.bind(this.commandBus);
+        const self = this;
+        this.commandBus.execute = (command) => {
+            const handler = () => self.originalExecute(command);
+            return (0, runPipeline_1.runPipeline)(command, handler, self.behaviors);
+        };
+        this.logger.log(`Command pipeline initialized — ${this.behaviors.length} behaviors`);
+    }
+};
+exports.QuanticCommandBus = QuanticCommandBus;
+exports.QuanticCommandBus = QuanticCommandBus = QuanticCommandBus_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Inject)(FeatureFlagBehavior_1.FeatureFlagBehavior)),
+    __param(5, (0, common_1.Optional)()),
+    __param(5, (0, common_1.Inject)(WorkflowBehavior_1.WorkflowBehavior)),
+    __metadata("design:paramtypes", [cqrs_1.CommandBus,
+        LogBehavior_1.LogBehavior,
+        PerformanceBehavior_1.PerformanceBehavior, Object, ValidationBehavior_1.ValidationBehavior, Object, CacheBehavior_1.CacheBehavior,
+        DistributedLockBehavior_1.DistributedLockBehavior,
+        TransactionalBehavior_1.TransactionalBehavior,
+        InvalidateCacheBehavior_1.InvalidateCacheBehavior])
+], QuanticCommandBus);

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

@@ -0,0 +1,28 @@
+import { OnModuleInit } from '@nestjs/common';
+import { QueryBus } from '@nestjs/cqrs';
+import { LogBehavior } from '../behaviors/LogBehavior';
+import { FeatureFlagBehavior } from '../behaviors/FeatureFlagBehavior';
+import { ValidationBehavior } from '../behaviors/ValidationBehavior';
+import { CacheBehavior } from '../behaviors/CacheBehavior';
+import { PerformanceBehavior } from '../behaviors/PerformanceBehavior';
+/**
+ * QuanticQueryBus — wraps the @nestjs/cqrs QueryBus with a behavior pipeline.
+ *
+ * Pipeline order:
+ *   Log → Performance → FeatureFlag → Validate → Cache → Handler
+ *
+ * Queries skip Workflow, DistributedLock, and Transactional — they are read-only.
+ */
+export declare class QuanticQueryBus implements OnModuleInit {
+    private readonly queryBus;
+    private readonly logBehavior;
+    private readonly performanceBehavior;
+    private readonly featureFlagBehavior;
+    private readonly validationBehavior;
+    private readonly cacheBehavior;
+    private readonly logger;
+    private behaviors;
+    private originalExecute;
+    constructor(queryBus: QueryBus, logBehavior: LogBehavior, performanceBehavior: PerformanceBehavior, featureFlagBehavior: FeatureFlagBehavior | undefined, validationBehavior: ValidationBehavior, cacheBehavior: CacheBehavior);
+    onModuleInit(): void;
+}

package/dist/cqrs/pipeline/QuanticQueryBus.js

@@ -0,0 +1,78 @@
+"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 QuanticQueryBus_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticQueryBus = void 0;
+const common_1 = require("@nestjs/common");
+const cqrs_1 = require("@nestjs/cqrs");
+const LogBehavior_1 = require("../behaviors/LogBehavior");
+const FeatureFlagBehavior_1 = require("../behaviors/FeatureFlagBehavior");
+const ValidationBehavior_1 = require("../behaviors/ValidationBehavior");
+const CacheBehavior_1 = require("../behaviors/CacheBehavior");
+const PerformanceBehavior_1 = require("../behaviors/PerformanceBehavior");
+const runPipeline_1 = require("./runPipeline");
+/**
+ * QuanticQueryBus — wraps the @nestjs/cqrs QueryBus with a behavior pipeline.
+ *
+ * Pipeline order:
+ *   Log → Performance → FeatureFlag → Validate → Cache → Handler
+ *
+ * Queries skip Workflow, DistributedLock, and Transactional — they are read-only.
+ */
+let QuanticQueryBus = QuanticQueryBus_1 = class QuanticQueryBus {
+    queryBus;
+    logBehavior;
+    performanceBehavior;
+    featureFlagBehavior;
+    validationBehavior;
+    cacheBehavior;
+    logger = new common_1.Logger(QuanticQueryBus_1.name);
+    behaviors = [];
+    originalExecute;
+    constructor(queryBus, logBehavior, performanceBehavior, featureFlagBehavior, validationBehavior, cacheBehavior) {
+        this.queryBus = queryBus;
+        this.logBehavior = logBehavior;
+        this.performanceBehavior = performanceBehavior;
+        this.featureFlagBehavior = featureFlagBehavior;
+        this.validationBehavior = validationBehavior;
+        this.cacheBehavior = cacheBehavior;
+    }
+    onModuleInit() {
+        const optional = (behavior) => behavior ? [(cmd, next) => behavior.execute(cmd, next)] : [];
+        this.behaviors = [
+            (cmd, next) => this.logBehavior.execute(cmd, next),
+            (cmd, next) => this.performanceBehavior.execute(cmd, next),
+            ...optional(this.featureFlagBehavior),
+            (cmd, next) => this.validationBehavior.execute(cmd, next),
+            (cmd, next) => this.cacheBehavior.execute(cmd, next),
+        ];
+        this.originalExecute = this.queryBus.execute.bind(this.queryBus);
+        const self = this;
+        this.queryBus.execute = (query) => {
+            const handler = () => self.originalExecute(query);
+            return (0, runPipeline_1.runPipeline)(query, handler, self.behaviors);
+        };
+        this.logger.log(`Query pipeline initialized — ${this.behaviors.length} behaviors`);
+    }
+};
+exports.QuanticQueryBus = QuanticQueryBus;
+exports.QuanticQueryBus = QuanticQueryBus = QuanticQueryBus_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Inject)(FeatureFlagBehavior_1.FeatureFlagBehavior)),
+    __metadata("design:paramtypes", [cqrs_1.QueryBus,
+        LogBehavior_1.LogBehavior,
+        PerformanceBehavior_1.PerformanceBehavior, Object, ValidationBehavior_1.ValidationBehavior,
+        CacheBehavior_1.CacheBehavior])
+], QuanticQueryBus);

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

@@ -0,0 +1,3 @@
+import { Result } from '../../result/Result';
+export type BehaviorFn = <T>(command: object, next: () => Promise<Result<T>>) => Promise<Result<T>>;
+export declare function runPipeline<T>(command: object, handler: () => Promise<Result<T>>, behaviors: BehaviorFn[]): Promise<Result<T>>;

package/dist/cqrs/pipeline/runPipeline.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPipeline = runPipeline;
+function runPipeline(command, handler, behaviors) {
+    let next = handler;
+    for (let i = behaviors.length - 1; i >= 0; i--) {
+        const behavior = behaviors[i];
+        const currentNext = next;
+        next = () => behavior(command, currentNext);
+    }
+    return next();
+}

package/dist/cqrs/transaction/TransactionContext.d.ts

@@ -0,0 +1,18 @@
+import type { QueryRunner } from 'typeorm';
+/**
+ * Ambient transaction context using AsyncLocalStorage.
+ *
+ * Node.js is single-threaded — each async chain (HTTP request, Bull job,
+ * event consumer) gets its own isolated storage. Two concurrent requests
+ * never share a QueryRunner.
+ *
+ * The TransactionalBehavior creates the context for the outermost command;
+ * nested commands join automatically.
+ */
+export declare class TransactionContext {
+    private static readonly storage;
+    /** Returns the active QueryRunner for this async scope, or undefined. */
+    static get(): QueryRunner | undefined;
+    /** Runs `fn` with `queryRunner` as the ambient transaction for all nested calls. */
+    static run<T>(queryRunner: QueryRunner, fn: () => Promise<T>): Promise<T>;
+}

package/dist/cqrs/transaction/TransactionContext.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionContext = void 0;
+const async_hooks_1 = require("async_hooks");
+/**
+ * Ambient transaction context using AsyncLocalStorage.
+ *
+ * Node.js is single-threaded — each async chain (HTTP request, Bull job,
+ * event consumer) gets its own isolated storage. Two concurrent requests
+ * never share a QueryRunner.
+ *
+ * The TransactionalBehavior creates the context for the outermost command;
+ * nested commands join automatically.
+ */
+class TransactionContext {
+    static storage = new async_hooks_1.AsyncLocalStorage();
+    /** Returns the active QueryRunner for this async scope, or undefined. */
+    static get() {
+        return this.storage.getStore();
+    }
+    /** Runs `fn` with `queryRunner` as the ambient transaction for all nested calls. */
+    static run(queryRunner, fn) {
+        return this.storage.run(queryRunner, fn);
+    }
+}
+exports.TransactionContext = TransactionContext;

package/dist/cqrs/transaction/getTransactionalRepo.d.ts

@@ -0,0 +1,16 @@
+import type { Repository, ObjectLiteral } from 'typeorm';
+/**
+ * Returns a repository bound to the ambient transaction's QueryRunner,
+ * or the original repository if no transaction context exists.
+ *
+ * Usage in command handlers:
+ * ```typescript
+ * async execute(cmd: CreateUserCommand): Promise<Result<UserDto>> {
+ *   const repo = getTransactionalRepo(this.userRepo);
+ *   const user = repo.create({ email: cmd.email });
+ *   await repo.save(user);
+ *   return Result.success(toDto(user));
+ * }
+ * ```
+ */
+export declare function getTransactionalRepo<T extends ObjectLiteral>(repo: Repository<T>): Repository<T>;

package/dist/cqrs/transaction/getTransactionalRepo.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransactionalRepo = getTransactionalRepo;
+const TransactionContext_1 = require("./TransactionContext");
+/**
+ * Returns a repository bound to the ambient transaction's QueryRunner,
+ * or the original repository if no transaction context exists.
+ *
+ * Usage in command handlers:
+ * ```typescript
+ * async execute(cmd: CreateUserCommand): Promise<Result<UserDto>> {
+ *   const repo = getTransactionalRepo(this.userRepo);
+ *   const user = repo.create({ email: cmd.email });
+ *   await repo.save(user);
+ *   return Result.success(toDto(user));
+ * }
+ * ```
+ */
+function getTransactionalRepo(repo) {
+    const qr = TransactionContext_1.TransactionContext.get();
+    return qr ? qr.manager.getRepository(repo.target) : repo;
+}

package/dist/cqrs/validation/ICommandValidator.d.ts

@@ -0,0 +1,48 @@
+import { Result } from '../../result/Result';
+/**
+ * Interface for Zod-based command/query validators.
+ *
+ * Each command that needs validation gets a separate validator class
+ * with a Zod schema. The `@Validate(ValidatorClass)` decorator links
+ * the command to its validator.
+ *
+ * Usage:
+ * ```typescript
+ * export class BlockUserValidator implements ICommandValidator<BlockUserCommand> {
+ *   schema = z.object({
+ *     blockerId: z.string().uuid(),
+ *     blockedUserId: z.string().uuid(),
+ *   }).refine(d => d.blockerId !== d.blockedUserId, 'Cannot block yourself');
+ *
+ *   validate(command: BlockUserCommand): Result<void> {
+ *     return validateCommand(this.schema, command);
+ *   }
+ * }
+ * ```
+ */
+export interface ICommandValidator<T = any> {
+    validate(command: T): Result<void>;
+}
+/**
+ * A schema that can safeParse — matches Zod's ZodType without importing it.
+ * This avoids Zod v3/v4 compatibility issues across packages.
+ */
+interface SafeParseable {
+    safeParse(data: unknown): {
+        success: true;
+    } | {
+        success: false;
+        error: {
+            issues: Array<{
+                path: PropertyKey[];
+                message: string;
+            }>;
+        };
+    };
+}
+/**
+ * Helper: run a Zod schema against a command and return Result<void>.
+ * Formats all Zod issues into a single error message.
+ */
+export declare function validateCommand(schema: SafeParseable, command: unknown): Result<void>;
+export {};

package/dist/cqrs/validation/ICommandValidator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = validateCommand;
+const Result_1 = require("../../result/Result");
+/**
+ * Helper: run a Zod schema against a command and return Result<void>.
+ * Formats all Zod issues into a single error message.
+ */
+function validateCommand(schema, command) {
+    const result = schema.safeParse(command);
+    if (result.success) {
+        return Result_1.Result.success(undefined);
+    }
+    const messages = result.error.issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? `${issue.path.map(String).join('.')}: ` : '';
+        return `${path}${issue.message}`;
+    })
+        .join('; ');
+    return Result_1.Result.validationError(messages);
+}

package/dist/entities/BaseEntity.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class BaseEntity {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/entities/BaseEntity.js

@@ -0,0 +1,31 @@
+"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.BaseEntity = void 0;
+const typeorm_1 = require("typeorm");
+class BaseEntity {
+    id;
+    createdAt;
+    updatedAt;
+}
+exports.BaseEntity = BaseEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], BaseEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], BaseEntity.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], BaseEntity.prototype, "updatedAt", void 0);

package/dist/entities/TenantBaseEntity.d.ts

@@ -0,0 +1,4 @@
+import { BaseEntity } from './BaseEntity';
+export declare abstract class TenantBaseEntity extends BaseEntity {
+    organizationId: string;
+}

package/dist/entities/TenantBaseEntity.js

@@ -0,0 +1,22 @@
+"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.TenantBaseEntity = void 0;
+const typeorm_1 = require("typeorm");
+const BaseEntity_1 = require("./BaseEntity");
+class TenantBaseEntity extends BaseEntity_1.BaseEntity {
+    organizationId;
+}
+exports.TenantBaseEntity = TenantBaseEntity;
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid' }),
+    __metadata("design:type", String)
+], TenantBaseEntity.prototype, "organizationId", void 0);

package/dist/events/DomainEvent.d.ts

@@ -0,0 +1,14 @@
+export interface DomainEventPayload {
+    [key: string]: unknown;
+}
+export declare class DomainEvent {
+    readonly eventType: string;
+    readonly aggregateId: string;
+    readonly payload: DomainEventPayload;
+    readonly organizationId?: string | undefined;
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    constructor(eventType: string, aggregateId: string, payload: DomainEventPayload, organizationId?: string | undefined);
+    /** The Redis Stream key this event should be published to */
+    get streamKey(): string;
+}

package/dist/events/DomainEvent.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainEvent = void 0;
+const uuid_1 = require("uuid");
+class DomainEvent {
+    eventType;
+    aggregateId;
+    payload;
+    organizationId;
+    eventId;
+    occurredAt;
+    constructor(eventType, aggregateId, payload, organizationId) {
+        this.eventType = eventType;
+        this.aggregateId = aggregateId;
+        this.payload = payload;
+        this.organizationId = organizationId;
+        this.eventId = (0, uuid_1.v4)();
+        this.occurredAt = new Date();
+    }
+    /** The Redis Stream key this event should be published to */
+    get streamKey() {
+        // e.g. 'build.completed' → 'arex:events:builds'
+        const category = this.eventType.split('.')[0];
+        return `arex:events:${category}s`;
+    }
+}
+exports.DomainEvent = DomainEvent;

package/dist/events/OutboxEvent.entity.d.ts

@@ -0,0 +1,18 @@
+export declare enum OutboxEventStatus {
+    Pending = "Pending",
+    Published = "Published",
+    Failed = "Failed"
+}
+export declare class OutboxEvent {
+    id: string;
+    eventType: string;
+    aggregateId: string;
+    streamKey: string;
+    payload: Record<string, unknown>;
+    organizationId: string | null;
+    status: OutboxEventStatus;
+    publishAttempts: number;
+    lastError: string | null;
+    createdAt: Date;
+    publishedAt: Date | null;
+}

package/dist/events/OutboxEvent.entity.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 __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.OutboxEvent = exports.OutboxEventStatus = void 0;
+const typeorm_1 = require("typeorm");
+var OutboxEventStatus;
+(function (OutboxEventStatus) {
+    OutboxEventStatus["Pending"] = "Pending";
+    OutboxEventStatus["Published"] = "Published";
+    OutboxEventStatus["Failed"] = "Failed";
+})(OutboxEventStatus || (exports.OutboxEventStatus = OutboxEventStatus = {}));
+let OutboxEvent = class OutboxEvent {
+    id;
+    eventType;
+    aggregateId;
+    streamKey;
+    payload;
+    organizationId;
+    status;
+    publishAttempts;
+    lastError;
+    createdAt;
+    publishedAt;
+};
+exports.OutboxEvent = OutboxEvent;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], OutboxEvent.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar' }),
+    __metadata("design:type", String)
+], OutboxEvent.prototype, "eventType", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar' }),
+    __metadata("design:type", String)
+], OutboxEvent.prototype, "aggregateId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar' }),
+    __metadata("design:type", String)
+], OutboxEvent.prototype, "streamKey", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb' }),
+    __metadata("design:type", Object)
+], OutboxEvent.prototype, "payload", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], OutboxEvent.prototype, "organizationId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: OutboxEventStatus,
+        default: OutboxEventStatus.Pending,
+    }),
+    __metadata("design:type", String)
+], OutboxEvent.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', default: 0 }),
+    __metadata("design:type", Number)
+], OutboxEvent.prototype, "publishAttempts", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", Object)
+], OutboxEvent.prototype, "lastError", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], OutboxEvent.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Object)
+], OutboxEvent.prototype, "publishedAt", void 0);
+exports.OutboxEvent = OutboxEvent = __decorate([
+    (0, typeorm_1.Entity)('outbox_events'),
+    (0, typeorm_1.Index)('idx_outbox_pending', ['status', 'createdAt'], {
+        where: `"status" = 'Pending'`,
+    })
+], OutboxEvent);

package/dist/events/OutboxPublisherService.d.ts

@@ -0,0 +1,14 @@
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { RedisStreamPublisher } from './RedisStreamPublisher';
+export declare class OutboxPublisherService implements OnModuleInit, OnModuleDestroy {
+    private readonly dataSource;
+    private readonly redisPublisher;
+    private readonly logger;
+    private timer;
+    private processing;
+    constructor(dataSource: DataSource, redisPublisher: RedisStreamPublisher);
+    onModuleInit(): void;
+    onModuleDestroy(): void;
+    private pollAndPublish;
+}