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

package/dist/firestore.event-stream.storage-layer.mjs

@@ -0,0 +1,65 @@
+import { StreamId } from "@ddd-ts/core";
+import { DefaultConverter } from "@ddd-ts/store-firestore";
+import * as fb from "firebase-admin";
+
+//#region src/firestore.event-stream.storage-layer.ts
+const serverTimestamp = fb.firestore.FieldValue.serverTimestamp;
+var FirestoreEventStreamStorageLayer = class {
+	constructor(firestore, converter = new DefaultConverter()) {
+		this.firestore = firestore;
+		this.converter = converter;
+	}
+	isLocalRevisionOutdatedError(error) {
+		return typeof error === "object" && error !== null && "code" in error && error.code === 6;
+	}
+	getCollection(streamId) {
+		return this.firestore.collection("event-store").doc(streamId.aggregateType).collection("streams").doc(streamId.aggregateId).collection("events");
+	}
+	async append(streamId, changes, expectedRevision, trx) {
+		const collection = this.getCollection(streamId);
+		const result = [];
+		let revision = expectedRevision + 1;
+		for (const change of changes) {
+			const storageChange = {
+				aggregateType: streamId.aggregateType,
+				eventId: change.id,
+				aggregateId: streamId.aggregateId,
+				revision,
+				name: change.name,
+				payload: change.payload,
+				occurredAt: serverTimestamp(),
+				version: change.version
+			};
+			const ref = collection.doc(`${revision}`);
+			result.push({
+				...change,
+				ref: ref.path,
+				revision,
+				occurredAt: void 0
+			});
+			trx.transaction.create(ref, this.converter.toFirestore(storageChange));
+			revision++;
+		}
+		return result;
+	}
+	async *read(streamId, startAt) {
+		const query = this.getCollection(streamId).where("revision", ">=", startAt || 0).orderBy("revision", "asc");
+		for await (const event of query.stream()) {
+			const e = event;
+			const data = this.converter.fromFirestore(e);
+			yield {
+				id: data.eventId,
+				ref: e.ref.path,
+				revision: data.revision,
+				name: data.name,
+				$name: data.name,
+				payload: data.payload,
+				occurredAt: data.occurredAt,
+				version: data.version ?? 1
+			};
+		}
+	}
+};
+
+//#endregion
+export { FirestoreEventStreamStorageLayer };

package/dist/firestore.event-stream.store.d.ts

@@ -0,0 +1,6 @@
+import { EventStreamStore, type IEsEvent, type IEventBus, type ISerializer } from "@ddd-ts/core";
+import { Firestore } from "firebase-admin/firestore";
+export declare class FirestoreEventStreamStore<Event extends IEsEvent> extends EventStreamStore<Event> {
+    constructor(firestore: Firestore, serializer: ISerializer<Event>, eventBus?: IEventBus);
+}
+//# sourceMappingURL=firestore.event-stream.store.d.ts.map

package/dist/firestore.event-stream.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-stream.store.d.ts","sourceRoot":"","sources":["../src/firestore.event-stream.store.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,WAAW,EACjB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,qBAAa,yBAAyB,CACpC,KAAK,SAAS,QAAQ,CACtB,SAAQ,gBAAgB,CAAC,KAAK,CAAC;gBAE7B,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC,EAC9B,QAAQ,CAAC,EAAE,SAAS;CAQvB"}

package/dist/firestore.event-stream.store.js

