@event-driven-io/emmett 0.43.0-beta.14 → 0.43.0-beta.16

package/dist/index.js

@@ -1,6 +1,7 @@
 import { _ as isValidYYYYMMDD, a as IllegalStateError, c as isErrorConstructor, d as assertPositiveNumber, f as assertUnsignedBigInt, g as formatDateToUtcYYYYMMDD, h as isString, i as EmmettError, l as ValidationErrors, m as isNumber, n as ConcurrencyError, o as NotFoundError, p as isBigint, r as ConcurrencyInMemoryDatabaseError, s as ValidationError, t as isPluginConfig, u as assertNotEmptyString, v as parseDateFromUtcYYYYMMDD } from "./plugins-CUbnGFPp.js";
 import { v4, v7 } from "uuid";
 import retry from "async-retry";
+import { MessagingAttributes, ObservabilityScope, noopMeter, noopTracer } from "@event-driven-io/almanac";
 
 //#region src/eventStore/afterCommit/afterEventStoreCommitHandler.ts
 async function tryPublishMessagesAfterCommit(messages, options, context) {
@@ -1068,14 +1069,27 @@ const reactor = (options) => {
 		canHandle,
 		init,
 		start: async (startOptions) => {
-			if (isActive) return;
+			if (isActive) {
+				console.log(`Processor ${processorId} with instance id ${instanceId} is already active. Start request ignored.`);
+				return;
+			}
+			console.log(`Starting processor ${processorId} with instance id ${instanceId}`);
 			await init(startOptions);
 			isActive = true;
 			closeSignal = onShutdown(() => close(startOptions));
-			if (lastCheckpoint !== null) return { lastCheckpoint };
+			if (lastCheckpoint !== null) {
+				console.log(`Processor ${processorId} started with instance id ${instanceId}, checkpoint: ${JSONSerializer.serialize(lastCheckpoint)}`);
+				return { lastCheckpoint };
+			}
 			return await processingScope(async (context) => {
-				if (hooks.onStart) await hooks.onStart(context);
-				if (startFrom && startFrom !== "CURRENT") return startFrom;
+				if (hooks.onStart) {
+					console.log(`Executing onStart hook for processor ${processorId} with instance id ${instanceId}`);
+					await hooks.onStart(context);
+				}
+				if (startFrom && startFrom !== "CURRENT") {
+					console.log(`Processor ${processorId} with instance id ${instanceId} starting from: ${JSONSerializer.serialize(startFrom)}`);
+					return startFrom;
+				}
 				if (checkpoints) lastCheckpoint = (await checkpoints?.read({
 					processorId,
 					partition
@@ -1083,7 +1097,11 @@ const reactor = (options) => {
 					...startOptions,
 					...context
 				})).lastCheckpoint;
-				if (lastCheckpoint === null) return "BEGINNING";
+				if (lastCheckpoint === null) {
+					console.log(`Processor ${processorId} with instance id ${instanceId} starting from: BEGINNING`);
+					return "BEGINNING";
+				}
+				console.log(`Checkpoint read for processor ${processorId} with instance id ${instanceId}: ${JSONSerializer.serialize(lastCheckpoint)}`);
 				return { lastCheckpoint };
 			}, startOptions);
 		},
@@ -1093,34 +1111,44 @@ const reactor = (options) => {
 		},
 		handle: async (messages, partialContext) => {
 			if (!isActive) return Promise.resolve();
-			return await processingScope(async (context) => {
-				const messagesAboveCheckpoint = messages.filter((message) => !wasMessageHandled(message, lastCheckpoint));
-				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;
-				const batchResult = await eachBatch(unhandledMessages, context);
-				const messageProcessingResult = batchResult?.type === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
+			try {
+				return await processingScope(async (context) => {
+					const messagesAboveCheckpoint = messages.filter((message) => !wasMessageHandled(message, lastCheckpoint));
+					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;
+					const batchResult = await eachBatch(unhandledMessages, context);
+					const messageProcessingResult = batchResult?.type === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
+						type: "STOP",
+						reason: "Stop condition reached",
+						lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
+					} : 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({
+							processorId,
+							version,
+							message: checkpointMessage,
+							lastCheckpoint,
+							partition
+						}, context);
+						if (storeCheckpointResult.success) lastCheckpoint = storeCheckpointResult.newCheckpoint;
+					}
+					if (isStop) {
+						isActive = false;
+						return messageProcessingResult;
+					}
+				}, partialContext);
+			} catch (error) {
+				console.log(`Error during message processing for processor ${processorId} with instance id ${instanceId}. Stopping the processor.`, error);
+				isActive = false;
+				return {
 					type: "STOP",
-					reason: "Stop condition reached",
-					lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
-				} : 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({
-						processorId,
-						version,
-						message: checkpointMessage,
-						lastCheckpoint,
-						partition
-					}, context);
-					if (storeCheckpointResult.success) lastCheckpoint = storeCheckpointResult.newCheckpoint;
-				}
-				if (isStop) {
-					isActive = false;
-					return messageProcessingResult;
-				}
-			}, partialContext);
+					error,
+					reason: "Error during message processing"
+				};
+			}
 		}
 	};
 };
