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

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

@@ -1,45 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryEventStreamStorageLayer = void 0;
-const core_1 = require("@ddd-ts/core");
-class InMemoryEventStreamStorageLayer {
-    database;
-    constructor(database) {
-        this.database = database;
-    }
-    isLocalRevisionOutdatedError(error) {
-        return error instanceof core_1.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: ref,
-                revision: revision,
-            };
-            this.database.create(streamId.serialize(), `${revision}`, stored, trx.transaction);
-            result.push({
-                ...change,
-                ref: ref,
-                revision: revision,
-                occurredAt: undefined,
-            });
-            revision++;
-        }
-        return result;
-    }
-    async *read(streamId, from) {
-        const events = this.database.loadAll(streamId.serialize());
-        const sorted = events.sort((a, b) => a.data.data.revision - b.data.data.revision);
-        const facts = sorted.map((e) => ({
-            ...e.data.data,
-            occurredAt: e.data.savedAt,
-        }));
-        yield* facts.slice(from !== undefined ? from : 0);
-    }
-}
-exports.InMemoryEventStreamStorageLayer = InMemoryEventStreamStorageLayer;
-//# sourceMappingURL=in-memory.event-stream.storage-layer.js.map
+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

@@ -1,4 +1,4 @@
-import { EventStreamStore, IEsEvent, ISerializer } from "@ddd-ts/core";
+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>);

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

@@ -1 +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,QAAQ,EAAU,WAAW,EAAE,MAAM,cAAc,CAAC;AAC/E,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"}
+{"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

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryEventStreamStore = void 0;
-const core_1 = require("@ddd-ts/core");
-const in_memory_event_stream_storage_layer_1 = require("./in-memory.event-stream.storage-layer");
-class InMemoryEventStreamStore extends core_1.EventStreamStore {
-    constructor(database, serializer) {
-        super(new in_memory_event_stream_storage_layer_1.InMemoryEventStreamStorageLayer(database), serializer);
-    }
-}
-exports.InMemoryEventStreamStore = InMemoryEventStreamStore;
-//# sourceMappingURL=in-memory.event-stream.store.js.map
+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.projected-stream.reader.d.ts

@@ -1,4 +1,4 @@
-import { IEsEvent, ISerializer, ProjectedStreamReader } from "@ddd-ts/core";
+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>);

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

@@ -1 +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,QAAQ,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC5E,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"}
+{"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

@@ -1,12 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryProjectedStreamReader = void 0;
-const core_1 = require("@ddd-ts/core");
-const in_memory_projected_stream_storage_layer_1 = require("./in-memory.projected-stream.storage-layer");
-class InMemoryProjectedStreamReader extends core_1.ProjectedStreamReader {
-    constructor(database, serializer) {
-        super(new in_memory_projected_stream_storage_layer_1.InMemoryProjectedStreamStorageLayer(database), serializer);
-    }
-}
-exports.InMemoryProjectedStreamReader = InMemoryProjectedStreamReader;
-//# sourceMappingURL=in-memory.projected-stream.reader.js.map
+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.storage-layer.d.ts

@@ -1,4 +1,4 @@
-import { ISerializedFact, LakeSource, ProjectedStream, ProjectedStreamStorageLayer, StreamSource, Cursor, ISerializedSavedChange } from "@ddd-ts/core";
+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;

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

@@ -1 +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,eAAe,EAEf,UAAU,EACV,eAAe,EACf,2BAA2B,EAC3B,YAAY,EACZ,MAAM,EACN,sBAAsB,EACvB,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"}
+{"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

@@ -1,121 +1,99 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryProjectedStreamStorageLayer = exports.InMemoryLakeSourceFilter = exports.InMemoryStreamSourceFilter = void 0;
-const core_1 = require("@ddd-ts/core");
-const shape_1 = require("@ddd-ts/shape");
-class InMemoryStreamSourceFilter {
-    database;
-    constructor(database) {
-        this.database = database;
-    }
-    *all(source, shard) {
-        const cols = [...this.database.storage.collections.keys()];
-        const streams = cols.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);
-        }
-    }
-}
-exports.InMemoryStreamSourceFilter = InMemoryStreamSourceFilter;
-class InMemoryLakeSourceFilter {
-    database;
-    constructor(database) {
-        this.database = database;
-    }
-    *all(source, shard) {
-        const lakeId = core_1.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);
-    }
-}
+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;
-class InMemoryProjectedStreamStorageLayer {
-    database;
-    constructor(database) {
-        this.database = database;
-    }
-    async getCursor(savedChange) {
-        const [collection, id] = savedChange.ref.split("/");
-        if (!collection || !id)
-            return undefined;
-        const raw = this.database.storage.getCollection(collection).getRaw(id);
-        if (!raw)
-            return undefined;
-        return new core_1.Cursor({
-            ref: savedChange.ref,
-            eventId: new core_1.EventId(savedChange.id),
-            occurredAt: shape_1.MicrosecondTimestamp.fromMicroseconds(raw.savedAt),
-            revision: savedChange.revision,
-        });
-    }
-    async get(cursor) {
-        const [collection, id] = cursor.ref.split("/");
-        if (!collection || !id)
-            return undefined;
-        const raw = this.database.storage.getCollection(collection).getRaw(id);
-        if (!raw)
-            return undefined;
-        return { ...raw.data, occurredAt: raw.savedAt };
-    }
-    async *read(projectedStream, shard, startAfter, endAt) {
-        const sources = projectedStream.sources.map((source) => {
-            if (source instanceof core_1.StreamSource) {
-                return new InMemoryStreamSourceFilter(this.database).all(source, shard);
-            }
-            return new InMemoryLakeSourceFilter(this.database).all(source, shard);
-        });
-        const all = sources
-            .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;
-    }
-}
 exports.InMemoryProjectedStreamStorageLayer = InMemoryProjectedStreamStorageLayer;
-//# sourceMappingURL=in-memory.projected-stream.storage-layer.js.map
+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.js

@@ -1,30 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemorySnapshotter = void 0;
-const store_inmemory_1 = require("@ddd-ts/store-inmemory");
-class SnapshotSerializer {
-    serializer;
-    constructor(serializer) {
-        this.serializer = serializer;
-    }
-    async serialize(instance) {
-        const serialized = await this.serializer.serialize(instance);
-        return {
-            ...serialized,
-            revision: instance.acknowledgedRevision,
-        };
-    }
-    async deserialize(serialized) {
-        const { revision, ...content } = serialized;
-        const instance = await this.serializer.deserialize(content);
-        instance.acknowledgedRevision = Number(revision);
-        return instance;
-    }
-}
-class InMemorySnapshotter extends store_inmemory_1.InMemoryStore {
-    constructor(aggregate, db, serializer) {
-        super(`snapshots-${aggregate}`, db, new SnapshotSerializer(serializer));
-    }
-}
-exports.InMemorySnapshotter = InMemorySnapshotter;
-//# sourceMappingURL=in-memory.snapshotter.js.map
+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;