@event-driven-io/emmett 0.43.0-beta.35 → 0.43.0-beta.37

package/dist/index.cjs

@@ -1102,7 +1102,7 @@ const ProcessorCheckpoint = Object.assign((checkpoint) => checkpoint, {
 	BEGINNING: "BEGINNING",
 	isBeginning: (checkpoint) => checkpoint === void 0 || checkpoint === "BEGINNING",
 	isEnd: (checkpoint) => checkpoint === "END",
-	compare: (a, b) => a > b ? 1 : -1
+	compare: (a, b) => a > b ? 1 : a < b ? -1 : 0
 });
 const bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
 const parseBigIntProcessorCheckpoint = (value) => BigInt(value);
@@ -1229,7 +1229,7 @@ const processorCollector = (observability) => {
 //#endregion
 //#region src/processors/processors.ts
 const CurrentMessageProcessorPosition = {
-	compare: (a, b, compareCheckpoints = (chkA, chkB) => chkA > chkB ? 1 : chkA < chkB ? -1 : 0) => {
+	compare: (a, b, compareCheckpoints = ProcessorCheckpoint.compare) => {
 		if (a === b) return 0;
 		if (a === "BEGINNING") return -1;
 		if (b === "BEGINNING") return 1;
@@ -1242,14 +1242,22 @@ const CurrentMessageProcessorPosition = {
 		return checkpoints.map((pos) => pos === void 0 ? "BEGINNING" : pos).sort((a, b) => CurrentMessageProcessorPosition.compare(a, b, compareCheckpoints))[0] ?? "BEGINNING";
 	}
 };
-const wasMessageHandled = (message, checkpoint) => {
+const wasMessageHandled = (message, checkpoint, compareCheckpoints = ProcessorCheckpoint.compare) => {
 	const messageCheckpoint = getCheckpoint(message);
-	return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && messageCheckpoint <= checkpoint;
+	return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && compareCheckpoints(messageCheckpoint, checkpoint) <= 0;
 };
 const MessageProcessorType = {
 	PROJECTOR: "projector",
 	REACTOR: "reactor"
 };
+const raceWithTimeout = (wait, timeout, timeoutMessage) => {
+	if (timeout === void 0) return wait;
+	let timer;
+	const timeoutPromise = new Promise((_resolve, reject) => {
+		timer = setTimeout(() => reject(new require_plugins.EmmettError(timeoutMessage())), timeout);
+	});
+	return Promise.race([wait, timeoutPromise]).finally(() => clearTimeout(timer));
+};
 const MessageProcessor = { result: {
 	skip: (options) => ({
 		type: "SKIP",
@@ -1270,7 +1278,7 @@ const getProcessorInstanceId = (processorId) => `${processorId}:${(0, uuid.v7)()
 const getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
 const { info, error } = _event_driven_io_almanac.LogEvent;
 const reactor = (options) => {
-	const { checkpoints, processorId, processorInstanceId: instanceId = getProcessorInstanceId(processorId), type = MessageProcessorType.REACTOR, version = 1, partition = defaultProcessorPartition, hooks = {}, processingScope = defaultProcessingMessageProcessingScope, startFrom, canHandle, stopAfter } = options;
+	const { checkpoints, processorId, processorInstanceId: instanceId = getProcessorInstanceId(processorId), type = MessageProcessorType.REACTOR, version = 1, partition = defaultProcessorPartition, hooks = {}, processingScope = defaultProcessingMessageProcessingScope, startFrom, canHandle, stopAfter, compareCheckpoints = ProcessorCheckpoint.compare } = options;
 	const checkpointer = checkpoints === "DISABLED" ? inMemoryCheckpointer() : checkpoints;
 	const collector = processorCollector(processorObservability(options));
 	const isCustomBatch = "eachBatch" in options && !!options.eachBatch;
@@ -1315,7 +1323,26 @@ const reactor = (options) => {
 	let isInitiated = false;
 	let isActive = false;
 	let lastCheckpoint = null;
+	let lastStoredCheckpoint = null;
 	let closeSignal = null;
+	const checkpointWaiters = /* @__PURE__ */ new Set();
+	const hasProcessed = (target) => lastCheckpoint !== null && compareCheckpoints(lastCheckpoint, target) >= 0;
+	const notifyCheckpointWaiters = () => {
+		for (const waiter of checkpointWaiters) if (hasProcessed(waiter.target)) {
+			checkpointWaiters.delete(waiter);
+			waiter.resolve();
+		}
+	};
+	const whenProcessed = (checkpoint, options) => {
+		if (hasProcessed(checkpoint)) return Promise.resolve();
+		const awaiter = asyncAwaiter();
+		const waiter = {
+			target: checkpoint,
+			resolve: awaiter.resolve
+		};
+		checkpointWaiters.add(waiter);
+		return raceWithTimeout(awaiter.wait, options?.timeout, () => `Processor ${processorId} with instance id ${instanceId} did not process checkpoint ${checkpoint} within ${options.timeout}ms (last processed checkpoint: ${lastCheckpoint ?? "none"})`).finally(() => checkpointWaiters.delete(waiter));
+	};
 	const init = async (initOptions) => {
 		if (isInitiated) return;
 		if (hooks.onInit === void 0) {
@@ -1372,18 +1399,23 @@ const reactor = (options) => {
 					log(info(`Executing onStart hook for processor ${processorId} with instance id ${instanceId}`));
 					await hooks.onStart(context);
 				}
-				if (startFrom !== void 0 && startFrom !== "CURRENT") {
-					if (typeof startFrom !== "string") lastCheckpoint = startFrom.lastCheckpoint;
-					log(info(`Processor ${processorId} with instance id ${instanceId} starting from: ${JSONSerializer.serialize(startFrom)}`));
-					return startFrom;
-				}
-				if (checkpointer) lastCheckpoint = (await checkpointer.read({
+				if (checkpointer) lastStoredCheckpoint = (await checkpointer.read({
 					processorId,
 					partition
 				}, {
 					...startOptions,
 					...context
 				})).lastCheckpoint;
+				if (startFrom !== void 0 && typeof startFrom !== "string") {
+					lastCheckpoint = startFrom.lastCheckpoint;
+					log(info(`Processor ${processorId} with instance id ${instanceId} starting from: ${JSONSerializer.serialize(startFrom)}`));
+					return startFrom;
+				}
+				if (startFrom === "BEGINNING" || startFrom === "END") {
+					log(info(`Processor ${processorId} with instance id ${instanceId} starting from: ${JSONSerializer.serialize(startFrom)}`));
+					return startFrom;
+				}
+				lastCheckpoint = lastStoredCheckpoint;
 				if (lastCheckpoint === null) {
 					log(info(`Processor ${processorId} with instance id ${instanceId} starting from: BEGINNING`));
 					return "BEGINNING";
@@ -1402,6 +1434,7 @@ const reactor = (options) => {
 		get isActive() {
 			return isActive;
 		},
+		whenProcessed,
 		handle: async (messages, partialContext) => {
 			if (!isActive) return Promise.resolve();
 			return collector.startScope({
@@ -1410,8 +1443,8 @@ const reactor = (options) => {
 				checkpoint: lastCheckpoint
 			}, messages, async (scope) => {
 				try {
-					return await processingScope(async (context) => {
-						const messagesAboveCheckpoint = messages.filter((message) => !wasMessageHandled(message, lastCheckpoint));
+					const result = await processingScope(async (context) => {
+						const messagesAboveCheckpoint = messages.filter((message) => !wasMessageHandled(message, lastCheckpoint, compareCheckpoints));
 						const upcastedMessages = messagesAboveCheckpoint.map((message) => upcastRecordedMessage(message, options.messageOptions?.schema?.versioning)).filter((upcasted) => !canHandle || canHandle.includes(upcasted.type));
 						const stopMessageIndex = isCustomBatch && stopAfter ? upcastedMessages.findIndex(stopAfter) : -1;
 						const unhandledMessages = stopMessageIndex !== -1 ? upcastedMessages.slice(0, stopMessageIndex + 1) : upcastedMessages;
@@ -1431,10 +1464,13 @@ const reactor = (options) => {
 								processorId,
 								version,
 								message: checkpointMessage,
-								lastCheckpoint,
+								lastCheckpoint: lastStoredCheckpoint,
 								partition
 							}, context);
-							if (storeCheckpointResult.success) lastCheckpoint = storeCheckpointResult.newCheckpoint;
+							if (storeCheckpointResult.success) {
+								lastCheckpoint = storeCheckpointResult.newCheckpoint;
+								lastStoredCheckpoint = storeCheckpointResult.newCheckpoint;
+							}
 						}
 						scope.setAttributes({ [EmmettAttributes.processor.status]: messageProcessingResult?.type ?? "ack" });
 						if (isStop) {
@@ -1445,6 +1481,8 @@ const reactor = (options) => {
 						...partialContext,
 						observabilityScope: scope
 					});
+					if (result?.type !== "STOP") notifyCheckpointWaiters();
+					return result;
 				} catch (err) {
 					scope.log(error({ err }, `Error during message processing for processor ${processorId} with instance id ${instanceId}. Stopping the processor.`));
 					isActive = false;
@@ -1572,9 +1610,10 @@ const ProcessorStartPositions = (options) => {
 			const position = positions.get(processorId);
 			if (position === void 0 || position === "BEGINNING" || position === "END") return messages;
 			const { lastCheckpoint } = position;
+			const compareCheckpoints = options?.compareCheckpoints ?? ProcessorCheckpoint.compare;
 			return messages.filter((message) => {
 				const checkpoint = getCheckpoint(message);
-				return checkpoint !== null && checkpoint > lastCheckpoint;
+				return checkpoint !== null && compareCheckpoints(checkpoint, lastCheckpoint) > 0;
 			});
 		}
 	};