node-cqrs 0.17.0 → 1.0.0-beta.0

package/dist/types/interfaces/ILogger.d.ts

@@ -0,0 +1,22 @@
+export interface ILogger {
+    log(level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: {
+        [key: string]: any;
+    }): void;
+    debug(message: string, meta?: {
+        [key: string]: any;
+    }): void;
+    info(message: string, meta?: {
+        [key: string]: any;
+    }): void;
+    warn(message: string, meta?: {
+        [key: string]: any;
+    }): void;
+    error(message: string, meta?: {
+        [key: string]: any;
+    }): void;
+}
+export interface IExtendableLogger extends ILogger {
+    child(meta?: {
+        [key: string]: any;
+    }): IExtendableLogger;
+}

package/dist/types/interfaces/IMessage.d.ts

@@ -0,0 +1,23 @@
+import type { Identifier } from './Identifier.ts';
+export type SagaOriginsMap = Record<string, string>;
+export interface IMessage<TPayload = any> {
+    /** Event or command type */
+    type: string;
+    /**
+     * Target aggregate identifier for commands,
+     * originating aggregate identifier for events
+     */
+    aggregateId?: Identifier;
+    /** Aggregate version at the time of the message */
+    aggregateVersion?: number;
+    /** Starter event ids of sagas associated with this message, keyed by saga descriptor */
+    sagaOrigins?: SagaOriginsMap;
+    /** Business data */
+    payload?: TPayload;
+    /**
+     * Optional metadata/context (e.g. auth info, request id);
+     * Commonly set on commands, then copied to emitted events
+     */
+    context?: any;
+}
+export declare const isMessage: (obj: unknown) => obj is IMessage;

package/dist/types/interfaces/IMutableState.d.ts

@@ -0,0 +1,14 @@
+import type { IEvent } from './IEvent.ts';
+export interface IMutableState {
+    /**
+     * Optional list of event types that are required to restore this state.
+     *
+     * Exposed by AbstractAggregate as `restoresFrom` and may be used by the command handler
+     * to load only the state-relevant events when rehydrating an aggregate.
+     */
+    handles?: Readonly<string[]>;
+    /**
+     * Apply a single event to mutate the state.
+     */
+    mutate(event: IEvent): void;
+}

package/dist/types/interfaces/IObjectStorage.d.ts

@@ -0,0 +1,8 @@
+import type { Identifier } from './Identifier.ts';
+export interface IObjectStorage<TRecord> {
+    get(id: Identifier): Promise<TRecord | undefined> | TRecord | undefined;
+    create(id: Identifier, r: TRecord): Promise<any> | any;
+    update(id: Identifier, cb: (r: TRecord) => TRecord): Promise<any> | any;
+    updateEnforcingNew(id: Identifier, cb: (r?: TRecord) => TRecord): Promise<any> | any;
+    delete(id: Identifier): Promise<any> | any;
+}

package/dist/types/interfaces/IObservable.d.ts

@@ -0,0 +1,15 @@
+import type { IMessage } from './IMessage.ts';
+export interface IMessageHandler {
+    (message: IMessage, meta?: Record<string, any>): unknown | Promise<unknown>;
+}
+export interface IObservable {
+    /**
+     * Setup a listener for a specific event type
+     */
+    on(type: string, handler: IMessageHandler): void;
+    /**
+     * Remove previously installed listener
+     */
+    off(type: string, handler: IMessageHandler): void;
+}
+export declare const isObservable: (obj: unknown) => obj is IObservable;

package/dist/types/interfaces/IObservableQueueProvider.d.ts

@@ -0,0 +1,8 @@
+import type { IObservable } from './IObservable.ts';
+export interface IObservableQueueProvider {
+    /**
+     * Get or create a named queue, which delivers events to a single handler only
+     */
+    queue(name: string): IObservable;
+}
+export declare const isObservableQueueProvider: (obj: unknown) => obj is IObservableQueueProvider;

