@event-driven-io/emmett-postgresql 0.17.0 → 0.18.0

package/dist/index.d.mts

@@ -1,10 +1,308 @@
-export { l as PongoAssertOptions, w as PongoDocumentEvolve, z as PongoMultiStreamProjectionOptions, t as PongoProjectionHandlerContext, x as PongoProjectionOptions, B as PongoSingleStreamProjectionOptions, u as PongoWithNotNullDocumentEvolve, v as PongoWithNullableDocumentEvolve, G as PostgreSQLProjectionAssert, e as PostgreSQLProjectionDefinition, d as PostgreSQLProjectionHandler, c as PostgreSQLProjectionHandlerContext, F as PostgreSQLProjectionSpec, D as PostgreSQLProjectionSpecEvent, H as PostgreSQLProjectionSpecOptions, E as PostgreSQLProjectionSpecWhenOptions, P as PostgresEventStore, a as PostgresEventStoreConnectionOptions, b as PostgresEventStoreOptions, h as ProjectionHandlerOptions, L as assertSQLQueryResultMatches, f as defaultPostgreSQLProjectionOptions, r as documentDoesNotExist, m as documentExists, q as documentMatchingExists, n as documentsAreTheSame, o as documentsMatchingHaveCount, I as eventInStream, J as eventsInStream, s as expectPongoDocuments, M as expectSQL, g as getPostgreSQLEventStore, i as handleProjections, K as newEventsInStream, A as pongoMultiStreamProjection, y as pongoProjection, C as pongoSingleStreamProjection, p as postgreSQLProjection, j as postgreSQLRawBatchSQLProjection, k as postgreSQLRawSQLProjection } from './postgreSQLEventStore-BDzOzx7q.mjs';
-export { createEventStoreSchema, schemaSQL } from './eventStore/schema/index.mjs';
-export { appendEventsSQL, appendToStream } from './eventStore/schema/appendToStream.mjs';
-export { readStream } from './eventStore/schema/readStream.mjs';
-export { addDefaultPartition, addEventsPartitions, addModuleForAllTenantsSQL, addModuleSQL, addTablePartitions, addTenantForAllModulesSQL, addTenantSQL, eventsTableSQL, sanitizeNameSQL, streamsTableSQL, subscriptionsTableSQL } from './eventStore/schema/tables.mjs';
-export { defaultTag, emmettPrefix, eventsTable, globalNames, globalTag, streamsTable } from './eventStore/schema/typing.mjs';
-import '@event-driven-io/dumbo';
-import '@event-driven-io/emmett';
-import 'pg';
-import '@event-driven-io/pongo';
+import * as _event_driven_io_dumbo from '@event-driven-io/dumbo';
+import { Dumbo, DumboOptions, QueryResultRow, SQL, NodePostgresClient, SQLExecutor, NodePostgresTransaction, NodePostgresConnector, NodePostgresPoolClientConnection, NodePostgresClientConnection, NodePostgresPool } from '@event-driven-io/dumbo';
+import { Event, EventMetaDataOf, ReadEventMetadataWithGlobalPosition, ReadEvent, CanHandle, ThenThrows, ReadEventMetadata, ProjectionHandler, TypedProjectionDefinition, EventStore, DefaultStreamVersionType, EventStoreSessionFactory, ProjectionRegistration, AppendToStreamOptions, ReadStreamOptions, ReadStreamResult } from '@event-driven-io/emmett';
+import pg from 'pg';
+import { PongoDocument, WithId, PongoFilter, PongoClient } from '@event-driven-io/pongo';
+
+type PongoAssertOptions = {
+    inCollection: string;
+    inDatabase?: string;
+};
+type FilterOrId<Doc extends PongoDocument | WithId<PongoDocument>> = {
+    withId: string;
+} | {
+    matchingFilter: PongoFilter<Doc>;
+};
+declare const documentExists: <Doc extends PongoDocument | WithId<PongoDocument>>(document: Doc, options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentsAreTheSame: <Doc extends PongoDocument | WithId<PongoDocument>>(documents: Doc[], options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentsMatchingHaveCount: <Doc extends PongoDocument | WithId<PongoDocument>>(expectedCount: number, options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentMatchingExists: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentDoesNotExist: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const expectPongoDocuments: {
+    fromCollection: <Doc extends PongoDocument | WithId<PongoDocument>>(collectionName: string) => {
+        withId: (id: string) => {
+            toBeEqual: (document: Doc) => PostgreSQLProjectionAssert;
+            toExist: () => PostgreSQLProjectionAssert;
+            notToExist: () => PostgreSQLProjectionAssert;
+        };
+        matching: <Doc_1 extends PongoDocument | WithId<PongoDocument>>(filter: PongoFilter<Doc_1>) => {
+            toBeTheSame: (documents: Doc_1[]) => PostgreSQLProjectionAssert;
+            toHaveCount: (expectedCount: number) => PostgreSQLProjectionAssert;
+            toExist: () => PostgreSQLProjectionAssert;
+            notToExist: () => PostgreSQLProjectionAssert;
+        };
+    };
+};
+
+type PongoProjectionHandlerContext = PostgreSQLProjectionHandlerContext & {
+    pongo: PongoClient;
+};
+type PongoWithNotNullDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = ((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 EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = ((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 EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType> | PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+type PongoProjectionOptions<EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = {
+    handle: (events: ReadEvent<EventType, EventMetaDataType>[], context: PongoProjectionHandlerContext) => Promise<void>;
+    canHandle: CanHandle<EventType>;
+};
+declare const pongoProjection: <EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>({ handle, canHandle, }: PongoProjectionOptions<EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = {
+    canHandle: CanHandle<EventType>;
+    collectionName: string;
+    getDocumentId: (event: ReadEvent<EventType>) => string;
+} & ({
+    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+    initialState: () => Document;
+});
+declare const pongoMultiStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(options: PongoMultiStreamProjectionOptions<Document, EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = {
+    canHandle: CanHandle<EventType>;
+    collectionName: string;
+} & ({
+    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+    initialState: () => Document;
+});
+declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(options: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+
+type PostgreSQLProjectionSpecEvent<EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = EventType & {
+    metadata?: Partial<EventMetaDataType>;
+};
+type PostgreSQLProjectionSpecWhenOptions = {
+    numberOfTimes: number;
+};
+type PostgreSQLProjectionAssert = (options: {
+    pool: Dumbo;
+    connectionString: string;
+}) => Promise<void | boolean>;
+type PostgreSQLProjectionSpecOptions = {
+    projection: PostgreSQLProjectionDefinition;
+} & DumboOptions;
+type PostgreSQLProjectionSpec<EventType extends Event> = (givenEvents: PostgreSQLProjectionSpecEvent<EventType>[]) => {
+    when: (events: PostgreSQLProjectionSpecEvent<EventType>[], options?: PostgreSQLProjectionSpecWhenOptions) => {
+        then: (assert: PostgreSQLProjectionAssert, message?: string) => Promise<void>;
+        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+    };
+};
+declare const PostgreSQLProjectionSpec: {
+    for: <EventType extends Event>(options: PostgreSQLProjectionSpecOptions) => PostgreSQLProjectionSpec<EventType>;
+};
+declare const eventInStream: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(streamName: string, event: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>;
+declare const eventsInStream: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[]) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[];
+declare const newEventsInStream: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[]) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[];
+declare const assertSQLQueryResultMatches: <T extends QueryResultRow>(sql: SQL, rows: T[]) => PostgreSQLProjectionAssert;
+declare const expectSQL: {
+    query: (sql: SQL) => {
+        resultRows: {
+            toBeTheSame: <T extends QueryResultRow>(rows: T[]) => PostgreSQLProjectionAssert;
+        };
+    };
+};
+
+type PostgreSQLProjectionHandlerContext = {
+    connectionString: string;
+    client: NodePostgresClient;
+    execute: SQLExecutor;
+    transaction: NodePostgresTransaction;
+};
+type PostgreSQLProjectionHandler<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, PostgreSQLProjectionHandlerContext>;
+type PostgreSQLProjectionDefinition<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = TypedProjectionDefinition<EventType, EventMetaDataType, PostgreSQLProjectionHandlerContext>;
+type ProjectionHandlerOptions<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = {
+    events: ReadEvent<EventType, EventMetaDataType>[];
+    projections: PostgreSQLProjectionDefinition<EventType>[];
+    connection: {
+        connectionString: string;
+        transaction: NodePostgresTransaction;
+    };
+};
+declare const handleProjections: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}>>(options: ProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
+declare const postgreSQLProjection: <EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}>>(definition: PostgreSQLProjectionDefinition<EventType>) => 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;
+
+interface PostgresEventStore extends EventStore<DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition>, EventStoreSessionFactory<PostgresEventStore, DefaultStreamVersionType> {
+    close(): Promise<void>;
+    schema: {
+        sql(): string;
+        print(): void;
+        migrate(): Promise<void>;
+    };
+}
+type PostgresEventStorePooledOptions = {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: true;
+    pool: pg.Pool;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pool: pg.Pool;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: true;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+};
+type PostgresEventStoreNotPooledOptions = {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: false;
+    client: pg.Client;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    client: pg.Client;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: false;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    connection: NodePostgresPoolClientConnection | NodePostgresClientConnection;
+    pooled?: false;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    dumbo: NodePostgresPool;
+    pooled?: false;
+};
+declare enum SchemaMigration {
+    None = "None",
+    CreateOrUpdate = "CreateOrUpdate"
+}
+type PostgresEventStoreConnectionOptions = PostgresEventStorePooledOptions | PostgresEventStoreNotPooledOptions;
+type PostgresEventStoreOptions = {
+    projections?: ProjectionRegistration<'inline', PostgreSQLProjectionHandlerContext>[];
+    schema?: {
+        autoMigration?: SchemaMigration;
+    };
+    connectionOptions?: PostgresEventStoreConnectionOptions;
+};
+declare const defaultPostgreSQLOptions: PostgresEventStoreOptions;
+declare const getPostgreSQLEventStore: (connectionString: string, options?: PostgresEventStoreOptions) => PostgresEventStore;
+
+declare const appendEventsSQL: _event_driven_io_dumbo.SQL;
+type AppendEventResult = {
+    success: true;
+    nextStreamPosition: bigint;
+    lastGlobalPosition: bigint;
+    transactionId: string;
+} | {
+    success: false;
+};
+type AppendToStreamPreCommitHook = (events: ReadEvent[], context: {
+    transaction: NodePostgresTransaction;
+}) => Promise<void>;
+declare const appendToStream: (pool: NodePostgresPool, streamName: string, streamType: string, events: Event[], options?: AppendToStreamOptions & {
+    partition?: string;
+    preCommitHook?: AppendToStreamPreCommitHook;
+}) => Promise<AppendEventResult>;
+
+declare const readStream: <EventType extends Event>(execute: SQLExecutor, streamId: string, options?: ReadStreamOptions & {
+    partition?: string;
+}) => Promise<ReadStreamResult<EventType, DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition>>;
+
+declare const streamsTableSQL: _event_driven_io_dumbo.SQL;
+declare const eventsTableSQL: _event_driven_io_dumbo.SQL;
+declare const subscriptionsTableSQL: _event_driven_io_dumbo.SQL;
+declare const sanitizeNameSQL: _event_driven_io_dumbo.SQL;
+declare const addTablePartitions: _event_driven_io_dumbo.SQL;
+declare const addEventsPartitions: _event_driven_io_dumbo.SQL;
+declare const addModuleSQL: _event_driven_io_dumbo.SQL;
+declare const addTenantSQL: _event_driven_io_dumbo.SQL;
+declare const addModuleForAllTenantsSQL: _event_driven_io_dumbo.SQL;
+declare const addTenantForAllModulesSQL: _event_driven_io_dumbo.SQL;
+declare const addDefaultPartition: _event_driven_io_dumbo.SQL;
+
+declare const emmettPrefix = "emt";
+declare const globalTag = "global";
+declare const defaultTag = "emt:default";
+declare const globalNames: {
+    module: string;
+    tenant: string;
+};
+declare const streamsTable: {
+    name: string;
+    columns: {
+        partition: {
+            name: string;
+        };
+        isArchived: {
+            name: string;
+        };
+    };
+};
+declare const eventsTable: {
+    name: string;
+    columns: {
+        partition: {
+            name: string;
+        };
+        isArchived: {
+            name: string;
+        };
+    };
+};
+
+declare const schemaSQL: SQL[];
+declare const createEventStoreSchema: (pool: NodePostgresPool) => Promise<void>;
+
+export { type AppendToStreamPreCommitHook, type PongoAssertOptions, type PongoDocumentEvolve, type PongoMultiStreamProjectionOptions, type PongoProjectionHandlerContext, type PongoProjectionOptions, type PongoSingleStreamProjectionOptions, type PongoWithNotNullDocumentEvolve, type PongoWithNullableDocumentEvolve, type PostgreSQLProjectionAssert, type PostgreSQLProjectionDefinition, type PostgreSQLProjectionHandler, type PostgreSQLProjectionHandlerContext, PostgreSQLProjectionSpec, type PostgreSQLProjectionSpecEvent, type PostgreSQLProjectionSpecOptions, type PostgreSQLProjectionSpecWhenOptions, type PostgresEventStore, type PostgresEventStoreConnectionOptions, type PostgresEventStoreOptions, type ProjectionHandlerOptions, SchemaMigration, 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, postgreSQLProjection, postgreSQLRawBatchSQLProjection, postgreSQLRawSQLProjection, readStream, sanitizeNameSQL, schemaSQL, streamsTable, streamsTableSQL, subscriptionsTableSQL };

package/dist/index.d.ts

@@ -1,10 +1,308 @@
-export { l as PongoAssertOptions, w as PongoDocumentEvolve, z as PongoMultiStreamProjectionOptions, t as PongoProjectionHandlerContext, x as PongoProjectionOptions, B as PongoSingleStreamProjectionOptions, u as PongoWithNotNullDocumentEvolve, v as PongoWithNullableDocumentEvolve, G as PostgreSQLProjectionAssert, e as PostgreSQLProjectionDefinition, d as PostgreSQLProjectionHandler, c as PostgreSQLProjectionHandlerContext, F as PostgreSQLProjectionSpec, D as PostgreSQLProjectionSpecEvent, H as PostgreSQLProjectionSpecOptions, E as PostgreSQLProjectionSpecWhenOptions, P as PostgresEventStore, a as PostgresEventStoreConnectionOptions, b as PostgresEventStoreOptions, h as ProjectionHandlerOptions, L as assertSQLQueryResultMatches, f as defaultPostgreSQLProjectionOptions, r as documentDoesNotExist, m as documentExists, q as documentMatchingExists, n as documentsAreTheSame, o as documentsMatchingHaveCount, I as eventInStream, J as eventsInStream, s as expectPongoDocuments, M as expectSQL, g as getPostgreSQLEventStore, i as handleProjections, K as newEventsInStream, A as pongoMultiStreamProjection, y as pongoProjection, C as pongoSingleStreamProjection, p as postgreSQLProjection, j as postgreSQLRawBatchSQLProjection, k as postgreSQLRawSQLProjection } from './postgreSQLEventStore-BDzOzx7q.js';
-export { createEventStoreSchema, schemaSQL } from './eventStore/schema/index.js';
-export { appendEventsSQL, appendToStream } from './eventStore/schema/appendToStream.js';
-export { readStream } from './eventStore/schema/readStream.js';
-export { addDefaultPartition, addEventsPartitions, addModuleForAllTenantsSQL, addModuleSQL, addTablePartitions, addTenantForAllModulesSQL, addTenantSQL, eventsTableSQL, sanitizeNameSQL, streamsTableSQL, subscriptionsTableSQL } from './eventStore/schema/tables.js';
-export { defaultTag, emmettPrefix, eventsTable, globalNames, globalTag, streamsTable } from './eventStore/schema/typing.js';
-import '@event-driven-io/dumbo';
-import '@event-driven-io/emmett';
-import 'pg';
-import '@event-driven-io/pongo';
+import * as _event_driven_io_dumbo from '@event-driven-io/dumbo';
+import { Dumbo, DumboOptions, QueryResultRow, SQL, NodePostgresClient, SQLExecutor, NodePostgresTransaction, NodePostgresConnector, NodePostgresPoolClientConnection, NodePostgresClientConnection, NodePostgresPool } from '@event-driven-io/dumbo';
+import { Event, EventMetaDataOf, ReadEventMetadataWithGlobalPosition, ReadEvent, CanHandle, ThenThrows, ReadEventMetadata, ProjectionHandler, TypedProjectionDefinition, EventStore, DefaultStreamVersionType, EventStoreSessionFactory, ProjectionRegistration, AppendToStreamOptions, ReadStreamOptions, ReadStreamResult } from '@event-driven-io/emmett';
+import pg from 'pg';
+import { PongoDocument, WithId, PongoFilter, PongoClient } from '@event-driven-io/pongo';
+
+type PongoAssertOptions = {
+    inCollection: string;
+    inDatabase?: string;
+};
+type FilterOrId<Doc extends PongoDocument | WithId<PongoDocument>> = {
+    withId: string;
+} | {
+    matchingFilter: PongoFilter<Doc>;
+};
+declare const documentExists: <Doc extends PongoDocument | WithId<PongoDocument>>(document: Doc, options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentsAreTheSame: <Doc extends PongoDocument | WithId<PongoDocument>>(documents: Doc[], options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentsMatchingHaveCount: <Doc extends PongoDocument | WithId<PongoDocument>>(expectedCount: number, options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentMatchingExists: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentDoesNotExist: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const expectPongoDocuments: {
+    fromCollection: <Doc extends PongoDocument | WithId<PongoDocument>>(collectionName: string) => {
+        withId: (id: string) => {
+            toBeEqual: (document: Doc) => PostgreSQLProjectionAssert;
+            toExist: () => PostgreSQLProjectionAssert;
+            notToExist: () => PostgreSQLProjectionAssert;
+        };
+        matching: <Doc_1 extends PongoDocument | WithId<PongoDocument>>(filter: PongoFilter<Doc_1>) => {
+            toBeTheSame: (documents: Doc_1[]) => PostgreSQLProjectionAssert;
+            toHaveCount: (expectedCount: number) => PostgreSQLProjectionAssert;
+            toExist: () => PostgreSQLProjectionAssert;
+            notToExist: () => PostgreSQLProjectionAssert;
+        };
+    };
+};
+
+type PongoProjectionHandlerContext = PostgreSQLProjectionHandlerContext & {
+    pongo: PongoClient;
+};
+type PongoWithNotNullDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = ((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 EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = ((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 EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType> | PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+type PongoProjectionOptions<EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = {
+    handle: (events: ReadEvent<EventType, EventMetaDataType>[], context: PongoProjectionHandlerContext) => Promise<void>;
+    canHandle: CanHandle<EventType>;
+};
+declare const pongoProjection: <EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>({ handle, canHandle, }: PongoProjectionOptions<EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = {
+    canHandle: CanHandle<EventType>;
+    collectionName: string;
+    getDocumentId: (event: ReadEvent<EventType>) => string;
+} & ({
+    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+    initialState: () => Document;
+});
+declare const pongoMultiStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(options: PongoMultiStreamProjectionOptions<Document, EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = {
+    canHandle: CanHandle<EventType>;
+    collectionName: string;
+} & ({
+    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+    initialState: () => Document;
+});
+declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(options: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType>) => PostgreSQLProjectionDefinition;
+
+type PostgreSQLProjectionSpecEvent<EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition> = EventType & {
+    metadata?: Partial<EventMetaDataType>;
+};
+type PostgreSQLProjectionSpecWhenOptions = {
+    numberOfTimes: number;
+};
+type PostgreSQLProjectionAssert = (options: {
+    pool: Dumbo;
+    connectionString: string;
+}) => Promise<void | boolean>;
+type PostgreSQLProjectionSpecOptions = {
+    projection: PostgreSQLProjectionDefinition;
+} & DumboOptions;
+type PostgreSQLProjectionSpec<EventType extends Event> = (givenEvents: PostgreSQLProjectionSpecEvent<EventType>[]) => {
+    when: (events: PostgreSQLProjectionSpecEvent<EventType>[], options?: PostgreSQLProjectionSpecWhenOptions) => {
+        then: (assert: PostgreSQLProjectionAssert, message?: string) => Promise<void>;
+        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+    };
+};
+declare const PostgreSQLProjectionSpec: {
+    for: <EventType extends Event>(options: PostgreSQLProjectionSpecOptions) => PostgreSQLProjectionSpec<EventType>;
+};
+declare const eventInStream: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(streamName: string, event: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>;
+declare const eventsInStream: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[]) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[];
+declare const newEventsInStream: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadataWithGlobalPosition = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}> & {
+    globalPosition: bigint;
+}>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[]) => PostgreSQLProjectionSpecEvent<EventType, EventMetaDataType>[];
+declare const assertSQLQueryResultMatches: <T extends QueryResultRow>(sql: SQL, rows: T[]) => PostgreSQLProjectionAssert;
+declare const expectSQL: {
+    query: (sql: SQL) => {
+        resultRows: {
+            toBeTheSame: <T extends QueryResultRow>(rows: T[]) => PostgreSQLProjectionAssert;
+        };
+    };
+};
+
+type PostgreSQLProjectionHandlerContext = {
+    connectionString: string;
+    client: NodePostgresClient;
+    execute: SQLExecutor;
+    transaction: NodePostgresTransaction;
+};
+type PostgreSQLProjectionHandler<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, PostgreSQLProjectionHandlerContext>;
+type PostgreSQLProjectionDefinition<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = TypedProjectionDefinition<EventType, EventMetaDataType, PostgreSQLProjectionHandlerContext>;
+type ProjectionHandlerOptions<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = {
+    events: ReadEvent<EventType, EventMetaDataType>[];
+    projections: PostgreSQLProjectionDefinition<EventType>[];
+    connection: {
+        connectionString: string;
+        transaction: NodePostgresTransaction;
+    };
+};
+declare const handleProjections: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}>>(options: ProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
+declare const postgreSQLProjection: <EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & Readonly<{
+    eventId: string;
+    streamPosition: bigint;
+    streamName: string;
+}>>(definition: PostgreSQLProjectionDefinition<EventType>) => 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;
+
+interface PostgresEventStore extends EventStore<DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition>, EventStoreSessionFactory<PostgresEventStore, DefaultStreamVersionType> {
+    close(): Promise<void>;
+    schema: {
+        sql(): string;
+        print(): void;
+        migrate(): Promise<void>;
+    };
+}
+type PostgresEventStorePooledOptions = {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: true;
+    pool: pg.Pool;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pool: pg.Pool;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: true;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+};
+type PostgresEventStoreNotPooledOptions = {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: false;
+    client: pg.Client;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    client: pg.Client;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: false;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    connection: NodePostgresPoolClientConnection | NodePostgresClientConnection;
+    pooled?: false;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    dumbo: NodePostgresPool;
+    pooled?: false;
+};
+declare enum SchemaMigration {
+    None = "None",
+    CreateOrUpdate = "CreateOrUpdate"
+}
+type PostgresEventStoreConnectionOptions = PostgresEventStorePooledOptions | PostgresEventStoreNotPooledOptions;
+type PostgresEventStoreOptions = {
+    projections?: ProjectionRegistration<'inline', PostgreSQLProjectionHandlerContext>[];
+    schema?: {
+        autoMigration?: SchemaMigration;
+    };
+    connectionOptions?: PostgresEventStoreConnectionOptions;
+};
+declare const defaultPostgreSQLOptions: PostgresEventStoreOptions;
+declare const getPostgreSQLEventStore: (connectionString: string, options?: PostgresEventStoreOptions) => PostgresEventStore;
+
+declare const appendEventsSQL: _event_driven_io_dumbo.SQL;
+type AppendEventResult = {
+    success: true;
+    nextStreamPosition: bigint;
+    lastGlobalPosition: bigint;
+    transactionId: string;
+} | {
+    success: false;
+};
+type AppendToStreamPreCommitHook = (events: ReadEvent[], context: {
+    transaction: NodePostgresTransaction;
+}) => Promise<void>;
+declare const appendToStream: (pool: NodePostgresPool, streamName: string, streamType: string, events: Event[], options?: AppendToStreamOptions & {
+    partition?: string;
+    preCommitHook?: AppendToStreamPreCommitHook;
+}) => Promise<AppendEventResult>;
+
+declare const readStream: <EventType extends Event>(execute: SQLExecutor, streamId: string, options?: ReadStreamOptions & {
+    partition?: string;
+}) => Promise<ReadStreamResult<EventType, DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition>>;
+
+declare const streamsTableSQL: _event_driven_io_dumbo.SQL;
+declare const eventsTableSQL: _event_driven_io_dumbo.SQL;
+declare const subscriptionsTableSQL: _event_driven_io_dumbo.SQL;
+declare const sanitizeNameSQL: _event_driven_io_dumbo.SQL;
+declare const addTablePartitions: _event_driven_io_dumbo.SQL;
+declare const addEventsPartitions: _event_driven_io_dumbo.SQL;
+declare const addModuleSQL: _event_driven_io_dumbo.SQL;
+declare const addTenantSQL: _event_driven_io_dumbo.SQL;
+declare const addModuleForAllTenantsSQL: _event_driven_io_dumbo.SQL;
+declare const addTenantForAllModulesSQL: _event_driven_io_dumbo.SQL;
+declare const addDefaultPartition: _event_driven_io_dumbo.SQL;
+
+declare const emmettPrefix = "emt";
+declare const globalTag = "global";
+declare const defaultTag = "emt:default";
+declare const globalNames: {
+    module: string;
+    tenant: string;
+};
+declare const streamsTable: {
+    name: string;
+    columns: {
+        partition: {
+            name: string;
+        };
+        isArchived: {
+            name: string;
+        };
+    };
+};
+declare const eventsTable: {
+    name: string;
+    columns: {
+        partition: {
+            name: string;
+        };
+        isArchived: {
+            name: string;
+        };
+    };
+};
+
+declare const schemaSQL: SQL[];
+declare const createEventStoreSchema: (pool: NodePostgresPool) => Promise<void>;
+
+export { type AppendToStreamPreCommitHook, type PongoAssertOptions, type PongoDocumentEvolve, type PongoMultiStreamProjectionOptions, type PongoProjectionHandlerContext, type PongoProjectionOptions, type PongoSingleStreamProjectionOptions, type PongoWithNotNullDocumentEvolve, type PongoWithNullableDocumentEvolve, type PostgreSQLProjectionAssert, type PostgreSQLProjectionDefinition, type PostgreSQLProjectionHandler, type PostgreSQLProjectionHandlerContext, PostgreSQLProjectionSpec, type PostgreSQLProjectionSpecEvent, type PostgreSQLProjectionSpecOptions, type PostgreSQLProjectionSpecWhenOptions, type PostgresEventStore, type PostgresEventStoreConnectionOptions, type PostgresEventStoreOptions, type ProjectionHandlerOptions, SchemaMigration, 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, postgreSQLProjection, postgreSQLRawBatchSQLProjection, postgreSQLRawSQLProjection, readStream, sanitizeNameSQL, schemaSQL, streamsTable, streamsTableSQL, subscriptionsTableSQL };