@ddd-ts/event-sourcing-firestore 0.0.0-compute-timeout-on-process.2 → 0.0.0-compute-timeout-on-process.4

package/dist/firestore.event-lake.aggregate-store.d.ts

@@ -0,0 +1,41 @@
+import * as _ddd_ts_store_firestore0 from "@ddd-ts/store-firestore";
+import { FirestoreStore, FirestoreTransaction, FirestoreTransactionPerformer } from "@ddd-ts/store-firestore";
+import * as _ddd_ts_core0 from "@ddd-ts/core";
+import { EventLakeStore, EventOf, EventSourced, IEventBus, IEventSourced, IIdentifiable, ISerializer, Identifiable, LakeId } from "@ddd-ts/core";
+import { CollectionReference } from "firebase-admin/firestore";
+import { HasTrait } from "@ddd-ts/traits";
+
+//#region src/firestore.event-lake.aggregate-store.d.ts
+declare const MakeFirestoreEventLakeAggregateStore: <A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>>(AGGREGATE: A) => abstract new (collection: CollectionReference, serializer: ISerializer<InstanceType<A>> & ISerializer<EventOf<InstanceType<A>>>, eventBus?: IEventBus) => {
+  getLakeId(instance: InstanceType<A>): LakeId;
+  transaction: FirestoreTransactionPerformer;
+  lakeStore: EventLakeStore<EventOf<InstanceType<A>>>;
+  save(aggregate: InstanceType<A>, trx?: FirestoreTransaction): Promise<void>;
+  defaultConverter: _ddd_ts_store_firestore0.DefaultConverter<FirebaseFirestore.DocumentData>;
+  readonly _collection: CollectionReference;
+  readonly serializer: ISerializer<InstanceType<A>, {}>;
+  readonly $name?: string | undefined;
+  readonly firestore: FirebaseFirestore.Firestore;
+  readonly collection: CollectionReference<_ddd_ts_core0.Serialized<S>, _ddd_ts_core0.Serialized<S>>;
+  executeQuery(query: FirebaseFirestore.Query<any>, trx?: FirestoreTransaction): Promise<InstanceType<A>[]>;
+  streamPages(query: FirebaseFirestore.Query<any>, pageSize: number): AsyncGenerator<FirebaseFirestore.QueryDocumentSnapshot<any, FirebaseFirestore.DocumentData>, void, unknown>;
+  streamQuery(query: FirebaseFirestore.Query<any>, pageSize?: number): AsyncIterable<InstanceType<A>>;
+  saveAll(models: InstanceType<A>[], trx?: FirestoreTransaction): Promise<void>;
+  load(id: InstanceType<A>["id"], trx?: FirestoreTransaction): Promise<InstanceType<A> | undefined>;
+  loadAll(transaction?: FirestoreTransaction): Promise<InstanceType<A>[]>;
+  delete(id: InstanceType<A>["id"], trx?: FirestoreTransaction): Promise<void>;
+  loadMany(ids: InstanceType<A>["id"][], trx?: FirestoreTransaction): Promise<InstanceType<A>[]>;
+  streamAll(pageSize?: number): AsyncIterable<InstanceType<A>>;
+  countAll(): Promise<number>;
+  count(query: FirebaseFirestore.Query<FirebaseFirestore.DocumentData>): Promise<number>;
+};
+declare abstract class FirestoreEventLakeAggregateStore<A extends IEventSourced & IIdentifiable> extends FirestoreStore<A> {
+  transaction: FirestoreTransactionPerformer;
+  lakeStore: EventLakeStore<EventOf<A>>;
+  constructor(collection: CollectionReference, serializer: ISerializer<EventOf<A>> & ISerializer<A>, eventBus?: IEventBus, $name?: string);
+  abstract getLakeId(instance: A): LakeId;
+  save(aggregate: A, trx?: FirestoreTransaction): Promise<void>;
+}
+//#endregion
+export { FirestoreEventLakeAggregateStore, MakeFirestoreEventLakeAggregateStore };
+//# sourceMappingURL=firestore.event-lake.aggregate-store.d.ts.map

package/dist/firestore.event-lake.aggregate-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-lake.aggregate-store.d.ts","names":[],"sources":["../src/firestore.event-lake.aggregate-store.ts"],"mappings":";;;;;;;;cAsBa,oCAAA,aACD,QAAA,QAAgB,YAAA,IAAgB,QAAA,QAAgB,YAAA,GAAa,SAAA,EAE5D,CAAA,mBAAC,UAAA,EAMI,mBAAA,EAAmB,UAAA,EACnB,WAAA,CAAY,YAAA,CAAa,CAAA,KACnC,WAAA,CAAY,OAAA,CAAQ,YAAA,CAAa,CAAA,KAAI,QAAA,GAC5B,SAAA;sBAKgB,YAAA,CAAa,CAAA,IAAK,MAAA;eASpC,6BAAA;;yCAsB2B,oBAAA,GAAoB,OAAA;;;;;;;sBAlCxD,iBAAA,CAAa,KAAA,OAAK,GAAA,GAAA,oBAAA,GAAA,OAAA,CAAA,YAAA,CAAA,CAAA;qBAelB,iBAAA,CAAmB,KAAA,OAAK,QAAA,WAAA,cAAA,CAAA,iBAAA,CAAA,qBAAA,MAAA,iBAAA,CAAA,YAAA;qBAuBL,iBAAA,CAAmB,KAAA,OAE5C,QAAA,YAAA,aAAA,CAAA,YAAA,CAAA,CAAA;;;;;;;;eAMu/E,iBAAA,CAAmB,KAAA,CAAK,iBAAA,CAAA,YAAA,IAAA,OAAA;AAAA;AAAA,uBArCz/E,gCAAA,WACV,aAAA,GAAgB,aAAA,UAClB,cAAA,CAAe,CAAA;EACvB,WAAA,EAAa,6BAAA;EACb,SAAA,EAAW,cAAA,CAAe,OAAA,CAAQ,CAAA;cAEhC,UAAA,EAAY,mBAAA,EACZ,UAAA,EAAY,WAAA,CAAY,OAAA,CAAQ,CAAA,KAAM,WAAA,CAAY,CAAA,GAClD,QAAA,GAAW,SAAA,EACX,KAAA;EAAA,SAcO,SAAA,CAAU,QAAA,EAAU,CAAA,GAAI,MAAA;EAElB,IAAA,CAAK,SAAA,EAAW,CAAA,EAAG,GAAA,GAAM,oBAAA,GAAoB,OAAA;AAAA"}

package/dist/firestore.event-lake.aggregate-store.js