@@ -0,0 +1,14 @@
+const require_runtime = require('./_virtual/_rolldown/runtime.js');
+const require_firestore_event_stream_storage_layer = require('./firestore.event-stream.storage-layer.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+let firebase_admin_firestore = require("firebase-admin/firestore");
+
+//#region src/firestore.event-stream.store.ts
+var FirestoreEventStreamStore = class extends _ddd_ts_core.EventStreamStore {
+	constructor(firestore, serializer, eventBus) {
+		super(new require_firestore_event_stream_storage_layer.FirestoreEventStreamStorageLayer(firestore), serializer, eventBus);
+	}
+};
+
+//#endregion
+exports.FirestoreEventStreamStore = FirestoreEventStreamStore;

package/dist/firestore.event-stream.store.mjs

@@ -0,0 +1,13 @@
+import { FirestoreEventStreamStorageLayer } from "./firestore.event-stream.storage-layer.mjs";
+import { EventStreamStore } from "@ddd-ts/core";
+import "firebase-admin/firestore";
+
+//#region src/firestore.event-stream.store.ts
+var FirestoreEventStreamStore = class extends EventStreamStore {
+	constructor(firestore, serializer, eventBus) {
+		super(new FirestoreEventStreamStorageLayer(firestore), serializer, eventBus);
+	}
+};
+
+//#endregion
+export { FirestoreEventStreamStore };

package/dist/firestore.projected-stream.reader.d.ts

@@ -0,0 +1,13 @@
+import { Cursor, type IEsEvent, type IFact, type ISavedChange, type ISerializer, ProjectedStream, ProjectedStreamReader } from "@ddd-ts/core";
+import { Firestore } from "firebase-admin/firestore";
+import { FirestoreProjectedStreamStorageLayer } from "./firestore.projected-stream.storage-layer";
+export declare class FirestoreProjectedStreamReader<Event extends IEsEvent> extends ProjectedStreamReader<Event> {
+    storage: FirestoreProjectedStreamStorageLayer;
+    serializer: ISerializer<Event>;
+    constructor(firestore: Firestore, serializer: ISerializer<Event>);
+    getCursor(savedChange: ISavedChange<Event>): Promise<Cursor | undefined>;
+    get(cursor: Cursor): Promise<IFact<Event> | undefined>;
+    slice(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor, endAt?: Cursor, limit?: number): Promise<any>;
+    read(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor, endAt?: Cursor): AsyncGenerator<IFact<Event>, void, unknown>;
+}
+//# sourceMappingURL=firestore.projected-stream.reader.d.ts.map

package/dist/firestore.projected-stream.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.projected-stream.reader.d.ts","sourceRoot":"","sources":["../src/firestore.projected-stream.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,KAAK,QAAQ,EACb,KAAK,KAAK,EACV,KAAK,YAAY,EAEjB,KAAK,WAAW,EAChB,eAAe,EACf,qBAAqB,EACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,oCAAoC,EAAE,MAAM,4CAA4C,CAAC;AAElG,qBAAa,8BAA8B,CACzC,KAAK,SAAS,QAAQ,CACtB,SAAQ,qBAAqB,CAAC,KAAK,CAAC;IACpC,OAAO,EAAE,oCAAoC,CAAC;IAC9C,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;gBACnB,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC;IAO1D,SAAS,CAAC,WAAW,EAAE,YAAY,CAAC,KAAK,CAAC;IAK1C,GAAG,CAAC,MAAM,EAAE,MAAM;IAUlB,KAAK,CACT,eAAe,EAAE,eAAe,EAChC,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM;IAcT,IAAI,CACT,eAAe,EAAE,eAAe,EAChC,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,MAAM;CAWjB"}

package/dist/firestore.projected-stream.reader.js

@@ -0,0 +1,35 @@
+const require_runtime = require('./_virtual/_rolldown/runtime.js');
+const require_firestore_projected_stream_storage_layer = require('./firestore.projected-stream.storage-layer.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+let firebase_admin_firestore = require("firebase-admin/firestore");
+
+//#region src/firestore.projected-stream.reader.ts
+var FirestoreProjectedStreamReader = class extends _ddd_ts_core.ProjectedStreamReader {
+	storage;
+	serializer;
+	constructor(firestore, serializer) {
+		const storage = new require_firestore_projected_stream_storage_layer.FirestoreProjectedStreamStorageLayer(firestore);
+		super(storage, serializer);
+		this.storage = storage;
+		this.serializer = serializer;
+	}
+	async getCursor(savedChange) {
+		const serialized = await this.serializer.serialize(savedChange);
+		return this.storage.getCursor(serialized);
+	}
+	async get(cursor) {
+		const serialized = await this.storage.get(cursor);
+		if (!serialized) return;
+		return this.serializer.deserialize(serialized);
+	}
+	async slice(projectedStream, shard, startAfter, endAt, limit) {
+		const serialized = await this.storage.slice(projectedStream, shard, startAfter, endAt, limit);
+		return Promise.all(serialized.map((s) => this.serializer.deserialize(s)));
+	}
+	async *read(projectedStream, shard, startAfter, endAt) {
+		for await (const serialized of this.storage.read(projectedStream, shard, startAfter, endAt)) yield this.serializer.deserialize(serialized);
+	}
+};
+
+//#endregion
+exports.FirestoreProjectedStreamReader = FirestoreProjectedStreamReader;

package/dist/firestore.projected-stream.reader.mjs

@@ -0,0 +1,34 @@
+import { FirestoreProjectedStreamStorageLayer } from "./firestore.projected-stream.storage-layer.mjs";
+import { Cursor, ProjectedStreamReader } from "@ddd-ts/core";
+import "firebase-admin/firestore";
+
+//#region src/firestore.projected-stream.reader.ts
+var FirestoreProjectedStreamReader = class extends ProjectedStreamReader {
+	storage;
+	serializer;
+	constructor(firestore, serializer) {
+		const storage = new FirestoreProjectedStreamStorageLayer(firestore);
+		super(storage, serializer);
+		this.storage = storage;
+		this.serializer = serializer;
+	}
+	async getCursor(savedChange) {
+		const serialized = await this.serializer.serialize(savedChange);
+		return this.storage.getCursor(serialized);
+	}
+	async get(cursor) {
+		const serialized = await this.storage.get(cursor);
+		if (!serialized) return;
+		return this.serializer.deserialize(serialized);
+	}
+	async slice(projectedStream, shard, startAfter, endAt, limit) {
+		const serialized = await this.storage.slice(projectedStream, shard, startAfter, endAt, limit);
+		return Promise.all(serialized.map((s) => this.serializer.deserialize(s)));
+	}
+	async *read(projectedStream, shard, startAfter, endAt) {
+		for await (const serialized of this.storage.read(projectedStream, shard, startAfter, endAt)) yield this.serializer.deserialize(serialized);
+	}
+};
+
+//#endregion
+export { FirestoreProjectedStreamReader };

package/dist/firestore.projected-stream.reader.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=firestore.projected-stream.reader.spec.d.ts.map

package/dist/firestore.projected-stream.reader.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.projected-stream.reader.spec.d.ts","sourceRoot":"","sources":["../src/firestore.projected-stream.reader.spec.ts"],"names":[],"mappings":""}

package/dist/firestore.projected-stream.storage-layer.d.ts

@@ -0,0 +1,31 @@
+import { type ISerializedFact, type ISerializedSavedChange, LakeSource, ProjectedStream, type ProjectedStreamStorageLayer, StreamSource } from "@ddd-ts/core";
+import { DefaultConverter } from "@ddd-ts/store-firestore";
+import { Filter, Firestore, Timestamp } from "firebase-admin/firestore";
+import { MicrosecondTimestamp } from "@ddd-ts/shape";
+import { Cursor } from "@ddd-ts/core/dist/components/cursor";
+export declare class FirestoreLakeSourceFilter {
+    filter(shard: string, lakeSource: LakeSource): Filter;
+}
+export declare class FirestoreStreamSourceFilter {
+    filter(shard: string, streamSource: StreamSource): Filter;
+}
+export declare class FirestoreProjectedStreamStorageLayer implements ProjectedStreamStorageLayer {
+    private readonly firestore;
+    readonly converter: DefaultConverter<FirebaseFirestore.DocumentData>;
+    constructor(firestore: Firestore, converter?: DefaultConverter<FirebaseFirestore.DocumentData>);
+    read(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor, endAt?: Cursor): AsyncGenerator<{
+        id: any;
+        ref: string;
+        revision: any;
+        name: any;
+        $name: any;
+        payload: any;
+        occurredAt: any;
+        version: any;
+    }, void, unknown>;
+    microsecondToTimestamp(microseconds: MicrosecondTimestamp): Timestamp;
+    get(cursor: Cursor): Promise<ISerializedFact | undefined>;
+    getCursor(savedChange: ISerializedSavedChange): Promise<Cursor | undefined>;
+    slice(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor, endAt?: Cursor, limit?: number): Promise<ISerializedFact[]>;
+}
+//# sourceMappingURL=firestore.projected-stream.storage-layer.d.ts.map

package/dist/firestore.projected-stream.storage-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.projected-stream.storage-layer.d.ts","sourceRoot":"","sources":["../src/firestore.projected-stream.storage-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,UAAU,EACV,eAAe,EACf,KAAK,2BAA2B,EAChC,YAAY,EACb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EACL,MAAM,EACN,SAAS,EAET,SAAS,EACV,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAE7D,qBAAa,yBAAyB;IACpC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU;CAM7C;AAED,qBAAa,2BAA2B;IACtC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY;CAOjD;AAED,qBAAa,oCACX,YAAW,2BAA2B;IAGpC,OAAO,CAAC,QAAQ,CAAC,SAAS;aACV,SAAS;gBADR,SAAS,EAAE,SAAS,EACrB,SAAS,mDAAyB;IAG7C,IAAI,CACT,eAAe,EAAE,eAAe,EAChC,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,MAAM;;;;;;;;;;IA2CT,sBAAsB,CAAC,YAAY,EAAE,oBAAoB;IAM1D,GAAG,CAAC,MAAM,EAAE,MAAM;IAkBlB,SAAS,CACb,WAAW,EAAE,sBAAsB,GAClC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAcxB,KAAK,CACT,eAAe,EAAE,eAAe,EAChC,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM;CAiDjB"}

package/dist/firestore.projected-stream.storage-layer.js

@@ -0,0 +1,121 @@
+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");
+let _ddd_ts_core_dist_components_cursor = require("@ddd-ts/core/dist/components/cursor");
+
+//#region src/firestore.projected-stream.storage-layer.ts
+var FirestoreLakeSourceFilter = class {
+	filter(shard, lakeSource) {
+		return firebase_admin_firestore.Filter.and(firebase_admin_firestore.Filter.where(`payload.${lakeSource.shardKey}`, "==", shard), firebase_admin_firestore.Filter.where("name", "in", lakeSource.events));
+	}
+};
+var FirestoreStreamSourceFilter = class {
+	filter(shard, streamSource) {
+		return firebase_admin_firestore.Filter.and(firebase_admin_firestore.Filter.where("aggregateType", "==", streamSource.aggregateType), firebase_admin_firestore.Filter.where(`payload.${streamSource.shardKey}`, "==", shard), firebase_admin_firestore.Filter.where("name", "in", streamSource.events));
+	}
+};
+var FirestoreProjectedStreamStorageLayer = class {
+	constructor(firestore, converter = new _ddd_ts_store_firestore.DefaultConverter()) {
+		this.firestore = firestore;
+		this.converter = converter;
+	}
+	async *read(projectedStream, shard, startAfter, endAt) {
+		let query = this.firestore.collectionGroup("events").orderBy("occurredAt").orderBy("revision");
+		const filters = projectedStream.sources.map((source) => {
+			if (source instanceof _ddd_ts_core.LakeSource) return new FirestoreLakeSourceFilter().filter(shard, source);
+			if (source instanceof _ddd_ts_core.StreamSource) return new FirestoreStreamSourceFilter().filter(shard, source);
+			throw new Error("Unknown source type");
+		});
+		query = query.where(firebase_admin_firestore.Filter.or(...filters));
+		if (startAfter) {
+			const ts = this.microsecondToTimestamp(startAfter.occurredAt);
+			query = query.startAfter(ts, startAfter.revision);
+		}
+		if (endAt) {
+			const ts = this.microsecondToTimestamp(endAt.occurredAt);
+			query = query.endAt(ts, endAt.revision);
+		}
+		for await (const doc of query.stream()) {
+			const data = this.converter.fromFirestore(doc);
+			yield {
+				id: data.eventId,
+				ref: doc.ref.path,
+				revision: data.revision,
+				name: data.name,
+				$name: data.name,
+				payload: data.payload,
+				occurredAt: data.occurredAt,
+				version: data.version ?? 1
+			};
+		}
+	}
+	microsecondToTimestamp(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 get(cursor) {
+		const doc = await this.firestore.doc(cursor.ref).get();
+		if (!doc.exists) return;
+		const data = this.converter.fromFirestoreSnapshot(doc);
+		return {
+			id: data.eventId,
+			ref: doc.ref.path,
+			revision: data.revision,
+			name: data.name,
+			$name: data.name,
+			payload: data.payload,
+			occurredAt: data.occurredAt,
+			version: data.version ?? 1
+		};
+	}
+	async getCursor(savedChange) {
+		const doc = await this.firestore.doc(savedChange.ref).get();
+		if (!doc.exists) return;
+		const data = this.converter.fromFirestoreSnapshot(doc);
+		return _ddd_ts_core_dist_components_cursor.Cursor.deserialize({
+			eventId: data.eventId,
+			ref: doc.ref.path,
+			occurredAt: data.occurredAt,
+			revision: data.revision
+		});
+	}
+	async slice(projectedStream, shard, startAfter, endAt, limit) {
+		let query = this.firestore.collectionGroup("events").orderBy("occurredAt").orderBy("revision");
+		const filters = projectedStream.sources.map((source) => {
+			if (source instanceof _ddd_ts_core.LakeSource) return new FirestoreLakeSourceFilter().filter(shard, source);
+			if (source instanceof _ddd_ts_core.StreamSource) return new FirestoreStreamSourceFilter().filter(shard, source);
+			throw new Error("Unknown source type");
+		});
+		query = query.where(firebase_admin_firestore.Filter.or(...filters));
+		if (startAfter) {
+			const ts = this.microsecondToTimestamp(startAfter.occurredAt);
+			query = query.startAfter(ts, startAfter.revision);
+		}
+		if (endAt) {
+			const ts = this.microsecondToTimestamp(endAt.occurredAt);
+			query = query.endAt(ts, endAt.revision);
+		}
+		if (limit) query = query.limit(limit);
+		return (await query.get()).docs.map((doc) => {
+			const data = this.converter.fromFirestore(doc);
+			return {
+				id: data.eventId,
+				ref: doc.ref.path,
+				revision: data.revision,
+				name: data.name,
+				$name: data.name,
+				payload: data.payload,
+				occurredAt: data.occurredAt,
+				version: data.version ?? 1
+			};
+		});
+	}
+};
+
+//#endregion
+exports.FirestoreLakeSourceFilter = FirestoreLakeSourceFilter;
+exports.FirestoreProjectedStreamStorageLayer = FirestoreProjectedStreamStorageLayer;
+exports.FirestoreStreamSourceFilter = FirestoreStreamSourceFilter;

package/dist/firestore.projected-stream.storage-layer.mjs

@@ -0,0 +1,118 @@
+import { LakeSource, StreamSource } from "@ddd-ts/core";
+import { DefaultConverter } from "@ddd-ts/store-firestore";
+import { Filter, Timestamp } from "firebase-admin/firestore";
+import { MicrosecondTimestamp } from "@ddd-ts/shape";
+import { Cursor as Cursor$1 } from "@ddd-ts/core/dist/components/cursor";
+
+//#region src/firestore.projected-stream.storage-layer.ts
+var FirestoreLakeSourceFilter = class {
+	filter(shard, lakeSource) {
+		return Filter.and(Filter.where(`payload.${lakeSource.shardKey}`, "==", shard), Filter.where("name", "in", lakeSource.events));
+	}
+};
+var FirestoreStreamSourceFilter = class {
+	filter(shard, streamSource) {
+		return Filter.and(Filter.where("aggregateType", "==", streamSource.aggregateType), Filter.where(`payload.${streamSource.shardKey}`, "==", shard), Filter.where("name", "in", streamSource.events));
+	}
+};
+var FirestoreProjectedStreamStorageLayer = class {
+	constructor(firestore, converter = new DefaultConverter()) {
+		this.firestore = firestore;
+		this.converter = converter;
+	}
+	async *read(projectedStream, shard, startAfter, endAt) {
+		let query = this.firestore.collectionGroup("events").orderBy("occurredAt").orderBy("revision");
+		const filters = projectedStream.sources.map((source) => {
+			if (source instanceof LakeSource) return new FirestoreLakeSourceFilter().filter(shard, source);
+			if (source instanceof StreamSource) return new FirestoreStreamSourceFilter().filter(shard, source);
+			throw new Error("Unknown source type");
+		});
+		query = query.where(Filter.or(...filters));
+		if (startAfter) {
+			const ts = this.microsecondToTimestamp(startAfter.occurredAt);
+			query = query.startAfter(ts, startAfter.revision);
+		}
+		if (endAt) {
+			const ts = this.microsecondToTimestamp(endAt.occurredAt);
+			query = query.endAt(ts, endAt.revision);
+		}
+		for await (const doc of query.stream()) {
+			const data = this.converter.fromFirestore(doc);
+			yield {
+				id: data.eventId,
+				ref: doc.ref.path,
+				revision: data.revision,
+				name: data.name,
+				$name: data.name,
+				payload: data.payload,
+				occurredAt: data.occurredAt,
+				version: data.version ?? 1
+			};
+		}
+	}
+	microsecondToTimestamp(microseconds) {
+		const seconds = BigInt(microseconds.micros) / 1000000n;
+		const nanoseconds = BigInt(microseconds.micros) % 1000000n * 1000n;
+		return new Timestamp(Number(seconds), Number(nanoseconds));
+	}
+	async get(cursor) {
+		const doc = await this.firestore.doc(cursor.ref).get();
+		if (!doc.exists) return;
+		const data = this.converter.fromFirestoreSnapshot(doc);
+		return {
+			id: data.eventId,
+			ref: doc.ref.path,
+			revision: data.revision,
+			name: data.name,
+			$name: data.name,
+			payload: data.payload,
+			occurredAt: data.occurredAt,
+			version: data.version ?? 1
+		};
+	}
+	async getCursor(savedChange) {
+		const doc = await this.firestore.doc(savedChange.ref).get();
+		if (!doc.exists) return;
+		const data = this.converter.fromFirestoreSnapshot(doc);
+		return Cursor$1.deserialize({
+			eventId: data.eventId,
+			ref: doc.ref.path,
+			occurredAt: data.occurredAt,
+			revision: data.revision
+		});
+	}
+	async slice(projectedStream, shard, startAfter, endAt, limit) {
+		let query = this.firestore.collectionGroup("events").orderBy("occurredAt").orderBy("revision");
+		const filters = projectedStream.sources.map((source) => {
+			if (source instanceof LakeSource) return new FirestoreLakeSourceFilter().filter(shard, source);
+			if (source instanceof StreamSource) return new FirestoreStreamSourceFilter().filter(shard, source);
+			throw new Error("Unknown source type");
+		});
+		query = query.where(Filter.or(...filters));
+		if (startAfter) {
+			const ts = this.microsecondToTimestamp(startAfter.occurredAt);
+			query = query.startAfter(ts, startAfter.revision);
+		}
+		if (endAt) {
+			const ts = this.microsecondToTimestamp(endAt.occurredAt);
+			query = query.endAt(ts, endAt.revision);
+		}
+		if (limit) query = query.limit(limit);
+		return (await query.get()).docs.map((doc) => {
+			const data = this.converter.fromFirestore(doc);
+			return {
+				id: data.eventId,
+				ref: doc.ref.path,
+				revision: data.revision,
+				name: data.name,
+				$name: data.name,
+				payload: data.payload,
+				occurredAt: data.occurredAt,
+				version: data.version ?? 1
+			};
+		});
+	}
+};
+
+//#endregion
+export { FirestoreLakeSourceFilter, FirestoreProjectedStreamStorageLayer, FirestoreStreamSourceFilter };

package/dist/firestore.snapshotter.d.ts

@@ -0,0 +1,6 @@
+import { type IEventSourced, type IIdentifiable, type ISerializer } from "@ddd-ts/core";
+import { FirestoreStore } from "@ddd-ts/store-firestore";
+export declare class FirestoreSnapshotter<A extends IEventSourced & IIdentifiable> extends FirestoreStore<A> {
+    constructor(aggregateType: string, database: FirebaseFirestore.Firestore, serializer: ISerializer<A>);
+}
+//# sourceMappingURL=firestore.snapshotter.d.ts.map

package/dist/firestore.snapshotter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.snapshotter.d.ts","sourceRoot":"","sources":["../src/firestore.snapshotter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AA4BzD,qBAAa,oBAAoB,CAC/B,CAAC,SAAS,aAAa,GAAG,aAAa,CACvC,SAAQ,cAAc,CAAC,CAAC,CAAC;gBAEvB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,iBAAiB,CAAC,SAAS,EACrC,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC;CAY7B"}

package/dist/firestore.snapshotter.js

@@ -0,0 +1,36 @@
+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");
+
+//#region src/firestore.snapshotter.ts
+var SnapshotSerializer = class {
+	constructor(serializer, aggregateType) {
+		this.serializer = serializer;
+		this.aggregateType = aggregateType;
+	}
+	async serialize(instance) {
+		return {
+			...await this.serializer.serialize(instance),
+			$name: this.aggregateType,
+			revision: instance.acknowledgedRevision
+		};
+	}
+	async deserialize(serialized) {
+		const { revision, ...content } = serialized;
+		const instance = await this.serializer.deserialize({
+			$name: this.aggregateType,
+			...content
+		});
+		instance.acknowledgedRevision = Number(revision);
+		return instance;
+	}
+};
+var FirestoreSnapshotter = class extends _ddd_ts_store_firestore.FirestoreStore {
+	constructor(aggregateType, database, serializer) {
+		const collection = database.collection("event-store").doc(aggregateType).collection("streams");
+		super(collection, new SnapshotSerializer(serializer, aggregateType), aggregateType);
+	}
+};
+
+//#endregion
+exports.FirestoreSnapshotter = FirestoreSnapshotter;

package/dist/firestore.snapshotter.mjs

@@ -0,0 +1,35 @@
+import "@ddd-ts/core";
+import { FirestoreStore } from "@ddd-ts/store-firestore";
+
+//#region src/firestore.snapshotter.ts
+var SnapshotSerializer = class {
+	constructor(serializer, aggregateType) {
+		this.serializer = serializer;
+		this.aggregateType = aggregateType;
+	}
+	async serialize(instance) {
+		return {
+			...await this.serializer.serialize(instance),
+			$name: this.aggregateType,
+			revision: instance.acknowledgedRevision
+		};
+	}
+	async deserialize(serialized) {
+		const { revision, ...content } = serialized;
+		const instance = await this.serializer.deserialize({
+			$name: this.aggregateType,
+			...content
+		});
+		instance.acknowledgedRevision = Number(revision);
+		return instance;
+	}
+};
+var FirestoreSnapshotter = class extends FirestoreStore {
+	constructor(aggregateType, database, serializer) {
+		const collection = database.collection("event-store").doc(aggregateType).collection("streams");
+		super(collection, new SnapshotSerializer(serializer, aggregateType), aggregateType);
+	}
+};
+
+//#endregion
+export { FirestoreSnapshotter };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { FirestoreEventLakeStorageLayer } from "./firestore.event-lake.storage-layer";
+export { FirestoreEventLakeStore } from "./firestore.event-lake.store";
+export { FirestoreEventStreamStorageLayer } from "./firestore.event-stream.storage-layer";
+export { FirestoreEventStreamStore } from "./firestore.event-stream.store";
+export { FirestoreEventStreamAggregateStore, MakeFirestoreEventStreamAggregateStore, } from "./firestore.event-stream.aggregate-store";
+export { FirestoreEventLakeAggregateStore, MakeFirestoreEventLakeAggregateStore, } from "./firestore.event-lake.aggregate-store";
+export { FirestoreProjectedStreamStorageLayer, FirestoreLakeSourceFilter, FirestoreStreamSourceFilter, } from "./firestore.projected-stream.storage-layer";
+export { FirestoreProjectedStreamReader } from "./firestore.projected-stream.reader";
+export { FirestoreSnapshotter } from "./firestore.snapshotter";
+export { FirestoreProjector, FirestoreQueueStore, Task, AlreadyEnqueuedError, ClaimerId, } from "./projection/firestore.projector";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,sCAAsC,CAAC;AACtF,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AAC1F,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAE3E,OAAO,EACL,kCAAkC,EAClC,sCAAsC,GACvC,MAAM,0CAA0C,CAAC;AAElD,OAAO,EACL,gCAAgC,EAChC,oCAAoC,GACrC,MAAM,wCAAwC,CAAC;AAEhD,OAAO,EACL,oCAAoC,EACpC,yBAAyB,EACzB,2BAA2B,GAC5B,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AAErF,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,IAAI,EACJ,oBAAoB,EACpB,SAAS,GACV,MAAM,kCAAkC,CAAC"}

package/dist/index.js

@@ -0,0 +1,30 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_firestore_event_lake_storage_layer = require('./firestore.event-lake.storage-layer.js');
+const require_firestore_event_lake_store = require('./firestore.event-lake.store.js');
+const require_firestore_event_stream_storage_layer = require('./firestore.event-stream.storage-layer.js');
+const require_firestore_event_stream_store = require('./firestore.event-stream.store.js');
+const require_firestore_snapshotter = require('./firestore.snapshotter.js');
+const require_firestore_event_stream_aggregate_store = require('./firestore.event-stream.aggregate-store.js');
+const require_firestore_event_lake_aggregate_store = require('./firestore.event-lake.aggregate-store.js');
+const require_firestore_projected_stream_storage_layer = require('./firestore.projected-stream.storage-layer.js');
+const require_firestore_projected_stream_reader = require('./firestore.projected-stream.reader.js');
+const require_firestore_projector = require('./projection/firestore.projector.js');
+
+exports.AlreadyEnqueuedError = require_firestore_projector.AlreadyEnqueuedError;
+exports.ClaimerId = require_firestore_projector.ClaimerId;
+exports.FirestoreEventLakeAggregateStore = require_firestore_event_lake_aggregate_store.FirestoreEventLakeAggregateStore;
+exports.FirestoreEventLakeStorageLayer = require_firestore_event_lake_storage_layer.FirestoreEventLakeStorageLayer;
+exports.FirestoreEventLakeStore = require_firestore_event_lake_store.FirestoreEventLakeStore;
+exports.FirestoreEventStreamAggregateStore = require_firestore_event_stream_aggregate_store.FirestoreEventStreamAggregateStore;
+exports.FirestoreEventStreamStorageLayer = require_firestore_event_stream_storage_layer.FirestoreEventStreamStorageLayer;
+exports.FirestoreEventStreamStore = require_firestore_event_stream_store.FirestoreEventStreamStore;
+exports.FirestoreLakeSourceFilter = require_firestore_projected_stream_storage_layer.FirestoreLakeSourceFilter;
+exports.FirestoreProjectedStreamReader = require_firestore_projected_stream_reader.FirestoreProjectedStreamReader;
+exports.FirestoreProjectedStreamStorageLayer = require_firestore_projected_stream_storage_layer.FirestoreProjectedStreamStorageLayer;
+exports.FirestoreProjector = require_firestore_projector.FirestoreProjector;
+exports.FirestoreQueueStore = require_firestore_projector.FirestoreQueueStore;
+exports.FirestoreSnapshotter = require_firestore_snapshotter.FirestoreSnapshotter;
+exports.FirestoreStreamSourceFilter = require_firestore_projected_stream_storage_layer.FirestoreStreamSourceFilter;
+exports.MakeFirestoreEventLakeAggregateStore = require_firestore_event_lake_aggregate_store.MakeFirestoreEventLakeAggregateStore;
+exports.MakeFirestoreEventStreamAggregateStore = require_firestore_event_stream_aggregate_store.MakeFirestoreEventStreamAggregateStore;
+exports.Task = require_firestore_projector.Task;

package/dist/index.mjs

@@ -0,0 +1,12 @@
+import { FirestoreEventLakeStorageLayer } from "./firestore.event-lake.storage-layer.mjs";
+import { FirestoreEventLakeStore } from "./firestore.event-lake.store.mjs";
+import { FirestoreEventStreamStorageLayer } from "./firestore.event-stream.storage-layer.mjs";
+import { FirestoreEventStreamStore } from "./firestore.event-stream.store.mjs";
+import { FirestoreSnapshotter } from "./firestore.snapshotter.mjs";
+import { FirestoreEventStreamAggregateStore, MakeFirestoreEventStreamAggregateStore } from "./firestore.event-stream.aggregate-store.mjs";
+import { FirestoreEventLakeAggregateStore, MakeFirestoreEventLakeAggregateStore } from "./firestore.event-lake.aggregate-store.mjs";
+import { FirestoreLakeSourceFilter, FirestoreProjectedStreamStorageLayer, FirestoreStreamSourceFilter } from "./firestore.projected-stream.storage-layer.mjs";
+import { FirestoreProjectedStreamReader } from "./firestore.projected-stream.reader.mjs";
+import { AlreadyEnqueuedError, ClaimerId, FirestoreProjector, FirestoreQueueStore, Task } from "./projection/firestore.projector.mjs";
+
+export { AlreadyEnqueuedError, ClaimerId, FirestoreEventLakeAggregateStore, FirestoreEventLakeStorageLayer, FirestoreEventLakeStore, FirestoreEventStreamAggregateStore, FirestoreEventStreamStorageLayer, FirestoreEventStreamStore, FirestoreLakeSourceFilter, FirestoreProjectedStreamReader, FirestoreProjectedStreamStorageLayer, FirestoreProjector, FirestoreQueueStore, FirestoreSnapshotter, FirestoreStreamSourceFilter, MakeFirestoreEventLakeAggregateStore, MakeFirestoreEventStreamAggregateStore, Task };

package/dist/projection/cases/attempts.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=attempts.spec.d.ts.map

package/dist/projection/cases/attempts.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempts.spec.d.ts","sourceRoot":"","sources":["../../../src/projection/cases/attempts.spec.ts"],"names":[],"mappings":""}

package/dist/projection/cases/batchlast.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=batchlast.spec.d.ts.map

package/dist/projection/cases/batchlast.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batchlast.spec.d.ts","sourceRoot":"","sources":["../../../src/projection/cases/batchlast.spec.ts"],"names":[],"mappings":""}

package/dist/projection/cases/bigshuffle.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bigshuffle.spec.d.ts.map