@event-driven-io/emmett-mongodb 0.22.0 → 0.23.0-alpha.1

package/dist/index.d.ts

@@ -1,11 +1,45 @@
-import { Event, EventMetaDataOf, ReadEvent, ReadEventMetadataWithoutGlobalPosition, ProjectionRegistration, EventStore, ReadStreamOptions, ReadStreamResult, AggregateStreamOptions, AggregateStreamResult, AppendToStreamOptions, AppendToStreamResult } from '@event-driven-io/emmett';
-import { UpdateFilter, Collection, Document } from 'mongodb';
+import { Event, EventMetaDataOf, ProjectionHandler, TypedProjectionDefinition, ReadEvent, CanHandle, ReadEventMetadataWithoutGlobalPosition, ProjectionRegistration, EventStore } from '@event-driven-io/emmett';
+import { UpdateFilter, Collection, Document, MongoClient, MongoClientOptions } from 'mongodb';
 
 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>>;
 };
+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> & {
+    name: string;
+};
+type InlineProjectionHandlerOptions<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> = {
+    readModels: Record<string, MongoDBReadModel>;
+    events: Array<ReadEvent<EventType, EventMetaDataType>>;
+    projections: MongoDBInlineProjectionDefinition<EventType, EventMetaDataType>[];
+    collection: Collection<EventStream>;
+    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> = {
+    name?: string;
+    schemaVersion?: number;
+    canHandle: CanHandle<EventType>;
+} & ({
+    evolve: MongoDBWithNullableDocumentEvolve<Doc, EventType, EventMetaDataType>;
+} | {
+    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 MongoDBEventStoreDefaultStreamVersion = 0n;
 type StreamType = string;
@@ -14,6 +48,10 @@ type StreamNameParts<T extends StreamType = StreamType> = {
     streamType: T;
     streamId: string;
 };
+type StreamCollectionName<T extends StreamType = StreamType> = `emt:${T}`;
+type StreamCollectionNameParts<T extends StreamType = StreamType> = {
+    streamType: T;
+};
 type MongoDBReadModelMetadata = {
     name: string;
     schemaVersion: number;
@@ -24,7 +62,7 @@ type MongoDBReadModel<Doc extends Document = Document> = Doc & {
 };
 interface EventStream<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & MongoDBReadEventMetadata = EventMetaDataOf<EventType> & MongoDBReadEventMetadata> {
     streamName: string;
-    events: Array<ReadEvent<EventType, EventMetaDataType>>;
+    messages: Array<ReadEvent<EventType, EventMetaDataType>>;
     metadata: {
         streamId: string;
         streamType: StreamType;
@@ -34,26 +72,22 @@ interface EventStream<EventType extends Event = Event, EventMetaDataType extends
     };
     projections: Record<string, MongoDBReadModel>;
 }
-interface MongoDBConnectionOptions {
-    connectionString: string;
-    database: string;
-    collection?: string;
-}
 type MongoDBReadEventMetadata = ReadEventMetadataWithoutGlobalPosition<bigint>;
 type MongoDBReadEvent<EventType extends Event = Event> = ReadEvent<EventType, MongoDBReadEventMetadata>;
 type MongoDBEventStoreOptions = {
-    collection: Collection<EventStream>;
+    database?: string;
+    collection?: string;
     projections?: ProjectionRegistration<'inline', MongoDBReadEventMetadata, MongoDBProjectionInlineHandlerContext>[];
+} & ({
+    client: MongoClient;
+} | {
+    connectionString: string;
+    clientOptions?: MongoClientOptions;
+});
+type MongoDBEventStore = EventStore<MongoDBReadEventMetadata> & {
+    close: () => Promise<void>;
 };
-declare class MongoDBEventStore implements EventStore<MongoDBReadEventMetadata> {
-    private readonly collection;
-    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: (options: ConstructorParameters<typeof MongoDBEventStore>[0]) => MongoDBEventStore;
+declare const getMongoDBEventStore: (options: MongoDBEventStoreOptions) => 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
@@ -65,5 +99,14 @@ declare function toStreamName<T extends StreamType>(streamType: T, streamId: str
  * `streamType` and `streamId`.
  */
 declare function fromStreamName<T extends StreamType>(streamName: StreamName<T>): StreamNameParts<T>;
+/**
+ * Accepts a `streamType` (the type/category of the event stream)
+ * and combines them to a `collectionName` which can be used in `EventStore`.
+ */
+declare function toStreamCollectionName<T extends StreamType>(streamType: T): StreamCollectionName<T>;
+/**
+ * Accepts a fully formatted `streamCollectionName` and returns the parsed `streamType`.
+ */
+declare function fromStreamCollectionName<T extends StreamType>(streamCollectionName: StreamCollectionName<T>): StreamCollectionNameParts<T>;
 
-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 };
+export { type EventStream, type InlineProjectionHandlerOptions, type MongoDBEventStore, MongoDBEventStoreDefaultStreamVersion, type MongoDBEventStoreOptions, 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, mongoDBInlineProjection, toStreamCollectionName, toStreamName };

package/dist/index.js

@@ -260,7 +260,9 @@ var streamTransformations = {
 var { retry: retry2 } = streamTransformations;
 
 // src/eventStore/mongoDBEventStore.ts
-import "mongodb";
+import {
+  MongoClient
+} from "mongodb";
 import { v4 as uuid4 } from "uuid";
 
 // src/eventStore/projections/index.ts
@@ -284,20 +286,59 @@ var handleInlineProjections = async (options) => {
     });
   }
 };
+var mongoDBInlineProjection = (options) => {
+  const projectionName = options.name ?? "_default";
+  const schemaVersion = options.schemaVersion ?? 1;
+  return {
+    name: projectionName,
+    canHandle: options.canHandle,
+    handle: async (events, { document, updates }) => {
+      if (events.length === 0) return;
+      let state = "initialState" in options ? document ?? options.initialState() : document;
+      for (const event of events) {
+        state = await options.evolve(
+          state,
+          event
+        );
+      }
+      const metadata = {
+        name: projectionName,
+        schemaVersion,
+        streamPosition: events[events.length - 1].metadata.streamPosition
+      };
+      updates.$set[`projections.${options.name}`] = state !== null ? {
+        ...state,
+        _metadata: metadata
+      } : null;
+    }
+  };
+};
 
 // src/eventStore/mongoDBEventStore.ts
 var MongoDBEventStoreDefaultStreamVersion = 0n;
-var MongoDBEventStore = class {
-  collection;
+var MongoDBEventStoreImplementation = class {
+  client;
+  defaultOptions;
+  shouldManageClientLifetime;
+  db;
+  streamCollections = /* @__PURE__ */ new Map();
   inlineProjections;
+  isClosed = false;
   constructor(options) {
-    this.collection = options.collection;
+    this.client = "client" in options ? options.client : new MongoClient(options.connectionString, options.clientOptions);
+    this.shouldManageClientLifetime = !("client" in options);
+    this.defaultOptions = {
+      database: options.database,
+      collection: options.collection
+    };
     this.inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(
       ({ projection }) => projection
     );
   }
   async readStream(streamName, options) {
+    const { streamType } = fromStreamName(streamName);
     const expectedStreamVersion = options?.expectedStreamVersion;
+    const collection = await this.collectionFor(streamType);
     const filter2 = {
       streamName: { $eq: streamName }
     };
@@ -311,11 +352,11 @@ var MongoDBEventStore = class {
       eventsSliceArr.push(Number(options.to));
     }
     const eventsSlice = eventsSliceArr.length > 1 ? { $slice: eventsSliceArr } : 1;
-    const stream = await this.collection.findOne(filter2, {
+    const stream = await collection.findOne(filter2, {
       useBigInt64: true,
       projection: {
         metadata: 1,
-        events: eventsSlice
+        messages: eventsSlice
       }
     });
     if (!stream) {
@@ -331,7 +372,7 @@ var MongoDBEventStore = class {
       MongoDBEventStoreDefaultStreamVersion
     );
     return {
-      events: stream.events,
+      events: stream.messages,
       currentStreamVersion: stream.metadata.streamPosition,
       streamExists: true
     };
@@ -346,8 +387,10 @@ var MongoDBEventStore = class {
     };
   }
   async appendToStream(streamName, events, options) {
+    const { streamId, streamType } = fromStreamName(streamName);
     const expectedStreamVersion = options?.expectedStreamVersion;
-    const stream = await this.collection.findOne(
+    const collection = await this.collectionFor(streamType);
+    const stream = await collection.findOne(
       { streamName: { $eq: streamName } },
       {
         useBigInt64: true,
@@ -379,22 +422,28 @@ var MongoDBEventStore = class {
         }
       };
     });
+    const now = /* @__PURE__ */ new Date();
     const updates = {
-      $push: { events: { $each: eventsToAppend } },
-      $set: { "metadata.updatedAt": /* @__PURE__ */ new Date() },
-      $inc: { "metadata.streamPosition": BigInt(events.length) }
+      $push: { messages: { $each: eventsToAppend } },
+      $set: { "metadata.updatedAt": now },
+      $inc: { "metadata.streamPosition": BigInt(events.length) },
+      $setOnInsert: {
+        "metadata.streamId": streamId,
+        "metadata.streamType": streamType,
+        "metadata.createdAt": now
+      }
     };
     if (this.inlineProjections) {
       await handleInlineProjections({
         readModels: stream?.projections ?? {},
         events: eventsToAppend,
         projections: this.inlineProjections,
-        collection: this.collection,
+        collection,
         updates,
         client: {}
       });
     }
-    const updatedStream = await this.collection.updateOne(
+    const updatedStream = await collection.updateOne(
       {
         streamName: { $eq: streamName },
         "metadata.streamPosition": toExpectedVersion(
@@ -415,11 +464,33 @@ var MongoDBEventStore = class {
       createdNewStream: currentStreamVersion === MongoDBEventStoreDefaultStreamVersion
     };
   }
+  close() {
+    if (this.isClosed) return Promise.resolve();
+    this.isClosed = true;
+    if (!this.shouldManageClientLifetime) return Promise.resolve();
+    return this.client.close();
+  }
+  getDB = async () => {
+    if (!this.db) {
+      if (!this.isClosed) await this.client.connect();
+      this.db = this.client.db(this.defaultOptions.database);
+    }
+    return this.db;
+  };
+  collectionFor = async (streamType) => {
+    const collectionName = this.defaultOptions?.collection ?? toStreamCollectionName(streamType);
+    let collection = this.streamCollections.get(collectionName);
+    if (collection) return collection;
+    const db = await this.getDB();
+    collection = db.collection(collectionName);
+    this.streamCollections.set(
+      collectionName,
+      collection
+    );
+    return collection;
+  };
 };
-var getMongoDBEventStore = (options) => {
-  const eventStore = new MongoDBEventStore(options);
-  return eventStore;
-};
+var getMongoDBEventStore = (options) => new MongoDBEventStoreImplementation(options);
 function toExpectedVersion(expectedStreamVersion) {
   if (!expectedStreamVersion) return void 0;
   if (typeof expectedStreamVersion === "string") {
@@ -442,11 +513,23 @@ function fromStreamName(streamName) {
     streamId: parts[1]
   };
 }
+function toStreamCollectionName(streamType) {
+  return `emt:${streamType}`;
+}
+function fromStreamCollectionName(streamCollectionName) {
+  const parts = streamCollectionName.split(":");
+  return {
+    streamType: parts[1]
+  };
+}
 export {
-  MongoDBEventStore,
   MongoDBEventStoreDefaultStreamVersion,
+  fromStreamCollectionName,
   fromStreamName,
   getMongoDBEventStore,
+  handleInlineProjections,
+  mongoDBInlineProjection,
+  toStreamCollectionName,
   toStreamName
 };
 //# sourceMappingURL=index.js.map