node-cqrs 1.0.0-rc.9 → 1.0.0

package/types/rabbitmq/RabbitMqGateway.d.ts

@@ -1,78 +0,0 @@
-import { ChannelModel } from 'amqplib';
-import { IContainer, IMessage } from '../interfaces';
-type MessageHandler = (m: IMessage) => Promise<unknown> | unknown;
-/**
- * Represents a subscription to events from a RabbitMQ exchange.
- */
-type Subscription = {
-    /** Name of the exchange to subscribe to */
-    exchange: string;
-    /** Optional durable queue name; if omitted, an exclusive temporary queue is used */
-    queueName?: string;
-    /** Specific event type (routing key) for filtering, defaults to all if omitted */
-    eventType?: string;
-    /** Callback function to process received messages */
-    handler: MessageHandler;
-    /** If true, messages originating from this instance are ignored */
-    ignoreOwn?: boolean;
-    /** Optional limit for concurrent message handling */
-    concurrentLimit?: number;
-};
-/**
- * RabbitMqGateway implements the IObservable interface using RabbitMQ.
- *
- * It uses a fanout exchange to broadcast messages to all connected subscribers.
- * The `on` and `off` methods allow you to register and remove handlers for specific event types.
- * The `queue(name)` method creates or returns a durable queue with the given name, ensuring that
- * all messages delivered to the fanout exchange are also routed to this queue.
- */
-export declare class RabbitMqGateway {
-    #private;
-    get connection(): ChannelModel | undefined;
-    constructor(o: Partial<Pick<IContainer, 'logger' | 'process'>> & {
-        rabbitMqConnectionFactory?: () => Promise<ChannelModel>;
-    });
-    /**
-     * Establishes a connection to RabbitMQ.
-     * If a connection attempt is already in progress, it waits for it to complete.
-     * If the connection is lost, it attempts to reconnect automatically.
-     * Upon successful connection, it restores any previously active subscriptions.
-     *
-     * This method is called automatically by other methods if a connection is required but not yet established.
-     *
-     * @returns A promise that resolves with the ChannelModel representing the established connection.
-     */
-    connect(): Promise<ChannelModel>;
-    disconnect(): Promise<void>;
-    subscribeToQueue(exchange: string, queueName: string, handler: MessageHandler): Promise<void>;
-    /**
-     * Subscribes to a non-durable, exclusive queue without requiring acknowledgments.
-     * The queue is deleted when the connection closes.
-     * Messages are considered "delivered" upon receipt.
-     * Failed message processing does not result in redelivery or dead-lettering.
-     */
-    subscribeToFanout(exchange: string, handler: MessageHandler): Promise<void>;
-    /**
-     * Subscribes to events from a specified exchange.
-     *
-     * This method sets up the necessary RabbitMQ topology (exchange, queue, bindings) based on the provided details.
-     * If a `queueName` is provided, it asserts a durable queue with a dead-letter queue for failed messages.
-     * If `queueName` is omitted, it uses or creates a temporary, exclusive queue for the connection.
-     * Then it starts consuming messages from the queue with the specified concurrency limit, if specified.
-     *
-     * @param subscription - The subscription details.
-     * @param subscription.exchange - The name of the exchange to subscribe to.
-     * @param subscription.queueName - Optional. The name of the durable queue. If omitted, an exclusive queue is used.
-     * @param subscription.eventType - The routing key or pattern to bind the queue with.
-     * @param subscription.concurrentLimit - Optional. The maximum number of concurrent messages to process.
-     * @returns A promise that resolves when the subscription is successfully set up.
-     */
-    subscribe(subscription: Subscription): Promise<void>;
-    unsubscribe(subscription: Pick<Subscription, 'exchange' | 'queueName' | 'eventType' | 'handler'>): Promise<void>;
-    /**
-     * Publishes an event to the fanout exchange.
-     * The event will be delivered to all subscribers, except this instance's own consumer.
-     */
-    publish(exchange: string, message: IMessage): Promise<void>;
-}
-export {};

package/types/rabbitmq/TerminationHandler.d.ts

@@ -1,10 +0,0 @@
-/**
- * Handles graceful termination of a Node.js process.
- * Listens for SIGINT and executes a cleanup routine before allowing the process to exit.
- */
-export declare class TerminationHandler {
-    #private;
-    constructor(process: NodeJS.Process, cleanupHandler: () => Promise<void>);
-    on(): void;
-    off(): void;
-}

package/types/rabbitmq/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_EXCHANGE = "node-cqrs.events";
-export declare const HANDLER_PROCESS_TIMEOUT: number;

