@event-driven-io/emmett-sqlite 0.43.0-beta.6 → 0.43.0-beta.7

package/dist/index.d.cts

@@ -1,7 +1,8 @@
-import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, A as AnyEventStoreDriver, c as SQLiteProjectionDefinition, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-D6WKeuhb.cjs';
-export { C as CreateEventStoreSchemaOptions, d as EventHandler, e as EventStoreSchemaMigrationOptions, f as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, g as SQLiteProjectionHandler, h as SQLiteProjectionHandlerContext, i as SQLiteProjectionHandlerOptions, j as SQLiteRawBatchSQLProjection, k as SQLiteRawSQLProjection, l as SQLiteReadEvent, m as SQLiteStreamExistsOptions, n as createEventStoreSchema, o as getSQLiteEventStore, p as handleProjections, q as messagesTableSQL, r as processorsTableSQL, s as projectionsTableSQL, t as schemaSQL, u as sqliteProjection, v as sqliteRawBatchSQLProjection, w as sqliteRawSQLProjection, x as streamExists, y as streamsTableSQL } from './sqliteProjection-D6WKeuhb.cjs';
 import * as _event_driven_io_emmett from '@event-driven-io/emmett';
-import { Event, AppendToStreamOptions, BeforeEventStoreCommitHandler, Message, RecordedMessageMetadata, RecordedMessage, RecordedMessageMetadataWithGlobalPosition, ProcessorCheckpoint, ReadStreamOptions, ReadStreamResult, ReadEventMetadataWithGlobalPosition, ThenThrows } from '@event-driven-io/emmett';
+import { Event, AppendToStreamOptions, BeforeEventStoreCommitHandler, Message, RecordedMessageMetadata, RecordedMessage, RecordedMessageMetadataWithGlobalPosition, ProcessorCheckpoint, ReadStreamOptions, ReadStreamResult, ReadEventMetadataWithGlobalPosition, ReadEvent, CanHandle, EventStoreReadSchemaOptions, TruncateProjection, ThenThrows } from '@event-driven-io/emmett';
+import { PongoDocument, PongoDBCollectionOptions, PongoClient, WithId, PongoFilter } from '@event-driven-io/pongo';
+import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, c as SQLiteProjectionHandlerContext, d as SQLiteProjectionDefinition, A as AnyEventStoreDriver, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-BZi2wy1K.cjs';
+export { C as CreateEventStoreSchemaOptions, e as EventHandler, f as EventStoreSchemaMigrationOptions, g as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, h as SQLiteProjectionHandler, i as SQLiteProjectionHandlerOptions, j as SQLiteRawBatchSQLProjection, k as SQLiteRawSQLProjection, l as SQLiteReadEvent, m as SQLiteStreamExistsOptions, n as createEventStoreSchema, o as getSQLiteEventStore, p as handleProjections, q as messagesTableSQL, r as processorsTableSQL, s as projectionsTableSQL, t as schemaSQL, u as sqliteProjection, v as sqliteRawBatchSQLProjection, w as sqliteRawSQLProjection, x as streamExists, y as streamsTableSQL } from './sqliteProjection-BZi2wy1K.cjs';
 import { SQL, SQLExecutor, Dumbo, QueryResultRow } from '@event-driven-io/dumbo';
 import { AnySQLiteConnection } from '@event-driven-io/dumbo/sqlite';
 
@@ -119,6 +120,89 @@ declare const projectionsTable: {
     name: string;
 };
 
