@event-driven-io/emmett-postgresql 0.36.0 → 0.37.0

package/dist/index.cjs

@@ -139,22 +139,6 @@ var deepEquals = (left, right) => {
 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, 
-    async (bail) => {
-      try {
-        return await fn();
-      } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _10 => _10.shouldRetryError]) && !opts.shouldRetryError(error2)) {
-          bail(error2);
-        }
-        throw error2;
-      }
-    },
-    _nullishCoalesce(opts, () => ( { retries: 0 }))
-  );
-};
 var ParseError = class extends Error {
   constructor(text) {
     super(`Cannot parse! ${text}`);
@@ -163,19 +147,41 @@ var ParseError = class extends Error {
 var JSONParser = {
   stringify: (value, options) => {
     return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _11 => _11.map]) ? options.map(value) : value,
+      _optionalChain([options, 'optionalAccess', _10 => _10.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)]))
+    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)]))
       throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _16 => _16.map]) ? options.map(parsed) : parsed;
+    return _optionalChain([options, 'optionalAccess', _15 => _15.map]) ? options.map(parsed) : parsed;
   }
 };
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return _asyncretry2.default.call(void 0, 
+    async (bail) => {
+      try {
+        const result = await fn();
+        if (_optionalChain([opts, 'optionalAccess', _16 => _16.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)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
+};
 var MessageProcessorType = {
   PROJECTOR: "projector",
   REACTOR: "reactor"
@@ -189,18 +195,18 @@ var reactor = (options) => {
   return {
     id: options.processorId,
     type: _nullishCoalesce(options.type, () => ( MessageProcessorType.REACTOR)),
-    close: () => _optionalChain([options, 'access', _17 => _17.hooks, 'optionalAccess', _18 => _18.onClose]) ? _optionalChain([options, 'access', _19 => _19.hooks, 'optionalAccess', _20 => _20.onClose, 'call', _21 => _21()]) : Promise.resolve(),
+    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;
       return await processingScope(async (context) => {
-        if (_optionalChain([options, 'access', _22 => _22.hooks, 'optionalAccess', _23 => _23.onStart])) {
-          await _optionalChain([options, 'access', _24 => _24.hooks, 'optionalAccess', _25 => _25.onStart, 'call', _26 => _26(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', _27 => _27.read, 'call', _28 => _28(
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _28 => _28.read, 'call', _29 => _29(
             {
               processorId,
               partition
@@ -265,12 +271,12 @@ var projector = (options) => {
     type: MessageProcessorType.PROJECTOR,
     processorId: _nullishCoalesce(options.processorId, () => ( `projection:${projection2.name}`)),
     hooks: {
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _29 => _29.hooks, 'optionalAccess', _30 => _30.onStart]) ? async (context) => {
+      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _30 => _30.hooks, 'optionalAccess', _31 => _31.onStart]) ? async (context) => {
         if (options.truncateOnStart && options.projection.truncate)
           await options.projection.truncate(context);
-        if (_optionalChain([options, 'access', _31 => _31.hooks, 'optionalAccess', _32 => _32.onStart])) await _optionalChain([options, 'access', _33 => _33.hooks, 'optionalAccess', _34 => _34.onStart, 'call', _35 => _35(context)]);
+        if (_optionalChain([options, 'access', _32 => _32.hooks, 'optionalAccess', _33 => _33.onStart])) await _optionalChain([options, 'access', _34 => _34.hooks, 'optionalAccess', _35 => _35.onStart, 'call', _36 => _36(context)]);
       } : void 0,
-      onClose: _optionalChain([options, 'access', _36 => _36.hooks, 'optionalAccess', _37 => _37.onClose])
+      onClose: _optionalChain([options, 'access', _37 => _37.hooks, 'optionalAccess', _38 => _38.onClose])
     },
     eachMessage: async (event2, context) => {
       if (!projection2.canHandle.includes(event2.type)) return;
@@ -587,7 +593,7 @@ var readLastMessageGlobalPosition = async (execute, options) => {
            WHERE partition = %L AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
            ORDER BY transaction_id, global_position
            LIMIT 1`,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _38 => _38.partition]), () => ( defaultTag))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _39 => _39.partition]), () => ( defaultTag))
       )
     )
   );
@@ -612,7 +618,7 @@ var readMessagesBatch = async (execute, options) => {
            WHERE partition = %L AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${fromCondition} ${toCondition}
            ORDER BY transaction_id, global_position
            ${limitCondition}`,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _39 => _39.partition]), () => ( defaultTag))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.partition]), () => ( defaultTag))
       )
     ),
     (row) => {
@@ -676,7 +682,7 @@ var postgreSQLEventStoreMessageBatchPuller = ({
       }
       readMessagesOptions.after = currentGlobalPosition;
       await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (_optionalChain([stopWhen, 'optionalAccess', _40 => _40.noMessagesLeft]) === true && !areMessagesLeft) {
+      if (_optionalChain([stopWhen, 'optionalAccess', _41 => _41.noMessagesLeft]) === true && !areMessagesLeft) {
         isRunning = false;
         break;
       }
@@ -827,7 +833,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
   let appendResult;
   try {
     const expectedStreamVersion = toExpectedVersion(
-      _optionalChain([options, 'optionalAccess', _41 => _41.expectedStreamVersion])
+      _optionalChain([options, 'optionalAccess', _42 => _42.expectedStreamVersion])
     );
     const messagesToAppend = messages.map((e, i) => ({
       ...e,
@@ -848,7 +854,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
         expectedStreamVersion
       }
     );
-    if (_optionalChain([options, 'optionalAccess', _42 => _42.beforeCommitHook]))
+    if (_optionalChain([options, 'optionalAccess', _43 => _43.beforeCommitHook]))
       await options.beforeCommitHook(messagesToAppend, { transaction });
   } catch (error) {
     if (!isOptimisticConcurrencyError(error)) throw error;
@@ -906,8 +912,8 @@ var appendEventsRaw = (execute, streamId, streamType, messages, options) => _dum
       messages.map((e) => _dumbo.sql.call(void 0, "%L", e.kind === "Event" ? "E" : "C")).join(","),
       streamId,
       streamType,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _43 => _43.expectedStreamVersion]), () => ( "NULL")),
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _44 => _44.partition]), () => ( defaultTag))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _44 => _44.expectedStreamVersion]), () => ( "NULL")),
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.partition]), () => ( defaultTag))
     )
   )
 );