package/dist/types/interfaces/IObserver.d.ts

@@ -0,0 +1,4 @@
+import type { IObservable } from './IObservable.ts';
+export interface IObserver {
+    subscribe(observable: IObservable): void;
+}

package/dist/types/interfaces/IProjection.d.ts

@@ -0,0 +1,17 @@
+import type { IObserver } from './IObserver.ts';
+import type { IObservable } from './IObservable.ts';
+import type { IEventStorageReader } from './IEventStorageReader.ts';
+import type { IEvent } from './IEvent.ts';
+export interface IProjection<TView> extends IObserver {
+    readonly view: TView;
+    /** Subscribe to new events */
+    subscribe(eventStore: IObservable): void;
+    /** Restore view state from not-yet-projected events */
+    restore(eventStore: IEventStorageReader): Promise<void> | void;
+    /** Project new event */
+    project(event: IEvent, meta?: Record<string, any>): Promise<void> | void;
+}
+export interface IProjectionConstructor {
+    new (c?: any): IProjection<any>;
+    readonly handles?: string[];
+}

package/dist/types/interfaces/ISaga.d.ts

@@ -0,0 +1,38 @@
+import type { IEvent } from './IEvent.ts';
+import type { IEventSet } from './IEventSet.ts';
+import type { ICommand } from './ICommand.ts';
+import type { Identifier } from './Identifier.ts';
+export interface ISaga {
+    /**
+     * Apply a historical event to restore saga state.
+     */
+    mutate(event: IEvent): unknown | Promise<unknown>;
+    /**
+     * Process an incoming event.
+     *
+     * @returns Commands produced by the saga in response to the event
+     */
+    handle(event: IEvent): ReadonlyArray<ICommand> | Promise<ReadonlyArray<ICommand>>;
+}
+export type ISagaConstructorParams = {
+    id: Identifier;
+    /** @deprecated Past events will be passed to the `mutate` method */
+    events?: IEventSet;
+};
+export type ISagaFactory = (options: ISagaConstructorParams) => ISaga;
+export interface ISagaConstructor {
+    new (options: ISagaConstructorParams): ISaga;
+    /**
+     * Override to provide a stable saga descriptor used as a key in `message.sagaOrigins`.
+     * Defaults to the Saga class name.
+     */
+    readonly sagaDescriptor?: string;
+    /**
+     * Optional list of event types that trigger new saga start.
+     *
+     * When not defined, saga start is inferred by the absence of `message.sagaOrigins[sagaDescriptor]`.
+     */
+    readonly startsWith?: string[];
+    /** List of events being handled by Saga */
+    readonly handles: string[];
+}

package/dist/types/interfaces/ISnapshotEvent.d.ts

@@ -0,0 +1,7 @@
+import { type IEvent } from './IEvent.ts';
+export declare const SNAPSHOT_EVENT_TYPE: 'snapshot';
+export interface ISnapshotEvent<TState = any> extends IEvent<TState> {
+    type: typeof SNAPSHOT_EVENT_TYPE;
+    payload: TState;
+}
+export declare const isSnapshotEvent: (event?: unknown) => event is ISnapshotEvent;

package/dist/types/interfaces/IViewLocker.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Interface for managing view restoration state to prevent early access to an inconsistent view
+ * or concurrent restoration by another process.
+ */
+export interface IViewLocker {
+    /**
+     * Indicates whether the view is fully restored and ready to accept new event projections.
+     */
+    ready: boolean;
+    /**
+     * Locks the view to prevent external read/write operations.
+     *
+     * @returns `true` if the lock is successfully acquired, `false` otherwise.
+     */
+    lock(): Promise<boolean> | boolean;
+    /**
+     * Unlocks the view, allowing external read/write operations to resume.
+     */
+    unlock(): Promise<void> | void;
+    /**
+     * Waits until the view is fully restored and ready to accept new events.
+     *
+     * @param eventType The event type to listen for (`"ready"`).
+     * @returns A promise that resolves when the view is ready.
+     */
+    once(eventType: 'ready'): Promise<void>;
+}
+/**
+ * Checks if a given object conforms to the `IViewLocker` interface.
+ *
+ * @param view The object to check.
+ * @returns `true` if the object implements `IViewLocker`, `false` otherwise.
+ */
+export declare const isViewLocker: (view: unknown) => view is IViewLocker;

