@ddd-ts/store-inmemory 0.0.0-compute-timeout-on-process.2 → 0.0.0-compute-timeout-on-process.4

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

@@ -0,0 +1,22 @@
+import { InMemoryDatabase, InMemoryUnderlyingTransaction } from "./store/in-memory.database.js";
+import { TransactionPerformer } from "@ddd-ts/core";
+
+//#region src/in-memory.transaction.d.ts
+declare class InMemoryTransaction {
+  readonly transaction: InMemoryUnderlyingTransaction;
+  commitListeners: (() => void)[];
+  constructor(transaction: InMemoryUnderlyingTransaction);
+  counter: number;
+  increment(): number;
+  onCommit(callback: () => void): void;
+  executeCommitListeners(): Promise<void>;
+}
+declare class InMemoryTransactionPerformer extends TransactionPerformer<InMemoryTransaction> {
+  constructor(db: InMemoryDatabase);
+}
+declare class FakeInMemoryTransactionPerformer extends TransactionPerformer<InMemoryTransaction> {
+  constructor();
+}
+//#endregion
+export { FakeInMemoryTransactionPerformer, InMemoryTransaction, InMemoryTransactionPerformer };
+//# sourceMappingURL=in-memory.transaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.transaction.d.ts","names":[],"sources":["../src/in-memory.transaction.ts"],"mappings":";;;;cAMa,mBAAA;EAAA,SAGiB,WAAA,EAAa,6BAAA;EAFzC,eAAA;cAE4B,WAAA,EAAa,6BAAA;EAEzC,OAAA;EAEA,SAAA,CAAA;EAKA,QAAA,CAAS,QAAA;EAIH,sBAAA,CAAA,GAAsB,OAAA;AAAA;AAAA,cAKjB,4BAAA,SAAqC,oBAAA,CAAqB,mBAAA;cACzD,EAAA,EAAI,gBAAA;AAAA;AAAA,cAKL,gCAAA,SAAyC,oBAAA,CAAqB,mBAAA"}

package/dist/in-memory.transaction.js

@@ -0,0 +1,34 @@
+import { TransactionPerformer } from "@ddd-ts/core";
+
+//#region src/in-memory.transaction.ts
+var InMemoryTransaction = class {
+	commitListeners = [];
+	constructor(transaction) {
+		this.transaction = transaction;
+	}
+	counter = -1;
+	increment() {
+		this.counter++;
+		return this.counter;
+	}
+	onCommit(callback) {
+		this.commitListeners.push(callback);
+	}
+	async executeCommitListeners() {
+		await Promise.all(this.commitListeners.map((cb) => cb()));
+	}
+};
+var InMemoryTransactionPerformer = class extends TransactionPerformer {
+	constructor(db) {
+		super((effect) => db.transactionally((trx) => effect(trx)));
+	}
+};
+var FakeInMemoryTransactionPerformer = class extends TransactionPerformer {
+	constructor() {
+		super((effect) => effect(new InMemoryTransaction(null)));
+	}
+};
+
+//#endregion
+export { FakeInMemoryTransactionPerformer, InMemoryTransaction, InMemoryTransactionPerformer };
+//# sourceMappingURL=in-memory.transaction.js.map

package/dist/in-memory.transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.transaction.js","names":[],"sources":["../src/in-memory.transaction.ts"],"sourcesContent":["import { TransactionPerformer } from \"@ddd-ts/core\";\nimport {\n  InMemoryDatabase,\n  InMemoryUnderlyingTransaction,\n} from \"./store/in-memory.database\";\n\nexport class InMemoryTransaction {\n  commitListeners: (() => void)[] = [];\n\n  constructor(public readonly transaction: InMemoryUnderlyingTransaction) {}\n\n  counter = -1;\n\n  increment() {\n    this.counter++;\n    return this.counter;\n  }\n\n  onCommit(callback: () => void) {\n    this.commitListeners.push(callback);\n  }\n\n  async executeCommitListeners() {\n    await Promise.all(this.commitListeners.map((cb) => cb()));\n  }\n}\n\nexport class InMemoryTransactionPerformer extends TransactionPerformer<InMemoryTransaction> {\n  constructor(db: InMemoryDatabase) {\n    super((effect) => db.transactionally((trx) => effect(trx)));\n  }\n}\n\nexport class FakeInMemoryTransactionPerformer extends TransactionPerformer<InMemoryTransaction> {\n  constructor() {\n    super((effect) => effect(new InMemoryTransaction(null as any)));\n  }\n}\n"],"mappings":";;;AAMA,IAAa,sBAAb,MAAiC;CAC/B,kBAAkC,EAAE;CAEpC,YAAY,AAAgB,aAA4C;EAA5C;;CAE5B,UAAU;CAEV,YAAY;AACV,OAAK;AACL,SAAO,KAAK;;CAGd,SAAS,UAAsB;AAC7B,OAAK,gBAAgB,KAAK,SAAS;;CAGrC,MAAM,yBAAyB;AAC7B,QAAM,QAAQ,IAAI,KAAK,gBAAgB,KAAK,OAAO,IAAI,CAAC,CAAC;;;AAI7D,IAAa,+BAAb,cAAkD,qBAA0C;CAC1F,YAAY,IAAsB;AAChC,SAAO,WAAW,GAAG,iBAAiB,QAAQ,OAAO,IAAI,CAAC,CAAC;;;AAI/D,IAAa,mCAAb,cAAsD,qBAA0C;CAC9F,cAAc;AACZ,SAAO,WAAW,OAAO,IAAI,oBAAoB,KAAY,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { CannotReadAfterWrites, InMemoryDatabase, InMemoryUnderlyingTransaction, TransactionCollidedTooManyTimes } from "./store/in-memory.database.js";
+import { FakeInMemoryTransactionPerformer, InMemoryTransaction, InMemoryTransactionPerformer } from "./in-memory.transaction.js";
+import { InMemoryStore } from "./store/in-memory.store.js";
+export { CannotReadAfterWrites, FakeInMemoryTransactionPerformer, InMemoryDatabase, InMemoryStore, InMemoryTransaction, InMemoryTransactionPerformer, InMemoryUnderlyingTransaction, TransactionCollidedTooManyTimes };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { FakeInMemoryTransactionPerformer, InMemoryTransaction, InMemoryTransactionPerformer } from "./in-memory.transaction.js";
+import { CannotReadAfterWrites, InMemoryDatabase, InMemoryUnderlyingTransaction, TransactionCollidedTooManyTimes } from "./store/in-memory.database.js";
+import { InMemoryStore } from "./store/in-memory.store.js";
+
+export { CannotReadAfterWrites, FakeInMemoryTransactionPerformer, InMemoryDatabase, InMemoryStore, InMemoryTransaction, InMemoryTransactionPerformer, InMemoryUnderlyingTransaction, TransactionCollidedTooManyTimes };

package/dist/store/in-memory.collection.d.ts