@@ -1351,7 +1357,7 @@ var readProcessorCheckpoint = async (execute, options) => {
            FROM ${subscriptionsTable.name}
            WHERE partition = %L AND subscription_id = %L
            LIMIT 1`,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.partition]), () => ( defaultTag)),
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.partition]), () => ( defaultTag)),
         options.processorId
       )
     )
@@ -1376,7 +1382,7 @@ var readStream = async (execute, streamId, options) => {
            FROM ${messagesTable.name}
            WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${fromCondition} ${toCondition}`,
         streamId,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.partition]), () => ( defaultTag))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _47 => _47.partition]), () => ( defaultTag))
       )
     ),
     (row) => {
@@ -1435,7 +1441,7 @@ var createEventStoreSchema = async (pool) => {
 var postgreSQLCheckpointer = () => ({
   read: async (options, context) => {
     const result = await readProcessorCheckpoint(context.execute, options);
-    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _47 => _47.lastProcessedPosition]) };
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _48 => _48.lastProcessedPosition]) };
   },
   store: async (options, context) => {
     const result = await storeProcessorCheckpoint(context.execute, {
@@ -1452,13 +1458,13 @@ var postgreSQLProcessingScope = (options) => {
   const processorConnectionString = options.connectionString;
   const processorPool = options.pool;
   const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _48 => _48.connection]);
-    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _49 => _49.connectionString])));
+    const connection = _optionalChain([partialContext, 'optionalAccess', _49 => _49.connection]);
+    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _50 => _50.connectionString])));
     if (!connectionString)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
       );
-    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _50 => _50.pool]) : processorPool), () => ( processorPool));
+    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _51 => _51.pool]) : processorPool), () => ( processorPool));
     if (!pool)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
