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

package/dist/index.cjs

@@ -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;
   };
@@ -4740,9 +4750,16 @@ var postgreSQLProjector = (options) => {
             version: _nullishCoalesce(options.projection.version, () => ( version)),
             status: "active",
             registrationType: "async",
-            context
+            context: {
+              ...context,
+              migrationOptions: options.migrationOptions
+            }
+          });
+        if (_optionalChain([options, 'access', _100 => _100.hooks, 'optionalAccess', _101 => _101.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]),
       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)]);