@event-driven-io/emmett-postgresql 0.42.0-rc.1 → 0.42.0

package/dist/index.cjs

@@ -892,10 +892,10 @@ var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
 
 require('pg');
 
-// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
 
 
-// src/eventStore/schema/processors/processorsLocks.ts
+// src/eventStore/schema/projections/projectionsLocks.ts
 
 
 // src/eventStore/schema/createFunctionIfDoesNotExist.ts
@@ -911,7 +911,97 @@ END $$;
 `
 );
 
+// src/eventStore/schema/projections/projectionsLocks.ts
+var tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL(
+  "emt_try_acquire_projection_lock",
+  `
+CREATE OR REPLACE FUNCTION emt_try_acquire_projection_lock(
+    p_lock_key   BIGINT,
+    p_partition  TEXT,
+    p_name       TEXT,
+    p_version    INT
+)
+RETURNS TABLE (acquired BOOLEAN, is_active BOOLEAN)
+LANGUAGE plpgsql
+AS $emt_try_acquire_projection_lock$
+BEGIN
+    RETURN QUERY
+    WITH lock_check AS (
+        SELECT pg_try_advisory_xact_lock_shared(p_lock_key) AS acquired
+    ),
+    status_check AS (
+        SELECT status = 'active' AS is_active
+        FROM ${projectionsTable.name}
+        WHERE partition = p_partition AND name = p_name AND version = p_version
+    )
+    SELECT
+        COALESCE((SELECT lc.acquired FROM lock_check lc), false),
+        COALESCE((SELECT sc.is_active FROM status_check sc), true);
+END;
+$emt_try_acquire_projection_lock$;
+`
+);
+var callTryAcquireProjectionLock = (params) => _dumbo.sql.call(void 0, 
+  `SELECT * FROM emt_try_acquire_projection_lock(%s::BIGINT, %L, %L, %s);`,
+  params.lockKey,
+  params.partition,
+  params.name,
+  params.version
+);
+
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
+var tryAcquireProjectionLock = async (execute, {
+  lockKey,
+  projectionName,
+  partition,
+  version
+}) => {
+  const lockKeyBigInt = isBigint(lockKey) ? lockKey : await hashText(lockKey);
+  const { acquired, is_active } = await _dumbo.single.call(void 0, 
+    execute.query(
+      callTryAcquireProjectionLock({
+        lockKey: lockKeyBigInt.toString(),
+        partition,
+        name: projectionName,
+        version
+      })
+    )
+  );
+  return acquired === true && is_active === true;
+};
+
+// src/eventStore/projections/locks/postgreSQLProjectionLock.ts
+var postgreSQLProjectionLock = (options) => {
+  let acquired = false;
+  const lockKey = _nullishCoalesce(options.lockKey, () => ( toProjectionLockKey(options)));
+  return {
+    tryAcquire: async (context) => {
+      if (acquired) {
+        return true;
+      }
+      acquired = await tryAcquireProjectionLock(context.execute, {
+        ...options,
+        lockKey
+      });
+      return acquired;
+    },
+    release: (_context) => {
+      if (!acquired) return;
+      acquired = false;
+    }
+  };
+};
+var toProjectionLockKey = ({
+  projectionName,
+  partition,
+  version
+}) => `${partition}:${projectionName}:${version}`;
+
+// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
+
+
 // src/eventStore/schema/processors/processorsLocks.ts
+
 var tryAcquireProcessorLockSQL = createFunctionIfDoesNotExistSQL(
   "emt_try_acquire_processor_lock",
   `