@@ -0,0 +1,32 @@
+//#region src/store/in-memory.collection.d.ts
+declare class Collection {
+  private data;
+  constructor(data?: Map<string, {
+    savedAt: bigint;
+    data: any;
+  }>);
+  clear(): void;
+  getLatestSnapshot(id: string): any;
+  clone(): Collection;
+  merge(other: Collection): Collection;
+  delete(id: string): void;
+  getRaw(id: string): {
+    savedAt: bigint;
+    data: any;
+  } | undefined;
+  countAll(): number;
+  get(id: string): any;
+  getAllRaw(): {
+    id: string;
+    data: {
+      savedAt: bigint;
+      data: any;
+    };
+  }[];
+  getAll(): any[];
+  save(id: string, data: any): void;
+  toPretty(): string;
+}
+//#endregion
+export { Collection };
+//# sourceMappingURL=in-memory.collection.d.ts.map

package/dist/store/in-memory.collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.collection.d.ts","names":[],"sources":["../../src/store/in-memory.collection.ts"],"mappings":";cAOa,UAAA;EAAA,QAED,IAAA;cAAA,IAAA,GAAM,GAAA;IAAc,OAAA;IAAiB,IAAA;EAAA;EAG/C,KAAA,CAAA;EAIA,iBAAA,CAAkB,EAAA;EAOlB,KAAA,CAAA,GAAK,UAAA;EAQL,KAAA,CAAM,KAAA,EAAO,UAAA,GAAU,UAAA;EAWvB,MAAA,CAAO,EAAA;EAIP,MAAA,CAAO,EAAA;;;;EAIP,QAAA,CAAA;EAIA,GAAA,CAAI,EAAA;EAIJ,SAAA,CAAA;;;;;;;EAIA,MAAA,CAAA;EAIA,IAAA,CAAK,EAAA,UAAY,IAAA;EAIjB,QAAA,CAAA;AAAA"}

package/dist/store/in-memory.collection.js

@@ -0,0 +1,65 @@
+//#region src/store/in-memory.collection.ts
+function now() {
+	if (typeof process === "object" && typeof process.hrtime === "function") return process.hrtime.bigint() / BigInt(1e3);
+	return BigInt(Date.now() * 1e3);
+}
+var Collection = class Collection {
+	constructor(data = /* @__PURE__ */ new Map()) {
+		this.data = data;
+	}
+	clear() {
+		this.data.clear();
+	}
+	getLatestSnapshot(id) {
+		return [...this.data.values()].filter((d) => d.data.id === id).sort((a, b) => b.savedAt > a.savedAt ? 1 : -1)[0]?.data;
+	}
+	clone() {
+		const clone = /* @__PURE__ */ new Map();
+		for (const [key, value] of this.data) clone.set(key, value);
+		return new Collection(clone);
+	}
+	merge(other) {
+		const merge = /* @__PURE__ */ new Map();
+		for (const [key, value] of this.data) merge.set(key, value);
+		for (const [key, value] of other.data) merge.set(key, value);
+		return new Collection(merge);
+	}
+	delete(id) {
+		this.data.delete(id);
+	}
+	getRaw(id) {
+		return this.data.get(id);
+	}
+	countAll() {
+		return this.data.size;
+	}
+	get(id) {
+		return this.data.get(id)?.data;
+	}
+	getAllRaw() {
+		return [...this.data.entries()].map(([id, data]) => ({
+			id,
+			data
+		}));
+	}
+	getAll() {
+		return [...this.data.entries()].map(([id, data]) => data.data);
+	}
+	save(id, data) {
+		this.data.set(id, {
+			savedAt: now(),
+			data
+		});
+	}
+	toPretty() {
+		return [...this.data.entries()].map(([id, data]) => `\t\t"${id}": ${JSON.stringify(data.data, replaceBigInt)}`).join(",\n");
+	}
+};
+function replaceBigInt(key, value) {
+	if (typeof value === "bigint") return value.toString();
+	return value;
+}
+
+//#endregion
+export { Collection };
+//# sourceMappingURL=in-memory.collection.js.map

package/dist/store/in-memory.collection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.collection.js","names":[],"sources":["../../src/store/in-memory.collection.ts"],"sourcesContent":["function now() {\n  if (typeof process === \"object\" && typeof process.hrtime === \"function\") {\n    return process.hrtime.bigint() / BigInt(1000);\n  }\n  return BigInt(Date.now() * 1_000);\n}\n\nexport class Collection {\n  constructor(\n    private data: Map<string, { savedAt: bigint; data: any }> = new Map(),\n  ) {}\n\n  clear() {\n    this.data.clear();\n  }\n\n  getLatestSnapshot(id: string) {\n    const data = [...this.data.values()];\n    const sameId = data.filter((d) => d.data.id === id);\n    const sorted = sameId.sort((a, b) => (b.savedAt > a.savedAt ? 1 : -1));\n    return sorted[0]?.data;\n  }\n\n  clone() {\n    const clone = new Map();\n    for (const [key, value] of this.data) {\n      clone.set(key, value);\n    }\n    return new Collection(clone);\n  }\n\n  merge(other: Collection) {\n    const merge = new Map();\n    for (const [key, value] of this.data) {\n      merge.set(key, value);\n    }\n    for (const [key, value] of other.data) {\n      merge.set(key, value);\n    }\n    return new Collection(merge);\n  }\n\n  delete(id: string): void {\n    this.data.delete(id);\n  }\n\n  getRaw(id: string) {\n    return this.data.get(id);\n  }\n\n  countAll() {\n    return this.data.size;\n  }\n\n  get(id: string): any {\n    return this.data.get(id)?.data;\n  }\n\n  getAllRaw() {\n    return [...this.data.entries()].map(([id, data]) => ({ id, data }));\n  }\n\n  getAll(): any[] {\n    return [...this.data.entries()].map(([id, data]) => data.data);\n  }\n\n  save(id: string, data: any): void {\n    this.data.set(id, { savedAt: now(), data });\n  }\n\n  toPretty() {\n    return [...this.data.entries()]\n      .map(\n        ([id, data]) =>\n          `\\t\\t\"${id}\": ${JSON.stringify(data.data, replaceBigInt)}`,\n      )\n      .join(\",\\n\");\n  }\n}\n\nfunction replaceBigInt(key: string, value: any) {\n  if (typeof value === \"bigint\") {\n    return value.toString();\n  }\n  return value;\n}\n"],"mappings":";AAAA,SAAS,MAAM;AACb,KAAI,OAAO,YAAY,YAAY,OAAO,QAAQ,WAAW,WAC3D,QAAO,QAAQ,OAAO,QAAQ,GAAG,OAAO,IAAK;AAE/C,QAAO,OAAO,KAAK,KAAK,GAAG,IAAM;;AAGnC,IAAa,aAAb,MAAa,WAAW;CACtB,YACE,AAAQ,uBAAoD,IAAI,KAAK,EACrE;EADQ;;CAGV,QAAQ;AACN,OAAK,KAAK,OAAO;;CAGnB,kBAAkB,IAAY;AAI5B,SAHa,CAAC,GAAG,KAAK,KAAK,QAAQ,CAAC,CAChB,QAAQ,MAAM,EAAE,KAAK,OAAO,GAAG,CAC7B,MAAM,GAAG,MAAO,EAAE,UAAU,EAAE,UAAU,IAAI,GAAI,CACxD,IAAI;;CAGpB,QAAQ;EACN,MAAM,wBAAQ,IAAI,KAAK;AACvB,OAAK,MAAM,CAAC,KAAK,UAAU,KAAK,KAC9B,OAAM,IAAI,KAAK,MAAM;AAEvB,SAAO,IAAI,WAAW,MAAM;;CAG9B,MAAM,OAAmB;EACvB,MAAM,wBAAQ,IAAI,KAAK;AACvB,OAAK,MAAM,CAAC,KAAK,UAAU,KAAK,KAC9B,OAAM,IAAI,KAAK,MAAM;AAEvB,OAAK,MAAM,CAAC,KAAK,UAAU,MAAM,KAC/B,OAAM,IAAI,KAAK,MAAM;AAEvB,SAAO,IAAI,WAAW,MAAM;;CAG9B,OAAO,IAAkB;AACvB,OAAK,KAAK,OAAO,GAAG;;CAGtB,OAAO,IAAY;AACjB,SAAO,KAAK,KAAK,IAAI,GAAG;;CAG1B,WAAW;AACT,SAAO,KAAK,KAAK;;CAGnB,IAAI,IAAiB;AACnB,SAAO,KAAK,KAAK,IAAI,GAAG,EAAE;;CAG5B,YAAY;AACV,SAAO,CAAC,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,KAAK,CAAC,IAAI,WAAW;GAAE;GAAI;GAAM,EAAE;;CAGrE,SAAgB;AACd,SAAO,CAAC,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,KAAK,CAAC,IAAI,UAAU,KAAK,KAAK;;CAGhE,KAAK,IAAY,MAAiB;AAChC,OAAK,KAAK,IAAI,IAAI;GAAE,SAAS,KAAK;GAAE;GAAM,CAAC;;CAG7C,WAAW;AACT,SAAO,CAAC,GAAG,KAAK,KAAK,SAAS,CAAC,CAC5B,KACE,CAAC,IAAI,UACJ,QAAQ,GAAG,KAAK,KAAK,UAAU,KAAK,MAAM,cAAc,GAC3D,CACA,KAAK,MAAM;;;AAIlB,SAAS,cAAc,KAAa,OAAY;AAC9C,KAAI,OAAO,UAAU,SACnB,QAAO,MAAM,UAAU;AAEzB,QAAO"}