@@ -0,0 +1,36 @@
+import { FirestoreEventLakeStorageLayer } from "./firestore.event-lake.storage-layer.js";
+import { FirestoreStore, FirestoreTransactionPerformer } from "@ddd-ts/store-firestore";
+import { EventLakeStore } from "@ddd-ts/core";
+
+//#region src/firestore.event-lake.aggregate-store.ts
+const MakeFirestoreEventLakeAggregateStore = (AGGREGATE) => {
+	class $FirestoreEventLakeAggregateStore extends FirestoreEventLakeAggregateStore {
+		constructor(collection, serializer, eventBus) {
+			super(collection, serializer, eventBus, AGGREGATE.name);
+		}
+	}
+	return $FirestoreEventLakeAggregateStore;
+};
+var FirestoreEventLakeAggregateStore = class extends FirestoreStore {
+	transaction;
+	lakeStore;
+	constructor(collection, serializer, eventBus, $name) {
+		super(collection, serializer, $name);
+		const storageLayer = new FirestoreEventLakeStorageLayer(collection.firestore);
+		this.transaction = new FirestoreTransactionPerformer(collection.firestore);
+		this.lakeStore = new EventLakeStore(storageLayer, serializer, eventBus);
+	}
+	async save(aggregate, trx) {
+		const changes = [...aggregate.changes];
+		await this.transaction.performWith(trx, async (trx) => {
+			const lakeId = this.getLakeId(aggregate);
+			await super.save(aggregate, trx);
+			await this.lakeStore.append(lakeId, changes, trx);
+			aggregate.clearChanges();
+		});
+	}
+};
+
+//#endregion
+export { FirestoreEventLakeAggregateStore, MakeFirestoreEventLakeAggregateStore };
+//# sourceMappingURL=firestore.event-lake.aggregate-store.js.map

package/dist/firestore.event-lake.aggregate-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-lake.aggregate-store.js","names":[],"sources":["../src/firestore.event-lake.aggregate-store.ts"],"sourcesContent":["import {\n  ISerializer,\n  IEventSourced,\n  IIdentifiable,\n  EventOf,\n  EventLakeStore,\n  LakeId,\n  IChange,\n  IEventBus,\n  EventSourced,\n  Identifiable,\n} from \"@ddd-ts/core\";\nimport {\n  FirestoreStore,\n  FirestoreTransaction,\n  FirestoreTransactionPerformer,\n} from \"@ddd-ts/store-firestore\";\n\nimport { CollectionReference } from \"firebase-admin/firestore\";\nimport { FirestoreEventLakeStorageLayer } from \"./firestore.event-lake.storage-layer\";\nimport { HasTrait } from \"@ddd-ts/traits\";\n\nexport const MakeFirestoreEventLakeAggregateStore = <\n  A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>,\n>(\n  AGGREGATE: A,\n) => {\n  abstract class $FirestoreEventLakeAggregateStore extends FirestoreEventLakeAggregateStore<\n    InstanceType<A>\n  > {\n    constructor(\n      collection: CollectionReference,\n      serializer: ISerializer<InstanceType<A>> &\n        ISerializer<EventOf<InstanceType<A>>>,\n      eventBus?: IEventBus,\n    ) {\n      super(collection, serializer, eventBus, AGGREGATE.name);\n    }\n\n    abstract getLakeId(instance: InstanceType<A>): LakeId;\n  }\n\n  return $FirestoreEventLakeAggregateStore;\n};\n\nexport abstract class FirestoreEventLakeAggregateStore<\n  A extends IEventSourced & IIdentifiable,\n> extends FirestoreStore<A> {\n  transaction: FirestoreTransactionPerformer;\n  lakeStore: EventLakeStore<EventOf<A>>;\n  constructor(\n    collection: CollectionReference,\n    serializer: ISerializer<EventOf<A>> & ISerializer<A>,\n    eventBus?: IEventBus,\n    $name?: string,\n  ) {\n    super(collection, serializer, $name);\n    const storageLayer = new FirestoreEventLakeStorageLayer(\n      collection.firestore,\n    );\n    this.transaction = new FirestoreTransactionPerformer(collection.firestore);\n    this.lakeStore = new EventLakeStore<EventOf<A>>(\n      storageLayer,\n      serializer,\n      eventBus,\n    );\n  }\n\n  abstract getLakeId(instance: A): LakeId;\n\n  override async save(aggregate: A, trx?: FirestoreTransaction) {\n    const changes = [...aggregate.changes] as IChange<EventOf<A>>[];\n\n    await this.transaction.performWith(trx, async (trx) => {\n      const lakeId = this.getLakeId(aggregate);\n\n      await super.save(aggregate, trx);\n      await this.lakeStore.append(lakeId, changes, trx);\n      aggregate.clearChanges();\n    });\n  }\n}\n"],"mappings":";;;;;AAsBA,MAAa,wCAGX,cACG;CACH,MAAe,0CAA0C,iCAEvD;EACA,YACE,YACA,YAEA,UACA;AACA,SAAM,YAAY,YAAY,UAAU,UAAU,KAAK;;;AAM3D,QAAO;;AAGT,IAAsB,mCAAtB,cAEU,eAAkB;CAC1B;CACA;CACA,YACE,YACA,YACA,UACA,OACA;AACA,QAAM,YAAY,YAAY,MAAM;EACpC,MAAM,eAAe,IAAI,+BACvB,WAAW,UACZ;AACD,OAAK,cAAc,IAAI,8BAA8B,WAAW,UAAU;AAC1E,OAAK,YAAY,IAAI,eACnB,cACA,YACA,SACD;;CAKH,MAAe,KAAK,WAAc,KAA4B;EAC5D,MAAM,UAAU,CAAC,GAAG,UAAU,QAAQ;AAEtC,QAAM,KAAK,YAAY,YAAY,KAAK,OAAO,QAAQ;GACrD,MAAM,SAAS,KAAK,UAAU,UAAU;AAExC,SAAM,MAAM,KAAK,WAAW,IAAI;AAChC,SAAM,KAAK,UAAU,OAAO,QAAQ,SAAS,IAAI;AACjD,aAAU,cAAc;IACxB"}

package/dist/firestore.event-lake.storage-layer.d.ts

@@ -0,0 +1,17 @@
+import { DefaultConverter, FirestoreTransaction } from "@ddd-ts/store-firestore";
+import * as fb from "firebase-admin";
+import { EventId, EventLakeStorageLayer, ISerializedChange, ISerializedFact, LakeId } from "@ddd-ts/core";
+import { ISerializedSavedChange as ISerializedSavedChange$1 } from "@ddd-ts/core/dist/interfaces/es-event";
+
+//#region src/firestore.event-lake.storage-layer.d.ts
+declare class FirestoreEventLakeStorageLayer implements EventLakeStorageLayer {
+  readonly firestore: fb.firestore.Firestore;
+  readonly converter: DefaultConverter<fb.firestore.DocumentData>;
+  constructor(firestore: fb.firestore.Firestore, converter?: DefaultConverter<fb.firestore.DocumentData>);
+  getCollection(lakeId: LakeId): fb.firestore.CollectionReference<fb.firestore.DocumentData, fb.firestore.DocumentData>;
+  append(lakeId: LakeId, changes: ISerializedChange[], trx: FirestoreTransaction): Promise<ISerializedSavedChange$1[]>;
+  read(lakeId: LakeId, startAfter?: EventId, endAt?: EventId): AsyncIterable<ISerializedFact>;
+}
+//#endregion
+export { FirestoreEventLakeStorageLayer };
+//# sourceMappingURL=firestore.event-lake.storage-layer.d.ts.map

