@event-driven-io/emmett-postgresql 0.40.1 → 0.41.0-alpha.2

package/dist/index.cjs

@@ -1487,15 +1487,33 @@ var schemaSQL = [
   addDefaultPartitionSQL,
   storeSubscriptionCheckpointSQL
 ];
-var createEventStoreSchema = async (pool) => {
-  await pool.withTransaction(({ execute }) => execute.batchCommand(schemaSQL));
+var createEventStoreSchema = async (connectionString, pool, hooks) => {
+  await pool.withTransaction(async (tx) => {
+    const client = await tx.connection.open();
+    const context = {
+      execute: tx.execute,
+      connection: {
+        connectionString,
+        client,
+        transaction: tx,
+        pool
+      }
+    };
+    if (_optionalChain([hooks, 'optionalAccess', _44 => _44.onBeforeSchemaCreated])) {
+      await hooks.onBeforeSchemaCreated(context);
+    }
+    await context.execute.batchCommand(schemaSQL);
+  });
+  if (_optionalChain([hooks, 'optionalAccess', _45 => _45.onAfterSchemaCreated])) {
+    await hooks.onAfterSchemaCreated();
+  }
 };
 
 // src/eventStore/consumers/postgreSQLProcessor.ts
 var postgreSQLCheckpointer = () => ({
   read: async (options, context) => {
     const result = await readProcessorCheckpoint(context.execute, options);
-    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _44 => _44.lastProcessedPosition]) };
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _46 => _46.lastProcessedPosition]) };
   },
   store: async (options, context) => {
     const newPosition = getCheckpoint(options.message);
@@ -1513,13 +1531,13 @@ var postgreSQLProcessingScope = (options) => {
   const processorConnectionString = options.connectionString;
   const processorPool = options.pool;
   const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _45 => _45.connection]);
-    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _46 => _46.connectionString])));
+    const connection = _optionalChain([partialContext, 'optionalAccess', _47 => _47.connection]);
+    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _48 => _48.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', _47 => _47.pool]) : processorPool), () => ( processorPool));
+    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _49 => _49.pool]) : processorPool), () => ( processorPool));
     if (!pool)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
@@ -1558,9 +1576,14 @@ var getProcessorPool = (options) => {
 var postgreSQLProjector = (options) => {
   const { pool, connectionString, close } = getProcessorPool(options);
   const hooks = {
-    onStart: _optionalChain([options, 'access', _48 => _48.hooks, 'optionalAccess', _49 => _49.onStart]),
-    onClose: _optionalChain([options, 'access', _50 => _50.hooks, 'optionalAccess', _51 => _51.onClose]) || close ? async () => {
-      if (_optionalChain([options, 'access', _52 => _52.hooks, 'optionalAccess', _53 => _53.onClose])) await _optionalChain([options, 'access', _54 => _54.hooks, 'optionalAccess', _55 => _55.onClose, 'call', _56 => _56()]);
+    onStart: async (context) => {
+      if (_optionalChain([options, 'access', _50 => _50.hooks, 'optionalAccess', _51 => _51.onStart])) await options.hooks.onStart(context);
+      if (options.projection.init) {
+        await options.projection.init(context);
+      }
+    },
+    onClose: _optionalChain([options, 'access', _52 => _52.hooks, 'optionalAccess', _53 => _53.onClose]) || close ? async () => {
+      if (_optionalChain([options, 'access', _54 => _54.hooks, 'optionalAccess', _55 => _55.onClose])) await _optionalChain([options, 'access', _56 => _56.hooks, 'optionalAccess', _57 => _57.onClose, 'call', _58 => _58()]);
       if (close) await close();
     } : void 0
   };
@@ -1578,9 +1601,9 @@ var postgreSQLProjector = (options) => {
 var postgreSQLReactor = (options) => {
   const { pool, connectionString, close } = getProcessorPool(options);
   const hooks = {
-    onStart: _optionalChain([options, 'access', _57 => _57.hooks, 'optionalAccess', _58 => _58.onStart]),
-    onClose: _optionalChain([options, 'access', _59 => _59.hooks, 'optionalAccess', _60 => _60.onClose]) || close ? async () => {
-      if (_optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onClose])) await _optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onClose, 'call', _65 => _65()]);
+    onStart: _optionalChain([options, 'access', _59 => _59.hooks, 'optionalAccess', _60 => _60.onStart]),
+    onClose: _optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onClose]) || close ? async () => {
+      if (_optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onClose])) await _optionalChain([options, 'access', _65 => _65.hooks, 'optionalAccess', _66 => _66.onClose, 'call', _67 => _67()]);
       if (close) await close();
     } : void 0
   };
@@ -1630,7 +1653,7 @@ var postgreSQLEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _66 => _66.value, 'optionalAccess', _67 => _67.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _68 => _68.value, 'optionalAccess', _69 => _69.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -1639,8 +1662,8 @@ var postgreSQLEventStoreConsumer = (options) => {
     stopWhen: options.stopWhen,
     executor: pool.execute,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _68 => _68.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _69 => _69.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _70 => _70.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _71 => _71.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs))
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -1799,6 +1822,15 @@ var pongoMultiStreamProjection = (options) => {
         connectionOptions: { client, pool }
       });
       await pongo.db().collection(collectionName).deleteMany();