package/dist/store/in-memory.database.d.ts

@@ -0,0 +1,71 @@
+import { Storage } from "./in-memory.storage.js";
+import { InMemoryTransaction } from "../in-memory.transaction.js";
+import "../index.js";
+import { ConcurrencyError } from "@ddd-ts/core";
+
+//#region src/store/in-memory.database.d.ts
+declare class CannotReadAfterWrites extends Error {
+  constructor();
+}
+declare class TransactionCollidedTooManyTimes extends Error {
+  constructor(tries: number);
+}
+type ReadOperation = {
+  type: "read";
+  collectionName: string;
+  id: string;
+  savedAt: bigint | undefined;
+};
+type WriteOperation = {
+  type: "write";
+  collectionName: string;
+  id: string;
+  data: any;
+};
+type CreateOperation = {
+  type: "create";
+  collectionName: string;
+  id: string;
+  data: any;
+};
+type DeleteOperation = {
+  type: "delete";
+  collectionName: string;
+  id: string;
+  savedAt: bigint | undefined;
+};
+type TransactionOperation = ReadOperation | WriteOperation | DeleteOperation | CreateOperation;
+declare class InMemoryUnderlyingTransaction {
+  readonly operations: TransactionOperation[];
+  readonly id: string;
+  private ensureNoWrites;
+  markRead(collectionName: string, id: string, savedAt: bigint | undefined): void;
+  markWritten(collectionName: string, id: any, data: any): void;
+  markCreated(collectionName: string, id: any, data: any): void;
+  markDeleted(collectionName: string, id: any, savedAt: bigint | undefined): void;
+  checkConsistency(storage: Storage): boolean;
+}
+declare class InMemoryDatabase {
+  storage: Storage;
+  clear(collectionName: string): void;
+  load(collectionName: string, id: string, trx?: InMemoryUnderlyingTransaction): any;
+  delete(collectionName: string, id: string, trx?: InMemoryUnderlyingTransaction): void;
+  countAll(collectionName: string): number;
+  loadAll(collectionName: string): {
+    id: string;
+    data: {
+      savedAt: bigint;
+      data: any;
+    };
+  }[];
+  loadLatestSnapshot(id: string): any;
+  save(collectionName: string, id: string, data: any, trx?: InMemoryUnderlyingTransaction): void;
+  create(collectionName: string, id: string, data: any, trx?: InMemoryUnderlyingTransaction): void;
+  private static transactionTries;
+  transactionally(fn: (trx: InMemoryTransaction) => any): Promise<any>;
+  private streamId;
+  print(): void;
+}
+//#endregion
+export { CannotReadAfterWrites, InMemoryDatabase, InMemoryUnderlyingTransaction, TransactionCollidedTooManyTimes };
+//# sourceMappingURL=in-memory.database.d.ts.map

package/dist/store/in-memory.database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.database.d.ts","names":[],"sources":["../../src/store/in-memory.database.ts"],"mappings":";;;;;;cAIa,qBAAA,SAA8B,KAAA;EAAA,WAAA,CAAA;AAAA;AAAA,cAkB9B,+BAAA,SAAwC,KAAA;cACvC,KAAA;AAAA;AAAA,KAKT,aAAA;EACH,IAAA;EACA,cAAA;EACA,EAAA;EACA,OAAA;AAAA;AAAA,KAGG,cAAA;EACH,IAAA;EACA,cAAA;EACA,EAAA;EACA,IAAA;AAAA;AAAA,KAGG,eAAA;EACH,IAAA;EACA,cAAA;EACA,EAAA;EACA,IAAA;AAAA;AAAA,KAGG,eAAA;EACH,IAAA;EACA,cAAA;EACA,EAAA;EACA,OAAA;AAAA;AAAA,KAGG,oBAAA,GACD,aAAA,GACA,cAAA,GACA,eAAA,GACA,eAAA;AAAA,cAES,6BAAA;EAAA,SACK,UAAA,EAAY,oBAAA;EAAA,SAEZ,EAAA;EAAA,QAER,cAAA;EAaD,QAAA,CACL,cAAA,UACA,EAAA,UACA,OAAA;EAMK,WAAA,CAAY,cAAA,UAAwB,EAAA,OAAS,IAAA;EAI7C,WAAA,CAAY,cAAA,UAAwB,EAAA,OAAS,IAAA;EAI7C,WAAA,CACL,cAAA,UACA,EAAA,OACA,OAAA;EAKK,gBAAA,CAAiB,OAAA,EAAS,OAAA;AAAA;AAAA,cA6BtB,gBAAA;EACJ,OAAA,EAAO,OAAA;EAEd,KAAA,CAAM,cAAA;EAIN,IAAA,CACE,cAAA,UACA,EAAA,UACA,GAAA,GAAM,6BAAA;EAWR,MAAA,CACE,cAAA,UACA,EAAA,UACA,GAAA,GAAM,6BAAA;EAUR,QAAA,CAAS,cAAA;EAIT,OAAA,CAAQ,cAAA;;;;;;;EAIR,kBAAA,CAAmB,EAAA;EAInB,IAAA,CACE,cAAA,UACA,EAAA,UACA,IAAA,OACA,GAAA,GAAM,6BAAA;EASR,MAAA,CACE,cAAA,UACA,EAAA,UACA,IAAA,OACA,GAAA,GAAM,6BAAA;EAAA,eAYO,gBAAA;EAET,eAAA,CAAgB,EAAA,GAAK,GAAA,EAAK,mBAAA,WAA2B,OAAA;EAAA,QA2BnD,QAAA;EAqBR,KAAA,CAAA;AAAA"}