package/dist/firestore.event-lake.storage-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-lake.storage-layer.d.ts","names":[],"sources":["../src/firestore.event-lake.storage-layer.ts"],"mappings":";;;;;;cAiBa,8BAAA,YAA0C,qBAAA;EAAA,SAEnC,SAAA,EAAW,EAAA,CAAG,SAAA,CAAU,SAAA;EAAA,SACxB,SAAA,EAAS,gBAAA,CAAA,EAAA,CAAA,SAAA,CAAA,YAAA;cADT,SAAA,EAAW,EAAA,CAAG,SAAA,CAAU,SAAA,EACxB,SAAA,GAAS,gBAAA,CAAA,EAAA,CAAA,SAAA,CAAA,YAAA;EAG3B,aAAA,CAAc,MAAA,EAAQ,MAAA,GAAM,EAAA,CAAA,SAAA,CAAA,mBAAA,CAAA,EAAA,CAAA,SAAA,CAAA,YAAA,EAAA,EAAA,CAAA,SAAA,CAAA,YAAA;EAStB,MAAA,CACJ,MAAA,EAAQ,MAAA,EACR,OAAA,EAAS,iBAAA,IACT,GAAA,EAAK,oBAAA,GAAoB,OAAA,CAAA,wBAAA;EA+BpB,IAAA,CACL,MAAA,EAAQ,MAAA,EACR,UAAA,GAAa,OAAA,EACb,KAAA,GAAQ,OAAA,GACP,aAAA,CAAc,eAAA;AAAA"}

package/dist/firestore.event-lake.storage-layer.js

@@ -0,0 +1,65 @@
+import { DefaultConverter } from "@ddd-ts/store-firestore";
+import * as fb from "firebase-admin";
+
+//#region src/firestore.event-lake.storage-layer.ts
+const serverTimestamp = fb.firestore.FieldValue.serverTimestamp;
+var FirestoreEventLakeStorageLayer = class {
+	constructor(firestore, converter = new DefaultConverter()) {
+		this.firestore = firestore;
+		this.converter = converter;
+	}
+	getCollection(lakeId) {
+		return this.firestore.collection("event-store").doc("Lakes").collection(lakeId.shardType).doc(lakeId.shardId).collection("events");
+	}
+	async append(lakeId, changes, trx) {
+		const collection = this.getCollection(lakeId);
+		const result = [];
+		for (const change of changes) {
+			const revision = trx.increment();
+			const storageChange = {
+				eventId: change.id,
+				name: change.name,
+				payload: change.payload,
+				occurredAt: serverTimestamp(),
+				version: change.version,
+				revision
+			};
+			const ref = collection.doc(change.id);
+			trx.transaction.create(ref, this.converter.toFirestore(storageChange));
+			result.push({
+				...change,
+				ref: ref.path,
+				revision,
+				occurredAt: void 0
+			});
+		}
+		return result;
+	}
+	async *read(lakeId, startAfter, endAt) {
+		const collection = this.getCollection(lakeId);
+		const [start, end] = await Promise.all([startAfter ? collection.doc(startAfter.serialize()).get() : null, endAt ? collection.doc(endAt.serialize()).get() : null]);
+		if (startAfter && !start?.exists) throw new Error(`StartAfter event not found: ${startAfter}`);
+		if (endAt && !end?.exists) throw new Error(`EndAt event not found: ${endAt}`);
+		let query = collection.orderBy("occurredAt", "asc").orderBy("revision", "asc");
+		if (start) query = query.startAfter(start);
+		if (endAt) query = query.endAt(end);
+		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 { FirestoreEventLakeStorageLayer };
+//# sourceMappingURL=firestore.event-lake.storage-layer.js.map

package/dist/firestore.event-lake.storage-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-lake.storage-layer.js","names":[],"sources":["../src/firestore.event-lake.storage-layer.ts"],"sourcesContent":["import {\n  LakeId,\n  EventId,\n  type ISerializedChange,\n  type ISerializedFact,\n  EventLakeStorageLayer,\n} from \"@ddd-ts/core\";\nimport { ISerializedSavedChange } from \"@ddd-ts/core/dist/interfaces/es-event\";\n\nimport {\n  DefaultConverter,\n  FirestoreTransaction,\n} from \"@ddd-ts/store-firestore\";\nimport * as fb from \"firebase-admin\";\n\nexport const serverTimestamp = fb.firestore.FieldValue.serverTimestamp;\n\nexport class FirestoreEventLakeStorageLayer implements EventLakeStorageLayer {\n  constructor(\n    public readonly firestore: fb.firestore.Firestore,\n    public readonly converter = new DefaultConverter(),\n  ) {}\n\n  getCollection(lakeId: LakeId) {\n    return this.firestore\n      .collection(\"event-store\")\n      .doc(\"Lakes\")\n      .collection(lakeId.shardType)\n      .doc(lakeId.shardId)\n      .collection(\"events\");\n  }\n\n  async append(\n    lakeId: LakeId,\n    changes: ISerializedChange[],\n    trx: FirestoreTransaction,\n  ) {\n    const collection = this.getCollection(lakeId);\n\n    const result: ISerializedSavedChange[] = [];\n\n    for (const change of changes) {\n      const revision = trx.increment();\n      const storageChange = {\n        eventId: change.id,\n        name: change.name,\n        payload: change.payload,\n        occurredAt: serverTimestamp(),\n        version: change.version,\n        revision,\n      };\n\n      const ref = collection.doc(change.id);\n      trx.transaction.create(ref, this.converter.toFirestore(storageChange));\n\n      result.push({\n        ...change,\n        ref: ref.path,\n        revision,\n        occurredAt: undefined,\n      });\n    }\n\n    return result;\n  }\n\n  async *read(\n    lakeId: LakeId,\n    startAfter?: EventId,\n    endAt?: EventId,\n  ): AsyncIterable<ISerializedFact> {\n    const collection = this.getCollection(lakeId);\n\n    const [start, end] = await Promise.all([\n      startAfter ? collection.doc(startAfter.serialize()).get() : null,\n      endAt ? collection.doc(endAt.serialize()).get() : null,\n    ]);\n\n    if (startAfter && !start?.exists) {\n      throw new Error(`StartAfter event not found: ${startAfter}`);\n    }\n\n    if (endAt && !end?.exists) {\n      throw new Error(`EndAt event not found: ${endAt}`);\n    }\n\n    let query = collection\n      .orderBy(\"occurredAt\", \"asc\")\n      .orderBy(\"revision\", \"asc\");\n\n    if (start) {\n      query = query.startAfter(start);\n    }\n\n    if (endAt) {\n      query = query.endAt(end);\n    }\n\n    for await (const event of query.stream()) {\n      const e = event as any as fb.firestore.QueryDocumentSnapshot<any>;\n      const data = this.converter.fromFirestore(e);\n      yield {\n        id: data.eventId,\n        ref: e.ref.path,\n        revision: data.revision,\n        name: data.name,\n        $name: data.name,\n        payload: data.payload,\n        occurredAt: data.occurredAt,\n        version: data.version ?? 1,\n      } as ISerializedFact;\n    }\n  }\n}\n"],"mappings":";;;;AAeA,MAAa,kBAAkB,GAAG,UAAU,WAAW;AAEvD,IAAa,iCAAb,MAA6E;CAC3E,YACE,AAAgB,WAChB,AAAgB,YAAY,IAAI,kBAAkB,EAClD;EAFgB;EACA;;CAGlB,cAAc,QAAgB;AAC5B,SAAO,KAAK,UACT,WAAW,cAAc,CACzB,IAAI,QAAQ,CACZ,WAAW,OAAO,UAAU,CAC5B,IAAI,OAAO,QAAQ,CACnB,WAAW,SAAS;;CAGzB,MAAM,OACJ,QACA,SACA,KACA;EACA,MAAM,aAAa,KAAK,cAAc,OAAO;EAE7C,MAAM,SAAmC,EAAE;AAE3C,OAAK,MAAM,UAAU,SAAS;GAC5B,MAAM,WAAW,IAAI,WAAW;GAChC,MAAM,gBAAgB;IACpB,SAAS,OAAO;IAChB,MAAM,OAAO;IACb,SAAS,OAAO;IAChB,YAAY,iBAAiB;IAC7B,SAAS,OAAO;IAChB;IACD;GAED,MAAM,MAAM,WAAW,IAAI,OAAO,GAAG;AACrC,OAAI,YAAY,OAAO,KAAK,KAAK,UAAU,YAAY,cAAc,CAAC;AAEtE,UAAO,KAAK;IACV,GAAG;IACH,KAAK,IAAI;IACT;IACA,YAAY;IACb,CAAC;;AAGJ,SAAO;;CAGT,OAAO,KACL,QACA,YACA,OACgC;EAChC,MAAM,aAAa,KAAK,cAAc,OAAO;EAE7C,MAAM,CAAC,OAAO,OAAO,MAAM,QAAQ,IAAI,CACrC,aAAa,WAAW,IAAI,WAAW,WAAW,CAAC,CAAC,KAAK,GAAG,MAC5D,QAAQ,WAAW,IAAI,MAAM,WAAW,CAAC,CAAC,KAAK,GAAG,KACnD,CAAC;AAEF,MAAI,cAAc,CAAC,OAAO,OACxB,OAAM,IAAI,MAAM,+BAA+B,aAAa;AAG9D,MAAI,SAAS,CAAC,KAAK,OACjB,OAAM,IAAI,MAAM,0BAA0B,QAAQ;EAGpD,IAAI,QAAQ,WACT,QAAQ,cAAc,MAAM,CAC5B,QAAQ,YAAY,MAAM;AAE7B,MAAI,MACF,SAAQ,MAAM,WAAW,MAAM;AAGjC,MAAI,MACF,SAAQ,MAAM,MAAM,IAAI;AAG1B,aAAW,MAAM,SAAS,MAAM,QAAQ,EAAE;GACxC,MAAM,IAAI;GACV,MAAM,OAAO,KAAK,UAAU,cAAc,EAAE;AAC5C,SAAM;IACJ,IAAI,KAAK;IACT,KAAK,EAAE,IAAI;IACX,UAAU,KAAK;IACf,MAAM,KAAK;IACX,OAAO,KAAK;IACZ,SAAS,KAAK;IACd,YAAY,KAAK;IACjB,SAAS,KAAK,WAAW;IAC1B"}

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

