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

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
@@ -314,17 +316,29 @@ var mongoDBInlineProjection = (options) => {
 
 // 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 }
     };
@@ -338,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) {
@@ -358,7 +372,7 @@ var MongoDBEventStore = class {
       MongoDBEventStoreDefaultStreamVersion
     );
     return {
-      events: stream.events,
+      events: stream.messages,
       currentStreamVersion: stream.metadata.streamPosition,
       streamExists: true
     };
@@ -373,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,
@@ -406,10 +422,9 @@ var MongoDBEventStore = class {
         }
       };
     });
-    const { streamId, streamType } = fromStreamName(streamName);
     const now = /* @__PURE__ */ new Date();
     const updates = {
-      $push: { events: { $each: eventsToAppend } },
+      $push: { messages: { $each: eventsToAppend } },
       $set: { "metadata.updatedAt": now },
       $inc: { "metadata.streamPosition": BigInt(events.length) },
       $setOnInsert: {
@@ -423,12 +438,12 @@ var MongoDBEventStore = class {
         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(
@@ -449,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") {
@@ -476,13 +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