@ddd-ts/store-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.transaction.d.ts

@@ -0,0 +1,18 @@
+import { TransactionPerformer } from "@ddd-ts/core";
+import { InMemoryDatabase, InMemoryUnderlyingTransaction } from "./store/in-memory.database";
+export declare class InMemoryTransaction {
+    readonly transaction: InMemoryUnderlyingTransaction;
+    commitListeners: (() => void)[];
+    constructor(transaction: InMemoryUnderlyingTransaction);
+    counter: number;
+    increment(): number;
+    onCommit(callback: () => void): void;
+    executeCommitListeners(): Promise<void>;
+}
+export declare class InMemoryTransactionPerformer extends TransactionPerformer<InMemoryTransaction> {
+    constructor(db: InMemoryDatabase);
+}
+export declare class FakeInMemoryTransactionPerformer extends TransactionPerformer<InMemoryTransaction> {
+    constructor();
+}
+//# 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","sourceRoot":"","sources":["../src/in-memory.transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EACL,gBAAgB,EAChB,6BAA6B,EAC9B,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,mBAAmB;aAGF,WAAW,EAAE,6BAA6B;IAFtE,eAAe,EAAE,CAAC,MAAM,IAAI,CAAC,EAAE,CAAM;gBAET,WAAW,EAAE,6BAA6B;IAEtE,OAAO,SAAM;IAEb,SAAS;IAKT,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI;IAIvB,sBAAsB;CAG7B;AAED,qBAAa,4BAA6B,SAAQ,oBAAoB,CAAC,mBAAmB,CAAC;gBAC7E,EAAE,EAAE,gBAAgB;CAGjC;AAED,qBAAa,gCAAiC,SAAQ,oBAAoB,CAAC,mBAAmB,CAAC;;CAI9F"}

package/dist/in-memory.transaction.js

@@ -0,0 +1,36 @@
+require('./store/in-memory.database.js');
+let _ddd_ts_core = require("@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 _ddd_ts_core.TransactionPerformer {
+	constructor(db) {
+		super((effect) => db.transactionally((trx) => effect(trx)));
+	}
+};
+var FakeInMemoryTransactionPerformer = class extends _ddd_ts_core.TransactionPerformer {
+	constructor() {
+		super((effect) => effect(new InMemoryTransaction(null)));
+	}
+};
+
+//#endregion
+exports.FakeInMemoryTransactionPerformer = FakeInMemoryTransactionPerformer;
+exports.InMemoryTransaction = InMemoryTransaction;
+exports.InMemoryTransactionPerformer = InMemoryTransactionPerformer;

package/dist/in-memory.transaction.mjs

@@ -0,0 +1,34 @@
+import "./store/in-memory.database.mjs";
+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 };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { InMemoryTransactionPerformer, FakeInMemoryTransactionPerformer, InMemoryTransaction, } from "./in-memory.transaction";
+export { InMemoryDatabase, InMemoryUnderlyingTransaction, CannotReadAfterWrites, TransactionCollidedTooManyTimes, } from "./store/in-memory.database";
+export { InMemoryStore } from "./store/in-memory.store";
+//# 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,EACN,4BAA4B,EAC5B,gCAAgC,EAChC,mBAAmB,GACnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACN,gBAAgB,EAChB,6BAA6B,EAC7B,qBAAqB,EACrB,+BAA+B,GAC/B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_in_memory_database = require('./store/in-memory.database.js');
+const require_in_memory_transaction = require('./in-memory.transaction.js');
+const require_in_memory_store = require('./store/in-memory.store.js');
+
+exports.CannotReadAfterWrites = require_in_memory_database.CannotReadAfterWrites;
+exports.FakeInMemoryTransactionPerformer = require_in_memory_transaction.FakeInMemoryTransactionPerformer;
+exports.InMemoryDatabase = require_in_memory_database.InMemoryDatabase;
+exports.InMemoryStore = require_in_memory_store.InMemoryStore;
+exports.InMemoryTransaction = require_in_memory_transaction.InMemoryTransaction;
+exports.InMemoryTransactionPerformer = require_in_memory_transaction.InMemoryTransactionPerformer;
+exports.InMemoryUnderlyingTransaction = require_in_memory_database.InMemoryUnderlyingTransaction;
+exports.TransactionCollidedTooManyTimes = require_in_memory_database.TransactionCollidedTooManyTimes;

package/dist/index.mjs

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

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