package/dist/store/in-memory.database.js

@@ -0,0 +1,153 @@
+import { InMemoryTransaction } from "../in-memory.transaction.js";
+import { Storage } from "./in-memory.storage.js";
+import "../index.js";
+import { ConcurrencyError } from "@ddd-ts/core";
+
+//#region src/store/in-memory.database.ts
+var CannotReadAfterWrites = class extends Error {
+	constructor() {
+		super("Cannot read after having written into a transaction");
+	}
+};
+var TransactionCollision = class extends Error {
+	constructor() {
+		super("Transaction has collided with other extern writes");
+	}
+};
+var DocumentAlreadyExists = class extends ConcurrencyError {
+	constructor() {
+		super("Document already exists");
+	}
+};
+var TransactionCollidedTooManyTimes = class extends Error {
+	constructor(tries) {
+		super(`Transaction collided too many times (${tries})`);
+	}
+};
+var InMemoryUnderlyingTransaction = class {
+	operations = [];
+	id = Math.random().toString().substring(2);
+	ensureNoWrites() {
+		if (this.operations.some((operation) => operation.type === "write" || operation.type === "create" || operation.type === "delete")) throw new CannotReadAfterWrites();
+	}
+	markRead(collectionName, id, savedAt) {
+		this.ensureNoWrites();
+		this.operations.push({
+			type: "read",
+			collectionName,
+			id,
+			savedAt
+		});
+	}
+	markWritten(collectionName, id, data) {
+		this.operations.push({
+			type: "write",
+			collectionName,
+			id,
+			data
+		});
+	}
+	markCreated(collectionName, id, data) {
+		this.operations.push({
+			type: "create",
+			collectionName,
+			id,
+			data
+		});
+	}
+	markDeleted(collectionName, id, savedAt) {
+		this.operations.push({
+			type: "delete",
+			collectionName,
+			id,
+			savedAt
+		});
+	}
+	checkConsistency(storage) {
+		for (const operation of this.operations) {
+			if (operation.type === "read") {
+				const collection = storage.getCollection(operation.collectionName);
+				if (!collection) return false;
+				if (operation.savedAt !== collection.getRaw(operation.id)?.savedAt) return false;
+			}
+			if (operation.type === "create") {
+				const collection = storage.getCollection(operation.collectionName);
+				if (collection && collection.getRaw(operation.id)?.savedAt !== void 0) throw new DocumentAlreadyExists();
+			}
+		}
+		return true;
+	}
+};
+var InMemoryDatabase = class InMemoryDatabase {
+	storage = new Storage();
+	clear(collectionName) {
+		this.storage.getCollection(collectionName).clear();
+	}
+	load(collectionName, id, trx) {
+		const collection = this.storage.getCollection(collectionName);
+		const data = collection.get(id);
+		if (trx) {
+			const doc = collection.getRaw(id);
+			trx.markRead(collectionName, id, doc?.savedAt);
+		}
+		return data;
+	}
+	delete(collectionName, id, trx) {
+		if (trx) {
+			const doc = this.storage.getCollection(collectionName).getRaw(id);
+			trx.markDeleted(collectionName, id, doc?.savedAt);
+		} else this.storage.getCollection(collectionName).delete(id);
+	}
+	countAll(collectionName) {
+		return this.storage.getCollection(collectionName).countAll();
+	}
+	loadAll(collectionName) {
+		return this.storage.getCollection(collectionName).getAllRaw();
+	}
+	loadLatestSnapshot(id) {
+		return this.storage.getCollection("snapshots").getLatestSnapshot(id);
+	}
+	save(collectionName, id, data, trx) {
+		if (trx) trx.markWritten(collectionName, id, data);
+		else this.storage.getCollection(collectionName).save(id, data);
+	}
+	create(collectionName, id, data, trx) {
+		if (trx) trx.markCreated(collectionName, id, data);
+		else {
+			if (this.storage.getCollection(collectionName).get(id)) throw new Error(`Document with id ${id} already exists`);
+			this.storage.getCollection(collectionName).save(id, data);
+		}
+	}
+	static transactionTries = 5;
+	async transactionally(fn) {
+		let trx = new InMemoryTransaction(new InMemoryUnderlyingTransaction());
+		let retry = InMemoryDatabase.transactionTries;
+		let latestReturnValue = void 0;
+		while (retry--) try {
+			latestReturnValue = await fn(trx);
+			this.streamId(trx);
+			break;
+		} catch (error) {
+			if (error instanceof TransactionCollision) trx = new InMemoryTransaction(new InMemoryUnderlyingTransaction());
+			else throw error;
+		}
+		if (retry === -1) throw new TransactionCollidedTooManyTimes(InMemoryDatabase.transactionTries);
+		return latestReturnValue;
+	}
+	streamId(trx) {
+		if (!trx.transaction.checkConsistency(this.storage)) throw new TransactionCollision();
+		for (const operation of trx.transaction.operations) {
+			if (operation.type === "read") continue;
+			if (operation.type === "write") this.save(operation.collectionName, operation.id, operation.data);
+			if (operation.type === "delete") this.delete(operation.collectionName, operation.id);
+			if (operation.type === "create") this.create(operation.collectionName, operation.id, operation.data);
+		}
+	}
+	print() {
+		console.log(["Database:", this.storage.toPretty()].join("\n"));
+	}
+};
+
+//#endregion
+export { CannotReadAfterWrites, InMemoryDatabase, InMemoryUnderlyingTransaction, TransactionCollidedTooManyTimes };
+//# sourceMappingURL=in-memory.database.js.map