@@ -1372,9 +1400,12 @@ const assertNotDeepEqual = (actual, expected, message) => {
 const assertThat = (item) => {
 	return { isEqualTo: (other) => assertTrue(deepEquals(item, other)) };
 };
-const assertDefined = (value, message) => {
-	assertOk(value, message instanceof Error ? message.message : message);
-};
+function assertDefined(value, message) {
+	if (value === void 0 || value === null) throw new AssertionError((message instanceof Error ? message.message : message) ?? "Value is not defined");
+}
+function assertUndefined(value, message) {
+	if (value !== void 0 && value !== null) throw new AssertionError((message instanceof Error ? message.message : message) ?? "Value is defined");
+}
 function assertFalse(condition, message) {
 	if (condition !== false) throw new AssertionError(message ?? `Condition is true`);
 }
@@ -1853,6 +1884,247 @@ const getInMemoryEventStore = (eventStoreOptions) => {
 	return eventStore;
 };
 
+//#endregion
+//#region src/observability/attributes.ts
+const EmmettAttributes = {
+	scope: { type: "emmett.scope.type" },
+	command: {
+		type: "emmett.command.type",
+		status: "emmett.command.status",
+		eventCount: "emmett.command.event_count",
+		eventTypes: "emmett.command.event_types"
+	},
+	stream: {
+		name: "emmett.stream.name",
+		versionBefore: "emmett.stream.version.before",
+		versionAfter: "emmett.stream.version.after"
+	},
+	eventStore: {
+		operation: "emmett.eventstore.operation",
+		read: {
+			eventCount: "emmett.eventstore.read.event_count",
+			eventTypes: "emmett.eventstore.read.event_types",
+			status: "emmett.eventstore.read.status"
+		},
+		append: {
+			batchSize: "emmett.eventstore.append.batch_size",
+			status: "emmett.eventstore.append.status"
+		}
+	},
+	event: { type: "emmett.event.type" },
+	processor: {
+		id: "emmett.processor.id",
+		type: "emmett.processor.type",
+		status: "emmett.processor.status",
+		batchSize: "emmett.processor.batch_size",
+		eventTypes: "emmett.processor.event_types",
+		checkpointBefore: "emmett.processor.checkpoint.before",
+		checkpointAfter: "emmett.processor.checkpoint.after",
+		lagEvents: "emmett.processor.lag_events"
+	},
+	workflow: {
+		id: "emmett.workflow.id",
+		type: "emmett.workflow.type",
+		inputType: "emmett.workflow.input.type",
+		outputs: "emmett.workflow.outputs",
+		outputsCount: "emmett.workflow.outputs.count",
+		streamPosition: "emmett.workflow.stream_position",
+		stateRebuildEventCount: "emmett.workflow.state_rebuild.event_count"
+	},
+	consumer: {
+		batchSize: "emmett.consumer.batch_size",
+		processorCount: "emmett.consumer.processor_count",
+		delivery: { processorId: "emmett.consumer.delivery.processor_id" }
+	}
+};
+const EmmettMetrics = {
+	command: { handlingDuration: "emmett.command.handling.duration" },
+	event: {
+		appendingCount: "emmett.event.appending.count",
+		readingCount: "emmett.event.reading.count"
+	},
+	stream: {
+		readingDuration: "emmett.stream.reading.duration",
+		readingSize: "emmett.stream.reading.size",
+		appendingDuration: "emmett.stream.appending.duration",
+		appendingSize: "emmett.stream.appending.size"
+	},
+	processor: {
+		processingDuration: "emmett.processor.processing.duration",
+		lagEvents: "emmett.processor.lag_events"
+	},
+	workflow: { processingDuration: "emmett.workflow.processing.duration" },
+	consumer: {
+		pollDuration: "emmett.consumer.poll.duration",
+		deliveryDuration: "emmett.consumer.delivery.duration"
+	}
+};
+const ScopeTypes = {
+	command: "command",
+	processor: "processor",
+	reactor: "reactor",
+	projector: "projector",
+	workflow: "workflow",
+	consumer: "consumer"
+};
+const MessagingSystemName = "emmett";
+
+//#endregion
+//#region src/observability/options.ts
+const resolveCommandObservability = (options, parent) => ({
+	tracer: options?.observability?.tracer ?? parent?.observability?.tracer ?? noopTracer(),
+	meter: options?.observability?.meter ?? parent?.observability?.meter ?? noopMeter(),
+	attributeTarget: options?.observability?.attributeTarget ?? parent?.observability?.attributeTarget ?? "both",
+	includeMessagePayloads: options?.observability?.includeMessagePayloads ?? parent?.observability?.includeMessagePayloads ?? false
+});
+
+//#endregion
+//#region src/observability/tracer.ts
+const tracer = () => {};
+const LogLevel = {
+	DISABLED: "DISABLED",
+	INFO: "INFO",
+	LOG: "LOG",
+	WARN: "WARN",
+	ERROR: "ERROR"
+};
+const getEnvVariable = (name) => {
+	try {
+		if (typeof process !== "undefined" && process.env) return process.env[name];
+		return;
+	} catch {
+		return;
+	}
+};
+const shouldLog = (logLevel) => {
+	const definedLogLevel = getEnvVariable("DUMBO_LOG_LEVEL") ?? LogLevel.ERROR;
+	if (definedLogLevel === LogLevel.ERROR && logLevel === LogLevel.ERROR) return true;
+	if (definedLogLevel === LogLevel.WARN && [LogLevel.ERROR, LogLevel.WARN].includes(logLevel)) return true;
+	if (definedLogLevel === LogLevel.LOG && [
+		LogLevel.ERROR,
+		LogLevel.WARN,
+		LogLevel.LOG
+	].includes(logLevel)) return true;
+	if (definedLogLevel === LogLevel.INFO && [
+		LogLevel.ERROR,
+		LogLevel.WARN,
+		LogLevel.LOG,
+		LogLevel.INFO
+	].includes(logLevel)) return true;
+	return false;
+};
+const nulloTraceEventRecorder = () => {};
+const getTraceEventFormatter = (logStyle, serializer) => (event) => {
+	serializer = serializer ?? JSONSerializer.from();
+	switch (logStyle) {
+		case "RAW": return serializer.serialize(event);
+		case "PRETTY": return serializer.serialize(event);
+	}
+};
+const getTraceEventRecorder = (logLevel, logStyle) => {
+	const format = getTraceEventFormatter(logStyle);
+	switch (logLevel) {
+		case "DISABLED": return nulloTraceEventRecorder;
+		case "INFO": return (event) => console.info(format(event));
+		case "LOG": return (event) => console.log(format(event));
+		case "WARN": return (event) => console.warn(format(event));
+		case "ERROR": return (event) => console.error(format(event));
+	}
+};
+const recordTraceEvent = (logLevel, eventName, attributes) => {
+	if (!shouldLog(LogLevel.LOG)) return;
+	const event = {
+		name: eventName,
+		timestamp: (/* @__PURE__ */ new Date()).getTime(),
+		...attributes
+	};
+	getTraceEventRecorder(logLevel, getEnvVariable("DUMBO_LOG_STYLE") ?? "RAW")(event);
+};
+tracer.info = (eventName, attributes) => recordTraceEvent(LogLevel.INFO, eventName, attributes);
+tracer.warn = (eventName, attributes) => recordTraceEvent(LogLevel.WARN, eventName, attributes);
+tracer.log = (eventName, attributes) => recordTraceEvent(LogLevel.LOG, eventName, attributes);
+tracer.error = (eventName, attributes) => recordTraceEvent(LogLevel.ERROR, eventName, attributes);
+
+//#endregion
+//#region src/commandHandling/observability/commandHandlerCollector.ts
+const commandHandlerCollector = (observability) => {
+	const { startScope } = ObservabilityScope({
+		...observability,
+		attributePrefix: "emmett"
+	});
+	const A = EmmettAttributes;
+	const M = MessagingAttributes;
+	const commandHandlingDuration = observability.meter.histogram(EmmettMetrics.command.handlingDuration);
+	const eventAppendingCount = observability.meter.counter(EmmettMetrics.event.appendingCount);
+	return {
+		startScope: (context, fn) => {
+			const start = Date.now();
+			return startScope("command.handle", async (scope) => {
+				scope.setAttributes({
+					[A.scope.type]: ScopeTypes.command,
+					[M.system]: MessagingSystemName,
+					[M.destination.name]: context.streamName,
+					...context.commandType ? { [A.command.type]: context.commandType } : {},
+					...context.correlationId ? { [M.message.correlationId]: context.correlationId } : {},
+					...context.causationId ? { [M.message.causationId]: context.causationId } : {}
+				});
+				let status = "success";
+				try {
+					const result = await fn(scope);
+					status = "success";
+					scope.setAttributes({
+						[A.command.status]: "success",
+						error: false
+					});
+					return result;
+				} catch (err) {
+					status = "failure";
+					scope.setAttributes({
+						[A.command.status]: "failure",
+						error: true,
+						"exception.message": err instanceof Error ? err.message : String(err),
+						"exception.type": err instanceof Error ? err.constructor.name : "unknown"
+					});
+					scope.recordException(err instanceof Error ? err : new Error(String(err)));
+					throw err;
+				} finally {
+					commandHandlingDuration.record(Date.now() - start, {
+						[A.command.status]: status,
+						...typeof context.commandType === "string" ? { [A.command.type]: context.commandType } : {}
+					});
+				}
+			}, {
+				parent: context.traceId && context.spanId ? {
+					traceId: context.traceId,
+					spanId: context.spanId
+				} : void 0,
+				attributes: {
+					[A.scope.type]: ScopeTypes.command,
+					[A.stream.name]: context.streamName,
+					...context.commandType ? { [A.command.type]: context.commandType } : {},
+					...context.correlationId ? { [M.message.correlationId]: context.correlationId } : {},
+					...context.causationId ? { [M.message.causationId]: context.causationId } : {}
+				}
+			});
+		},
+		recordEvents: (scope, events, status) => {
+			scope.setAttributes({
+				[A.command.eventCount]: events.length,
+				[A.command.eventTypes]: events.map((e) => e.type),
+				[M.batch.messageCount]: events.length,
+				[A.command.status]: status
+			});
+			for (const event of events) eventAppendingCount.add(1, { [A.event.type]: event.type });
+		},
+		recordVersions: (scope, before, after) => {
+			scope.setAttributes({
+				[A.stream.versionBefore]: Number(before),
+				[A.stream.versionAfter]: Number(after)
+			});
+		}
+	};
+};
+
 //#endregion
 //#region src/commandHandling/handleCommand.ts
 const CommandHandlerStreamVersionConflictRetryOptions = {
@@ -1861,6 +2133,76 @@ const CommandHandlerStreamVersionConflictRetryOptions = {
 	factor: 1.5,
 	shouldRetryError: isExpectedVersionConflictError
 };
+const CommandHandler = (options) => async (store, id, handle, handleOptions) => {
+	const collector = commandHandlerCollector(resolveCommandObservability(options));
+	const streamName = (options.mapToStreamId ?? ((id) => id))(id);
+	const commandType = handleOptions?.commandType ?? options.commandType ?? options.name ?? handlerNames(handle);
+	const correlationId = handleOptions?.observability?.correlationId ?? v7();
+	const causationId = handleOptions?.observability?.causationId;
+	return asyncRetry(() => collector.startScope({
+		streamName,
+		commandType,
+		correlationId,
+		causationId,
+		traceId: handleOptions?.observability?.traceId,
+		spanId: handleOptions?.observability?.spanId
+	}, async (scope) => {
+		return await withSession$1(store, async ({ eventStore }) => {
+			const { evolve, initialState } = options;
+			const aggregationResult = await eventStore.aggregateStream(streamName, {
+				evolve,
+				initialState,
+				read: {
+					schema: options.schema,
+					...handleOptions,
+					serialization: options.serialization,
+					expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
+				}
+			});
+			const { currentStreamVersion, streamExists: _streamExists, ...restOfAggregationResult } = aggregationResult;
+			let state = aggregationResult.state;
+			const handlers = Array.isArray(handle) ? handle : [handle];
+			let eventsToAppend = [];
+			for (const handler of handlers) {
+				const result = await handler(state);
+				const newEvents = Array.isArray(result) ? result : [result];
+				if (newEvents.length > 0) state = newEvents.reduce(evolve, state);
+				eventsToAppend = [...eventsToAppend, ...newEvents];
+			}
+			if (eventsToAppend.length === 0) {
+				collector.recordVersions(scope, currentStreamVersion, currentStreamVersion);
+				return {
+					...restOfAggregationResult,
+					newEvents: [],
+					newState: state,
+					nextExpectedStreamVersion: currentStreamVersion,
+					createdNewStream: false
+				};
+			}
+			const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : "STREAM_DOES_NOT_EXIST");
+			const { traceId, spanId } = scope.spanContext();
+			const { observability: _appendObservability, ...handleOptionsForAppend } = handleOptions ?? {};
+			const appendResult = await eventStore.appendToStream(streamName, eventsToAppend, {
+				...handleOptionsForAppend,
+				expectedStreamVersion,
+				correlationId,
+				...causationId ? { causationId } : {},
+				traceId,
+				spanId
+			});
+			collector.recordEvents(scope, eventsToAppend, "success");
+			collector.recordVersions(scope, currentStreamVersion, appendResult.nextExpectedStreamVersion);
+			return {
+				...appendResult,
+				newEvents: eventsToAppend,
+				newState: state
+			};
+		});
+	}), fromCommandHandlerRetryOptions(handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry));
+};
+const withSession$1 = (eventStore, callback) => {
+	return (canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore)).withSession(callback);
+};
 const fromCommandHandlerRetryOptions = (retryOptions) => {
 	if (retryOptions === void 0) return NoRetries;
 	if ("onVersionConflict" in retryOptions) if (typeof retryOptions.onVersionConflict === "boolean") return CommandHandlerStreamVersionConflictRetryOptions;
@@ -1871,58 +2213,24 @@ const fromCommandHandlerRetryOptions = (retryOptions) => {
 	else return retryOptions.onVersionConflict;
 	return retryOptions;
 };
-const CommandHandler = (options) => async (store, id, handle, handleOptions) => asyncRetry(async () => {
-	return await withSession$1(store, async ({ eventStore }) => {
-		const { evolve, initialState } = options;
-		const streamName = (options.mapToStreamId ?? ((id) => id))(id);
-		const aggregationResult = await eventStore.aggregateStream(streamName, {
-			evolve,
-			initialState,
-			read: {
-				schema: options.schema,
-				...handleOptions,
-				serialization: options.serialization,
-				expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
-			}
-		});
-		const { currentStreamVersion, streamExists: _streamExists, ...restOfAggregationResult } = aggregationResult;
-		let state = aggregationResult.state;
-		const handlers = Array.isArray(handle) ? handle : [handle];
-		let eventsToAppend = [];
-		for (const handler of handlers) {
-			const result = await handler(state);
-			const newEvents = Array.isArray(result) ? result : [result];
-			if (newEvents.length > 0) state = newEvents.reduce(evolve, state);
-			eventsToAppend = [...eventsToAppend, ...newEvents];
-		}
-		if (eventsToAppend.length === 0) return {
-			...restOfAggregationResult,
-			newEvents: [],
-			newState: state,
-			nextExpectedStreamVersion: currentStreamVersion,
-			createdNewStream: false
-		};
-		const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : "STREAM_DOES_NOT_EXIST");
-		return {
-			...await eventStore.appendToStream(streamName, eventsToAppend, {
-				...handleOptions,
-				expectedStreamVersion
-			}),
-			newEvents: eventsToAppend,
-			newState: state
-		};
-	});
-}, fromCommandHandlerRetryOptions(handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry));
-const withSession$1 = (eventStore, callback) => {
-	return (canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore)).withSession(callback);
+const handlerNames = (handle) => {
+	if (Array.isArray(handle)) {
+		const names = handle.map((h) => h.name).filter((n) => !!n);
+		return names.length > 0 ? names : void 0;
+	}
+	return handle.name || void 0;
 };
 
 //#endregion
 //#region src/commandHandling/handleCommandWithDecider.ts
