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

package/dist/index.cjs

@@ -1,6 +1,10 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;// ../emmett/dist/chunk-AEEEXE2R.js
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;// ../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 {
   
   constructor(options) {
@@ -15,7 +19,7 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
   constructor(current, expected, message) {
     super({
       errorCode: 412,
-      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _ => _.toString, 'call', _2 => _2()])}`))
+      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))
     });
     this.current = current;
     this.expected = expected;
@@ -59,7 +63,7 @@ var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) =>
 };
 var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
   constructor(current, expected) {
-    super(_optionalChain([current, 'optionalAccess', _3 => _3.toString, 'call', _4 => _4()]), _optionalChain([expected, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6()]));
+    super(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
@@ -73,9 +77,9 @@ var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfi
       }
     });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
     this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.streamId]), () => ( _uuid.v4.call(void 0, )));
     this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.intervalCheckInMs]), () => ( 20)));
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => ( 20)));
   }
   __init() {this.checkInterval = null}
   
@@ -101,6 +105,72 @@ var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfi
     }
   }
 }, _class);
+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 _asyncretry2.default.call(void 0, 
@@ -108,7 +178,7 @@ var asyncRetry = async (fn, opts) => {
       try {
         return await fn();
       } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _9 => _9.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+        if (_optionalChain([opts, 'optionalAccess', _10 => _10.shouldRetryError]) && !opts.shouldRetryError(error2)) {
           bail(error2);
         }
         throw error2;
@@ -117,6 +187,47 @@ var asyncRetry = async (fn, opts) => {
     _nullishCoalesce(opts, () => ( { retries: 0 }))
   );
 };
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      _optionalChain([options, 'optionalAccess', _11 => _11.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, _optionalChain([options, 'optionalAccess', _12 => _12.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck]) && !_optionalChain([options, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(parsed)]))
+      throw new ParseError(text);
+    return _optionalChain([options, 'optionalAccess', _16 => _16.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 (0, _webstreamspolyfill.TransformStream)({
   transform(chunk, controller) {
     if (filter2(chunk)) {
@@ -258,6 +369,33 @@ 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(_nullishCoalesce(message, () => ( "That should not ever happened, right?")));
+};
+function assertTrue(condition, message) {
+  if (condition !== true)
+    throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is false`)));
+}
+function assertOk(obj, message) {
+  if (!obj) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is not truthy`)));
+}
 
 // src/eventStore/mongoDBEventStore.ts
 
@@ -265,7 +403,7 @@ var { retry: retry2 } = streamTransformations;
 var _mongodb = require('mongodb');
 
 
-// src/eventStore/projections/index.ts
+// src/eventStore/projections/mongoDBInlineProjection.ts
 var MongoDBDefaultInlineProjectionName = "_default";
 var handleInlineProjections = async (options) => {
   const {
@@ -277,10 +415,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: _nullishCoalesce(readModels[projection.name], () => ( null)),
       streamId,
@@ -318,6 +456,135 @@ var mongoDBInlineProjection = (options) => {
   };
 };
 
+// src/eventStore/projections/mongoDBInlineProjectionSpec.ts
+
+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 (0, _mongodb.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(
+                      _nullishCoalesce(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 (0, _mongodb.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: ${_optionalChain([error, 'optionalAccess', _17 => _17.toString, 'call', _18 => _18()])}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _19 => _19.toString, 'call', _20 => _20()])}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _21 => _21.toString, 'call', _22 => _22()])}`
+                    );
+                  }
+                } 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";
@@ -405,8 +672,9 @@ var MongoDBEventStoreImplementation = (_class4 = class {
       storage: options.storage,
       getConnectedClient: () => this.getConnectedClient()
     });
