@event-driven-io/emmett-postgresql 0.38.0-alpha.3 → 0.38.0-alpha.5

package/dist/index.cjs

@@ -3,7 +3,7 @@
 
 var _dumbo = require('@event-driven-io/dumbo');
 
-// ../emmett/dist/chunk-BQYVGGNE.js
+// ../emmett/dist/chunk-SJ7ERGWB.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isString = (val) => typeof val === "string";
 var isErrorConstructor = (expect) => {
@@ -34,12 +34,12 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
-var _webstreamspolyfill = require('web-streams-polyfill');
 
+var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
+var _webstreamspolyfill = require('web-streams-polyfill');
 
 
-var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
 
@@ -74,44 +74,6 @@ var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends C
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
-var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
-var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfill.TransformStream {
-  constructor(onNoActiveReaderCallback, options = {}) {
-    super({
-      cancel: (reason) => {
-        console.log("Stream was canceled. Reason:", reason);
-        this.stopChecking();
-      }
-    });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
-    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.streamId]), () => ( _uuid.v4.call(void 0, )));
-    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => ( 20)));
-  }
-  __init() {this.checkInterval = null}
-  
-  __init2() {this._isStopped = false}
-  get hasActiveSubscribers() {
-    return !this._isStopped;
-  }
-  startChecking(interval) {
-    this.checkInterval = setInterval(() => {
-      this.checkNoActiveReader();
-    }, interval);
-  }
-  stopChecking() {
-    if (!this.checkInterval) return;
-    clearInterval(this.checkInterval);
-    this.checkInterval = null;
-    this._isStopped = true;
-    this.onNoActiveReaderCallback(this);
-  }
-  checkNoActiveReader() {
-    if (!this.readable.locked && !this._isStopped) {
-      this.stopChecking();
-    }
-  }
-}, _class);
 var deepEquals = (left, right) => {
   if (isEquatable(left)) {
     return left.equals(right);
@@ -148,17 +110,17 @@ var ParseError = class extends Error {
 var JSONParser = {
   stringify: (value, options) => {
     return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _10 => _10.map]) ? options.map(value) : value,
+      _optionalChain([options, 'optionalAccess', _8 => _8.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', _11 => _11.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _12 => _12.typeCheck]) && !_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck, 'call', _14 => _14(parsed)]))
+    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _9 => _9.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _10 => _10.typeCheck]) && !_optionalChain([options, 'optionalAccess', _11 => _11.typeCheck, 'call', _12 => _12(parsed)]))
       throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _15 => _15.map]) ? options.map(parsed) : parsed;
