@znight/messaging 0.0.0-stage → 0.1.1

package/dist/kafka.mjs

@@ -0,0 +1,517 @@
+import { _ as consumerError, a as sleep, c as attemptFromHeaders, g as brokerUnavailableError, l as headerRecord, o as truncate, r as errorMessage, s as MessagingHeaders, t as MAX_TIMER_DELAY_MS } from "./async-CFh_bvex.mjs";
+import { r as durationOption, t as MAX_ERROR_HEADER_LENGTH } from "./shared-BJBpLS8V.mjs";
+import { Admin, Consumer, MessagesStreamFallbackModes, MessagesStreamModes, ProduceAcks, Producer, stringDeserializer, stringSerializer } from "@platformatic/kafka";
+// src/drivers/kafka.ts
+const DEFAULT_MAX_RETRY_DELAY_MS = 9e5;
+/** Attempts of a topic creation failing with transient broker errors, and the first backoff (doubled each time). */
+const CREATE_TOPICS_ATTEMPTS = 3;
+const CREATE_TOPICS_BACKOFF_MS = 250;
+/** Headers carrying transport fields (not exposed as message headers). */
+const TRANSPORT_HEADERS = /* @__PURE__ */ new Set([
+	MessagingHeaders.Id,
+	MessagingHeaders.Type,
+	MessagingHeaders.ContentType,
+	MessagingHeaders.NotBefore
+]);
+/** Creates a {@link KafkaDriver}. */
+function kafka(options) {
+	return new KafkaDriver(options);
+}
+/** Kafka {@link MessagingDriver}. See the module documentation. */
+var KafkaDriver = class {
+	name = "kafka";
+	capabilities;
+	#options;
+	#clientId;
+	#subscriptions = /* @__PURE__ */ new Set();
+	/** Consumer group → topic, to refuse groups shared between topics. */
+	#groups = /* @__PURE__ */ new Map();
+	#logger = {
+		debug() {},
+		info() {},
+		warn() {},
+		error() {}
+	};
+	#producer;
+	#closed = false;
+	constructor(options) {
+		if (options === null || typeof options !== "object" || !Array.isArray(options.bootstrapBrokers) || options.bootstrapBrokers.length === 0) throw new TypeError("[znight] kafka(): the \"bootstrapBrokers\" option is required");
+		this.#options = options;
+		this.#clientId = options.clientId ?? "znight";
+		this.capabilities = Object.freeze({
+			nativeDelay: true,
+			maxNativeDelayMs: durationOption(options.maxRetryDelayMs, DEFAULT_MAX_RETRY_DELAY_MS, "kafka maxRetryDelayMs"),
+			maxInProcessDelayMs: durationOption(options.maxInProcessDelayMs, 0, "kafka maxInProcessDelayMs"),
+			deliveryCount: "header",
+			maxPublishDelayMs: 0
+		});
+	}
+	async connect(context) {
+		this.#logger = context.logger;
+		if (this.#closed) throw brokerUnavailableError("Kafka: the driver is closed, create a new one");
+		if (this.#producer !== void 0) return;
+		const producer = new Producer({
+			...this.#options.connection,
+			clientId: this.#clientId,
+			bootstrapBrokers: [...this.#options.bootstrapBrokers],
+			serializers: {
+				key: stringSerializer,
+				headerKey: stringSerializer,
+				headerValue: stringSerializer
+			}
+		});
+		try {
+			await producer.metadata({ topics: [] });
+		} catch (error) {
+			await producer.close().catch(() => void 0);
+			throw brokerUnavailableError(`Kafka: cannot reach ${this.#options.bootstrapBrokers.join(", ")}: ${errorMessage(error)}`, error);
+		}
+		this.#producer = producer;
+	}
+	async close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		const subscriptions = [...this.#subscriptions];
+		this.#subscriptions.clear();
+		await Promise.allSettled(subscriptions.map((subscription) => subscription.close()));
+		const producer = this.#producer;
+		this.#producer = void 0;
+		if (producer !== void 0) await producer.close().catch(() => void 0);
+	}
+	deadLetterName(topic) {
+		return this.#options.deadLetterName?.(topic) ?? `${topic}.dlq`;
+	}
+	#producerOrThrow(action) {
+		const producer = this.#producer;
+		if (producer === void 0) throw brokerUnavailableError(this.#closed ? `Kafka: cannot ${action}, the driver is closed` : `Kafka: cannot ${action} before connect()`);
+		return producer;
+	}
+	/** Produces one record and waits for the acknowledgement of all in-sync replicas. */
+	async produce(topic, value, headers, key, timestamp) {
+		await this.#producerOrThrow(`produce to "${topic}"`).send({
+			messages: [{
+				topic,
+				value,
+				headers: { ...headers },
+				...key === void 0 ? {} : { key },
+				...timestamp === void 0 ? {} : { timestamp: BigInt(timestamp) }
+			}],
+			acks: ProduceAcks.ALL
+		});
+	}
+	async publish(topic, message) {
+		if (message.delayMs > 0) throw new RangeError("[znight] The kafka driver does not support delayed publishing");
+		const headers = headerRecord();
+		for (const [name, value] of Object.entries(message.headers)) if (!TRANSPORT_HEADERS.has(name)) headers[name] = value;
+		headers[MessagingHeaders.Id] = message.id;
+		if (message.type !== void 0) headers[MessagingHeaders.Type] = message.type;
+		headers[MessagingHeaders.ContentType] = message.contentType;
+		try {
+			await this.produce(topic, Buffer.from(message.body), headers, message.key, message.timestamp);
+		} catch (error) {
+			throw brokerUnavailableError(`Kafka: producing to "${topic}" failed: ${errorMessage(error)}`, error);
+		}
+	}
+	async subscribe(topic, handler, options) {
+		this.#producerOrThrow(`subscribe to "${topic}"`);
+		const configuredGroup = options.options["groupId"];
+		if (configuredGroup !== void 0 && (typeof configuredGroup !== "string" || configuredGroup === "")) throw consumerError(`Kafka: the groupId of ${options.consumer} must be a non-empty string`);
+		const group = configuredGroup ?? `${this.#options.groupId ?? "znight"}.${topic}`;
+		const owner = this.#groups.get(group);
+		if (owner !== void 0 && owner !== topic) throw consumerError(`Kafka: consumer group "${group}" is used for "${owner}" and "${topic}"`, ["Each @Consumer needs its own consumer group: remove the groupId option or make it unique"]);
+		const retryTopic = options.maxAttempts > 1 ? this.#options.retryTopicName?.(topic, group) ?? `${group}.retry` : void 0;
+		const topics = [
+			topic,
+			retryTopic,
+			options.deadLetterQueue
+		].filter((name) => name !== void 0);
+		this.#groups.set(group, topic);
+		try {
+			await this.#ensureTopics(topics, options.consumer);
+		} catch (error) {
+			this.#groups.delete(group);
+			throw error;
+		}
+		const subscription = new KafkaSubscription({
+			driver: this,
+			topic,
+			group,
+			retryTopic,
+			handler,
+			options,
+			logger: this.#logger
+		});
+		try {
+			await subscription.start((groupId) => new Consumer({
+				...this.#options.connection,
+				...this.#options.consumer,
+				clientId: this.#clientId,
+				bootstrapBrokers: [...this.#options.bootstrapBrokers],
+				groupId,
+				autocommit: false,
+				deserializers: {
+					key: stringDeserializer,
+					headerKey: stringDeserializer,
+					headerValue: stringDeserializer
+				}
+			}), this.#options.fromBeginning === true);
+		} catch (error) {
+			this.#groups.delete(group);
+			await subscription.close();
+			throw brokerUnavailableError(`Kafka: cannot consume "${topic}": ${errorMessage(error)}`, error);
+		}
+		this.#subscriptions.add(subscription);
+		return {
+			cancel: async () => {
+				await subscription.cancel();
+			},
+			close: async () => {
+				this.#subscriptions.delete(subscription);
+				this.#groups.delete(group);
+				await subscription.close();
+			}
+		};
+	}
+	async #ensureTopics(topics, consumer) {
+		const admin = new Admin({
+			...this.#options.connection,
+			clientId: `${this.#clientId}-admin`,
+			bootstrapBrokers: [...this.#options.bootstrapBrokers]
+		});
+		try {
+			const existing = new Set(await admin.listTopics());
+			const missing = topics.filter((topic) => !existing.has(topic));
+			if (missing.length === 0) return;
+			const create = this.#options.createTopics;
+			if (create === void 0 || create === false) throw consumerError(`Kafka: topic(s) ${missing.map((name) => `"${name}"`).join(", ")} of ${consumer} do not exist`, ["Create them, or set kafka({ createTopics: true }) to let Znight create them"]);
+			await createMissingTopics(admin, missing, create === true ? {} : create, consumer);
+		} finally {
+			await admin.close().catch(() => void 0);
+		}
+	}
+};
+/**
+* Creates `topics`. A topic the broker reports as already existing counts as created: subscriptions
+* sharing a topic (a consumer and the collector of its dead letters) or other instances create it
+* concurrently, and the topic listing lags behind the controller, so it cannot tell on its own. The
+* client retries transient errors by itself, but not in a response that also reports an existing
+* topic (not retriable): then the topics still missing are retried here, with a short backoff.
+*/
+async function createMissingTopics(admin, topics, settings, consumer) {
+	let pending = topics;
+	for (let attempt = 1;; attempt++) try {
+		await admin.createTopics({
+			topics: [...pending],
+			partitions: settings.partitions ?? 1,
+			replicas: settings.replicas ?? 1
+		});
+		return;
+	} catch (error) {
+		const all = topicCreationFailures(error);
+		const failures = all.filter((failure) => failure.code !== "TOPIC_ALREADY_EXISTS");
+		if (failures.length === 0) return;
+		const failed = failures.every((failure) => failure.topic !== void 0) ? new Set(failures.map((failure) => failure.topic)) : void 0;
+		const listed = new Set(await admin.listTopics().catch(() => []));
+		pending = pending.filter((topic) => (failed?.has(topic) ?? true) && !listed.has(topic));
+		if (pending.length === 0) return;
+		const clientRetried = failures.length === all.length;
+		if (attempt >= CREATE_TOPICS_ATTEMPTS || clientRetried || failures.some((failure) => !failure.retriable)) {
+			const causes = new Set(failures.map(({ topic, code, message }) => `${topic === void 0 ? "" : `"${topic}" `}${code}: ${message}`));
+			throw brokerUnavailableError(`Kafka: cannot create topic(s) ${pending.map((name) => `"${name}"`).join(", ")} of ${consumer} (${attempt} attempt${attempt === 1 ? "" : "s"}): ${[...causes].join("; ")}`, error);
+		}
+		await sleep(CREATE_TOPICS_BACKOFF_MS * 2 ** (attempt - 1));
+	}
+}
+/**
+* The leaf errors of a failed `createTopics`: a `MultipleErrors` of the attempts of the client (only
+* the last one counts), each a `ResponseError` carrying the response and one `ProtocolError` per failed
+* topic (`path: /topics/<index>`), or a network error.
+*/
+function topicCreationFailures(error, response) {
+	const fields = error !== null && typeof error === "object" ? error : {};
+	const nested = fields["errors"];
+	if (Array.isArray(nested) && nested.length > 0) return (fields["response"] === void 0 ? nested.slice(-1) : nested).flatMap((inner) => topicCreationFailures(inner, fields["response"] ?? response));
+	const index = /^\/topics\/(\d+)$/.exec(String(fields["path"]))?.[1];
+	const topics = response?.topics;
+	const name = index !== void 0 && Array.isArray(topics) ? topics[Number(index)]?.name : void 0;
+	return [{
+		topic: typeof name === "string" ? name : void 0,
+		code: String(fields["apiId"] ?? fields["code"] ?? (error instanceof Error ? error.name : "UNKNOWN")),
+		message: String(fields["serverErrorMessage"] ?? errorMessage(error)),
+		retriable: fields["canRetry"] !== false
+	}];
+}
+/**
+* The consumers of one `@Consumer`: the main topic and, with retries, the retry topic. Records are
+* queued per partition; at most `concurrency` partitions are handled at once, one record at a time.
+*/
+var KafkaSubscription = class {
+	#config;
+	#partitions = /* @__PURE__ */ new Map();
+	#ready = [];
+	#sources = [];
+	#highWater;
+	#lowWater;
+	#idle = /* @__PURE__ */ new Set();
+	#running = 0;
+	#active = true;
+	#closed;
+	constructor(config) {
+		this.#config = config;
+		this.#highWater = Math.max(64, config.options.concurrency * 8);
+		this.#lowWater = Math.floor(this.#highWater / 2);
+	}
+	async start(createConsumer, fromBeginning) {
+		const { topic, group, retryTopic } = this.#config;
+		await this.#consume(createConsumer(group), topic, fromBeginning);
+		if (retryTopic !== void 0) await this.#consume(createConsumer(`${group}.retry`), retryTopic, true);
+	}
+	async #consume(consumer, topic, fromBeginning) {
+		const source = {
+			topic,
+			consumer,
+			stream: void 0,
+			buffered: 0,
+			paused: false,
+			assigned: void 0
+		};
+		this.#sources.push(source);
+		consumer.on("consumer:group:join", () => this.#onGroupJoin(source));
+		const stream = await consumer.consume({
+			topics: [topic],
+			autocommit: false,
+			mode: MessagesStreamModes.COMMITTED,
+			fallbackMode: fromBeginning ? MessagesStreamFallbackModes.EARLIEST : MessagesStreamFallbackModes.LATEST
+		});
+		source.stream = stream;
+		stream.on("data", (record) => this.#push(source, record));
+		stream.on("error", (error) => {
+			this.#config.logger.error(`Kafka: consumer stream of "${topic}" failed`, { err: error });
+		});
+	}
+	/** Stops dispatching: buffered records are dropped (not committed, consumed again later). */
+	async cancel() {
+		await Promise.resolve();
+		if (!this.#active) return;
+		this.#active = false;
+		for (const source of this.#sources) source.stream?.pause();
+		for (const queue of this.#partitions.values()) this.#dropBuffered(queue);
+		this.#ready.length = 0;
+	}
+	/** Waits for the records being handled, then leaves the consumer groups. Idempotent. */
+	close() {
+		this.#closed ??= this.#close();
+		return this.#closed;
+	}
+	async #close() {
+		await this.cancel();
+		if (this.#running > 0) await new Promise((resolve) => this.#idle.add(resolve));
+		await Promise.allSettled(this.#sources.map((source) => source.stream?.close()));
+		await Promise.allSettled(this.#sources.map((source) => source.consumer.close()));
+	}
+	/**
+	* A (re)join of the group, with its new assignment: the partitions this member lost belong to
+	* another one now, so their buffered records are dropped (the record being handled finishes).
+	*/
+	#onGroupJoin(source) {
+		const assigned = /* @__PURE__ */ new Set();
+		for (const assignment of source.consumer.assignments ?? []) if (assignment.topic === source.topic) for (const partition of assignment.partitions) assigned.add(partition);
+		source.assigned = assigned;
+		for (const queue of this.#partitions.values()) {
+			if (queue.source !== source || assigned.has(queue.partition)) continue;
+			this.#dropBuffered(queue);
+			queue.next = queue.running ? queue.records[0].offset + 1n : void 0;
+		}
+	}
+	/** Drops the records of `queue` that are not being handled. */
+	#dropBuffered(queue) {
+		if (queue.timer !== void 0) clearTimeout(queue.timer);
+		queue.timer = void 0;
+		const keep = queue.running ? queue.records.slice(0, 1) : [];
+		this.#unbuffer(queue.source, queue.records.length - keep.length);
+		queue.records.length = 0;
+		queue.records.push(...keep);
+	}
+	#push(source, record) {
+		if (!this.#active) return;
+		if (source.assigned !== void 0 && !source.assigned.has(record.partition)) return;
+		const key = `${record.topic}:${record.partition}`;
+		let queue = this.#partitions.get(key);
+		if (queue === void 0) {
+			queue = {
+				key,
+				source,
+				partition: record.partition,
+				records: [],
+				running: false,
+				queued: false,
+				timer: void 0,
+				next: void 0
+			};
+			this.#partitions.set(key, queue);
+		}
+		if (queue.next !== void 0 && record.offset < queue.next) return;
+		queue.next = record.offset + 1n;
+		queue.records.push(record);
+		source.buffered++;
+		if (!queue.running && !queue.queued && queue.timer === void 0) this.#enqueue(queue);
+		if (source.buffered >= this.#highWater) {
+			source.paused = true;
+			source.stream?.pause();
+		}
+		this.#pump();
+	}
+	/** `count` records of `source` left the partition queues: resume it below the low-water mark. */
+	#unbuffer(source, count) {
+		source.buffered -= count;
+		if (source.paused && this.#active && source.buffered <= this.#lowWater) {
+			source.paused = false;
+			source.stream?.resume();
+		}
+	}
+	#enqueue(queue) {
+		queue.queued = true;
+		this.#ready.push(queue);
+	}
+	#pump() {
+		while (this.#active && this.#running < this.#config.options.concurrency && this.#ready.length > 0) {
+			const queue = this.#ready.shift();
+			queue.queued = false;
+			const head = queue.records[0];
+			if (head === void 0) continue;
+			const wait = notBefore(head) - Date.now();
+			if (wait > 0) {
+				queue.timer = setTimeout(() => {
+					queue.timer = void 0;
+					if (!this.#active) return;
+					this.#enqueue(queue);
+					this.#pump();
+				}, Math.min(wait, this.#config.driver.capabilities.maxNativeDelayMs, MAX_TIMER_DELAY_MS));
+				continue;
+			}
+			queue.running = true;
+			this.#running++;
+			this.#work(queue, head).then(() => void 0, () => void 0);
+		}
+	}
+	async #work(queue, record) {
+		let outcome = "stop";
+		try {
+			outcome = await this.#process(record);
+		} catch (error) {
+			this.#config.logger.error(`Kafka: unexpected failure handling a record of ${queue.key}`, { err: error });
+			outcome = this.#active ? "again" : "stop";
+		} finally {
+			queue.running = false;
+			this.#running--;
+			const assigned = queue.source.assigned;
+			if (outcome === "again" && assigned !== void 0 && !assigned.has(queue.partition)) {
+				outcome = "stop";
+				queue.next = void 0;
+			}
+			if (outcome === "next") {
+				queue.records.shift();
+				this.#unbuffer(queue.source, 1);
+			} else if (outcome === "stop") {
+				const dropped = queue.records.length;
+				queue.records.length = 0;
+				this.#unbuffer(queue.source, dropped);
+			}
+			if (this.#active && queue.records.length > 0) this.#enqueue(queue);
+			if (this.#running === 0) {
+				const waiters = [...this.#idle];
+				this.#idle.clear();
+				for (const waiter of waiters) waiter();
+			}
+			this.#pump();
+		}
+	}
+	/** Hands one record to the runtime; resolves once it was settled. */
+	async #process(record) {
+		const { driver, topic, retryTopic, group, logger } = this.#config;
+		const all = headerRecord();
+		for (const [name, value] of record.headers) if (value !== void 0) all[name] = value;
+		const headers = headerRecord();
+		for (const [name, value] of Object.entries(all)) if (!TRANSPORT_HEADERS.has(name)) headers[name] = value;
+		const id = all[MessagingHeaders.Id] ?? `${record.topic}-${record.partition}-${record.offset}`;
+		const value = record.value ?? Buffer.alloc(0);
+		let settled = false;
+		let released = false;
+		const check = (action) => {
+			if (settled) throw new Error(`[kafka] record ${id} was already settled (${action})`);
+		};
+		/** Commits the offset. A failure (rebalance...) is not fatal: the record may be consumed again. */
+		const commit = async () => {
+			try {
+				await record.commit();
+			} catch (error) {
+				logger.warn(`Kafka: committing record ${id} of ${record.topic}:${record.partition} failed, it may be consumed again`, { err: error });
+			}
+		};
+		const copyHeaders = (extra, drop) => {
+			const result = headerRecord();
+			for (const [name, headerValue] of Object.entries(all)) if (!drop.includes(name)) result[name] = headerValue;
+			return Object.assign(result, extra);
+		};
+		const delivery = {
+			id,
+			body: value,
+			contentType: all[MessagingHeaders.ContentType],
+			headers,
+			type: all[MessagingHeaders.Type],
+			key: record.key ?? void 0,
+			attempt: attemptFromHeaders(all),
+			redelivered: attemptFromHeaders(all) > 1,
+			timestamp: Number(record.timestamp),
+			raw: record,
+			ack: async () => {
+				check("ack");
+				settled = true;
+				await commit();
+			},
+			release: async () => {
+				await Promise.resolve();
+				check("release");
+				settled = true;
+				released = true;
+			},
+			retry: async (request) => {
+				check("retry");
+				if (retryTopic === void 0) throw new Error(`[kafka] ${topic} has no retry topic (single attempt)`);
+				const extra = { [MessagingHeaders.Attempt]: String(request.attempt) };
+				if (request.delayMs > 0) extra[MessagingHeaders.NotBefore] = String(Date.now() + request.delayMs);
+				await driver.produce(retryTopic, value, copyHeaders(extra, [MessagingHeaders.NotBefore]), record.key ?? void 0);
+				settled = true;
+				await commit();
+			},
+			deadLetter: async (request) => {
+				check("dead-letter");
+				if (request.queue !== void 0) await driver.produce(request.queue, value, copyHeaders({
+					[MessagingHeaders.DeadLetterReason]: request.reason,
+					[MessagingHeaders.Error]: truncate(errorMessage(request.error), MAX_ERROR_HEADER_LENGTH),
+					[MessagingHeaders.OriginalQueue]: topic,
+					[MessagingHeaders.Attempts]: String(request.attempt),
+					[MessagingHeaders.ConsumerGroup]: group
+				}, [MessagingHeaders.Attempt, MessagingHeaders.NotBefore]), record.key ?? void 0);
+				settled = true;
+				await commit();
+			}
+		};
+		try {
+			await this.#config.handler(delivery);
+		} catch (error) {
+			logger.error(`Kafka: unexpected failure handling record ${id}`, { err: error });
+		}
+		if (released || !settled) return this.#active ? "again" : "stop";
+		return "next";
+	}
+};
+/** `x-znight-not-before` of a retry record (epoch ms), 0 when absent. */
+function notBefore(record) {
+	const value = record.headers.get(MessagingHeaders.NotBefore);
+	const time = value === void 0 ? 0 : Number(value);
+	return Number.isFinite(time) ? time : 0;
+}
+export { KafkaDriver, kafka };
+
+//# sourceMappingURL=kafka.mjs.map

package/dist/kafka.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.mjs","names":[],"sources":["../src/drivers/kafka.ts"],"sourcesContent":["/**\n * `@znight/messaging/kafka`: Apache Kafka driver built on\n * [@platformatic/kafka](https://github.com/platformatic/kafka) 2.x (optional peer dependency).\n *\n * - Each `@Consumer` uses its own consumer group: `<groupId>.<topic>` (or `@Consumer({ groupId })`),\n *   with manual commits: an offset is committed once its record was settled.\n * - Records of a partition are handled one after the other (ordering), different partitions\n *   concurrently up to the consumer concurrency.\n * - Retries are non-blocking: the record is produced to the group's retry topic (`<group>.retry`) with\n *   `x-znight-attempt` and `x-znight-not-before`, then committed. A dedicated retry consumer waits\n *   until `not-before` (bounded by `maxRetryDelayMs`) without blocking the main topic (each stream has\n *   its own back-pressure). Retried records lose their ordering relative to the partition.\n * - After a rebalance, records fetched again from the committed offset of a partition this member kept\n *   are skipped (already buffered or handled); buffered records of the partitions it lost are dropped.\n * - Dead letters are produced to `<topic>.dlq` (acks from all in-sync replicas), then committed.\n * - On stop, unsettled records are not committed: they are consumed again after a restart or rebalance.\n * - Delayed publishing is not supported.\n */\nimport type { ConsumerOptions, Message, MessagesStream, ProducerOptions } from '@platformatic/kafka'\nimport type {\n  DeadLetterRequest,\n  DeliveryHandler,\n  DriverCapabilities,\n  DriverContext,\n  DriverDelivery,\n  MessagingDriver,\n  RetryRequest,\n  SubscribeOptions,\n  Subscription,\n} from '../driver.ts'\nimport type { OutboundMessage } from '../message.ts'\n\nimport {\n  Admin,\n  Consumer,\n  MessagesStreamFallbackModes,\n  MessagesStreamModes,\n  ProduceAcks,\n  Producer,\n  stringDeserializer,\n  stringSerializer,\n} from '@platformatic/kafka'\n\nimport { brokerUnavailableError, consumerError } from '../errors.ts'\nimport { attemptFromHeaders, headerRecord, MessagingHeaders } from '../headers.ts'\nimport { errorMessage, MAX_TIMER_DELAY_MS, sleep, truncate } from '../internal/async.ts'\nimport { durationOption, MAX_ERROR_HEADER_LENGTH } from './shared.ts'\n\ntype KafkaRecord = Message<string, Buffer, string, string>\n\n/** Topic creation settings. */\nexport interface KafkaTopicOptions {\n  /** Partitions of created topics. Default: 1. */\n  readonly partitions?: number\n  /** Replication factor of created topics. Default: 1. */\n  readonly replicas?: number\n}\n\n/** Options of {@link kafka}. */\nexport interface KafkaDriverOptions {\n  /** `host:port` of the bootstrap brokers. */\n  readonly bootstrapBrokers: readonly string[]\n  /** Client id. Default: `znight`. */\n  readonly clientId?: string\n  /** Prefix of the consumer groups (`<groupId>.<topic>`), typically the service name. Default: `znight`. */\n  readonly groupId?: string\n  /** Options shared by the producer, the consumers and the admin client (tls, sasl, timeouts...). */\n  readonly connection?: Readonly<Partial<ProducerOptions<string, Buffer, string, string>>>\n  /** Extra consumer options (sessionTimeout, heartbeatInterval...). */\n  readonly consumer?: Readonly<Partial<ConsumerOptions<string, Buffer, string, string>>>\n  /** Start new consumer groups at the beginning of the topic (`earliest`). Default: `false` (latest). */\n  readonly fromBeginning?: boolean\n  /** Create missing topics at subscribe time; otherwise their existence is verified. Default: `false`. */\n  readonly createTopics?: boolean | KafkaTopicOptions\n  /** Name of the retry topic of a consumer group. Default: `${group}.retry`. */\n  readonly retryTopicName?: (topic: string, group: string) => string\n  /** Default dead-letter topic. Default: `${topic}.dlq`. */\n  readonly deadLetterName?: (topic: string) => string\n  /** Longest retry delay waited in-process before producing the retry (blocks the partition). Default: 0. */\n  readonly maxInProcessDelayMs?: number\n  /** Longest delay a retry record may wait in the retry consumer. Default: 15 minutes. */\n  readonly maxRetryDelayMs?: number\n}\n\nconst DEFAULT_MAX_RETRY_DELAY_MS = 15 * 60_000\n/** Attempts of a topic creation failing with transient broker errors, and the first backoff (doubled each time). */\nconst CREATE_TOPICS_ATTEMPTS = 3\nconst CREATE_TOPICS_BACKOFF_MS = 250\n/** Headers carrying transport fields (not exposed as message headers). */\nconst TRANSPORT_HEADERS = new Set<string>([\n  MessagingHeaders.Id,\n  MessagingHeaders.Type,\n  MessagingHeaders.ContentType,\n  MessagingHeaders.NotBefore,\n])\n\n/** Creates a {@link KafkaDriver}. */\nexport function kafka(options: KafkaDriverOptions): KafkaDriver {\n  return new KafkaDriver(options)\n}\n\n/** Kafka {@link MessagingDriver}. See the module documentation. */\nexport class KafkaDriver implements MessagingDriver {\n  readonly name = 'kafka'\n  readonly capabilities: DriverCapabilities\n  readonly #options: KafkaDriverOptions\n  readonly #clientId: string\n  readonly #subscriptions = new Set<KafkaSubscription>()\n  /** Consumer group → topic, to refuse groups shared between topics. */\n  readonly #groups = new Map<string, string>()\n  #logger: DriverContext['logger'] = { debug() {}, info() {}, warn() {}, error() {} }\n  #producer: Producer<string, Buffer, string, string> | undefined\n  #closed = false\n\n  constructor(options: KafkaDriverOptions) {\n    if (\n      options === null ||\n      typeof options !== 'object' ||\n      !Array.isArray(options.bootstrapBrokers) ||\n      options.bootstrapBrokers.length === 0\n    ) {\n      throw new TypeError('[znight] kafka(): the \"bootstrapBrokers\" option is required')\n    }\n    this.#options = options\n    this.#clientId = options.clientId ?? 'znight'\n    this.capabilities = Object.freeze({\n      nativeDelay: true,\n      maxNativeDelayMs: durationOption(options.maxRetryDelayMs, DEFAULT_MAX_RETRY_DELAY_MS, 'kafka maxRetryDelayMs'),\n      maxInProcessDelayMs: durationOption(options.maxInProcessDelayMs, 0, 'kafka maxInProcessDelayMs'),\n      deliveryCount: 'header',\n      maxPublishDelayMs: 0,\n    })\n  }\n\n  async connect(context: DriverContext): Promise<void> {\n    this.#logger = context.logger\n    if (this.#closed) throw brokerUnavailableError('Kafka: the driver is closed, create a new one')\n    if (this.#producer !== undefined) return\n    const producer = new Producer<string, Buffer, string, string>({\n      ...this.#options.connection,\n      clientId: this.#clientId,\n      bootstrapBrokers: [...this.#options.bootstrapBrokers],\n      serializers: { key: stringSerializer, headerKey: stringSerializer, headerValue: stringSerializer },\n    })\n    try {\n      await producer.metadata({ topics: [] })\n    } catch (error) {\n      await producer.close().catch(() => undefined)\n      throw brokerUnavailableError(\n        `Kafka: cannot reach ${this.#options.bootstrapBrokers.join(', ')}: ${errorMessage(error)}`,\n        error,\n      )\n    }\n    this.#producer = producer\n  }\n\n  async close(): Promise<void> {\n    if (this.#closed) return\n    this.#closed = true\n    const subscriptions = [...this.#subscriptions]\n    this.#subscriptions.clear()\n    await Promise.allSettled(subscriptions.map(subscription => subscription.close()))\n    const producer = this.#producer\n    this.#producer = undefined\n    if (producer !== undefined) await producer.close().catch(() => undefined)\n  }\n\n  deadLetterName(topic: string): string {\n    return this.#options.deadLetterName?.(topic) ?? `${topic}.dlq`\n  }\n\n  #producerOrThrow(action: string): Producer<string, Buffer, string, string> {\n    const producer = this.#producer\n    if (producer === undefined) {\n      throw brokerUnavailableError(\n        this.#closed ? `Kafka: cannot ${action}, the driver is closed` : `Kafka: cannot ${action} before connect()`,\n      )\n    }\n    return producer\n  }\n\n  /** Produces one record and waits for the acknowledgement of all in-sync replicas. */\n  async produce(\n    topic: string,\n    value: Buffer,\n    headers: Readonly<Record<string, string>>,\n    key: string | undefined,\n    timestamp?: number,\n  ): Promise<void> {\n    await this.#producerOrThrow(`produce to \"${topic}\"`).send({\n      messages: [\n        {\n          topic,\n          value,\n          headers: { ...headers },\n          ...(key === undefined ? {} : { key }),\n          ...(timestamp === undefined ? {} : { timestamp: BigInt(timestamp) }),\n        },\n      ],\n      acks: ProduceAcks.ALL,\n    })\n  }\n\n  async publish(topic: string, message: OutboundMessage): Promise<void> {\n    if (message.delayMs > 0) throw new RangeError('[znight] The kafka driver does not support delayed publishing')\n    const headers = headerRecord()\n    for (const [name, value] of Object.entries(message.headers)) if (!TRANSPORT_HEADERS.has(name)) headers[name] = value\n    headers[MessagingHeaders.Id] = message.id\n    if (message.type !== undefined) headers[MessagingHeaders.Type] = message.type\n    headers[MessagingHeaders.ContentType] = message.contentType\n    try {\n      await this.produce(topic, Buffer.from(message.body), headers, message.key, message.timestamp)\n    } catch (error) {\n      throw brokerUnavailableError(`Kafka: producing to \"${topic}\" failed: ${errorMessage(error)}`, error)\n    }\n  }\n\n  // -----------------------------------------------------------------------------------------------\n  // Consuming\n  // -----------------------------------------------------------------------------------------------\n\n  async subscribe(topic: string, handler: DeliveryHandler, options: SubscribeOptions): Promise<Subscription> {\n    this.#producerOrThrow(`subscribe to \"${topic}\"`)\n    const configuredGroup = options.options['groupId']\n    if (configuredGroup !== undefined && (typeof configuredGroup !== 'string' || configuredGroup === '')) {\n      throw consumerError(`Kafka: the groupId of ${options.consumer} must be a non-empty string`)\n    }\n    const group = configuredGroup ?? `${this.#options.groupId ?? 'znight'}.${topic}`\n    const owner = this.#groups.get(group)\n    if (owner !== undefined && owner !== topic) {\n      throw consumerError(`Kafka: consumer group \"${group}\" is used for \"${owner}\" and \"${topic}\"`, [\n        'Each @Consumer needs its own consumer group: remove the groupId option or make it unique',\n      ])\n    }\n    const retryTopic =\n      options.maxAttempts > 1 ? (this.#options.retryTopicName?.(topic, group) ?? `${group}.retry`) : undefined\n    const topics = [topic, retryTopic, options.deadLetterQueue].filter((name): name is string => name !== undefined)\n    this.#groups.set(group, topic) // reserved before any await: subscriptions may start concurrently\n    try {\n      await this.#ensureTopics(topics, options.consumer)\n    } catch (error) {\n      this.#groups.delete(group)\n      throw error\n    }\n\n    const subscription = new KafkaSubscription({\n      driver: this,\n      topic,\n      group,\n      retryTopic,\n      handler,\n      options,\n      logger: this.#logger,\n    })\n    try {\n      await subscription.start(\n        groupId =>\n          new Consumer<string, Buffer, string, string>({\n            ...this.#options.connection,\n            ...this.#options.consumer,\n            clientId: this.#clientId,\n            bootstrapBrokers: [...this.#options.bootstrapBrokers],\n            groupId,\n            autocommit: false,\n            deserializers: { key: stringDeserializer, headerKey: stringDeserializer, headerValue: stringDeserializer },\n          } as ConsumerOptions<string, Buffer, string, string>),\n        this.#options.fromBeginning === true,\n      )\n    } catch (error) {\n      this.#groups.delete(group)\n      await subscription.close()\n      throw brokerUnavailableError(`Kafka: cannot consume \"${topic}\": ${errorMessage(error)}`, error)\n    }\n    this.#subscriptions.add(subscription)\n    return {\n      cancel: async (): Promise<void> => {\n        await subscription.cancel()\n      },\n      close: async (): Promise<void> => {\n        this.#subscriptions.delete(subscription)\n        this.#groups.delete(group)\n        await subscription.close()\n      },\n    }\n  }\n\n  async #ensureTopics(topics: readonly string[], consumer: string): Promise<void> {\n    const admin = new Admin({\n      ...this.#options.connection,\n      clientId: `${this.#clientId}-admin`,\n      bootstrapBrokers: [...this.#options.bootstrapBrokers],\n    })\n    try {\n      const existing = new Set(await admin.listTopics())\n      const missing = topics.filter(topic => !existing.has(topic))\n      if (missing.length === 0) return\n      const create = this.#options.createTopics\n      if (create === undefined || create === false) {\n        throw consumerError(\n          `Kafka: topic(s) ${missing.map(name => `\"${name}\"`).join(', ')} of ${consumer} do not exist`,\n          ['Create them, or set kafka({ createTopics: true }) to let Znight create them'],\n        )\n      }\n      await createMissingTopics(admin, missing, create === true ? {} : create, consumer)\n    } finally {\n      await admin.close().catch(() => undefined)\n    }\n  }\n}\n\n/**\n * Creates `topics`. A topic the broker reports as already existing counts as created: subscriptions\n * sharing a topic (a consumer and the collector of its dead letters) or other instances create it\n * concurrently, and the topic listing lags behind the controller, so it cannot tell on its own. The\n * client retries transient errors by itself, but not in a response that also reports an existing\n * topic (not retriable): then the topics still missing are retried here, with a short backoff.\n */\nasync function createMissingTopics(\n  admin: Admin,\n  topics: readonly string[],\n  settings: KafkaTopicOptions,\n  consumer: string,\n): Promise<void> {\n  let pending = topics\n  for (let attempt = 1; ; attempt++) {\n    try {\n      await admin.createTopics({\n        topics: [...pending],\n        partitions: settings.partitions ?? 1,\n        replicas: settings.replicas ?? 1,\n      })\n      return\n    } catch (error) {\n      const all = topicCreationFailures(error)\n      const failures = all.filter(failure => failure.code !== 'TOPIC_ALREADY_EXISTS')\n      if (failures.length === 0) return\n      // a topic without an error was created, unless the request failed as a whole (timeout...)\n      const failed = failures.every(failure => failure.topic !== undefined)\n        ? new Set(failures.map(failure => failure.topic))\n        : undefined\n      // created in the meantime, by this request or concurrently\n      const listed = new Set(await admin.listTopics().catch((): string[] => []))\n      pending = pending.filter(topic => (failed?.has(topic) ?? true) && !listed.has(topic))\n      if (pending.length === 0) return\n      // without an existing topic in the response, the client already spent its own retries\n      const clientRetried = failures.length === all.length\n      if (attempt >= CREATE_TOPICS_ATTEMPTS || clientRetried || failures.some(failure => !failure.retriable)) {\n        const causes = new Set(\n          failures.map(({ topic, code, message }) => `${topic === undefined ? '' : `\"${topic}\" `}${code}: ${message}`),\n        )\n        throw brokerUnavailableError(\n          `Kafka: cannot create topic(s) ${pending.map(name => `\"${name}\"`).join(', ')} of ${consumer}` +\n            ` (${attempt} attempt${attempt === 1 ? '' : 's'}): ${[...causes].join('; ')}`,\n          error,\n        )\n      }\n      await sleep(CREATE_TOPICS_BACKOFF_MS * 2 ** (attempt - 1))\n    }\n  }\n}\n\n/** One error of a failed topic creation. */\ninterface TopicCreationFailure {\n  /** The topic it concerns, when the broker answered topic by topic. */\n  readonly topic: string | undefined\n  /** Kafka error (`TOPIC_ALREADY_EXISTS`, `REQUEST_TIMED_OUT`...) or client error code. */\n  readonly code: string\n  readonly message: string\n  /** Whether the client flags it as worth retrying. */\n  readonly retriable: boolean\n}\n\n/**\n * The leaf errors of a failed `createTopics`: a `MultipleErrors` of the attempts of the client (only\n * the last one counts), each a `ResponseError` carrying the response and one `ProtocolError` per failed\n * topic (`path: /topics/<index>`), or a network error.\n */\nfunction topicCreationFailures(error: unknown, response?: unknown): TopicCreationFailure[] {\n  const fields = (error !== null && typeof error === 'object' ? error : {}) as Record<string, unknown>\n  const nested = fields['errors']\n  if (Array.isArray(nested) && nested.length > 0) {\n    // the errors of a response are its topics; the errors of a retry wrapper are attempts\n    const inners = fields['response'] === undefined ? nested.slice(-1) : nested\n    return inners.flatMap(inner => topicCreationFailures(inner, fields['response'] ?? response))\n  }\n  const index = /^\\/topics\\/(\\d+)$/.exec(String(fields['path']))?.[1]\n  const topics = (response as { topics?: unknown } | null | undefined)?.topics\n  const name =\n    index !== undefined && Array.isArray(topics)\n      ? (topics[Number(index)] as { name?: unknown } | undefined)?.name\n      : undefined\n  return [\n    {\n      topic: typeof name === 'string' ? name : undefined,\n      code: String(fields['apiId'] ?? fields['code'] ?? (error instanceof Error ? error.name : 'UNKNOWN')),\n      message: String(fields['serverErrorMessage'] ?? errorMessage(error)),\n      retriable: fields['canRetry'] !== false,\n    },\n  ]\n}\n\n/**\n * A consumer of the subscription (main topic, or retry topic) with its stream and its back-pressure:\n * each stream is paused and resumed on its own, so that retries waiting for their `not-before` never\n * hold the main topic.\n */\ninterface StreamState {\n  readonly topic: string\n  readonly consumer: Consumer<string, Buffer, string, string>\n  stream: MessagesStream<string, Buffer, string, string> | undefined\n  /** Records of this stream in the partition queues (the ones being handled included). */\n  buffered: number\n  paused: boolean\n  /** Partitions of `topic` assigned by the last group join (`undefined` before the first one). */\n  assigned: ReadonlySet<number> | undefined\n}\n\ninterface PartitionQueue {\n  readonly key: string\n  readonly source: StreamState\n  readonly partition: number\n  readonly records: KafkaRecord[]\n  running: boolean\n  queued: boolean\n  timer: ReturnType<typeof setTimeout> | undefined\n  /**\n   * Offset following the last record pushed. After a rebalance the stream fetches the partitions it\n   * keeps again from their committed offset: older records were already buffered or handled.\n   */\n  next: bigint | undefined\n}\n\ninterface KafkaSubscriptionConfig {\n  readonly driver: KafkaDriver\n  readonly topic: string\n  readonly group: string\n  readonly retryTopic: string | undefined\n  readonly handler: DeliveryHandler\n  readonly options: SubscribeOptions\n  readonly logger: DriverContext['logger']\n}\n\ntype Outcome = 'next' | 'again' | 'stop'\n\n/**\n * The consumers of one `@Consumer`: the main topic and, with retries, the retry topic. Records are\n * queued per partition; at most `concurrency` partitions are handled at once, one record at a time.\n */\nclass KafkaSubscription {\n  readonly #config: KafkaSubscriptionConfig\n  readonly #partitions = new Map<string, PartitionQueue>()\n  readonly #ready: PartitionQueue[] = []\n  readonly #sources: StreamState[] = []\n  readonly #highWater: number\n  readonly #lowWater: number\n  readonly #idle = new Set<() => void>()\n  #running = 0\n  #active = true\n  #closed: Promise<void> | undefined\n\n  constructor(config: KafkaSubscriptionConfig) {\n    this.#config = config\n    this.#highWater = Math.max(64, config.options.concurrency * 8)\n    this.#lowWater = Math.floor(this.#highWater / 2)\n  }\n\n  async start(\n    createConsumer: (groupId: string) => Consumer<string, Buffer, string, string>,\n    fromBeginning: boolean,\n  ): Promise<void> {\n    const { topic, group, retryTopic } = this.#config\n    await this.#consume(createConsumer(group), topic, fromBeginning)\n    // the retry topic only holds records of this group: always read it from the beginning\n    if (retryTopic !== undefined) await this.#consume(createConsumer(`${group}.retry`), retryTopic, true)\n  }\n\n  async #consume(\n    consumer: Consumer<string, Buffer, string, string>,\n    topic: string,\n    fromBeginning: boolean,\n  ): Promise<void> {\n    const source: StreamState = { topic, consumer, stream: undefined, buffered: 0, paused: false, assigned: undefined }\n    this.#sources.push(source)\n    consumer.on('consumer:group:join', () => this.#onGroupJoin(source))\n    const stream = await consumer.consume({\n      topics: [topic],\n      autocommit: false,\n      mode: MessagesStreamModes.COMMITTED,\n      fallbackMode: fromBeginning ? MessagesStreamFallbackModes.EARLIEST : MessagesStreamFallbackModes.LATEST,\n    })\n    source.stream = stream\n    stream.on('data', (record: KafkaRecord) => this.#push(source, record))\n    stream.on('error', (error: Error) => {\n      this.#config.logger.error(`Kafka: consumer stream of \"${topic}\" failed`, { err: error })\n    })\n  }\n\n  /** Stops dispatching: buffered records are dropped (not committed, consumed again later). */\n  async cancel(): Promise<void> {\n    await Promise.resolve()\n    if (!this.#active) return\n    this.#active = false\n    for (const source of this.#sources) source.stream?.pause()\n    for (const queue of this.#partitions.values()) this.#dropBuffered(queue)\n    this.#ready.length = 0\n  }\n\n  /** Waits for the records being handled, then leaves the consumer groups. Idempotent. */\n  close(): Promise<void> {\n    this.#closed ??= this.#close()\n    return this.#closed\n  }\n\n  async #close(): Promise<void> {\n    await this.cancel()\n    if (this.#running > 0) await new Promise<void>(resolve => this.#idle.add(resolve))\n    await Promise.allSettled(this.#sources.map(source => source.stream?.close()))\n    await Promise.allSettled(this.#sources.map(source => source.consumer.close()))\n  }\n\n  /**\n   * A (re)join of the group, with its new assignment: the partitions this member lost belong to\n   * another one now, so their buffered records are dropped (the record being handled finishes).\n   */\n  #onGroupJoin(source: StreamState): void {\n    const assigned = new Set<number>()\n    for (const assignment of source.consumer.assignments ?? []) {\n      if (assignment.topic === source.topic) for (const partition of assignment.partitions) assigned.add(partition)\n    }\n    source.assigned = assigned\n    for (const queue of this.#partitions.values()) {\n      if (queue.source !== source || assigned.has(queue.partition)) continue\n      this.#dropBuffered(queue)\n      // records older than the one being handled come back if the partition is assigned again\n      queue.next = queue.running ? (queue.records[0] as KafkaRecord).offset + 1n : undefined\n    }\n  }\n\n  /** Drops the records of `queue` that are not being handled. */\n  #dropBuffered(queue: PartitionQueue): void {\n    if (queue.timer !== undefined) clearTimeout(queue.timer)\n    queue.timer = undefined\n    const keep = queue.running ? queue.records.slice(0, 1) : []\n    this.#unbuffer(queue.source, queue.records.length - keep.length)\n    queue.records.length = 0\n    queue.records.push(...keep)\n  }\n\n  #push(source: StreamState, record: KafkaRecord): void {\n    if (!this.#active) return\n    // a late record of a partition revoked by the last rebalance\n    if (source.assigned !== undefined && !source.assigned.has(record.partition)) return\n    const key = `${record.topic}:${record.partition}`\n    let queue = this.#partitions.get(key)\n    if (queue === undefined) {\n      queue = {\n        key,\n        source,\n        partition: record.partition,\n        records: [],\n        running: false,\n        queued: false,\n        timer: undefined,\n        next: undefined,\n      }\n      this.#partitions.set(key, queue)\n    }\n    // fetched again after a rebalance (from the committed offset): already buffered or handled\n    if (queue.next !== undefined && record.offset < queue.next) return\n    queue.next = record.offset + 1n\n    queue.records.push(record)\n    source.buffered++\n    if (!queue.running && !queue.queued && queue.timer === undefined) this.#enqueue(queue)\n    if (source.buffered >= this.#highWater) {\n      // pause again even when paused: the client resumes its streams after a rebalance\n      source.paused = true\n      source.stream?.pause()\n    }\n    this.#pump()\n  }\n\n  /** `count` records of `source` left the partition queues: resume it below the low-water mark. */\n  #unbuffer(source: StreamState, count: number): void {\n    source.buffered -= count\n    if (source.paused && this.#active && source.buffered <= this.#lowWater) {\n      source.paused = false\n      source.stream?.resume()\n    }\n  }\n\n  #enqueue(queue: PartitionQueue): void {\n    queue.queued = true\n    this.#ready.push(queue)\n  }\n\n  #pump(): void {\n    while (this.#active && this.#running < this.#config.options.concurrency && this.#ready.length > 0) {\n      const queue = this.#ready.shift() as PartitionQueue\n      queue.queued = false\n      const head = queue.records[0]\n      if (head === undefined) continue\n      const wait = notBefore(head) - Date.now()\n      if (wait > 0) {\n        // a retry that is not due yet: wait without holding a slot (timers cannot wait more than 2^31 - 1 ms)\n        queue.timer = setTimeout(\n          () => {\n            queue.timer = undefined\n            if (!this.#active) return\n            this.#enqueue(queue)\n            this.#pump()\n          },\n          Math.min(wait, this.#config.driver.capabilities.maxNativeDelayMs, MAX_TIMER_DELAY_MS),\n        )\n        continue\n      }\n      queue.running = true\n      this.#running++\n      this.#work(queue, head).then(\n        () => undefined,\n        () => undefined,\n      )\n    }\n  }\n\n  async #work(queue: PartitionQueue, record: KafkaRecord): Promise<void> {\n    let outcome: Outcome = 'stop'\n    try {\n      outcome = await this.#process(record)\n    } catch (error) {\n      this.#config.logger.error(`Kafka: unexpected failure handling a record of ${queue.key}`, { err: error })\n      outcome = this.#active ? 'again' : 'stop'\n    } finally {\n      queue.running = false\n      this.#running--\n      const assigned = queue.source.assigned\n      if (outcome === 'again' && assigned !== undefined && !assigned.has(queue.partition)) {\n        // revoked meanwhile: the new owner of the partition handles it\n        outcome = 'stop'\n        queue.next = undefined\n      }\n      if (outcome === 'next') {\n        queue.records.shift()\n        this.#unbuffer(queue.source, 1)\n      } else if (outcome === 'stop') {\n        const dropped = queue.records.length\n        queue.records.length = 0\n        this.#unbuffer(queue.source, dropped)\n      }\n      if (this.#active && queue.records.length > 0) this.#enqueue(queue)\n      if (this.#running === 0) {\n        const waiters = [...this.#idle]\n        this.#idle.clear()\n        for (const waiter of waiters) waiter()\n      }\n      this.#pump()\n    }\n  }\n\n  /** Hands one record to the runtime; resolves once it was settled. */\n  async #process(record: KafkaRecord): Promise<Outcome> {\n    const { driver, topic, retryTopic, group, logger } = this.#config\n    const all = headerRecord()\n    for (const [name, value] of record.headers) if (value !== undefined) all[name] = value\n    const headers = headerRecord()\n    for (const [name, value] of Object.entries(all)) if (!TRANSPORT_HEADERS.has(name)) headers[name] = value\n    const id = all[MessagingHeaders.Id] ?? `${record.topic}-${record.partition}-${record.offset}`\n    const value = record.value ?? Buffer.alloc(0)\n    let settled = false\n    let released = false\n    const check = (action: string): void => {\n      if (settled) throw new Error(`[kafka] record ${id} was already settled (${action})`)\n    }\n    /** Commits the offset. A failure (rebalance...) is not fatal: the record may be consumed again. */\n    const commit = async (): Promise<void> => {\n      try {\n        await record.commit()\n      } catch (error) {\n        logger.warn(\n          `Kafka: committing record ${id} of ${record.topic}:${record.partition} failed, it may be consumed again`,\n          {\n            err: error,\n          },\n        )\n      }\n    }\n    const copyHeaders = (extra: Record<string, string>, drop: readonly string[]): Record<string, string> => {\n      const result = headerRecord()\n      for (const [name, headerValue] of Object.entries(all)) if (!drop.includes(name)) result[name] = headerValue\n      return Object.assign(result, extra)\n    }\n    const delivery: DriverDelivery = {\n      id,\n      body: value,\n      contentType: all[MessagingHeaders.ContentType],\n      headers,\n      type: all[MessagingHeaders.Type],\n      key: record.key ?? undefined,\n      attempt: attemptFromHeaders(all),\n      redelivered: attemptFromHeaders(all) > 1,\n      timestamp: Number(record.timestamp),\n      raw: record,\n      ack: async (): Promise<void> => {\n        check('ack')\n        settled = true\n        await commit()\n      },\n      release: async (): Promise<void> => {\n        await Promise.resolve()\n        check('release')\n        settled = true\n        released = true\n      },\n      retry: async (request: RetryRequest): Promise<void> => {\n        check('retry')\n        if (retryTopic === undefined) throw new Error(`[kafka] ${topic} has no retry topic (single attempt)`)\n        const extra: Record<string, string> = { [MessagingHeaders.Attempt]: String(request.attempt) }\n        if (request.delayMs > 0) extra[MessagingHeaders.NotBefore] = String(Date.now() + request.delayMs)\n        await driver.produce(\n          retryTopic,\n          value,\n          copyHeaders(extra, [MessagingHeaders.NotBefore]),\n          record.key ?? undefined,\n        )\n        settled = true\n        await commit()\n      },\n      deadLetter: async (request: DeadLetterRequest): Promise<void> => {\n        check('dead-letter')\n        if (request.queue !== undefined) {\n          await driver.produce(\n            request.queue,\n            value,\n            copyHeaders(\n              {\n                [MessagingHeaders.DeadLetterReason]: request.reason,\n                [MessagingHeaders.Error]: truncate(errorMessage(request.error), MAX_ERROR_HEADER_LENGTH),\n                [MessagingHeaders.OriginalQueue]: topic,\n                [MessagingHeaders.Attempts]: String(request.attempt),\n                [MessagingHeaders.ConsumerGroup]: group,\n              },\n              [MessagingHeaders.Attempt, MessagingHeaders.NotBefore],\n            ),\n            record.key ?? undefined,\n          )\n        }\n        settled = true\n        await commit()\n      },\n    }\n    try {\n      await this.#config.handler(delivery)\n    } catch (error) {\n      logger.error(`Kafka: unexpected failure handling record ${id}`, { err: error })\n    }\n    if (released || !settled) return this.#active ? 'again' : 'stop'\n    return 'next'\n  }\n}\n\n/** `x-znight-not-before` of a retry record (epoch ms), 0 when absent. */\nfunction notBefore(record: KafkaRecord): number {\n  const value = record.headers.get(MessagingHeaders.NotBefore)\n  const time = value === undefined ? 0 : Number(value)\n  return Number.isFinite(time) ? time : 0\n}\n"],"mappings":"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"}