package/dist/types/interfaces/Identifier.d.ts

@@ -0,0 +1 @@
+export type Identifier = string | number | object;

package/dist/types/interfaces/index.d.ts

@@ -0,0 +1,29 @@
+export * from './IAggregate.ts';
+export * from './IAggregateSnapshotStorage.ts';
+export * from './ICommand.ts';
+export * from './ICommandBus.ts';
+export * from './IContainer.ts';
+export * from './Identifier.ts';
+export * from './IDispatchPipelineProcessor.ts';
+export * from './IEvent.ts';
+export * from './IEventBus.ts';
+export * from './IEventDispatcher.ts';
+export * from './IEventLocker.ts';
+export * from './IEventReceptor.ts';
+export * from './IEventSet.ts';
+export * from './IEventStorageReader.ts';
+export * from './IEventStore.ts';
+export * from './IEventStream.ts';
+export * from './IIdentifierProvider.ts';
+export * from './ILocker.ts';
+export * from './ILogger.ts';
+export * from './IMessage.ts';
+export * from './IMutableState.ts';
+export * from './IObjectStorage.ts';
+export * from './IObservable.ts';
+export * from './IObservableQueueProvider.ts';
+export * from './IObserver.ts';
+export * from './IProjection.ts';
+export * from './ISaga.ts';
+export * from './ISnapshotEvent.ts';
+export * from './IViewLocker.ts';

package/dist/types/interfaces/isObject.d.ts

@@ -0,0 +1 @@
+export declare const isObject: (obj: unknown) => obj is Record<string, any>;

package/dist/types/rabbitmq/IContainer.d.ts

@@ -0,0 +1,19 @@
+import type { ChannelModel } from 'amqplib';
+import type { RabbitMqCommandBusConfig } from './RabbitMqCommandBus.ts';
+import type { RabbitMqEventBusConfig } from './RabbitMqEventBus.ts';
+import type { RabbitMqGateway } from './RabbitMqGateway.ts';
+import type { ConfigProvider } from './utils/index.ts';
+declare module 'node-cqrs' {
+    interface IContainer {
+        rabbitMqGateway?: RabbitMqGateway;
+        rabbitMqConnectionFactory?: () => Promise<ChannelModel>;
+        /**
+         * Provides app id for publish metadata and `ignoreOwn` filtering.
+         *
+         * Defaults to a random string for each {@link RabbitMqGateway} instance.
+         */
+        rabbitMqAppId?: ConfigProvider<string>;
+        rabbitMqEventBusConfig?: ConfigProvider<RabbitMqEventBusConfig>;
+        rabbitMqCommandBusConfig?: ConfigProvider<RabbitMqCommandBusConfig>;
+    }
+}

package/dist/types/rabbitmq/RabbitMqCommandBus.d.ts