@@ -0,0 +1,10 @@
+import { EventLakeStore, IEsEvent, IEventBus, ISerializer } from "@ddd-ts/core";
+import { Firestore } from "firebase-admin/firestore";
+
+//#region src/firestore.event-lake.store.d.ts
+declare class FirestoreEventLakeStore<Event extends IEsEvent> extends EventLakeStore<Event> {
+  constructor(firestore: Firestore, serializer: ISerializer<Event>, eventBus?: IEventBus);
+}
+//#endregion
+export { FirestoreEventLakeStore };
+//# sourceMappingURL=firestore.event-lake.store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-lake.store.d.ts","names":[],"sources":["../src/firestore.event-lake.store.ts"],"mappings":";;;;cAIa,uBAAA,eACG,QAAA,UACN,cAAA,CAAe,KAAA;cAErB,SAAA,EAAW,SAAA,EACX,UAAA,EAAY,WAAA,CAAY,KAAA,GACxB,QAAA,GAAW,SAAA;AAAA"}

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

@@ -0,0 +1,13 @@
+import { FirestoreEventLakeStorageLayer } from "./firestore.event-lake.storage-layer.js";
+import { EventLakeStore } from "@ddd-ts/core";
+
+//#region src/firestore.event-lake.store.ts
+var FirestoreEventLakeStore = class extends EventLakeStore {
+	constructor(firestore, serializer, eventBus) {
+		super(new FirestoreEventLakeStorageLayer(firestore), serializer, eventBus);
+	}
+};
+
+//#endregion
+export { FirestoreEventLakeStore };
+//# sourceMappingURL=firestore.event-lake.store.js.map

package/dist/firestore.event-lake.store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-lake.store.js","names":[],"sources":["../src/firestore.event-lake.store.ts"],"sourcesContent":["import { EventLakeStore, IEsEvent, IEventBus, ISerializer } from \"@ddd-ts/core\";\nimport { FirestoreEventLakeStorageLayer } from \"./firestore.event-lake.storage-layer\";\nimport { Firestore } from \"firebase-admin/firestore\";\n\nexport class FirestoreEventLakeStore<\n  Event extends IEsEvent,\n> extends EventLakeStore<Event> {\n  constructor(\n    firestore: Firestore,\n    serializer: ISerializer<Event>,\n    eventBus?: IEventBus,\n  ) {\n    super(new FirestoreEventLakeStorageLayer(firestore), serializer, eventBus);\n  }\n}\n"],"mappings":";;;;AAIA,IAAa,0BAAb,cAEU,eAAsB;CAC9B,YACE,WACA,YACA,UACA;AACA,QAAM,IAAI,+BAA+B,UAAU,EAAE,YAAY,SAAS"}

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

