nest-eventsource-kit 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## [1.1.0] - 2026-01-31
+
+### Added
+- Aggregate Root base class
+- Event Bus implementation
+- Command and Query handler interfaces
+- Docker and docker-compose setup
+- CI/CD pipeline
+- Additional tests
+
+## [1.0.0] - 2026-01-31
+- Initial release

package/CONTRIBUTING.md

@@ -0,0 +1,14 @@
+# Contributing
+
+Thank you for contributing to nest-eventsource-kit!
+
+## Setup
+```bash
+npm install
+npm test
+```
+
+## Guidelines
+- Write tests
+- Follow TypeScript best practices
+- Update documentation

package/dist/base/aggregate-root.d.ts

@@ -0,0 +1,11 @@
+import { DomainEvent } from '../interfaces/event.interface';
+export declare abstract class AggregateRoot {
+    private uncommittedEvents;
+    protected version: number;
+    abstract get aggregateId(): string;
+    protected applyEvent(event: DomainEvent): void;
+    getUncommittedEvents(): DomainEvent[];
+    clearUncommittedEvents(): void;
+    loadFromHistory(events: DomainEvent[]): void;
+    protected abstract apply(event: DomainEvent): void;
+}

package/dist/base/aggregate-root.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateRoot = void 0;
+class AggregateRoot {
+    constructor() {
+        this.uncommittedEvents = [];
+        this.version = 0;
+    }
+    applyEvent(event) {
+        this.uncommittedEvents.push(event);
+        this.version++;
+    }
+    getUncommittedEvents() {
+        return [...this.uncommittedEvents];
+    }
+    clearUncommittedEvents() {
+        this.uncommittedEvents = [];
+    }
+    loadFromHistory(events) {
+        events.forEach(event => {
+            this.apply(event);
+            this.version = event.version;
+        });
+    }
+}
+exports.AggregateRoot = AggregateRoot;

package/dist/handlers/command-handler.interface.d.ts

@@ -0,0 +1,6 @@
+export interface Command {
+    readonly type: string;
+}
+export interface CommandHandler<T extends Command = any, R = any> {
+    execute(command: T): Promise<R>;
+}

package/dist/handlers/command-handler.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/handlers/query-handler.interface.d.ts

@@ -0,0 +1,6 @@
+export interface Query {
+    readonly type: string;
+}
+export interface QueryHandler<T extends Query = any, R = any> {
+    execute(query: T): Promise<R>;
+}

package/dist/handlers/query-handler.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,3 +1,7 @@
 export * from './event-sourcing.module';
 export * from './services/event-store.service';
+export * from './services/event-bus.service';
 export * from './interfaces/event.interface';
+export * from './base/aggregate-root';
+export * from './handlers/command-handler.interface';
+export * from './handlers/query-handler.interface';

package/dist/index.js

@@ -16,4 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./event-sourcing.module"), exports);
 __exportStar(require("./services/event-store.service"), exports);
+__exportStar(require("./services/event-bus.service"), exports);
 __exportStar(require("./interfaces/event.interface"), exports);
+__exportStar(require("./base/aggregate-root"), exports);
+__exportStar(require("./handlers/command-handler.interface"), exports);
+__exportStar(require("./handlers/query-handler.interface"), exports);

package/dist/services/event-bus.service.d.ts

@@ -0,0 +1,9 @@
+import { DomainEvent } from '../interfaces/event.interface';
+type EventHandler = (event: DomainEvent) => void | Promise<void>;
+export declare class EventBusService {
+    private handlers;
+    subscribe(eventType: string, handler: EventHandler): void;
+    publish(event: DomainEvent): Promise<void>;
+    publishAll(events: DomainEvent[]): Promise<void>;
+}
+export {};

package/dist/services/event-bus.service.js

