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

package/dist/index.js

@@ -84,6 +84,12 @@ var accept = () => {
   return { action: "Accept" };
 };
 
+// src/typing/index.ts
+var emmettPrefix = "emt";
+var globalTag = "global";
+var defaultTag = `${emmettPrefix}:default`;
+var unknownTag = `${emmettPrefix}:unknown`;
+
 // src/eventStore/afterCommit/afterEventStoreCommitHandler.ts
 async function tryPublishMessagesAfterCommit(messages, options, context) {
   if (options?.onAfterCommit === void 0) return false;
@@ -586,6 +592,12 @@ var InProcessLock = () => {
   };
 };
 
+// src/utils/numbers/bigint.ts
+var toNormalizedString = (value) => value.toString().padStart(19, "0");
+var bigInt = {
+  toNormalizedString
+};
+
 // src/utils/promises.ts
 var delay = (ms) => {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -653,6 +665,17 @@ var asyncRetry = async (fn, opts) => {
   );
 };
 
+// src/utils/strings/hashText.ts
+var textEncoder = new TextEncoder();
+var hashText = async (text) => {
+  const hashBuffer = await crypto.subtle.digest(
+    "SHA-256",
+    textEncoder.encode(text)
+  );
+  const view = new BigInt64Array(hashBuffer, 0, 1);
+  return view[0];
+};
+
 // src/database/utils.ts
 var isGeneralExpectedDocumentVersion = (version) => {
   return version === "DOCUMENT_DOES_NOT_EXIST" || version === "DOCUMENT_EXISTS" || version === "NO_CONCURRENCY_CHECK";
@@ -1429,6 +1452,9 @@ var InMemoryProjectionSpec = {
                   nextExpectedStreamVersion: 0n,
                   createdNewStream: false
                 });
+              },
+              streamExists: async () => {
+                return Promise.resolve(false);
               }
             };
             await handleInMemoryProjections({
@@ -1617,6 +1643,10 @@ var getInMemoryEventStore = (eventStoreOptions) => {
         eventStoreOptions?.hooks
       );
       return result;
+    },
+    streamExists: (streamName) => {
+      const events = streams.get(streamName);
+      return Promise.resolve(events !== void 0 && events.length > 0);
     }
   };
   return eventStore;
@@ -1782,6 +1812,7 @@ var getInMemoryMessageBus = () => {
 };
 
 // src/processors/processors.ts
