@event-driven-io/emmett-postgresql 0.43.0-beta.1 → 0.43.0-beta.2

package/dist/index.cjs

@@ -53,9 +53,20 @@ var _uuid = require('uuid');
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
+
 var emmettPrefix = "emt";
 var defaultTag = `${emmettPrefix}:default`;
 var unknownTag = `${emmettPrefix}:unknown`;
+var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
+var nulloSessionFactory = (eventStore) => ({
+  withSession: (callback) => {
+    const nulloSession = {
+      eventStore,
+      close: () => Promise.resolve()
+    };
+    return callback(nulloSession);
+  }
+});
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -76,6 +87,10 @@ var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends C
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
+var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
+  error,
+  ExpectedVersionConflictError.Codes.ConcurrencyError
+);
 var isPrimitive = (value) => {
   const type = typeof value;
   return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
@@ -302,6 +317,7 @@ var JSONParser = {
     return _optionalChain([options, 'optionalAccess', _13 => _13.map]) ? options.map(parsed) : parsed;
   }
 };
+var NoRetries = { retries: 0 };
 var asyncRetry = async (fn, opts) => {
   if (opts === void 0 || opts.retries === 0) return fn();
   return _asyncretry2.default.call(void 0, 
@@ -314,12 +330,12 @@ var asyncRetry = async (fn, opts) => {
           );
         }
         return result;
-      } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _15 => _15.shouldRetryError]) && !opts.shouldRetryError(error2)) {
-          bail(error2);
+      } catch (error) {
+        if (_optionalChain([opts, 'optionalAccess', _15 => _15.shouldRetryError]) && !opts.shouldRetryError(error)) {
+          bail(error);
           return void 0;
         }
-        throw error2;
+        throw error;
       }
     },
     _nullishCoalesce(opts, () => ( { retries: 0 }))
@@ -423,6 +439,7 @@ var reactor = (options) => {
     id: processorId,
     instanceId,
     type,
+    canHandle,
     init,
     start: async (startOptions) => {
       if (isActive) return;
@@ -690,6 +707,243 @@ var upcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var projection = (definition) => definition;
+var WorkflowHandlerStreamVersionConflictRetryOptions = {
+  retries: 3,
+  minTimeout: 100,
+  factor: 1.5,
+  shouldRetryError: isExpectedVersionConflictError
+};
+var fromWorkflowHandlerRetryOptions = (retryOptions) => {
+  if (retryOptions === void 0) return NoRetries;
+  if ("onVersionConflict" in retryOptions) {
+    if (typeof retryOptions.onVersionConflict === "boolean")
+      return WorkflowHandlerStreamVersionConflictRetryOptions;
+    else if (typeof retryOptions.onVersionConflict === "number")
+      return {
+        ...WorkflowHandlerStreamVersionConflictRetryOptions,
+        retries: retryOptions.onVersionConflict
+      };
+    else return retryOptions.onVersionConflict;
+  }
+  return retryOptions;
+};
+var emptyHandlerResult = (nextExpectedStreamVersion = 0n) => ({
+  newMessages: [],
+  createdNewStream: false,
+  nextExpectedStreamVersion
+});
+var createInputMetadata = (originalMessageId, action) => ({
+  originalMessageId,
+  input: true,
+  action
+});
+var tagOutputMessage = (msg, action) => {
+  const existingMetadata = "metadata" in msg && msg.metadata ? msg.metadata : {};
+  return {
+    ...msg,
+    metadata: {
+      ...existingMetadata,
+      action
+    }
+  };
+};
+var createWrappedInitialState = (initialState) => {
+  return () => ({
+    userState: initialState(),
+    processedInputIds: /* @__PURE__ */ new Set()
+  });
+};
+var createWrappedEvolve = (evolve, workflowName, separateInputInboxFromProcessing) => {
+  return (state, event2) => {
+    const metadata = event2.metadata;
+    let processedInputIds = state.processedInputIds;
+    if (_optionalChain([metadata, 'optionalAccess', _35 => _35.input]) === true && typeof _optionalChain([metadata, 'optionalAccess', _36 => _36.originalMessageId]) === "string") {
+      processedInputIds = new Set(state.processedInputIds);
+      processedInputIds.add(metadata.originalMessageId);
+    }
+    if (separateInputInboxFromProcessing && _optionalChain([metadata, 'optionalAccess', _37 => _37.input]) === true) {
+      return {
+        userState: state.userState,
+        processedInputIds
+      };
+    }
+    const eventType = event2.type;
+    const eventForEvolve = eventType.startsWith(`${workflowName}:`) ? {
+      ...event2,
+      type: eventType.replace(`${workflowName}:`, "")
+    } : event2;
+    return {
+      userState: evolve(state.userState, eventForEvolve),
+      processedInputIds
+    };
+  };
+};
+var workflowStreamName = ({
+  workflowName,
+  workflowId
+}) => `emt:workflow:${workflowName}:${workflowId}`;
+var WorkflowHandler = (options) => async (store, message2, handleOptions) => asyncRetry(
+  async () => {
+    const result = await withSession2(store, async ({ eventStore }) => {
+      const {
+        workflow: { evolve, initialState, decide, name: workflowName },
+        getWorkflowId: getWorkflowId2
+      } = options;
+      const inputMessageId = (
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        _nullishCoalesce(("metadata" in message2 && _optionalChain([message2, 'access', _38 => _38.metadata, 'optionalAccess', _39 => _39.messageId]) ? (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          message2.metadata.messageId
+        ) : void 0), () => ( _uuid.v7.call(void 0, )))
+      );
+      const messageWithMetadata = {
+        ...message2,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        metadata: {
+          messageId: inputMessageId,
+          ...message2.metadata
+        }
+      };
+      const workflowId = getWorkflowId2(messageWithMetadata);
+      if (!workflowId) {
+        return emptyHandlerResult();
+      }
+      const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({ workflowName, workflowId });
+      const messageType = messageWithMetadata.type;
+      const hasWorkflowPrefix = messageType.startsWith(`${workflowName}:`);
+      if (options.separateInputInboxFromProcessing && !hasWorkflowPrefix) {
+        const inputMetadata2 = createInputMetadata(
+          inputMessageId,
+          "InitiatedBy"
+        );
+        const inputToStore2 = {
+          type: `${workflowName}:${messageWithMetadata.type}`,
+          data: messageWithMetadata.data,
+          kind: messageWithMetadata.kind,
+          metadata: inputMetadata2
+        };
+        const appendResult2 = await eventStore.appendToStream(
+          streamName,
+          [inputToStore2],
+          {
+            ...handleOptions,
+            expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _40 => _40.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          }
+        );
+        return {
+          ...appendResult2,
+          newMessages: []
+        };
+      }
+      const wrappedInitialState = createWrappedInitialState(initialState);
+      const wrappedEvolve = createWrappedEvolve(
+        evolve,
+        workflowName,
+        _nullishCoalesce(options.separateInputInboxFromProcessing, () => ( false))
+      );
+      const aggregationResult = await eventStore.aggregateStream(streamName, {
+        evolve: wrappedEvolve,
+        initialState: wrappedInitialState,
+        read: {
+          ...handleOptions,
+          // expected stream version is passed to fail fast
+          // if stream is in the wrong state
+          expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _41 => _41.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+        }
+      });
+      const { currentStreamVersion } = aggregationResult;
+      const { userState: state, processedInputIds } = aggregationResult.state;
+      if (processedInputIds.has(inputMessageId)) {
+        return emptyHandlerResult(currentStreamVersion);
+      }
+      const messageForDecide = hasWorkflowPrefix ? {
+        ...messageWithMetadata,
+        type: messageType.replace(`${workflowName}:`, "")
+      } : messageWithMetadata;
+      const result2 = decide(messageForDecide, state);
+      const inputMetadata = createInputMetadata(
+        inputMessageId,
+        aggregationResult.streamExists ? "Received" : "InitiatedBy"
+      );
+      const inputToStore = {
+        type: `${workflowName}:${messageWithMetadata.type}`,
+        data: messageWithMetadata.data,
+        kind: messageWithMetadata.kind,
+        metadata: inputMetadata
+      };
+      const outputMessages = (Array.isArray(result2) ? result2 : [result2]).filter((msg) => msg !== void 0 && msg !== null);
+      const outputCommandTypes = _nullishCoalesce(_optionalChain([options, 'access', _42 => _42.outputs, 'optionalAccess', _43 => _43.commands]), () => ( []));
+      const taggedOutputMessages = outputMessages.map((msg) => {
+        const action = outputCommandTypes.includes(
+          msg.type
+        ) ? "Sent" : "Published";
+        return tagOutputMessage(msg, action);
+      });
+      const messagesToAppend = options.separateInputInboxFromProcessing && hasWorkflowPrefix ? [...taggedOutputMessages] : [inputToStore, ...taggedOutputMessages];
+      if (messagesToAppend.length === 0) {
+        return emptyHandlerResult(currentStreamVersion);
+      }
+      const expectedStreamVersion = _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _44 => _44.expectedStreamVersion]), () => ( (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST)));
+      const appendResult = await eventStore.appendToStream(
+        streamName,
+        // TODO: Fix this cast
+        messagesToAppend,
+        {
+          ...handleOptions,
+          expectedStreamVersion
+        }
+      );
+      return {
+        ...appendResult,
+        newMessages: outputMessages
+      };
+    });
+    return result;
+  },
+  fromWorkflowHandlerRetryOptions(
+    handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry
+  )
+);
+var withSession2 = (eventStore, callback) => {
+  const sessionFactory = canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore);
+  return sessionFactory.withSession(callback);
+};
+var getWorkflowId = (options) => `emt:processor:workflow:${options.workflowName}`;
+var workflowProcessor = (options) => {
+  const { workflow, ...rest } = options;
+  const canHandle = options.separateInputInboxFromProcessing ? [
+    ...options.inputs.commands,
+    ...options.inputs.events,
+    ...options.inputs.commands.map((t) => `${workflow.name}:${t}`),
+    ...options.inputs.events.map((t) => `${workflow.name}:${t}`)
+  ] : [...options.inputs.commands, ...options.inputs.events];
+  const handle = WorkflowHandler(options);
+  return reactor({
+    ...rest,
+    processorId: _nullishCoalesce(options.processorId, () => ( getWorkflowId({ workflowName: workflow.name }))),
+    canHandle,
+    type: MessageProcessorType.PROJECTOR,
+    eachMessage: async (message2, context) => {
+      const messageType = message2.type;
+      if (!canHandle.includes(messageType)) return;
+      const result = await handle(
+        context.connection.messageStore,
+        message2,
+        context
+      );
+      if (options.stopAfter && result.newMessages.length > 0) {
+        for (const outputMessage of result.newMessages) {
+          if (options.stopAfter(
+            outputMessage
+          )) {
+            return { type: "STOP", reason: "Stop condition reached" };
+          }
+        }
+      }
+      return;
+    }
+  });
+};
 
 // src/eventStore/schema/readLastMessageGlobalPosition.ts
 var _dumbo = require('@event-driven-io/dumbo');