+const commandTypesOf = (commands) => Array.isArray(commands) ? commands.map((c) => c.type) : commands.type;
 const DeciderCommandHandler = (options) => async (eventStore, id, commands, handleOptions) => {
 	const { decide, ...rest } = options;
 	const deciders = (Array.isArray(commands) ? commands : [commands]).map((command) => (state) => decide(command, state));
-	return CommandHandler(rest)(eventStore, id, deciders, handleOptions);
+	return CommandHandler(rest)(eventStore, id, deciders, {
+		commandType: commandTypesOf(commands),
+		...handleOptions
+	});
 };
 
 //#endregion
@@ -2201,5 +2509,5 @@ const workflowProcessor = (options) => {
 };
 
 //#endregion
-export { AssertionError, CommandHandler, CommandHandlerStreamVersionConflictRetryOptions, ConcurrencyError, ConcurrencyInMemoryDatabaseError, DATABASE_REQUIRED_ERROR_MESSAGE, DeciderCommandHandler, DeciderSpecification, EmmettError, ExpectedVersionConflictError, GlobalStreamCaughtUpType, IllegalStateError, InMemoryEventStoreDefaultStreamVersion, InMemoryProjectionSpec, InProcessLock, JSONCodec, JSONReplacer, JSONReplacers, JSONReviver, JSONRevivers, JSONSerializer, MessageProcessor, MessageProcessorType, NO_CONCURRENCY_CHECK, NoRetries, NotFoundError, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, TaskProcessor, ValidationError, ValidationErrors, Workflow, WorkflowHandler, WorkflowHandlerStreamVersionConflictRetryOptions, WorkflowSpecification, WrapEventStore, argMatches, argValue, arrayUtils, assertDeepEqual, assertDefined, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUnsignedBigInt, asyncAwaiter, asyncProjections, asyncRetry, bigInt, bigIntProcessorCheckpoint, canCreateEventStoreSession, caughtUpEventFrom, command, composeJSONReplacers, composeJSONRevivers, deepEquals, defaultProcessingMessageProcessingScope, defaultProcessorPartition, defaultProcessorVersion, defaultTag, delay, documentExists, downcastRecordedMessage, downcastRecordedMessages, emmettPrefix, event, eventInStream, eventsInStream, expectInMemoryDocuments, filterProjections, formatDateToUtcYYYYMMDD, forwardToMessageBus, getCheckpoint, getInMemoryDatabase, getInMemoryEventStore, getInMemoryMessageBus, getProcessorInstanceId, getProjectorId, getWorkflowId, globalStreamCaughtUp, globalTag, guardBoundedAccess, guardExclusiveAccess, guardInitializedOnce, handleInMemoryProjections, hashText, inMemoryCheckpointer, inMemoryMultiStreamProjection, inMemoryProjection, inMemoryProjector, inMemoryReactor, inMemorySingleStreamProjection, inlineProjections, isBigint, isEquatable, isErrorConstructor, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isPluginConfig, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, jsonSerializer, matchesExpectedVersion, merge, message, newEventsInStream, nulloSessionFactory, onShutdown, parseBigIntProcessorCheckpoint, parseDateFromUtcYYYYMMDD, projection, projections, projector, reactor, reduceAsync, sum, toNormalizedString, tryPublishMessagesAfterCommit, unknownTag, upcastRecordedMessage, upcastRecordedMessages, verifyThat, wasMessageHandled, workflowOutputHandler, workflowProcessor, workflowStreamName };
+export { AssertionError, CommandHandler, CommandHandlerStreamVersionConflictRetryOptions, ConcurrencyError, ConcurrencyInMemoryDatabaseError, DATABASE_REQUIRED_ERROR_MESSAGE, DeciderCommandHandler, DeciderSpecification, EmmettError, ExpectedVersionConflictError, GlobalStreamCaughtUpType, IllegalStateError, InMemoryEventStoreDefaultStreamVersion, InMemoryProjectionSpec, InProcessLock, JSONCodec, JSONReplacer, JSONReplacers, JSONReviver, JSONRevivers, JSONSerializer, MessageProcessor, MessageProcessorType, NO_CONCURRENCY_CHECK, NoRetries, NotFoundError, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, TaskProcessor, ValidationError, ValidationErrors, Workflow, WorkflowHandler, WorkflowHandlerStreamVersionConflictRetryOptions, WorkflowSpecification, WrapEventStore, argMatches, argValue, arrayUtils, assertDeepEqual, assertDefined, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUndefined, assertUnsignedBigInt, asyncAwaiter, asyncProjections, asyncRetry, bigInt, bigIntProcessorCheckpoint, canCreateEventStoreSession, caughtUpEventFrom, command, composeJSONReplacers, composeJSONRevivers, deepEquals, defaultProcessingMessageProcessingScope, defaultProcessorPartition, defaultProcessorVersion, defaultTag, delay, documentExists, downcastRecordedMessage, downcastRecordedMessages, emmettPrefix, event, eventInStream, eventsInStream, expectInMemoryDocuments, filterProjections, formatDateToUtcYYYYMMDD, forwardToMessageBus, getCheckpoint, getInMemoryDatabase, getInMemoryEventStore, getInMemoryMessageBus, getProcessorInstanceId, getProjectorId, getWorkflowId, globalStreamCaughtUp, globalTag, guardBoundedAccess, guardExclusiveAccess, guardInitializedOnce, handleInMemoryProjections, hashText, inMemoryCheckpointer, inMemoryMultiStreamProjection, inMemoryProjection, inMemoryProjector, inMemoryReactor, inMemorySingleStreamProjection, inlineProjections, isBigint, isEquatable, isErrorConstructor, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isPluginConfig, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, jsonSerializer, matchesExpectedVersion, merge, message, newEventsInStream, nulloSessionFactory, onShutdown, parseBigIntProcessorCheckpoint, parseDateFromUtcYYYYMMDD, projection, projections, projector, reactor, reduceAsync, sum, toNormalizedString, tryPublishMessagesAfterCommit, unknownTag, upcastRecordedMessage, upcastRecordedMessages, verifyThat, wasMessageHandled, workflowOutputHandler, workflowProcessor, workflowStreamName };
 //# sourceMappingURL=index.js.map