@@ -1070,7 +1160,7 @@ var tryAcquireProcessorLock = async (execute, options) => {
   return acquired ? { acquired: true, checkpoint } : { acquired: false };
 };
 var tryAcquireProcessorLockWithRetry = async (execute, options) => {
-  const policy = _nullishCoalesce(options.lockPolicy, () => ( DefaultPostgreSQLProcessorLockPolicy));
+  const policy = _nullishCoalesce(options.lockAcquisitionPolicy, () => ( DefaultPostgreSQLProcessorLockPolicy));
   if (policy.type === "retry") {
     return asyncRetry(() => tryAcquireProcessorLock(execute, options), {
       retries: policy.retries - 1,
@@ -1098,96 +1188,6 @@ var releaseProcessorLock = async (execute, options) => {
   return result;
 };
 
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-
-
-// src/eventStore/schema/projections/projectionsLocks.ts
-
-var tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL(
-  "emt_try_acquire_projection_lock",
-  `
-CREATE OR REPLACE FUNCTION emt_try_acquire_projection_lock(
-    p_lock_key   BIGINT,
-    p_partition  TEXT,
-    p_name       TEXT,
-    p_version    INT
-)
-RETURNS TABLE (acquired BOOLEAN, is_active BOOLEAN)
-LANGUAGE plpgsql
-AS $emt_try_acquire_projection_lock$
-BEGIN
-    RETURN QUERY
-    WITH lock_check AS (
-        SELECT pg_try_advisory_xact_lock_shared(p_lock_key) AS acquired
-    ),
-    status_check AS (
-        SELECT status = 'active' AS is_active
-        FROM ${projectionsTable.name}
-        WHERE partition = p_partition AND name = p_name AND version = p_version
-    )
-    SELECT
-        COALESCE((SELECT lc.acquired FROM lock_check lc), false),
-        COALESCE((SELECT sc.is_active FROM status_check sc), true);
-END;
-$emt_try_acquire_projection_lock$;
-`
-);
-var callTryAcquireProjectionLock = (params) => _dumbo.sql.call(void 0, 
-  `SELECT * FROM emt_try_acquire_projection_lock(%s::BIGINT, %L, %L, %s);`,
-  params.lockKey,
-  params.partition,
-  params.name,
-  params.version
-);
-
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-var tryAcquireProjectionLock = async (execute, {
-  lockKey,
-  projectionName,
-  partition,
-  version
-}) => {
-  const lockKeyBigInt = isBigint(lockKey) ? lockKey : await hashText(lockKey);
-  const { acquired, is_active } = await _dumbo.single.call(void 0, 
-    execute.query(
-      callTryAcquireProjectionLock({
-        lockKey: lockKeyBigInt.toString(),
-        partition,
-        name: projectionName,
-        version
-      })
-    )
-  );
-  return acquired === true && is_active === true;
-};
-
-// src/eventStore/projections/locks/postgreSQLProjectionLock.ts
-var postgreSQLProjectionLock = (options) => {
-  let acquired = false;
-  const lockKey = _nullishCoalesce(options.lockKey, () => ( toProjectionLockKey(options)));
-  return {
-    tryAcquire: async (context) => {
-      if (acquired) {
-        return true;
-      }
-      acquired = await tryAcquireProjectionLock(context.execute, {
-        ...options,
-        lockKey
-      });
-      return acquired;
-    },
-    release: (_context) => {
-      if (!acquired) return;
-      acquired = false;
-    }
-  };
-};
-var toProjectionLockKey = ({
-  projectionName,
-  partition,
-  version
-}) => `${partition}:${projectionName}:${version}`;
-
 // src/eventStore/projections/locks/postgreSQLProcessorLock.ts
 var DefaultPostgreSQLProcessorLockPolicy = {
   type: "fail"
@@ -1204,7 +1204,7 @@ var postgreSQLProcessorLock = (options) => {
         ...options,
         lockKey
       });
-      if (!result.acquired && _optionalChain([options, 'access', _45 => _45.lockPolicy, 'optionalAccess', _46 => _46.type]) !== "skip") {
+      if (!result.acquired && _optionalChain([options, 'access', _45 => _45.lockAcquisitionPolicy, 'optionalAccess', _46 => _46.type]) !== "skip") {
         throw new EmmettError(
           `Failed to acquire lock for processor '${options.processorId}'`
         );
@@ -1589,7 +1589,7 @@ var pongoMultiStreamProjection = (options) => {
         await pongo.db().collection(
           collectionNameWithVersion,
           options.collectionOptions
-        ).schema.migrate();
+        ).schema.migrate(context.migrationOptions);
       } finally {
         await pongo.close();
       }
@@ -4166,8 +4166,8 @@ var eventStoreSchemaMigrations = [
   migration_0_42_0_2_AddProcessorProjectionFunctions,
   schemaMigration
 ];
-var createEventStoreSchema = async (connectionString, pool, hooks) => {
-  await pool.withTransaction(async (tx) => {
+var createEventStoreSchema = (connectionString, pool, hooks, options) => {
+  return pool.withTransaction(async (tx) => {
     const client = await tx.connection.open();
     const context = {
       execute: tx.execute,
@@ -4183,10 +4183,15 @@ var createEventStoreSchema = async (connectionString, pool, hooks) => {
       if (_optionalChain([hooks, 'optionalAccess', _65 => _65.onBeforeSchemaCreated])) {
         await hooks.onBeforeSchemaCreated(context);
       }
-      await _dumbo.runPostgreSQLMigrations.call(void 0, nestedPool, eventStoreSchemaMigrations);
+      const result = await _dumbo.runPostgreSQLMigrations.call(void 0, 
+        nestedPool,
+        eventStoreSchemaMigrations,
+        options
+      );
       if (_optionalChain([hooks, 'optionalAccess', _66 => _66.onAfterSchemaCreated])) {
         await hooks.onAfterSchemaCreated(context);
       }
+      return result;
     } finally {
       await nestedPool.close();
     }
@@ -4218,30 +4223,35 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
   let migrateSchema = void 0;
   const autoGenerateSchema = _optionalChain([options, 'access', _68 => _68.schema, 'optionalAccess', _69 => _69.autoMigration]) === void 0 || _optionalChain([options, 'access', _70 => _70.schema, 'optionalAccess', _71 => _71.autoMigration]) !== "None";
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const migrate = async () => {
+  const migrate = async (migrationOptions) => {
     if (!migrateSchema) {
-      migrateSchema = createEventStoreSchema(connectionString, pool, {
-        onBeforeSchemaCreated: async (context) => {
-          if (_optionalChain([options, 'access', _72 => _72.hooks, 'optionalAccess', _73 => _73.onBeforeSchemaCreated])) {
-            await options.hooks.onBeforeSchemaCreated(context);
-          }
-        },
-        onAfterSchemaCreated: async (context) => {
-          for (const projection2 of inlineProjections) {
-            if (projection2.init) {
-              await projection2.init({
-                version: _nullishCoalesce(projection2.version, () => ( 1)),
-                status: "active",
-                registrationType: "inline",
-                context
-              });
+      migrateSchema = createEventStoreSchema(
+        connectionString,
+        pool,
+        {
+          onBeforeSchemaCreated: async (context) => {
+            if (_optionalChain([options, 'access', _72 => _72.hooks, 'optionalAccess', _73 => _73.onBeforeSchemaCreated])) {
+              await options.hooks.onBeforeSchemaCreated(context);
+            }
+          },
+          onAfterSchemaCreated: async (context) => {
+            for (const projection2 of inlineProjections) {
+              if (projection2.init) {
+                await projection2.init({
+                  version: _nullishCoalesce(projection2.version, () => ( 1)),
+                  status: "active",
+                  registrationType: "inline",
+                  context: { ...context, migrationOptions }
+                });
+              }
+            }
+            if (_optionalChain([options, 'access', _74 => _74.hooks, 'optionalAccess', _75 => _75.onAfterSchemaCreated])) {
+              await options.hooks.onAfterSchemaCreated(context);
             }
           }
-          if (_optionalChain([options, 'access', _74 => _74.hooks, 'optionalAccess', _75 => _75.onAfterSchemaCreated])) {
-            await options.hooks.onAfterSchemaCreated(context);
-          }
-        }
-      });
+        },
+        migrationOptions
+      );
     }
     return migrateSchema;
   };
@@ -4713,8 +4723,7 @@ var postgreSQLProjector = (options) => {
     processorInstanceId = getProcessorInstanceId(processorId),
     version = defaultProcessorVersion,
     partition = defaultProcessorPartition,
-    lockPolicy = DefaultPostgreSQLProcessorLockPolicy,
-    lockTimeoutSeconds
+    lock
   } = options;
   const { pool, connectionString, close } = getProcessorPool(options);
   const processorLock = postgreSQLProcessorLock({
@@ -4728,26 +4737,33 @@ var postgreSQLProjector = (options) => {
       version: _nullishCoalesce(options.projection.version, () => ( version)),
       handlingType: "async"
     } : void 0,
-    lockPolicy,
-    lockTimeoutSeconds
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _98 => _98.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _99 => _99.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
-      onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _98 => _98.hooks, 'optionalAccess', _99 => _99.onInit]) ? async (context) => {
+      onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _100 => _100.hooks, 'optionalAccess', _101 => _101.onInit]) ? async (context) => {
         if (options.projection.init)
           await options.projection.init({
             version: _nullishCoalesce(options.projection.version, () => ( version)),
             status: "active",
             registrationType: "async",
-            context
+            context: {
+              ...context,
+              migrationOptions: options.migrationOptions
+            }
+          });
+        if (_optionalChain([options, 'access', _102 => _102.hooks, 'optionalAccess', _103 => _103.onInit]))
+          await options.hooks.onInit({
+            ...context,
+            migrationOptions: options.migrationOptions
           });
-        if (_optionalChain([options, 'access', _100 => _100.hooks, 'optionalAccess', _101 => _101.onInit])) await options.hooks.onInit(context);
-      } : _optionalChain([options, 'access', _102 => _102.hooks, 'optionalAccess', _103 => _103.onInit]),
+      } : _optionalChain([options, 'access', _104 => _104.hooks, 'optionalAccess', _105 => _105.onInit]),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _104 => _104.hooks, 'optionalAccess', _105 => _105.onClose])) await _optionalChain([options, 'access', _106 => _106.hooks, 'optionalAccess', _107 => _107.onClose, 'call', _108 => _108(context)]);
+        if (_optionalChain([options, 'access', _106 => _106.hooks, 'optionalAccess', _107 => _107.onClose])) await _optionalChain([options, 'access', _108 => _108.hooks, 'optionalAccess', _109 => _109.onClose, 'call', _110 => _110(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _109 => _109.hooks, 'optionalAccess', _110 => _110.onClose])
+      } : _optionalChain([options, 'access', _111 => _111.hooks, 'optionalAccess', _112 => _112.onClose])
     },
     processorLock
   );
@@ -4774,7 +4790,7 @@ var postgreSQLReactor = (options) => {
     processorInstanceId = getProcessorInstanceId(processorId),
     version = defaultProcessorVersion,
     partition = defaultProcessorPartition,
-    lockPolicy = DefaultPostgreSQLProcessorLockPolicy
+    lock
   } = options;
   const { pool, connectionString, close } = getProcessorPool(options);
   const processorLock = postgreSQLProcessorLock({
@@ -4783,15 +4799,16 @@ var postgreSQLReactor = (options) => {
     partition,
     processorInstanceId,
     projection: void 0,
-    lockPolicy
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _113 => _113.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _114 => _114.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _111 => _111.hooks, 'optionalAccess', _112 => _112.onClose])) await _optionalChain([options, 'access', _113 => _113.hooks, 'optionalAccess', _114 => _114.onClose, 'call', _115 => _115(context)]);
+        if (_optionalChain([options, 'access', _115 => _115.hooks, 'optionalAccess', _116 => _116.onClose])) await _optionalChain([options, 'access', _117 => _117.hooks, 'optionalAccess', _118 => _118.onClose, 'call', _119 => _119(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _116 => _116.hooks, 'optionalAccess', _117 => _117.onClose])
+      } : _optionalChain([options, 'access', _120 => _120.hooks, 'optionalAccess', _121 => _121.onClose])
     },
     processorLock
   );
@@ -4848,7 +4865,7 @@ var postgreSQLEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _118 => _118.value, 'optionalAccess', _119 => _119.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _122 => _122.value, 'optionalAccess', _123 => _123.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -4867,7 +4884,7 @@ var postgreSQLEventStoreConsumer = (options) => {
     if (!isRunning) return;
     isRunning = false;
     if (messagePuller) {
-      _optionalChain([abortController, 'optionalAccess', _120 => _120.abort, 'call', _121 => _121()]);
+      _optionalChain([abortController, 'optionalAccess', _124 => _124.abort, 'call', _125 => _125()]);
       await messagePuller.stop();
       messagePuller = void 0;
       abortController = null;
@@ -4920,8 +4937,8 @@ var postgreSQLEventStoreConsumer = (options) => {
         stopWhen: options.stopWhen,
         executor: pool.execute,
         eachBatch,
-        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _122 => _122.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
-        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _123 => _123.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
+        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _126 => _126.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _127 => _127.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
         signal: abortController.signal
       });
       start = (async () => {
@@ -4969,9 +4986,9 @@ var rebuildPostgreSQLProjections = (options) => {
     ...options,
     stopWhen: { noMessagesLeft: true }
   });
+  const lock = { acquisitionPolicy: defaultRebuildLockPolicy, ...options.lock };
   const projections = "projections" in options ? options.projections.map(
     (p) => "projection" in p ? {
-      lockPolicy: defaultRebuildLockPolicy,
       truncateOnStart: true,
       processorId: getProjectorId({
         projectionName: _nullishCoalesce(p.projection.name, () => ( unknownTag2))
@@ -4982,14 +4999,14 @@ var rebuildPostgreSQLProjections = (options) => {
       processorId: getProjectorId({
         projectionName: _nullishCoalesce(p.name, () => ( unknownTag2))
       }),
-      truncateOnStart: true,
-      lockPolicy: defaultRebuildLockPolicy
+      truncateOnStart: true
     }
   ) : [options];
   for (const projectionDefinition of projections) {
     consumer.projector({
       ...projectionDefinition,
-      truncateOnStart: _nullishCoalesce(projectionDefinition.truncateOnStart, () => ( true))
+      truncateOnStart: _nullishCoalesce(projectionDefinition.truncateOnStart, () => ( true)),
+      lock
     });
   }
   return consumer;