@@ -736,7 +990,7 @@ var readLastMessageGlobalPosition = async (execute, options) => {
     execute.query(
       _dumbo.SQL`SELECT global_position
            FROM ${_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _35 => _35.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
            ORDER BY transaction_id, global_position
            LIMIT 1`
     )
@@ -760,7 +1014,7 @@ var readMessagesBatch = async (execute, options) => {
       _dumbo.SQL`
           SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
            FROM ${_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _36 => _36.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${fromCondition} ${toCondition}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${fromCondition} ${toCondition}
            ORDER BY transaction_id, global_position
            ${limitCondition}`
     ),
@@ -816,7 +1070,7 @@ var postgreSQLEventStoreMessageBatchPuller = ({
       batchSize
     };
     let waitTime = 100;
-    while (isRunning && !_optionalChain([signal, 'optionalAccess', _37 => _37.aborted])) {
+    while (isRunning && !_optionalChain([signal, 'optionalAccess', _47 => _47.aborted])) {
       const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
       if (messages.length > 0) {
         const result = await eachBatch(messages);
@@ -827,7 +1081,7 @@ var postgreSQLEventStoreMessageBatchPuller = ({
       }
       readMessagesOptions.after = currentGlobalPosition;
       await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (_optionalChain([stopWhen, 'optionalAccess', _38 => _38.noMessagesLeft]) === true && !areMessagesLeft) {
+      if (_optionalChain([stopWhen, 'optionalAccess', _48 => _48.noMessagesLeft]) === true && !areMessagesLeft) {
         isRunning = false;
         break;
       }
@@ -871,6 +1125,14 @@ var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
 // src/eventStore/consumers/postgreSQLProcessor.ts
 
 
+// src/eventStore/postgreSQLEventStore.ts
+
+
+
+
+
+
+
 // src/eventStore/projections/locks/tryAcquireProjectionLock.ts
 
 
@@ -1121,9 +1383,9 @@ var tryAcquireProcessorLock = async (execute, options) => {
         version: options.version,
         partition: options.partition,
         processorInstanceId: options.processorInstanceId,
-        projectionName: _nullishCoalesce(_optionalChain([options, 'access', _39 => _39.projection, 'optionalAccess', _40 => _40.name]), () => ( null)),
-        projectionType: _optionalChain([options, 'access', _41 => _41.projection, 'optionalAccess', _42 => _42.handlingType]) ? options.projection.handlingType === "inline" ? "i" : "a" : null,
-        projectionKind: _nullishCoalesce(_optionalChain([options, 'access', _43 => _43.projection, 'optionalAccess', _44 => _44.kind]), () => ( null)),
+        projectionName: _nullishCoalesce(_optionalChain([options, 'access', _49 => _49.projection, 'optionalAccess', _50 => _50.name]), () => ( null)),
+        projectionType: _optionalChain([options, 'access', _51 => _51.projection, 'optionalAccess', _52 => _52.handlingType]) ? options.projection.handlingType === "inline" ? "i" : "a" : null,
+        projectionKind: _nullishCoalesce(_optionalChain([options, 'access', _53 => _53.projection, 'optionalAccess', _54 => _54.kind]), () => ( null)),
         lockTimeoutSeconds: _nullishCoalesce(options.lockTimeoutSeconds, () => ( PROCESSOR_LOCK_DEFAULT_TIMEOUT_SECONDS))
       })
     )
@@ -1175,7 +1437,7 @@ var postgreSQLProcessorLock = (options) => {
         ...options,
         lockKey
       });
-      if (!result.acquired && _optionalChain([options, 'access', _45 => _45.lockAcquisitionPolicy, 'optionalAccess', _46 => _46.type]) !== "skip") {
+      if (!result.acquired && _optionalChain([options, 'access', _55 => _55.lockAcquisitionPolicy, 'optionalAccess', _56 => _56.type]) !== "skip") {
         throw new EmmettError(
           `Failed to acquire lock for processor '${options.processorId}'`
         );
@@ -1189,7 +1451,7 @@ var postgreSQLProcessorLock = (options) => {
       await releaseProcessorLock(context.execute, {
         ...releaseOptions,
         lockKey,
-        projectionName: _optionalChain([projection2, 'optionalAccess', _47 => _47.name])
+        projectionName: _optionalChain([projection2, 'optionalAccess', _57 => _57.name])
       });
       acquired = false;
     }
@@ -1702,46 +1964,284 @@ var expectPongoDocuments = {
 
 
 
+var PostgreSQLProjectionSpec = {
+  for: (options) => {
+    {
+      const { projection: projection2, ...dumoOptions } = options;
+      const { connectionString } = dumoOptions;
+      let wasInitialised = false;
+      const initialize = async (pool) => {
+        const eventStore = getPostgreSQLEventStore(connectionString, {
+          // TODO: This will need to change when we support other drivers
+          connectionOptions: { dumbo: pool }
+        });
+        if (wasInitialised) return;
+        wasInitialised = true;
+        await eventStore.schema.migrate();
+        if (projection2.init)
+          await pool.withTransaction(async (transaction) => {
+            await projection2.init({
+              registrationType: "async",
+              version: _nullishCoalesce(projection2.version, () => ( 1)),
+              status: "active",
+              context: await transactionToPostgreSQLProjectionHandlerContext(
+                connectionString,
+                pool,
+                transaction
+              )
+            });
+          });
+      };
+      return (givenEvents) => {
+        return {
+          when: (events, options2) => {
+            const allEvents = [];
+            const run = async (pool) => {
+              let globalPosition = 0n;
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _58 => _58.numberOfTimes]), () => ( 1));
+              for (const event of [
+                ...givenEvents,
+                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
+              ]) {
+                const metadata = {
+                  checkpoint: bigIntProcessorCheckpoint(++globalPosition),
+                  globalPosition,
+                  streamPosition: globalPosition,
+                  streamName: `test-${_uuid.v4.call(void 0, )}`,
+                  messageId: _uuid.v4.call(void 0, )
+                };
+                allEvents.push({
+                  ...event,
+                  kind: "Event",
+                  metadata: {
+                    ...metadata,
+                    ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
+                  }
+                });
+              }
+              await initialize(pool);
+              await pool.withTransaction(async (transaction) => {
+                await handleProjections({
+                  events: allEvents,
+                  projections: [projection2],
+                  ...await transactionToPostgreSQLProjectionHandlerContext(
+                    connectionString,
+                    pool,
+                    transaction
+                  )
+                });
+              });
+            };
+            return {
+              then: async (assert, message) => {
+                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
+                try {
+                  await run(pool);
+                  const succeeded = await assert({ pool, connectionString });
+                  if (succeeded !== void 0 && succeeded === false)
+                    assertFails(
+                      _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
+                    );
+                } finally {
+                  await pool.close();
+                }
+              },
+              thenThrows: async (...args) => {
+                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
+                try {
+                  await run(pool);
+                  throw new AssertionError("Handler did not fail as expected");
+                } catch (error) {
+                  if (error instanceof AssertionError) throw error;
+                  if (args.length === 0) return;
+                  if (!isErrorConstructor(args[0])) {
+                    assertTrue(
+                      args[0](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _59 => _59.toString, 'call', _60 => _60()])}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _61 => _61.toString, 'call', _62 => _62()])}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _63 => _63.toString, 'call', _64 => _64()])}`
+                    );
+                  }
+                } finally {
+                  await pool.close();
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+var eventInStream = (streamName, event) => {
+  return {
+    ...event,
+    metadata: {
+      ..._nullishCoalesce(event.metadata, () => ( {})),
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _65 => _65.metadata, 'optionalAccess', _66 => _66.streamName]), () => ( streamName))
+    }
+  };
+};
+var eventsInStream = (streamName, events) => {
+  return events.map((e) => eventInStream(streamName, e));
+};
+var newEventsInStream = eventsInStream;
+var assertSQLQueryResultMatches = (sql, rows) => async ({ pool: { execute } }) => {
+  const result = await execute.query(sql);
+  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
+};
+var expectSQL = {
+  query: (sql) => ({
+    resultRows: {
+      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows)
+    }
+  })
+};
 
-// src/eventStore/postgreSQLEventStore.ts
-
-
-
-
-
-
-
-// src/eventStore/schema/index.ts
-
-
-
-
-
-
-// src/eventStore/schema/appendToStream.ts
-
-
-
-
-
-
-
-var appendToStreamSQL = createFunctionIfDoesNotExistSQL(
-  "emt_append_to_stream",
-  _dumbo.SQL`CREATE OR REPLACE FUNCTION emt_append_to_stream(
-      v_message_ids text[],
-      v_messages_data jsonb[],
-      v_messages_metadata jsonb[],
-      v_message_schema_versions text[],
-      v_message_types text[],
-      v_message_kinds text[],
-      v_stream_id text,
-      v_stream_type text,
-      v_expected_stream_position bigint DEFAULT NULL,
-      v_partition text DEFAULT emt_sanitize_name('default_partition')
-  ) RETURNS TABLE (
-      success boolean,
-      next_stream_position bigint,
+// src/eventStore/projections/postgreSQLProjection.ts
+var transactionToPostgreSQLProjectionHandlerContext = async (connectionString, pool, transaction) => ({
+  execute: transaction.execute,
+  connection: {
+    connectionString,
+    client: await transaction.connection.open(),
+    transaction,
+    pool
+  }
+});
+var handleProjections = async (options) => {
+  const {
+    projections: allProjections,
+    events,
+    connection: { pool, transaction, connectionString },
+    partition = defaultTag2
+  } = options;
+  const eventTypes = events.map((e) => e.type);
+  const projections = allProjections.filter(
+    (p) => p.canHandle.some((type) => eventTypes.includes(type))
+  );
+  const client = await transaction.connection.open();
+  for (const projection2 of projections) {
+    if (projection2.name) {
+      const lockAcquired = await postgreSQLProjectionLock({
+        projectionName: projection2.name,
+        partition,
+        version: _nullishCoalesce(projection2.version, () => ( 1))
+      }).tryAcquire({ execute: transaction.execute });
+      if (!lockAcquired) {
+        continue;
+      }
+    }
+    await projection2.handle(events, {
+      connection: {
+        connectionString,
+        pool,
+        client,
+        transaction
+      },
+      execute: transaction.execute
+    });
+  }
+};
+var postgreSQLProjection = (definition) => projection({
+  ...definition,
+  init: async (options) => {
+    await registerProjection(options.context.execute, {
+      // TODO: pass partition from options
+      partition: defaultTag2,
+      status: "active",
+      registration: {
+        type: "async",
+        // TODO: fix this
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+        projection: definition
+      }
+    });
+    if (definition.init) {
+      await definition.init(options);
+    }
+  }
+});
+var postgreSQLRawBatchSQLProjection = (options) => postgreSQLProjection({
+  name: options.name,
+  kind: _nullishCoalesce(options.kind, () => ( "emt:projections:postgresql:raw_sql:batch")),
+  version: options.version,
+  canHandle: options.canHandle,
+  eventsOptions: options.eventsOptions,
+  handle: async (events, context) => {
+    const sqls = await options.evolve(events, context);
+    await context.execute.batchCommand(sqls);
+  },
+  init: async (initOptions) => {
+    const initSQL = options.init ? await options.init(initOptions) : void 0;
+    if (initSQL) {
+      if (Array.isArray(initSQL)) {
+        await initOptions.context.execute.batchCommand(initSQL);
+      } else {
+        await initOptions.context.execute.command(initSQL);
+      }
+    }
+  }
+});
+var postgreSQLRawSQLProjection = (options) => {
+  const { evolve, kind, ...rest } = options;
+  return postgreSQLRawBatchSQLProjection({
+    kind: _nullishCoalesce(kind, () => ( "emt:projections:postgresql:raw:_sql:single")),
+    ...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;
+    }
+  });
+};
+
+// src/eventStore/schema/index.ts
+
+
+
+
+
+
+// src/eventStore/schema/appendToStream.ts
+
+
+
+
+
+
+
+var appendToStreamSQL = createFunctionIfDoesNotExistSQL(
+  "emt_append_to_stream",
+  _dumbo.SQL`CREATE OR REPLACE FUNCTION emt_append_to_stream(
+      v_message_ids text[],
+      v_messages_data jsonb[],
+      v_messages_metadata jsonb[],
+      v_message_schema_versions text[],
+      v_message_types text[],
+      v_message_kinds text[],
+      v_stream_id text,
+      v_stream_type text,
+      v_expected_stream_position bigint DEFAULT NULL,
+      v_partition text DEFAULT emt_sanitize_name('default_partition')
+  ) RETURNS TABLE (
+      success boolean,
+      next_stream_position bigint,
       global_positions bigint[],
       transaction_id xid8
   ) LANGUAGE plpgsql
@@ -1838,7 +2338,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
     return { success: false, result: { success: false } };
   try {
     const expectedStreamVersion = toExpectedVersion(
-      _optionalChain([options, 'optionalAccess', _48 => _48.expectedStreamVersion])
+      _optionalChain([options, 'optionalAccess', _67 => _67.expectedStreamVersion])
     );
     const messagesToAppend = messages.map((e) => ({
       ...e,
@@ -1878,7 +2378,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
         globalPosition
       };
     });
-    if (_optionalChain([options, 'optionalAccess', _49 => _49.beforeCommitHook]))
+    if (_optionalChain([options, 'optionalAccess', _68 => _68.beforeCommitHook]))
       await options.beforeCommitHook(messagesToAppend, { transaction });
     return {
       success: true,
@@ -1921,8 +2421,8 @@ var appendEventsRaw = (execute, streamId, streamType, messages, options) => _dum
       messageKinds: messages.map((e) => e.kind === "Event" ? "E" : "C"),
       streamId,
       streamType,
-      expectedStreamPosition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _50 => _50.expectedStreamVersion]), () => ( null)),
-      partition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.partition]), () => ( defaultTag2))
+      expectedStreamPosition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _69 => _69.expectedStreamVersion]), () => ( null)),
+      partition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.partition]), () => ( defaultTag2))
     })
   )
 );
@@ -3984,7 +4484,7 @@ var readProcessorCheckpoint = async (execute, options) => {
     execute.query(
       _dumbo.SQL`SELECT last_processed_checkpoint
            FROM ${_dumbo.SQL.identifier(processorsTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId} AND version = ${_nullishCoalesce(options.version, () => ( 1))}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _71 => _71.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId} AND version = ${_nullishCoalesce(options.version, () => ( 1))}
            LIMIT 1`
     )
   );
@@ -3996,16 +4496,16 @@ var readProcessorCheckpoint = async (execute, options) => {
 // src/eventStore/schema/readStream.ts
 
 var readStream = async (execute, streamId, options) => {
-  const fromCondition = _optionalChain([options, 'optionalAccess', _53 => _53.from]) ? `AND stream_position >= ${options.from}` : "";
+  const fromCondition = _optionalChain([options, 'optionalAccess', _72 => _72.from]) ? `AND stream_position >= ${options.from}` : "";
   const to = Number(
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.to]), () => ( (_optionalChain([options, 'optionalAccess', _55 => _55.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _73 => _73.to]), () => ( (_optionalChain([options, 'optionalAccess', _74 => _74.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
   );
   const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
   const events = await _dumbo.mapRows.call(void 0, 
     execute.query(
       _dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
            FROM ${_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _56 => _56.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${_dumbo.SQL.plain(fromCondition)} ${_dumbo.SQL.plain(toCondition)}
+           WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _75 => _75.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${_dumbo.SQL.plain(fromCondition)} ${_dumbo.SQL.plain(toCondition)}
            ORDER BY stream_position ASC`
     ),
     (row) => {
@@ -4027,7 +4527,7 @@ var readStream = async (execute, streamId, options) => {
         kind: "Event",
         metadata
       };
-      return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _57 => _57.schema, 'optionalAccess', _58 => _58.versioning]));
+      return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _76 => _76.schema, 'optionalAccess', _77 => _77.versioning]));
     }
   );
   return events.length > 0 ? {
@@ -4048,10 +4548,10 @@ var streamExists = async (execute, streamId, options) => {
     _dumbo.SQL`SELECT EXISTS (
         SELECT 1
         from ${_dumbo.SQL.identifier(streamsTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _59 => _59.partition]), () => ( defaultTag2))} AND is_archived = FALSE)
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _78 => _78.partition]), () => ( defaultTag2))} AND is_archived = FALSE)
       `
   );
-  return _nullishCoalesce(_optionalChain([queryResult, 'access', _60 => _60.rows, 'access', _61 => _61[0], 'optionalAccess', _62 => _62.exists]), () => ( false));
+  return _nullishCoalesce(_optionalChain([queryResult, 'access', _79 => _79.rows, 'access', _80 => _80[0], 'optionalAccess', _81 => _81.exists]), () => ( false));
 };
 
 // src/eventStore/schema/index.ts
