@ddd-ts/event-sourcing-firestore 0.0.36 → 0.0.38

package/dist/projection/firestore.projector.js

@@ -1,637 +1,484 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Task = exports.ClaimerId = exports.FirestoreQueueStore = exports.AlreadyEnqueuedError = exports.FirestoreProjector = void 0;
-const firestore_1 = require("firebase-admin/firestore");
-const core_1 = require("@ddd-ts/core");
-const shape_1 = require("@ddd-ts/shape");
-const store_firestore_1 = require("@ddd-ts/store-firestore");
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_firestore = require("@ddd-ts/store-firestore");
+let firebase_admin_firestore = require("firebase-admin/firestore");
+let _ddd_ts_shape = require("@ddd-ts/shape");
+
+//#region src/projection/firestore.projector.ts
 const Status = {
-    SUCCESS: "OK",
-    FAILURE: "FAILURE",
-    DEFERRED: "DEFERRED",
+	SUCCESS: "OK",
+	FAILURE: "FAILURE",
+	DEFERRED: "DEFERRED"
 };
 const TaskState = {
-    ENQUEUED: "ENQUEUED",
-    PROCESSED: "PROCESSED",
-    MISSING: "MISSING",
+	ENQUEUED: "ENQUEUED",
+	PROCESSED: "PROCESSED",
+	MISSING: "MISSING"
 };
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const RETENTION = shape_1.MicrosecondTimestamp.MONTH;
-class FirestoreProjector {
-    projection;
-    reader;
-    queue;
-    config;
-    _unclaim = true;
-    constructor(projection, reader, queue, config = {
-        retry: { attempts: 10, minDelay: 10, maxDelay: 200, backoff: 1.5 },
-        enqueue: { batchSize: 100 },
-        onProcessError: (error) => {
-            console.error("Error processing event:", error);
-        },
-        onEnqueueError: (error) => {
-            console.error("Error enqueuing tasks:", error);
-        },
-    }) {
-        this.projection = projection;
-        this.reader = reader;
-        this.queue = queue;
-        this.config = config;
-    }
-    async *breathe() {
-        const { attempts, minDelay, maxDelay, backoff } = this.config.retry;
-        for (let i = 0; i < attempts; i++) {
-            const reset = () => {
-                i--;
-            };
-            yield [i, reset];
-            const margin = maxDelay - minDelay;
-            const jitter = Math.random() * margin;
-            const backedoff = (backoff * i + 1) * minDelay;
-            const jitteredDelay = backedoff + jitter;
-            await wait(jitteredDelay);
-        }
-    }
-    // @Trace("projector.handle", ($, e) => ({
-    //   eventId: e.id.serialize(),
-    //   eventName: e.name,
-    //   eventRevision: e.revision,
-    //   eventReference: e.ref,
-    //   projectionName: $.projection.constructor.name,
-    //   checkpointId: $.projection.getCheckpointId(e).serialize(),
-    // }))
-    async handle(savedChange) {
-        const checkpointId = this.projection.getCheckpointId(savedChange);
-        const target = await this.getCursor(savedChange);
-        if (!target) {
-            throw new Error(`Cursor not found for event ${savedChange.id.serialize()}`);
-        }
-        const errors = [];
-        for await (const [attempt, reset] of this.breathe()) {
-            // console.log(`Attempt ${attempt} for event ${savedChange.id.serialize()}`);
-            const source = this.projection.getSource(savedChange);
-            const [status, message] = await this.attempt(source, checkpointId, target);
-            if (status === Status.DEFERRED) {
-                reset();
-                continue;
-            }
-            if (status === Status.SUCCESS) {
-                await this.queue.cleanup(checkpointId);
-                return;
-            }
-            errors.push(message);
-        }
-        throw new Error(`Failed to handle event ${savedChange.id.serialize()}: ${errors.join(", ")}`);
-    }
-    // @Trace("projector.reader.getCursor")
-    async getCursor(savedChange) {
-        return await this.reader.getCursor(savedChange);
-    }
-    // @Trace("projector.attempt")
-    async attempt(source, checkpointId, target) {
-        const headCursor = await this.getQueueHead(checkpointId);
-        const isTargetAfterHead = !headCursor || target.isAfter(headCursor);
-        if (isTargetAfterHead) {
-            const [status, message] = await this.enqueue(source, headCursor, checkpointId, target);
-            if (status === Status.DEFERRED) {
-                return [Status.DEFERRED, message];
-            }
-        }
-        if (!isTargetAfterHead) {
-            const processed = await this.checkIsProcessed(checkpointId, target);
-            if (processed === TaskState.PROCESSED) {
-                return [Status.SUCCESS, "Target event already processed"];
-            }
-            if (processed === TaskState.MISSING) {
-                const [status, message] = await this.enqueueOne(checkpointId, target);
-                if (status === Status.DEFERRED) {
-                    return [Status.FAILURE, message];
-                }
-            }
-        }
-        const unprocessed = await this.getUnprocessed(checkpointId);
-        if (!unprocessed.length) {
-            return [Status.FAILURE, "No unprocessed tasks found"];
-        }
-        const batch = Task.batch(unprocessed);
-        if (!batch.length) {
-            return [
-                Status.DEFERRED,
-                "No tasks available to claim, deferring",
-            ];
-        }
-        const claimer = ClaimerId.generate();
-        const [status, message] = await this.claimTasks(checkpointId, claimer, batch);
-        if (status === Status.FAILURE) {
-            return [Status.DEFERRED, message];
-        }
-        return await this.processEvents(checkpointId, claimer, target.eventId);
-    }
-    // @Trace("projector.queue.head")
-    async getQueueHead(checkpointId) {
-        return await this.queue.head(checkpointId);
-    }
-    // @Trace("projector.readSourceStream")
-    async readSourceStream(source, head, checkpointId, target) {
-        const shard = checkpointId.shard();
-        const headCursor = head;
-        const limit = this.config.enqueue.batchSize;
-        return this.reader.slice(source, shard, headCursor, target, limit);
-    }
-    // @Trace("projector.enqueue")
-    async enqueue(source, head, checkpointId, target) {
-        const events = await this.readSourceStream(source, head, checkpointId, target);
-        const tasks = events.map((e) => {
-            const settings = this.projection.getTaskSettings(e);
-            return Task.new(e, settings);
-        });
-        return await this.queue.enqueue(checkpointId, tasks);
-    }
-    async enqueueOne(checkpointId, target) {
-        const event = await this.reader.get(target);
-        if (!event) {
-            throw new Error(`Event not found for cursor ${target.ref}`);
-        }
-        const settings = this.projection.getTaskSettings(event);
-        const task = Task.new(event, settings);
-        return await this.queue.enqueue(checkpointId, [task]);
-    }
-    // @Trace("projector.queue.isProcessed")
-    async checkIsProcessed(checkpointId, cursor) {
-        return await this.queue.isProcessed(checkpointId, cursor);
-    }
-    // @Trace("projector.queue.unprocessed")
-    async getUnprocessed(checkpointId) {
-        return await this.queue.unprocessed(checkpointId);
-    }
-    // @Trace("projector.queue.claim")
-    async claimTasks(checkpointId, claimer, batch) {
-        try {
-            await this.queue.claim(checkpointId, claimer, batch);
-            return [Status.SUCCESS, "Tasks claimed successfully"];
-        }
-        catch (e) {
-            return [Status.FAILURE, e];
-        }
-    }
-    // @Trace("projector.processEvents")
-    async processEvents(checkpointId, claimer, targetEventId) {
-        const tasks = await this.queue.claimed(checkpointId, claimer);
-        const todo = await Promise.all(tasks.map((t) => this.reader.get(t.cursor)));
-        const filtered = todo.filter((t) => !!t);
-        if (!filtered.length) {
-            // Nothing to process, possibly all tasks were for events that no longer exist
-            return [
-                Status.DEFERRED,
-                "No events to process in claimed tasks",
-            ];
-        }
-        const onProcessed = this.queue.processed.bind(this.queue);
-        const context = { onProcessed, checkpointId };
-        const hasTarget = tasks.some((t) => t.id.equals(targetEventId));
-        try {
-            const processed = await this.projection.process(filtered, context);
-            if (processed.some((id) => id?.equals(targetEventId))) {
-                return [Status.SUCCESS, "Target event processed successfully"];
-            }
-            return [Status.DEFERRED, "Target event not processed yet"];
-        }
-        catch (e) {
-            this.config.onProcessError(e);
-            if (this._unclaim) {
-                await this.queue.unclaim(checkpointId, tasks);
-            }
-            if (!hasTarget) {
-                return [
-                    Status.DEFERRED,
-                    "Target event not in claimed batch, deferring",
-                ];
-            }
-            return [Status.FAILURE, e];
-        }
-    }
-}
-exports.FirestoreProjector = FirestoreProjector;
-class AlreadyEnqueuedError extends Error {
-    constructor() {
-        super("Tasks already enqueued");
-        this.name = "AlreadyEnqueuedError";
-    }
-}
+const RETENTION = _ddd_ts_shape.MicrosecondTimestamp.MONTH;
+var FirestoreProjector = class {
+	_unclaim = true;
+	constructor(projection, reader, queue, config = {
+		retry: {
+			attempts: 10,
+			minDelay: 10,
+			maxDelay: 200,
+			backoff: 1.5
+		},
+		enqueue: { batchSize: 100 },
+		onProcessError: (error) => {
+			console.error("Error processing event:", error);
+		},
+		onEnqueueError: (error) => {
+			console.error("Error enqueuing tasks:", error);
+		}
+	}) {
+		this.projection = projection;
+		this.reader = reader;
+		this.queue = queue;
+		this.config = config;
+	}
+	async *breathe() {
+		const { attempts, minDelay, maxDelay, backoff } = this.config.retry;
+		for (let i = 0; i < attempts; i++) {
+			const reset = () => {
+				i--;
+			};
+			yield [i, reset];
+			const margin = maxDelay - minDelay;
+			const jitter = Math.random() * margin;
+			await wait((backoff * i + 1) * minDelay + jitter);
+		}
+	}
+	async handle(savedChange) {
+		const checkpointId = this.projection.getCheckpointId(savedChange);
+		const target = await this.getCursor(savedChange);
+		if (!target) throw new Error(`Cursor not found for event ${savedChange.id.serialize()}`);
+		const errors = [];
+		for await (const [attempt, reset] of this.breathe()) {
+			const source = this.projection.getSource(savedChange);
+			const [status, message] = await this.attempt(source, checkpointId, target);
+			if (status === Status.DEFERRED) {
+				reset();
+				continue;
+			}
+			if (status === Status.SUCCESS) {
+				await this.queue.cleanup(checkpointId);
+				return;
+			}
+			errors.push(message);
+		}
+		throw new Error(`Failed to handle event ${savedChange.id.serialize()}: ${errors.join(", ")}`);
+	}
+	async getCursor(savedChange) {
+		return await this.reader.getCursor(savedChange);
+	}
+	async attempt(source, checkpointId, target) {
+		const headCursor = await this.getQueueHead(checkpointId);
+		const isTargetAfterHead = !headCursor || target.isAfter(headCursor);
+		if (isTargetAfterHead) {
+			const [status, message] = await this.enqueue(source, headCursor, checkpointId, target);
+			if (status === Status.DEFERRED) return [Status.DEFERRED, message];
+		}
+		if (!isTargetAfterHead) {
+			const processed = await this.checkIsProcessed(checkpointId, target);
+			if (processed === TaskState.PROCESSED) return [Status.SUCCESS, "Target event already processed"];
+			if (processed === TaskState.MISSING) {
+				const [status, message] = await this.enqueueOne(checkpointId, target);
+				if (status === Status.DEFERRED) return [Status.FAILURE, message];
+			}
+		}
+		const unprocessed = await this.getUnprocessed(checkpointId);
+		if (!unprocessed.length) return [Status.FAILURE, "No unprocessed tasks found"];
+		const batch = Task.batch(unprocessed);
+		if (!batch.length) return [Status.DEFERRED, "No tasks available to claim, deferring"];
+		const claimer = ClaimerId.generate();
+		const [status, message] = await this.claimTasks(checkpointId, claimer, batch);
+		if (status === Status.FAILURE) return [Status.DEFERRED, message];
+		return await this.processEvents(checkpointId, claimer, target.eventId);
+	}
+	async getQueueHead(checkpointId) {
+		return await this.queue.head(checkpointId);
+	}
+	async readSourceStream(source, head, checkpointId, target) {
+		const shard = checkpointId.shard();
+		const headCursor = head;
+		const limit = this.config.enqueue.batchSize;
+		return this.reader.slice(source, shard, headCursor, target, limit);
+	}
+	async enqueue(source, head, checkpointId, target) {
+		const tasks = (await this.readSourceStream(source, head, checkpointId, target)).map((e) => {
+			const settings = this.projection.getTaskSettings(e);
+			return Task.new(e, settings);
+		});
+		return await this.queue.enqueue(checkpointId, tasks);
+	}
+	async enqueueOne(checkpointId, target) {
+		const event = await this.reader.get(target);
+		if (!event) throw new Error(`Event not found for cursor ${target.ref}`);
+		const settings = this.projection.getTaskSettings(event);
+		const task = Task.new(event, settings);
+		return await this.queue.enqueue(checkpointId, [task]);
+	}
+	async checkIsProcessed(checkpointId, cursor) {
+		return await this.queue.isProcessed(checkpointId, cursor);
+	}
+	async getUnprocessed(checkpointId) {
+		return await this.queue.unprocessed(checkpointId);
+	}
+	async claimTasks(checkpointId, claimer, batch) {
+		try {
+			await this.queue.claim(checkpointId, claimer, batch);
+			return [Status.SUCCESS, "Tasks claimed successfully"];
+		} catch (e) {
+			return [Status.FAILURE, e];
+		}
+	}
+	async processEvents(checkpointId, claimer, targetEventId) {
+		const tasks = await this.queue.claimed(checkpointId, claimer);
+		const filtered = (await Promise.all(tasks.map((t) => this.reader.get(t.cursor)))).filter((t) => !!t);
+		if (!filtered.length) return [Status.DEFERRED, "No events to process in claimed tasks"];
+		const context = {
+			onProcessed: this.queue.processed.bind(this.queue),
+			checkpointId
+		};
+		const hasTarget = tasks.some((t) => t.id.equals(targetEventId));
+		try {
+			if ((await this.projection.process(filtered, context)).some((id) => id?.equals(targetEventId))) return [Status.SUCCESS, "Target event processed successfully"];
+			return [Status.DEFERRED, "Target event not processed yet"];
+		} catch (e) {
+			this.config.onProcessError(e);
+			if (this._unclaim) await this.queue.unclaim(checkpointId, tasks);
+			if (!hasTarget) return [Status.DEFERRED, "Target event not in claimed batch, deferring"];
+			return [Status.FAILURE, e];
+		}
+	}
+};
+var AlreadyEnqueuedError = class extends Error {
+	constructor() {
+		super("Tasks already enqueued");
+		this.name = "AlreadyEnqueuedError";
+	}
+};
+var FirestoreQueueStore = class {
+	converter = new _ddd_ts_store_firestore.DefaultConverter();
+	collection;
+	constructor(db) {
+		this.db = db;
+		this.collection = db.collection("checkpoints");
+	}
+	timestampToMicroseconds(timestamp) {
+		return new _ddd_ts_shape.MicrosecondTimestamp(BigInt(timestamp.seconds) * BigInt(1e6) + BigInt(timestamp.nanoseconds) / BigInt(1e3));
+	}
+	microsecondsToTimestamp(microseconds) {
+		const seconds = BigInt(microseconds.micros) / 1000000n;
+		const nanoseconds = BigInt(microseconds.micros) % 1000000n * 1000n;
+		return new firebase_admin_firestore.Timestamp(Number(seconds), Number(nanoseconds));
+	}
+	async enqueue(checkpointId, tasks) {
+		const batch = this.collection.firestore.batch();
+		for (const task of tasks) {
+			const ref = this.queued(checkpointId, task.id);
+			batch.create(ref, {
+				ref: this.db.doc(task.cursor.ref),
+				...this.converter.toFirestore(task.serialize())
+			});
+		}
+		try {
+			await batch.commit();
+			return [Status.SUCCESS, "Tasks enqueued successfully"];
+		} catch (err) {
+			if (err.code === 6) return [Status.DEFERRED, new AlreadyEnqueuedError()];
+			return [Status.DEFERRED, err];
+		}
+	}
+	async claim(checkpointId, claimer, tasks) {
+		const batch = this.collection.firestore.batch();
+		for (const task of tasks) {
+			const ref = this.queued(checkpointId, task.id);
+			batch.update(ref, {
+				claimer: claimer.serialize(),
+				claimedAt: firebase_admin_firestore.FieldValue.serverTimestamp(),
+				attempts: firebase_admin_firestore.FieldValue.increment(1),
+				remaining: firebase_admin_firestore.FieldValue.increment(-1)
+			}, { lastUpdateTime: this.microsecondsToTimestamp(task.lastUpdateTime) });
+		}
+		await batch.commit();
+	}
+	async head(checkpointId) {
+		const headDoc = (await this.queue(checkpointId).orderBy("occurredAt", "desc").orderBy("revision", "desc").limit(1).get()).docs[0];
+		if (!headDoc) return;
+		const headData = this.converter.fromFirestoreSnapshot(headDoc);
+		if (!headData) return;
+		return headDoc ? _ddd_ts_core.Cursor.deserialize({
+			ref: headData.ref,
+			occurredAt: headData.occurredAt,
+			revision: headData.revision,
+			eventId: headData.id
+		}) : void 0;
+	}
+	async unprocessed(checkpointId) {
+		const tasks = (await this.queue(checkpointId).where("processed", "==", false).where("remaining", ">", 0).orderBy("occurredAt", "asc").orderBy("revision", "asc").limit(100).get()).docs.map((doc) => {
+			const data = this.converter.fromFirestoreSnapshot(doc);
+			const timestamp = doc.updateTime ? this.timestampToMicroseconds(doc.updateTime) : void 0;
+			return Task.deserializeWithLastUpdateTime(data, timestamp);
+		});
+		const expiredTasks = [];
+		for (const task of tasks) {
+			const originalClaimer = task.claimer;
+			task.checkTimeout();
+			if (originalClaimer && !task.claimer) expiredTasks.push(task);
+		}
+		if (expiredTasks.length > 0) {
+			const batch = this.collection.firestore.batch();
+			for (const task of expiredTasks) {
+				const ref = this.queued(checkpointId, task.id);
+				batch.update(ref, {
+					claimer: firebase_admin_firestore.FieldValue.delete(),
+					claimedAt: firebase_admin_firestore.FieldValue.delete(),
+					attempts: task.attempts,
+					remaining: task.remaining
+				});
+			}
+			await batch.commit();
+		}
+		return tasks;
+	}
+	async claimed(checkpointId, claimer) {
+		return (await this.queue(checkpointId).where("claimer", "==", claimer.serialize()).orderBy("occurredAt", "asc").orderBy("revision", "asc").get()).docs.map((doc) => {
+			const data = this.converter.fromFirestoreSnapshot(doc);
+			const timestamp = doc.updateTime ? this.timestampToMicroseconds(doc.updateTime) : void 0;
+			return Task.deserializeWithLastUpdateTime(data, timestamp);
+		});
+	}
+	async unclaim(checkpointId, tasks) {
+		const batch = this.collection.firestore.batch();
+		for (const task of tasks) {
+			const ref = this.queued(checkpointId, task.id);
+			batch.update(ref, {
+				claimer: firebase_admin_firestore.FieldValue.delete(),
+				claimedAt: firebase_admin_firestore.FieldValue.delete()
+			});
+		}
+		await batch.commit();
+	}
+	/**
+	* If the task exists, then looks for a processed flag.
+	* If not found, check if the cursor is older than the retention time for processed event.
+	* If so, consider it processed.
+	* Otherwise, consider it missing.
+	*/
+	async isProcessed(checkpointId, cursor) {
+		const doc = await this.queued(checkpointId, cursor.eventId).get();
+		if (doc.exists) {
+			const data = doc.data();
+			if (!data) throw new Error("No data in queued document");
+			if (data.processed === true) return TaskState.PROCESSED;
+			return TaskState.ENQUEUED;
+		}
+		const lastRetention = _ddd_ts_shape.MicrosecondTimestamp.now().sub(RETENTION);
+		if (cursor.isOlderThan(lastRetention)) return TaskState.PROCESSED;
+		return TaskState.MISSING;
+	}
+	checkpoint(id) {
+		return this.collection.doc(id.name).collection("shards");
+	}
+	queue(id) {
+		return this.checkpoint(id).doc(id.shard()).collection("queue");
+	}
+	queued(id, eventId) {
+		return this.queue(id).doc(eventId.serialize());
+	}
+	async processed(id, eventIds, context = {}) {
+		const { transaction: trx, batchWriter } = context;
+		if (trx) {
+			for (const eventId of eventIds) {
+				const ref = this.queued(id, eventId);
+				trx.transaction.update(ref, { processed: true });
+			}
+			return;
+		}
+		await Promise.all(eventIds.map((eventId) => this.queued(id, eventId).update({ processed: true })));
+	}
+	async getTailCursor(id) {
+		const tailDoc = (await this.queue(id).where("remaining", ">", 0).orderBy("occurredAt", "asc").orderBy("revision", "asc").limit(1).get()).docs[0];
+		if (!tailDoc) return;
+		const tailData = this.converter.fromFirestoreSnapshot(tailDoc);
+		if (!tailData) return;
+		return tailDoc ? _ddd_ts_core.Cursor.deserialize({
+			ref: tailData.ref,
+			occurredAt: tailData.occurredAt,
+			revision: tailData.revision,
+			eventId: tailData.id
+		}) : void 0;
+	}
+	async cleanup(id) {
+		const aMonthAgo = _ddd_ts_shape.MicrosecondTimestamp.now().sub(_ddd_ts_shape.MicrosecondTimestamp.WEEK.mult(4));
+		const query = this.queue(id).where("remaining", ">", 0).where("occurredAt", "<", aMonthAgo.serialize()).orderBy("occurredAt", "asc").orderBy("revision", "asc");
+		const TRAIL = 1;
+		const snapshot = await query.get();
+		if (snapshot.size < TRAIL) return;
+		const stopper = snapshot.docs.findIndex((doc) => !doc.data().processed);
+		const cleanable = snapshot.docs.slice(0, stopper);
+		const cleaning = cleanable.slice(0, cleanable.length - TRAIL);
+		if (cleaning.length === 0) return;
+		const batch = this.collection.firestore.batch();
+		for (const queued of cleaning) batch.delete(queued.ref);
+		await batch.commit();
+	}
+	async flush(id) {
+		const stream = this.queue(id).stream();
+		const writer = this.collection.firestore.bulkWriter();
+		for await (const queued of stream) writer.delete(queued.ref);
+		await writer.close();
+	}
+	/**
+	* This method adds a fake processed event to the queue.
+	* It is useful for initializing the tail cursor of a new projection, at the
+	* same time as the projection's initial state is created, reset, or updated.
+	* By default, it will use the current time as the occurredAt timestamp.
+	* You can override this by providing a specific timestamp.
+	*
+	* This ensures that the projection can start processing new events from the
+	* correct point in time, avoiding reprocessing of old events.
+	*/
+	async seed(checkpointId) {
+		const cursor = new _ddd_ts_core.Cursor({
+			ref: "seed",
+			occurredAt: _ddd_ts_shape.MicrosecondTimestamp.now(),
+			revision: 0,
+			eventId: _ddd_ts_core.EventId.generate()
+		});
+		const task = new Task({
+			id: _ddd_ts_core.EventId.generate(),
+			ref: "Seed",
+			occurredAt: cursor.occurredAt,
+			revision: cursor.revision,
+			attempts: 0,
+			processed: true,
+			claimer: void 0,
+			claimedAt: void 0,
+			lock: new _ddd_ts_core.Lock({}),
+			remaining: 1,
+			claimTimeout: 0,
+			skipAfter: 0,
+			isolateAfter: 0,
+			lastUpdateTime: void 0
+		});
+		try {
+			const serialized = task.serialize();
+			const converted = this.converter.toFirestore(serialized);
+			await this.queued(checkpointId, task.cursor.eventId).create(converted);
+		} catch (e) {
+			if (!(e instanceof AlreadyEnqueuedError)) throw e;
+		}
+	}
+};
+var ClaimerId = class extends _ddd_ts_core.EventId {};
+var Task = class Task extends (0, _ddd_ts_shape.Shape)({
+	id: _ddd_ts_core.EventId,
+	ref: String,
+	occurredAt: _ddd_ts_shape.MicrosecondTimestamp,
+	revision: Number,
+	attempts: Number,
+	processed: Boolean,
+	claimer: (0, _ddd_ts_shape.Optional)(String),
+	claimedAt: (0, _ddd_ts_shape.Optional)(_ddd_ts_shape.MicrosecondTimestamp),
+	lock: _ddd_ts_core.Lock,
+	skipAfter: Number,
+	remaining: Number,
+	isolateAfter: Number,
+	claimTimeout: Number,
+	lastUpdateTime: (0, _ddd_ts_shape.Optional)(_ddd_ts_shape.MicrosecondTimestamp)
+}) {
+	get cursor() {
+		return new _ddd_ts_core.Cursor({
+			ref: this.ref,
+			occurredAt: this.occurredAt,
+			revision: this.revision,
+			eventId: this.id
+		});
+	}
+	static new(fact, config) {
+		return new Task({
+			id: fact.id,
+			attempts: 0,
+			claimer: void 0,
+			processed: false,
+			claimedAt: void 0,
+			lock: config.lock,
+			claimTimeout: config.claimTimeout,
+			skipAfter: config.skipAfter,
+			isolateAfter: config.isolateAfter,
+			remaining: config.skipAfter,
+			ref: fact.ref,
+			revision: fact.revision,
+			occurredAt: fact.occurredAt,
+			lastUpdateTime: void 0
+		});
+	}
+	get isProcessing() {
+		return !!this.claimer;
+	}
+	get isProcessed() {
+		return !!this.processed;
+	}
+	get shouldSkip() {
+		return this.attempts > this.skipAfter;
+	}
+	get shouldIsolate() {
+		return this.attempts > this.isolateAfter;
+	}
+	checkTimeout() {
+		if (!this.claimedAt) return;
+		if (_ddd_ts_shape.MicrosecondTimestamp.now().micros - this.claimedAt.micros > BigInt(this.claimTimeout) * 1000n) {
+			this.claimedAt = void 0;
+			this.claimer = void 0;
+			this.attempts += 1;
+			this.remaining -= 1;
+		}
+	}
+	static deserializeWithLastUpdateTime(data, timestamp) {
+		return Task.deserialize({
+			...data,
+			lastUpdateTime: timestamp
+		});
+	}
+	static batch(tasks) {
+		const locks = [];
+		const batchLocks = [];
+		const batch = [];
+		for (const task of tasks) {
+			if (task.shouldSkip) continue;
+			if (task.shouldIsolate) {
+				if (batch.length > 0) return batch;
+				batch.push(task);
+				return batch;
+			}
+			if (locks.some((l) => l.restrains(task.lock))) {
+				locks.push(task.lock);
+				continue;
+			}
+			if (batchLocks.some((l) => l.restrains(task.lock, false))) {
+				locks.push(task.lock);
+				continue;
+			}
+			if (task.isProcessed) continue;
+			if (task.isProcessing) {
+				locks.push(task.lock);
+				continue;
+			}
+			batch.push(task);
+			batchLocks.push(task.lock);
+		}
+		return batch;
+	}
+};
+
+//#endregion
 exports.AlreadyEnqueuedError = AlreadyEnqueuedError;