@@ -0,0 +1,35 @@
+import { FirestoreSnapshotter } from "./firestore.snapshotter.js";
+import * as _ddd_ts_core0 from "@ddd-ts/core";
+import { EventOf, EventSourced, EventStreamAggregateStore, EventStreamStore, EventsOf, IEventBus, IEventSourced, IIdentifiable, ISerializer, Identifiable, StreamId } from "@ddd-ts/core";
+import { Firestore } from "firebase-admin/firestore";
+import { HasTrait } from "@ddd-ts/traits";
+
+//#region src/firestore.event-stream.aggregate-store.d.ts
+declare const MakeFirestoreEventStreamAggregateStore: <A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>>(AGGREGATE: A) => {
+  new (firestore: Firestore, serializer: ISerializer<InstanceType<A>> & ISerializer<EventOf<InstanceType<A>>>, eventBus?: IEventBus): {
+    loadFirst(event: EventsOf<A>[number]): InstanceType<A>;
+    getStreamId(id: InstanceType<A>["id"]): StreamId;
+    readonly firestore: Firestore;
+    readonly serializer: ISerializer<EventOf<InstanceType<A>>, {}>;
+    readonly snapshotter: FirestoreSnapshotter<InstanceType<A>>;
+    readonly eventBus?: IEventBus | undefined;
+    readonly streamStore: EventStreamStore<EventOf<InstanceType<A>>>;
+    readonly transaction: _ddd_ts_core0.TransactionPerformer;
+    loadFromSnapshot(snapshot: InstanceType<A>): Promise<InstanceType<A>>;
+    loadFromScratch(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
+    loadForce(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
+    load(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
+    saveAll(aggregates: InstanceType<A>[], parentTrx?: _ddd_ts_core0.Transaction, attempts?: number): Promise<void>;
+    save(aggregate: InstanceType<A>, trx?: _ddd_ts_core0.Transaction, attempts?: number): Promise<void>;
+  };
+};
+declare abstract class FirestoreEventStreamAggregateStore<A extends IEventSourced & IIdentifiable> extends EventStreamAggregateStore<A> {
+  readonly firestore: Firestore;
+  readonly serializer: ISerializer<EventOf<A>>;
+  readonly snapshotter: FirestoreSnapshotter<A>;
+  readonly eventBus?: IEventBus | undefined;
+  constructor(firestore: Firestore, serializer: ISerializer<EventOf<A>>, snapshotter: FirestoreSnapshotter<A>, eventBus?: IEventBus | undefined);
+}
+//#endregion
+export { FirestoreEventStreamAggregateStore, MakeFirestoreEventStreamAggregateStore };
+//# sourceMappingURL=firestore.event-stream.aggregate-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-stream.aggregate-store.d.ts","names":[],"sources":["../src/firestore.event-stream.aggregate-store.ts"],"mappings":";;;;;;;cAoBa,sCAAA,aACD,QAAA,QAAgB,YAAA,IAAgB,QAAA,QAAgB,YAAA,GAAa,SAAA,EAE5D,CAAA;EAAA,gBAMI,SAAA,EAAS,UAAA,EACR,WAAA,CAAY,YAAA,CAAa,CAAA,KACnC,WAAA,CAAY,OAAA,CAAQ,YAAA,CAAa,CAAA,KAAI,QAAA,GAC5B,SAAA;qBAUI,QAAA,CAAS,CAAA,YAAa,YAAA,CAAa,CAAA;oBAIpC,YAAA,CAAa,CAAA,UAAW,QAAA;IAAA,oBAUb,SAAA;IAAA;;wBAGA,SAAA;IAAA;;;;;;;;;;uBAPT,kCAAA,WACV,aAAA,GAAgB,aAAA,UAClB,yBAAA,CAA0B,CAAA;EAAA,SAEhB,SAAA,EAAW,SAAA;EAAA,SACX,UAAA,EAAY,WAAA,CAAY,OAAA,CAAQ,CAAA;EAAA,SAChC,WAAA,EAAa,oBAAA,CAAqB,CAAA;EAAA,SAClC,QAAA,GAAW,SAAA;cAHX,SAAA,EAAW,SAAA,EACX,UAAA,EAAY,WAAA,CAAY,OAAA,CAAQ,CAAA,IAChC,WAAA,EAAa,oBAAA,CAAqB,CAAA,GAClC,QAAA,GAAW,SAAA;AAAA"}

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

@@ -0,0 +1,36 @@
+import { FirestoreEventStreamStorageLayer } from "./firestore.event-stream.storage-layer.js";
+import { FirestoreSnapshotter } from "./firestore.snapshotter.js";
+import { FirestoreTransactionPerformer } from "@ddd-ts/store-firestore";
+import { EventStreamAggregateStore, EventStreamStore, StreamId } from "@ddd-ts/core";
+
+//#region src/firestore.event-stream.aggregate-store.ts
+const MakeFirestoreEventStreamAggregateStore = (AGGREGATE) => {
+	return class $FirestoreEventStreamAggregateStore extends FirestoreEventStreamAggregateStore {
+		constructor(firestore, serializer, eventBus) {
+			const snapshotter = new FirestoreSnapshotter(AGGREGATE.name, firestore, serializer);
+			super(firestore, serializer, snapshotter, eventBus);
+		}
+		loadFirst(event) {
+			return AGGREGATE.loadFirst(event);
+		}
+		getStreamId(id) {
+			return StreamId.from(AGGREGATE.name, id.serialize());
+		}
+	};
+};
+var FirestoreEventStreamAggregateStore = class extends EventStreamAggregateStore {
+	constructor(firestore, serializer, snapshotter, eventBus) {
+		const storageLayer = new FirestoreEventStreamStorageLayer(firestore);
+		const transaction = new FirestoreTransactionPerformer(firestore);
+		const streamStore = new EventStreamStore(storageLayer, serializer, eventBus);
+		super(streamStore, transaction, snapshotter);
+		this.firestore = firestore;
+		this.serializer = serializer;
+		this.snapshotter = snapshotter;
+		this.eventBus = eventBus;
+	}
+};
+
+//#endregion
+export { FirestoreEventStreamAggregateStore, MakeFirestoreEventStreamAggregateStore };
+//# sourceMappingURL=firestore.event-stream.aggregate-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-stream.aggregate-store.js","names":[],"sources":["../src/firestore.event-stream.aggregate-store.ts"],"sourcesContent":["import { HasTrait } from \"@ddd-ts/traits\";\nimport {\n  StreamId,\n  EventsOf,\n  EventSourced,\n  type Identifiable,\n  type IEventBus,\n  EventStreamStore,\n  EventStreamAggregateStore,\n  ISerializer,\n  IEventSourced,\n  IIdentifiable,\n  EventOf,\n} from \"@ddd-ts/core\";\nimport { FirestoreTransactionPerformer } from \"@ddd-ts/store-firestore\";\n\nimport { FirestoreSnapshotter } from \"./firestore.snapshotter\";\nimport { FirestoreEventStreamStorageLayer } from \"./firestore.event-stream.storage-layer\";\nimport { Firestore } from \"firebase-admin/firestore\";\n\nexport const MakeFirestoreEventStreamAggregateStore = <\n  A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>,\n>(\n  AGGREGATE: A,\n) => {\n  return class $FirestoreEventStreamAggregateStore extends FirestoreEventStreamAggregateStore<\n    InstanceType<A>\n  > {\n    constructor(\n      firestore: Firestore,\n      serializer: ISerializer<InstanceType<A>> &\n        ISerializer<EventOf<InstanceType<A>>>,\n      eventBus?: IEventBus,\n    ) {\n      const snapshotter = new FirestoreSnapshotter<InstanceType<A>>(\n        AGGREGATE.name,\n        firestore,\n        serializer,\n      );\n      super(firestore, serializer, snapshotter, eventBus);\n    }\n\n    loadFirst(event: EventsOf<A>[number]): InstanceType<A> {\n      return AGGREGATE.loadFirst(event);\n    }\n\n    getStreamId(id: InstanceType<A>[\"id\"]): StreamId {\n      return StreamId.from(AGGREGATE.name, id.serialize());\n    }\n  };\n};\n\nexport abstract class FirestoreEventStreamAggregateStore<\n  A extends IEventSourced & IIdentifiable,\n> extends EventStreamAggregateStore<A> {\n  constructor(\n    public readonly firestore: Firestore,\n    public readonly serializer: ISerializer<EventOf<A>>,\n    public readonly snapshotter: FirestoreSnapshotter<A>,\n    public readonly eventBus?: IEventBus,\n  ) {\n    const storageLayer = new FirestoreEventStreamStorageLayer(firestore);\n    const transaction = new FirestoreTransactionPerformer(firestore);\n    const streamStore = new EventStreamStore<EventOf<A>>(\n      storageLayer,\n      serializer,\n      eventBus,\n    );\n    super(streamStore, transaction, snapshotter);\n  }\n}\n"],"mappings":";;;;;;AAoBA,MAAa,0CAGX,cACG;AACH,QAAO,MAAM,4CAA4C,mCAEvD;EACA,YACE,WACA,YAEA,UACA;GACA,MAAM,cAAc,IAAI,qBACtB,UAAU,MACV,WACA,WACD;AACD,SAAM,WAAW,YAAY,aAAa,SAAS;;EAGrD,UAAU,OAA6C;AACrD,UAAO,UAAU,UAAU,MAAM;;EAGnC,YAAY,IAAqC;AAC/C,UAAO,SAAS,KAAK,UAAU,MAAM,GAAG,WAAW,CAAC;;;;AAK1D,IAAsB,qCAAtB,cAEU,0BAA6B;CACrC,YACE,AAAgB,WAChB,AAAgB,YAChB,AAAgB,aAChB,AAAgB,UAChB;EACA,MAAM,eAAe,IAAI,iCAAiC,UAAU;EACpE,MAAM,cAAc,IAAI,8BAA8B,UAAU;EAChE,MAAM,cAAc,IAAI,iBACtB,cACA,YACA,SACD;AACD,QAAM,aAAa,aAAa,YAAY;EAZ5B;EACA;EACA;EACA"}

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

@@ -0,0 +1,18 @@
+import { DefaultConverter, FirestoreTransaction } from "@ddd-ts/store-firestore";
+import * as fb from "firebase-admin";
+import { EventStreamStorageLayer, ISerializedChange, ISerializedFact, StreamId } from "@ddd-ts/core";
+import { ISerializedSavedChange as ISerializedSavedChange$1 } from "@ddd-ts/core/dist/interfaces/es-event";
+
+//#region src/firestore.event-stream.storage-layer.d.ts
+declare class FirestoreEventStreamStorageLayer implements EventStreamStorageLayer {
+  readonly firestore: fb.firestore.Firestore;
+  readonly converter: DefaultConverter<fb.firestore.DocumentData>;
+  constructor(firestore: fb.firestore.Firestore, converter?: DefaultConverter<fb.firestore.DocumentData>);
+  isLocalRevisionOutdatedError(error: unknown): boolean;
+  getCollection(streamId: StreamId): fb.firestore.CollectionReference<fb.firestore.DocumentData, fb.firestore.DocumentData>;
+  append(streamId: StreamId, changes: ISerializedChange[], expectedRevision: number, trx: FirestoreTransaction): Promise<ISerializedSavedChange$1[]>;
+  read(streamId: StreamId, startAt?: number): AsyncIterable<ISerializedFact>;
+}
+//#endregion
+export { FirestoreEventStreamStorageLayer };
+//# sourceMappingURL=firestore.event-stream.storage-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-stream.storage-layer.d.ts","names":[],"sources":["../src/firestore.event-stream.storage-layer.ts"],"mappings":";;;;;;cAgBa,gCAAA,YACA,uBAAA;EAAA,SAGO,SAAA,EAAW,EAAA,CAAG,SAAA,CAAU,SAAA;EAAA,SACxB,SAAA,EAAS,gBAAA,CAAA,EAAA,CAAA,SAAA,CAAA,YAAA;cADT,SAAA,EAAW,EAAA,CAAG,SAAA,CAAU,SAAA,EACxB,SAAA,GAAS,gBAAA,CAAA,EAAA,CAAA,SAAA,CAAA,YAAA;EAG3B,4BAAA,CAA6B,KAAA;EAS7B,aAAA,CAAc,QAAA,EAAU,QAAA,GAAQ,EAAA,CAAA,SAAA,CAAA,mBAAA,CAAA,EAAA,CAAA,SAAA,CAAA,YAAA,EAAA,EAAA,CAAA,SAAA,CAAA,YAAA;EAS1B,MAAA,CACJ,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,iBAAA,IACT,gBAAA,UACA,GAAA,EAAK,oBAAA,GAAoB,OAAA,CAAA,wBAAA;EAkCpB,IAAA,CACL,QAAA,EAAU,QAAA,EACV,OAAA,YACC,aAAA,CAAc,eAAA;AAAA"}

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

@@ -0,0 +1,65 @@
+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 };
+//# sourceMappingURL=firestore.event-stream.storage-layer.js.map

package/dist/firestore.event-stream.storage-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-stream.storage-layer.js","names":[],"sources":["../src/firestore.event-stream.storage-layer.ts"],"sourcesContent":["import {\n  StreamId,\n  type ISerializedChange,\n  type ISerializedFact,\n  EventStreamStorageLayer,\n} from \"@ddd-ts/core\";\nimport { ISerializedSavedChange } from \"@ddd-ts/core/dist/interfaces/es-event\";\n\nimport {\n  DefaultConverter,\n  FirestoreTransaction,\n} from \"@ddd-ts/store-firestore\";\nimport * as fb from \"firebase-admin\";\n\nexport const serverTimestamp = fb.firestore.FieldValue.serverTimestamp;\n\nexport class FirestoreEventStreamStorageLayer\n  implements EventStreamStorageLayer\n{\n  constructor(\n    public readonly firestore: fb.firestore.Firestore,\n    public readonly converter = new DefaultConverter(),\n  ) {}\n\n  isLocalRevisionOutdatedError(error: unknown): boolean {\n    return (\n      typeof error === \"object\" &&\n      error !== null &&\n      \"code\" in error &&\n      error.code === 6\n    );\n  }\n\n  getCollection(streamId: StreamId) {\n    return this.firestore\n      .collection(\"event-store\")\n      .doc(streamId.aggregateType)\n      .collection(\"streams\")\n      .doc(streamId.aggregateId)\n      .collection(\"events\");\n  }\n\n  async append(\n    streamId: StreamId,\n    changes: ISerializedChange[],\n    expectedRevision: number,\n    trx: FirestoreTransaction,\n  ) {\n    const collection = this.getCollection(streamId);\n    const result: ISerializedSavedChange[] = [];\n\n    let revision = expectedRevision + 1;\n    for (const change of changes) {\n      const storageChange = {\n        aggregateType: streamId.aggregateType,\n        eventId: change.id,\n        aggregateId: streamId.aggregateId,\n        revision: revision,\n        name: change.name,\n        payload: change.payload,\n        occurredAt: serverTimestamp(),\n        version: change.version,\n      };\n\n      const ref = collection.doc(`${revision}`);\n\n      result.push({\n        ...change,\n        ref: ref.path,\n        revision: revision,\n        occurredAt: undefined,\n      });\n\n      trx.transaction.create(ref, this.converter.toFirestore(storageChange));\n      revision++;\n    }\n\n    return result;\n  }\n\n  async *read(\n    streamId: StreamId,\n    startAt?: number,\n  ): AsyncIterable<ISerializedFact> {\n    const collection = this.getCollection(streamId);\n\n    const query = collection\n      .where(\"revision\", \">=\", startAt || 0)\n      .orderBy(\"revision\", \"asc\");\n\n    for await (const event of query.stream()) {\n      const e = event as any as fb.firestore.QueryDocumentSnapshot<any>;\n      const data = this.converter.fromFirestore(e);\n      yield {\n        id: data.eventId,\n        ref: e.ref.path,\n        revision: data.revision,\n        name: data.name,\n        $name: data.name,\n        payload: data.payload,\n        occurredAt: data.occurredAt,\n        version: data.version ?? 1,\n      };\n    }\n  }\n}\n"],"mappings":";;;;AAcA,MAAa,kBAAkB,GAAG,UAAU,WAAW;AAEvD,IAAa,mCAAb,MAEA;CACE,YACE,AAAgB,WAChB,AAAgB,YAAY,IAAI,kBAAkB,EAClD;EAFgB;EACA;;CAGlB,6BAA6B,OAAyB;AACpD,SACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,MAAM,SAAS;;CAInB,cAAc,UAAoB;AAChC,SAAO,KAAK,UACT,WAAW,cAAc,CACzB,IAAI,SAAS,cAAc,CAC3B,WAAW,UAAU,CACrB,IAAI,SAAS,YAAY,CACzB,WAAW,SAAS;;CAGzB,MAAM,OACJ,UACA,SACA,kBACA,KACA;EACA,MAAM,aAAa,KAAK,cAAc,SAAS;EAC/C,MAAM,SAAmC,EAAE;EAE3C,IAAI,WAAW,mBAAmB;AAClC,OAAK,MAAM,UAAU,SAAS;GAC5B,MAAM,gBAAgB;IACpB,eAAe,SAAS;IACxB,SAAS,OAAO;IAChB,aAAa,SAAS;IACZ;IACV,MAAM,OAAO;IACb,SAAS,OAAO;IAChB,YAAY,iBAAiB;IAC7B,SAAS,OAAO;IACjB;GAED,MAAM,MAAM,WAAW,IAAI,GAAG,WAAW;AAEzC,UAAO,KAAK;IACV,GAAG;IACH,KAAK,IAAI;IACC;IACV,YAAY;IACb,CAAC;AAEF,OAAI,YAAY,OAAO,KAAK,KAAK,UAAU,YAAY,cAAc,CAAC;AACtE;;AAGF,SAAO;;CAGT,OAAO,KACL,UACA,SACgC;EAGhC,MAAM,QAFa,KAAK,cAAc,SAAS,CAG5C,MAAM,YAAY,MAAM,WAAW,EAAE,CACrC,QAAQ,YAAY,MAAM;AAE7B,aAAW,MAAM,SAAS,MAAM,QAAQ,EAAE;GACxC,MAAM,IAAI;GACV,MAAM,OAAO,KAAK,UAAU,cAAc,EAAE;AAC5C,SAAM;IACJ,IAAI,KAAK;IACT,KAAK,EAAE,IAAI;IACX,UAAU,KAAK;IACf,MAAM,KAAK;IACX,OAAO,KAAK;IACZ,SAAS,KAAK;IACd,YAAY,KAAK;IACjB,SAAS,KAAK,WAAW;IAC1B"}

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