package/dist/store/in-memory.database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.database.js","names":[],"sources":["../../src/store/in-memory.database.ts"],"sourcesContent":["import { ConcurrencyError } from \"@ddd-ts/core\";\nimport { InMemoryTransaction } from \"..\";\nimport { Storage } from \"./in-memory.storage\";\n\nexport class CannotReadAfterWrites extends Error {\n  constructor() {\n    super(\"Cannot read after having written into a transaction\");\n  }\n}\n\nexport class TransactionCollision extends Error {\n  constructor() {\n    super(\"Transaction has collided with other extern writes\");\n  }\n}\n\nexport class DocumentAlreadyExists extends ConcurrencyError {\n  constructor() {\n    super(\"Document already exists\");\n  }\n}\n\nexport class TransactionCollidedTooManyTimes extends Error {\n  constructor(tries: number) {\n    super(`Transaction collided too many times (${tries})`);\n  }\n}\n\ntype ReadOperation = {\n  type: \"read\";\n  collectionName: string;\n  id: string;\n  savedAt: bigint | undefined;\n};\n\ntype WriteOperation = {\n  type: \"write\";\n  collectionName: string;\n  id: string;\n  data: any;\n};\n\ntype CreateOperation = {\n  type: \"create\";\n  collectionName: string;\n  id: string;\n  data: any;\n};\n\ntype DeleteOperation = {\n  type: \"delete\";\n  collectionName: string;\n  id: string;\n  savedAt: bigint | undefined;\n};\n\ntype TransactionOperation =\n  | ReadOperation\n  | WriteOperation\n  | DeleteOperation\n  | CreateOperation;\n\nexport class InMemoryUnderlyingTransaction {\n  public readonly operations: TransactionOperation[] = [];\n\n  public readonly id = Math.random().toString().substring(2);\n\n  private ensureNoWrites() {\n    if (\n      this.operations.some(\n        (operation) =>\n          operation.type === \"write\" ||\n          operation.type === \"create\" ||\n          operation.type === \"delete\",\n      )\n    ) {\n      throw new CannotReadAfterWrites();\n    }\n  }\n\n  public markRead(\n    collectionName: string,\n    id: string,\n    savedAt: bigint | undefined,\n  ) {\n    this.ensureNoWrites();\n    this.operations.push({ type: \"read\", collectionName, id, savedAt });\n  }\n\n  public markWritten(collectionName: string, id: any, data: any) {\n    this.operations.push({ type: \"write\", collectionName, id, data });\n  }\n\n  public markCreated(collectionName: string, id: any, data: any) {\n    this.operations.push({ type: \"create\", collectionName, id, data });\n  }\n\n  public markDeleted(\n    collectionName: string,\n    id: any,\n    savedAt: bigint | undefined,\n  ) {\n    this.operations.push({ type: \"delete\", collectionName, id, savedAt });\n  }\n\n  public checkConsistency(storage: Storage) {\n    for (const operation of this.operations) {\n      if (operation.type === \"read\") {\n        const collection = storage.getCollection(operation.collectionName);\n\n        if (!collection) {\n          return false;\n        }\n\n        if (operation.savedAt !== collection.getRaw(operation.id)?.savedAt) {\n          return false;\n        }\n      }\n\n      if (operation.type === \"create\") {\n        const collection = storage.getCollection(operation.collectionName);\n\n        if (\n          collection &&\n          collection.getRaw(operation.id)?.savedAt !== undefined\n        ) {\n          throw new DocumentAlreadyExists();\n        }\n      }\n    }\n    return true;\n  }\n}\n\nexport class InMemoryDatabase {\n  public storage = new Storage();\n\n  clear(collectionName: string) {\n    this.storage.getCollection(collectionName).clear();\n  }\n\n  load(\n    collectionName: string,\n    id: string,\n    trx?: InMemoryUnderlyingTransaction,\n  ): any {\n    const collection = this.storage.getCollection(collectionName);\n    const data = collection.get(id);\n    if (trx) {\n      const doc = collection.getRaw(id);\n      trx.markRead(collectionName, id, doc?.savedAt);\n    }\n    return data;\n  }\n\n  delete(\n    collectionName: string,\n    id: string,\n    trx?: InMemoryUnderlyingTransaction,\n  ): void {\n    if (trx) {\n      const doc = this.storage.getCollection(collectionName).getRaw(id);\n      trx.markDeleted(collectionName, id, doc?.savedAt);\n    } else {\n      this.storage.getCollection(collectionName).delete(id);\n    }\n  }\n\n  countAll(collectionName: string) {\n    return this.storage.getCollection(collectionName).countAll();\n  }\n\n  loadAll(collectionName: string) {\n    return this.storage.getCollection(collectionName).getAllRaw();\n  }\n\n  loadLatestSnapshot(id: string) {\n    return this.storage.getCollection(\"snapshots\").getLatestSnapshot(id);\n  }\n\n  save(\n    collectionName: string,\n    id: string,\n    data: any,\n    trx?: InMemoryUnderlyingTransaction,\n  ): void {\n    if (trx) {\n      trx.markWritten(collectionName, id, data);\n    } else {\n      this.storage.getCollection(collectionName).save(id, data);\n    }\n  }\n\n  create(\n    collectionName: string,\n    id: string,\n    data: any,\n    trx?: InMemoryUnderlyingTransaction,\n  ): void {\n    if (trx) {\n      trx.markCreated(collectionName, id, data);\n    } else {\n      if (this.storage.getCollection(collectionName).get(id)) {\n        throw new Error(`Document with id ${id} already exists`);\n      }\n      this.storage.getCollection(collectionName).save(id, data);\n    }\n  }\n\n  private static transactionTries = 5;\n\n  async transactionally(fn: (trx: InMemoryTransaction) => any) {\n    let trx = new InMemoryTransaction(new InMemoryUnderlyingTransaction());\n    let retry = InMemoryDatabase.transactionTries;\n    let latestReturnValue = undefined;\n    while (retry--) {\n      try {\n        latestReturnValue = await fn(trx);\n        this.streamId(trx);\n        break;\n      } catch (error) {\n        if (error instanceof TransactionCollision) {\n          trx = new InMemoryTransaction(new InMemoryUnderlyingTransaction());\n        } else {\n          throw error;\n        }\n      }\n    }\n\n    if (retry === -1) {\n      throw new TransactionCollidedTooManyTimes(\n        InMemoryDatabase.transactionTries,\n      );\n    }\n\n    return latestReturnValue;\n  }\n\n  private streamId(trx: InMemoryTransaction) {\n    if (!trx.transaction.checkConsistency(this.storage)) {\n      throw new TransactionCollision();\n    }\n\n    for (const operation of trx.transaction.operations) {\n      if (operation.type === \"read\") {\n        continue;\n      }\n      if (operation.type === \"write\") {\n        this.save(operation.collectionName, operation.id, operation.data);\n      }\n      if (operation.type === \"delete\") {\n        this.delete(operation.collectionName, operation.id);\n      }\n      if (operation.type === \"create\") {\n        this.create(operation.collectionName, operation.id, operation.data);\n      }\n    }\n  }\n\n  print() {\n    console.log([\"Database:\", this.storage.toPretty()].join(\"\\n\"));\n  }\n}\n"],"mappings":"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"}

package/dist/store/in-memory.storage.d.ts

@@ -0,0 +1,14 @@
+import { Collection } from "./in-memory.collection.js";
+
+//#region src/store/in-memory.storage.d.ts
+declare class Storage {
+  collections: Map<string, Collection>;
+  constructor(collections?: Map<string, Collection>);
+  clone(): Storage;
+  merge(other: Storage): Storage;
+  getCollection(collectionName: string): Collection;
+  toPretty(): string;
+}
+//#endregion
+export { Storage };
+//# sourceMappingURL=in-memory.storage.d.ts.map

