@ddd-ts/event-sourcing-firestore 0.0.0-compute-timeout-on-process.7 → 0.0.0-compute-timeout-on-process.9

package/dist/projection/firestore.projector.js

@@ -1,7 +1,8 @@
-import { CheckpointId, Cursor, ESProjection, EventId, IEsEvent, IFact, ISavedChange, Lock, ProjectedStream, ProjectedStreamReader, Serialized } from "@ddd-ts/core";
-import { DefaultConverter, FirestoreTransaction } from "@ddd-ts/store-firestore";
-import { FieldValue, Firestore, Timestamp, WriteBatch } from "firebase-admin/firestore";
-import { Mapping, MicrosecondTimestamp, Optional, Shape } from "@ddd-ts/shape";
+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 = {
@@ -15,7 +16,7 @@ const TaskState = {
 	MISSING: "MISSING"
 };
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const RETENTION = MicrosecondTimestamp.MONTH;
+const RETENTION = _ddd_ts_shape.MicrosecondTimestamp.MONTH;
 var FirestoreProjector = class {
 	_unclaim = true;
 	constructor(projection, reader, queue, config = {
@@ -183,19 +184,19 @@ var AlreadyEnqueuedError = class extends Error {
 	}
 };
 var FirestoreQueueStore = class {
-	converter = new DefaultConverter();
+	converter = new _ddd_ts_store_firestore.DefaultConverter();
 	collection;
 	constructor(db) {
 		this.db = db;
 		this.collection = db.collection("checkpoints");
 	}
 	timestampToMicroseconds(timestamp) {
-		return new MicrosecondTimestamp(BigInt(timestamp.seconds) * BigInt(1e6) + BigInt(timestamp.nanoseconds) / BigInt(1e3));
+		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 Timestamp(Number(seconds), Number(nanoseconds));
+		return new firebase_admin_firestore.Timestamp(Number(seconds), Number(nanoseconds));
 	}
 	async enqueue(checkpointId, tasks) {
 		const batch = this.collection.firestore.batch();
@@ -221,11 +222,11 @@ var FirestoreQueueStore = class {
 			const ref = this.queued(checkpointId, task.id);
 			batch.update(ref, {
 				claimer: claimer.serialize(),
-				claimedAt: FieldValue.serverTimestamp(),
-				[`claimsMetadata.${claimer.serialize()}`]: { claimedAt: FieldValue.serverTimestamp() },
-				claimIds: FieldValue.arrayUnion(claimer.serialize()),
-				attempts: FieldValue.increment(1),
-				remaining: FieldValue.increment(-1)
+				claimedAt: firebase_admin_firestore.FieldValue.serverTimestamp(),
+				[`claimsMetadata.${claimer.serialize()}`]: { claimedAt: firebase_admin_firestore.FieldValue.serverTimestamp() },
+				claimIds: firebase_admin_firestore.FieldValue.arrayUnion(claimer.serialize()),
+				attempts: firebase_admin_firestore.FieldValue.increment(1),
+				remaining: firebase_admin_firestore.FieldValue.increment(-1)
 			}, { lastUpdateTime: this.microsecondsToTimestamp(task.lastUpdateTime) });
 		}
 		await batch.commit();
@@ -235,7 +236,7 @@ var FirestoreQueueStore = class {
 		if (!headDoc) return;
 		const headData = this.converter.fromFirestoreSnapshot(headDoc);
 		if (!headData) return;
-		return headDoc ? Cursor.deserialize({
+		return headDoc ? _ddd_ts_core.Cursor.deserialize({
 			ref: headData.ref,
 			occurredAt: headData.occurredAt,
 			revision: headData.revision,
@@ -259,8 +260,8 @@ var FirestoreQueueStore = class {
 			for (const task of expiredTasks) {
 				const ref = this.queued(checkpointId, task.id);
 				batch.update(ref, {
-					claimer: FieldValue.delete(),
-					claimedAt: FieldValue.delete(),
+					claimer: firebase_admin_firestore.FieldValue.delete(),
+					claimedAt: firebase_admin_firestore.FieldValue.delete(),
 					claimIds: task.claimIds
 				}, { lastUpdateTime: this.microsecondsToTimestamp(task.lastUpdateTime) });
 			}
@@ -280,9 +281,9 @@ var FirestoreQueueStore = class {
 		for (const task of tasks) {
 			const ref = this.queued(checkpointId, task.id);
 			batch.update(ref, {
-				claimer: FieldValue.delete(),
-				claimedAt: FieldValue.delete(),
-				claimIds: FieldValue.arrayRemove(task.currentClaimId)
+				claimer: firebase_admin_firestore.FieldValue.delete(),
+				claimedAt: firebase_admin_firestore.FieldValue.delete(),
+				claimIds: firebase_admin_firestore.FieldValue.arrayRemove(task.currentClaimId)
 			}, { lastUpdateTime: this.microsecondsToTimestamp(task.lastUpdateTime) });
 		}
 		await batch.commit();
@@ -301,7 +302,7 @@ var FirestoreQueueStore = class {
 			if (data.processed === true) return TaskState.PROCESSED;
 			return TaskState.ENQUEUED;
 		}
-		const lastRetention = MicrosecondTimestamp.now().sub(RETENTION);
+		const lastRetention = _ddd_ts_shape.MicrosecondTimestamp.now().sub(RETENTION);
 		if (cursor.isOlderThan(lastRetention)) return TaskState.PROCESSED;
 		return TaskState.MISSING;
 	}
@@ -321,14 +322,14 @@ var FirestoreQueueStore = class {
 				const ref = this.queued(id, eventId);
 				trx.transaction.update(ref, {
 					processed: true,
-					[`claimsMetadata.${claimerId.serialize()}.processedAt`]: FieldValue.serverTimestamp()
+					[`claimsMetadata.${claimerId.serialize()}.processedAt`]: firebase_admin_firestore.FieldValue.serverTimestamp()
 				});
 			}
 			return;
 		}
 		await Promise.all(eventIds.map((eventId) => this.queued(id, eventId).update({
 			processed: true,
-			[`claimsMetadata.${claimerId.serialize()}.processedAt`]: FieldValue.serverTimestamp()
+			[`claimsMetadata.${claimerId.serialize()}.processedAt`]: firebase_admin_firestore.FieldValue.serverTimestamp()
 		})));
 	}
 	async getTailCursor(id) {
@@ -336,7 +337,7 @@ var FirestoreQueueStore = class {
 		if (!tailDoc) return;
 		const tailData = this.converter.fromFirestoreSnapshot(tailDoc);
 		if (!tailData) return;
-		return tailDoc ? Cursor.deserialize({
+		return tailDoc ? _ddd_ts_core.Cursor.deserialize({
 			ref: tailData.ref,
 			occurredAt: tailData.occurredAt,
 			revision: tailData.revision,
@@ -344,7 +345,7 @@ var FirestoreQueueStore = class {
 		}) : void 0;
 	}
 	async cleanup(id) {
-		const aMonthAgo = MicrosecondTimestamp.now().sub(MicrosecondTimestamp.WEEK.mult(4));
+		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();
@@ -374,14 +375,14 @@ var FirestoreQueueStore = class {
 	* correct point in time, avoiding reprocessing of old events.
 	*/
 	async seed(checkpointId) {
-		const cursor = new Cursor({
+		const cursor = new _ddd_ts_core.Cursor({
 			ref: "seed",
-			occurredAt: MicrosecondTimestamp.now(),
+			occurredAt: _ddd_ts_shape.MicrosecondTimestamp.now(),
 			revision: 0,
-			eventId: EventId.generate()
+			eventId: _ddd_ts_core.EventId.generate()
 		});
 		const task = new Task({
-			id: EventId.generate(),
+			id: _ddd_ts_core.EventId.generate(),
 			ref: "Seed",
 			occurredAt: cursor.occurredAt,
 			revision: cursor.revision,
@@ -391,7 +392,7 @@ var FirestoreQueueStore = class {
 			claimedAt: void 0,
 			claimsMetadata: {},
 			claimIds: [],
-			lock: new Lock({}),
+			lock: new _ddd_ts_core.Lock({}),
 			remaining: 1,
 			claimTimeout: 0,
 			skipAfter: 0,
@@ -407,30 +408,30 @@ var FirestoreQueueStore = class {
 		}
 	}
 };
-var ClaimerId = class extends EventId {};
-var Task = class Task extends Shape({
-	id: EventId,
+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: MicrosecondTimestamp,
+	occurredAt: _ddd_ts_shape.MicrosecondTimestamp,
 	revision: Number,
 	attempts: Number,
 	processed: Boolean,
-	claimer: Optional(String),
-	claimedAt: Optional(MicrosecondTimestamp),
-	claimsMetadata: Mapping([{
-		claimedAt: MicrosecondTimestamp,
-		processedAt: Optional(MicrosecondTimestamp)
+	claimer: (0, _ddd_ts_shape.Optional)(String),
+	claimedAt: (0, _ddd_ts_shape.Optional)(_ddd_ts_shape.MicrosecondTimestamp),
+	claimsMetadata: (0, _ddd_ts_shape.Mapping)([{
+		claimedAt: _ddd_ts_shape.MicrosecondTimestamp,
+		processedAt: (0, _ddd_ts_shape.Optional)(_ddd_ts_shape.MicrosecondTimestamp)
 	}]),
 	claimIds: [String],
-	lock: Lock,
+	lock: _ddd_ts_core.Lock,
 	skipAfter: Number,
 	remaining: Number,
 	isolateAfter: Number,
 	claimTimeout: Number,
-	lastUpdateTime: Optional(MicrosecondTimestamp)
+	lastUpdateTime: (0, _ddd_ts_shape.Optional)(_ddd_ts_shape.MicrosecondTimestamp)
 }) {
 	get cursor() {
-		return new Cursor({
+		return new _ddd_ts_core.Cursor({
 			ref: this.ref,
 			occurredAt: this.occurredAt,
 			revision: this.revision,
@@ -477,7 +478,7 @@ var Task = class Task extends Shape({
 		if (!claimer) return;
 		const claimInfo = this.claimsMetadata[claimer];
 		if (!claimInfo || !claimInfo.claimedAt) return;
-		if (MicrosecondTimestamp.now().micros - claimInfo.claimedAt.micros > BigInt(this.claimTimeout) * 1000n) this.claimIds = this.claimIds.filter((id) => id !== claimer);
+		if (_ddd_ts_shape.MicrosecondTimestamp.now().micros - claimInfo.claimedAt.micros > BigInt(this.claimTimeout) * 1000n) this.claimIds = this.claimIds.filter((id) => id !== claimer);
 	}
 	static deserializeWithLastUpdateTime(data, timestamp) {
 		return Task.deserialize({
@@ -517,5 +518,8 @@ var Task = class Task extends Shape({
 };
 
 //#endregion
-export { AlreadyEnqueuedError, ClaimerId, FirestoreProjector, FirestoreQueueStore, Task };
-//# sourceMappingURL=firestore.projector.js.map
+exports.AlreadyEnqueuedError = AlreadyEnqueuedError;
+exports.ClaimerId = ClaimerId;
+exports.FirestoreProjector = FirestoreProjector;
+exports.FirestoreQueueStore = FirestoreQueueStore;
+exports.Task = Task;