package/types/rabbitmq/index.d.ts

@@ -1,3 +0,0 @@
-export * from './RabbitMqEventBus';
-export * from './RabbitMqEventInjector';
-export * from './RabbitMqGateway';

package/types/sqlite/AbstractSqliteAccessor.d.ts

@@ -1,25 +0,0 @@
-import { IContainer } from '../interfaces';
-import { Database } from 'better-sqlite3';
-/**
- * Abstract base class for accessing a SQLite database.
- *
- * Manages the database connection lifecycle, ensuring initialization via `assertDb`.
- * Supports providing a database instance directly or a factory function for lazy initialization.
- *
- * Subclasses must implement the `initialize` method for specific setup tasks.
- */
-export declare abstract class AbstractSqliteAccessor {
-    #private;
-    protected db: Database | undefined;
-    constructor(c: Partial<Pick<IContainer, 'viewModelSqliteDb' | 'viewModelSqliteDbFactory'>>);
-    protected abstract initialize(db: Database): Promise<void> | void;
-    /**
-     * Ensures that the database connection is initialized.
-     * Uses a lock to prevent race conditions during concurrent initialization attempts.
-     * If the database is not already initialized, it creates the database connection
-     * using the provided factory and calls the `initialize` method.
-     *
-     * This method is idempotent and safe to call multiple times.
-     */
-    assertConnection(): Promise<void>;
-}

package/types/sqlite/AbstractSqliteObjectProjection.d.ts

@@ -1,8 +0,0 @@
-import { AbstractProjection } from '../AbstractProjection';
-import { IContainer } from '../interfaces';
-import { SqliteObjectView } from './SqliteObjectView';
-export declare abstract class AbstractSqliteObjectProjection<T> extends AbstractProjection<SqliteObjectView<T>> {
-    static get tableName(): string;
-    static get schemaVersion(): string;
-    constructor({ viewModelSqliteDb, viewModelSqliteDbFactory, logger }: Pick<IContainer, 'viewModelSqliteDbFactory' | 'viewModelSqliteDb' | 'logger'>);
-}

package/types/sqlite/AbstractSqliteView.d.ts

@@ -1,18 +0,0 @@
-import { IContainer, IEvent, IEventLocker, ILogger, IViewLocker } from '../interfaces';
-import { SqliteViewLocker, SqliteViewLockerParams } from './SqliteViewLocker';
-import { SqliteEventLocker, SqliteEventLockerParams } from './SqliteEventLocker';
-import { AbstractSqliteAccessor } from './AbstractSqliteAccessor';
-export declare abstract class AbstractSqliteView extends AbstractSqliteAccessor implements IViewLocker, IEventLocker {
-    protected readonly schemaVersion: string;
-    protected readonly viewLocker: SqliteViewLocker;
-    protected readonly eventLocker: SqliteEventLocker;
-    protected logger: ILogger | undefined;
-    get ready(): boolean;
-    constructor(options: Partial<Pick<IContainer, 'viewModelSqliteDb' | 'viewModelSqliteDbFactory' | 'logger'>> & SqliteEventLockerParams & SqliteViewLockerParams);
-    lock(): Promise<boolean>;
-    unlock(): void;
-    once(event: 'ready'): Promise<void>;
-    getLastEvent(): Promise<IEvent<any> | undefined>;
-    tryMarkAsProjecting(event: IEvent<any>): Promise<boolean>;
-    markAsProjected(event: IEvent<any>): Promise<void>;
-}

package/types/sqlite/IContainer.d.ts

@@ -1,7 +0,0 @@
-import { Database } from 'better-sqlite3';
-declare module '../interfaces/IContainer' {
-    interface IContainer {
-        viewModelSqliteDbFactory?: () => Promise<Database> | Database;
-        viewModelSqliteDb?: Database;
-    }
-}

package/types/sqlite/SqliteEventLocker.d.ts

@@ -1,28 +0,0 @@
-import { Database } from 'better-sqlite3';
-import { IContainer, IEvent, IEventLocker } from '../interfaces';
-import { SqliteViewLockerParams } from './SqliteViewLocker';
-import { SqliteProjectionDataParams } from './SqliteProjectionDataParams';
-import { AbstractSqliteAccessor } from './AbstractSqliteAccessor';
-export type SqliteEventLockerParams = SqliteProjectionDataParams & Pick<SqliteViewLockerParams, 'viewLockTableName'> & {
-    /**
-     * (Optional) SQLite table name where event locks are stored
-     *
-     * @default "tbl_event_lock"
-     */
-    eventLockTableName?: string;
-    /**
-     * (Optional) Time-to-live (TTL) duration in milliseconds
-     * for which an event remains in the "processing" state until released.
-     *
-     * @default 15_000
-     */
-    eventLockTtl?: number;
-};
-export declare class SqliteEventLocker extends AbstractSqliteAccessor implements IEventLocker {
-    #private;
-    constructor(o: Pick<IContainer, 'viewModelSqliteDb' | 'viewModelSqliteDbFactory'> & SqliteEventLockerParams);
-    protected initialize(db: Database): void;
-    tryMarkAsProjecting(event: IEvent<any>): Promise<boolean>;
-    markAsProjected(event: IEvent<any>): Promise<void>;
-    getLastEvent(): Promise<IEvent<any> | undefined>;
-}

