@event-driven-io/emmett-sqlite 0.43.0-alpha.4 → 0.43.0-beta.1

package/dist/sqlite3.d.cts

@@ -1,5 +1,5 @@
 import { sqlite3DumboDriver, SQLite3DumboOptions } from '@event-driven-io/dumbo/sqlite3';
-import { E as EventStoreDriver, S as SQLiteEventStoreOptions } from './sqliteProjection-CFGjb8aY.cjs';
+import { E as EventStoreDriver, S as SQLiteEventStoreOptions } from './sqliteProjection-V1lU-4KS.cjs';
 import '@event-driven-io/dumbo';
 import '@event-driven-io/dumbo/sqlite';
 import '@event-driven-io/emmett';

package/dist/sqlite3.d.ts

@@ -1,5 +1,5 @@
 import { sqlite3DumboDriver, SQLite3DumboOptions } from '@event-driven-io/dumbo/sqlite3';
-import { E as EventStoreDriver, S as SQLiteEventStoreOptions } from './sqliteProjection-CFGjb8aY.js';
+import { E as EventStoreDriver, S as SQLiteEventStoreOptions } from './sqliteProjection-V1lU-4KS.js';
 import '@event-driven-io/dumbo';
 import '@event-driven-io/dumbo/sqlite';
 import '@event-driven-io/emmett';

package/dist/sqliteProjection-V1lU-4KS.d.cts

