@event-driven-io/emmett-mongodb 0.21.1 → 0.22.0-alpha.2

package/dist/index.d.ts

@@ -1,47 +1,59 @@
-import { Event, ReadEvent, ReadEventMetadata, EventStore, ReadStreamOptions, ReadStreamResult, AggregateStreamOptions, AggregateStreamResult, AppendToStreamOptions, AppendToStreamResult } from '@event-driven-io/emmett';
-import { Collection } from 'mongodb';
+import { Event, EventMetaDataOf, ReadEvent, ReadEventMetadataWithoutGlobalPosition, ProjectionRegistration, EventStore, ReadStreamOptions, ReadStreamResult, AggregateStreamOptions, AggregateStreamResult, AppendToStreamOptions, AppendToStreamResult } from '@event-driven-io/emmett';
+import { UpdateFilter, Collection, Document } from 'mongodb';
 
-declare const MongoDBEventStoreDefaultStreamVersion = 0;
+type MongoDBProjectionInlineHandlerContext<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = {
+    document: MongoDBReadModel | null;
+    updates: UpdateFilter<EventStream<EventType, EventMetaDataType>>;
+    collection: Collection<EventStream<EventType, EventMetaDataType>>;
+};
+
+declare const MongoDBEventStoreDefaultStreamVersion = 0n;
 type StreamType = string;
 type StreamName<T extends StreamType = StreamType> = `${T}:${string}`;
 type StreamNameParts<T extends StreamType = StreamType> = {
     streamType: T;
     streamId: string;
 };
