@event-driven-io/emmett-postgresql 0.29.0 → 0.31.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _event_driven_io_dumbo from '@event-driven-io/dumbo';
 import { SQLExecutor, Dumbo, DumboOptions, QueryResultRow, SQL, NodePostgresClient, NodePostgresTransaction, NodePostgresConnector, NodePostgresPoolClientConnection, NodePostgresClientConnection, NodePostgresPool, MigrationStyle } from '@event-driven-io/dumbo';
-import { Event, ReadEvent, ReadEventMetadataWithGlobalPosition, EmmettError, CanHandle, ThenThrows, TypedProjectionDefinition, ProjectionHandler, EventStore, EventStoreSessionFactory, AppendToStreamOptions, AppendToStreamResultWithGlobalPosition, ProjectionRegistration, ReadEventMetadata, ReadStreamOptions, ReadStreamResult } from '@event-driven-io/emmett';
+import { Event, ReadEvent, ReadEventMetadataWithGlobalPosition, EmmettError, CanHandle, ThenThrows, ProjectionDefinition, ProjectionHandler, EventStore, EventStoreSessionFactory, AppendToStreamOptions, AppendToStreamResultWithGlobalPosition, ProjectionRegistration, ReadEventMetadata, ReadStreamOptions, ReadStreamResult } from '@event-driven-io/emmett';
 import pg from 'pg';
 import { PongoDocument, WithId, PongoFilter, PongoClient } from '@event-driven-io/pongo';
 
