@event-driven-io/emmett-postgresql 0.38.2 → 0.38.4

package/dist/index.cjs

@@ -3,7 +3,7 @@
 
 var _dumbo = require('@event-driven-io/dumbo');
 
-// ../emmett/dist/chunk-SJ7ERGWB.js
+// ../emmett/dist/chunk-O2VMBOV4.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isBigint = (val) => typeof val === "bigint" && val === val;
 var isString = (val) => typeof val === "string";
@@ -20,6 +20,15 @@ var EmmettError = class _EmmettError extends Error {
     this.errorCode = errorCode;
     Object.setPrototypeOf(this, _EmmettError.prototype);
   }
+  static mapFrom(error) {
+    if (error instanceof _EmmettError) {
+      return error;
+    }
+    return new _EmmettError({
+      errorCode: "errorCode" in error && error.errorCode !== void 0 && error.errorCode !== null ? error.errorCode : 500,
+      message: _nullishCoalesce(error.message, () => ( "An unknown error occurred"))
+    });
+  }
 };
 var ConcurrencyError = class _ConcurrencyError extends EmmettError {
   constructor(current, expected, message) {
@@ -139,6 +148,7 @@ var asyncRetry = async (fn, opts) => {
       } catch (error2) {
         if (_optionalChain([opts, 'optionalAccess', _15 => _15.shouldRetryError]) && !opts.shouldRetryError(error2)) {
           bail(error2);
+          return void 0;
         }
         throw error2;
       }
@@ -314,6 +324,11 @@ var getCheckpoint = (message2) => {
     message2.metadata.streamPosition
   ) : null;
 };
+var wasMessageHandled = (message2, checkpoint) => {
+  const messageCheckpoint = getCheckpoint(message2);
+  const checkpointBigint = checkpoint;
+  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpointBigint !== null && checkpointBigint !== void 0 && messageCheckpoint <= checkpointBigint;
+};
 var MessageProcessorType = {
   PROJECTOR: "projector",
   REACTOR: "reactor"
@@ -365,6 +380,7 @@ var reactor = (options) => {
       return await processingScope(async (context) => {
         let result = void 0;
         for (const message2 of messages) {
+          if (wasMessageHandled(message2, lastCheckpoint)) continue;
           const messageProcessingResult = await eachMessage(message2, context);
           if (checkpoints) {
             const storeCheckpointResult = await checkpoints.store(
@@ -377,7 +393,7 @@ var reactor = (options) => {
               },
               context
             );
-            if (storeCheckpointResult && storeCheckpointResult.success) {
+            if (storeCheckpointResult.success) {
               lastCheckpoint = storeCheckpointResult.newCheckpoint;
             }
           }
@@ -788,9 +804,15 @@ var appendToStreamSQL = _dumbo.rawSql.call(void 0,
       v_transaction_id := pg_current_xact_id();
 
       IF v_expected_stream_position IS NULL THEN
-          SELECT COALESCE(max(stream_position), 0) INTO v_expected_stream_position
-          FROM ${streamsTable.name}
-          WHERE stream_id = v_stream_id AND partition = v_partition;
+          SELECT COALESCE(
+            (SELECT stream_position 
+            FROM ${streamsTable.name}
+            WHERE stream_id = v_stream_id 
+              AND partition = v_partition 
+              AND is_archived = FALSE
+            LIMIT 1), 
+            0
+        ) INTO v_expected_stream_position;
       END IF;
 
       v_next_stream_position := v_expected_stream_position + array_upper(v_messages_data, 1);
@@ -1044,9 +1066,12 @@ var streamsTableSQL = _dumbo.rawSql.call(void 0,
       stream_type       TEXT                      NOT NULL,
       stream_metadata   JSONB                     NOT NULL,
       is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
-      PRIMARY KEY (stream_id, stream_position, partition, is_archived),
-      UNIQUE (stream_id, partition, is_archived)
-  ) PARTITION BY LIST (partition);`
+      PRIMARY KEY (stream_id, partition, is_archived)
+  ) PARTITION BY LIST (partition);
+   
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_streams_unique 
+  ON ${streamsTable.name}(stream_id, partition, is_archived) 
+  INCLUDE (stream_position);`
 );
 var messagesTableSQL = _dumbo.rawSql.call(void 0, 
   `
@@ -2104,12 +2129,16 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     ...options.connectionOptions ? options.connectionOptions : {}
   };
   const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
-  let migrateSchema;
+  let migrateSchema = void 0;
   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) {
-      migrateSchema = createEventStoreSchema(pool);
+      migrateSchema = createEventStoreSchema(pool).then(async () => {
+        if (_optionalChain([options, 'access', _87 => _87.hooks, 'optionalAccess', _88 => _88.onAfterSchemaCreated])) {
+          await options.hooks.onAfterSchemaCreated();
+        }
+      });
     }
     return migrateSchema;
   };
@@ -2135,7 +2164,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _87 => _87.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _89 => _89.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(streamName, options2.read);
       const currentStreamVersion = result.currentStreamVersion;
@@ -2176,7 +2205,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _88 => _88.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _90 => _90.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -2196,16 +2225,22 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
           ...options,
           connectionOptions: {
             connection
+          },
+          schema: {
+            ..._nullishCoalesce(options.schema, () => ( {})),
+            autoMigration: "None"
           }
         };
         const eventStore = getPostgreSQLEventStore(
           connectionString,
           storeOptions
         );
-        return callback({
-          eventStore,
-          close: () => Promise.resolve()
-        });
+        return ensureSchemaExists().then(
+          () => callback({
+            eventStore,
+            close: () => Promise.resolve()
+          })
+        );
       });
     }
   };