@event-driven-io/emmett-sqlite 0.43.0-beta.1 → 0.43.0-beta.3

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, A as AnyEventStoreDriver, c as SQLiteProjectionDefinition, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-V1lU-4KS.cjs';
-export { C as CreateEventStoreSchemaOptions, v as EventHandler, t as EventStoreSchemaMigrationOptions, w as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, e as SQLiteProjectionHandler, d as SQLiteProjectionHandlerContext, f as SQLiteProjectionHandlerOptions, g as SQLiteRawBatchSQLProjection, j as SQLiteRawSQLProjection, x as SQLiteReadEvent, l as SQLiteStreamExistsOptions, u as createEventStoreSchema, y as getSQLiteEventStore, h as handleProjections, o as messagesTableSQL, p as processorsTableSQL, q as projectionsTableSQL, r as schemaSQL, s as sqliteProjection, i as sqliteRawBatchSQLProjection, k as sqliteRawSQLProjection, m as streamExists, n as streamsTableSQL } from './sqliteProjection-V1lU-4KS.cjs';
+import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, A as AnyEventStoreDriver, c as SQLiteProjectionDefinition, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-BJ6uAnzZ.cjs';
+export { C as CreateEventStoreSchemaOptions, v as EventHandler, t as EventStoreSchemaMigrationOptions, w as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, e as SQLiteProjectionHandler, d as SQLiteProjectionHandlerContext, f as SQLiteProjectionHandlerOptions, g as SQLiteRawBatchSQLProjection, j as SQLiteRawSQLProjection, x as SQLiteReadEvent, l as SQLiteStreamExistsOptions, u as createEventStoreSchema, y as getSQLiteEventStore, h as handleProjections, o as messagesTableSQL, p as processorsTableSQL, q as projectionsTableSQL, r as schemaSQL, s as sqliteProjection, i as sqliteRawBatchSQLProjection, k as sqliteRawSQLProjection, m as streamExists, n as streamsTableSQL } from './sqliteProjection-BJ6uAnzZ.cjs';
 import * as _event_driven_io_emmett from '@event-driven-io/emmett';
 import { Event, AppendToStreamOptions, BeforeEventStoreCommitHandler, Message, RecordedMessageMetadata, RecordedMessage, RecordedMessageMetadataWithGlobalPosition, ProcessorCheckpoint, ReadStreamOptions, ReadStreamResult, ReadEventMetadataWithGlobalPosition, ThenThrows } from '@event-driven-io/emmett';
 import { SQL, SQLExecutor, Dumbo, QueryResultRow } from '@event-driven-io/dumbo';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, A as AnyEventStoreDriver, c as SQLiteProjectionDefinition, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-V1lU-4KS.js';
-export { C as CreateEventStoreSchemaOptions, v as EventHandler, t as EventStoreSchemaMigrationOptions, w as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, e as SQLiteProjectionHandler, d as SQLiteProjectionHandlerContext, f as SQLiteProjectionHandlerOptions, g as SQLiteRawBatchSQLProjection, j as SQLiteRawSQLProjection, x as SQLiteReadEvent, l as SQLiteStreamExistsOptions, u as createEventStoreSchema, y as getSQLiteEventStore, h as handleProjections, o as messagesTableSQL, p as processorsTableSQL, q as projectionsTableSQL, r as schemaSQL, s as sqliteProjection, i as sqliteRawBatchSQLProjection, k as sqliteRawSQLProjection, m as streamExists, n as streamsTableSQL } from './sqliteProjection-V1lU-4KS.js';
+import { a as SQLiteEventStore, b as SQLiteReadEventMetadata, A as AnyEventStoreDriver, c as SQLiteProjectionDefinition, I as InferOptionsFromEventStoreDriver } from './sqliteProjection-BJ6uAnzZ.js';
+export { C as CreateEventStoreSchemaOptions, v as EventHandler, t as EventStoreSchemaMigrationOptions, w as SQLiteEventStoreDefaultStreamVersion, S as SQLiteEventStoreOptions, e as SQLiteProjectionHandler, d as SQLiteProjectionHandlerContext, f as SQLiteProjectionHandlerOptions, g as SQLiteRawBatchSQLProjection, j as SQLiteRawSQLProjection, x as SQLiteReadEvent, l as SQLiteStreamExistsOptions, u as createEventStoreSchema, y as getSQLiteEventStore, h as handleProjections, o as messagesTableSQL, p as processorsTableSQL, q as projectionsTableSQL, r as schemaSQL, s as sqliteProjection, i as sqliteRawBatchSQLProjection, k as sqliteRawSQLProjection, m as streamExists, n as streamsTableSQL } from './sqliteProjection-BJ6uAnzZ.js';
 import * as _event_driven_io_emmett from '@event-driven-io/emmett';
 import { Event, AppendToStreamOptions, BeforeEventStoreCommitHandler, Message, RecordedMessageMetadata, RecordedMessage, RecordedMessageMetadataWithGlobalPosition, ProcessorCheckpoint, ReadStreamOptions, ReadStreamResult, ReadEventMetadataWithGlobalPosition, ThenThrows } from '@event-driven-io/emmett';
 import { SQL, SQLExecutor, Dumbo, QueryResultRow } from '@event-driven-io/dumbo';

