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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Aetherall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/in-memory.event-lake.aggregate-store.d.ts

@@ -0,0 +1,37 @@
+import { LakeId, type IEventBus, EventLakeStore, type EventOf, type ISerializer, type IEventSourced, type IIdentifiable, EventSourced, Identifiable } from "@ddd-ts/core";
+import { InMemoryDatabase, InMemoryStore, InMemoryTransaction, InMemoryTransactionPerformer } from "@ddd-ts/store-inmemory";
+import type { HasTrait } from "@ddd-ts/traits";
+export declare const MakeInMemoryEventLakeAggregateStore: <A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>>(AGGREGATE: A) => abstract new (database: InMemoryDatabase, collection: string, serializer: ISerializer<InstanceType<A>> & ISerializer<EventOf<InstanceType<A>>>, eventBus?: IEventBus) => {
+    readonly database: InMemoryDatabase;
+    readonly collection: string;
+    getLakeId(instance: InstanceType<A>): LakeId;
+    transaction: InMemoryTransactionPerformer;
+    lakeStore: EventLakeStore<EventOf<InstanceType<A>>>;
+    readonly serializer: ISerializer<EventOf<InstanceType<A>>, {}> & ISerializer<InstanceType<A>, {}>;
+    readonly eventBus?: IEventBus | undefined;
+    readonly $name?: string | undefined;
+    save(aggregate: InstanceType<A>, trx?: InMemoryTransaction): Promise<void>;
+    filter(predicate: (model: InstanceType<A>) => boolean, trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
+    clear(): void;
+    create(model: InstanceType<A>, trx?: InMemoryTransaction): Promise<void>;
+    saveAll(models: InstanceType<A>[], trx?: InMemoryTransaction): Promise<void>;
+    load(id: InstanceType<A>["id"], trx?: InMemoryTransaction): Promise<InstanceType<A> | undefined>;
+    loadAll(trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
+    loadMany(ids: InstanceType<A>["id"][], trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
+    delete(id: InstanceType<A>["id"], trx?: InMemoryTransaction): Promise<void>;
+    countAll(): Promise<number>;
+    streamAll(): AsyncIterable<InstanceType<A>>;
+};
+export declare abstract class InMemoryEventLakeAggregateStore<A extends IEventSourced & IIdentifiable> extends InMemoryStore<A> {
+    readonly database: InMemoryDatabase;
+    readonly collection: string;
+    readonly serializer: ISerializer<EventOf<A>> & ISerializer<A>;
+    readonly eventBus?: IEventBus | undefined;
+    readonly $name?: string | undefined;
+    transaction: InMemoryTransactionPerformer;
+    lakeStore: EventLakeStore<EventOf<A>>;
+    constructor(database: InMemoryDatabase, collection: string, serializer: ISerializer<EventOf<A>> & ISerializer<A>, eventBus?: IEventBus | undefined, $name?: string | undefined);
+    abstract getLakeId(instance: A): LakeId;
+    save(aggregate: A, trx?: InMemoryTransaction): Promise<void>;
+}
+//# sourceMappingURL=in-memory.event-lake.aggregate-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.aggregate-store.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.aggregate-store.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,KAAK,SAAS,EACd,cAAc,EACd,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,aAAa,EAElB,YAAY,EACZ,YAAY,EACb,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EACnB,4BAA4B,EAC7B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,eAAO,MAAM,mCAAmC,GAC9C,CAAC,SAAS,QAAQ,CAAC,OAAO,YAAY,CAAC,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,aAE5D,CAAC,6BAMkB,gBAAgB,cACd,MAAM,cACtB,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GACtC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,aAC5B,SAAS;uBAJM,gBAAgB;yBACd,MAAM;wBAQP,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM;iBAS1C,4BAA4B;;;wBAMZ,SAAS;qBACZ,MAAM;2CAcQ,mBAAmB;;;;;;;;;;;CA1B5D,CAAC;AAEF,8BAAsB,+BAA+B,CACnD,CAAC,SAAS,aAAa,GAAG,aAAa,CACvC,SAAQ,aAAa,CAAC,CAAC,CAAC;aAIN,QAAQ,EAAE,gBAAgB;aAC1B,UAAU,EAAE,MAAM;aAClB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;aACpD,QAAQ,CAAC,EAAE,SAAS;aACpB,KAAK,CAAC,EAAE,MAAM;IAPhC,WAAW,EAAE,4BAA4B,CAAC;IAC1C,SAAS,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;gBAEpB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EACpD,QAAQ,CAAC,EAAE,SAAS,YAAA,EACpB,KAAK,CAAC,EAAE,MAAM,YAAA;IAYhC,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,GAAG,MAAM;IAExB,IAAI,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,mBAAmB;CAW5D"}

package/dist/in-memory.event-lake.aggregate-store.js

@@ -0,0 +1,43 @@
+const require_in_memory_event_lake_storage_layer = require('./in-memory.event-lake.storage-layer.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
+
+//#region src/in-memory.event-lake.aggregate-store.ts
+const MakeInMemoryEventLakeAggregateStore = (AGGREGATE) => {
+	class $InMemoryEventLakeAggregateStore extends InMemoryEventLakeAggregateStore {
+		constructor(database, collection, serializer, eventBus) {
+			super(database, collection, serializer, eventBus, AGGREGATE.name);
+			this.database = database;
+			this.collection = collection;
+		}
+	}
+	return $InMemoryEventLakeAggregateStore;
+};
+var InMemoryEventLakeAggregateStore = class extends _ddd_ts_store_inmemory.InMemoryStore {
+	transaction;
+	lakeStore;
+	constructor(database, collection, serializer, eventBus, $name) {
+		const storageLayer = new require_in_memory_event_lake_storage_layer.InMemoryEventLakeStorageLayer(database);
+		super(collection, database, serializer, $name);
+		this.database = database;
+		this.collection = collection;
+		this.serializer = serializer;
+		this.eventBus = eventBus;
+		this.$name = $name;
+		this.lakeStore = new _ddd_ts_core.EventLakeStore(storageLayer, serializer, eventBus);
+		this.transaction = new _ddd_ts_store_inmemory.InMemoryTransactionPerformer(database);
+	}
+	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
+exports.InMemoryEventLakeAggregateStore = InMemoryEventLakeAggregateStore;
+exports.MakeInMemoryEventLakeAggregateStore = MakeInMemoryEventLakeAggregateStore;

package/dist/in-memory.event-lake.aggregate-store.mjs

@@ -0,0 +1,42 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.mjs";
+import { EventLakeStore, LakeId } from "@ddd-ts/core";
+import { InMemoryStore, InMemoryTransactionPerformer } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.event-lake.aggregate-store.ts
+const MakeInMemoryEventLakeAggregateStore = (AGGREGATE) => {
+	class $InMemoryEventLakeAggregateStore extends InMemoryEventLakeAggregateStore {
+		constructor(database, collection, serializer, eventBus) {
+			super(database, collection, serializer, eventBus, AGGREGATE.name);
+			this.database = database;
+			this.collection = collection;
+		}
+	}
+	return $InMemoryEventLakeAggregateStore;
+};
+var InMemoryEventLakeAggregateStore = class extends InMemoryStore {
+	transaction;
+	lakeStore;
+	constructor(database, collection, serializer, eventBus, $name) {
+		const storageLayer = new InMemoryEventLakeStorageLayer(database);
+		super(collection, database, serializer, $name);
+		this.database = database;
+		this.collection = collection;
+		this.serializer = serializer;
+		this.eventBus = eventBus;
+		this.$name = $name;
+		this.lakeStore = new EventLakeStore(storageLayer, serializer, eventBus);
+		this.transaction = new InMemoryTransactionPerformer(database);
+	}
+	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 { InMemoryEventLakeAggregateStore, MakeInMemoryEventLakeAggregateStore };

package/dist/in-memory.event-lake.aggregate-store.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=in-memory.event-lake.aggregate-store.spec.d.ts.map

package/dist/in-memory.event-lake.aggregate-store.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.aggregate-store.spec.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.aggregate-store.spec.ts"],"names":[],"mappings":""}

package/dist/in-memory.event-lake.storage-layer.d.ts

@@ -0,0 +1,10 @@
+import { LakeId, type ISerializedChange, type ISerializedFact, type EventLakeStorageLayer, EventId } from "@ddd-ts/core";
+import type { ISerializedSavedChange } from "@ddd-ts/core/dist/interfaces/es-event";
+import { InMemoryDatabase, InMemoryTransaction } from "@ddd-ts/store-inmemory";
+export declare class InMemoryEventLakeStorageLayer implements EventLakeStorageLayer {
+    readonly database: InMemoryDatabase;
+    constructor(database: InMemoryDatabase);
+    append(lakeId: LakeId, changes: ISerializedChange[], trx: InMemoryTransaction): Promise<ISerializedSavedChange[]>;
+    read(lakeId: LakeId, startAfter?: EventId, endAt?: EventId): AsyncIterable<ISerializedFact>;
+}
+//# sourceMappingURL=in-memory.event-lake.storage-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.storage-layer.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.storage-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,OAAO,EACR,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE/E,qBAAa,6BAA8B,YAAW,qBAAqB;aAC7C,QAAQ,EAAE,gBAAgB;gBAA1B,QAAQ,EAAE,gBAAgB;IAEhD,MAAM,CACV,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAAE,EAC5B,GAAG,EAAE,mBAAmB;IA+BnB,IAAI,CACT,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,OAAO,EACpB,KAAK,CAAC,EAAE,OAAO,GACd,aAAa,CAAC,eAAe,CAAC;CA6BlC"}

package/dist/in-memory.event-lake.storage-layer.js

@@ -0,0 +1,54 @@
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
+
+//#region src/in-memory.event-lake.storage-layer.ts
+var InMemoryEventLakeStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	async append(lakeId, changes, trx) {
+		const result = [];
+		let revision = 0;
+		for (const change of changes) {
+			const ref = `${lakeId.serialize()}/${change.id}`;
+			const stored = {
+				...change,
+				ref,
+				revision
+			};
+			this.database.save(lakeId.serialize(), change.id, stored, trx.transaction);
+			result.push({
+				...change,
+				ref,
+				revision,
+				occurredAt: void 0
+			});
+			revision++;
+		}
+		return result;
+	}
+	async *read(lakeId, startAfter, endAt) {
+		const facts = this.database.loadAll(lakeId.serialize()).sort((a, b) => a.data.savedAt === b.data.savedAt ? a.data.data.revision - b.data.data.revision : a.data.savedAt < b.data.savedAt ? -1 : 1).map((e) => e.data);
+		let started = !startAfter;
+		for (const fact of facts) {
+			if (startAfter && fact.data.id === startAfter.serialize()) {
+				started = true;
+				continue;
+			}
+			if (endAt && fact.data.id === endAt.serialize()) {
+				yield {
+					...fact.data,
+					occurredAt: fact.data.savedAt
+				};
+				break;
+			}
+			if (started) yield {
+				...fact.data,
+				occurredAt: fact.data.savedAt
+			};
+		}
+	}
+};
+
+//#endregion
+exports.InMemoryEventLakeStorageLayer = InMemoryEventLakeStorageLayer;

package/dist/in-memory.event-lake.storage-layer.mjs

@@ -0,0 +1,54 @@
+import { EventId, LakeId } from "@ddd-ts/core";
+import "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.event-lake.storage-layer.ts
+var InMemoryEventLakeStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	async append(lakeId, changes, trx) {
+		const result = [];
+		let revision = 0;
+		for (const change of changes) {
+			const ref = `${lakeId.serialize()}/${change.id}`;
+			const stored = {
+				...change,
+				ref,
+				revision
+			};
+			this.database.save(lakeId.serialize(), change.id, stored, trx.transaction);
+			result.push({
+				...change,
+				ref,
+				revision,
+				occurredAt: void 0
+			});
+			revision++;
+		}
+		return result;
+	}
+	async *read(lakeId, startAfter, endAt) {
+		const facts = this.database.loadAll(lakeId.serialize()).sort((a, b) => a.data.savedAt === b.data.savedAt ? a.data.data.revision - b.data.data.revision : a.data.savedAt < b.data.savedAt ? -1 : 1).map((e) => e.data);
+		let started = !startAfter;
+		for (const fact of facts) {
+			if (startAfter && fact.data.id === startAfter.serialize()) {
+				started = true;
+				continue;
+			}
+			if (endAt && fact.data.id === endAt.serialize()) {
+				yield {
+					...fact.data,
+					occurredAt: fact.data.savedAt
+				};
+				break;
+			}
+			if (started) yield {
+				...fact.data,
+				occurredAt: fact.data.savedAt
+			};
+		}
+	}
+};
+
+//#endregion
+export { InMemoryEventLakeStorageLayer };

package/dist/in-memory.event-lake.store.d.ts

@@ -0,0 +1,6 @@
+import { type IEsEvent, EventLakeStore, type ISerializer } from "@ddd-ts/core";
+import type { InMemoryDatabase } from "@ddd-ts/store-inmemory";
+export declare class InMemoryEventLakeStore<Event extends IEsEvent> extends EventLakeStore<Event> {
+    constructor(database: InMemoryDatabase, serializer: ISerializer<Event>);
+}
+//# sourceMappingURL=in-memory.event-lake.store.d.ts.map

package/dist/in-memory.event-lake.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.store.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,qBAAa,sBAAsB,CACjC,KAAK,SAAS,QAAQ,CACtB,SAAQ,cAAc,CAAC,KAAK,CAAC;gBACjB,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC;CAGvE"}

package/dist/in-memory.event-lake.store.js

@@ -0,0 +1,12 @@
+const require_in_memory_event_lake_storage_layer = require('./in-memory.event-lake.storage-layer.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+
+//#region src/in-memory.event-lake.store.ts
+var InMemoryEventLakeStore = class extends _ddd_ts_core.EventLakeStore {
+	constructor(database, serializer) {
+		super(new require_in_memory_event_lake_storage_layer.InMemoryEventLakeStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+exports.InMemoryEventLakeStore = InMemoryEventLakeStore;

package/dist/in-memory.event-lake.store.mjs

@@ -0,0 +1,12 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.mjs";
+import { EventLakeStore } from "@ddd-ts/core";
+
+//#region src/in-memory.event-lake.store.ts
+var InMemoryEventLakeStore = class extends EventLakeStore {
+	constructor(database, serializer) {
+		super(new InMemoryEventLakeStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+export { InMemoryEventLakeStore };

package/dist/in-memory.event-lake.store.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=in-memory.event-lake.store.spec.d.ts.map

package/dist/in-memory.event-lake.store.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.store.spec.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.store.spec.ts"],"names":[],"mappings":""}

package/dist/in-memory.event-stream.aggregate-store.d.ts

@@ -0,0 +1,30 @@
+import type { HasTrait } from "@ddd-ts/traits";
+import { StreamId, type EventsOf, EventSourced, type Identifiable, type IEventBus, EventStreamStore, EventStreamAggregateStore, type EventOf, type ISerializer, type IEventSourced, type IIdentifiable } from "@ddd-ts/core";
+import { InMemoryDatabase } from "@ddd-ts/store-inmemory";
+import { InMemorySnapshotter } from "./in-memory.snapshotter";
+export declare const MakeInMemoryEventStreamAggregateStore: <A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>>(AGGREGATE: A) => {
+    new (database: InMemoryDatabase, serializer: ISerializer<InstanceType<A>> & ISerializer<EventOf<InstanceType<A>>>, eventBus?: IEventBus): {
+        loadFirst(event: EventsOf<A>[number]): InstanceType<A>;
+        getStreamId(id: InstanceType<A>["id"]): StreamId;
+        readonly database: InMemoryDatabase;
+        readonly serializer: ISerializer<EventOf<InstanceType<A>>, {}>;
+        readonly snapshotter: InMemorySnapshotter<InstanceType<A>>;
+        readonly eventBus?: IEventBus | undefined;
+        readonly streamStore: EventStreamStore<EventOf<InstanceType<A>>>;
+        readonly transaction: import("@ddd-ts/core").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?: import("@ddd-ts/core").Transaction, attempts?: number): Promise<void>;
+        save(aggregate: InstanceType<A>, trx?: import("@ddd-ts/core").Transaction, attempts?: number): Promise<void>;
+    };
+};
+export declare abstract class InMemoryEventStreamAggregateStore<A extends IEventSourced & IIdentifiable> extends EventStreamAggregateStore<A> {
+    readonly database: InMemoryDatabase;
+    readonly serializer: ISerializer<EventOf<A>>;
+    readonly snapshotter: InMemorySnapshotter<A>;
+    readonly eventBus?: IEventBus | undefined;
+    constructor(database: InMemoryDatabase, serializer: ISerializer<EventOf<A>>, snapshotter: InMemorySnapshotter<A>, eventBus?: IEventBus | undefined);
+}
+//# sourceMappingURL=in-memory.event-stream.aggregate-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.aggregate-store.d.ts","sourceRoot":"","sources":["../src/in-memory.event-stream.aggregate-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,YAAY,EACZ,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,gBAAgB,EAChB,yBAAyB,EAEzB,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAG9D,eAAO,MAAM,qCAAqC,GAChD,CAAC,SAAS,QAAQ,CAAC,OAAO,YAAY,CAAC,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,aAE5D,CAAC;mBAME,gBAAgB,cACd,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GACtC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,aAC5B,SAAS;yBAUL,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;wBAItC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,QAAQ;2BAUtB,gBAAgB;;;4BAGf,SAAS;;;;;;;;;;CATvC,CAAC;AAEF,8BAAsB,iCAAiC,CACrD,CAAC,SAAS,aAAa,GAAG,aAAa,CACvC,SAAQ,yBAAyB,CAAC,CAAC,CAAC;aAElB,QAAQ,EAAE,gBAAgB;aAC1B,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;aACnC,WAAW,EAAE,mBAAmB,CAAC,CAAC,CAAC;aACnC,QAAQ,CAAC,EAAE,SAAS;gBAHpB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EACnC,WAAW,EAAE,mBAAmB,CAAC,CAAC,CAAC,EACnC,QAAQ,CAAC,EAAE,SAAS,YAAA;CAWvC"}

package/dist/in-memory.event-stream.aggregate-store.js

@@ -0,0 +1,36 @@
+const require_in_memory_event_stream_storage_layer = require('./in-memory.event-stream.storage-layer.js');
+const require_in_memory_snapshotter = require('./in-memory.snapshotter.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
+
+//#region src/in-memory.event-stream.aggregate-store.ts
+const MakeInMemoryEventStreamAggregateStore = (AGGREGATE) => {
+	return class $InMemoryEventStreamAggregateStore extends InMemoryEventStreamAggregateStore {
+		constructor(database, serializer, eventBus) {
+			const snapshotter = new require_in_memory_snapshotter.InMemorySnapshotter(AGGREGATE.name, database, serializer);
+			super(database, serializer, snapshotter, eventBus);
+		}
+		loadFirst(event) {
+			return AGGREGATE.loadFirst(event);
+		}
+		getStreamId(id) {
+			return _ddd_ts_core.StreamId.from(AGGREGATE.name, id.serialize());
+		}
+	};
+};
+var InMemoryEventStreamAggregateStore = class extends _ddd_ts_core.EventStreamAggregateStore {
+	constructor(database, serializer, snapshotter, eventBus) {
+		const storageLayer = new require_in_memory_event_stream_storage_layer.InMemoryEventStreamStorageLayer(database);
+		const transaction = new _ddd_ts_store_inmemory.InMemoryTransactionPerformer(database);
+		const streamStore = new _ddd_ts_core.EventStreamStore(storageLayer, serializer, eventBus);
+		super(streamStore, transaction, snapshotter);
+		this.database = database;
+		this.serializer = serializer;
+		this.snapshotter = snapshotter;
+		this.eventBus = eventBus;
+	}
+};
+
+//#endregion
+exports.InMemoryEventStreamAggregateStore = InMemoryEventStreamAggregateStore;
+exports.MakeInMemoryEventStreamAggregateStore = MakeInMemoryEventStreamAggregateStore;

package/dist/in-memory.event-stream.aggregate-store.mjs

@@ -0,0 +1,35 @@
+import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.mjs";
+import { InMemorySnapshotter } from "./in-memory.snapshotter.mjs";
+import { EventStreamAggregateStore, EventStreamStore, StreamId } from "@ddd-ts/core";
+import { InMemoryTransactionPerformer } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.event-stream.aggregate-store.ts
+const MakeInMemoryEventStreamAggregateStore = (AGGREGATE) => {
+	return class $InMemoryEventStreamAggregateStore extends InMemoryEventStreamAggregateStore {
+		constructor(database, serializer, eventBus) {
+			const snapshotter = new InMemorySnapshotter(AGGREGATE.name, database, serializer);
+			super(database, serializer, snapshotter, eventBus);
+		}
+		loadFirst(event) {
+			return AGGREGATE.loadFirst(event);
+		}
+		getStreamId(id) {
+			return StreamId.from(AGGREGATE.name, id.serialize());
+		}
+	};
+};
+var InMemoryEventStreamAggregateStore = class extends EventStreamAggregateStore {
+	constructor(database, serializer, snapshotter, eventBus) {
+		const storageLayer = new InMemoryEventStreamStorageLayer(database);
+		const transaction = new InMemoryTransactionPerformer(database);
+		const streamStore = new EventStreamStore(storageLayer, serializer, eventBus);
+		super(streamStore, transaction, snapshotter);
+		this.database = database;
+		this.serializer = serializer;
+		this.snapshotter = snapshotter;
+		this.eventBus = eventBus;
+	}
+};
+
+//#endregion
+export { InMemoryEventStreamAggregateStore, MakeInMemoryEventStreamAggregateStore };

package/dist/in-memory.event-stream.aggregate-store.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=in-memory.event-stream.aggregate-store.spec.d.ts.map

package/dist/in-memory.event-stream.aggregate-store.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.aggregate-store.spec.d.ts","sourceRoot":"","sources":["../src/in-memory.event-stream.aggregate-store.spec.ts"],"names":[],"mappings":""}

package/dist/in-memory.event-stream.storage-layer.d.ts

@@ -0,0 +1,11 @@
+import { StreamId, type ISerializedChange, type ISerializedFact, type EventStreamStorageLayer } from "@ddd-ts/core";
+import type { ISerializedSavedChange } from "@ddd-ts/core/dist/interfaces/es-event";
+import { InMemoryDatabase, InMemoryTransaction } from "@ddd-ts/store-inmemory";
+export declare class InMemoryEventStreamStorageLayer implements EventStreamStorageLayer {
+    readonly database: InMemoryDatabase;
+    constructor(database: InMemoryDatabase);
+    isLocalRevisionOutdatedError(error: unknown): boolean;
+    append(streamId: StreamId, changes: ISerializedChange[], expectedRevision: number, trx: InMemoryTransaction): Promise<ISerializedSavedChange[]>;
+    read(streamId: StreamId, from?: number): AsyncIterable<ISerializedFact>;
+}
+//# sourceMappingURL=in-memory.event-stream.storage-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.storage-layer.d.ts","sourceRoot":"","sources":["../src/in-memory.event-stream.storage-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAE7B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE/E,qBAAa,+BACX,YAAW,uBAAuB;aAEN,QAAQ,EAAE,gBAAgB;gBAA1B,QAAQ,EAAE,gBAAgB;IAEtD,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAI/C,MAAM,CACV,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,iBAAiB,EAAE,EAC5B,gBAAgB,EAAE,MAAM,EACxB,GAAG,EAAE,mBAAmB;IAkCnB,IAAI,CACT,QAAQ,EAAE,QAAQ,EAClB,IAAI,CAAC,EAAE,MAAM,GACZ,aAAa,CAAC,eAAe,CAAC;CAclC"}

package/dist/in-memory.event-stream.storage-layer.js

@@ -0,0 +1,42 @@
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
+
+//#region src/in-memory.event-stream.storage-layer.ts
+var InMemoryEventStreamStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	isLocalRevisionOutdatedError(error) {
+		return error instanceof _ddd_ts_core.ConcurrencyError;
+	}
+	async append(streamId, changes, expectedRevision, trx) {
+		const result = [];
+		let revision = expectedRevision + 1;
+		for (const change of changes) {
+			const ref = `${streamId.serialize()}/${revision}`;
+			const stored = {
+				...change,
+				ref,
+				revision
+			};
+			this.database.create(streamId.serialize(), `${revision}`, stored, trx.transaction);
+			result.push({
+				...change,
+				ref,
+				revision,
+				occurredAt: void 0
+			});
+			revision++;
+		}
+		return result;
+	}
+	async *read(streamId, from) {
+		yield* this.database.loadAll(streamId.serialize()).sort((a, b) => a.data.data.revision - b.data.data.revision).map((e) => ({
+			...e.data.data,
+			occurredAt: e.data.savedAt
+		})).slice(from !== void 0 ? from : 0);
+	}
+};
+
+//#endregion
+exports.InMemoryEventStreamStorageLayer = InMemoryEventStreamStorageLayer;

package/dist/in-memory.event-stream.storage-layer.mjs

@@ -0,0 +1,42 @@
+import { ConcurrencyError, StreamId } from "@ddd-ts/core";
+import "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.event-stream.storage-layer.ts
+var InMemoryEventStreamStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	isLocalRevisionOutdatedError(error) {
+		return error instanceof ConcurrencyError;
+	}
+	async append(streamId, changes, expectedRevision, trx) {
+		const result = [];
+		let revision = expectedRevision + 1;
+		for (const change of changes) {
+			const ref = `${streamId.serialize()}/${revision}`;
+			const stored = {
+				...change,
+				ref,
+				revision
+			};
+			this.database.create(streamId.serialize(), `${revision}`, stored, trx.transaction);
+			result.push({
+				...change,
+				ref,
+				revision,
+				occurredAt: void 0
+			});
+			revision++;
+		}
+		return result;
+	}
+	async *read(streamId, from) {
+		yield* this.database.loadAll(streamId.serialize()).sort((a, b) => a.data.data.revision - b.data.data.revision).map((e) => ({
+			...e.data.data,
+			occurredAt: e.data.savedAt
+		})).slice(from !== void 0 ? from : 0);
+	}
+};
+
+//#endregion
+export { InMemoryEventStreamStorageLayer };

package/dist/in-memory.event-stream.store.d.ts

@@ -0,0 +1,6 @@
+import { EventStreamStore, type IEsEvent, type ISerializer } from "@ddd-ts/core";
+import type { InMemoryDatabase } from "@ddd-ts/store-inmemory";
+export declare class InMemoryEventStreamStore<Event extends IEsEvent> extends EventStreamStore<Event> {
+    constructor(database: InMemoryDatabase, serializer: ISerializer<Event>);
+}
+//# sourceMappingURL=in-memory.event-stream.store.d.ts.map

package/dist/in-memory.event-stream.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.store.d.ts","sourceRoot":"","sources":["../src/in-memory.event-stream.store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,QAAQ,EAAe,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC9F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,qBAAa,wBAAwB,CACnC,KAAK,SAAS,QAAQ,CACtB,SAAQ,gBAAgB,CAAC,KAAK,CAAC;gBACnB,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC;CAGvE"}

package/dist/in-memory.event-stream.store.js

@@ -0,0 +1,12 @@
+const require_in_memory_event_stream_storage_layer = require('./in-memory.event-stream.storage-layer.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+
+//#region src/in-memory.event-stream.store.ts
+var InMemoryEventStreamStore = class extends _ddd_ts_core.EventStreamStore {
+	constructor(database, serializer) {
+		super(new require_in_memory_event_stream_storage_layer.InMemoryEventStreamStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+exports.InMemoryEventStreamStore = InMemoryEventStreamStore;

package/dist/in-memory.event-stream.store.mjs

@@ -0,0 +1,12 @@
+import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.mjs";
+import { EventStreamStore } from "@ddd-ts/core";
+
+//#region src/in-memory.event-stream.store.ts
+var InMemoryEventStreamStore = class extends EventStreamStore {
+	constructor(database, serializer) {
+		super(new InMemoryEventStreamStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+export { InMemoryEventStreamStore };

package/dist/in-memory.event-stream.store.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=in-memory.event-stream.store.spec.d.ts.map

package/dist/in-memory.event-stream.store.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.store.spec.d.ts","sourceRoot":"","sources":["../src/in-memory.event-stream.store.spec.ts"],"names":[],"mappings":""}

package/dist/in-memory.projected-stream.reader.d.ts

@@ -0,0 +1,6 @@
+import { type IEsEvent, type ISerializer, ProjectedStreamReader } from "@ddd-ts/core";
+import { InMemoryDatabase } from "@ddd-ts/store-inmemory";
+export declare class InMemoryProjectedStreamReader<Events extends IEsEvent> extends ProjectedStreamReader<Events> {
+    constructor(database: InMemoryDatabase, serializer: ISerializer<Events>);
+}
+//# sourceMappingURL=in-memory.projected-stream.reader.d.ts.map

package/dist/in-memory.projected-stream.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.projected-stream.reader.d.ts","sourceRoot":"","sources":["../src/in-memory.projected-stream.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,qBAAa,6BAA6B,CACxC,MAAM,SAAS,QAAQ,CACvB,SAAQ,qBAAqB,CAAC,MAAM,CAAC;gBACzB,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC;CAGxE"}

package/dist/in-memory.projected-stream.reader.js

@@ -0,0 +1,13 @@
+const require_in_memory_projected_stream_storage_layer = require('./in-memory.projected-stream.storage-layer.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
+
+//#region src/in-memory.projected-stream.reader.ts
+var InMemoryProjectedStreamReader = class extends _ddd_ts_core.ProjectedStreamReader {
+	constructor(database, serializer) {
+		super(new require_in_memory_projected_stream_storage_layer.InMemoryProjectedStreamStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+exports.InMemoryProjectedStreamReader = InMemoryProjectedStreamReader;

package/dist/in-memory.projected-stream.reader.mjs

@@ -0,0 +1,13 @@
+import { InMemoryProjectedStreamStorageLayer } from "./in-memory.projected-stream.storage-layer.mjs";
+import { ProjectedStreamReader } from "@ddd-ts/core";
+import "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.projected-stream.reader.ts
+var InMemoryProjectedStreamReader = class extends ProjectedStreamReader {
+	constructor(database, serializer) {
+		super(new InMemoryProjectedStreamStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+export { InMemoryProjectedStreamReader };

package/dist/in-memory.projected-stream.reader.spec.d.ts

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

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

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

package/dist/in-memory.projected-stream.storage-layer.d.ts

@@ -0,0 +1,27 @@
+import { type ISerializedFact, LakeSource, ProjectedStream, type ProjectedStreamStorageLayer, StreamSource, Cursor, type ISerializedSavedChange } from "@ddd-ts/core";
+import { InMemoryDatabase } from "@ddd-ts/store-inmemory";
+export declare class InMemoryStreamSourceFilter {
+    private readonly database;
+    constructor(database: InMemoryDatabase);
+    all(source: StreamSource, shard: string): Generator<{
+        savedAt: bigint;
+        data: any;
+    }, void, unknown>;
+}
+export declare class InMemoryLakeSourceFilter {
+    private readonly database;
+    constructor(database: InMemoryDatabase);
+    all(source: LakeSource, shard: string): Generator<{
+        savedAt: bigint;
+        data: any;
+    }, void, unknown>;
+}
+export declare class InMemoryProjectedStreamStorageLayer implements ProjectedStreamStorageLayer {
+    private readonly database;
+    constructor(database: InMemoryDatabase);
+    getCursor(savedChange: ISerializedSavedChange): Promise<Cursor | undefined>;
+    get(cursor: Cursor): Promise<ISerializedFact | undefined>;
+    read(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor, endAt?: Cursor): AsyncGenerator<any, void, unknown>;
+    slice(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor, endAt?: Cursor, count?: number): Promise<ISerializedFact[]>;
+}
+//# sourceMappingURL=in-memory.projected-stream.storage-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.projected-stream.storage-layer.d.ts","sourceRoot":"","sources":["../src/in-memory.projected-stream.storage-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAEpB,UAAU,EACV,eAAe,EACf,KAAK,2BAA2B,EAChC,YAAY,EACZ,MAAM,EACN,KAAK,sBAAsB,EAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,qBAAa,0BAA0B;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,gBAAgB;IAEtD,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM;;;;CAezC;AAED,qBAAa,wBAAwB;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,gBAAgB;IAEtD,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM;;;;CAYvC;AAED,qBAAa,mCACX,YAAW,2BAA2B;IAE1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,gBAAgB;IAEjD,SAAS,CACb,WAAW,EAAE,sBAAsB,GAClC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAexB,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAUxD,IAAI,CACT,eAAe,EAAE,eAAe,EAChC,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,MAAM;IAmCV,KAAK,CACT,eAAe,EAAE,eAAe,EAChC,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,EAAE,CAAC;CAa9B"}

package/dist/in-memory.projected-stream.storage-layer.js

@@ -0,0 +1,99 @@
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
+let _ddd_ts_shape = require("@ddd-ts/shape");
+
+//#region src/in-memory.projected-stream.storage-layer.ts
+var InMemoryStreamSourceFilter = class {
+	constructor(database) {
+		this.database = database;
+	}
+	*all(source, shard) {
+		const streams = [...this.database.storage.collections.keys()].filter((it) => it.startsWith(source.aggregateType));
+		for (const stream of streams) yield* this.database.loadAll(stream).filter((event) => {
+			if (!source.events.includes(event.data.data.name)) return false;
+			const payload = event.data.data.payload;
+			if (!payload) return false;
+			return payload[source.shardKey] === shard;
+		}).map((event) => event.data);
+	}
+};
+var InMemoryLakeSourceFilter = class {
+	constructor(database) {
+		this.database = database;
+	}
+	*all(source, shard) {
+		const lakeId = _ddd_ts_core.LakeId.from(source.shardType, shard);
+		yield* this.database.loadAll(lakeId.serialize()).filter((event) => {
+			if (!source.events.includes(event.data.data.name)) return false;
+			const payload = event.data.data.payload;
+			if (!payload) return false;
+			return payload[source.shardKey] === shard;
+		}).map((event) => event.data);
+	}
+};
+var InMemoryProjectedStreamStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	async getCursor(savedChange) {
+		const [collection, id] = savedChange.ref.split("/");
+		if (!collection || !id) return void 0;
+		const raw = this.database.storage.getCollection(collection).getRaw(id);
+		if (!raw) return void 0;
+		return new _ddd_ts_core.Cursor({
+			ref: savedChange.ref,
+			eventId: new _ddd_ts_core.EventId(savedChange.id),
+			occurredAt: _ddd_ts_shape.MicrosecondTimestamp.fromMicroseconds(raw.savedAt),
+			revision: savedChange.revision
+		});
+	}
+	async get(cursor) {
+		const [collection, id] = cursor.ref.split("/");
+		if (!collection || !id) return void 0;
+		const raw = this.database.storage.getCollection(collection).getRaw(id);
+		if (!raw) return void 0;
+		return {
+			...raw.data,
+			occurredAt: raw.savedAt
+		};
+	}
+	async *read(projectedStream, shard, startAfter, endAt) {
+		const all = projectedStream.sources.map((source) => {
+			if (source instanceof _ddd_ts_core.StreamSource) return new InMemoryStreamSourceFilter(this.database).all(source, shard);
+			return new InMemoryLakeSourceFilter(this.database).all(source, shard);
+		}).flatMap((source) => [...source]).sort((a, b) => a.savedAt === b.savedAt ? a.data.revision - b.data.revision : a.savedAt > b.savedAt ? 1 : -1);
+		let started = !startAfter?.ref;
+		for (const fact of all) {
+			if (startAfter && fact.data.ref === startAfter.ref) {
+				started = true;
+				continue;
+			}
+			if (endAt?.ref && fact.data.ref === endAt.ref) {
+				yield {
+					...fact.data,
+					occurredAt: fact.savedAt
+				};
+				break;
+			}
+			if (started) yield {
+				...fact.data,
+				occurredAt: fact.savedAt
+			};
+		}
+	}
+	async slice(projectedStream, shard, startAfter, endAt, count) {
+		const stream = this.read(projectedStream, shard, startAfter, endAt);
+		const result = [];
+		let limit = count ?? Number.POSITIVE_INFINITY;
+		for await (const fact of stream) {
+			if (!limit--) break;
+			result.push(fact);
+		}
+		return result;
+	}
+};
+
+//#endregion
+exports.InMemoryLakeSourceFilter = InMemoryLakeSourceFilter;
+exports.InMemoryProjectedStreamStorageLayer = InMemoryProjectedStreamStorageLayer;
+exports.InMemoryStreamSourceFilter = InMemoryStreamSourceFilter;

package/dist/in-memory.projected-stream.storage-layer.mjs

@@ -0,0 +1,97 @@
+import { Cursor, EventId, LakeId, StreamSource } from "@ddd-ts/core";
+import "@ddd-ts/store-inmemory";
+import { MicrosecondTimestamp } from "@ddd-ts/shape";
+
+//#region src/in-memory.projected-stream.storage-layer.ts
+var InMemoryStreamSourceFilter = class {
+	constructor(database) {
+		this.database = database;
+	}
+	*all(source, shard) {
+		const streams = [...this.database.storage.collections.keys()].filter((it) => it.startsWith(source.aggregateType));
+		for (const stream of streams) yield* this.database.loadAll(stream).filter((event) => {
+			if (!source.events.includes(event.data.data.name)) return false;
+			const payload = event.data.data.payload;
+			if (!payload) return false;
+			return payload[source.shardKey] === shard;
+		}).map((event) => event.data);
+	}
+};
+var InMemoryLakeSourceFilter = class {
+	constructor(database) {
+		this.database = database;
+	}
+	*all(source, shard) {
+		const lakeId = LakeId.from(source.shardType, shard);
+		yield* this.database.loadAll(lakeId.serialize()).filter((event) => {
+			if (!source.events.includes(event.data.data.name)) return false;
+			const payload = event.data.data.payload;
+			if (!payload) return false;
+			return payload[source.shardKey] === shard;
+		}).map((event) => event.data);
+	}
+};
+var InMemoryProjectedStreamStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	async getCursor(savedChange) {
+		const [collection, id] = savedChange.ref.split("/");
+		if (!collection || !id) return void 0;
+		const raw = this.database.storage.getCollection(collection).getRaw(id);
+		if (!raw) return void 0;
+		return new Cursor({
+			ref: savedChange.ref,
+			eventId: new EventId(savedChange.id),
+			occurredAt: MicrosecondTimestamp.fromMicroseconds(raw.savedAt),
+			revision: savedChange.revision
+		});
+	}
+	async get(cursor) {
+		const [collection, id] = cursor.ref.split("/");
+		if (!collection || !id) return void 0;
+		const raw = this.database.storage.getCollection(collection).getRaw(id);
+		if (!raw) return void 0;
+		return {
+			...raw.data,
+			occurredAt: raw.savedAt
+		};
+	}
+	async *read(projectedStream, shard, startAfter, endAt) {
+		const all = projectedStream.sources.map((source) => {
+			if (source instanceof StreamSource) return new InMemoryStreamSourceFilter(this.database).all(source, shard);
+			return new InMemoryLakeSourceFilter(this.database).all(source, shard);
+		}).flatMap((source) => [...source]).sort((a, b) => a.savedAt === b.savedAt ? a.data.revision - b.data.revision : a.savedAt > b.savedAt ? 1 : -1);
+		let started = !startAfter?.ref;
+		for (const fact of all) {
+			if (startAfter && fact.data.ref === startAfter.ref) {
+				started = true;
+				continue;
+			}
+			if (endAt?.ref && fact.data.ref === endAt.ref) {
+				yield {
+					...fact.data,
+					occurredAt: fact.savedAt
+				};
+				break;
+			}
+			if (started) yield {
+				...fact.data,
+				occurredAt: fact.savedAt
+			};
+		}
+	}
+	async slice(projectedStream, shard, startAfter, endAt, count) {
+		const stream = this.read(projectedStream, shard, startAfter, endAt);
+		const result = [];
+		let limit = count ?? Number.POSITIVE_INFINITY;
+		for await (const fact of stream) {
+			if (!limit--) break;
+			result.push(fact);
+		}
+		return result;
+	}
+};
+
+//#endregion
+export { InMemoryLakeSourceFilter, InMemoryProjectedStreamStorageLayer, InMemoryStreamSourceFilter };

package/dist/in-memory.snapshotter.d.ts

@@ -0,0 +1,6 @@
+import { type IEsAggregateStore, type IEventSourced, type IIdentifiable, type ISerializer } from "@ddd-ts/core";
+import { InMemoryDatabase, InMemoryStore } from "@ddd-ts/store-inmemory";
+export declare class InMemorySnapshotter<A extends IEventSourced & IIdentifiable> extends InMemoryStore<A> implements IEsAggregateStore<A> {
+    constructor(aggregate: string, db: InMemoryDatabase, serializer: ISerializer<A>);
+}
+//# sourceMappingURL=in-memory.snapshotter.d.ts.map

package/dist/in-memory.snapshotter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.snapshotter.d.ts","sourceRoot":"","sources":["../src/in-memory.snapshotter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EACjB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAqBzE,qBAAa,mBAAmB,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,CACtE,SAAQ,aAAa,CAAC,CAAC,CACvB,YAAW,iBAAiB,CAAC,CAAC,CAAC;gBAG7B,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,gBAAgB,EACpB,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC;CAI7B"}

package/dist/in-memory.snapshotter.js

@@ -0,0 +1,29 @@
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
+
+//#region src/in-memory.snapshotter.ts
+var SnapshotSerializer = class {
+	constructor(serializer) {
+		this.serializer = serializer;
+	}
+	async serialize(instance) {
+		return {
+			...await this.serializer.serialize(instance),
+			revision: instance.acknowledgedRevision
+		};
+	}
+	async deserialize(serialized) {
+		const { revision, ...content } = serialized;
+		const instance = await this.serializer.deserialize(content);
+		instance.acknowledgedRevision = Number(revision);
+		return instance;
+	}
+};
+var InMemorySnapshotter = class extends _ddd_ts_store_inmemory.InMemoryStore {
+	constructor(aggregate, db, serializer) {
+		super(`snapshots-${aggregate}`, db, new SnapshotSerializer(serializer));
+	}
+};
+
+//#endregion
+exports.InMemorySnapshotter = InMemorySnapshotter;

package/dist/in-memory.snapshotter.mjs

@@ -0,0 +1,29 @@
+import "@ddd-ts/core";
+import { InMemoryStore } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.snapshotter.ts
+var SnapshotSerializer = class {
+	constructor(serializer) {
+		this.serializer = serializer;
+	}
+	async serialize(instance) {
+		return {
+			...await this.serializer.serialize(instance),
+			revision: instance.acknowledgedRevision
+		};
+	}
+	async deserialize(serialized) {
+		const { revision, ...content } = serialized;
+		const instance = await this.serializer.deserialize(content);
+		instance.acknowledgedRevision = Number(revision);
+		return instance;
+	}
+};
+var InMemorySnapshotter = class extends InMemoryStore {
+	constructor(aggregate, db, serializer) {
+		super(`snapshots-${aggregate}`, db, new SnapshotSerializer(serializer));
+	}
+};
+
+//#endregion
+export { InMemorySnapshotter };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer";
+export { InMemoryEventLakeStore } from "./in-memory.event-lake.store";
+export { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer";
+export { InMemoryEventStreamStore } from "./in-memory.event-stream.store";
+export { InMemoryEventStreamAggregateStore, MakeInMemoryEventStreamAggregateStore, } from "./in-memory.event-stream.aggregate-store";
+export { InMemoryEventLakeAggregateStore, MakeInMemoryEventLakeAggregateStore, } from "./in-memory.event-lake.aggregate-store";
+export { InMemoryProjectedStreamStorageLayer, InMemoryLakeSourceFilter, InMemoryStreamSourceFilter, } from "./in-memory.projected-stream.storage-layer";
+export { InMemoryProjectedStreamReader } from "./in-memory.projected-stream.reader";
+export { InMemorySnapshotter } from "./in-memory.snapshotter";
+//# 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,6BAA6B,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAAE,+BAA+B,EAAE,MAAM,wCAAwC,CAAC;AACzF,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAE1E,OAAO,EACL,iCAAiC,EACjC,qCAAqC,GACtC,MAAM,0CAA0C,CAAC;AAElD,OAAO,EACL,+BAA+B,EAC/B,mCAAmC,GACpC,MAAM,wCAAwC,CAAC;AAEhD,OAAO,EACL,mCAAmC,EACnC,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAC;AAEpF,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_in_memory_event_lake_storage_layer = require('./in-memory.event-lake.storage-layer.js');
+const require_in_memory_event_lake_store = require('./in-memory.event-lake.store.js');
+const require_in_memory_event_stream_storage_layer = require('./in-memory.event-stream.storage-layer.js');
+const require_in_memory_event_stream_store = require('./in-memory.event-stream.store.js');
+const require_in_memory_snapshotter = require('./in-memory.snapshotter.js');
+const require_in_memory_event_stream_aggregate_store = require('./in-memory.event-stream.aggregate-store.js');
+const require_in_memory_event_lake_aggregate_store = require('./in-memory.event-lake.aggregate-store.js');
+const require_in_memory_projected_stream_storage_layer = require('./in-memory.projected-stream.storage-layer.js');
+const require_in_memory_projected_stream_reader = require('./in-memory.projected-stream.reader.js');
+
+exports.InMemoryEventLakeAggregateStore = require_in_memory_event_lake_aggregate_store.InMemoryEventLakeAggregateStore;
+exports.InMemoryEventLakeStorageLayer = require_in_memory_event_lake_storage_layer.InMemoryEventLakeStorageLayer;
+exports.InMemoryEventLakeStore = require_in_memory_event_lake_store.InMemoryEventLakeStore;
+exports.InMemoryEventStreamAggregateStore = require_in_memory_event_stream_aggregate_store.InMemoryEventStreamAggregateStore;
+exports.InMemoryEventStreamStorageLayer = require_in_memory_event_stream_storage_layer.InMemoryEventStreamStorageLayer;
+exports.InMemoryEventStreamStore = require_in_memory_event_stream_store.InMemoryEventStreamStore;
+exports.InMemoryLakeSourceFilter = require_in_memory_projected_stream_storage_layer.InMemoryLakeSourceFilter;
+exports.InMemoryProjectedStreamReader = require_in_memory_projected_stream_reader.InMemoryProjectedStreamReader;
+exports.InMemoryProjectedStreamStorageLayer = require_in_memory_projected_stream_storage_layer.InMemoryProjectedStreamStorageLayer;
+exports.InMemorySnapshotter = require_in_memory_snapshotter.InMemorySnapshotter;
+exports.InMemoryStreamSourceFilter = require_in_memory_projected_stream_storage_layer.InMemoryStreamSourceFilter;
+exports.MakeInMemoryEventLakeAggregateStore = require_in_memory_event_lake_aggregate_store.MakeInMemoryEventLakeAggregateStore;
+exports.MakeInMemoryEventStreamAggregateStore = require_in_memory_event_stream_aggregate_store.MakeInMemoryEventStreamAggregateStore;

package/dist/index.mjs

@@ -0,0 +1,11 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.mjs";
+import { InMemoryEventLakeStore } from "./in-memory.event-lake.store.mjs";
+import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.mjs";
+import { InMemoryEventStreamStore } from "./in-memory.event-stream.store.mjs";
+import { InMemorySnapshotter } from "./in-memory.snapshotter.mjs";
+import { InMemoryEventStreamAggregateStore, MakeInMemoryEventStreamAggregateStore } from "./in-memory.event-stream.aggregate-store.mjs";
+import { InMemoryEventLakeAggregateStore, MakeInMemoryEventLakeAggregateStore } from "./in-memory.event-lake.aggregate-store.mjs";
+import { InMemoryLakeSourceFilter, InMemoryProjectedStreamStorageLayer, InMemoryStreamSourceFilter } from "./in-memory.projected-stream.storage-layer.mjs";
+import { InMemoryProjectedStreamReader } from "./in-memory.projected-stream.reader.mjs";
+
+export { InMemoryEventLakeAggregateStore, InMemoryEventLakeStorageLayer, InMemoryEventLakeStore, InMemoryEventStreamAggregateStore, InMemoryEventStreamStorageLayer, InMemoryEventStreamStore, InMemoryLakeSourceFilter, InMemoryProjectedStreamReader, InMemoryProjectedStreamStorageLayer, InMemorySnapshotter, InMemoryStreamSourceFilter, MakeInMemoryEventLakeAggregateStore, MakeInMemoryEventStreamAggregateStore };

package/package.json

@@ -1,37 +1,39 @@
 {
   "name": "@ddd-ts/event-sourcing-inmemory",
-  "version": "0.0.37",
+  "version": "0.0.38",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "repository": {
     "url": "git+https://github.com/ddd-ts/monorepo"
   },
-  "scripts": {
-    "test": "jest --config node_modules/@ddd-ts/tools/jest.config.js",
-    "build": "tsdown --config node_modules/@ddd-ts/tools/tsdown.config.js"
-  },
+  "files": [
+    "dist"
+  ],
   "dependencies": {
-    "@ddd-ts/core": "0.0.37",
-    "@ddd-ts/shape": "0.0.37",
-    "@ddd-ts/store-inmemory": "0.0.37",
-    "@ddd-ts/types": "0.0.37"
+    "@ddd-ts/core": "0.0.38",
+    "@ddd-ts/shape": "0.0.38",
+    "@ddd-ts/store-inmemory": "0.0.38",
+    "@ddd-ts/types": "0.0.38"
   },
   "devDependencies": {
-    "@ddd-ts/shape": "0.0.37",
-    "@ddd-ts/tests": "0.0.37",
-    "@ddd-ts/tools": "0.0.37",
-    "@ddd-ts/traits": "0.0.37",
+    "@ddd-ts/shape": "0.0.38",
+    "@ddd-ts/tests": "0.0.38",
+    "@ddd-ts/tools": "0.0.38",
+    "@ddd-ts/traits": "0.0.38",
     "@types/jest": "^29.5.1",
     "@types/node": "^20.12.4"
   },
   "exports": {
-    ".": "./src/index.ts",
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
     "./package.json": "./package.json"
   },
-  "publishConfig": {
-    "exports": {
-      ".": "./dist/index.js",
-      "./package.json": "./package.json"
-    }
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "scripts": {
+    "test": "jest --config node_modules/@ddd-ts/tools/jest.config.js",
+    "build": "tsdown --config node_modules/@ddd-ts/tools/tsdown.config.js"
   }
-}
+}