package/dist/store/in-memory.storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.storage.d.ts","names":[],"sources":["../../src/store/in-memory.storage.ts"],"mappings":";;;cAEa,OAAA;EACQ,WAAA,EAAa,GAAA,SAAY,UAAA;cAAzB,WAAA,GAAa,GAAA,SAAY,UAAA;EAE5C,KAAA,CAAA,GAAK,OAAA;EASL,KAAA,CAAM,KAAA,EAAO,OAAA,GAAO,OAAA;EAWpB,aAAA,CAAc,cAAA,WAAyB,UAAA;EAMvC,QAAA,CAAA;AAAA"}

package/dist/store/in-memory.storage.js

@@ -0,0 +1,32 @@
+import { Collection } from "./in-memory.collection.js";
+
+//#region src/store/in-memory.storage.ts
+var Storage = class Storage {
+	constructor(collections = /* @__PURE__ */ new Map()) {
+		this.collections = collections;
+	}
+	clone() {
+		const clone = /* @__PURE__ */ new Map();
+		for (const [collectionName, collection] of this.collections) clone.set(collectionName, collection.clone());
+		return new Storage(clone);
+	}
+	merge(other) {
+		const collections = /* @__PURE__ */ new Map();
+		for (const [collectionName, collection] of other.collections) collections.set(collectionName, this.getCollection(collectionName).merge(collection));
+		return new Storage(collections);
+	}
+	getCollection(collectionName) {
+		const collection = this.collections.get(collectionName) || new Collection();
+		this.collections.set(collectionName, collection);
+		return collection;
+	}
+	toPretty() {
+		return [...this.collections.entries()].map(([collectionName, collection]) => {
+			return [`Collection: "${collectionName}"`, collection.toPretty()].join("\n");
+		}).join("\n");
+	}
+};
+
+//#endregion
+export { Storage };
+//# sourceMappingURL=in-memory.storage.js.map

package/dist/store/in-memory.storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.storage.js","names":[],"sources":["../../src/store/in-memory.storage.ts"],"sourcesContent":["import { Collection } from \"./in-memory.collection\";\n\nexport class Storage {\n  constructor(public collections: Map<string, Collection> = new Map()) {}\n\n  clone() {\n    const clone = new Map<string, Collection>();\n    for (const [collectionName, collection] of this.collections) {\n      clone.set(collectionName, collection.clone());\n    }\n\n    return new Storage(clone);\n  }\n\n  merge(other: Storage) {\n    const collections = new Map<string, Collection>();\n    for (const [collectionName, collection] of other.collections) {\n      collections.set(\n        collectionName,\n        this.getCollection(collectionName).merge(collection),\n      );\n    }\n    return new Storage(collections);\n  }\n\n  getCollection(collectionName: string): Collection {\n    const collection = this.collections.get(collectionName) || new Collection();\n    this.collections.set(collectionName, collection);\n    return collection;\n  }\n\n  toPretty() {\n    return [...this.collections.entries()]\n      .map(([collectionName, collection]) => {\n        return [`Collection: \"${collectionName}\"`, collection.toPretty()].join(\n          \"\\n\",\n        );\n      })\n      .join(\"\\n\");\n  }\n}\n"],"mappings":";;;AAEA,IAAa,UAAb,MAAa,QAAQ;CACnB,YAAY,AAAO,8BAAuC,IAAI,KAAK,EAAE;EAAlD;;CAEnB,QAAQ;EACN,MAAM,wBAAQ,IAAI,KAAyB;AAC3C,OAAK,MAAM,CAAC,gBAAgB,eAAe,KAAK,YAC9C,OAAM,IAAI,gBAAgB,WAAW,OAAO,CAAC;AAG/C,SAAO,IAAI,QAAQ,MAAM;;CAG3B,MAAM,OAAgB;EACpB,MAAM,8BAAc,IAAI,KAAyB;AACjD,OAAK,MAAM,CAAC,gBAAgB,eAAe,MAAM,YAC/C,aAAY,IACV,gBACA,KAAK,cAAc,eAAe,CAAC,MAAM,WAAW,CACrD;AAEH,SAAO,IAAI,QAAQ,YAAY;;CAGjC,cAAc,gBAAoC;EAChD,MAAM,aAAa,KAAK,YAAY,IAAI,eAAe,IAAI,IAAI,YAAY;AAC3E,OAAK,YAAY,IAAI,gBAAgB,WAAW;AAChD,SAAO;;CAGT,WAAW;AACT,SAAO,CAAC,GAAG,KAAK,YAAY,SAAS,CAAC,CACnC,KAAK,CAAC,gBAAgB,gBAAgB;AACrC,UAAO,CAAC,gBAAgB,eAAe,IAAI,WAAW,UAAU,CAAC,CAAC,KAChE,KACD;IACD,CACD,KAAK,KAAK"}

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

@@ -0,0 +1,30 @@
+import { InMemoryDatabase } from "./in-memory.database.js";
+import { InMemoryTransaction } from "../in-memory.transaction.js";
+import { IIdentifiable, ISerializer, Store } from "@ddd-ts/core";
+
+//#region src/store/in-memory.store.d.ts
+/**
+ * This in memory store is a copy store. It stores a copy of the actual model.
+ * It is the recommended inmemory store to use, as it reflects more closely the behaviour of a real store.
+ */
+declare class InMemoryStore<M extends IIdentifiable> implements Store<M> {
+  readonly collection: string;
+  readonly database: InMemoryDatabase;
+  readonly serializer: ISerializer<M>;
+  readonly $name?: string | undefined;
+  constructor(collection: string, database: InMemoryDatabase, serializer: ISerializer<M>, $name?: string | undefined);
+  filter(predicate: (model: M) => boolean, trx?: InMemoryTransaction): Promise<M[]>;
+  clear(): void;
+  create(model: M, trx?: InMemoryTransaction): Promise<void>;
+  save(model: M, trx?: InMemoryTransaction): Promise<void>;
+  saveAll(models: M[], trx?: InMemoryTransaction): Promise<void>;
+  load(id: M["id"], trx?: InMemoryTransaction): Promise<M | undefined>;
+  loadAll(trx?: InMemoryTransaction): Promise<M[]>;
+  loadMany(ids: M["id"][], trx?: InMemoryTransaction): Promise<M[]>;
+  delete(id: M["id"], trx?: InMemoryTransaction): Promise<void>;
+  countAll(): Promise<number>;
+  streamAll(): AsyncIterable<M>;
+}
+//#endregion
+export { InMemoryStore };
+//# sourceMappingURL=in-memory.store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.store.d.ts","names":[],"sources":["../../src/store/in-memory.store.ts"],"mappings":";;;;;;;AAOA;;cAAa,aAAA,WAAwB,aAAA,aAA0B,KAAA,CAAM,CAAA;EAAA,SAEjD,UAAA;EAAA,SACA,QAAA,EAAU,gBAAA;EAAA,SACV,UAAA,EAAY,WAAA,CAAY,CAAA;EAAA,SACxB,KAAA;cAHA,UAAA,UACA,QAAA,EAAU,gBAAA,EACV,UAAA,EAAY,WAAA,CAAY,CAAA,GACxB,KAAA;EAGZ,MAAA,CACJ,SAAA,GAAY,KAAA,EAAO,CAAA,cACnB,GAAA,GAAM,mBAAA,GACL,OAAA,CAAQ,CAAA;EAiBX,KAAA,CAAA;EAIM,MAAA,CAAO,KAAA,EAAO,CAAA,EAAG,GAAA,GAAM,mBAAA,GAAsB,OAAA;EAU7C,IAAA,CAAK,KAAA,EAAO,CAAA,EAAG,GAAA,GAAM,mBAAA,GAAsB,OAAA;EAU3C,OAAA,CAAQ,MAAA,EAAQ,CAAA,IAAK,GAAA,GAAM,mBAAA,GAAsB,OAAA;EAIjD,IAAA,CAAK,EAAA,EAAI,CAAA,QAAS,GAAA,GAAM,mBAAA,GAAsB,OAAA,CAAQ,CAAA;EAiB5D,OAAA,CAAQ,GAAA,GAAM,mBAAA,GAAsB,OAAA,CAAQ,CAAA;EActC,QAAA,CAAS,GAAA,EAAK,CAAA,UAAW,GAAA,GAAM,mBAAA,GAAsB,OAAA,CAAQ,CAAA;EAK7D,MAAA,CAAO,EAAA,EAAI,CAAA,QAAS,GAAA,GAAM,mBAAA,GAAsB,OAAA;EAIhD,QAAA,CAAA,GAAQ,OAAA;EAIP,SAAA,CAAA,GAAa,aAAA,CAAc,CAAA;AAAA"}

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

