@event-driven-io/emmett 0.43.0-beta.24 → 0.43.0-beta.26

package/dist/index.cjs

@@ -997,7 +997,13 @@ const getInMemoryDatabase = () => {
 
 //#endregion
 //#region src/processors/checkpoints.ts
-const ProcessorCheckpoint = (checkpoint) => checkpoint;
+const ProcessorCheckpoint = Object.assign((checkpoint) => checkpoint, {
+	END: "END",
+	BEGINNING: "BEGINNING",
+	isBeginning: (checkpoint) => checkpoint === void 0 || checkpoint === "BEGINNING",
+	isEnd: (checkpoint) => checkpoint === "END",
+	compare: (a, b) => a > b ? 1 : -1
+});
 const bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
 const parseBigIntProcessorCheckpoint = (value) => BigInt(value);
 const getCheckpoint = (message) => {
@@ -1187,6 +1193,20 @@ const processorCollector = (observability) => {
 
 //#endregion
 //#region src/processors/processors.ts
+const CurrentMessageProcessorPosition = {
+	compare: (a, b, compareCheckpoints = (chkA, chkB) => chkA > chkB ? 1 : chkA < chkB ? -1 : 0) => {
+		if (a === b) return 0;
+		if (a === "BEGINNING") return -1;
+		if (b === "BEGINNING") return 1;
+		if (a === "END") return 1;
+		if (b === "END") return -1;
+		return compareCheckpoints(a.lastCheckpoint, b.lastCheckpoint);
+	},
+	zip: (checkpoints, compareCheckpoints) => {
+		if (checkpoints.length === 0) return "BEGINNING";
+		return checkpoints.map((pos) => pos === void 0 ? "BEGINNING" : pos).sort((a, b) => CurrentMessageProcessorPosition.compare(a, b, compareCheckpoints))[0] ?? "BEGINNING";
+	}
+};
 const wasMessageHandled = (message, checkpoint) => {
 	const messageCheckpoint = getCheckpoint(message);
 	return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && messageCheckpoint <= checkpoint;
@@ -1216,6 +1236,7 @@ const getProjectorId = (options) => `emt:processor:projector:${options.projectio
 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 checkpointer = checkpoints === "DISABLED" ? inMemoryCheckpointer() : checkpoints;
 	const collector = processorCollector(processorObservability(options));
 	const isCustomBatch = "eachBatch" in options && !!options.eachBatch;
 	const eachBatch = isCustomBatch ? options.eachBatch : async (messages, context) => {
@@ -1317,11 +1338,12 @@ const reactor = (options) => {
 					log(info(`Executing onStart hook for processor ${processorId} with instance id ${instanceId}`));
 					await hooks.onStart(context);
 				}
-				if (startFrom && startFrom !== "CURRENT") {
+				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 (checkpoints) lastCheckpoint = (await checkpoints?.read({
+				if (checkpointer) lastCheckpoint = (await checkpointer.read({
 					processorId,
 					partition
 				}, {
@@ -1370,8 +1392,8 @@ const reactor = (options) => {
 						} : batchResult;
 						const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
 						const checkpointMessage = messageProcessingResult?.type === "STOP" ? messageProcessingResult.lastSuccessfulMessage : messagesAboveCheckpoint[messagesAboveCheckpoint.length - 1];
-						if (checkpointMessage && checkpoints) {
-							const storeCheckpointResult = await checkpoints.store({
+						if (checkpointMessage && checkpointer) {
+							const storeCheckpointResult = await checkpointer.store({
 								processorId,
 								version,
 								message: checkpointMessage,
@@ -1425,14 +1447,14 @@ const projector = (options) => {
 //#endregion
 //#region src/processors/inMemoryProcessors.ts
 const inMemoryCheckpointer = () => {
+	let fallbackDatabase;
+	const resolveDatabase = (context) => context?.database ?? (fallbackDatabase ??= getInMemoryDatabase());
 	return {
-		read: async ({ processorId }, { database }) => {
-			const checkpoint = await database.collection("emt_processor_checkpoints").findOne((d) => d._id === processorId);
-			return Promise.resolve({ lastCheckpoint: checkpoint?.lastCheckpoint ?? null });
+		read: async ({ processorId }, context) => {
+			return { lastCheckpoint: (await resolveDatabase(context).collection("emt_processor_checkpoints").findOne((d) => d._id === processorId))?.lastCheckpoint ?? null };
 		},
-		store: async (context, { database }) => {
-			const { message, processorId, lastCheckpoint } = context;
-			const checkpoints = database.collection("emt_processor_checkpoints");
+		store: async ({ message, processorId, lastCheckpoint }, context) => {
+			const checkpoints = resolveDatabase(context).collection("emt_processor_checkpoints");
 			const currentPosition = (await checkpoints.findOne((d) => d._id === processorId))?.lastCheckpoint ?? null;
 			const newCheckpoint = getCheckpoint(message);
 			if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) return {
@@ -1502,6 +1524,49 @@ const inMemoryReactor = (options) => {
 	return Object.assign(processor, { database });
 };
 
+//#endregion
+//#region src/processors/processorStartPositions.ts
+const ProcessorStartPositions = (options) => {
+	const positions = /* @__PURE__ */ new Map();
+	return {
+		set: (processorId, position) => {
+			positions.set(processorId, position);
+		},
+		with: (expected) => [...positions.entries()].filter(([, position]) => position === expected).map((p) => p[0]),
+		zip: () => CurrentMessageProcessorPosition.zip([...positions.values()], options?.compareCheckpoints),
+		afterStartPosition: (processorId, messages) => {
+			const position = positions.get(processorId);
+			if (position === void 0 || position === "BEGINNING" || position === "END") return messages;
+			const { lastCheckpoint } = position;
+			return messages.filter((message) => {
+				const checkpoint = getCheckpoint(message);
+				return checkpoint !== null && checkpoint > lastCheckpoint;
+			});
+		}
+	};
+};
+const ConsumerStartPositions = { resolve: async ({ processors, handlerContext: handlerOptions, readLastMessageCheckpoint, compareCheckpoints }) => {
+	const positions = ProcessorStartPositions({ compareCheckpoints });
+	await Promise.all(processors.map(async (o) => {
+		try {
+			const position = await o.start(handlerOptions);
+			positions.set(o.id, position);
+		} catch (error) {
+			console.log(`Error during processor start position retrieval for processor: ${o.id}. Stopping it.`, error);
+			throw error;
+		}
+	}));
+	const endProcessorIds = positions.with("END");
+	if (endProcessorIds.length > 0) {
+		const lastCheckpoint = await readLastMessageCheckpoint(handlerOptions);
+		for (const processorId of endProcessorIds) positions.set(processorId, lastCheckpoint ? { lastCheckpoint } : "BEGINNING");
+	}
+	return {
+		earliestPosition: positions.zip(),
+		afterStartPosition: (processorId, messages) => positions.afterStartPosition(processorId, messages)
+	};
+} };
+
 //#endregion
 //#region src/eventStore/projections/inMemory/inMemoryProjection.ts
 const DATABASE_REQUIRED_ERROR_MESSAGE = "Database is required in context for InMemory projections";
@@ -2856,6 +2921,8 @@ var src_exports = /* @__PURE__ */ require_plugins.__exportAll({
 	CommandHandlerStreamVersionConflictRetryOptions: () => CommandHandlerStreamVersionConflictRetryOptions,
 	ConcurrencyError: () => require_plugins.ConcurrencyError,
 	ConcurrencyInMemoryDatabaseError: () => require_plugins.ConcurrencyInMemoryDatabaseError,
+	ConsumerStartPositions: () => ConsumerStartPositions,
+	CurrentMessageProcessorPosition: () => CurrentMessageProcessorPosition,
 	DATABASE_REQUIRED_ERROR_MESSAGE: () => DATABASE_REQUIRED_ERROR_MESSAGE,
 	DeciderCommandHandler: () => DeciderCommandHandler,
 	DeciderSpecification: () => DeciderSpecification,
@@ -2881,6 +2948,7 @@ var src_exports = /* @__PURE__ */ require_plugins.__exportAll({
 	NoRetries: () => NoRetries,
 	NotFoundError: () => require_plugins.NotFoundError,
 	ProcessorCheckpoint: () => ProcessorCheckpoint,
+	ProcessorStartPositions: () => ProcessorStartPositions,
 	STREAM_DOES_NOT_EXIST: () => STREAM_DOES_NOT_EXIST,
 	STREAM_EXISTS: () => STREAM_EXISTS,
 	ScopeTypes: () => ScopeTypes,
@@ -3021,6 +3089,8 @@ exports.CommandHandler = CommandHandler;
 exports.CommandHandlerStreamVersionConflictRetryOptions = CommandHandlerStreamVersionConflictRetryOptions;
 exports.ConcurrencyError = require_plugins.ConcurrencyError;
 exports.ConcurrencyInMemoryDatabaseError = require_plugins.ConcurrencyInMemoryDatabaseError;
+exports.ConsumerStartPositions = ConsumerStartPositions;
+exports.CurrentMessageProcessorPosition = CurrentMessageProcessorPosition;
 exports.DATABASE_REQUIRED_ERROR_MESSAGE = DATABASE_REQUIRED_ERROR_MESSAGE;
 exports.DeciderCommandHandler = DeciderCommandHandler;
 exports.DeciderSpecification = DeciderSpecification;
@@ -3046,6 +3116,7 @@ exports.NO_CONCURRENCY_CHECK = NO_CONCURRENCY_CHECK;
 exports.NoRetries = NoRetries;
 exports.NotFoundError = require_plugins.NotFoundError;
 exports.ProcessorCheckpoint = ProcessorCheckpoint;
+exports.ProcessorStartPositions = ProcessorStartPositions;
 exports.STREAM_DOES_NOT_EXIST = STREAM_DOES_NOT_EXIST;
 exports.STREAM_EXISTS = STREAM_EXISTS;
 exports.ScopeTypes = ScopeTypes;