@@ -0,0 +1,78 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBusService = void 0;
+const common_1 = require("@nestjs/common");
+let EventBusService = (() => {
+    let _classDecorators = [(0, common_1.Injectable)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var EventBusService = _classThis = class {
+        constructor() {
+            this.handlers = new Map();
+        }
+        subscribe(eventType, handler) {
+            if (!this.handlers.has(eventType)) {
+                this.handlers.set(eventType, []);
+            }
+            this.handlers.get(eventType).push(handler);
+        }
+        async publish(event) {
+            const handlers = this.handlers.get(event.eventType) || [];
+            await Promise.all(handlers.map(handler => handler(event)));
+        }
+        async publishAll(events) {
+            for (const event of events) {
+                await this.publish(event);
+            }
+        }
+    };
+    __setFunctionName(_classThis, "EventBusService");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        EventBusService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return EventBusService = _classThis;
+})();
+exports.EventBusService = EventBusService;

package/dist/services/event-bus.service.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/event-bus.service.spec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_bus_service_1 = require("./event-bus.service");
+describe('EventBusService', () => {
+    let service;
+    beforeEach(() => {
+        service = new event_bus_service_1.EventBusService();
+    });
+    it('should publish events to subscribers', async () => {
+        const handler = jest.fn();
+        service.subscribe('TestEvent', handler);
+        const event = {
+            aggregateId: 'test-1',
+            eventType: 'TestEvent',
+            data: {},
+            timestamp: new Date(),
+            version: 1,
+        };
+        await service.publish(event);
+        expect(handler).toHaveBeenCalledWith(event);
+    });
+    it('should publish to multiple handlers', async () => {
+        const handler1 = jest.fn();
+        const handler2 = jest.fn();
+        service.subscribe('TestEvent', handler1);
+        service.subscribe('TestEvent', handler2);
+        const event = {
+            aggregateId: 'test-1',
+            eventType: 'TestEvent',
+            data: {},
+            timestamp: new Date(),
+            version: 1,
+        };
+        await service.publish(event);
+        expect(handler1).toHaveBeenCalled();
+        expect(handler2).toHaveBeenCalled();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nest-eventsource-kit",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Event Sourcing and CQRS toolkit for NestJS with support for event store, command/query separation, and saga patterns",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/jest.config.js

@@ -1,7 +0,0 @@
-module.exports = {
-  moduleFileExtensions: ['js', 'json', 'ts'],
-  rootDir: 'src',
-  testRegex: '.*\\.spec\\.ts$',
-  transform: { '^.+\\.(t|j)s$': 'ts-jest' },
-  testEnvironment: 'node',
-};

package/src/event-sourcing.module.ts

@@ -1,14 +0,0 @@
-import { Module, DynamicModule } from '@nestjs/common';
-import { EventStoreService } from './services/event-store.service';
-
-@Module({})
-export class EventSourcingModule {
-  static forRoot(): DynamicModule {
-    return {
-      module: EventSourcingModule,
-      providers: [EventStoreService],
-      exports: [EventStoreService],
-      global: true,
-    };
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './event-sourcing.module';
-export * from './services/event-store.service';
-export * from './interfaces/event.interface';

package/src/interfaces/event.interface.ts

@@ -1,12 +0,0 @@
-export interface DomainEvent {
-  aggregateId: string;
-  eventType: string;
-  data: any;
-  timestamp: Date;
-  version: number;
-}
-
-export interface EventStore {
-  append(event: DomainEvent): Promise<void>;
-  getEvents(aggregateId: string): Promise<DomainEvent[]>;
-}

package/src/services/event-store.service.spec.ts

@@ -1,30 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { EventStoreService } from './event-store.service';
-
-describe('EventStoreService', () => {
-  let service: EventStoreService;
-
-  beforeEach(async () => {
-    const module = await Test.createTestingModule({
-      providers: [EventStoreService],
-    }).compile();
-
-    service = module.get<EventStoreService>(EventStoreService);
-  });
-
-  it('should append and retrieve events', async () => {
-    const event = {
-      aggregateId: 'test-1',
-      eventType: 'TestEvent',
-      data: { value: 42 },
-      timestamp: new Date(),
-      version: 1,
-    };
-
-    await service.append(event);
-    const events = await service.getEvents('test-1');
-
-    expect(events).toHaveLength(1);
-    expect(events[0]).toEqual(event);
-  });
-});

package/src/services/event-store.service.ts

@@ -1,15 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DomainEvent, EventStore } from '../interfaces/event.interface';
-
-@Injectable()
-export class EventStoreService implements EventStore {
-  private events: DomainEvent[] = [];
-
-  async append(event: DomainEvent): Promise<void> {
-    this.events.push(event);
-  }
-
-  async getEvents(aggregateId: string): Promise<DomainEvent[]> {
-    return this.events.filter(e => e.aggregateId === aggregateId);
-  }
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "target": "ES2021",
-    "outDir": "./dist",
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*"]
-}