@@ -0,0 +1,78 @@
+//#region src/store/in-memory.store.ts
+/**
+* This in memory store is a copy store. It stores a copy of the actual model.
+* It is the recommended inmemory store to use, as it reflects more closely the behaviour of a real store.
+*/
+var InMemoryStore = class {
+	constructor(collection, database, serializer, $name) {
+		this.collection = collection;
+		this.database = database;
+		this.serializer = serializer;
+		this.$name = $name;
+	}
+	async filter(predicate, trx) {
+		return (await Promise.all(this.database.loadAll(this.collection).map(async (e) => {
+			const deserialized = await this.serializer.deserialize({
+				...this.$name ? { $name: this.$name } : {},
+				...e.data.data
+			});
+			if (!predicate(deserialized)) return;
+			trx?.transaction.markRead(this.collection, e.id, e.data.savedAt);
+			return deserialized;
+		}))).filter((e) => Boolean(e));
+	}
+	clear() {
+		this.database.clear(this.collection);
+	}
+	async create(model, trx) {
+		const serialized = await this.serializer.serialize(model);
+		await this.database.create(this.collection, model.id.serialize(), {
+			...this.$name ? { $name: this.$name } : {},
+			...serialized
+		}, trx?.transaction);
+	}
+	async save(model, trx) {
+		const serialized = await this.serializer.serialize(model);
+		await this.database.save(this.collection, model.id.serialize(), {
+			...this.$name ? { $name: this.$name } : {},
+			...serialized
+		}, trx?.transaction);
+	}
+	async saveAll(models, trx) {
+		await Promise.all(models.map((m) => this.save(m, trx)));
+	}
+	async load(id, trx) {
+		const serialized = await this.database.load(this.collection, id.serialize(), trx?.transaction);
+		if (!serialized) return;
+		return this.serializer.deserialize({
+			...this.$name ? { $name: this.$name } : {},
+			...serialized
+		});
+	}
+	loadAll(trx) {
+		const serialized = this.database.loadAll(this.collection);
+		return Promise.all(serialized.map(async (s) => {
+			trx?.transaction.markRead(this.collection, s.id, s.data.savedAt);
+			return this.serializer.deserialize({
+				...this.$name ? { $name: this.$name } : {},
+				...s.data.data
+			});
+		}));
+	}
+	async loadMany(ids, trx) {
+		return (await Promise.all(ids.map((id) => this.load(id, trx)))).filter((m) => m !== void 0);
+	}
+	async delete(id, trx) {
+		this.database.delete(this.collection, id.serialize(), trx?.transaction);
+	}
+	async countAll() {
+		return this.database.countAll(this.collection);
+	}
+	async *streamAll() {
+		for (const item of await this.filter(() => true)) yield item;
+	}
+};
+
+//#endregion
+export { InMemoryStore };
+//# sourceMappingURL=in-memory.store.js.map