package/types/sqlite/SqliteObjectStorage.d.ts

@@ -1,16 +0,0 @@
-import { Database } from 'better-sqlite3';
-import { IContainer, IObjectStorage } from '../interfaces';
-import { AbstractSqliteAccessor } from './AbstractSqliteAccessor';
-export declare class SqliteObjectStorage<TRecord> extends AbstractSqliteAccessor implements IObjectStorage<TRecord> {
-    #private;
-    constructor(o: Pick<IContainer, 'viewModelSqliteDb' | 'viewModelSqliteDbFactory'> & {
-        tableName: string;
-    });
-    protected initialize(db: Database): void;
-    get(id: string): Promise<TRecord | undefined>;
-    getSync(id: string): TRecord | undefined;
-    create(id: string, data: TRecord): Promise<void>;
-    update(id: string, update: (r: TRecord) => TRecord): Promise<void>;
-    updateEnforcingNew(id: string, update: (r?: TRecord) => TRecord): Promise<void>;
-    delete(id: string): Promise<boolean>;
-}

package/types/sqlite/SqliteObjectView.d.ts

@@ -1,16 +0,0 @@
-import { AbstractSqliteView } from './AbstractSqliteView';
-import { IObjectStorage, IEventLocker } from '../interfaces';
-import { Database } from 'better-sqlite3';
-export declare class SqliteObjectView<TRecord> extends AbstractSqliteView implements IObjectStorage<TRecord>, IEventLocker {
-    #private;
-    constructor(options: ConstructorParameters<typeof AbstractSqliteView>[0] & {
-        tableNamePrefix: string;
-    });
-    protected initialize(db: Database): Promise<void> | void;
-    get(id: string): Promise<TRecord | undefined>;
-    getSync(id: string): TRecord | undefined;
-    create(id: string, data: TRecord): Promise<void>;
-    update(id: string, update: (r: TRecord) => TRecord): Promise<void>;
-    updateEnforcingNew(id: string, update: (r?: TRecord) => TRecord): Promise<void>;
-    delete(id: string): Promise<boolean>;
-}

package/types/sqlite/SqliteViewLocker.d.ts

@@ -1,30 +0,0 @@
-import { Database } from 'better-sqlite3';
-import { IContainer, IViewLocker } from '../interfaces';
-import { SqliteProjectionDataParams } from './SqliteProjectionDataParams';
-import { AbstractSqliteAccessor } from './AbstractSqliteAccessor';
-export type SqliteViewLockerParams = SqliteProjectionDataParams & {
-    /**
-     * (Optional) SQLite table name where event locks along with the latest event are stored
-     *
-     * @default "tbl_view_lock"
-     */
-    viewLockTableName?: string;
-    /**
-     * (Optional) Time-to-live (TTL) duration (in milliseconds) for which a view remains locked
-     *
-     * @default 120_000
-     */
-    viewLockTtl?: number;
-};
-export declare class SqliteViewLocker extends AbstractSqliteAccessor implements IViewLocker {
-    #private;
-    constructor(o: Partial<Pick<IContainer, 'viewModelSqliteDb' | 'viewModelSqliteDbFactory' | 'logger'>> & SqliteViewLockerParams);
-    protected initialize(db: Database): void;
-    get ready(): boolean;
-    lock(): Promise<boolean>;
-    private scheduleLockProlongation;
-    private cancelLockProlongation;
-    private prolongLock;
-    unlock(): void;
-    once(event: 'ready'): Promise<void>;
-}

package/types/sqlite/index.d.ts

@@ -1,8 +0,0 @@
-export * from './AbstractSqliteAccessor';
-export * from './AbstractSqliteObjectProjection';
-export * from './AbstractSqliteView';
-export * from './SqliteEventLocker';
-export * from './SqliteObjectStorage';
-export * from './SqliteObjectView';
-export * from './SqliteViewLocker';
-export * from './utils';