@@ -1496,9 +1502,9 @@ var getProcessorPool = (options) => {
 var postgreSQLProjector = (options) => {
   const { pool, connectionString, close } = getProcessorPool(options);
   const hooks = {
-    onStart: _optionalChain([options, 'access', _51 => _51.hooks, 'optionalAccess', _52 => _52.onStart]),
-    onClose: _optionalChain([options, 'access', _53 => _53.hooks, 'optionalAccess', _54 => _54.onClose]) || close ? async () => {
-      if (_optionalChain([options, 'access', _55 => _55.hooks, 'optionalAccess', _56 => _56.onClose])) await _optionalChain([options, 'access', _57 => _57.hooks, 'optionalAccess', _58 => _58.onClose, 'call', _59 => _59()]);
+    onStart: _optionalChain([options, 'access', _52 => _52.hooks, 'optionalAccess', _53 => _53.onStart]),
+    onClose: _optionalChain([options, 'access', _54 => _54.hooks, 'optionalAccess', _55 => _55.onClose]) || close ? async () => {
+      if (_optionalChain([options, 'access', _56 => _56.hooks, 'optionalAccess', _57 => _57.onClose])) await _optionalChain([options, 'access', _58 => _58.hooks, 'optionalAccess', _59 => _59.onClose, 'call', _60 => _60()]);
       if (close) await close();
     } : void 0
   };
@@ -1516,9 +1522,9 @@ var postgreSQLProjector = (options) => {
 var postgreSQLReactor = (options) => {
   const { pool, connectionString, close } = getProcessorPool(options);
   const hooks = {
-    onStart: _optionalChain([options, 'access', _60 => _60.hooks, 'optionalAccess', _61 => _61.onStart]),
-    onClose: _optionalChain([options, 'access', _62 => _62.hooks, 'optionalAccess', _63 => _63.onClose]) || close ? async () => {
-      if (_optionalChain([options, 'access', _64 => _64.hooks, 'optionalAccess', _65 => _65.onClose])) await _optionalChain([options, 'access', _66 => _66.hooks, 'optionalAccess', _67 => _67.onClose, 'call', _68 => _68()]);
+    onStart: _optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onStart]),
+    onClose: _optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onClose]) || close ? async () => {
+      if (_optionalChain([options, 'access', _65 => _65.hooks, 'optionalAccess', _66 => _66.onClose])) await _optionalChain([options, 'access', _67 => _67.hooks, 'optionalAccess', _68 => _68.onClose, 'call', _69 => _69()]);
       if (close) await close();
     } : void 0
   };
@@ -1568,7 +1574,7 @@ var postgreSQLEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _69 => _69.value, 'optionalAccess', _70 => _70.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _70 => _70.value, 'optionalAccess', _71 => _71.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -1577,8 +1583,8 @@ var postgreSQLEventStoreConsumer = (options) => {
     stopWhen: options.stopWhen,
     executor: pool.execute,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _71 => _71.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _72 => _72.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _72 => _72.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _73 => _73.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs))
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -1891,7 +1897,7 @@ var PostgreSQLProjectionSpec = {
             const allEvents = [];
             const run = async (pool) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _73 => _73.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _74 => _74.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -1948,18 +1954,18 @@ var PostgreSQLProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _74 => _74.toString, 'call', _75 => _75()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _75 => _75.toString, 'call', _76 => _76()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _76 => _76.toString, 'call', _77 => _77()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _77 => _77.toString, 'call', _78 => _78()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _78 => _78.toString, 'call', _79 => _79()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _79 => _79.toString, 'call', _80 => _80()])}`
                     );
                   }
                 } finally {
@@ -1978,7 +1984,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _80 => _80.metadata, 'optionalAccess', _81 => _81.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _81 => _81.metadata, 'optionalAccess', _82 => _82.streamName]), () => ( streamName))
     }
   };
 };
@@ -2055,7 +2061,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
   };
   const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
   let migrateSchema;
-  const autoGenerateSchema = _optionalChain([options, 'access', _82 => _82.schema, 'optionalAccess', _83 => _83.autoMigration]) === void 0 || _optionalChain([options, 'access', _84 => _84.schema, 'optionalAccess', _85 => _85.autoMigration]) !== "None";
+  const autoGenerateSchema = _optionalChain([options, 'access', _83 => _83.schema, 'optionalAccess', _84 => _84.autoMigration]) === void 0 || _optionalChain([options, 'access', _85 => _85.schema, 'optionalAccess', _86 => _86.autoMigration]) !== "None";
   const ensureSchemaExists = () => {
     if (!autoGenerateSchema) return Promise.resolve();
     if (!migrateSchema) {
@@ -2085,7 +2091,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _86 => _86.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _87 => _87.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(streamName, options2.read);
       const currentStreamVersion = result.currentStreamVersion;
@@ -2126,7 +2132,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _87 => _87.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _88 => _88.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,