@@ -0,0 +1,10 @@
+import { EventStreamStore, IEsEvent, IEventBus, ISerializer } from "@ddd-ts/core";
+import { Firestore } from "firebase-admin/firestore";
+
+//#region src/firestore.event-stream.store.d.ts
+declare class FirestoreEventStreamStore<Event extends IEsEvent> extends EventStreamStore<Event> {
+  constructor(firestore: Firestore, serializer: ISerializer<Event>, eventBus?: IEventBus);
+}
+//#endregion
+export { FirestoreEventStreamStore };
+//# 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","names":[],"sources":["../src/firestore.event-stream.store.ts"],"mappings":";;;;cASa,yBAAA,eACG,QAAA,UACN,gBAAA,CAAiB,KAAA;cAEvB,SAAA,EAAW,SAAA,EACX,UAAA,EAAY,WAAA,CAAY,KAAA,GACxB,QAAA,GAAW,SAAA;AAAA"}

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

@@ -0,0 +1,13 @@
+import { FirestoreEventStreamStorageLayer } from "./firestore.event-stream.storage-layer.js";
+import { EventStreamStore } from "@ddd-ts/core";
+
+//#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 };
+//# sourceMappingURL=firestore.event-stream.store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.event-stream.store.js","names":[],"sources":["../src/firestore.event-stream.store.ts"],"sourcesContent":["import {\n  EventStreamStore,\n  IEsEvent,\n  IEventBus,\n  ISerializer,\n} from \"@ddd-ts/core\";\nimport { FirestoreEventStreamStorageLayer } from \"./firestore.event-stream.storage-layer\";\nimport { Firestore } from \"firebase-admin/firestore\";\n\nexport class FirestoreEventStreamStore<\n  Event extends IEsEvent,\n> extends EventStreamStore<Event> {\n  constructor(\n    firestore: Firestore,\n    serializer: ISerializer<Event>,\n    eventBus?: IEventBus,\n  ) {\n    super(\n      new FirestoreEventStreamStorageLayer(firestore),\n      serializer,\n      eventBus,\n    );\n  }\n}\n"],"mappings":";;;;AASA,IAAa,4BAAb,cAEU,iBAAwB;CAChC,YACE,WACA,YACA,UACA;AACA,QACE,IAAI,iCAAiC,UAAU,EAC/C,YACA,SACD"}

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