@@ -0,0 +1,146 @@
+import { AnyDumboDatabaseDriver, ExtractDumboDatabaseDriverOptions, SQLExecutor, SQL, Dumbo, DatabaseDriverType } from '@event-driven-io/dumbo';
+import { AnySQLiteConnection } from '@event-driven-io/dumbo/sqlite';
+import { StreamExistsResult, Message, AnyMessage, ReactorOptions, ReadEventMetadataWithGlobalPosition, MessageProcessor, AnyEvent, Event, ProjectorOptions, MessageConsumerOptions, MessageConsumer, ProjectionRegistration, BeforeEventStoreCommitHandler, EventStore, AppendToStreamOptions, AppendToStreamResultWithGlobalPosition, ReadEvent, ProjectionHandler, ProjectionDefinition, CanHandle, ProjectionInitOptions, EventStoreReadSchemaOptions } from '@event-driven-io/emmett';
+
+interface EventStoreDriver<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, DriverOptions extends AnyEventStoreDriverOptions = AnyEventStoreDriverOptions> {
+    driverType: DatabaseDriver['driverType'];
+    dumboDriver: DatabaseDriver;
+    mapToDumboOptions(driverOptions: DriverOptions): ExtractDumboDatabaseDriverOptions<DatabaseDriver>;
+}
+type EventStoreDriverOptions<Driver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
+    connectionOptions?: ExtractDumboDatabaseDriverOptions<Driver['dumboDriver']> | undefined;
+};
+type AnyEventStoreDriverOptions = EventStoreDriverOptions<any>;
+type AnyEventStoreDriver = EventStoreDriver<AnyDumboDatabaseDriver, AnyEventStoreDriverOptions>;
+type InferOptionsFromEventStoreDriver<C extends AnyEventStoreDriver> = C extends EventStoreDriver<any, infer DO> ? DO : never;
+
+type SQLiteStreamExistsOptions = {
+    partition: string;
+};
+declare const streamExists: (execute: SQLExecutor, streamId: string, options?: SQLiteStreamExistsOptions) => Promise<StreamExistsResult>;
+
+declare const streamsTableSQL: SQL;
+declare const messagesTableSQL: SQL;
+declare const processorsTableSQL: SQL;
+declare const projectionsTableSQL: SQL;
+declare const schemaSQL: SQL[];
+type CreateEventStoreSchemaOptions = {
+    dryRun?: boolean | undefined;
+    ignoreMigrationHashMismatch?: boolean | undefined;
+    migrationTimeoutMs?: number | undefined;
+};
+type EventStoreSchemaMigrationOptions = {
+    migrationOptions?: CreateEventStoreSchemaOptions;
+};
+declare const createEventStoreSchema: (pool: AnySQLiteConnection, hooks?: SQLiteEventStoreOptions["hooks"]) => Promise<void>;
+
+type SQLiteProcessorHandlerContext = {
+    execute: SQLExecutor;
+    connection: AnySQLiteConnection;
+} & EventStoreSchemaMigrationOptions;
+type SQLiteProcessor<MessageType extends Message = AnyMessage> = MessageProcessor<MessageType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext>;
+type SQLiteProcessorConnectionOptions = {
+    connection?: AnySQLiteConnection;
+};
+type SQLiteReactorOptions<MessageType extends Message = Message, MessagePayloadType extends AnyMessage = MessageType> = ReactorOptions<MessageType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext, MessagePayloadType> & SQLiteProcessorConnectionOptions;
+type SQLiteProjectorOptions<EventType extends AnyEvent = AnyEvent, EventPayloadType extends Event = EventType> = ProjectorOptions<EventType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext, EventPayloadType> & SQLiteProcessorConnectionOptions & EventStoreSchemaMigrationOptions;
+
+type SQLiteEventStoreConsumerConfig<ConsumerMessageType extends Message = any> = MessageConsumerOptions<ConsumerMessageType> & {
+    stopWhen?: {
+        noMessagesLeft?: boolean;
+    };
+    pulling?: {
+        batchSize?: number;
+        pullingFrequencyInMs?: number;
+    };
+};
+type SQLiteEventStoreConsumer<ConsumerMessageType extends AnyMessage = any> = MessageConsumer<ConsumerMessageType> & Readonly<{
+    reactor: <MessageType extends AnyMessage = ConsumerMessageType>(options: SQLiteReactorOptions<MessageType>) => SQLiteProcessor<MessageType>;
+}> & (AnyEvent extends ConsumerMessageType ? Readonly<{
+    projector: <EventType extends AnyEvent = ConsumerMessageType & AnyEvent>(options: SQLiteProjectorOptions<EventType>) => SQLiteProcessor<EventType>;
+}> : object);
+
+type EventHandler<E extends Event = Event> = (eventEnvelope: ReadEvent<E>) => void;
+declare const SQLiteEventStoreDefaultStreamVersion = 0n;
+interface SQLiteEventStore extends EventStore<SQLiteReadEventMetadata> {
+    appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<EventType, EventPayloadType>): Promise<AppendToStreamResultWithGlobalPosition>;
+    consumer<ConsumerEventType extends Event = Event>(options?: SQLiteEventStoreConsumerConfig<ConsumerEventType>): SQLiteEventStoreConsumer<ConsumerEventType>;
+    streamExists(streamName: string, options?: SQLiteStreamExistsOptions): Promise<StreamExistsResult>;
+    close(): Promise<void>;
+    schema: {
+        sql(): string;
+        print(): void;
+        migrate(): Promise<void>;
+    };
+}
+type SQLiteReadEventMetadata = ReadEventMetadataWithGlobalPosition;
+type SQLiteReadEvent<EventType extends Event = Event> = ReadEvent<EventType, SQLiteReadEventMetadata>;
+type SQLiteEventStoreOptions<EventStoreDriver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
+    driver: EventStoreDriver;
+    projections?: ProjectionRegistration<'inline', SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>[];
+    schema?: {
+        autoMigration?: 'None' | 'CreateOrUpdate';
+    };
+    hooks?: {
+        /**
+         * This hook will be called **BEFORE** event store schema is created
+         */
+        onBeforeSchemaCreated?: (context: {
+            connection: AnySQLiteConnection;
+        }) => Promise<void> | void;
+        /**
+         * This hook will be called **BEFORE** events were stored in the event store.
+         * @type {BeforeEventStoreCommitHandler<SQLiteEventStore, HandlerContext>}
+         */
+        onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
+            connection: AnySQLiteConnection;
+        }>;
+        /**
+         * This hook will be called **AFTER** event store schema was created
+         */
+        onAfterSchemaCreated?: () => Promise<void> | void;
+    };
+} & {
+    pool?: Dumbo;
+} & InferOptionsFromEventStoreDriver<EventStoreDriver>;
+declare const getSQLiteEventStore: <Driver extends AnyEventStoreDriver = AnyEventStoreDriver>(options: SQLiteEventStoreOptions<Driver>) => SQLiteEventStore;
+
+type SQLiteProjectionHandlerContext = {
+    execute: SQLExecutor;
+    connection: AnySQLiteConnection;
+    driverType: DatabaseDriverType;
+};
+type SQLiteProjectionHandler<EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, SQLiteProjectionHandlerContext>;
+type SQLiteProjectionDefinition<EventType extends Event = Event, EventPayloadType extends Event = EventType> = ProjectionDefinition<EventType, SQLiteReadEventMetadata, SQLiteProjectionHandlerContext, EventPayloadType>;
+type SQLiteProjectionHandlerOptions<EventType extends Event = Event> = {
+    events: ReadEvent<EventType, SQLiteReadEventMetadata>[];
+    projections: SQLiteProjectionDefinition<EventType>[];
+} & SQLiteProjectionHandlerContext;
+declare const handleProjections: <EventType extends Event = Event>(options: SQLiteProjectionHandlerOptions<EventType>) => Promise<void>;
+declare const sqliteProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(definition: SQLiteProjectionDefinition<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type SQLiteRawBatchSQLProjection<EventType extends Event, EventPayloadType extends Event = EventType> = {
+    name: string;
+    kind?: string;
+    version?: number;
+    evolve: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[];
+    canHandle: CanHandle<EventType>;
+    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+};
+declare const sqliteRawBatchSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(options: SQLiteRawBatchSQLProjection<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type SQLiteRawSQLProjection<EventType extends Event, EventPayloadType extends Event = EventType> = {
+    name: string;
+    kind?: string;
+    version?: number;
+    evolve: (events: EventType, context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[] | Promise<SQL> | SQL;
+    canHandle: CanHandle<EventType>;
+    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+};
+declare const sqliteRawSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(options: SQLiteRawSQLProjection<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+
+export { type AnyEventStoreDriver as A, type CreateEventStoreSchemaOptions as C, type EventStoreDriver as E, type InferOptionsFromEventStoreDriver as I, type SQLiteEventStoreOptions as S, type SQLiteEventStore as a, type SQLiteReadEventMetadata as b, type SQLiteProjectionDefinition as c, type SQLiteProjectionHandlerContext as d, type SQLiteProjectionHandler as e, type SQLiteProjectionHandlerOptions as f, type SQLiteRawBatchSQLProjection as g, handleProjections as h, sqliteRawBatchSQLProjection as i, type SQLiteRawSQLProjection as j, sqliteRawSQLProjection as k, type SQLiteStreamExistsOptions as l, streamExists as m, streamsTableSQL as n, messagesTableSQL as o, processorsTableSQL as p, projectionsTableSQL as q, schemaSQL as r, sqliteProjection as s, type EventStoreSchemaMigrationOptions as t, createEventStoreSchema as u, type EventHandler as v, SQLiteEventStoreDefaultStreamVersion as w, type SQLiteReadEvent as x, getSQLiteEventStore as y };

package/dist/sqliteProjection-V1lU-4KS.d.ts

@@ -0,0 +1,146 @@
+import { AnyDumboDatabaseDriver, ExtractDumboDatabaseDriverOptions, SQLExecutor, SQL, Dumbo, DatabaseDriverType } from '@event-driven-io/dumbo';
+import { AnySQLiteConnection } from '@event-driven-io/dumbo/sqlite';
+import { StreamExistsResult, Message, AnyMessage, ReactorOptions, ReadEventMetadataWithGlobalPosition, MessageProcessor, AnyEvent, Event, ProjectorOptions, MessageConsumerOptions, MessageConsumer, ProjectionRegistration, BeforeEventStoreCommitHandler, EventStore, AppendToStreamOptions, AppendToStreamResultWithGlobalPosition, ReadEvent, ProjectionHandler, ProjectionDefinition, CanHandle, ProjectionInitOptions, EventStoreReadSchemaOptions } from '@event-driven-io/emmett';
+
+interface EventStoreDriver<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, DriverOptions extends AnyEventStoreDriverOptions = AnyEventStoreDriverOptions> {
+    driverType: DatabaseDriver['driverType'];
+    dumboDriver: DatabaseDriver;
+    mapToDumboOptions(driverOptions: DriverOptions): ExtractDumboDatabaseDriverOptions<DatabaseDriver>;
+}
+type EventStoreDriverOptions<Driver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
+    connectionOptions?: ExtractDumboDatabaseDriverOptions<Driver['dumboDriver']> | undefined;
+};
+type AnyEventStoreDriverOptions = EventStoreDriverOptions<any>;
+type AnyEventStoreDriver = EventStoreDriver<AnyDumboDatabaseDriver, AnyEventStoreDriverOptions>;
+type InferOptionsFromEventStoreDriver<C extends AnyEventStoreDriver> = C extends EventStoreDriver<any, infer DO> ? DO : never;
+
+type SQLiteStreamExistsOptions = {
+    partition: string;
+};
+declare const streamExists: (execute: SQLExecutor, streamId: string, options?: SQLiteStreamExistsOptions) => Promise<StreamExistsResult>;
+
+declare const streamsTableSQL: SQL;
+declare const messagesTableSQL: SQL;
+declare const processorsTableSQL: SQL;
+declare const projectionsTableSQL: SQL;
+declare const schemaSQL: SQL[];
+type CreateEventStoreSchemaOptions = {
+    dryRun?: boolean | undefined;
+    ignoreMigrationHashMismatch?: boolean | undefined;
+    migrationTimeoutMs?: number | undefined;
+};
+type EventStoreSchemaMigrationOptions = {
+    migrationOptions?: CreateEventStoreSchemaOptions;
+};
+declare const createEventStoreSchema: (pool: AnySQLiteConnection, hooks?: SQLiteEventStoreOptions["hooks"]) => Promise<void>;
+
+type SQLiteProcessorHandlerContext = {
+    execute: SQLExecutor;
+    connection: AnySQLiteConnection;
+} & EventStoreSchemaMigrationOptions;
+type SQLiteProcessor<MessageType extends Message = AnyMessage> = MessageProcessor<MessageType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext>;
+type SQLiteProcessorConnectionOptions = {
+    connection?: AnySQLiteConnection;
+};
+type SQLiteReactorOptions<MessageType extends Message = Message, MessagePayloadType extends AnyMessage = MessageType> = ReactorOptions<MessageType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext, MessagePayloadType> & SQLiteProcessorConnectionOptions;
+type SQLiteProjectorOptions<EventType extends AnyEvent = AnyEvent, EventPayloadType extends Event = EventType> = ProjectorOptions<EventType, ReadEventMetadataWithGlobalPosition, SQLiteProcessorHandlerContext, EventPayloadType> & SQLiteProcessorConnectionOptions & EventStoreSchemaMigrationOptions;
+
+type SQLiteEventStoreConsumerConfig<ConsumerMessageType extends Message = any> = MessageConsumerOptions<ConsumerMessageType> & {
+    stopWhen?: {
+        noMessagesLeft?: boolean;
+    };
+    pulling?: {
+        batchSize?: number;
+        pullingFrequencyInMs?: number;
+    };
+};
+type SQLiteEventStoreConsumer<ConsumerMessageType extends AnyMessage = any> = MessageConsumer<ConsumerMessageType> & Readonly<{
+    reactor: <MessageType extends AnyMessage = ConsumerMessageType>(options: SQLiteReactorOptions<MessageType>) => SQLiteProcessor<MessageType>;
+}> & (AnyEvent extends ConsumerMessageType ? Readonly<{
+    projector: <EventType extends AnyEvent = ConsumerMessageType & AnyEvent>(options: SQLiteProjectorOptions<EventType>) => SQLiteProcessor<EventType>;
+}> : object);
+
+type EventHandler<E extends Event = Event> = (eventEnvelope: ReadEvent<E>) => void;
+declare const SQLiteEventStoreDefaultStreamVersion = 0n;
+interface SQLiteEventStore extends EventStore<SQLiteReadEventMetadata> {
+    appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<EventType, EventPayloadType>): Promise<AppendToStreamResultWithGlobalPosition>;
+    consumer<ConsumerEventType extends Event = Event>(options?: SQLiteEventStoreConsumerConfig<ConsumerEventType>): SQLiteEventStoreConsumer<ConsumerEventType>;
+    streamExists(streamName: string, options?: SQLiteStreamExistsOptions): Promise<StreamExistsResult>;
+    close(): Promise<void>;
+    schema: {
+        sql(): string;
+        print(): void;
+        migrate(): Promise<void>;
+    };
+}
+type SQLiteReadEventMetadata = ReadEventMetadataWithGlobalPosition;
+type SQLiteReadEvent<EventType extends Event = Event> = ReadEvent<EventType, SQLiteReadEventMetadata>;
+type SQLiteEventStoreOptions<EventStoreDriver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
+    driver: EventStoreDriver;
+    projections?: ProjectionRegistration<'inline', SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>[];
+    schema?: {
+        autoMigration?: 'None' | 'CreateOrUpdate';
+    };
+    hooks?: {
+        /**
+         * This hook will be called **BEFORE** event store schema is created
+         */
+        onBeforeSchemaCreated?: (context: {
+            connection: AnySQLiteConnection;
+        }) => Promise<void> | void;
+        /**
+         * This hook will be called **BEFORE** events were stored in the event store.
+         * @type {BeforeEventStoreCommitHandler<SQLiteEventStore, HandlerContext>}
+         */
+        onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
+            connection: AnySQLiteConnection;
+        }>;
+        /**
+         * This hook will be called **AFTER** event store schema was created
+         */
+        onAfterSchemaCreated?: () => Promise<void> | void;
+    };
+} & {
+    pool?: Dumbo;
+} & InferOptionsFromEventStoreDriver<EventStoreDriver>;
+declare const getSQLiteEventStore: <Driver extends AnyEventStoreDriver = AnyEventStoreDriver>(options: SQLiteEventStoreOptions<Driver>) => SQLiteEventStore;
+
+type SQLiteProjectionHandlerContext = {
+    execute: SQLExecutor;
+    connection: AnySQLiteConnection;
+    driverType: DatabaseDriverType;
+};
+type SQLiteProjectionHandler<EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, SQLiteProjectionHandlerContext>;
+type SQLiteProjectionDefinition<EventType extends Event = Event, EventPayloadType extends Event = EventType> = ProjectionDefinition<EventType, SQLiteReadEventMetadata, SQLiteProjectionHandlerContext, EventPayloadType>;
+type SQLiteProjectionHandlerOptions<EventType extends Event = Event> = {
+    events: ReadEvent<EventType, SQLiteReadEventMetadata>[];
+    projections: SQLiteProjectionDefinition<EventType>[];
+} & SQLiteProjectionHandlerContext;
+declare const handleProjections: <EventType extends Event = Event>(options: SQLiteProjectionHandlerOptions<EventType>) => Promise<void>;
+declare const sqliteProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(definition: SQLiteProjectionDefinition<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type SQLiteRawBatchSQLProjection<EventType extends Event, EventPayloadType extends Event = EventType> = {
+    name: string;
+    kind?: string;
+    version?: number;
+    evolve: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[];
+    canHandle: CanHandle<EventType>;
+    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+};
+declare const sqliteRawBatchSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(options: SQLiteRawBatchSQLProjection<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type SQLiteRawSQLProjection<EventType extends Event, EventPayloadType extends Event = EventType> = {
+    name: string;
+    kind?: string;
+    version?: number;
+    evolve: (events: EventType, context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[] | Promise<SQL> | SQL;
+    canHandle: CanHandle<EventType>;
+    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void> | SQL | Promise<SQL> | Promise<SQL[]> | SQL[];
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+};
+declare const sqliteRawSQLProjection: <EventType extends Event, EventPayloadType extends Event = EventType>(options: SQLiteRawSQLProjection<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+
+export { type AnyEventStoreDriver as A, type CreateEventStoreSchemaOptions as C, type EventStoreDriver as E, type InferOptionsFromEventStoreDriver as I, type SQLiteEventStoreOptions as S, type SQLiteEventStore as a, type SQLiteReadEventMetadata as b, type SQLiteProjectionDefinition as c, type SQLiteProjectionHandlerContext as d, type SQLiteProjectionHandler as e, type SQLiteProjectionHandlerOptions as f, type SQLiteRawBatchSQLProjection as g, handleProjections as h, sqliteRawBatchSQLProjection as i, type SQLiteRawSQLProjection as j, sqliteRawSQLProjection as k, type SQLiteStreamExistsOptions as l, streamExists as m, streamsTableSQL as n, messagesTableSQL as o, processorsTableSQL as p, projectionsTableSQL as q, schemaSQL as r, sqliteProjection as s, type EventStoreSchemaMigrationOptions as t, createEventStoreSchema as u, type EventHandler as v, SQLiteEventStoreDefaultStreamVersion as w, type SQLiteReadEvent as x, getSQLiteEventStore as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@event-driven-io/emmett-sqlite",
-  "version": "0.43.0-alpha.4",
+  "version": "0.43.0-beta.1",
   "type": "module",
   "description": "Emmett - SQLite - Event Sourcing development made simple",
   "scripts": {
@@ -92,8 +92,8 @@
     "dist"
   ],
   "dependencies": {
-    "@event-driven-io/emmett": "0.43.0-alpha.4",
-    "@event-driven-io/pongo": "0.17.0-beta.19"
+    "@event-driven-io/emmett": "0.43.0-beta.1",
+    "@event-driven-io/pongo": "0.17.0-beta.21"
   },
   "peerDependencies": {
     "@cloudflare/workers-types": "^4.20260115.0",

package/dist/sqliteProjection-CFGjb8aY.d.cts

@@ -1,172 +0,0 @@
-import { AnyDumboDatabaseDriver, ExtractDumboDatabaseDriverOptions, SQLExecutor, Dumbo, SQL } from '@event-driven-io/dumbo';
-import { AnySQLiteConnection } from '@event-driven-io/dumbo/sqlite';
-import { Event, ReadEvent, ReadEventMetadataWithGlobalPosition, EmmettError, StreamExistsResult, ProjectionRegistration, BeforeEventStoreCommitHandler, EventStore, AppendToStreamOptions, BigIntStreamPosition, AppendToStreamResultWithGlobalPosition, ProjectionDefinition, ProjectionHandler, CanHandle, ProjectionInitOptions } from '@event-driven-io/emmett';
-
-type SQLiteEventStoreMessageBatchPullerStartFrom = {
-    globalPosition: bigint;
-} | 'BEGINNING' | 'END';
-
-interface EventStoreDriver<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboDatabaseDriver, DriverOptions extends AnyEventStoreDriverOptions = AnyEventStoreDriverOptions> {
-    driverType: DatabaseDriver['driverType'];
-    dumboDriver: DatabaseDriver;
-    mapToDumboOptions(driverOptions: DriverOptions): ExtractDumboDatabaseDriverOptions<DatabaseDriver>;
-}
-type EventStoreDriverOptions<Driver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
-    connectionOptions?: ExtractDumboDatabaseDriverOptions<Driver['dumboDriver']> | undefined;
-};
-type AnyEventStoreDriverOptions = EventStoreDriverOptions<any>;
-type AnyEventStoreDriver = EventStoreDriver<AnyDumboDatabaseDriver, AnyEventStoreDriverOptions>;
-type InferOptionsFromEventStoreDriver<C extends AnyEventStoreDriver> = C extends EventStoreDriver<any, infer DO> ? DO : never;
-
-type SQLiteProcessorEventsBatch<EventType extends Event = Event> = {
-    messages: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>[];
-};
-type SQLiteProcessorHandlerContext = {
-    connection: AnySQLiteConnection;
-};
-type SQLiteProcessor<EventType extends Event = Event> = {
-    id: string;
-    start: (connection: AnySQLiteConnection) => Promise<SQLiteEventStoreMessageBatchPullerStartFrom | undefined>;
-    isActive: boolean;
-    handle: (messagesBatch: SQLiteProcessorEventsBatch<EventType>, context: {
-        connection?: AnySQLiteConnection;
-    }) => Promise<SQLiteProcessorMessageHandlerResult>;
-};
-declare const SQLiteProcessor: {
-    result: {
-        skip: (options?: {
-            reason?: string;
-        }) => SQLiteProcessorMessageHandlerResult;
-        stop: (options?: {
-            reason?: string;
-            error?: EmmettError;
-        }) => SQLiteProcessorMessageHandlerResult;
-    };
-};
-type SQLiteProcessorMessageHandlerResult = void | {
-    type: 'SKIP';
-    reason?: string;
-} | {
-    type: 'STOP';
-    reason?: string;
-    error?: EmmettError;
-};
-type SQLiteProcessorEachMessageHandler<EventType extends Event = Event> = (event: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>, context: SQLiteProcessorHandlerContext) => Promise<SQLiteProcessorMessageHandlerResult> | SQLiteProcessorMessageHandlerResult;
-type SQLiteProcessorStartFrom = SQLiteEventStoreMessageBatchPullerStartFrom | 'CURRENT';
-type SQLiteProcessorConnectionOptions = {
-    fileName: string;
-    connection?: AnySQLiteConnection;
-};
-type GenericSQLiteProcessorOptions<EventType extends Event = Event> = {
-    processorId: string;
-    version?: number;
-    partition?: string;
-    startFrom?: SQLiteProcessorStartFrom;
-    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
-    eachMessage: SQLiteProcessorEachMessageHandler<EventType>;
-    connectionOptions?: SQLiteProcessorConnectionOptions;
-};
-type SQLiteProjectionProcessorOptions<EventType extends Event = Event> = {
-    processorId?: string;
-    version?: number;
-    projection: SQLiteProjectionDefinition<EventType>;
-    partition?: string;
-    startFrom?: SQLiteProcessorStartFrom;
-    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
-};
-type SQLiteProcessorOptions<EventType extends Event = Event> = GenericSQLiteProcessorOptions<EventType> | SQLiteProjectionProcessorOptions<EventType>;
-
-type SQLiteEventStoreConsumerConfig<ConsumerEventType extends Event = Event> = {
-    processors?: SQLiteProcessor<ConsumerEventType>[];
-    pulling?: {
-        batchSize?: number;
-        pullingFrequencyInMs?: number;
-    };
-};
-type SQLiteEventStoreConsumer<ConsumerEventType extends Event = Event> = Readonly<{
-    isRunning: boolean;
-    processors: SQLiteProcessor<ConsumerEventType>[];
-    processor: <EventType extends ConsumerEventType = ConsumerEventType>(options: SQLiteProcessorOptions<EventType>) => SQLiteProcessor<EventType>;
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-    close: () => Promise<void>;
-}>;
-
-type SQLiteStreamExistsOptions = {
-    partition: string;
-};
-declare const streamExists: (execute: SQLExecutor, streamId: string, options?: SQLiteStreamExistsOptions) => Promise<StreamExistsResult>;
-
-type EventHandler<E extends Event = Event> = (eventEnvelope: ReadEvent<E>) => void;
-declare const SQLiteEventStoreDefaultStreamVersion = 0n;
-interface SQLiteEventStore extends EventStore<SQLiteReadEventMetadata> {
-    appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<BigIntStreamPosition, EventType, EventPayloadType>): Promise<AppendToStreamResultWithGlobalPosition>;
-    consumer<ConsumerEventType extends Event = Event>(options?: SQLiteEventStoreConsumerConfig<ConsumerEventType>): SQLiteEventStoreConsumer<ConsumerEventType>;
-    streamExists(streamName: string, options?: SQLiteStreamExistsOptions): Promise<StreamExistsResult>;
-    close(): Promise<void>;
-    schema: {
-        sql(): string;
-        print(): void;
-        migrate(): Promise<void>;
-    };
-}
-type SQLiteReadEventMetadata = ReadEventMetadataWithGlobalPosition;
-type SQLiteReadEvent<EventType extends Event = Event> = ReadEvent<EventType, SQLiteReadEventMetadata>;
-type SQLiteEventStoreOptions<EventStoreDriver extends AnyEventStoreDriver = AnyEventStoreDriver> = {
-    driver: EventStoreDriver;
-    projections?: ProjectionRegistration<'inline', SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>[];
-    schema?: {
-        autoMigration?: 'None' | 'CreateOrUpdate';
-    };
-    hooks?: {
-        /**
-         * This hook will be called **BEFORE** event store schema is created
-         */
-        onBeforeSchemaCreated?: (context: {
-            connection: AnySQLiteConnection;
-        }) => Promise<void> | void;
-        /**
-         * This hook will be called **BEFORE** events were stored in the event store.
-         * @type {BeforeEventStoreCommitHandler<SQLiteEventStore, HandlerContext>}
-         */
-        onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
-            connection: AnySQLiteConnection;
-        }>;
-        /**
-         * This hook will be called **AFTER** event store schema was created
-         */
-        onAfterSchemaCreated?: () => Promise<void> | void;
-    };
-} & {
-    pool?: Dumbo;
-} & InferOptionsFromEventStoreDriver<EventStoreDriver>;
-declare const getSQLiteEventStore: <Driver extends AnyEventStoreDriver = AnyEventStoreDriver>(options: SQLiteEventStoreOptions<Driver>) => SQLiteEventStore;
-
-type SQLiteProjectionHandlerContext = {
-    connection: AnySQLiteConnection;
-};
-type SQLiteProjectionHandler<EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, SQLiteProjectionHandlerContext>;
-type SQLiteProjectionDefinition<EventType extends Event = Event> = ProjectionDefinition<EventType, SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>;
-type SQLiteProjectionHandlerOptions<EventType extends Event = Event> = {
-    events: ReadEvent<EventType, SQLiteReadEventMetadata>[];
-    projections: SQLiteProjectionDefinition<EventType>[];
-    connection: AnySQLiteConnection;
-};
-declare const handleProjections: <EventType extends Event = Event>(options: SQLiteProjectionHandlerOptions<EventType>) => Promise<void>;
-declare const sqliteProjection: <EventType extends Event>(definition: SQLiteProjectionDefinition<EventType>) => SQLiteProjectionDefinition<EventType>;
-type SQLiteRawBatchSQLProjection<EventType extends Event> = {
-    evolve: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[];
-    canHandle: CanHandle<EventType>;
-    initSQL?: SQL | SQL[];
-    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void>;
-};
-declare const sqliteRawBatchSQLProjection: <EventType extends Event>(options: SQLiteRawBatchSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
-type SQLiteRawSQLProjection<EventType extends Event> = {
-    evolve: (events: EventType, context: SQLiteProjectionHandlerContext) => Promise<SQL[]> | SQL[] | Promise<SQL> | SQL;
-    canHandle: CanHandle<EventType>;
-    initSQL?: SQL | SQL[];
-    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void>;
-};
-declare const sqliteRawSQLProjection: <EventType extends Event>(options: SQLiteRawSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
-
-export { type AnyEventStoreDriver as A, type EventStoreDriver as E, type InferOptionsFromEventStoreDriver as I, type SQLiteEventStoreOptions as S, type SQLiteEventStore as a, type SQLiteReadEventMetadata as b, type SQLiteProjectionDefinition as c, type SQLiteProjectionHandlerContext as d, type SQLiteProjectionHandler as e, type SQLiteProjectionHandlerOptions as f, type SQLiteRawBatchSQLProjection as g, handleProjections as h, sqliteRawBatchSQLProjection as i, type SQLiteRawSQLProjection as j, sqliteRawSQLProjection as k, type SQLiteStreamExistsOptions as l, streamExists as m, type EventHandler as n, SQLiteEventStoreDefaultStreamVersion as o, type SQLiteReadEvent as p, getSQLiteEventStore as q, sqliteProjection as s };