@@ -0,0 +1,38 @@
+import type { IContainer } from 'node-cqrs';
+import type { ICommand, ICommandBus, IMessageHandler } from '../interfaces/index.ts';
+import { type Subscription } from './RabbitMqGateway.ts';
+export type RabbitMqCommandBusConfig = Partial<Pick<Subscription, 'exchange' | 'queueName' | 'ignoreOwn' | 'concurrentLimit' | 'handlerProcessTimeout' | 'queueExpires'>>;
+/**
+ * RabbitMQ-backed command bus: delivers each message to exactly
+ * one consumer via a durable named queue.
+ *
+ * Used for point-to-point command delivery or durable event processing.
+ */
+export declare class RabbitMqCommandBus implements ICommandBus {
+    #private;
+    static DEFAULT_EXCHANGE: string;
+    constructor({ rabbitMqGateway, rabbitMqCommandBusConfig }: Pick<IContainer, 'rabbitMqGateway' | 'rabbitMqCommandBusConfig'>);
+    /**
+     * Format and send a command for execution
+     */
+    send(commandType: string, aggregateId?: string, options?: {
+        payload?: object;
+        context?: object;
+    }): Promise<any>;
+    /**
+     * Sends a pre-built command to the exchange, routed to the durable queue.
+     * Exactly one consumer will process it.
+     */
+    send(command: ICommand): Promise<any>;
+    /** @deprecated Use {@link send} */
+    sendRaw(command: ICommand): Promise<any>;
+    /**
+     * Registers a message handler for a specific message type on the durable queue.
+     * Only one consumer receives each message.
+     */
+    on(messageType: string, handler: IMessageHandler): Promise<void>;
+    /**
+     * Removes a previously registered message handler.
+     */
+    off(messageType: string, handler: IMessageHandler): Promise<void>;
+}

package/dist/types/rabbitmq/RabbitMqEventBus.d.ts

@@ -0,0 +1,44 @@
+import type { IContainer } from 'node-cqrs';
+import type { IEventBus, IMessage, IMessageHandler, IObservable, IObservableQueueProvider } from '../interfaces/index.ts';
+import { type Subscription, type SubscribeResult } from './RabbitMqGateway.ts';
+export type RabbitMqEventBusConfig = Partial<Pick<Subscription, 'exchange' | 'queueName' | 'ignoreOwn' | 'concurrentLimit' | 'handlerProcessTimeout' | 'queueExpires'>>;
+/**
+ * RabbitMQ-backed event bus: delivers each published message
+ * to all subscribers.
+ *
+ * By default uses an exclusive (non-durable) queue per connection.
+ * Set `queueName` in config for a durable queue that survives restarts.
+ *
+ * Optionally ignores messages published by this instance (default: true).
+ *
+ * Supports named durable queues via {@link queue} for single-consumer delivery.
+ */
+export declare class RabbitMqEventBus implements IEventBus, IObservableQueueProvider {
+    #private;
+    static get allEventsWildcard(): string;
+    static DEFAULT_EXCHANGE: string;
+    constructor({ rabbitMqGateway, rabbitMqEventBusConfig }: Pick<IContainer, 'rabbitMqGateway' | 'rabbitMqEventBusConfig'>);
+    /**
+     * Publishes a message to the event exchange.
+     * The message will be delivered to all subscribers.
+     */
+    publish(message: IMessage): Promise<void>;
+    /**
+     * Registers a message handler for a specific message type.
+     *
+     * When `queueName` is set in config, uses a durable queue
+     * that survives broker restarts. Otherwise uses an exclusive
+     * (non-durable) queue that is deleted on disconnect.
+     */
+    on(eventType: string, handler: IMessageHandler): Promise<SubscribeResult>;
+    /**
+     * Removes a previously registered message handler for a specific message type.
+     */
+    off(eventType: string, handler: IMessageHandler): Promise<void>;
+    /**
+     * Returns a {@link RabbitMqCommandBus} that uses a durable queue with the given name.
+     * Messages published to the event exchange are also delivered to this queue,
+     * but only one consumer will process each message.
+     */
+    queue(queueName: string): IObservable;
+}

package/dist/types/rabbitmq/RabbitMqGateway.d.ts