+    },
+    init: async (context) => {
+      const {
+        connection: { connectionString, client, pool }
+      } = context;
+      const pongo = _pongo.pongoClient.call(void 0, connectionString, {
+        connectionOptions: { client, pool }
+      });
+      await pongo.db().collection(collectionName).schema.migrate();
     }
   });
 };
@@ -1961,7 +1993,7 @@ var PostgreSQLProjectionSpec = {
             const allEvents = [];
             const run = async (pool) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _70 => _70.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _72 => _72.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -2018,18 +2050,18 @@ var PostgreSQLProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _71 => _71.toString, 'call', _72 => _72()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _73 => _73.toString, 'call', _74 => _74()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _73 => _73.toString, 'call', _74 => _74()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _75 => _75.toString, 'call', _76 => _76()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _75 => _75.toString, 'call', _76 => _76()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _77 => _77.toString, 'call', _78 => _78()])}`
                     );
                   }
                 } finally {
@@ -2048,7 +2080,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _77 => _77.metadata, 'optionalAccess', _78 => _78.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _79 => _79.metadata, 'optionalAccess', _80 => _80.streamName]), () => ( streamName))
     }
   };
 };
@@ -2094,23 +2126,39 @@ var handleProjections = async (options) => {
   }
 };
 var postgreSQLProjection = (definition) => projection(definition);
-var postgreSQLRawBatchSQLProjection = (handle, ...canHandle) => postgreSQLProjection({
-  canHandle,
+var postgreSQLRawBatchSQLProjection = (options) => postgreSQLProjection({
+  canHandle: options.canHandle,
   handle: async (events, context) => {
-    const sqls = await handle(events, context);
+    const sqls = await options.evolve(events, context);
     await context.execute.batchCommand(sqls);
+  },
+  init: async (context) => {
+    if (options.init) {
+      await options.init(context);
+    }
+    if (options.initSQL) {
+      await context.execute.command(options.initSQL);
+    }
   }
 });
-var postgreSQLRawSQLProjection = (handle, ...canHandle) => postgreSQLRawBatchSQLProjection(
-  async (events, context) => {
-    const sqls = [];
-    for (const event of events) {
-      sqls.push(await handle(event, context));
+var postgreSQLRawSQLProjection = (options) => {
+  const { evolve, ...rest } = options;
+  return postgreSQLRawBatchSQLProjection({
+    ...rest,
+    evolve: async (events, context) => {
+      const sqls = [];
+      for (const event of events) {
+        const pendingSqls = await evolve(event, context);
+        if (Array.isArray(pendingSqls)) {
+          sqls.push(...pendingSqls);
+        } else {
+          sqls.push(pendingSqls);
+        }
+      }
+      return sqls;
     }
-    return sqls;
-  },
-  ...canHandle
-);
+  });
+};
 
 // src/eventStore/postgreSQLEventStore.ts
 var defaultPostgreSQLOptions = {
@@ -2125,19 +2173,30 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
   };
   const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
   let migrateSchema = void 0;
-  const autoGenerateSchema = _optionalChain([options, 'access', _79 => _79.schema, 'optionalAccess', _80 => _80.autoMigration]) === void 0 || _optionalChain([options, 'access', _81 => _81.schema, 'optionalAccess', _82 => _82.autoMigration]) !== "None";
-  const ensureSchemaExists = () => {
-    if (!autoGenerateSchema) return Promise.resolve();
+  const autoGenerateSchema = _optionalChain([options, 'access', _81 => _81.schema, 'optionalAccess', _82 => _82.autoMigration]) === void 0 || _optionalChain([options, 'access', _83 => _83.schema, 'optionalAccess', _84 => _84.autoMigration]) !== "None";
+  const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
+  const migrate = async () => {
     if (!migrateSchema) {
-      migrateSchema = createEventStoreSchema(pool).then(async () => {
-        if (_optionalChain([options, 'access', _83 => _83.hooks, 'optionalAccess', _84 => _84.onAfterSchemaCreated])) {
-          await options.hooks.onAfterSchemaCreated();
-        }
+      migrateSchema = createEventStoreSchema(connectionString, pool, {
+        onBeforeSchemaCreated: async (context) => {
+          for (const projection2 of inlineProjections) {
+            if (projection2.init) {
+              await projection2.init(context);
+            }
+          }
+          if (_optionalChain([options, 'access', _85 => _85.hooks, 'optionalAccess', _86 => _86.onBeforeSchemaCreated])) {
+            await options.hooks.onBeforeSchemaCreated(context);
+          }
+        },
+        onAfterSchemaCreated: _optionalChain([options, 'access', _87 => _87.hooks, 'optionalAccess', _88 => _88.onAfterSchemaCreated])
       });
     }
     return migrateSchema;
   };
-  const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
+  const ensureSchemaExists = () => {
+    if (!autoGenerateSchema) return Promise.resolve();
+    return migrate();
+  };
   const beforeCommitHook = inlineProjections.length > 0 ? (events, { transaction }) => handleProjections({
     projections: inlineProjections,
     connection: {
@@ -2153,13 +2212,11 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     schema: {
       sql: () => schemaSQL.join(""),
       print: () => console.log(schemaSQL.join("")),
-      migrate: async () => {
-        await (migrateSchema = createEventStoreSchema(pool));
-      }
+      migrate
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _85 => _85.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _89 => _89.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(streamName, options2.read);
       const currentStreamVersion = result.currentStreamVersion;
@@ -2200,7 +2257,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _86 => _86.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _90 => _90.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,