-    this.inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(
-      ({ projection }) => projection
+    this.inlineProjections = filterProjections(
+      "inline",
+      _nullishCoalesce(options.projections, () => ( []))
     );
     this.projections = {
       inline: {
@@ -418,7 +686,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   }
   async readStream(streamName, options) {
     const { streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _10 => _10.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _23 => _23.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const filter2 = {
       streamName: { $eq: streamName }
@@ -459,7 +727,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     };
   }
   async aggregateStream(streamName, options) {
-    const stream = await this.readStream(streamName, _optionalChain([options, 'optionalAccess', _11 => _11.read]));
+    const stream = await this.readStream(streamName, _optionalChain([options, 'optionalAccess', _24 => _24.read]));
     const state = stream.events.reduce(options.evolve, options.initialState());
     return {
       state,
@@ -469,7 +737,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   }
   async appendToStream(streamName, events, options) {
     const { streamId, streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _12 => _12.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _25 => _25.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const stream = await collection.findOne(
       { streamName: { $eq: streamName } },
@@ -481,7 +749,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         }
       }
     );
-    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _13 => _13.metadata, 'access', _14 => _14.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
+    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _26 => _26.metadata, 'access', _27 => _27.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
     assertExpectedVersionMatchesCurrent(
       currentStreamVersion,
       expectedStreamVersion,
@@ -499,7 +767,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         data: event.data,
         metadata: {
           ...metadata,
-          ..._nullishCoalesce(event.metadata, () => ( {}))
+          ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
         }
       };
     });
@@ -519,7 +787,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     };
     if (this.inlineProjections) {
       await handleInlineProjections({
-        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _15 => _15.projections]), () => ( {})),
+        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _28 => _28.projections]), () => ( {})),
         streamId,
         events: eventsToAppend,
         projections: this.inlineProjections,
@@ -539,7 +807,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     if (!updatedStream) {
       throw new ExpectedVersionConflictError(
         currentStreamVersion,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.expectedStreamVersion]), () => ( 0n))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.expectedStreamVersion]), () => ( 0n))
       );
     }
     return {
@@ -583,7 +851,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _17 => _17.projections, 'optionalAccess', _18 => _18[projectionName]]), () => ( null));
+    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _30 => _30.projections, 'optionalAccess', _31 => _31[projectionName]]), () => ( null));
   }
   async findInlineProjection(streamFilter, projectionQuery, queryOptions) {
     const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
@@ -608,13 +876,13 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    if (_optionalChain([queryOptions, 'optionalAccess', _19 => _19.skip])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _32 => _32.skip])) {
       query = query.skip(queryOptions.skip);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _20 => _20.limit])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _33 => _33.limit])) {
       query = query.limit(queryOptions.limit);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _21 => _21.sort])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _34 => _34.sort])) {
       const sort = prependMongoFilterWithProjectionPrefix(
         queryOptions.sort,
         prefix
@@ -766,5 +1034,9 @@ function fromStreamCollectionName(streamCollectionName) {
 
 
 
-exports.DefaultMongoDBEventStoreCollectionName = DefaultMongoDBEventStoreCollectionName; exports.DefaultMongoDBEventStoreStorageOptions = DefaultMongoDBEventStoreStorageOptions; exports.MongoDBDefaultInlineProjectionName = MongoDBDefaultInlineProjectionName; exports.MongoDBEventStoreDefaultStreamVersion = MongoDBEventStoreDefaultStreamVersion; exports.fromStreamCollectionName = fromStreamCollectionName; exports.fromStreamName = fromStreamName; exports.getMongoDBEventStore = getMongoDBEventStore; exports.handleInlineProjections = handleInlineProjections; exports.mongoDBEventStoreStorage = mongoDBEventStoreStorage; exports.mongoDBInlineProjection = mongoDBInlineProjection; exports.prependMongoFilterWithProjectionPrefix = prependMongoFilterWithProjectionPrefix; exports.toStreamCollectionName = toStreamCollectionName; exports.toStreamName = toStreamName;
+
+
+
+
+exports.DefaultMongoDBEventStoreCollectionName = DefaultMongoDBEventStoreCollectionName; exports.DefaultMongoDBEventStoreStorageOptions = DefaultMongoDBEventStoreStorageOptions; exports.MongoDBDefaultInlineProjectionName = MongoDBDefaultInlineProjectionName; exports.MongoDBEventStoreDefaultStreamVersion = MongoDBEventStoreDefaultStreamVersion; exports.MongoDBInlineProjectionSpec = MongoDBInlineProjectionSpec; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectInlineReadModel = expectInlineReadModel; exports.fromStreamCollectionName = fromStreamCollectionName; exports.fromStreamName = fromStreamName; exports.getMongoDBEventStore = getMongoDBEventStore; exports.handleInlineProjections = handleInlineProjections; exports.mongoDBEventStoreStorage = mongoDBEventStoreStorage; exports.mongoDBInlineProjection = mongoDBInlineProjection; exports.prependMongoFilterWithProjectionPrefix = prependMongoFilterWithProjectionPrefix; exports.toStreamCollectionName = toStreamCollectionName; exports.toStreamName = toStreamName;
 //# sourceMappingURL=index.cjs.map