package/dist/index.js

@@ -52,9 +52,20 @@ import { v7 as uuid } from "uuid";
 import retry from "async-retry";
 import { v7 as uuid2 } from "uuid";
 import { v4 as uuid3 } from "uuid";
+import { v7 as uuid5 } from "uuid";
 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";
@@ -75,8 +86,8 @@ var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends C
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
-var isExpectedVersionConflictError = (error2) => error2 instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
-  error2,
+var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
+  error,
   ExpectedVersionConflictError.Codes.ConcurrencyError
 );
 var isPrimitive = (value) => {
@@ -305,6 +316,30 @@ var JSONParser = {
     return options?.map ? options.map(parsed) : parsed;
   }
 };
+var NoRetries = { retries: 0 };
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return retry(
+    async (bail) => {
+      try {
+        const result = await fn();
+        if (opts?.shouldRetryResult && opts.shouldRetryResult(result)) {
+          throw new EmmettError(
+            `Retrying because of result: ${JSONParser.stringify(result)}`
+          );
+        }
+        return result;
+      } catch (error) {
+        if (opts?.shouldRetryError && !opts.shouldRetryError(error)) {
+          bail(error);
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    opts ?? { retries: 0 }
+  );
+};
 var onShutdown = (handler) => {
   const signals = ["SIGTERM", "SIGINT"];
   if (typeof process !== "undefined" && typeof process.on === "function") {
@@ -395,12 +430,13 @@ var reactor = (options) => {
     id: processorId,
     instanceId,
     type,
+    canHandle,
     init,
     start: async (startOptions) => {
       if (isActive) return;
       await init(startOptions);
       isActive = true;
-      closeSignal = onShutdown(() => close({}));
+      closeSignal = onShutdown(() => close(startOptions));
       if (lastCheckpoint !== null)
         return {
           lastCheckpoint
@@ -649,6 +685,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 (metadata?.input === true && typeof metadata?.originalMessageId === "string") {
+      processedInputIds = new Set(state.processedInputIds);
+      processedInputIds.add(metadata.originalMessageId);
+    }
+    if (separateInputInboxFromProcessing && metadata?.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
+        ("metadata" in message2 && message2.metadata?.messageId ? (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          message2.metadata.messageId
+        ) : void 0) ?? uuid5()
+      );
+      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: handleOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+          }
+        );
+        return {
+          ...appendResult2,
+          newMessages: []
+        };
+      }
+      const wrappedInitialState = createWrappedInitialState(initialState);
+      const wrappedEvolve = createWrappedEvolve(
+        evolve,
+        workflowName,
+        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: handleOptions?.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 = options.outputs?.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 = handleOptions?.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: 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/projections/sqliteProjection.ts
 var handleProjections = async (options) => {
@@ -715,7 +988,7 @@ var sqliteRawSQLProjection = (options) => {
 
 // src/eventStore/projections/sqliteProjectionSpec.ts
 import { dumbo } from "@event-driven-io/dumbo";
-import { v4 as uuid5 } from "uuid";
+import { v4 as uuid6 } from "uuid";
 var SQLiteProjectionSpec = {
   for: (options) => {
     {
@@ -740,8 +1013,8 @@ var SQLiteProjectionSpec = {
                   checkpoint: bigIntProcessorCheckpoint(++globalPosition),
                   globalPosition,
                   streamPosition: globalPosition,
-                  streamName: `test-${uuid5()}`,
-                  messageId: uuid5()
+                  streamName: `test-${uuid6()}`,
+                  messageId: uuid6()
                 };
                 allEvents.push({
                   ...event,
@@ -856,7 +1129,7 @@ import {
   SQL,
   UniqueConstraintError
 } from "@event-driven-io/dumbo";
-import { v4 as uuid6 } from "uuid";
+import { v4 as uuid7 } from "uuid";
 
 // src/eventStore/schema/typing.ts
 var emmettPrefix2 = "emt";
@@ -906,7 +1179,7 @@ var appendToStream = async (connection, streamName, streamType, messages, option
       kind: m.kind ?? "Event",
       metadata: {
         streamName,
-        messageId: uuid6(),
+        messageId: uuid7(),
         streamPosition: BigInt(i + 1),
         ..."metadata" in m ? m.metadata ?? {} : {}
       }
@@ -1337,7 +1610,7 @@ var zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
 
 // src/eventStore/consumers/sqliteEventStoreConsumer.ts
 import { dumbo as dumbo2 } from "@event-driven-io/dumbo";
-import { v7 as uuid7 } from "uuid";
+import { v7 as uuid8 } from "uuid";
 
 // src/eventStore/consumers/sqliteCheckpointer.ts
 var sqliteCheckpointer = () => ({
@@ -1376,6 +1649,49 @@ var sqliteProcessingScope = () => {
   };
   return processingScope;
 };
+var sqliteWorkflowProcessingScope = (messageStore) => {
+  const processingScope = async (handler, partialContext) => {
+    const connection = partialContext?.connection;
+    if (!connection)
+      throw new EmmettError("Connection is required in context or options");
+    return connection.withTransaction(
+      async (transaction) => {
+        return handler({
+          ...partialContext,
+          connection: Object.assign(connection, { messageStore }),
+          execute: transaction.execute
+        });
+      }
+    );
+  };
+  return processingScope;
+};
+var sqliteWorkflowProcessor = (options) => {
+  const {
+    processorId = options.processorId ?? getWorkflowId({
+      workflowName: options.workflow.name ?? "unknown"
+    }),
+    processorInstanceId = getProcessorInstanceId(processorId),
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition
+  } = options;
+  const hooks = {
+    ...options.hooks ?? {},
+    onClose: options.hooks?.onClose
+  };
+  return workflowProcessor({
+    ...options,
+    processorId,
+    processorInstanceId,
+    version,
+    partition,
+    hooks,
+    processingScope: sqliteWorkflowProcessingScope(
+      options.messageStore
+    ),
+    checkpoints: sqliteCheckpointer()
+  });
+};
 var sqliteReactor = (options) => {
   const {
     processorId = options.processorId,
@@ -1509,7 +1825,7 @@ var sqliteEventStoreConsumer = (options) => {
     isInitialized = true;
   };
   return {
-    consumerId: options.consumerId ?? uuid7(),
+    consumerId: options.consumerId ?? uuid8(),
     get isRunning() {
       return isRunning;
     },
@@ -1531,6 +1847,22 @@ var sqliteEventStoreConsumer = (options) => {
       );
       return processor;
     },
+    workflowProcessor: (processorOptions) => {
+      const messageStore = getSQLiteEventStore({
+        ...options,
+        pool,
+        schema: { autoMigration: "None" }
+      });
+      const processor = sqliteWorkflowProcessor({
+        ...processorOptions,
+        messageStore
+      });
+      processors.push(
+        // TODO: change that
+        processor
+      );
+      return processor;
+    },
     start: () => {
       if (isRunning) return start;
       if (processors.length === 0)