-class FirestoreQueueStore {
-    db;
-    converter = new store_firestore_1.DefaultConverter();
-    collection;
-    constructor(db) {
-        this.db = db;
-        this.collection = db.collection("checkpoints");
-    }
-    timestampToMicroseconds(timestamp) {
-        const microseconds = BigInt(timestamp.seconds) * BigInt(1_000_000) +
-            BigInt(timestamp.nanoseconds) / BigInt(1_000);
-        return new shape_1.MicrosecondTimestamp(microseconds);
-    }
-    microsecondsToTimestamp(microseconds) {
-        const seconds = BigInt(microseconds.micros) / 1000000n;
-        const nanoseconds = (BigInt(microseconds.micros) % 1000000n) * 1000n; // Convert to nanoseconds
-        return new firestore_1.Timestamp(Number(seconds), Number(nanoseconds));
-    }
-    async enqueue(checkpointId, tasks) {
-        // console.log(
-        //   `Enqueuing ${tasks.length} tasks for checkpoint ${checkpointId.serialize()}`,
-        // );
-        const batch = this.collection.firestore.batch();
-        for (const task of tasks) {
-            const ref = this.queued(checkpointId, task.id);
-            batch.create(ref, {
-                ref: this.db.doc(task.cursor.ref),
-                ...this.converter.toFirestore(task.serialize()),
-            });
-        }
-        try {
-            await batch.commit();
-            return [Status.SUCCESS, "Tasks enqueued successfully"];
-        }
-        catch (err) {
-            if (err.code === 6) {
-                return [Status.DEFERRED, new AlreadyEnqueuedError()];
-            }
-            return [Status.DEFERRED, err];
-        }
-    }
-    async claim(checkpointId, claimer, tasks) {
-        const batch = this.collection.firestore.batch();
-        for (const task of tasks) {
-            const ref = this.queued(checkpointId, task.id);
-            batch.update(ref, {
-                claimer: claimer.serialize(),
-                claimedAt: firestore_1.FieldValue.serverTimestamp(),
-                attempts: firestore_1.FieldValue.increment(1),
-                remaining: firestore_1.FieldValue.increment(-1),
-            }, { lastUpdateTime: this.microsecondsToTimestamp(task.lastUpdateTime) });
-        }
-        await batch.commit();
-    }
-    async head(checkpointId) {
-        const head = this.queue(checkpointId)
-            .orderBy("occurredAt", "desc")
-            .orderBy("revision", "desc")
-            .limit(1);
-        const headDoc = (await head.get()).docs[0];
-        if (!headDoc) {
-            return undefined;
-        }
-        const headData = this.converter.fromFirestoreSnapshot(headDoc);
-        if (!headData) {
-            return undefined;
-        }
-        const headCursor = headDoc
-            ? core_1.Cursor.deserialize({
-                ref: headData.ref,
-                occurredAt: headData.occurredAt,
-                revision: headData.revision,
-                eventId: headData.id,
-            })
-            : undefined;
-        return headCursor;
-    }
-    async unprocessed(checkpointId) {
-        const query = this.queue(checkpointId)
-            .where("processed", "==", false)
-            .where("remaining", ">", 0)
-            .orderBy("occurredAt", "asc")
-            .orderBy("revision", "asc")
-            .limit(100);
-        const snapshot = await query.get();
-        const tasks = snapshot.docs.map((doc) => {
-            const data = this.converter.fromFirestoreSnapshot(doc);
-            const timestamp = doc.updateTime
-                ? this.timestampToMicroseconds(doc.updateTime)
-                : undefined;
-            return Task.deserializeWithLastUpdateTime(data, timestamp);
-        });
-        // Check for timeouts and unclaim expired tasks
-        const expiredTasks = [];
-        for (const task of tasks) {
-            const originalClaimer = task.claimer;
-            task.checkTimeout();
-            // If timeout cleared the claimer, we need to update the database
-            if (originalClaimer && !task.claimer) {
-                expiredTasks.push(task);
-            }
-        }
-        // Update expired tasks in the database
-        if (expiredTasks.length > 0) {
-            const batch = this.collection.firestore.batch();
-            for (const task of expiredTasks) {
-                const ref = this.queued(checkpointId, task.id);
-                batch.update(ref, {
-                    claimer: firestore_1.FieldValue.delete(),
-                    claimedAt: firestore_1.FieldValue.delete(),
-                    attempts: task.attempts,
-                    remaining: task.remaining,
-                });
-            }
-            await batch.commit();
-        }
-        return tasks;
-    }
-    async claimed(checkpointId, claimer) {
-        const query = this.queue(checkpointId)
-            .where("claimer", "==", claimer.serialize())
-            .orderBy("occurredAt", "asc")
-            .orderBy("revision", "asc");
-        const snapshot = await query.get();
-        return snapshot.docs.map((doc) => {
-            const data = this.converter.fromFirestoreSnapshot(doc);
-            const timestamp = doc.updateTime
-                ? this.timestampToMicroseconds(doc.updateTime)
-                : undefined;
-            return Task.deserializeWithLastUpdateTime(data, timestamp);
-        });
-    }
-    async unclaim(checkpointId, tasks) {
-        const batch = this.collection.firestore.batch();
-        for (const task of tasks) {
-            const ref = this.queued(checkpointId, task.id);
-            batch.update(ref, {
-                claimer: firestore_1.FieldValue.delete(),
-                claimedAt: firestore_1.FieldValue.delete(),
-            });
-        }
-        await batch.commit();
-    }
-    /**
-     * If the task exists, then looks for a processed flag.
-     * If not found, check if the cursor is older than the retention time for processed event.
-     * If so, consider it processed.
-     * Otherwise, consider it missing.
-     */
-    async isProcessed(checkpointId, cursor) {
-        const doc = await this.queued(checkpointId, cursor.eventId).get();
-        if (doc.exists) {
-            const data = doc.data();
-            if (!data)
-                throw new Error("No data in queued document");
-            if (data.processed === true)
-                return TaskState.PROCESSED;
-            return TaskState.ENQUEUED;
-        }
-        const lastRetention = shape_1.MicrosecondTimestamp.now().sub(RETENTION);
-        if (cursor.isOlderThan(lastRetention)) {
-            return TaskState.PROCESSED;
-        }
-        return TaskState.MISSING;
-    }
-    checkpoint(id) {
-        return this.collection.doc(id.name).collection("shards");
-    }
-    queue(id) {
-        return this.checkpoint(id).doc(id.shard()).collection("queue");
-    }
-    queued(id, eventId) {
-        return this.queue(id).doc(eventId.serialize());
-    }
-    async processed(id, eventIds, context = {}) {
-        const { transaction: trx, batchWriter } = context;
-        if (trx) {
-            for (const eventId of eventIds) {
-                const ref = this.queued(id, eventId);
-                trx.transaction.update(ref, { processed: true });
-            }
-            return;
-        }
-        await Promise.all(eventIds.map((eventId) => this.queued(id, eventId).update({
-            processed: true,
-        })));
-        return;
-    }
-    async getTailCursor(id) {
-        const tail = this.queue(id)
-            .where("remaining", ">", 0)
-            .orderBy("occurredAt", "asc")
-            .orderBy("revision", "asc")
-            .limit(1);
-        const tailDoc = (await tail.get()).docs[0];
-        if (!tailDoc) {
-            return undefined;
-        }
-        const tailData = this.converter.fromFirestoreSnapshot(tailDoc);
-        if (!tailData) {
-            return undefined;
-        }
-        const tailCursor = tailDoc
-            ? core_1.Cursor.deserialize({
-                ref: tailData.ref,
-                occurredAt: tailData.occurredAt,
-                revision: tailData.revision,
-                eventId: tailData.id,
-            })
-            : undefined;
-        return tailCursor;
-    }
-    async cleanup(id) {
-        const aMonthAgo = shape_1.MicrosecondTimestamp.now().sub(shape_1.MicrosecondTimestamp.WEEK.mult(4));
-        const query = this.queue(id)
-            .where("remaining", ">", 0)
-            .where("occurredAt", "<", aMonthAgo.serialize()) // Only consider events older than 4 weeks
-            .orderBy("occurredAt", "asc")
-            .orderBy("revision", "asc");
-        const MIN_TRAIL = 1; // Keep at least one processed document to maintain the tail cursor
-        const TRAIL = MIN_TRAIL + 0; // Extra buffer to optimize isProcessed checks
-        const snapshot = await query.get();
-        if (snapshot.size < TRAIL)
-            return;
-        const stopper = snapshot.docs.findIndex((doc) => !doc.data().processed);
-        const cleanable = snapshot.docs.slice(0, stopper);
-        const cleaning = cleanable.slice(0, cleanable.length - TRAIL);
-        if (cleaning.length === 0)
-            return;
-        const batch = this.collection.firestore.batch();
-        for (const queued of cleaning)
-            batch.delete(queued.ref);
-        await batch.commit();
-    }
-    async flush(id) {
-        const stream = this.queue(id).stream();
-        const writer = this.collection.firestore.bulkWriter();
-        for await (const queued of stream)
-            writer.delete(queued.ref);
-        await writer.close();
-    }
-    /**
-     * This method adds a fake processed event to the queue.
-     * It is useful for initializing the tail cursor of a new projection, at the
-     * same time as the projection's initial state is created, reset, or updated.
-     * By default, it will use the current time as the occurredAt timestamp.
-     * You can override this by providing a specific timestamp.
-     *
-     * This ensures that the projection can start processing new events from the
-     * correct point in time, avoiding reprocessing of old events.
-     */
-    async seed(checkpointId) {
-        const cursor = new core_1.Cursor({
-            ref: "seed",
-            occurredAt: shape_1.MicrosecondTimestamp.now(),
-            revision: 0,
-            eventId: core_1.EventId.generate(),
-        });
-        const task = new Task({
-            id: core_1.EventId.generate(),
-            ref: "Seed",
-            occurredAt: cursor.occurredAt,
-            revision: cursor.revision,
-            attempts: 0,
-            processed: true,
-            claimer: undefined,
-            claimedAt: undefined,
-            lock: new core_1.Lock({}),
-            remaining: 1,
-            claimTimeout: 0,
-            skipAfter: 0,
-            isolateAfter: 0,
-            lastUpdateTime: undefined,
-        });
-        try {
-            const serialized = task.serialize();
-            const converted = this.converter.toFirestore(serialized);
-            await this.queued(checkpointId, task.cursor.eventId).create(converted);
-        }
-        catch (e) {
-            // Ignore if already exists
-            if (!(e instanceof AlreadyEnqueuedError)) {
-                throw e;
-            }
-        }
-    }
-}
-exports.FirestoreQueueStore = FirestoreQueueStore;
-class ClaimerId extends core_1.EventId {
-}
 exports.ClaimerId = ClaimerId;