+type PongoProjectionHandlerContext = SQLiteProjectionHandlerContext & {
+    pongo: PongoClient;
+};
+type PongoWithNotNullDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ((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 SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ((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 SQLiteReadEventMetadata = SQLiteReadEventMetadata> = PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType> | PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+type PongoProjectionOptions<EventType extends Event, EventPayloadType extends Event = EventType> = {
+    name: string;
+    kind?: string;
+    version?: number;
+    handle: (events: ReadEvent<EventType, SQLiteReadEventMetadata>[], context: PongoProjectionHandlerContext) => Promise<void>;
+    canHandle: CanHandle<EventType>;
+    truncate?: TruncateProjection<PongoProjectionHandlerContext>;
+    init?: (context: PongoProjectionHandlerContext) => void | Promise<void>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+};
+declare const pongoProjection: <EventType extends Event, EventPayloadType extends Event = EventType>({ name, kind, version, truncate, handle, canHandle, eventsOptions, }: PongoProjectionOptions<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType, DocumentPayload extends PongoDocument = Document> = {
+    kind?: string;
+    canHandle: CanHandle<EventType>;
+    version?: number;
+    collectionName: string;
+    collectionOptions?: PongoDBCollectionOptions<Document, DocumentPayload>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+    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 SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType>(options: PongoMultiStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType, DocumentPayload extends PongoDocument = Document> = {
+    canHandle: CanHandle<EventType>;
+    getDocumentId?: (event: ReadEvent<EventType>) => string;
+    version?: number;
+    collectionName: string;
+    collectionOptions?: PongoDBCollectionOptions<Document, DocumentPayload>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+} & ({
+    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+    initialState: () => Document;
+});
+declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType>(options: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+
+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>) => SQLiteProjectionAssert;
+declare const documentsAreTheSame: <Doc extends PongoDocument | WithId<PongoDocument>>(documents: Doc[], options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentsMatchingHaveCount: <Doc extends PongoDocument | WithId<PongoDocument>>(expectedCount: number, options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentMatchingExists: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentDoesNotExist: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const expectPongoDocuments: {
+    fromCollection: <Doc extends PongoDocument | WithId<PongoDocument>>(collectionName: string) => {
+        withId: (id: string) => {
+            toBeEqual: (document: Doc) => SQLiteProjectionAssert;
+            toExist: () => SQLiteProjectionAssert;
+            notToExist: () => SQLiteProjectionAssert;
+        };
+        matching: <Doc_1 extends PongoDocument | WithId<PongoDocument>>(filter: PongoFilter<Doc_1>) => {
+            toBeTheSame: (documents: Doc_1[]) => SQLiteProjectionAssert;
+            toHaveCount: (expectedCount: number) => SQLiteProjectionAssert;
+            toExist: () => SQLiteProjectionAssert;
+            notToExist: () => SQLiteProjectionAssert;
+        };
+    };
+};
+
 type SQLiteProjectionSpecEvent<EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = EventType & {
     metadata?: Partial<EventMetaDataType>;
 };
@@ -154,4 +238,4 @@ declare const expectSQL: {
     };
 };
 
-export { type AppendEventResult, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, SQLiteEventStore, type SQLiteProjectionAssert, SQLiteProjectionDefinition, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, SQLiteReadEventMetadata, type StoreProcessorCheckpointResult, appendToStream, assertSQLQueryResultMatches, defaultTag, emmettPrefix, eventInStream, eventsInStream, expectSQL, globalNames, globalTag, messagesTable, migration_0_42_0_FromSubscriptionsToProcessors, migration_0_42_0_SQLs, newEventsInStream, processorsTable, projectionsTable, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schema_0_41_0, schema_0_42_0, storeProcessorCheckpoint, streamsTable, unknownTag };
+export { type AppendEventResult, type PongoAssertOptions, type PongoDocumentEvolve, type PongoMultiStreamProjectionOptions, type PongoProjectionHandlerContext, type PongoProjectionOptions, type PongoSingleStreamProjectionOptions, type PongoWithNotNullDocumentEvolve, type PongoWithNullableDocumentEvolve, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, SQLiteEventStore, type SQLiteProjectionAssert, SQLiteProjectionDefinition, SQLiteProjectionHandlerContext, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, SQLiteReadEventMetadata, type StoreProcessorCheckpointResult, appendToStream, assertSQLQueryResultMatches, defaultTag, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, emmettPrefix, eventInStream, eventsInStream, expectPongoDocuments, expectSQL, globalNames, globalTag, messagesTable, migration_0_42_0_FromSubscriptionsToProcessors, migration_0_42_0_SQLs, newEventsInStream, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, processorsTable, projectionsTable, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schema_0_41_0, schema_0_42_0, storeProcessorCheckpoint, streamsTable, unknownTag };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, A as AnyEventStoreDriver, c as SQLiteProjectionDefinition, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-D6WKeuhb.js';
-export { C as CreateEventStoreSchemaOptions, d as EventHandler, e as EventStoreSchemaMigrationOptions, f as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, g as SQLiteProjectionHandler, h as SQLiteProjectionHandlerContext, i as SQLiteProjectionHandlerOptions, j as SQLiteRawBatchSQLProjection, k as SQLiteRawSQLProjection, l as SQLiteReadEvent, m as SQLiteStreamExistsOptions, n as createEventStoreSchema, o as getSQLiteEventStore, p as handleProjections, q as messagesTableSQL, r as processorsTableSQL, s as projectionsTableSQL, t as schemaSQL, u as sqliteProjection, v as sqliteRawBatchSQLProjection, w as sqliteRawSQLProjection, x as streamExists, y as streamsTableSQL } from './sqliteProjection-D6WKeuhb.js';
 import * as _event_driven_io_emmett from '@event-driven-io/emmett';
-import { Event, AppendToStreamOptions, BeforeEventStoreCommitHandler, Message, RecordedMessageMetadata, RecordedMessage, RecordedMessageMetadataWithGlobalPosition, ProcessorCheckpoint, ReadStreamOptions, ReadStreamResult, ReadEventMetadataWithGlobalPosition, ThenThrows } from '@event-driven-io/emmett';
+import { Event, AppendToStreamOptions, BeforeEventStoreCommitHandler, Message, RecordedMessageMetadata, RecordedMessage, RecordedMessageMetadataWithGlobalPosition, ProcessorCheckpoint, ReadStreamOptions, ReadStreamResult, ReadEventMetadataWithGlobalPosition, ReadEvent, CanHandle, EventStoreReadSchemaOptions, TruncateProjection, ThenThrows } from '@event-driven-io/emmett';
+import { PongoDocument, PongoDBCollectionOptions, PongoClient, WithId, PongoFilter } from '@event-driven-io/pongo';
+import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, c as SQLiteProjectionHandlerContext, d as SQLiteProjectionDefinition, A as AnyEventStoreDriver, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-BZi2wy1K.js';
+export { C as CreateEventStoreSchemaOptions, e as EventHandler, f as EventStoreSchemaMigrationOptions, g as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, h as SQLiteProjectionHandler, i as SQLiteProjectionHandlerOptions, j as SQLiteRawBatchSQLProjection, k as SQLiteRawSQLProjection, l as SQLiteReadEvent, m as SQLiteStreamExistsOptions, n as createEventStoreSchema, o as getSQLiteEventStore, p as handleProjections, q as messagesTableSQL, r as processorsTableSQL, s as projectionsTableSQL, t as schemaSQL, u as sqliteProjection, v as sqliteRawBatchSQLProjection, w as sqliteRawSQLProjection, x as streamExists, y as streamsTableSQL } from './sqliteProjection-BZi2wy1K.js';
 import { SQL, SQLExecutor, Dumbo, QueryResultRow } from '@event-driven-io/dumbo';
 import { AnySQLiteConnection } from '@event-driven-io/dumbo/sqlite';
 
@@ -119,6 +120,89 @@ declare const projectionsTable: {
     name: string;
 };
 
+type PongoProjectionHandlerContext = SQLiteProjectionHandlerContext & {
+    pongo: PongoClient;
+};
+type PongoWithNotNullDocumentEvolve<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ((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 SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ((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 SQLiteReadEventMetadata = SQLiteReadEventMetadata> = PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType> | PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+type PongoProjectionOptions<EventType extends Event, EventPayloadType extends Event = EventType> = {
+    name: string;
+    kind?: string;
+    version?: number;
+    handle: (events: ReadEvent<EventType, SQLiteReadEventMetadata>[], context: PongoProjectionHandlerContext) => Promise<void>;
+    canHandle: CanHandle<EventType>;
+    truncate?: TruncateProjection<PongoProjectionHandlerContext>;
+    init?: (context: PongoProjectionHandlerContext) => void | Promise<void>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+};
+declare const pongoProjection: <EventType extends Event, EventPayloadType extends Event = EventType>({ name, kind, version, truncate, handle, canHandle, eventsOptions, }: PongoProjectionOptions<EventType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType, DocumentPayload extends PongoDocument = Document> = {
+    kind?: string;
+    canHandle: CanHandle<EventType>;
+    version?: number;
+    collectionName: string;
+    collectionOptions?: PongoDBCollectionOptions<Document, DocumentPayload>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+    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 SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType>(options: PongoMultiStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType, DocumentPayload extends PongoDocument = Document> = {
+    canHandle: CanHandle<EventType>;
+    getDocumentId?: (event: ReadEvent<EventType>) => string;
+    version?: number;
+    collectionName: string;
+    collectionOptions?: PongoDBCollectionOptions<Document, DocumentPayload>;
+    eventsOptions?: {
+        schema?: EventStoreReadSchemaOptions<EventType, EventPayloadType>;
+    };
+} & ({
+    evolve: PongoWithNullableDocumentEvolve<Document, EventType, EventMetaDataType>;
+} | {
+    evolve: PongoWithNotNullDocumentEvolve<Document, EventType, EventMetaDataType>;
+    initialState: () => Document;
+});
+declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata, EventPayloadType extends Event = EventType>(options: PongoSingleStreamProjectionOptions<Document, EventType, EventMetaDataType, EventPayloadType>) => SQLiteProjectionDefinition<EventType, EventPayloadType>;
+
+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>) => SQLiteProjectionAssert;
+declare const documentsAreTheSame: <Doc extends PongoDocument | WithId<PongoDocument>>(documents: Doc[], options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentsMatchingHaveCount: <Doc extends PongoDocument | WithId<PongoDocument>>(expectedCount: number, options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentMatchingExists: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const documentDoesNotExist: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => SQLiteProjectionAssert;
+declare const expectPongoDocuments: {
+    fromCollection: <Doc extends PongoDocument | WithId<PongoDocument>>(collectionName: string) => {
+        withId: (id: string) => {
+            toBeEqual: (document: Doc) => SQLiteProjectionAssert;
+            toExist: () => SQLiteProjectionAssert;
+            notToExist: () => SQLiteProjectionAssert;
+        };
+        matching: <Doc_1 extends PongoDocument | WithId<PongoDocument>>(filter: PongoFilter<Doc_1>) => {
+            toBeTheSame: (documents: Doc_1[]) => SQLiteProjectionAssert;
+            toHaveCount: (expectedCount: number) => SQLiteProjectionAssert;
+            toExist: () => SQLiteProjectionAssert;
+            notToExist: () => SQLiteProjectionAssert;
+        };
+    };
+};
+
 type SQLiteProjectionSpecEvent<EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = EventType & {
     metadata?: Partial<EventMetaDataType>;
 };
@@ -154,4 +238,4 @@ declare const expectSQL: {
     };
 };
 
-export { type AppendEventResult, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, SQLiteEventStore, type SQLiteProjectionAssert, SQLiteProjectionDefinition, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, SQLiteReadEventMetadata, type StoreProcessorCheckpointResult, appendToStream, assertSQLQueryResultMatches, defaultTag, emmettPrefix, eventInStream, eventsInStream, expectSQL, globalNames, globalTag, messagesTable, migration_0_42_0_FromSubscriptionsToProcessors, migration_0_42_0_SQLs, newEventsInStream, processorsTable, projectionsTable, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schema_0_41_0, schema_0_42_0, storeProcessorCheckpoint, streamsTable, unknownTag };
+export { type AppendEventResult, type PongoAssertOptions, type PongoDocumentEvolve, type PongoMultiStreamProjectionOptions, type PongoProjectionHandlerContext, type PongoProjectionOptions, type PongoSingleStreamProjectionOptions, type PongoWithNotNullDocumentEvolve, type PongoWithNullableDocumentEvolve, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, SQLiteEventStore, type SQLiteProjectionAssert, SQLiteProjectionDefinition, SQLiteProjectionHandlerContext, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, SQLiteReadEventMetadata, type StoreProcessorCheckpointResult, appendToStream, assertSQLQueryResultMatches, defaultTag, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, emmettPrefix, eventInStream, eventsInStream, expectPongoDocuments, expectSQL, globalNames, globalTag, messagesTable, migration_0_42_0_FromSubscriptionsToProcessors, migration_0_42_0_SQLs, newEventsInStream, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, processorsTable, projectionsTable, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schema_0_41_0, schema_0_42_0, storeProcessorCheckpoint, streamsTable, unknownTag };

package/dist/index.js

@@ -1,3 +1,130 @@
+// src/eventStore/projections/pongo/pongoProjections.ts
+import {
+  pongoClient
+} from "@event-driven-io/pongo";
+var pongoProjection = ({
+  name,
+  kind,
+  version,
+  truncate,
+  handle,
+  canHandle,
+  eventsOptions
+}) => sqliteProjection({
+  name,
+  version,
+  kind: kind ?? "emt:projections:postgresql:pongo:generic",
+  canHandle,
+  eventsOptions,
+  handle: async (events, context) => {
+    const { connection } = context;
+    const driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = pongoClient({
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await handle(events, {
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  },
+  truncate: truncate ? async (context) => {
+    const { connection } = context;
+    const driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = pongoClient({
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await truncate({
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  } : void 0
+});
+var pongoMultiStreamProjection = (options) => {
+  const { collectionName, getDocumentId, canHandle } = options;
+  const collectionNameWithVersion = options.version && options.version > 0 ? `${collectionName}_v${options.version}` : collectionName;
+  return pongoProjection({
+    name: collectionNameWithVersion,
+    version: options.version,
+    kind: options.kind ?? "emt:projections:postgresql:pongo:multi_stream",
+    eventsOptions: options.eventsOptions,
+    handle: async (events, { pongo }) => {
+      const collection = pongo.db().collection(
+        collectionNameWithVersion,
+        options.collectionOptions
+      );
+      for (const event of events) {
+        await collection.handle(getDocumentId(event), async (document) => {
+          return "initialState" in options ? await options.evolve(
+            document ?? options.initialState(),
+            event
+          ) : await options.evolve(
+            document,
+            event
+          );
+        });
+      }
+    },
+    canHandle,
+    truncate: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = pongoClient({
+        driver,
+        connectionOptions: { connection }
+      });
+      try {
+        await pongo.db().collection(
+          collectionNameWithVersion,
+          options.collectionOptions
+        ).deleteMany();
+      } finally {
+        await pongo.close();
+      }
+    },
+    init: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = pongoClient({
+        connectionOptions: { connection },
+        driver
+      });
+      try {
+        await pongo.db().collection(
+          collectionNameWithVersion,
+          options.collectionOptions
+        ).schema.migrate();
+      } finally {
+        await pongo.close();
+      }
+    }
+  });
+};
+var pongoSingleStreamProjection = (options) => {
+  return pongoMultiStreamProjection({
+    ...options,
+    kind: "emt:projections:postgresql:pongo:single_stream",
+    getDocumentId: options.getDocumentId ?? ((event) => event.metadata.streamName)
+  });
+};
+
 // ../emmett/dist/chunk-AZDDB5SF.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isString = (val) => typeof val === "string";
@@ -560,6 +687,15 @@ var isSubset = (superObj, subObj) => {
 var assertFails = (message2) => {
   throw new AssertionError(message2 ?? "That should not ever happened, right?");
 };
+var assertDeepEqual = (actual, expected, message2) => {
+  if (!deepEquals(actual, expected))
+    throw new AssertionError(
+      message2 ?? `subObj:
+${JSONParser.stringify(expected)}
+is not equal to
+${JSONParser.stringify(actual)}`
+    );
+};
 function assertTrue(condition, message2) {
   if (condition !== true)
     throw new AssertionError(message2 ?? `Condition is false`);
@@ -581,6 +717,13 @@ function assertNotEqual(obj, other, message2) {
       message2 ?? `Objects are equal: ${JSONParser.stringify(obj)}`
     );
 }
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
+}
+function assertIsNull(result) {
+  assertEqual(result, null);
+}
 var assertThatArray = (array) => {
   return {
     isEmpty: () => assertEqual(
@@ -924,6 +1067,143 @@ var workflowProcessor = (options) => {
   });
 };
 
+// src/eventStore/projections/pongo/pongoProjectionSpec.ts
+import {
+  pongoClient as pongoClient2
+} from "@event-driven-io/pongo";
+var withCollection = async (handle, options) => {
+  const { connection, inDatabase, inCollection } = options;
+  const driver = await pongoDriverRegistry.tryResolve(
+    connection.driverType
+  );
+  const pongo = pongoClient2({
+    connectionOptions: { connection },
+    driver
+  });
+  try {
+    const collection = pongo.db(inDatabase).collection(inCollection);
+    return handle(collection);
+  } finally {
+    await pongo.close();
+  }
+};
+var withoutIdAndVersion = (doc) => {
+  const { _id, _version, ...without } = doc;
+  return without;
+};
+var assertDocumentsEqual = (actual, expected) => {
+  if ("_id" in expected)
+    assertEqual(
+      expected._id,
+      actual._id,
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Document ids are not matching! Expected: ${expected._id}, Actual: ${actual._id}`
+    );
+  return assertDeepEqual(
+    withoutIdAndVersion(actual),
+    withoutIdAndVersion(expected)
+  );
+};
+var documentExists = (document, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNotNull(result);
+    assertDocumentsEqual(result, document);
+  },
+  { ...options, ...assertOptions }
+);
+var documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      documents.length,
+      result.length,
+      "Different Documents Count than expected"
+    );
+    for (let i = 0; i < documents.length; i++) {
+      assertThatArray(result).contains(documents[i]);
+    }
+  },
+  { ...options, ...assertOptions }
+);
+var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      expectedCount,
+      result.length,
+      "Different Documents Count than expected"
+    );
+  },
+  { ...options, ...assertOptions }
+);
+var documentMatchingExists = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertThatArray(result).isNotEmpty();
+  },
+  { ...options, ...assertOptions }
+);
+var documentDoesNotExist = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNull(result);
+  },
+  { ...options, ...assertOptions }
+);
+var expectPongoDocuments = {
+  fromCollection: (collectionName) => {
+    return {
+      withId: (id) => {
+        return {
+          toBeEqual: (document) => documentExists(document, {
+            withId: id,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            withId: id,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            withId: id,
+            inCollection: collectionName
+          })
+        };
+      },
+      matching: (filter) => {
+        return {
+          toBeTheSame: (documents) => documentsAreTheSame(documents, {
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            matchingFilter: filter,
+            inCollection: collectionName
+          })
+        };
+      }
+    };
+  }
+};
+
 // src/eventStore/projections/sqliteProjection.ts
 var handleProjections = async (options) => {
   const {
@@ -2297,9 +2577,15 @@ export {
   assertSQLQueryResultMatches,
   createEventStoreSchema,
   defaultTag2 as defaultTag,
+  documentDoesNotExist,
+  documentExists,
+  documentMatchingExists,
+  documentsAreTheSame,
+  documentsMatchingHaveCount,
   emmettPrefix2 as emmettPrefix,
   eventInStream,
   eventsInStream,
+  expectPongoDocuments,
   expectSQL,
   getSQLiteEventStore,
   globalNames,
@@ -2310,6 +2596,9 @@ export {
   migration_0_42_0_FromSubscriptionsToProcessors,
   migration_0_42_0_SQLs,
   newEventsInStream,
+  pongoMultiStreamProjection,
+  pongoProjection,
+  pongoSingleStreamProjection,
   processorsTable,
   processorsTableSQL,
   projectionsTable,