+    return _optionalChain([options, 'optionalAccess', _13 => _13.map]) ? options.map(parsed) : parsed;
   }
 };
 var asyncRetry = async (fn, opts) => {
@@ -167,14 +129,14 @@ var asyncRetry = async (fn, opts) => {
     async (bail) => {
       try {
         const result = await fn();
-        if (_optionalChain([opts, 'optionalAccess', _16 => _16.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+        if (_optionalChain([opts, 'optionalAccess', _14 => _14.shouldRetryResult]) && opts.shouldRetryResult(result)) {
           throw new EmmettError(
             `Retrying because of result: ${JSONParser.stringify(result)}`
           );
         }
         return result;
       } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _17 => _17.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+        if (_optionalChain([opts, 'optionalAccess', _15 => _15.shouldRetryError]) && !opts.shouldRetryError(error2)) {
           bail(error2);
         }
         throw error2;
@@ -298,6 +260,44 @@ var assertThatArray = (array) => {
     }
   };
 };
+var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
+var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfill.TransformStream {
+  constructor(onNoActiveReaderCallback, options = {}) {
+    super({
+      cancel: (reason) => {
+        console.log("Stream was canceled. Reason:", reason);
+        this.stopChecking();
+      }
+    });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.intervalCheckInMs]), () => ( 20)));
+  }
+  __init() {this.checkInterval = null}
+  
+  __init2() {this._isStopped = false}
+  get hasActiveSubscribers() {
+    return !this._isStopped;
+  }
+  startChecking(interval) {
+    this.checkInterval = setInterval(() => {
+      this.checkNoActiveReader();
+    }, interval);
+  }
+  stopChecking() {
+    if (!this.checkInterval) return;
+    clearInterval(this.checkInterval);
+    this.checkInterval = null;
+    this._isStopped = true;
+    this.onNoActiveReaderCallback(this);
+  }
+  checkNoActiveReader() {
+    if (!this.readable.locked && !this._isStopped) {
+      this.stopChecking();
+    }
+  }
+}, _class);
 var MessageProcessorType = {
   PROJECTOR: "projector",
   REACTOR: "reactor"
@@ -308,26 +308,30 @@ var reactor = (options) => {
   let isActive = true;
   const { checkpoints, processorId, partition } = options;
   const processingScope = _nullishCoalesce(options.processingScope, () => ( defaultProcessingMessageProcessingScope));
+  let lastCheckpoint = null;
   return {
     id: options.processorId,
     type: _nullishCoalesce(options.type, () => ( MessageProcessorType.REACTOR)),
     close: () => _optionalChain([options, 'access', _18 => _18.hooks, 'optionalAccess', _19 => _19.onClose]) ? _optionalChain([options, 'access', _20 => _20.hooks, 'optionalAccess', _21 => _21.onClose, 'call', _22 => _22()]) : Promise.resolve(),
     start: async (startOptions) => {
       isActive = true;
+      if (lastCheckpoint !== null)
+        return {
+          lastCheckpoint
+        };
       return await processingScope(async (context) => {
         if (_optionalChain([options, 'access', _23 => _23.hooks, 'optionalAccess', _24 => _24.onStart])) {
           await _optionalChain([options, 'access', _25 => _25.hooks, 'optionalAccess', _26 => _26.onStart, 'call', _27 => _27(context)]);
         }
         if (options.startFrom !== "CURRENT" && options.startFrom)
           return options.startFrom;
-        let lastCheckpoint = null;
         if (checkpoints) {
           const readResult = await _optionalChain([checkpoints, 'optionalAccess', _28 => _28.read, 'call', _29 => _29(
             {
               processorId,
               partition
             },
-            startOptions
+            { ...startOptions, ...context }
           )]);
           lastCheckpoint = readResult.lastCheckpoint;
         }
@@ -344,7 +348,6 @@ var reactor = (options) => {
       if (!isActive) return Promise.resolve();
       return await processingScope(async (context) => {
         let result = void 0;
-        let lastCheckpoint = null;
         for (const message2 of messages) {
           const messageProcessingResult = await eachMessage(message2, context);
           if (checkpoints) {
@@ -755,7 +758,7 @@ var appendToStreamSQL = _dumbo.rawSql.call(void 0,
   ) RETURNS TABLE (
       success boolean,
       next_stream_position bigint,
-      last_global_position bigint,
+      global_positions bigint[],
       transaction_id xid8
   ) LANGUAGE plpgsql
   AS $$
@@ -764,7 +767,7 @@ var appendToStreamSQL = _dumbo.rawSql.call(void 0,
       v_position bigint;
       v_updated_rows int;
       v_transaction_id xid8;
-      v_last_global_position bigint;
+      v_global_positions bigint[];
   BEGIN
       v_transaction_id := pg_current_xact_id();
 
@@ -789,7 +792,7 @@ var appendToStreamSQL = _dumbo.rawSql.call(void 0,
           get diagnostics v_updated_rows = row_count;
 
           IF v_updated_rows = 0 THEN
-              RETURN QUERY SELECT FALSE, NULL::bigint, NULL::bigint, NULL::xid8;
+              RETURN QUERY SELECT FALSE, NULL::bigint, NULL::bigint[], NULL::xid8;
               RETURN;
           END IF;
       END IF;
@@ -818,11 +821,11 @@ var appendToStreamSQL = _dumbo.rawSql.call(void 0,
           RETURNING global_position
       )
       SELECT 
-          max(global_position) INTO v_last_global_position 
+          array_agg(global_position ORDER BY global_position) INTO v_global_positions
       FROM 
           all_messages_insert;
 
-      RETURN QUERY SELECT TRUE, v_next_stream_position, v_last_global_position, v_transaction_id;
+      RETURN QUERY SELECT TRUE, v_next_stream_position, v_global_positions, v_transaction_id;
   END;
   $$;
   `
@@ -831,22 +834,24 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
   const { execute } = transaction;
   if (messages.length === 0)
     return { success: false, result: { success: false } };
-  let appendResult;
   try {
     const expectedStreamVersion = toExpectedVersion(
       _optionalChain([options, 'optionalAccess', _42 => _42.expectedStreamVersion])
     );
-    const messagesToAppend = messages.map((e, i) => ({
+    const messagesToAppend = messages.map((e) => ({
       ...e,
       kind: _nullishCoalesce(e.kind, () => ( "Event")),
       metadata: {
-        streamName,
         messageId: _uuid.v4.call(void 0, ),
-        streamPosition: BigInt(i),
         ..."metadata" in e ? _nullishCoalesce(e.metadata, () => ( {})) : {}
       }
     }));
-    appendResult = await appendEventsRaw(
+    const {
+      success,
+      next_stream_position,
+      global_positions,
+      transaction_id
+    } = await appendEventsRaw(
       execute,
       streamName,
       streamType,
@@ -855,32 +860,40 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
         expectedStreamVersion
       }
     );
+    if (!success || next_stream_position === null || global_positions === null || global_positions.length === 0 || transaction_id == null) {
+      return {
+        success: false,
+        result: { success: false }
+      };
+    }
+    const nextStreamPosition = BigInt(next_stream_position);
+    const globalPositions = global_positions.map(BigInt);
+    globalPositions.forEach((globalPosition, index) => {
+      messagesToAppend[index].metadata = {
+        ...messagesToAppend[index].metadata,
+        streamName,
+        streamPosition: nextStreamPosition - BigInt(messagesToAppend.length) + BigInt(index + 1),
+        globalPosition
+      };
+    });
     if (_optionalChain([options, 'optionalAccess', _43 => _43.beforeCommitHook]))
       await options.beforeCommitHook(messagesToAppend, { transaction });
+    return {
+      success: true,
+      result: {
+        success: true,
+        nextStreamPosition,
+        globalPositions,
+        transactionId: transaction_id
+      }
+    };
   } catch (error) {
     if (!isOptimisticConcurrencyError(error)) throw error;
-    appendResult = {
+    return {
       success: false,
-      last_global_position: null,
-      next_stream_position: null,
-      transaction_id: null
+      result: { success: false }
     };
   }
-  const {
-    success,
-    next_stream_position,
-    last_global_position,
-    transaction_id
-  } = appendResult;
-  return {
-    success,
-    result: success && next_stream_position && last_global_position && transaction_id ? {
-      success: true,
-      nextStreamPosition: BigInt(next_stream_position),
-      lastGlobalPosition: BigInt(last_global_position),
-      transactionId: transaction_id
-    } : { success: false }
-  };
 });
 var toExpectedVersion = (expected) => {
   if (expected === void 0) return null;
@@ -907,7 +920,10 @@ var appendEventsRaw = (execute, streamId, streamType, messages, options) => _dum
               )`,
       messages.map((e) => _dumbo.sql.call(void 0, "%L", e.metadata.messageId)).join(","),
       messages.map((e) => _dumbo.sql.call(void 0, "%L", JSONParser.stringify(e.data))).join(","),
-      messages.map((e) => _dumbo.sql.call(void 0, "%L", JSONParser.stringify(_nullishCoalesce(e.metadata, () => ( {}))))).join(","),
+      messages.map((e) => {
+        const { messageId: _messageId, ...rawMetadata } = e.metadata;
+        return _dumbo.sql.call(void 0, "%L", JSONParser.stringify(rawMetadata));
+      }).join(","),
       messages.map(() => `'1'`).join(","),
       messages.map((e) => _dumbo.sql.call(void 0, "%L", e.type)).join(","),
       messages.map((e) => _dumbo.sql.call(void 0, "%L", e.kind === "Event" ? "E" : "C")).join(","),
@@ -2146,7 +2162,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
-        lastEventGlobalPosition: appendResult.lastGlobalPosition,
+        lastEventGlobalPosition: appendResult.globalPositions[appendResult.globalPositions.length - 1],
         createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
       };
     },