-class Task extends (0, shape_1.Shape)({
-    id: core_1.EventId,
-    ref: String,
-    occurredAt: shape_1.MicrosecondTimestamp,
-    revision: Number,
-    attempts: Number,
-    processed: Boolean,
-    claimer: (0, shape_1.Optional)(String),
-    claimedAt: (0, shape_1.Optional)(shape_1.MicrosecondTimestamp),
-    lock: core_1.Lock,
-    skipAfter: Number,
-    remaining: Number,
-    isolateAfter: Number,
-    claimTimeout: Number,
-    lastUpdateTime: (0, shape_1.Optional)(shape_1.MicrosecondTimestamp),
-}) {
-    get cursor() {
-        return new core_1.Cursor({
-            ref: this.ref,
-            occurredAt: this.occurredAt,
-            revision: this.revision,
-            eventId: this.id,
-        });
-    }
-    static new(fact, config) {
-        return new Task({
-            id: fact.id,
-            attempts: 0,
-            claimer: undefined,
-            processed: false,
-            claimedAt: undefined,
-            lock: config.lock,
-            claimTimeout: config.claimTimeout,
-            skipAfter: config.skipAfter,
-            isolateAfter: config.isolateAfter,
-            remaining: config.skipAfter,
-            ref: fact.ref,
-            revision: fact.revision,
-            occurredAt: fact.occurredAt,
-            lastUpdateTime: undefined,
-        });
-    }
-    get isProcessing() {
-        return !!this.claimer;
-    }
-    get isProcessed() {
-        return !!this.processed;
-    }
-    get shouldSkip() {
-        return this.attempts > this.skipAfter;
-    }
-    get shouldIsolate() {
-        return this.attempts > this.isolateAfter;
-    }
-    checkTimeout() {
-        if (!this.claimedAt)
-            return;
-        const now = shape_1.MicrosecondTimestamp.now();
-        const elapsedMicros = now.micros - this.claimedAt.micros;
-        const timeoutMicros = BigInt(this.claimTimeout) * 1000n; // Convert ms to microseconds
-        if (elapsedMicros > timeoutMicros) {
-            this.claimedAt = undefined;
-            this.claimer = undefined;
-            this.attempts += 1;
-            this.remaining -= 1;
-        }
-    }
-    static deserializeWithLastUpdateTime(data, timestamp) {
-        const task = Task.deserialize({
-            ...data,
-            lastUpdateTime: timestamp,
-        });
-        return task;
-    }
-    static batch(tasks) {
-        // console.log(
-        //   JSON.stringify(
-        //     tasks.map((t) => t.serialize()),
-        //     null,
-        //     2,
-        //   ),
-        // );
-        const locks = [];
-        const batchLocks = [];
-        const batch = [];
-        for (const task of tasks) {
-            if (task.shouldSkip) {
-                // console.log(
-                //   `Skipping task ${task.id.serialize()} due to skipAfter limit`,
-                // );
-                continue;
-            }
-            if (task.shouldIsolate) {
-                if (batch.length > 0) {
-                    return batch;
-                }
-                // console.log(
-                //   `Isolating task ${task.id.serialize()} due to isolateAfter limit`,
-                // );
-                batch.push(task);
-                return batch;
-            }
-            if (locks.some((l) => l.restrains(task.lock))) {
-                locks.push(task.lock);
-                continue;
-            }
-            if (batchLocks.some((l) => l.restrains(task.lock, false))) {
-                locks.push(task.lock);
-                continue;
-            }
-            if (task.isProcessed) {
-                continue;
-            }
-            if (task.isProcessing) {
-                locks.push(task.lock);
-                continue;
-            }
-            batch.push(task);
-            batchLocks.push(task.lock);
-        }
-        return batch;
-    }
-}
-exports.Task = Task;
-//# sourceMappingURL=firestore.projector.js.map
+exports.FirestoreProjector = FirestoreProjector;
+exports.FirestoreQueueStore = FirestoreQueueStore;
+exports.Task = Task;