@@ -4091,7 +4591,7 @@ var createEventStoreSchema = (connectionString, pool, hooks, options) => {
     );
     const nestedPool = _dumbo.dumbo.call(void 0, { connectionString, connection: tx.connection });
     try {
-      if (_optionalChain([hooks, 'optionalAccess', _63 => _63.onBeforeSchemaCreated])) {
+      if (_optionalChain([hooks, 'optionalAccess', _82 => _82.onBeforeSchemaCreated])) {
         await hooks.onBeforeSchemaCreated(context);
       }
       const result = await _dumbo.runSQLMigrations.call(void 0, 
@@ -4099,7 +4599,7 @@ var createEventStoreSchema = (connectionString, pool, hooks, options) => {
         eventStoreSchemaMigrations,
         options
       );
-      if (_optionalChain([hooks, 'optionalAccess', _64 => _64.onAfterSchemaCreated])) {
+      if (_optionalChain([hooks, 'optionalAccess', _83 => _83.onAfterSchemaCreated])) {
         await hooks.onAfterSchemaCreated(context);
       }
       return result;
@@ -4118,7 +4618,7 @@ var truncateTables = async (execute, options) => {
         ${_dumbo.SQL.identifier(messagesTable.name)}, 
         ${_dumbo.SQL.identifier(processorsTable.name)}, 
         ${_dumbo.SQL.identifier(projectionsTable.name)} 
-        CASCADE${_dumbo.SQL.plain(_optionalChain([options, 'optionalAccess', _65 => _65.resetSequences]) ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : "")};`
+        CASCADE${_dumbo.SQL.plain(_optionalChain([options, 'optionalAccess', _84 => _84.resetSequences]) ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : "")};`
   );
 };
 
@@ -4135,7 +4635,7 @@ 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', _66 => _66.schema, 'optionalAccess', _67 => _67.autoMigration]) === void 0 || _optionalChain([options, 'access', _68 => _68.schema, 'optionalAccess', _69 => _69.autoMigration]) !== "None";
+  const autoGenerateSchema = _optionalChain([options, 'access', _85 => _85.schema, 'optionalAccess', _86 => _86.autoMigration]) === void 0 || _optionalChain([options, 'access', _87 => _87.schema, 'optionalAccess', _88 => _88.autoMigration]) !== "None";
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
   const migrate = async (migrationOptions) => {
     if (!migrateSchema) {
@@ -4144,7 +4644,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         pool,
         {
           onBeforeSchemaCreated: async (context) => {
-            if (_optionalChain([options, 'access', _70 => _70.hooks, 'optionalAccess', _71 => _71.onBeforeSchemaCreated])) {
+            if (_optionalChain([options, 'access', _89 => _89.hooks, 'optionalAccess', _90 => _90.onBeforeSchemaCreated])) {
               await options.hooks.onBeforeSchemaCreated(context);
             }
           },
@@ -4159,7 +4659,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
                 });
               }
             }
-            if (_optionalChain([options, 'access', _72 => _72.hooks, 'optionalAccess', _73 => _73.onAfterSchemaCreated])) {
+            if (_optionalChain([options, 'access', _91 => _91.hooks, 'optionalAccess', _92 => _92.onAfterSchemaCreated])) {
               await options.hooks.onAfterSchemaCreated(context);
             }
           }
@@ -4201,13 +4701,13 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         truncate: (truncateOptions) => pool.withTransaction(async (transaction) => {
           await ensureSchemaExists();
           await truncateTables(transaction.execute, truncateOptions);
-          if (_optionalChain([truncateOptions, 'optionalAccess', _74 => _74.truncateProjections])) {
+          if (_optionalChain([truncateOptions, 'optionalAccess', _93 => _93.truncateProjections])) {
             const projectionContext = await transactionToPostgreSQLProjectionHandlerContext(
               connectionString,
               pool,
               transaction
             );
-            for (const projection2 of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _75 => _75.projections]), () => ( []))) {
+            for (const projection2 of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _94 => _94.projections]), () => ( []))) {
               if (projection2.projection.truncate)
                 await projection2.projection.truncate(projectionContext);
             }
@@ -4217,7 +4717,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _76 => _76.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _95 => _95.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(
         streamName,
@@ -4256,7 +4756,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         pool,
         streamName,
         streamType,
-        downcastRecordedMessages(events, _optionalChain([options2, 'optionalAccess', _77 => _77.schema, 'optionalAccess', _78 => _78.versioning])),
+        downcastRecordedMessages(events, _optionalChain([options2, 'optionalAccess', _96 => _96.schema, 'optionalAccess', _97 => _97.versioning])),
         {
           ...options2,
           beforeCommitHook
@@ -4266,7 +4766,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _79 => _79.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _98 => _98.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -4311,259 +4811,11 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
   };
 };
 
-// src/eventStore/projections/postgresProjectionSpec.ts
-var PostgreSQLProjectionSpec = {
-  for: (options) => {
-    {
-      const { projection: projection2, ...dumoOptions } = options;
-      const { connectionString } = dumoOptions;
-      let wasInitialised = false;
-      const initialize = async (pool) => {
-        const eventStore = getPostgreSQLEventStore(connectionString, {
-          // TODO: This will need to change when we support other drivers
-          connectionOptions: { dumbo: pool }
-        });
-        if (wasInitialised) return;
-        wasInitialised = true;
-        await eventStore.schema.migrate();
-        if (projection2.init)
-          await pool.withTransaction(async (transaction) => {
-            await projection2.init({
-              registrationType: "async",
-              version: _nullishCoalesce(projection2.version, () => ( 1)),
-              status: "active",
-              context: await transactionToPostgreSQLProjectionHandlerContext(
-                connectionString,
-                pool,
-                transaction
-              )
-            });
-          });
-      };
-      return (givenEvents) => {
-        return {
-          when: (events, options2) => {
-            const allEvents = [];
-            const run = async (pool) => {
-              let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _80 => _80.numberOfTimes]), () => ( 1));
-              for (const event of [
-                ...givenEvents,
-                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
-              ]) {
-                const metadata = {
-                  checkpoint: bigIntProcessorCheckpoint(++globalPosition),
-                  globalPosition,
-                  streamPosition: globalPosition,
-                  streamName: `test-${_uuid.v4.call(void 0, )}`,
-                  messageId: _uuid.v4.call(void 0, )
-                };
-                allEvents.push({
-                  ...event,
-                  kind: "Event",
-                  metadata: {
-                    ...metadata,
-                    ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
-                  }
-                });
-              }
-              await initialize(pool);
-              await pool.withTransaction(async (transaction) => {
-                await handleProjections({
-                  events: allEvents,
-                  projections: [projection2],
-                  ...await transactionToPostgreSQLProjectionHandlerContext(
-                    connectionString,
-                    pool,
-                    transaction
-                  )
-                });
-              });
-            };
-            return {
-              then: async (assert, message) => {
-                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
-                try {
-                  await run(pool);
-                  const succeeded = await assert({ pool, connectionString });
-                  if (succeeded !== void 0 && succeeded === false)
-                    assertFails(
-                      _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
-                    );
-                } finally {
-                  await pool.close();
-                }
-              },
-              thenThrows: async (...args) => {
-                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
-                try {
-                  await run(pool);
-                  throw new AssertionError("Handler did not fail as expected");
-                } catch (error) {
-                  if (error instanceof AssertionError) throw error;
-                  if (args.length === 0) return;
-                  if (!isErrorConstructor(args[0])) {
-                    assertTrue(
-                      args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _81 => _81.toString, 'call', _82 => _82()])}`
-                    );
-                    return;
-                  }
-                  assertTrue(
-                    error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _83 => _83.toString, 'call', _84 => _84()])}`
-                  );
-                  if (args[1]) {
-                    assertTrue(
-                      args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _85 => _85.toString, 'call', _86 => _86()])}`
-                    );
-                  }
-                } finally {
-                  await pool.close();
-                }
-              }
-            };
-          }
-        };
-      };
-    }
-  }
-};
-var eventInStream = (streamName, event) => {
-  return {
-    ...event,
-    metadata: {
-      ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _87 => _87.metadata, 'optionalAccess', _88 => _88.streamName]), () => ( streamName))
-    }
-  };
-};
-var eventsInStream = (streamName, events) => {
-  return events.map((e) => eventInStream(streamName, e));
-};
-var newEventsInStream = eventsInStream;
-var assertSQLQueryResultMatches = (sql, rows) => async ({ pool: { execute } }) => {
-  const result = await execute.query(sql);
-  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
-};
-var expectSQL = {
-  query: (sql) => ({
-    resultRows: {
-      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows)
-    }
-  })
-};
-
-// src/eventStore/projections/postgreSQLProjection.ts
-var transactionToPostgreSQLProjectionHandlerContext = async (connectionString, pool, transaction) => ({
-  execute: transaction.execute,
-  connection: {
-    connectionString,
-    client: await transaction.connection.open(),
-    transaction,
-    pool
-  }
-});
-var handleProjections = async (options) => {
-  const {
-    projections: allProjections,
-    events,
-    connection: { pool, transaction, connectionString },
-    partition = defaultTag2
-  } = options;
-  const eventTypes = events.map((e) => e.type);
-  const projections = allProjections.filter(
-    (p) => p.canHandle.some((type) => eventTypes.includes(type))
-  );
-  const client = await transaction.connection.open();
-  for (const projection2 of projections) {
-    if (projection2.name) {
-      const lockAcquired = await postgreSQLProjectionLock({
-        projectionName: projection2.name,
-        partition,
-        version: _nullishCoalesce(projection2.version, () => ( 1))
-      }).tryAcquire({ execute: transaction.execute });
-      if (!lockAcquired) {
-        continue;
-      }
-    }
-    await projection2.handle(events, {
-      connection: {
-        connectionString,
-        pool,
-        client,
-        transaction
-      },
-      execute: transaction.execute
-    });
-  }
-};
-var postgreSQLProjection = (definition) => projection({
-  ...definition,
-  init: async (options) => {
-    await registerProjection(options.context.execute, {
-      // TODO: pass partition from options
-      partition: defaultTag2,
-      status: "active",
-      registration: {
-        type: "async",
-        // TODO: fix this
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-        projection: definition
-      }
-    });
-    if (definition.init) {
-      await definition.init(options);
-    }
-  }
-});
-var postgreSQLRawBatchSQLProjection = (options) => postgreSQLProjection({
-  name: options.name,
-  kind: _nullishCoalesce(options.kind, () => ( "emt:projections:postgresql:raw_sql:batch")),
-  version: options.version,
-  canHandle: options.canHandle,
-  eventsOptions: options.eventsOptions,
-  handle: async (events, context) => {
-    const sqls = await options.evolve(events, context);
-    await context.execute.batchCommand(sqls);
-  },
-  init: async (initOptions) => {
-    const initSQL = options.init ? await options.init(initOptions) : void 0;
-    if (initSQL) {
-      if (Array.isArray(initSQL)) {
-        await initOptions.context.execute.batchCommand(initSQL);
-      } else {
-        await initOptions.context.execute.command(initSQL);
-      }
-    }
-  }
-});
-var postgreSQLRawSQLProjection = (options) => {
-  const { evolve, kind, ...rest } = options;
-  return postgreSQLRawBatchSQLProjection({
-    kind: _nullishCoalesce(kind, () => ( "emt:projections:postgresql:raw:_sql:single")),
-    ...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;
-    }
-  });
-};
-
 // src/eventStore/consumers/postgreSQLProcessor.ts
 var postgreSQLCheckpointer = () => ({
   read: async (options, context) => {
     const result = await readProcessorCheckpoint(context.execute, options);
-    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _89 => _89.lastProcessedCheckpoint]) };
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _99 => _99.lastProcessedCheckpoint]) };
   },
   store: async (options, context) => {
     const newCheckpoint = getCheckpoint(options.message);
@@ -4581,13 +4833,13 @@ var postgreSQLProcessingScope = (options) => {
   const processorConnectionString = options.connectionString;
   const processorPool = options.pool;
   const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _90 => _90.connection]);
-    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _91 => _91.connectionString])));
+    const connection = _optionalChain([partialContext, 'optionalAccess', _100 => _100.connection]);
+    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _101 => _101.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', _92 => _92.pool]) : processorPool), () => ( processorPool));
+    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _102 => _102.pool]) : processorPool), () => ( processorPool));
     if (!pool)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
@@ -4602,7 +4854,10 @@ var postgreSQLProcessingScope = (options) => {
           connectionString,
           pool,
           client,
-          transaction
+          transaction,
+          messageStore: getPostgreSQLEventStore(connectionString, {
+            connectionOptions: { client }
+          })
         }
       });
     });
@@ -4628,11 +4883,11 @@ var wrapHooksWithProcessorLocks = (hooks, processorLock) => ({
   ..._nullishCoalesce(hooks, () => ( {})),
   onStart: async (context) => {
     await processorLock.tryAcquire({ execute: context.execute });
-    if (_optionalChain([hooks, 'optionalAccess', _93 => _93.onStart])) await hooks.onStart(context);
+    if (_optionalChain([hooks, 'optionalAccess', _103 => _103.onStart])) await hooks.onStart(context);
   },
-  onClose: _optionalChain([hooks, 'optionalAccess', _94 => _94.onClose]) || processorLock ? async (context) => {
+  onClose: _optionalChain([hooks, 'optionalAccess', _104 => _104.onClose]) || processorLock ? async (context) => {
     await processorLock.release({ execute: context.execute });
-    if (_optionalChain([hooks, 'optionalAccess', _95 => _95.onClose])) await hooks.onClose(context);
+    if (_optionalChain([hooks, 'optionalAccess', _105 => _105.onClose])) await hooks.onClose(context);
   } : void 0
 });
 var postgreSQLProjector = (options) => {
@@ -4657,13 +4912,13 @@ var postgreSQLProjector = (options) => {
       version: _nullishCoalesce(options.projection.version, () => ( version)),
       handlingType: "async"
     } : void 0,
-    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _96 => _96.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
-    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _97 => _97.timeoutSeconds])
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _106 => _106.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _107 => _107.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', _108 => _108.hooks, 'optionalAccess', _109 => _109.onInit]) ? async (context) => {
         if (options.projection.init)
           await options.projection.init({
             version: _nullishCoalesce(options.projection.version, () => ( version)),
@@ -4674,16 +4929,16 @@ var postgreSQLProjector = (options) => {
               migrationOptions: options.migrationOptions
             }
           });
-        if (_optionalChain([options, 'access', _100 => _100.hooks, 'optionalAccess', _101 => _101.onInit]))
+        if (_optionalChain([options, 'access', _110 => _110.hooks, 'optionalAccess', _111 => _111.onInit]))
           await options.hooks.onInit({
             ...context,
             migrationOptions: options.migrationOptions
           });
-      } : _optionalChain([options, 'access', _102 => _102.hooks, 'optionalAccess', _103 => _103.onInit]),
+      } : _optionalChain([options, 'access', _112 => _112.hooks, 'optionalAccess', _113 => _113.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', _114 => _114.hooks, 'optionalAccess', _115 => _115.onClose])) await _optionalChain([options, 'access', _116 => _116.hooks, 'optionalAccess', _117 => _117.onClose, 'call', _118 => _118(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _109 => _109.hooks, 'optionalAccess', _110 => _110.onClose])
+      } : _optionalChain([options, 'access', _119 => _119.hooks, 'optionalAccess', _120 => _120.onClose])
     },
     processorLock
   );
@@ -4704,6 +4959,53 @@ var postgreSQLProjector = (options) => {
   });
   return processor;
 };
+var postgreSQLWorkflowProcessor = (options) => {
+  const {
+    processorId = _nullishCoalesce(options.processorId, () => ( getWorkflowId({
+      workflowName: _nullishCoalesce(options.workflow.name, () => ( "unknown"))
+    }))),
+    processorInstanceId = getProcessorInstanceId(processorId),
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition,
+    lock
+  } = options;
+  const { pool, connectionString, close } = getProcessorPool(options);
+  const processorLock = postgreSQLProcessorLock({
+    processorId,
+    version,
+    partition,
+    processorInstanceId,
+    projection: void 0,
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _121 => _121.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _122 => _122.timeoutSeconds])
+  });
+  const hooks = wrapHooksWithProcessorLocks(
+    {
+      ..._nullishCoalesce(options.hooks, () => ( {})),
+      onClose: close ? async (context) => {
+        if (_optionalChain([options, 'access', _123 => _123.hooks, 'optionalAccess', _124 => _124.onClose]))
+          await _optionalChain([options, 'access', _125 => _125.hooks, 'optionalAccess', _126 => _126.onClose, 'call', _127 => _127(context)]);
+        if (close) await close();
+      } : _optionalChain([options, 'access', _128 => _128.hooks, 'optionalAccess', _129 => _129.onClose])
+    },
+    processorLock
+  );
+  return workflowProcessor({
+    ...options,
+    processorId,
+    processorInstanceId,
+    version,
+    partition,
+    hooks,
+    processingScope: postgreSQLProcessingScope({
+      pool,
+      connectionString,
+      processorId,
+      partition
+    }),
+    checkpoints: postgreSQLCheckpointer()
+  });
+};
 var postgreSQLReactor = (options) => {
   const {
     processorId = options.processorId,
@@ -4719,16 +5021,16 @@ var postgreSQLReactor = (options) => {
     partition,
     processorInstanceId,
     projection: void 0,
-    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _111 => _111.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
-    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _112 => _112.timeoutSeconds])
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _130 => _130.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _131 => _131.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _113 => _113.hooks, 'optionalAccess', _114 => _114.onClose])) await _optionalChain([options, 'access', _115 => _115.hooks, 'optionalAccess', _116 => _116.onClose, 'call', _117 => _117(context)]);
+        if (_optionalChain([options, 'access', _132 => _132.hooks, 'optionalAccess', _133 => _133.onClose])) await _optionalChain([options, 'access', _134 => _134.hooks, 'optionalAccess', _135 => _135.onClose, 'call', _136 => _136(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _118 => _118.hooks, 'optionalAccess', _119 => _119.onClose])
+      } : _optionalChain([options, 'access', _137 => _137.hooks, 'optionalAccess', _138 => _138.onClose])
     },
     processorLock
   );
@@ -4777,7 +5079,7 @@ var postgreSQLEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _120 => _120.value, 'optionalAccess', _121 => _121.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _139 => _139.value, 'optionalAccess', _140 => _140.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -4788,7 +5090,8 @@ var postgreSQLEventStoreConsumer = (options) => {
       connectionString: options.connectionString,
       pool,
       client: void 0,
-      transaction: void 0
+      transaction: void 0,
+      messageStore: void 0
     }
   };
   const stopProcessors = () => Promise.all(processors.map((p) => p.close(processorContext)));
@@ -4796,7 +5099,7 @@ var postgreSQLEventStoreConsumer = (options) => {
     if (!isRunning) return;
     isRunning = false;
     if (messagePuller) {
-      _optionalChain([abortController, 'optionalAccess', _122 => _122.abort, 'call', _123 => _123()]);
+      _optionalChain([abortController, 'optionalAccess', _141 => _141.abort, 'call', _142 => _142()]);
       await messagePuller.stop();
       messagePuller = void 0;
       abortController = null;
@@ -4837,6 +5140,14 @@ var postgreSQLEventStoreConsumer = (options) => {
       );
       return processor;
     },
+    workflowProcessor: (options2) => {
+      const processor = postgreSQLWorkflowProcessor(options2);
+      processors.push(
+        // TODO: change that
+        processor
+      );
+      return processor;
+    },
     start: () => {
       if (isRunning) return start;
       if (processors.length === 0)
@@ -4849,8 +5160,8 @@ var postgreSQLEventStoreConsumer = (options) => {
         stopWhen: options.stopWhen,
         executor: pool.execute,
         eachBatch,
-        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _124 => _124.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
-        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _125 => _125.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
+        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _143 => _143.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _144 => _144.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
         signal: abortController.signal
       });
       start = (async () => {
@@ -5014,5 +5325,6 @@ var rebuildPostgreSQLProjections = (options) => {
 
 
 
-exports.DefaultPostgreSQLEventStoreProcessorBatchSize = DefaultPostgreSQLEventStoreProcessorBatchSize; exports.DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs; exports.DefaultPostgreSQLProcessorLockPolicy = DefaultPostgreSQLProcessorLockPolicy; exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.activateProjection = activateProjection; exports.activateProjectionSQL = activateProjectionSQL; exports.addDefaultPartitionSQL = addDefaultPartitionSQL; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addPartitionSQL = addPartitionSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendToStream = appendToStream; exports.appendToStreamSQL = appendToStreamSQL; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.callActivateProjection = callActivateProjection; exports.callAppendToStream = callAppendToStream; exports.callDeactivateProjection = callDeactivateProjection; exports.callRegisterProjection = callRegisterProjection; exports.callReleaseProcessorLock = callReleaseProcessorLock; exports.callStoreProcessorCheckpoint = callStoreProcessorCheckpoint; exports.callTryAcquireProcessorLock = callTryAcquireProcessorLock; exports.callTryAcquireProjectionLock = callTryAcquireProjectionLock; exports.cleanupLegacySubscriptionTables = cleanupLegacySubscriptionTables; exports.createEventStoreSchema = createEventStoreSchema; exports.deactivateProjection = deactivateProjection; exports.deactivateProjectionSQL = deactivateProjectionSQL; exports.defaultPostgreSQLOptions = defaultPostgreSQLOptions; exports.defaultTag = defaultTag2; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventStoreSchemaMigrations = eventStoreSchemaMigrations; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLCheckpointer = postgreSQLCheckpointer; exports.postgreSQLEventStoreConsumer = postgreSQLEventStoreConsumer; exports.postgreSQLEventStoreMessageBatchPuller = postgreSQLEventStoreMessageBatchPuller; exports.postgreSQLProcessorLock = postgreSQLProcessorLock; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLProjectionLock = postgreSQLProjectionLock; exports.postgreSQLProjector = postgreSQLProjector; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.postgreSQLReactor = postgreSQLReactor; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readProjectionInfo = readProjectionInfo; exports.readStream = readStream; exports.rebuildPostgreSQLProjections = rebuildPostgreSQLProjections; exports.registerProjection = registerProjection; exports.registerProjectionSQL = registerProjectionSQL; exports.releaseProcessorLockSQL = releaseProcessorLockSQL; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaMigration = schemaMigration; exports.schemaSQL = schemaSQL; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.storeSubscriptionCheckpointSQL = storeSubscriptionCheckpointSQL; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.toProcessorLockKey = toProcessorLockKey; exports.toProjectionLockKey = toProjectionLockKey; exports.transactionToPostgreSQLProjectionHandlerContext = transactionToPostgreSQLProjectionHandlerContext; exports.tryAcquireProcessorLockSQL = tryAcquireProcessorLockSQL; exports.tryAcquireProjectionLockSQL = tryAcquireProjectionLockSQL; exports.unknownTag = unknownTag2; exports.zipPostgreSQLEventStoreMessageBatchPullerStartFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom;
+
+exports.DefaultPostgreSQLEventStoreProcessorBatchSize = DefaultPostgreSQLEventStoreProcessorBatchSize; exports.DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs; exports.DefaultPostgreSQLProcessorLockPolicy = DefaultPostgreSQLProcessorLockPolicy; exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.activateProjection = activateProjection; exports.activateProjectionSQL = activateProjectionSQL; exports.addDefaultPartitionSQL = addDefaultPartitionSQL; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addPartitionSQL = addPartitionSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendToStream = appendToStream; exports.appendToStreamSQL = appendToStreamSQL; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.callActivateProjection = callActivateProjection; exports.callAppendToStream = callAppendToStream; exports.callDeactivateProjection = callDeactivateProjection; exports.callRegisterProjection = callRegisterProjection; exports.callReleaseProcessorLock = callReleaseProcessorLock; exports.callStoreProcessorCheckpoint = callStoreProcessorCheckpoint; exports.callTryAcquireProcessorLock = callTryAcquireProcessorLock; exports.callTryAcquireProjectionLock = callTryAcquireProjectionLock; exports.cleanupLegacySubscriptionTables = cleanupLegacySubscriptionTables; exports.createEventStoreSchema = createEventStoreSchema; exports.deactivateProjection = deactivateProjection; exports.deactivateProjectionSQL = deactivateProjectionSQL; exports.defaultPostgreSQLOptions = defaultPostgreSQLOptions; exports.defaultTag = defaultTag2; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventStoreSchemaMigrations = eventStoreSchemaMigrations; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLCheckpointer = postgreSQLCheckpointer; exports.postgreSQLEventStoreConsumer = postgreSQLEventStoreConsumer; exports.postgreSQLEventStoreMessageBatchPuller = postgreSQLEventStoreMessageBatchPuller; exports.postgreSQLProcessorLock = postgreSQLProcessorLock; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLProjectionLock = postgreSQLProjectionLock; exports.postgreSQLProjector = postgreSQLProjector; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.postgreSQLReactor = postgreSQLReactor; exports.postgreSQLWorkflowProcessor = postgreSQLWorkflowProcessor; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readProjectionInfo = readProjectionInfo; exports.readStream = readStream; exports.rebuildPostgreSQLProjections = rebuildPostgreSQLProjections; exports.registerProjection = registerProjection; exports.registerProjectionSQL = registerProjectionSQL; exports.releaseProcessorLockSQL = releaseProcessorLockSQL; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaMigration = schemaMigration; exports.schemaSQL = schemaSQL; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.storeSubscriptionCheckpointSQL = storeSubscriptionCheckpointSQL; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.toProcessorLockKey = toProcessorLockKey; exports.toProjectionLockKey = toProjectionLockKey; exports.transactionToPostgreSQLProjectionHandlerContext = transactionToPostgreSQLProjectionHandlerContext; exports.tryAcquireProcessorLockSQL = tryAcquireProcessorLockSQL; exports.tryAcquireProjectionLockSQL = tryAcquireProjectionLockSQL; exports.unknownTag = unknownTag2; exports.zipPostgreSQLEventStoreMessageBatchPullerStartFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom;
 //# sourceMappingURL=index.cjs.map