package/dist/store/in-memory.store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.store.js","names":[],"sources":["../../src/store/in-memory.store.ts"],"sourcesContent":["import { ISerializer, Store, type IIdentifiable } from \"@ddd-ts/core\";\nimport { InMemoryDatabase } from \"./in-memory.database\";\nimport { InMemoryTransaction } from \"../in-memory.transaction\";\n/**\n * This in memory store is a copy store. It stores a copy of the actual model.\n * It is the recommended inmemory store to use, as it reflects more closely the behaviour of a real store.\n */\nexport class InMemoryStore<M extends IIdentifiable> implements Store<M> {\n  constructor(\n    public readonly collection: string,\n    public readonly database: InMemoryDatabase,\n    public readonly serializer: ISerializer<M>,\n    public readonly $name?: string,\n  ) {}\n\n  async filter(\n    predicate: (model: M) => boolean,\n    trx?: InMemoryTransaction,\n  ): Promise<M[]> {\n    const filtered = await Promise.all(\n      this.database.loadAll(this.collection).map(async (e) => {\n        const deserialized = await this.serializer.deserialize({\n          ...(this.$name ? { $name: this.$name } : {}),\n          ...e.data.data,\n        });\n        if (!predicate(deserialized)) {\n          return undefined;\n        }\n        trx?.transaction.markRead(this.collection, e.id, e.data.savedAt);\n        return deserialized;\n      }),\n    );\n    return filtered.filter((e): e is NonNullable<typeof e> => Boolean(e));\n  }\n\n  clear() {\n    this.database.clear(this.collection);\n  }\n\n  async create(model: M, trx?: InMemoryTransaction): Promise<void> {\n    const serialized = await this.serializer.serialize(model);\n    await this.database.create(\n      this.collection,\n      model.id.serialize(),\n      { ...(this.$name ? { $name: this.$name } : {}), ...serialized },\n      trx?.transaction,\n    );\n  }\n\n  async save(model: M, trx?: InMemoryTransaction): Promise<void> {\n    const serialized = await this.serializer.serialize(model);\n    await this.database.save(\n      this.collection,\n      model.id.serialize(),\n      { ...(this.$name ? { $name: this.$name } : {}), ...serialized },\n      trx?.transaction,\n    );\n  }\n\n  async saveAll(models: M[], trx?: InMemoryTransaction): Promise<void> {\n    await Promise.all(models.map((m) => this.save(m, trx)));\n  }\n\n  async load(id: M[\"id\"], trx?: InMemoryTransaction): Promise<M | undefined> {\n    const serialized = await this.database.load(\n      this.collection,\n      id.serialize(),\n      trx?.transaction,\n    );\n\n    if (!serialized) {\n      return undefined;\n    }\n\n    return this.serializer.deserialize({\n      ...(this.$name ? { $name: this.$name } : {}),\n      ...serialized,\n    });\n  }\n\n  loadAll(trx?: InMemoryTransaction): Promise<M[]> {\n    const serialized = this.database.loadAll(this.collection);\n\n    return Promise.all(\n      serialized.map(async (s) => {\n        trx?.transaction.markRead(this.collection, s.id, s.data.savedAt);\n        return this.serializer.deserialize({\n          ...(this.$name ? { $name: this.$name } : {}),\n          ...s.data.data,\n        });\n      }),\n    );\n  }\n\n  async loadMany(ids: M[\"id\"][], trx?: InMemoryTransaction): Promise<M[]> {\n    const result = await Promise.all(ids.map((id) => this.load(id, trx)));\n    return result.filter((m) => m !== undefined) as M[];\n  }\n\n  async delete(id: M[\"id\"], trx?: InMemoryTransaction): Promise<void> {\n    this.database.delete(this.collection, id.serialize(), trx?.transaction);\n  }\n\n  async countAll() {\n    return this.database.countAll(this.collection);\n  }\n\n  async *streamAll(): AsyncIterable<M> {\n    for (const item of await this.filter(() => true)) {\n      yield item;\n    }\n  }\n}\n"],"mappings":";;;;;AAOA,IAAa,gBAAb,MAAwE;CACtE,YACE,AAAgB,YAChB,AAAgB,UAChB,AAAgB,YAChB,AAAgB,OAChB;EAJgB;EACA;EACA;EACA;;CAGlB,MAAM,OACJ,WACA,KACc;AAcd,UAbiB,MAAM,QAAQ,IAC7B,KAAK,SAAS,QAAQ,KAAK,WAAW,CAAC,IAAI,OAAO,MAAM;GACtD,MAAM,eAAe,MAAM,KAAK,WAAW,YAAY;IACrD,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,OAAO,GAAG,EAAE;IAC3C,GAAG,EAAE,KAAK;IACX,CAAC;AACF,OAAI,CAAC,UAAU,aAAa,CAC1B;AAEF,QAAK,YAAY,SAAS,KAAK,YAAY,EAAE,IAAI,EAAE,KAAK,QAAQ;AAChE,UAAO;IACP,CACH,EACe,QAAQ,MAAkC,QAAQ,EAAE,CAAC;;CAGvE,QAAQ;AACN,OAAK,SAAS,MAAM,KAAK,WAAW;;CAGtC,MAAM,OAAO,OAAU,KAA0C;EAC/D,MAAM,aAAa,MAAM,KAAK,WAAW,UAAU,MAAM;AACzD,QAAM,KAAK,SAAS,OAClB,KAAK,YACL,MAAM,GAAG,WAAW,EACpB;GAAE,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,OAAO,GAAG,EAAE;GAAG,GAAG;GAAY,EAC/D,KAAK,YACN;;CAGH,MAAM,KAAK,OAAU,KAA0C;EAC7D,MAAM,aAAa,MAAM,KAAK,WAAW,UAAU,MAAM;AACzD,QAAM,KAAK,SAAS,KAClB,KAAK,YACL,MAAM,GAAG,WAAW,EACpB;GAAE,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,OAAO,GAAG,EAAE;GAAG,GAAG;GAAY,EAC/D,KAAK,YACN;;CAGH,MAAM,QAAQ,QAAa,KAA0C;AACnE,QAAM,QAAQ,IAAI,OAAO,KAAK,MAAM,KAAK,KAAK,GAAG,IAAI,CAAC,CAAC;;CAGzD,MAAM,KAAK,IAAa,KAAmD;EACzE,MAAM,aAAa,MAAM,KAAK,SAAS,KACrC,KAAK,YACL,GAAG,WAAW,EACd,KAAK,YACN;AAED,MAAI,CAAC,WACH;AAGF,SAAO,KAAK,WAAW,YAAY;GACjC,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,OAAO,GAAG,EAAE;GAC3C,GAAG;GACJ,CAAC;;CAGJ,QAAQ,KAAyC;EAC/C,MAAM,aAAa,KAAK,SAAS,QAAQ,KAAK,WAAW;AAEzD,SAAO,QAAQ,IACb,WAAW,IAAI,OAAO,MAAM;AAC1B,QAAK,YAAY,SAAS,KAAK,YAAY,EAAE,IAAI,EAAE,KAAK,QAAQ;AAChE,UAAO,KAAK,WAAW,YAAY;IACjC,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,OAAO,GAAG,EAAE;IAC3C,GAAG,EAAE,KAAK;IACX,CAAC;IACF,CACH;;CAGH,MAAM,SAAS,KAAgB,KAAyC;AAEtE,UADe,MAAM,QAAQ,IAAI,IAAI,KAAK,OAAO,KAAK,KAAK,IAAI,IAAI,CAAC,CAAC,EACvD,QAAQ,MAAM,MAAM,OAAU;;CAG9C,MAAM,OAAO,IAAa,KAA0C;AAClE,OAAK,SAAS,OAAO,KAAK,YAAY,GAAG,WAAW,EAAE,KAAK,YAAY;;CAGzE,MAAM,WAAW;AACf,SAAO,KAAK,SAAS,SAAS,KAAK,WAAW;;CAGhD,OAAO,YAA8B;AACnC,OAAK,MAAM,QAAQ,MAAM,KAAK,aAAa,KAAK,CAC9C,OAAM"}

package/package.json

@@ -1,20 +1,23 @@
 {
 	"name": "@ddd-ts/store-inmemory",
-	"version": "0.0.0-compute-timeout-on-process.2",
+	"version": "0.0.0-compute-timeout-on-process.4",
 	"types": "dist/index.d.ts",
 	"license": "MIT",
 	"repository": {
 		"url": "git+https://github.com/ddd-ts/monorepo"
 	},
+	"files": [
+		"dist"
+	],
 	"scripts": {
 		"build": "tsdown --config node_modules/@ddd-ts/tools/tsdown.config.js"
 	},
 	"dependencies": {
-		"@ddd-ts/core": "0.0.0-compute-timeout-on-process.2"
+		"@ddd-ts/core": "0.0.0-compute-timeout-on-process.4"
 	},
 	"devDependencies": {
-		"@ddd-ts/tools": "0.0.0-compute-timeout-on-process.2",
-		"@ddd-ts/types": "0.0.0-compute-timeout-on-process.2",
+		"@ddd-ts/tools": "0.0.0-compute-timeout-on-process.4",
+		"@ddd-ts/types": "0.0.0-compute-timeout-on-process.4",
 		"@types/jest": "^29.5.1",
 		"@types/node": "^20.12.4"
 	},