@@ -0,0 +1,17 @@
+import { FirestoreProjectedStreamStorageLayer } from "./firestore.projected-stream.storage-layer.js";
+import { Cursor, IEsEvent, IFact, ISavedChange, ISerializer, ProjectedStream, ProjectedStreamReader } from "@ddd-ts/core";
+import { Firestore } from "firebase-admin/firestore";
+
+//#region src/firestore.projected-stream.reader.d.ts
+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>;
+}
+//#endregion
+export { FirestoreProjectedStreamReader };
+//# 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","names":[],"sources":["../src/firestore.projected-stream.reader.ts"],"mappings":";;;;;cAaa,8BAAA,eACG,QAAA,UACN,qBAAA,CAAsB,KAAA;EAC9B,OAAA,EAAS,oCAAA;EACT,UAAA,EAAY,WAAA,CAAY,KAAA;cACZ,SAAA,EAAW,SAAA,EAAW,UAAA,EAAY,WAAA,CAAY,KAAA;EAOpD,SAAA,CAAU,WAAA,EAAa,YAAA,CAAa,KAAA,IAAM,OAAA,CAAA,MAAA;EAK1C,GAAA,CAAI,MAAA,EAAQ,MAAA,GAAM,OAAA,CAAA,KAAA,CAAA,KAAA;EAUlB,KAAA,CACJ,eAAA,EAAiB,eAAA,EACjB,KAAA,UACA,UAAA,GAAa,MAAA,EACb,KAAA,GAAQ,MAAA,EACR,KAAA,YAAc,OAAA;EAcT,IAAA,CACL,eAAA,EAAiB,eAAA,EACjB,KAAA,UACA,UAAA,GAAa,MAAA,EACb,KAAA,GAAQ,MAAA,GAAM,cAAA,CAAA,KAAA,CAAA,KAAA;AAAA"}

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

