@event-driven-io/emmett-mongodb 0.23.0-alpha.9 → 0.24.0

package/dist/index.d.ts

@@ -1,18 +1,18 @@
-import { Event, EventMetaDataOf, ProjectionHandler, TypedProjectionDefinition, ReadEvent, CanHandle, ReadEventMetadataWithoutGlobalPosition, ProjectionRegistration, EventStore, Closeable } from '@event-driven-io/emmett';
+import { Event, ProjectionHandler, TypedProjectionDefinition, ReadEvent, CanHandle, ThenThrows, ReadEventMetadataWithoutGlobalPosition, ProjectionRegistration, DefaultEventStoreOptions, EventStore, Closeable } from '@event-driven-io/emmett';
 import { UpdateFilter, Collection, Document, MongoClient, MongoClientOptions, Filter } from 'mongodb';
 
 declare const MongoDBDefaultInlineProjectionName = "_default";
-type MongoDBProjectionInlineHandlerContext<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = {
+type MongoDBProjectionInlineHandlerContext<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = {
     document: MongoDBReadModel | null;
     streamId: string;
     updates: UpdateFilter<EventStream<EventType, EventMetaDataType>>;
     collection: Collection<EventStream<EventType, EventMetaDataType>>;
 };
-type MongoDBInlineProjectionHandler<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, MongoDBProjectionInlineHandlerContext>;
-type MongoDBInlineProjectionDefinition<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = TypedProjectionDefinition<EventType, EventMetaDataType, MongoDBProjectionInlineHandlerContext> & {
+type MongoDBInlineProjectionHandler<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, MongoDBProjectionInlineHandlerContext>;
+type MongoDBInlineProjectionDefinition<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = TypedProjectionDefinition<EventType, EventMetaDataType, MongoDBProjectionInlineHandlerContext> & {
     name: string;
 };
-type InlineProjectionHandlerOptions<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = {
+type InlineProjectionHandlerOptions<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = {
     readModels: Record<string, MongoDBReadModel>;
     events: Array<ReadEvent<EventType, EventMetaDataType>>;
     projections: MongoDBInlineProjectionDefinition<EventType, EventMetaDataType>[];
@@ -21,14 +21,10 @@ type InlineProjectionHandlerOptions<EventType extends Event = Event, EventMetaDa
     updates: UpdateFilter<EventStream<Event>>;
     client: {};
 };
-declare const handleInlineProjections: <EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & Readonly<{
-    eventId: string;
-    streamPosition: bigint;
-    streamName: string;
-}> & object>(options: InlineProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
-type MongoDBWithNotNullDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = ((document: Doc, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc, event: ReadEvent<EventType>) => Promise<Doc | null>);
-type MongoDBWithNullableDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = ((document: Doc | null, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc | null, event: ReadEvent<EventType>) => Promise<Doc | null>);
-type MongoDBInlineProjectionOptions<Doc extends Document, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = {
+declare const handleInlineProjections: <EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata>(options: InlineProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
+type MongoDBWithNotNullDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ((document: Doc, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc, event: ReadEvent<EventType>) => Promise<Doc | null>);
+type MongoDBWithNullableDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ((document: Doc | null, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc | null, event: ReadEvent<EventType>) => Promise<Doc | null>);
+type MongoDBInlineProjectionOptions<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = {
     name?: string;
     schemaVersion?: number;
     canHandle: CanHandle<EventType>;
@@ -38,11 +34,45 @@ type MongoDBInlineProjectionOptions<Doc extends Document, EventType extends Even
     evolve: MongoDBWithNotNullDocumentEvolve<Doc, EventType, EventMetaDataType>;
     initialState: () => Doc;
 });
-declare const mongoDBInlineProjection: <Doc extends Document, EventType extends Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & Readonly<{
-    eventId: string;
-    streamPosition: bigint;
-    streamName: string;
-}> & object>(options: MongoDBInlineProjectionOptions<Doc, EventType, EventMetaDataType>) => MongoDBInlineProjectionDefinition;
+declare const mongoDBInlineProjection: <Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata>(options: MongoDBInlineProjectionOptions<Doc, EventType, EventMetaDataType>) => MongoDBInlineProjectionDefinition;
+
+type MongoDBInlineProjectionSpecGivenEvents<StreamNameType extends StreamName, EventType extends Event> = {
+    streamName: StreamNameType;
+    events: EventType[];
+};
+type MongoDBInlineProjectionAssertOptions<StreamNameType extends StreamName = StreamName> = {
+    streamName: StreamNameType;
+    eventStore: MongoDBEventStore;
+};
+type MongoDBInlineProjectionAssert<StreamNameType extends StreamName = StreamName> = (options: MongoDBInlineProjectionAssertOptions<StreamNameType>) => Promise<void | boolean>;
+type MongoDBInlineProjectionSpecOptions = {
+    projection: MongoDBInlineProjectionDefinition;
+} & MongoDBEventStoreConnectionOptions;
+type MongoDBInlineProjectionSpec<StreamNameType extends StreamName, EventType extends Event> = (givenStream: MongoDBInlineProjectionSpecGivenEvents<StreamNameType, EventType>) => {
+    when: (events: EventType[]) => {
+        then: (assert: MongoDBInlineProjectionAssert, message?: string) => Promise<void>;
+        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+    };
+};
+declare const MongoDBInlineProjectionSpec: {
+    for: <StreamNameType extends StreamName, EventType extends Event>(options: MongoDBInlineProjectionSpecOptions) => MongoDBInlineProjectionSpec<StreamNameType, EventType>;
+};
+declare const eventInStream: <StreamNameType extends StreamName, EventType extends Event>(streamName: StreamNameType, event: EventType) => MongoDBInlineProjectionSpecGivenEvents<StreamNameType, EventType>;
+declare const eventsInStream: <StreamNameType extends StreamName, EventType extends Event>(streamName: StreamNameType, events: EventType[]) => MongoDBInlineProjectionSpecGivenEvents<StreamNameType, EventType>;
+declare const expectInlineReadModel: {
+    toHave: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: Partial<MongoDBReadModel<Doc>> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
+    toDeepEquals: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: MongoDBReadModel<Doc> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
+    toMatch: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(match: (readModel: MongoDBReadModel<Doc> | null) => boolean) => MongoDBInlineProjectionAssert<StreamNameType>;
+    notToExist: <StreamNameType extends StreamName = `${string}:${string}`>() => MongoDBInlineProjectionAssert<StreamNameType>;
+    toExist: () => MongoDBInlineProjectionAssert;
+    withName: (name: string) => {
+        toHave: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: Partial<MongoDBReadModel<Doc>> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
+        toDeepEquals: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(expected: MongoDBReadModel<Doc> | null) => MongoDBInlineProjectionAssert<StreamNameType>;
+        toMatch: <Doc extends Document, StreamNameType extends StreamName = `${string}:${string}`>(match: (readModel: MongoDBReadModel<Doc> | null) => boolean) => MongoDBInlineProjectionAssert<StreamNameType>;
+        notToExist: <StreamNameType extends StreamName = `${string}:${string}`>() => MongoDBInlineProjectionAssert<StreamNameType>;
+        toExist: () => MongoDBInlineProjectionAssert;
+    };
+};
 
 type MongoDBEventStoreCollectionPerStreamTypeStorageOptions = {
     /**
@@ -106,7 +136,7 @@ type MongoDBReadModelMetadata = {
 type MongoDBReadModel<Doc extends Document = Document> = Doc & {
     _metadata: MongoDBReadModelMetadata;
 };
-interface EventStream<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> {
+interface EventStream<EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> {
     streamName: string;
     messages: Array<ReadEvent<EventType, EventMetaDataType>>;
     metadata: {
@@ -187,10 +217,11 @@ type MongoDBEventStoreConnectionStringOptions = {
     connectionString: string;
     clientOptions?: MongoClientOptions;
 };
+type MongoDBEventStoreConnectionOptions = MongoDBEventStoreClientOptions | MongoDBEventStoreConnectionStringOptions;
 type MongoDBEventStoreOptions = {
     projections?: ProjectionRegistration<'inline', MongoDBReadEventMetadata, MongoDBProjectionInlineHandlerContext>[];
     storage?: MongoDBEventStoreStorageOptions;
-} & (MongoDBEventStoreClientOptions | MongoDBEventStoreConnectionStringOptions);
+} & MongoDBEventStoreConnectionOptions & DefaultEventStoreOptions<MongoDBEventStore>;
 type MongoDBEventStore = EventStore<MongoDBReadEventMetadata> & {
     projections: ProjectionQueries<StreamType>;
     collectionFor: <EventType extends Event>(streamType: StreamType) => Promise<Collection<EventStream<EventType>>>;
@@ -226,4 +257,4 @@ declare function toStreamCollectionName<T extends StreamType>(streamType: T): St
  */
 declare function fromStreamCollectionName<T extends StreamType>(streamCollectionName: StreamCollectionName<T>): StreamCollectionNameParts<T>;
 
-export { DefaultMongoDBEventStoreCollectionName, DefaultMongoDBEventStoreStorageOptions, type EventStream, type InlineProjectionHandlerOptions, MongoDBDefaultInlineProjectionName, type MongoDBEventStore, type MongoDBEventStoreCollectionPerStreamTypeStorageOptions, type MongoDBEventStoreCollectionResolution, type MongoDBEventStoreCustomStorageOptions, MongoDBEventStoreDefaultStreamVersion, type MongoDBEventStoreOptions, type MongoDBEventStoreSingleCollectionStorageOptions, type MongoDBEventStoreStorage, type MongoDBEventStoreStorageOptions, type MongoDBInlineProjectionDefinition, type MongoDBInlineProjectionHandler, type MongoDBInlineProjectionOptions, type MongoDBProjectionInlineHandlerContext, type MongoDBReadEvent, type MongoDBReadEventMetadata, type MongoDBReadModel, type MongoDBReadModelMetadata, type MongoDBWithNotNullDocumentEvolve, type MongoDBWithNullableDocumentEvolve, type StreamCollectionName, type StreamCollectionNameParts, type StreamName, type StreamNameParts, type StreamType, fromStreamCollectionName, fromStreamName, getMongoDBEventStore, handleInlineProjections, mongoDBEventStoreStorage, mongoDBInlineProjection, prependMongoFilterWithProjectionPrefix, toStreamCollectionName, toStreamName };
+export { DefaultMongoDBEventStoreCollectionName, DefaultMongoDBEventStoreStorageOptions, type EventStream, type InlineProjectionHandlerOptions, MongoDBDefaultInlineProjectionName, type MongoDBEventStore, type MongoDBEventStoreClientOptions, type MongoDBEventStoreCollectionPerStreamTypeStorageOptions, type MongoDBEventStoreCollectionResolution, type MongoDBEventStoreConnectionOptions, type MongoDBEventStoreConnectionStringOptions, type MongoDBEventStoreCustomStorageOptions, MongoDBEventStoreDefaultStreamVersion, type MongoDBEventStoreOptions, type MongoDBEventStoreSingleCollectionStorageOptions, type MongoDBEventStoreStorage, type MongoDBEventStoreStorageOptions, type MongoDBInlineProjectionAssert, type MongoDBInlineProjectionAssertOptions, type MongoDBInlineProjectionDefinition, type MongoDBInlineProjectionHandler, type MongoDBInlineProjectionOptions, MongoDBInlineProjectionSpec, type MongoDBInlineProjectionSpecGivenEvents, type MongoDBInlineProjectionSpecOptions, type MongoDBProjectionInlineHandlerContext, type MongoDBReadEvent, type MongoDBReadEventMetadata, type MongoDBReadModel, type MongoDBReadModelMetadata, type MongoDBWithNotNullDocumentEvolve, type MongoDBWithNullableDocumentEvolve, type StreamCollectionName, type StreamCollectionNameParts, type StreamName, type StreamNameParts, type StreamType, eventInStream, eventsInStream, expectInlineReadModel, fromStreamCollectionName, fromStreamName, getMongoDBEventStore, handleInlineProjections, mongoDBEventStoreStorage, mongoDBInlineProjection, prependMongoFilterWithProjectionPrefix, toStreamCollectionName, toStreamName };

package/dist/index.js

@@ -1,6 +1,10 @@
-// ../emmett/dist/chunk-AEEEXE2R.js
+// ../emmett/dist/chunk-4E7QLAH5.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isString = (val) => typeof val === "string";
+var isErrorConstructor = (expect) => {
+  return typeof expect === "function" && expect.prototype && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  expect.prototype.constructor === expect;
+};
 var EmmettError = class _EmmettError extends Error {
   errorCode;
   constructor(options) {
@@ -43,6 +47,16 @@ import { TransformStream as TransformStream8 } from "web-streams-polyfill";
 import { TransformStream as TransformStream9 } from "web-streams-polyfill";
 import { TransformStream as TransformStream10 } from "web-streams-polyfill";
 import { TransformStream as TransformStream11 } from "web-streams-polyfill";
+async function tryPublishMessagesAfterCommit(messages, options, context) {
+  if (options?.onAfterCommit === void 0) return false;
+  try {
+    await options?.onAfterCommit(messages, context);
+    return true;
+  } catch (error2) {
+    console.error(`Error in on after commit hook`, error2);
+    return false;
+  }
+}
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -101,6 +115,72 @@ var NotifyAboutNoActiveReadersStream = class extends TransformStream2 {
     }
   }
 };
+var hasDuplicates = (array, predicate) => {
+  const mapped = array.map(predicate);
+  const uniqueValues = new Set(mapped);
+  return uniqueValues.size < mapped.length;
+};
+var getDuplicates = (array, predicate) => {
+  const map2 = /* @__PURE__ */ new Map();
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    const key = predicate(item, i, array);
+    if (!map2.has(key)) {
+      map2.set(key, []);
+    }
+    map2.get(key).push(item);
+  }
+  return Array.from(map2.values()).filter((group) => group.length > 1).flat();
+};
+var merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
+  let wasFound = false;
+  const result = array.map((p) => {
+    if (!where(p)) return p;
+    wasFound = true;
+    return onExisting(p);
+  }).filter((p) => p !== void 0).map((p) => {
+    if (!p) throw Error("That should not happen");
+    return p;
+  });
+  if (!wasFound) {
+    const result2 = onNotFound();
+    if (result2 !== void 0) return [...array, item];
+  }
+  return result;
+};
+var arrayUtils = {
+  merge,
+  hasDuplicates,
+  getDuplicates
+};
+var deepEquals = (left, right) => {
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
+    return left === right;
+  }
+  if (Array.isArray(right)) return false;
+  const keys1 = Object.keys(left);
+  const keys2 = Object.keys(right);
+  if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key)))
+    return false;
+  for (const key in left) {
+    if (left[key] instanceof Function && right[key] instanceof Function)
+      continue;
+    const isEqual = deepEquals(left[key], right[key]);
+    if (!isEqual) {
+      return false;
+    }
+  }
+  return true;
+};
+var isEquatable = (left) => {
+  return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
 var asyncRetry = async (fn, opts) => {
   if (opts === void 0 || opts.retries === 0) return fn();
   return retry(
@@ -117,6 +197,47 @@ var asyncRetry = async (fn, opts) => {
     opts ?? { retries: 0 }
   );
 };
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      options?.map ? options.map(value) : value,
+      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (_, v) => typeof v === "bigint" ? v.toString() : v
+    );
+  },
+  parse: (text, options) => {
+    const parsed = JSON.parse(text, options?.reviver);
+    if (options?.typeCheck && !options?.typeCheck(parsed))
+      throw new ParseError(text);
+    return options?.map ? options.map(parsed) : parsed;
+  }
+};
+var filterProjections = (type, projections2) => {
+  const inlineProjections2 = projections2.filter((projection2) => projection2.type === type).map(({ projection: projection2 }) => projection2);
+  const duplicateRegistrations = arrayUtils.getDuplicates(
+    inlineProjections2,
+    (proj) => proj.name
+  );
+  if (duplicateRegistrations.length > 0) {
+    throw new EmmettError(`You cannot register multiple projections with the same name (or without the name).
+      Ensure that:
+      ${JSONParser.stringify(duplicateRegistrations)}
+      have different names`);
+  }
+  return inlineProjections2;
+};
+var inlineProjections = (definitions) => definitions.map((projection2) => ({ type: "inline", projection: projection2 }));
+var asyncProjections = (definitions) => definitions.map((projection2) => ({ type: "async", projection: projection2 }));
+var projections = {
+  inline: inlineProjections,
+  async: asyncProjections
+};
 var filter = (filter2) => new TransformStream3({
   transform(chunk, controller) {
     if (filter2(chunk)) {
@@ -258,14 +379,41 @@ var streamTransformations = {
   waitAtMost
 };
 var { retry: retry2 } = streamTransformations;
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+var isSubset = (superObj, subObj) => {
+  const sup = superObj;
+  const sub = subObj;
+  assertOk(sup);
+  assertOk(sub);
+  return Object.keys(sub).every((ele) => {
+    if (typeof sub[ele] == "object") {
+      return isSubset(sup[ele], sub[ele]);
+    }
+    return sub[ele] === sup[ele];
+  });
+};
+var assertFails = (message) => {
+  throw new AssertionError(message ?? "That should not ever happened, right?");
+};
+function assertTrue(condition, message) {
+  if (condition !== true)
+    throw new AssertionError(message ?? `Condition is false`);
+}
+function assertOk(obj, message) {
+  if (!obj) throw new AssertionError(message ?? `Condition is not truthy`);
+}
 
 // src/eventStore/mongoDBEventStore.ts
 import {
-  MongoClient
+  MongoClient as MongoClient2
 } from "mongodb";
 import { v4 as uuid4 } from "uuid";
 
-// src/eventStore/projections/index.ts
+// src/eventStore/projections/mongoDBInlineProjection.ts
 var MongoDBDefaultInlineProjectionName = "_default";
 var handleInlineProjections = async (options) => {
   const {
@@ -277,10 +425,10 @@ var handleInlineProjections = async (options) => {
     readModels
   } = options;
   const eventTypes = events.map((e) => e.type);
-  const projections = allProjections.filter(
+  const projections2 = allProjections.filter(
     (p) => p.canHandle.some((type) => eventTypes.includes(type))
   );
-  for (const projection of projections) {
+  for (const projection of projections2) {
     await projection.handle(events, {
       document: readModels[projection.name] ?? null,
       streamId,
@@ -318,6 +466,135 @@ var mongoDBInlineProjection = (options) => {
   };
 };
 
+// src/eventStore/projections/mongoDBInlineProjectionSpec.ts
+import { MongoClient } from "mongodb";
+var MongoDBInlineProjectionSpec = {
+  for: (options) => {
+    {
+      const { projection, ...connectionOptions } = options;
+      return (givenStream) => {
+        const { streamName, events: givenEvents } = givenStream;
+        return {
+          when: (events) => {
+            const allEvents = [...givenEvents, ...events];
+            const run = (eventStore) => eventStore.appendToStream(streamName, allEvents);
+            return {
+              then: async (assert, message) => {
+                const client = "client" in connectionOptions && connectionOptions.client ? connectionOptions.client : new MongoClient(
+                  connectionOptions.connectionString,
+                  connectionOptions.clientOptions
+                );
+                const eventStore = getMongoDBEventStore({
+                  projections: projections.inline([projection]),
+                  client
+                });
+                try {
+                  await run(eventStore);
+                  const succeeded = await assert({ eventStore, streamName });
+                  if (succeeded !== void 0 && succeeded === false)
+                    assertFails(
+                      message ?? "Projection specification didn't match the criteria"
+                    );
+                } finally {
+                  await client.close();
+                }
+              },
+              thenThrows: async (...args) => {
+                const client = "client" in connectionOptions && connectionOptions.client ? connectionOptions.client : new MongoClient(
+                  connectionOptions.connectionString,
+                  connectionOptions.clientOptions
+                );
+                const eventStore = getMongoDBEventStore({
+                  projections: projections.inline([projection]),
+                  client
+                });
+                try {
+                  await run(eventStore);
+                  throw new AssertionError("Handler did not fail as expected");
+                } catch (error) {
+                  if (error instanceof AssertionError) throw error;
+                  if (args.length === 0) return;
+                  if (!isErrorConstructor(args[0])) {
+                    assertTrue(
+                      args[0](error),
+                      `Error didn't match the error condition: ${error?.toString()}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${error?.toString()}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${error?.toString()}`
+                    );
+                  }
+                } finally {
+                  await client.close();
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+var eventInStream = (streamName, event) => ({
+  streamName,
+  events: [event]
+});
+var eventsInStream = (streamName, events) => ({
+  streamName,
+  events
+});
+var expectReadModelToMatch = async (options) => {
+  const { streamName, projectionName, eventStore, match } = options;
+  const readModel = await eventStore.projections.inline.findOne({
+    streamName,
+    projectionName
+  });
+  return match(readModel);
+};
+var expectInlineReadModelWithName = (projectionName) => ({
+  toHave: (expected) => ({ eventStore, streamName }) => expectReadModelToMatch({
+    eventStore,
+    streamName,
+    projectionName,
+    match: (readModel) => isSubset(readModel, expected)
+  }),
+  toDeepEquals: (expected) => ({ eventStore, streamName }) => expectReadModelToMatch({
+    eventStore,
+    streamName,
+    projectionName,
+    match: (readModel) => deepEquals(readModel, expected)
+  }),
+  toMatch: (match) => ({ eventStore, streamName }) => expectReadModelToMatch({
+    eventStore,
+    streamName,
+    projectionName,
+    match
+  }),
+  notToExist: () => ({ eventStore, streamName }) => expectReadModelToMatch({
+    eventStore,
+    streamName,
+    projectionName,
+    match: (readModel) => readModel === null
+  }),
+  toExist: () => ({ eventStore, streamName }) => expectReadModelToMatch({
+    eventStore,
+    streamName,
+    projectionName,
+    match: (readModel) => readModel !== null
+  })
+});
+var expectInlineReadModel = {
+  withName: (name) => expectInlineReadModelWithName(name),
+  ...expectInlineReadModelWithName(MongoDBDefaultInlineProjectionName)
+};
+
 // src/eventStore/storage/mongoDBEventStoreStorage.ts
 var DefaultMongoDBEventStoreStorageOptions = "COLLECTION_PER_STREAM_TYPE";
 var DefaultMongoDBEventStoreCollectionName = "emt:streams";
@@ -393,20 +670,23 @@ var mongoDBEventStoreStorage = (options) => {
 var MongoDBEventStoreDefaultStreamVersion = 0n;
 var MongoDBEventStoreImplementation = class {
   client;
-  shouldManageClientLifetime;
   inlineProjections;
+  shouldManageClientLifetime;
   isClosed = false;
-  projections;
   storage;
+  options;
+  projections;
   constructor(options) {
-    this.client = "client" in options && options.client ? options.client : new MongoClient(options.connectionString, options.clientOptions);
+    this.options = options;
+    this.client = "client" in options && options.client ? options.client : new MongoClient2(options.connectionString, options.clientOptions);
     this.shouldManageClientLifetime = !("client" in options);
     this.storage = mongoDBEventStoreStorage({
       storage: options.storage,
       getConnectedClient: () => this.getConnectedClient()
     });
-    this.inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(
-      ({ projection }) => projection
+    this.inlineProjections = filterProjections(
+      "inline",
+      options.projections ?? []
     );
     this.projections = {
       inline: {
@@ -499,7 +779,7 @@ var MongoDBEventStoreImplementation = class {
         data: event.data,
         metadata: {
           ...metadata,
-          ...event.metadata ?? {}
+          ..."metadata" in event ? event.metadata ?? {} : {}
         }
       };
     });
@@ -542,6 +822,14 @@ var MongoDBEventStoreImplementation = class {
         options?.expectedStreamVersion ?? 0n
       );
     }
+    await tryPublishMessagesAfterCommit(
+      // @ts-expect-error Issues with `globalPosition` not being present causing the type for metadata to expect `never`
+      eventsToAppend,
+      this.options.hooks
+      // {
+      // TODO: same context as InlineProjectionHandlerContext for mongodb?
+      // },
+    );
     return {
       nextExpectedStreamVersion: currentStreamVersion + BigInt(eventsToAppend.length),
       createdNewStream: currentStreamVersion === MongoDBEventStoreDefaultStreamVersion
@@ -757,6 +1045,10 @@ export {
   DefaultMongoDBEventStoreStorageOptions,
   MongoDBDefaultInlineProjectionName,
   MongoDBEventStoreDefaultStreamVersion,
+  MongoDBInlineProjectionSpec,
+  eventInStream,
+  eventsInStream,
+  expectInlineReadModel,
   fromStreamCollectionName,
   fromStreamName,
   getMongoDBEventStore,