package/types/sqlite/queries/index.d.ts

@@ -1,2 +0,0 @@
-export * from './eventLockTableInit';
-export * from './viewLockTableInit';

package/types/sqlite/utils/getEventId.d.ts

@@ -1,5 +0,0 @@
-import { IEvent } from '../../interfaces';
-/**
- * Get assigned or generate new event ID from event content
- */
-export declare const getEventId: (event: IEvent) => Buffer;

package/types/sqlite/utils/index.d.ts

@@ -1,2 +0,0 @@
-export * from './guid';
-export * from './getEventId';

package/types/utils/Lock.d.ts

@@ -1,22 +0,0 @@
-/**
- * Provides a simple asynchronous lock mechanism.
- * Useful for ensuring that only one asynchronous operation proceeds at a time
- * for a specific resource or section of code.
- */
-export declare class Lock {
-    #private;
-    get isLocked(): boolean;
-    /**
-     * Wait until lock is released, then acquire it
-     */
-    acquire(): Promise<void>;
-    /**
-     * Returns a promise that is resolved once lock is released
-     */
-    unblocked(): Promise<void>;
-    release(): void;
-    /**
-     * Execute callback with lock acquired, then release lock
-     */
-    runLocked(callback: () => Promise<void>): Promise<void>;
-}

package/types/utils/delay.d.ts

@@ -1,5 +0,0 @@
-/**
- * Returns a promise that resolves after the specified number of milliseconds.
- * The internal timeout is unref'd to avoid blocking Node.js process termination.
- */
-export declare const delay: (ms: number) => Promise<void>;

package/types/utils/getHandler.d.ts

@@ -1,7 +0,0 @@
-import { IMessageHandler } from '../interfaces';
-/**
- * Gets a handler for a specific message type, prefers a public (w\o _ prefix) method, if available
- */
-export declare function getHandler(context: {
-    [key: string]: any;
-}, messageType: string): IMessageHandler | null;

package/types/utils/getMessageHandlerNames.d.ts

@@ -1,5 +0,0 @@
-/**
- * Get message handler names from a command/event handler class.
- * Assumes all private method names start from underscore ("_").
- */
-export declare function getMessageHandlerNames(observerInstanceOrClass: (object | Function)): string[];

package/types/utils/index.d.ts

@@ -1,12 +0,0 @@
-export * from './Deferred';
-export * from './delay';
-export * from './getClassName';
-export * from './getHandler';
-export * from './getMessageHandlerNames';
-export * from './isClass';
-export * from './iteratorToArray';
-export * from './Lock';
-export * from './notEmpty';
-export * from './setupOneTimeEmitterSubscription';
-export * from './subscribe';
-export * from './validateHandlers';

package/types/utils/isClass.d.ts

@@ -1 +0,0 @@
-export declare function isClass(func: Function): boolean;

package/types/utils/iteratorToArray.d.ts

@@ -1 +0,0 @@
-export declare function iteratorToArray<T>(input: AsyncIterable<T> | Iterable<T>): Promise<T[]>;

package/types/utils/notEmpty.d.ts

@@ -1 +0,0 @@
-export declare const notEmpty: <T>(t: T) => t is Exclude<T, undefined | null>;

package/types/utils/setupOneTimeEmitterSubscription.d.ts

@@ -1,12 +0,0 @@
-import { IEvent, ILogger, IObservable } from '../interfaces';
-/**
- * Create one-time eventEmitter subscription for one or multiple events that match a filter
- *
- * @param {IObservable} emitter
- * @param {string[]} messageTypes Array of event type to subscribe to
- * @param {function(IEvent):any} [handler] Optional handler to execute for a first event received
- * @param {function(IEvent):boolean} [filter] Optional filter to apply before executing a handler
- * @param {ILogger} logger
- * @return {Promise<IEvent>} Resolves to first event that passes filter
- */
-export declare function setupOneTimeEmitterSubscription(emitter: IObservable, messageTypes: string[], filter?: (e: IEvent) => boolean, handler?: (e: IEvent) => void, logger?: ILogger): Promise<IEvent>;

package/types/utils/subscribe.d.ts

@@ -1,13 +0,0 @@
-import { IMessageHandler, IObservable } from '../interfaces';
-/**
- * Get a list of message types handled by observer
- */
-export declare function getHandledMessageTypes(observerInstanceOrClass: (object | Function)): string[];
-/**
- * Subscribe observer to observable
- */
-export declare function subscribe(observable: IObservable, observer: object, options?: {
-    messageTypes?: string[];
-    masterHandler?: IMessageHandler;
-    queueName?: string;
-}): void;