@@ -0,0 +1,133 @@
+import type { ChannelModel } from 'amqplib';
+import type { IContainer } from 'node-cqrs';
+import type { IMessage } from '../interfaces/index.ts';
+import { EventEmitter } from 'events';
+type MessageHandler = (m: IMessage) => Promise<unknown> | unknown;
+/**
+ * Represents a subscription to events from a RabbitMQ exchange.
+ */
+export 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;
+    /**
+     * If true, the broker won't expect an acknowledgement of messages delivered to this consumer;
+     * i.e., it will dequeue messages as soon as they've been sent down the wire.
+     *
+     * Defaults to `false` - messages are acknowledged after successful handler completion or rejected on exception.
+     */
+    noAck?: boolean;
+    /**
+     * Handler timeout in milliseconds; if the handler does not complete within this time,
+     * the message is considered failed and is rejected.
+     *
+     * Defaults to 1h (`RabbitMqGateway.HANDLER_PROCESS_TIMEOUT`).
+     * Set to `0` to disable the timeout entirely.
+     */
+    handlerProcessTimeout?: number;
+    /**
+     * How long a durable queue may remain unused (no consumers, no new messages) before RabbitMQ
+     * automatically deletes it, in milliseconds.
+     *
+     * When set, the `x-expires` argument is passed to RabbitMQ on queue assertion (requires RabbitMQ ≥ 3.10
+     * for quorum queues). Set to `0` or leave `undefined` to keep the queue indefinitely.
+     */
+    queueExpires?: number;
+    /**
+     * Enables RabbitMQ single active consumer mode (`x-single-active-consumer`).
+     */
+    singleActiveConsumer?: boolean;
+};
+export type SubscribeResult = {
+    /** The actual queue name (may be auto-generated for exclusive queues) */
+    queue: string;
+    /** True when a new consumer was created for the queue in this call */
+    consumerCreated: boolean;
+    /** Number of ready messages in the queue at the time of subscription */
+    messageCount: number;
+    /** Number of consumers on the queue at the time of subscription (before this one) */
+    consumerCount: number;
+};
+interface RabbitMqGatewayConnected {
+    get connection(): ChannelModel;
+}
+type GatewayEvents = {
+    connected: [];
+    disconnected: [reason?: string];
+};
+/**
+ * RabbitMqGateway provides RabbitMQ-based publish/subscribe for ICommand/IEvent-style messages.
+ *
+ * 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;
+    static HANDLER_PROCESS_TIMEOUT: number;
+    static ALL_EVENTS_WILDCARD: string;
+    static RECONNECT_DELAY: number;
+    get connection(): ChannelModel | undefined;
+    isConnected(): this is this & RabbitMqGatewayConnected;
+    constructor({ rabbitMqConnectionFactory, rabbitMqAppId, eventEmitterFactory, logger, process }: Partial<Pick<IContainer, 'logger' | 'process' | 'rabbitMqConnectionFactory' | 'rabbitMqAppId'>> & {
+        eventEmitterFactory?: () => EventEmitter<GatewayEvents>;
+    });
+    /** Returns this gateway's app id from `rabbitMqAppIdProvider` */
+    getAppId(): Promise<string>;
+    /**
+     * 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, options?: Omit<Subscription, 'exchange' | 'queueName' | 'handler'>): Promise<SubscribeResult>;
+    /**
+     * 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, options?: Omit<Subscription, 'exchange' | 'handler'>): Promise<SubscribeResult>;
+    /**
+     * 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<SubscribeResult>;
+    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>;
+    on<K extends keyof GatewayEvents>(event: K, fn: (...args: GatewayEvents[K]) => void): this;
+    once<K extends keyof GatewayEvents>(event: K, fn: (...args: GatewayEvents[K]) => void): this;
+    off<K extends keyof GatewayEvents>(event: K, fn: (...args: GatewayEvents[K]) => void): this;
+}
+export {};

package/dist/types/rabbitmq/index.d.ts

@@ -0,0 +1,4 @@
+import './IContainer.ts';
+export * from './RabbitMqEventBus.ts';
+export * from './RabbitMqGateway.ts';
+export * from './RabbitMqCommandBus.ts';

package/dist/types/rabbitmq/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './registerExitCleanup.ts';
+export * from './resolveProvider.ts';

package/dist/types/rabbitmq/utils/registerExitCleanup.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Registers cleanup handlers for SIGINT and SIGTERM signals on a Node.js process.
+ * Executes the provided cleanup procedure when one of these signals is received,
+ * then removes the listeners to allow the process to exit gracefully.
+ *
+ * @returns An object with a `dispose` method to manually remove the registered signal handlers.
+ */
+export declare const registerExitCleanup: (process: NodeJS.Process | undefined, cleanupProcedure: () => Promise<unknown> | unknown) => {
+    dispose: () => void;
+};