@@ -0,0 +1,29 @@
+export 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;
+}
+//# 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","sourceRoot":"","sources":["../../src/store/in-memory.collection.ts"],"names":[],"mappings":"AAOA,qBAAa,UAAU;IAEnB,OAAO,CAAC,IAAI;gBAAJ,IAAI,GAAE,GAAG,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,CAAa;IAGvE,KAAK;IAIL,iBAAiB,CAAC,EAAE,EAAE,MAAM;IAO5B,KAAK;IAQL,KAAK,CAAC,KAAK,EAAE,UAAU;IAWvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIxB,MAAM,CAAC,EAAE,EAAE,MAAM;iBArCsB,MAAM;cAAQ,GAAG;;IAyCxD,QAAQ;IAIR,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,GAAG;IAIpB,SAAS;;;qBAjD8B,MAAM;kBAAQ,GAAG;;;IAqDxD,MAAM,IAAI,GAAG,EAAE;IAIf,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAIjC,QAAQ;CAQT"}

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
+exports.Collection = Collection;

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

@@ -0,0 +1,64 @@
+//#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 };

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

@@ -0,0 +1,73 @@
+import { ConcurrencyError } from "@ddd-ts/core";
+import { InMemoryTransaction } from "..";
+import { Storage } from "./in-memory.storage";
+export declare class CannotReadAfterWrites extends Error {
+    constructor();
+}
+export declare class TransactionCollision extends Error {
+    constructor();
+}
+export declare class DocumentAlreadyExists extends ConcurrencyError {
+    constructor();
+}
+export 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;
+export 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;
+}
+export 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;
+}
+export {};
+//# 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","sourceRoot":"","sources":["../../src/store/in-memory.database.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,155 @@
+const require_in_memory_storage = require('./in-memory.storage.js');
+const require_in_memory_transaction = require('../in-memory.transaction.js');
+require('../index.js');
+let _ddd_ts_core = require("@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 _ddd_ts_core.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 require_in_memory_storage.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 require_in_memory_transaction.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 require_in_memory_transaction.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
+exports.CannotReadAfterWrites = CannotReadAfterWrites;
+exports.InMemoryDatabase = InMemoryDatabase;
+exports.InMemoryUnderlyingTransaction = InMemoryUnderlyingTransaction;
+exports.TransactionCollidedTooManyTimes = TransactionCollidedTooManyTimes;

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

@@ -0,0 +1,152 @@
+import { Storage } from "./in-memory.storage.mjs";
+import { InMemoryTransaction } from "../in-memory.transaction.mjs";
+import "../index.mjs";
+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 };

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

@@ -0,0 +1,10 @@
+import { Collection } from "./in-memory.collection";
+export declare class Storage {
+    collections: Map<string, Collection>;
+    constructor(collections?: Map<string, Collection>);
+    clone(): Storage;
+    merge(other: Storage): Storage;
+    getCollection(collectionName: string): Collection;
+    toPretty(): string;
+}
+//# 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","sourceRoot":"","sources":["../../src/store/in-memory.storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,qBAAa,OAAO;IACC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC;gBAApC,WAAW,GAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAa;IAEnE,KAAK;IASL,KAAK,CAAC,KAAK,EAAE,OAAO;IAWpB,aAAa,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU;IAMjD,QAAQ;CAST"}

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

@@ -0,0 +1,31 @@
+const require_in_memory_collection = require('./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 require_in_memory_collection.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
+exports.Storage = Storage;

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

@@ -0,0 +1,31 @@
+import { Collection } from "./in-memory.collection.mjs";
+
+//#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 };

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

@@ -0,0 +1,26 @@
+import type { ISerializer, Store, IIdentifiable } from "@ddd-ts/core";
+import { InMemoryDatabase } from "./in-memory.database";
+import { InMemoryTransaction } from "../in-memory.transaction";
+/**
+ * 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.
+ */
+export 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>;
+}
+//# 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","sourceRoot":"","sources":["../../src/store/in-memory.store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D;;;GAGG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,aAAa,CAAE,YAAW,KAAK,CAAC,CAAC,CAAC;aAEnD,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,gBAAgB;aAC1B,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC;aAC1B,KAAK,CAAC,EAAE,MAAM;gBAHd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC,EAC1B,KAAK,CAAC,EAAE,MAAM,YAAA;IAG1B,MAAM,CACV,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,EAChC,GAAG,CAAC,EAAE,mBAAmB,GACxB,OAAO,CAAC,CAAC,EAAE,CAAC;IAiBf,KAAK;IAIC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAU1D,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAUxD,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9D,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAiB1E,OAAO,CAAC,GAAG,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAc1C,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAKjE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7D,QAAQ;IAIP,SAAS,IAAI,aAAa,CAAC,CAAC,CAAC;CAKrC"}

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

@@ -0,0 +1,80 @@
+require('./in-memory.database.js');
+require('../in-memory.transaction.js');
+
+//#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
+exports.InMemoryStore = InMemoryStore;

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

@@ -0,0 +1,80 @@
+import "./in-memory.database.mjs";
+import "../in-memory.transaction.mjs";
+
+//#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 };

package/package.json

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