-type StreamToProject<EventType extends Event> = {
-    streamName: StreamName;
-    streamType: StreamType;
-    streamId: string;
-    streamVersion: number;
-    events: ReadEvent<EventType, ReadEventMetadata>[];
+type MongoDBReadModelMetadata = {
+    name: string;
+    schemaVersion: number;
+    streamPosition: bigint;
 };
-type Projection<EventType extends Event> = (stream: StreamToProject<EventType>) => void | Promise<void>;
-interface EventStream<EventType extends Event = Event> {
+type MongoDBReadModel<Doc extends Document = Document> = Doc & {
+    _metadata: MongoDBReadModelMetadata;
+};
+interface EventStream<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> {
     streamName: string;
-    events: Array<ReadEvent<EventType, ReadEventMetadata>>;
-    createdAt: Date;
-    updatedAt: Date;
+    events: Array<ReadEvent<EventType, EventMetaDataType>>;
+    metadata: {
+        streamId: string;
+        streamType: StreamType;
+        streamPosition: bigint;
+        createdAt: Date;
+        updatedAt: Date;
+    };
+    projections: Record<string, MongoDBReadModel>;
 }
-type EventStreamEvent<EventType extends Event = Event> = EventStream<EventType>['events'][number];
 interface MongoDBConnectionOptions {
     connectionString: string;
     database: string;
     collection?: string;
 }
-declare class MongoDBEventStore implements EventStore<number> {
+type MongoDBReadEventMetadata = ReadEventMetadataWithoutGlobalPosition<bigint>;
+type MongoDBReadEvent<EventType extends Event = Event> = ReadEvent<EventType, MongoDBReadEventMetadata>;
+type MongoDBEventStoreOptions = {
+    collection: Collection<EventStream>;
+    projections?: ProjectionRegistration<'inline', MongoDBReadEventMetadata, MongoDBProjectionInlineHandlerContext>[];
+};
+declare class MongoDBEventStore implements EventStore<MongoDBReadEventMetadata> {
     private readonly collection;
-    constructor(collection: typeof this.collection);
-    readStream<EventType extends Event>(streamName: StreamName, options?: ReadStreamOptions<number>): Promise<Exclude<ReadStreamResult<EventType, number>, null>>;
-    aggregateStream<State, EventType extends Event>(streamName: StreamName, options: AggregateStreamOptions<State, EventType, number>): Promise<AggregateStreamResult<State, number>>;
-    appendToStream<EventType extends Event>(streamName: StreamName, events: EventType[], options?: AppendToStreamOptions<number> & {
-        /**
-         * These will be ran after a the events have been successfully appended to
-         * the stream. `appendToStream` will return after every projection is completed.
-         */
-        projections?: Array<Projection<EventType>>;
-    }): Promise<AppendToStreamResult<number>>;
+    private readonly inlineProjections;
+    constructor(options: MongoDBEventStoreOptions);
+    readStream<EventType extends Event>(streamName: StreamName, options?: ReadStreamOptions): Promise<Exclude<ReadStreamResult<EventType, MongoDBReadEventMetadata>, null>>;
+    aggregateStream<State, EventType extends Event>(streamName: StreamName, options: AggregateStreamOptions<State, EventType, MongoDBReadEventMetadata>): Promise<AggregateStreamResult<State>>;
+    appendToStream<EventType extends Event>(streamName: StreamName, events: EventType[], options?: AppendToStreamOptions): Promise<AppendToStreamResult>;
 }
-declare const getMongoDBEventStore: (collection: Collection<EventStream>) => MongoDBEventStore;
+declare const getMongoDBEventStore: (options: ConstructorParameters<typeof MongoDBEventStore>[0]) => MongoDBEventStore;
 /**
  * Accepts a `streamType` (the type/category of the event stream) and an `streamId`
  * (the individual entity/object or aggregate ID) and combines them to a singular
@@ -54,4 +66,4 @@ declare function toStreamName<T extends StreamType>(streamType: T, streamId: str
  */
 declare function fromStreamName<T extends StreamType>(streamName: StreamName<T>): StreamNameParts<T>;
 
-export { type EventStream, type EventStreamEvent, type MongoDBConnectionOptions, MongoDBEventStore, MongoDBEventStoreDefaultStreamVersion, type Projection, type StreamName, type StreamNameParts, type StreamToProject, type StreamType, fromStreamName, getMongoDBEventStore, toStreamName };
+export { type EventStream, type MongoDBConnectionOptions, MongoDBEventStore, MongoDBEventStoreDefaultStreamVersion, type MongoDBEventStoreOptions, type MongoDBReadEvent, type MongoDBReadEventMetadata, type MongoDBReadModel, type MongoDBReadModelMetadata, type StreamName, type StreamNameParts, type StreamType, fromStreamName, getMongoDBEventStore, toStreamName };

package/dist/index.js

@@ -262,16 +262,61 @@ var { retry: retry2 } = streamTransformations;
 // src/eventStore/mongoDBEventStore.ts
 import "mongodb";
 import { v4 as uuid4 } from "uuid";
-var MongoDBEventStoreDefaultStreamVersion = 0;
+
+// src/eventStore/projections/index.ts
+var handleInlineProjections = async (options) => {
+  const {
+    events,
+    projections: allProjections,
+    updates: update,
+    collection,
+    readModels
+  } = options;
+  const eventTypes = events.map((e) => e.type);
+  const projections = allProjections.filter(
+    (p) => p.canHandle.some((type) => eventTypes.includes(type))
+  );
+  for (const projection of projections) {
+    await projection.handle(events, {
+      document: readModels[projection.name] ?? null,
+      collection,
+      updates: update
+    });
+  }
+};
+
+// src/eventStore/mongoDBEventStore.ts
+var MongoDBEventStoreDefaultStreamVersion = 0n;
 var MongoDBEventStore = class {
   collection;
-  constructor(collection) {
-    this.collection = collection;
+  inlineProjections;
+  constructor(options) {
+    this.collection = options.collection;
+    this.inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(
+      ({ projection }) => projection
+    );
   }
   async readStream(streamName, options) {
     const expectedStreamVersion = options?.expectedStreamVersion;
-    const stream = await this.collection.findOne({
+    const filter2 = {
       streamName: { $eq: streamName }
+    };
+    const eventsSliceArr = [];
+    if (options && "from" in options) {
+      eventsSliceArr.push(Number(options.from));
+    } else {
+      eventsSliceArr.push(0);
+    }
+    if (options && "to" in options) {
+      eventsSliceArr.push(Number(options.to));
+    }
+    const eventsSlice = eventsSliceArr.length > 1 ? { $slice: eventsSliceArr } : 1;
+    const stream = await this.collection.findOne(filter2, {
+      useBigInt64: true,
+      projection: {
+        metadata: 1,
+        events: eventsSlice
+      }
     });
     if (!stream) {
       return {
@@ -281,13 +326,13 @@ var MongoDBEventStore = class {
       };
     }
     assertExpectedVersionMatchesCurrent(
-      stream.events.length,
+      stream.metadata.streamPosition,
       expectedStreamVersion,
       MongoDBEventStoreDefaultStreamVersion
     );
     return {
-      events: stream.events.slice(0, maxEventIndex(expectedStreamVersion)),
-      currentStreamVersion: stream.events.length,
+      events: stream.events,
+      currentStreamVersion: stream.metadata.streamPosition,
       streamExists: true
     };
   }
@@ -301,100 +346,91 @@ var MongoDBEventStore = class {
     };
   }
   async appendToStream(streamName, events, options) {
-    let stream = await this.collection.findOne({
-      streamName: { $eq: streamName }
-    });
-    let currentStreamPosition = stream?.events.length ?? 0;
-    let createdNewStream = false;
-    if (!stream) {
-      const now = /* @__PURE__ */ new Date();
-      const result = await this.collection.insertOne({
+    const expectedStreamVersion = options?.expectedStreamVersion;
+    const stream = await this.collection.findOne(
+      { streamName: { $eq: streamName } },
+      {
+        useBigInt64: true,
+        projection: {
+          "metadata.streamPosition": 1,
+          projections: 1
+        }
+      }
+    );
+    const currentStreamVersion = stream?.metadata.streamPosition ?? MongoDBEventStoreDefaultStreamVersion;
+    assertExpectedVersionMatchesCurrent(
+      currentStreamVersion,
+      expectedStreamVersion,
+      MongoDBEventStoreDefaultStreamVersion
+    );
+    let streamOffset = currentStreamVersion;
+    const eventsToAppend = events.map((event) => {
+      const metadata = {
+        eventId: uuid4(),
         streamName,
-        events: [],
-        createdAt: now,
-        updatedAt: now
-      });
-      stream = await this.collection.findOne({
-        _id: result.insertedId
-      });
-      createdNewStream = true;
-    }
-    const eventCreateInputs = [];
-    for (const event of events) {
-      currentStreamPosition++;
-      eventCreateInputs.push({
+        streamPosition: ++streamOffset
+      };
+      return {
         type: event.type,
         data: event.data,
         metadata: {
-          now: /* @__PURE__ */ new Date(),
-          eventId: uuid4(),
-          streamName,
-          streamPosition: BigInt(currentStreamPosition),
+          ...metadata,
           ...event.metadata ?? {}
         }
+      };
+    });
+    const updates = {
+      $push: { events: { $each: eventsToAppend } },
+      $set: { "metadata.updatedAt": /* @__PURE__ */ new Date() },
+      $inc: { "metadata.streamPosition": BigInt(events.length) }
+    };
+    if (this.inlineProjections) {
+      await handleInlineProjections({
+        readModels: stream?.projections ?? {},
+        events: eventsToAppend,
+        projections: this.inlineProjections,
+        collection: this.collection,
+        updates,
+        client: {}
       });
     }
-    if (!stream) throw new Error("Failed to create stream");
-    assertExpectedVersionMatchesCurrent(
-      stream.events.length,
-      options?.expectedStreamVersion,
-      MongoDBEventStoreDefaultStreamVersion
-    );
-    const updatedStream = await this.collection.findOneAndUpdate(
+    const updatedStream = await this.collection.updateOne(
       {
         streamName: { $eq: streamName },
-        events: { $size: stream.events.length }
-      },
-      {
-        $push: { events: { $each: eventCreateInputs } },
-        $set: { updatedAt: /* @__PURE__ */ new Date() }
+        "metadata.streamPosition": toExpectedVersion(
+          options?.expectedStreamVersion
+        )
       },
-      { returnDocument: "after" }
+      updates,
+      { useBigInt64: true, upsert: true }
     );
     if (!updatedStream) {
-      const currentStream = await this.collection.findOne({
-        streamName: { $eq: streamName }
-      });
       throw new ExpectedVersionConflictError(
-        currentStream?.events.length ?? -1,
-        stream.events.length
+        currentStreamVersion,
+        options?.expectedStreamVersion ?? 0n
       );
     }
-    const { streamType, streamId } = fromStreamName(streamName);
-    await executeProjections(
-      {
-        streamName,
-        streamType,
-        streamId,
-        streamVersion: updatedStream.events.length,
-        events: updatedStream.events
-      },
-      options?.projections
-    );
     return {
-      nextExpectedStreamVersion: updatedStream.events.length,
-      createdNewStream
+      nextExpectedStreamVersion: currentStreamVersion + BigInt(eventsToAppend.length),
+      createdNewStream: currentStreamVersion === MongoDBEventStoreDefaultStreamVersion
     };
   }
 };
-var getMongoDBEventStore = (collection) => {
-  const eventStore = new MongoDBEventStore(collection);
+var getMongoDBEventStore = (options) => {
+  const eventStore = new MongoDBEventStore(options);
   return eventStore;
 };
-function executeProjections(params, projections) {
-  return Promise.all((projections ?? []).map((project) => project(params)));
-}
-function maxEventIndex(expectedStreamVersion) {
+function toExpectedVersion(expectedStreamVersion) {
   if (!expectedStreamVersion) return void 0;
-  if (typeof expectedStreamVersion === "number") {
-    return expectedStreamVersion;
-  }
-  switch (expectedStreamVersion) {
-    case STREAM_DOES_NOT_EXIST:
-      return 0;
-    default:
-      return void 0;
+  if (typeof expectedStreamVersion === "string") {
+    switch (expectedStreamVersion) {
+      case STREAM_DOES_NOT_EXIST:
+        return BigInt(0);
+      default:
+        return void 0;
+    }
   }
+  return expectedStreamVersion;
 }
 function toStreamName(streamType, streamId) {
   return `${streamType}:${streamId}`;