@@ -0,0 +1,34 @@
+import { FirestoreProjectedStreamStorageLayer } from "./firestore.projected-stream.storage-layer.js";
+import { ProjectedStreamReader } from "@ddd-ts/core";
+
+//#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 };
+//# sourceMappingURL=firestore.projected-stream.reader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.projected-stream.reader.js","names":[],"sources":["../src/firestore.projected-stream.reader.ts"],"sourcesContent":["import {\n  Cursor,\n  IEsEvent,\n  IFact,\n  ISavedChange,\n  ISerializedSavedChange,\n  ISerializer,\n  ProjectedStream,\n  ProjectedStreamReader,\n} from \"@ddd-ts/core\";\nimport { Firestore } from \"firebase-admin/firestore\";\nimport { FirestoreProjectedStreamStorageLayer } from \"./firestore.projected-stream.storage-layer\";\n\nexport class FirestoreProjectedStreamReader<\n  Event extends IEsEvent,\n> extends ProjectedStreamReader<Event> {\n  storage: FirestoreProjectedStreamStorageLayer;\n  serializer: ISerializer<Event>;\n  constructor(firestore: Firestore, serializer: ISerializer<Event>) {\n    const storage = new FirestoreProjectedStreamStorageLayer(firestore);\n    super(storage, serializer);\n    this.storage = storage;\n    this.serializer = serializer;\n  }\n\n  async getCursor(savedChange: ISavedChange<Event>) {\n    const serialized = await this.serializer.serialize(savedChange);\n    return this.storage.getCursor(serialized as ISerializedSavedChange);\n  }\n\n  async get(cursor: Cursor) {\n    const serialized = await this.storage.get(cursor);\n    if (!serialized) {\n      return undefined;\n    }\n    return this.serializer.deserialize(serialized) as unknown as Promise<\n      IFact<Event>\n    >;\n  }\n\n  async slice(\n    projectedStream: ProjectedStream,\n    shard: string,\n    startAfter?: Cursor,\n    endAt?: Cursor,\n    limit?: number,\n  ) {\n    const serialized = await this.storage.slice(\n      projectedStream,\n      shard,\n      startAfter,\n      endAt,\n      limit,\n    );\n    return Promise.all(\n      serialized.map((s) => this.serializer.deserialize(s)),\n    ) as any;\n  }\n\n  async *read(\n    projectedStream: ProjectedStream,\n    shard: string,\n    startAfter?: Cursor,\n    endAt?: Cursor,\n  ) {\n    for await (const serialized of this.storage.read(\n      projectedStream,\n      shard,\n      startAfter,\n      endAt,\n    )) {\n      yield this.serializer.deserialize(serialized) as unknown as IFact<Event>;\n    }\n  }\n}\n"],"mappings":";;;;AAaA,IAAa,iCAAb,cAEU,sBAA6B;CACrC;CACA;CACA,YAAY,WAAsB,YAAgC;EAChE,MAAM,UAAU,IAAI,qCAAqC,UAAU;AACnE,QAAM,SAAS,WAAW;AAC1B,OAAK,UAAU;AACf,OAAK,aAAa;;CAGpB,MAAM,UAAU,aAAkC;EAChD,MAAM,aAAa,MAAM,KAAK,WAAW,UAAU,YAAY;AAC/D,SAAO,KAAK,QAAQ,UAAU,WAAqC;;CAGrE,MAAM,IAAI,QAAgB;EACxB,MAAM,aAAa,MAAM,KAAK,QAAQ,IAAI,OAAO;AACjD,MAAI,CAAC,WACH;AAEF,SAAO,KAAK,WAAW,YAAY,WAAW;;CAKhD,MAAM,MACJ,iBACA,OACA,YACA,OACA,OACA;EACA,MAAM,aAAa,MAAM,KAAK,QAAQ,MACpC,iBACA,OACA,YACA,OACA,MACD;AACD,SAAO,QAAQ,IACb,WAAW,KAAK,MAAM,KAAK,WAAW,YAAY,EAAE,CAAC,CACtD;;CAGH,OAAO,KACL,iBACA,OACA,YACA,OACA;AACA,aAAW,MAAM,cAAc,KAAK,QAAQ,KAC1C,iBACA,OACA,YACA,MACD,CACC,OAAM,KAAK,WAAW,YAAY,WAAW"}

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

@@ -0,0 +1,35 @@
+import { DefaultConverter } from "@ddd-ts/store-firestore";
+import { ISerializedFact, ISerializedSavedChange, LakeSource, ProjectedStream, ProjectedStreamStorageLayer, StreamSource } from "@ddd-ts/core";
+import { Filter, Firestore, Timestamp } from "firebase-admin/firestore";
+import { Cursor as Cursor$1 } from "@ddd-ts/core/dist/components/cursor";
+import { MicrosecondTimestamp } from "@ddd-ts/shape";
+
+//#region src/firestore.projected-stream.storage-layer.d.ts
+declare class FirestoreLakeSourceFilter {
+  filter(shard: string, lakeSource: LakeSource): Filter;
+}
+declare class FirestoreStreamSourceFilter {
+  filter(shard: string, streamSource: StreamSource): Filter;
+}
+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$1, endAt?: Cursor$1): 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$1): Promise<ISerializedFact | undefined>;
+  getCursor(savedChange: ISerializedSavedChange): Promise<Cursor$1 | undefined>;
+  slice(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor$1, endAt?: Cursor$1, limit?: number): Promise<ISerializedFact[]>;
+}
+//#endregion
+export { FirestoreLakeSourceFilter, FirestoreProjectedStreamStorageLayer, FirestoreStreamSourceFilter };
+//# 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","names":[],"sources":["../src/firestore.projected-stream.storage-layer.ts"],"mappings":";;;;;;;cAkBa,yBAAA;EACX,MAAA,CAAO,KAAA,UAAe,UAAA,EAAY,UAAA,GAAU,MAAA;AAAA;AAAA,cAQjC,2BAAA;EACX,MAAA,CAAO,KAAA,UAAe,YAAA,EAAc,YAAA,GAAY,MAAA;AAAA;AAAA,cASrC,oCAAA,YACA,2BAAA;EAAA,iBAGQ,SAAA;EAAA,SACD,SAAA,EAAS,gBAAA,CAAA,iBAAA,CAAA,YAAA;cADR,SAAA,EAAW,SAAA,EACZ,SAAA,GAAS,gBAAA,CAAA,iBAAA,CAAA,YAAA;EAGpB,IAAA,CACL,eAAA,EAAiB,eAAA,EACjB,KAAA,UACA,UAAA,GAAa,QAAA,EACb,KAAA,GAAQ,QAAA,GAAM,cAAA;;;;;;;;;;EA2CT,sBAAA,CAAuB,YAAA,EAAc,oBAAA,GAAoB,SAAA;EAM1D,GAAA,CAAI,MAAA,EAAQ,QAAA,GAAM,OAAA,CAAA,eAAA;EAkBlB,SAAA,CACJ,WAAA,EAAa,sBAAA,GACZ,OAAA,CAAQ,QAAA;EAcL,KAAA,CACJ,eAAA,EAAiB,eAAA,EACjB,KAAA,UACA,UAAA,GAAa,QAAA,EACb,KAAA,GAAQ,QAAA,EACR,KAAA,YAAc,OAAA,CAAA,eAAA;AAAA"}