package/dist/types/rabbitmq/utils/resolveProvider.d.ts

@@ -0,0 +1,3 @@
+export type ConfigProvider<T> = T | (() => T | Promise<T>);
+export declare function resolveProvider<T>(provider: ConfigProvider<T>): Promise<T>;
+export declare function resolveProvider<T>(provider: ConfigProvider<T> | undefined): Promise<T | undefined>;

package/dist/types/sqlite/AbstractSqliteAccessor.d.ts

@@ -0,0 +1,25 @@
+import type { IContainer } from 'node-cqrs';
+import type { 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/dist/types/sqlite/AbstractSqliteObjectProjection.d.ts

@@ -0,0 +1,8 @@
+import type { IContainer } from 'node-cqrs';
+import { AbstractProjection } from '../AbstractProjection.ts';
+import { SqliteObjectView } from './SqliteObjectView.ts';
+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/dist/types/sqlite/AbstractSqliteView.d.ts

@@ -0,0 +1,23 @@
+import type { IContainer } from 'node-cqrs';
+import type { IEvent, IEventLocker, ILogger, IViewLocker } from '../interfaces/index.ts';
+import { SqliteViewLocker, SqliteViewLockerParams } from './SqliteViewLocker.ts';
+import { SqliteEventLocker, SqliteEventLockerParams } from './SqliteEventLocker.ts';
+import { AbstractSqliteAccessor } from './AbstractSqliteAccessor.ts';
+/**
+ * Base class for SQLite-backed projection views with restore locking and last-processed-event tracking
+ */
+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>;
+    markAsLastEvent(event: IEvent<any>): Promise<void>;
+}

package/dist/types/sqlite/IContainer.d.ts

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

package/dist/types/sqlite/SqliteEventLocker.d.ts

@@ -0,0 +1,30 @@
+import type { Database } from 'better-sqlite3';
+import type { IContainer } from 'node-cqrs';
+import type { IEvent, IEventLocker } from '../interfaces/index.ts';
+import type { SqliteViewLockerParams } from './SqliteViewLocker.ts';
+import type { SqliteProjectionDataParams } from './SqliteProjectionDataParams.ts';
+import { AbstractSqliteAccessor } from './AbstractSqliteAccessor.ts';
+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>;
+    markAsLastEvent(event: IEvent<any>): Promise<void>;
+    getLastEvent(): Promise<IEvent<any> | undefined>;
+}

package/dist/types/sqlite/SqliteObjectStorage.d.ts

@@ -0,0 +1,17 @@
+import type { Database } from 'better-sqlite3';
+import type { IContainer } from 'node-cqrs';
+import type { IObjectStorage } from '../interfaces/index.ts';
+import { AbstractSqliteAccessor } from './AbstractSqliteAccessor.ts';
+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/dist/types/sqlite/SqliteObjectView.d.ts

@@ -0,0 +1,19 @@
+import { AbstractSqliteView } from './AbstractSqliteView.ts';
+import type { IObjectStorage, IEventLocker } from '../interfaces/index.ts';
+import type { Database } from 'better-sqlite3';
+/**
+ * SQLite-backed object view with restore locking and last-processed-event tracking
+ */
+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>;
+}