+import { v7 as uuid4 } from "uuid";
 var getCheckpoint = (message2) => {
   return "checkpoint" in message2.metadata ? (
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -1818,28 +1849,58 @@ var MessageProcessor = {
   }
 };
 var defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
+var defaultProcessorVersion = 1;
+var defaultProcessorPartition = defaultTag;
+var getProcessorInstanceId = (processorId) => `${processorId}:${uuid4()}`;
+var getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
 var reactor = (options) => {
+  const {
+    checkpoints,
+    processorId,
+    processorInstanceId: instanceId = getProcessorInstanceId(processorId),
+    type = MessageProcessorType.REACTOR,
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition,
+    hooks = {},
+    processingScope = defaultProcessingMessageProcessingScope,
+    startFrom,
+    canHandle,
+    stopAfter
+  } = options;
   const eachMessage = "eachMessage" in options && options.eachMessage ? options.eachMessage : () => Promise.resolve();
-  let isActive = true;
-  const { checkpoints, processorId, partition } = options;
-  const processingScope = options.processingScope ?? defaultProcessingMessageProcessingScope;
+  let isInitiated = false;
+  let isActive = false;
   let lastCheckpoint = null;
+  const init = async (initOptions) => {
+    if (isInitiated) return;
+    if (hooks.onInit === void 0) {
+      isInitiated = true;
+      return;
+    }
+    return await processingScope(async (context) => {
+      await hooks.onInit(context);
+      isInitiated = true;
+    }, initOptions);
+  };
   return {
-    id: options.processorId,
-    type: options.type ?? MessageProcessorType.REACTOR,
-    close: () => options.hooks?.onClose ? options.hooks?.onClose() : Promise.resolve(),
+    // TODO: Consider whether not make it optional or add URN prefix
+    id: processorId,
+    instanceId,
+    type,
+    init,
     start: async (startOptions) => {
+      if (isActive) return;
+      await init(startOptions);
       isActive = true;
       if (lastCheckpoint !== null)
         return {
           lastCheckpoint
         };
       return await processingScope(async (context) => {
-        if (options.hooks?.onStart) {
-          await options.hooks?.onStart(context);
+        if (hooks.onStart) {
+          await hooks.onStart(context);
         }
-        if (options.startFrom !== "CURRENT" && options.startFrom)
-          return options.startFrom;
+        if (startFrom && startFrom !== "CURRENT") return startFrom;
         if (checkpoints) {
           const readResult = await checkpoints?.read(
             {
@@ -1856,6 +1917,7 @@ var reactor = (options) => {
         };
       }, startOptions);
     },
+    close: hooks?.onClose ? async (closeOptions) => await processingScope(hooks.onClose, closeOptions) : () => Promise.resolve(),
     get isActive() {
       return isActive;
     },
@@ -1865,15 +1927,17 @@ var reactor = (options) => {
         let result = void 0;
         for (const message2 of messages) {
           if (wasMessageHandled(message2, lastCheckpoint)) continue;
+          if (canHandle !== void 0 && !canHandle.includes(message2.type))
+            return;
           const messageProcessingResult = await eachMessage(message2, context);
           if (checkpoints) {
             const storeCheckpointResult = await checkpoints.store(
               {
-                processorId: options.processorId,
-                version: options.version,
+                processorId,
+                version,
                 message: message2,
                 lastCheckpoint,
-                partition: options.partition
+                partition
               },
               context
             );
@@ -1886,7 +1950,7 @@ var reactor = (options) => {
             result = messageProcessingResult;
             break;
           }
-          if (options.stopAfter && options.stopAfter(message2)) {
+          if (stopAfter && stopAfter(message2)) {
             isActive = false;
             result = { type: "STOP", reason: "Stop condition reached" };
             break;
@@ -1900,12 +1964,20 @@ var reactor = (options) => {
   };
 };
 var projector = (options) => {
-  const { projection: projection2, ...rest } = options;
+  const {
+    projection: projection2,
+    processorId = getProjectorId({
+      projectionName: projection2.name ?? "unknown"
+    }),
+    ...rest
+  } = options;
   return reactor({
     ...rest,
     type: MessageProcessorType.PROJECTOR,
-    processorId: options.processorId ?? `projection:${projection2.name}`,
+    canHandle: projection2.canHandle,
+    processorId,
     hooks: {
+      onInit: options.hooks?.onInit,
       onStart: options.truncateOnStart && options.projection.truncate || options.hooks?.onStart ? async (context) => {
         if (options.truncateOnStart && options.projection.truncate)
           await options.projection.truncate(context);
@@ -1913,10 +1985,7 @@ var projector = (options) => {
       } : void 0,
       onClose: options.hooks?.onClose
     },
-    eachMessage: async (event2, context) => {
-      if (!projection2.canHandle.includes(event2.type)) return;
-      await projection2.handle([event2], context);
-    }
+    eachMessage: async (event2, context) => projection2.handle([event2], context)
   });
 };
 
@@ -1942,7 +2011,7 @@ var inMemoryCheckpointer = () => {
       if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) {
         return {
           success: false,
-          reason: currentPosition === newCheckpoint ? "IGNORED" : "MISMATCH"
+          reason: currentPosition === newCheckpoint ? "IGNORED" : newCheckpoint !== null && currentPosition > newCheckpoint ? "CURRENT_AHEAD" : "MISMATCH"
         };
       }
       await checkpoints.handle(processorId, (existing) => ({
@@ -1969,44 +2038,40 @@ var inMemoryProcessingScope = (options) => {
 var inMemoryProjector = (options) => {
   const database = options.connectionOptions?.database ?? getInMemoryDatabase();
   const hooks = {
+    onInit: options.hooks?.onInit,
     onStart: options.hooks?.onStart,
-    onClose: options.hooks?.onClose ? async () => {
-      if (options.hooks?.onClose) await options.hooks?.onClose();
+    onClose: options.hooks?.onClose ? async (context) => {
+      if (options.hooks?.onClose) await options.hooks?.onClose(context);
     } : void 0
   };
-  return {
-    ...projector({
-      ...options,
-      hooks,
-      processingScope: inMemoryProcessingScope({
-        database,
-        processorId: options.processorId ?? `projection:${options.projection.name}`
-      }),
-      checkpoints: inMemoryCheckpointer()
+  const processor = projector({
+    ...options,
+    hooks,
+    processingScope: inMemoryProcessingScope({
+      database,
+      processorId: options.processorId ?? `projection:${options.projection.name}`
     }),
-    database
-  };
+    checkpoints: inMemoryCheckpointer()
+  });
+  return Object.assign(processor, { database });
 };
 var inMemoryReactor = (options) => {
   const database = options.connectionOptions?.database ?? getInMemoryDatabase();
   const hooks = {
+    onInit: options.hooks?.onInit,
     onStart: options.hooks?.onStart,
-    onClose: options.hooks?.onClose ? async () => {
-      if (options.hooks?.onClose) await options.hooks?.onClose();
-    } : void 0
+    onClose: options.hooks?.onClose
   };
-  return {
-    ...reactor({
-      ...options,
-      hooks,
-      processingScope: inMemoryProcessingScope({
-        database,
-        processorId: options.processorId
-      }),
-      checkpoints: inMemoryCheckpointer()
+  const processor = reactor({
+    ...options,
+    hooks,
+    processingScope: inMemoryProcessingScope({
+      database,
+      processorId: options.processorId
     }),
-    database
-  };
+    checkpoints: inMemoryCheckpointer()
+  });
+  return Object.assign(processor, { database });
 };
 
 // src/projections/index.ts
@@ -2095,14 +2160,19 @@ export {
   asyncAwaiter,
   asyncProjections,
   asyncRetry,
+  bigInt,
   canCreateEventStoreSession,
   caughtUpEventFrom,
   command,
   complete,
   deepEquals,
   defaultProcessingMessageProcessingScope,
+  defaultProcessorPartition,
+  defaultProcessorVersion,
+  defaultTag,
   delay,
   documentExists,
+  emmettPrefix,
   error,
   event,
   eventInStream,
@@ -2115,8 +2185,12 @@ export {
   getInMemoryDatabase,
   getInMemoryEventStore,
   getInMemoryMessageBus,
+  getProcessorInstanceId,
+  getProjectorId,
   globalStreamCaughtUp,
+  globalTag,
   handleInMemoryProjections,
+  hashText,
   ignore,
   inMemoryCheckpointer,
   inMemoryMultiStreamProjection,
@@ -2152,7 +2226,9 @@ export {
   schedule,
   send,
   sum,
+  toNormalizedString,
   tryPublishMessagesAfterCommit,
+  unknownTag,
   verifyThat,
   wasMessageHandled
 };