@@ -35,70 +35,6 @@ type PostgreSQLEventStoreMessageBatchPuller = {
 declare const postgreSQLEventStoreMessageBatchPuller: <EventType extends Event = Event>({ executor, batchSize, eachBatch, pullingFrequencyInMs, }: PostgreSQLEventStoreMessageBatchPullerOptions<EventType>) => PostgreSQLEventStoreMessageBatchPuller;
 declare const zipPostgreSQLEventStoreMessageBatchPullerStartFrom: (options: (PostgreSQLEventStoreMessageBatchPullerStartFrom | undefined)[]) => PostgreSQLEventStoreMessageBatchPullerStartFrom;
 
-type PostgreSQLProcessorEventsBatch<EventType extends Event = Event> = {
-    messages: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>[];
-};
-type PostgreSQLProcessor<EventType extends Event = Event> = {
-    id: string;
-    start: (execute: SQLExecutor) => Promise<PostgreSQLEventStoreMessageBatchPullerStartFrom | undefined>;
-    isActive: boolean;
-    handle: (messagesBatch: PostgreSQLProcessorEventsBatch<EventType>, context: {
-        pool: Dumbo;
-    }) => Promise<PostgreSQLProcessorMessageHandlerResult>;
-};
-declare const PostgreSQLProcessor: {
-    result: {
-        skip: (options?: {
-            reason?: string;
-        }) => PostgreSQLProcessorMessageHandlerResult;
-        stop: (options?: {
-            reason?: string;
-            error?: EmmettError;
-        }) => PostgreSQLProcessorMessageHandlerResult;
-    };
-};
-type PostgreSQLProcessorMessageHandlerResult = void | {
-    type: 'SKIP';
-    reason?: string;
-} | {
-    type: 'STOP';
-    reason?: string;
-    error?: EmmettError;
-};
-type PostgreSQLProcessorEachMessageHandler<EventType extends Event = Event> = (event: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => Promise<PostgreSQLProcessorMessageHandlerResult> | PostgreSQLProcessorMessageHandlerResult;
-type PostgreSQLProcessorStartFrom = PostgreSQLEventStoreMessageBatchPullerStartFrom | 'CURRENT';
-type PostgreSQLProcessorOptions<EventType extends Event = Event> = {
-    processorId: string;
-    version?: number;
-    partition?: string;
-    startFrom?: PostgreSQLProcessorStartFrom;
-    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
-    eachMessage: PostgreSQLProcessorEachMessageHandler<EventType>;
-};
-declare const postgreSQLProcessor: <EventType extends Event = Event>(options: PostgreSQLProcessorOptions<EventType>) => PostgreSQLProcessor;
-
-type PostgreSQLEventStoreConsumerConfig<ConsumerEventType extends Event = Event> = {
-    processors?: PostgreSQLProcessor<ConsumerEventType>[];
-    pulling?: {
-        batchSize?: number;
-        pullingFrequencyInMs?: number;
-    };
-};
-type PostgreSQLEventStoreConsumerOptions<ConsumerEventType extends Event = Event> = PostgreSQLEventStoreConsumerConfig<ConsumerEventType> & ({
-    connectionString: string;
-} | {
-    pool: Dumbo;
-});
-type PostgreSQLEventStoreConsumer<ConsumerEventType extends Event = Event> = Readonly<{
-    isRunning: boolean;
-    processors: PostgreSQLProcessor<ConsumerEventType>[];
-    processor: <EventType extends ConsumerEventType = ConsumerEventType>(options: PostgreSQLProcessorOptions<EventType>) => PostgreSQLProcessor<EventType>;
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-    close: () => Promise<void>;
-}>;
-declare const postgreSQLEventStoreConsumer: <ConsumerEventType extends Event = Event>(options: PostgreSQLEventStoreConsumerOptions<ConsumerEventType>) => PostgreSQLEventStoreConsumer<ConsumerEventType>;
-
 type PongoAssertOptions = {
     inCollection: string;
     inDatabase?: string;
@@ -135,11 +71,11 @@ type PongoProjectionHandlerContext = PostgreSQLProjectionHandlerContext & {
 type PongoWithNotNullDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = ((document: Document, event: ReadEvent<EventType, EventMetaDataType>) => Document | null) | ((document: Document, event: ReadEvent<EventType>) => Promise<Document | null>);
 type PongoWithNullableDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = ((document: Document | null, event: ReadEvent<EventType, EventMetaDataType>) => Document | null) | ((document: Document | null, event: ReadEvent<EventType>) => Promise<Document | null>);
 type PongoDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType> | PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
-type PongoProjectionOptions<EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = {
-    handle: (events: ReadEvent<EventType, EventMetaDataType>[], context: PongoProjectionHandlerContext) => Promise<void>;
+type PongoProjectionOptions<EventType extends Event> = {
+    handle: (events: ReadEvent<EventType, PostgresReadEventMetadata>[], context: PongoProjectionHandlerContext) => Promise<void>;
     canHandle: CanHandle<EventType>;
 };
-declare const pongoProjection: <EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>({ handle, canHandle, }: PongoProjectionOptions<EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+declare const pongoProjection: <EventType extends Event>({ handle, canHandle, }: PongoProjectionOptions<EventType>) => PostgreSQLProjectionDefinition<EventType>;
 type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = {
     canHandle: CanHandle<EventType>;
     collectionName: string;
@@ -150,7 +86,7 @@ type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType
     evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
     initialState: () => Document;
 });
-declare const pongoMultiStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(options: PongoMultiStreamProjectionOptions<Document, EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+declare const pongoMultiStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(options: PongoMultiStreamProjectionOptions<Document, EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition<EventType>;
 type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = {
     canHandle: CanHandle<EventType>;
     getDocumentId?: (event: ReadEvent<EventType>) => string;
@@ -161,7 +97,7 @@ type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventTyp
     evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
     initialState: () => Document;
 });
-declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(options: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(options: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition<EventType>;
 
 type PostgreSQLProjectionSpecEvent<EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = EventType & {
     metadata?: Partial<EventMetaDataType>;
@@ -173,8 +109,8 @@ type PostgreSQLProjectionAssert = (options: {
     pool: Dumbo;
     connectionString: string;
 }) => Promise<void | boolean>;
-type PostgreSQLProjectionSpecOptions = {
-    projection: PostgreSQLProjectionDefinition;
+type PostgreSQLProjectionSpecOptions<EventType extends Event> = {
+    projection: PostgreSQLProjectionDefinition<EventType>;
 } & DumboOptions;
 type PostgreSQLProjectionSpec<EventType extends Event> = (givenEvents: PostgreSQLProjectionSpecEvent<EventType>[]) => {
     when: (events: PostgreSQLProjectionSpecEvent<EventType>[], options?: PostgreSQLProjectionSpecWhenOptions) => {
@@ -183,7 +119,7 @@ type PostgreSQLProjectionSpec<EventType extends Event> = (givenEvents: PostgreSQ
     };
 };
 declare const PostgreSQLProjectionSpec: {
-    for: <EventType extends Event>(options: PostgreSQLProjectionSpecOptions) => PostgreSQLProjectionSpec<EventType>;
+    for: <EventType extends Event>(options: PostgreSQLProjectionSpecOptions<EventType>) => PostgreSQLProjectionSpec<EventType>;
 };
 declare const eventInStream: <EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(streamName: string, event: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>;
 declare const eventsInStream: <EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[]) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[];
@@ -198,29 +134,163 @@ declare const expectSQL: {
 };
 
 type PostgreSQLProjectionHandlerContext = {
-    connectionString: string;
-    client: NodePostgresClient;
     execute: SQLExecutor;
-    transaction: NodePostgresTransaction;
+    connection: {
+        connectionString: string;
+        client: NodePostgresClient;
+        transaction: NodePostgresTransaction;
+        pool: Dumbo;
+    };
 };
 type PostgreSQLProjectionHandler<EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, PostgreSQLProjectionHandlerContext>;
-type PostgreSQLProjectionDefinition<EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = TypedProjectionDefinition<EventType, EventMetaDataType, PostgreSQLProjectionHandlerContext>;
-type ProjectionHandlerOptions<EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata> = {
-    events: ReadEvent<EventType, EventMetaDataType>[];
-    projections: PostgreSQLProjectionDefinition<EventType, EventMetaDataType>[];
+type PostgreSQLProjectionDefinition<EventType extends Event = Event> = ProjectionDefinition<EventType, PostgresReadEventMetadata, PostgreSQLProjectionHandlerContext>;
+type PostgreSQLProjectionHandlerOptions<EventType extends Event = Event> = {
+    events: ReadEvent<EventType, PostgresReadEventMetadata>[];
+    projections: PostgreSQLProjectionDefinition<EventType>[];
     connection: {
         connectionString: string;
         transaction: NodePostgresTransaction;
+        pool: Dumbo;
+    };
+};
+declare const handleProjections: <EventType extends Event = Event>(options: PostgreSQLProjectionHandlerOptions<EventType>) => Promise<void>;
+declare const postgreSQLProjection: <EventType extends Event>(definition: PostgreSQLProjectionDefinition<EventType>) => PostgreSQLProjectionDefinition<EventType>;
+declare const postgreSQLRawBatchSQLProjection: <EventType extends Event>(handle: (events: EventType[], context: PostgreSQLProjectionHandlerContext) => Promise<SQL[]> | SQL[], ...canHandle: CanHandle<EventType>) => PostgreSQLProjectionDefinition<EventType>;
+declare const postgreSQLRawSQLProjection: <EventType extends Event>(handle: (event: EventType, context: PostgreSQLProjectionHandlerContext) => Promise<SQL> | SQL, ...canHandle: CanHandle<EventType>) => PostgreSQLProjectionDefinition<EventType>;
+
+type PostgreSQLProcessorEventsBatch<EventType extends Event = Event> = {
+    messages: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>[];
+};
+type PostgreSQLProcessorHandlerContext = {
+    execute: SQLExecutor;
+    connection: {
+        connectionString: string;
+        client: NodePostgresClient;
+        transaction: NodePostgresTransaction;
+        pool: Dumbo;
     };
 };
-declare const handleProjections: <EventType extends Event = Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(options: ProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
-declare const postgreSQLProjection: <EventType extends Event, EventMetaDataType extends PostgresReadEventMetadata = PostgresReadEventMetadata>(definition: PostgreSQLProjectionDefinition<EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
-declare const postgreSQLRawBatchSQLProjection: <EventType extends Event>(handle: (events: EventType[], context: PostgreSQLProjectionHandlerContext) => Promise<SQL[]> | SQL[], ...canHandle: CanHandle<EventType>) => PostgreSQLProjectionDefinition;
-declare const postgreSQLRawSQLProjection: <EventType extends Event>(handle: (event: EventType, context: PostgreSQLProjectionHandlerContext) => Promise<SQL> | SQL, ...canHandle: CanHandle<EventType>) => PostgreSQLProjectionDefinition;
+type PostgreSQLProcessor<EventType extends Event = Event> = {
+    id: string;
+    start: (execute: SQLExecutor) => Promise<PostgreSQLEventStoreMessageBatchPullerStartFrom | undefined>;
+    isActive: boolean;
+    handle: (messagesBatch: PostgreSQLProcessorEventsBatch<EventType>, context: {
+        pool?: Dumbo;
+        connectionString?: string;
+    }) => Promise<PostgreSQLProcessorMessageHandlerResult>;
+};
+declare const PostgreSQLProcessor: {
+    result: {
+        skip: (options?: {
+            reason?: string;
+        }) => PostgreSQLProcessorMessageHandlerResult;
+        stop: (options?: {
+            reason?: string;
+            error?: EmmettError;
+        }) => PostgreSQLProcessorMessageHandlerResult;
+    };
+};
+type PostgreSQLProcessorMessageHandlerResult = void | {
+    type: 'SKIP';
+    reason?: string;
+} | {
+    type: 'STOP';
+    reason?: string;
+    error?: EmmettError;
+};
+type PostgreSQLProcessorEachMessageHandler<EventType extends Event = Event> = (event: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>, context: PostgreSQLProcessorHandlerContext) => Promise<PostgreSQLProcessorMessageHandlerResult> | PostgreSQLProcessorMessageHandlerResult;
+type PostgreSQLProcessorEachBatchHandler<EventType extends Event = Event> = (event: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>[], context: PostgreSQLProcessorHandlerContext) => Promise<PostgreSQLProcessorMessageHandlerResult> | PostgreSQLProcessorMessageHandlerResult;
+type PostgreSQLProcessorStartFrom = PostgreSQLEventStoreMessageBatchPullerStartFrom | 'CURRENT';
+type PostgreSQLProcessorPooledOptions = {
+    connector?: NodePostgresConnector;
+    database?: string;
+    pooled: true;
+    pool: pg.Pool;
+} | {
+    connector?: NodePostgresConnector;
+    database?: string;
+    pool: pg.Pool;
+} | {
+    connector?: NodePostgresConnector;
+    database?: string;
+    pooled: true;
+} | {
+    connector?: NodePostgresConnector;
+    database?: string;
+};
+type PostgreSQLProcessorNotPooledOptions = {
+    connector?: NodePostgresConnector;
+    database?: string;
+    pooled: false;
+    client: pg.Client;
+} | {
+    connector?: NodePostgresConnector;
+    database?: string;
+    client: pg.Client;
+} | {
+    connector?: NodePostgresConnector;
+    database?: string;
+    pooled: false;
+} | {
+    connector?: NodePostgresConnector;
+    database?: string;
+    connection: NodePostgresPoolClientConnection | NodePostgresClientConnection;
+    pooled?: false;
+} | {
+    connector?: NodePostgresConnector;
+    database?: string;
+    dumbo: NodePostgresPool;
+    pooled?: false;
+};
+type PostgreSQLProcessorConnectionOptions = {
+    connectionString: string;
+} & (PostgreSQLProcessorPooledOptions | PostgreSQLProcessorNotPooledOptions);
+type GenericPostgreSQLProcessorOptions<EventType extends Event = Event> = {
+    processorId: string;
+    version?: number;
+    partition?: string;
+    startFrom?: PostgreSQLProcessorStartFrom;
+    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
+    eachMessage: PostgreSQLProcessorEachMessageHandler<EventType>;
+    connectionOptions?: PostgreSQLProcessorConnectionOptions;
+};
+type PostgreSQLProjectionProcessorOptions<EventType extends Event = Event> = {
+    processorId?: string;
+    version?: number;
+    projection: PostgreSQLProjectionDefinition<EventType>;
+    partition?: string;
+    startFrom?: PostgreSQLProcessorStartFrom;
+    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
+    connectionOptions?: PostgreSQLProcessorConnectionOptions;
+};
+type PostgreSQLProcessorOptions<EventType extends Event = Event> = GenericPostgreSQLProcessorOptions<EventType> | PostgreSQLProjectionProcessorOptions<EventType>;
+declare const postgreSQLProjectionProcessor: <EventType extends Event = Event>(options: PostgreSQLProjectionProcessorOptions<EventType>) => PostgreSQLProcessor;
+declare const postgreSQLProcessor: <EventType extends Event = Event>(options: PostgreSQLProcessorOptions<EventType>) => PostgreSQLProcessor;
+
+type PostgreSQLEventStoreConsumerConfig<ConsumerEventType extends Event = Event> = {
+    processors?: PostgreSQLProcessor<ConsumerEventType>[];
+    pulling?: {
+        batchSize?: number;
+        pullingFrequencyInMs?: number;
+    };
+};
+type PostgreSQLEventStoreConsumerOptions<ConsumerEventType extends Event = Event> = PostgreSQLEventStoreConsumerConfig<ConsumerEventType> & {
+    connectionString: string;
+    pool?: Dumbo;
+};
+type PostgreSQLEventStoreConsumer<ConsumerEventType extends Event = Event> = Readonly<{
+    isRunning: boolean;
+    processors: PostgreSQLProcessor<ConsumerEventType>[];
+    processor: <EventType extends ConsumerEventType = ConsumerEventType>(options: PostgreSQLProcessorOptions<EventType>) => PostgreSQLProcessor<EventType>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    close: () => Promise<void>;
+}>;
+declare const postgreSQLEventStoreConsumer: <ConsumerEventType extends Event = Event>(options: PostgreSQLEventStoreConsumerOptions<ConsumerEventType>) => PostgreSQLEventStoreConsumer<ConsumerEventType>;
 
 interface PostgresEventStore extends EventStore<PostgresReadEventMetadata>, EventStoreSessionFactory<PostgresEventStore> {
     appendToStream<EventType extends Event>(streamName: string, events: EventType[], options?: AppendToStreamOptions): Promise<AppendToStreamResultWithGlobalPosition>;
-    consumer<ConsumerEventType extends Event = Event>(options: PostgreSQLEventStoreConsumerConfig<ConsumerEventType>): PostgreSQLEventStoreConsumer<ConsumerEventType>;
+    consumer<ConsumerEventType extends Event = Event>(options?: PostgreSQLEventStoreConsumerConfig<ConsumerEventType>): PostgreSQLEventStoreConsumer<ConsumerEventType>;
     close(): Promise<void>;
     schema: {
         sql(): string;
@@ -421,4 +491,4 @@ declare const subscriptionsTable: {
 declare const schemaSQL: SQL[];
 declare const createEventStoreSchema: (pool: NodePostgresPool) => Promise<void>;
 
-export { type AppendToStreamPreCommitHook, DefaultPostgreSQLEventStoreProcessorBatchSize, DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs, type PongoAssertOptions, type PongoDocumentEvolve, type PongoMultiStreamProjectionOptions, type PongoProjectionHandlerContext, type PongoProjectionOptions, type PongoSingleStreamProjectionOptions, type PongoWithNotNullDocumentEvolve, type PongoWithNullableDocumentEvolve, type PostgreSQLEventStoreConsumer, type PostgreSQLEventStoreConsumerConfig, type PostgreSQLEventStoreConsumerOptions, PostgreSQLEventStoreDefaultStreamVersion, type PostgreSQLEventStoreMessageBatchPuller, type PostgreSQLEventStoreMessageBatchPullerOptions, type PostgreSQLEventStoreMessageBatchPullerStartFrom, type PostgreSQLEventStoreMessageBatchPullerStartOptions, type PostgreSQLEventStoreMessagesBatch, type PostgreSQLEventStoreMessagesBatchHandler, type PostgreSQLEventStoreMessagesBatchHandlerResult, PostgreSQLProcessor, type PostgreSQLProcessorEachMessageHandler, type PostgreSQLProcessorEventsBatch, type PostgreSQLProcessorMessageHandlerResult, type PostgreSQLProcessorOptions, type PostgreSQLProcessorStartFrom, type PostgreSQLProjectionAssert, type PostgreSQLProjectionDefinition, type PostgreSQLProjectionHandler, type PostgreSQLProjectionHandlerContext, PostgreSQLProjectionSpec, type PostgreSQLProjectionSpecEvent, type PostgreSQLProjectionSpecOptions, type PostgreSQLProjectionSpecWhenOptions, type PostgresEventStore, type PostgresEventStoreConnectionOptions, type PostgresEventStoreOptions, type PostgresReadEvent, type PostgresReadEventMetadata, type ProjectionHandlerOptions, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type StoreLastProcessedProcessorPositionResult, addDefaultPartition, addEventsPartitions, addModuleForAllTenantsSQL, addModuleSQL, addTablePartitions, addTenantForAllModulesSQL, addTenantSQL, appendEventsSQL, appendToStream, assertSQLQueryResultMatches, createEventStoreSchema, defaultPostgreSQLOptions, defaultTag, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, emmettPrefix, eventInStream, eventsInStream, eventsTable, eventsTableSQL, expectPongoDocuments, expectSQL, getPostgreSQLEventStore, globalNames, globalTag, handleProjections, newEventsInStream, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, postgreSQLEventStoreConsumer, postgreSQLEventStoreMessageBatchPuller, postgreSQLProcessor, postgreSQLProjection, postgreSQLRawBatchSQLProjection, postgreSQLRawSQLProjection, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, sanitizeNameSQL, schemaSQL, storeProcessorCheckpoint, storeSubscriptionCheckpointSQL, streamsTable, streamsTableSQL, subscriptionsTable, subscriptionsTableSQL, zipPostgreSQLEventStoreMessageBatchPullerStartFrom };
+export { type AppendToStreamPreCommitHook, DefaultPostgreSQLEventStoreProcessorBatchSize, DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs, type GenericPostgreSQLProcessorOptions, type PongoAssertOptions, type PongoDocumentEvolve, type PongoMultiStreamProjectionOptions, type PongoProjectionHandlerContext, type PongoProjectionOptions, type PongoSingleStreamProjectionOptions, type PongoWithNotNullDocumentEvolve, type PongoWithNullableDocumentEvolve, type PostgreSQLEventStoreConsumer, type PostgreSQLEventStoreConsumerConfig, type PostgreSQLEventStoreConsumerOptions, PostgreSQLEventStoreDefaultStreamVersion, type PostgreSQLEventStoreMessageBatchPuller, type PostgreSQLEventStoreMessageBatchPullerOptions, type PostgreSQLEventStoreMessageBatchPullerStartFrom, type PostgreSQLEventStoreMessageBatchPullerStartOptions, type PostgreSQLEventStoreMessagesBatch, type PostgreSQLEventStoreMessagesBatchHandler, type PostgreSQLEventStoreMessagesBatchHandlerResult, PostgreSQLProcessor, type PostgreSQLProcessorConnectionOptions, type PostgreSQLProcessorEachBatchHandler, type PostgreSQLProcessorEachMessageHandler, type PostgreSQLProcessorEventsBatch, type PostgreSQLProcessorHandlerContext, type PostgreSQLProcessorMessageHandlerResult, type PostgreSQLProcessorOptions, type PostgreSQLProcessorStartFrom, type PostgreSQLProjectionAssert, type PostgreSQLProjectionDefinition, type PostgreSQLProjectionHandler, type PostgreSQLProjectionHandlerContext, type PostgreSQLProjectionHandlerOptions, type PostgreSQLProjectionProcessorOptions, PostgreSQLProjectionSpec, type PostgreSQLProjectionSpecEvent, type PostgreSQLProjectionSpecOptions, type PostgreSQLProjectionSpecWhenOptions, type PostgresEventStore, type PostgresEventStoreConnectionOptions, type PostgresEventStoreOptions, type PostgresReadEvent, type PostgresReadEventMetadata, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type StoreLastProcessedProcessorPositionResult, addDefaultPartition, addEventsPartitions, addModuleForAllTenantsSQL, addModuleSQL, addTablePartitions, addTenantForAllModulesSQL, addTenantSQL, appendEventsSQL, appendToStream, assertSQLQueryResultMatches, createEventStoreSchema, defaultPostgreSQLOptions, defaultTag, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, emmettPrefix, eventInStream, eventsInStream, eventsTable, eventsTableSQL, expectPongoDocuments, expectSQL, getPostgreSQLEventStore, globalNames, globalTag, handleProjections, newEventsInStream, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, postgreSQLEventStoreConsumer, postgreSQLEventStoreMessageBatchPuller, postgreSQLProcessor, postgreSQLProjection, postgreSQLProjectionProcessor, postgreSQLRawBatchSQLProjection, postgreSQLRawSQLProjection, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, sanitizeNameSQL, schemaSQL, storeProcessorCheckpoint, storeSubscriptionCheckpointSQL, streamsTable, streamsTableSQL, subscriptionsTable, subscriptionsTableSQL, zipPostgreSQLEventStoreMessageBatchPullerStartFrom };

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/eventStore/postgreSQLEventStore.ts
 import {
-  dumbo as dumbo3
+  dumbo as dumbo4
 } from "@event-driven-io/dumbo";
 
 // ../emmett/dist/chunk-4E7QLAH5.js
@@ -605,10 +605,13 @@ var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
 };
 
 // src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
-import { dumbo } from "@event-driven-io/dumbo";
+import { dumbo as dumbo2 } from "@event-driven-io/dumbo";
 
 // src/eventStore/consumers/postgreSQLProcessor.ts
-import "@event-driven-io/dumbo";
+import {
+  dumbo
+} from "@event-driven-io/dumbo";
+import "pg";
 
 // src/eventStore/schema/index.ts
 import "@event-driven-io/dumbo";
@@ -1276,9 +1279,33 @@ var PostgreSQLProcessor = {
     })
   }
 };
-var postgreSQLProcessor = (options) => {
+var genericPostgreSQLProcessor = (options) => {
   const { eachMessage } = options;
   let isActive = true;
+  const poolOptions = {
+    ...options.connectionOptions ? options.connectionOptions : {}
+  };
+  const processorConnectionString = "connectionString" in poolOptions ? poolOptions.connectionString : null;
+  const processorPool = "dumbo" in poolOptions ? poolOptions.dumbo : processorConnectionString ? dumbo({
+    connectionString: processorConnectionString,
+    ...poolOptions
+  }) : null;
+  const getPool = (context) => {
+    const connectionString = processorConnectionString ?? context.connectionString;
+    if (!connectionString)
+      throw new EmmettError(
+        `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
+      );
+    const pool = (!processorConnectionString || connectionString == processorConnectionString ? context?.pool : processorPool) ?? processorPool;
+    if (!pool)
+      throw new EmmettError(
+        `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
+      );
+    return {
+      connectionString,
+      pool
+    };
+  };
   return {
     id: options.processorId,
     start: async (execute) => {
@@ -1294,15 +1321,25 @@ var postgreSQLProcessor = (options) => {
     get isActive() {
       return isActive;
     },
-    handle: async ({ messages }, { pool }) => {
+    handle: async ({ messages }, context) => {
       if (!isActive) return;
-      return pool.withTransaction(async (tx) => {
+      const { pool, connectionString } = getPool(context);
+      return pool.withTransaction(async (transaction) => {
         let result = void 0;
         let lastProcessedPosition = null;
         for (const message of messages) {
           const typedMessage = message;
-          const messageProcessingResult = await eachMessage(typedMessage);
-          await storeProcessorCheckpoint(tx.execute, {
+          const client = await transaction.connection.open();
+          const messageProcessingResult = await eachMessage(typedMessage, {
+            execute: transaction.execute,
+            connection: {
+              connectionString,
+              pool,
+              transaction,
+              client
+            }
+          });
+          await storeProcessorCheckpoint(transaction.execute, {
             processorId: options.processorId,
             version: options.version,
             lastProcessedPosition,
@@ -1328,6 +1365,23 @@ var postgreSQLProcessor = (options) => {
     }
   };
 };
+var postgreSQLProjectionProcessor = (options) => {
+  const projection2 = options.projection;
+  return genericPostgreSQLProcessor({
+    processorId: options.processorId ?? `projection:${projection2.name}`,
+    eachMessage: async (event, context) => {
+      if (!projection2.canHandle.includes(event.type)) return;
+      await projection2.handle([event], context);
+    },
+    ...options
+  });
+};
+var postgreSQLProcessor = (options) => {
+  if ("projection" in options) {
+    return postgreSQLProjectionProcessor(options);
+  }
+  return genericPostgreSQLProcessor(options);
+};
 
 // src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
 var postgreSQLEventStoreConsumer = (options) => {
@@ -1336,7 +1390,7 @@ var postgreSQLEventStoreConsumer = (options) => {
   const processors = options.processors ?? [];
   let start;
   let currentMessagePuller;
-  const pool = "pool" in options ? options.pool : dumbo({ connectionString: options.connectionString });
+  const pool = options.pool ? options.pool : dumbo2({ connectionString: options.connectionString });
   const eachBatch = async (messagesBatch) => {
     const activeProcessors = processors.filter((s) => s.isActive);
     if (activeProcessors.length === 0)
@@ -1346,7 +1400,10 @@ var postgreSQLEventStoreConsumer = (options) => {
       };
     const result = await Promise.allSettled(
       activeProcessors.map((s) => {
-        return s.handle(messagesBatch, { pool });
+        return s.handle(messagesBatch, {
+          pool,
+          connectionString: options.connectionString
+        });
       })
     );
     return result.some(
@@ -1554,7 +1611,9 @@ var pongoProjection = ({
 }) => postgreSQLProjection({
   canHandle,
   handle: async (events, context) => {
-    const { connectionString, client } = context;
+    const {
+      connection: { connectionString, client }
+    } = context;
     const pongo = pongoClient2(connectionString, {
       connectionOptions: { client }
     });
@@ -1593,7 +1652,7 @@ var pongoSingleStreamProjection = (options) => {
 
 // src/eventStore/projections/postgresProjectionSpec.ts
 import {
-  dumbo as dumbo2
+  dumbo as dumbo3
 } from "@event-driven-io/dumbo";
 import { v4 as uuid5 } from "uuid";
 var PostgreSQLProjectionSpec = {
@@ -1631,6 +1690,7 @@ var PostgreSQLProjectionSpec = {
                   events: allEvents,
                   projections: [projection2],
                   connection: {
+                    pool,
                     connectionString,
                     transaction
                   }
@@ -1639,7 +1699,7 @@ var PostgreSQLProjectionSpec = {
             };
             return {
               then: async (assert, message) => {
-                const pool = dumbo2(dumoOptions);
+                const pool = dumbo3(dumoOptions);
                 try {
                   await run(pool);
                   const succeeded = await assert({ pool, connectionString });
@@ -1652,7 +1712,7 @@ var PostgreSQLProjectionSpec = {
                 }
               },
               thenThrows: async (...args) => {
-                const pool = dumbo2(dumoOptions);
+                const pool = dumbo3(dumoOptions);
                 try {
                   await run(pool);
                   throw new AssertionError("Handler did not fail as expected");
@@ -1717,7 +1777,7 @@ var handleProjections = async (options) => {
   const {
     projections: allProjections,
     events,
-    connection: { transaction, connectionString }
+    connection: { pool, transaction, connectionString }
   } = options;
   const eventTypes = events.map((e) => e.type);
   const projections = allProjections.filter(
@@ -1726,9 +1786,12 @@ var handleProjections = async (options) => {
   const client = await transaction.connection.open();
   for (const projection2 of projections) {
     await projection2.handle(events, {
-      connectionString,
-      client,
-      transaction,
+      connection: {
+        connectionString,
+        pool,
+        client,
+        transaction
+      },
       execute: transaction.execute
     });
   }
@@ -1763,7 +1826,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     connectionString,
     ...options.connectionOptions ? options.connectionOptions : {}
   };
-  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : dumbo3(poolOptions);
+  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : dumbo4(poolOptions);
   let migrateSchema;
   const autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
   const ensureSchemaExists = () => {
@@ -1778,6 +1841,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     projections: inlineProjections,
     connection: {
       connectionString,
+      pool,
       transaction
     },
     // TODO: Add proper handling of global data
@@ -1843,7 +1907,11 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
       };
     },
-    consumer: (options2) => postgreSQLEventStoreConsumer({ ...options2, pool }),
+    consumer: (options2) => postgreSQLEventStoreConsumer({
+      ...options2 ?? {},
+      pool,
+      connectionString
+    }),
     close: () => pool.close(),
     async withSession(callback) {
       return await pool.withConnection(async (connection) => {
@@ -1908,6 +1976,7 @@ export {
   postgreSQLEventStoreMessageBatchPuller,
   postgreSQLProcessor,
   postgreSQLProjection,
+  postgreSQLProjectionProcessor,
   postgreSQLRawBatchSQLProjection,
   postgreSQLRawSQLProjection,
   readLastMessageGlobalPosition,