@hg-ts/repository 0.5.16 → 0.5.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hg-ts/repository",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -18,13 +18,13 @@
     "test:dev": "vitest watch"
   },
   "devDependencies": {
-    "@hg-ts-config/typescript": "0.5.16",
-    "@hg-ts/domain": "0.5.16",
-    "@hg-ts/events": "0.5.16",
-    "@hg-ts/exception": "0.5.16",
-    "@hg-ts/linter": "0.5.16",
-    "@hg-ts/tests": "0.5.16",
-    "@hg-ts/types": "0.5.16",
+    "@hg-ts-config/typescript": "0.5.18",
+    "@hg-ts/domain": "0.5.18",
+    "@hg-ts/events": "0.5.18",
+    "@hg-ts/exception": "0.5.18",
+    "@hg-ts/linter": "0.5.18",
+    "@hg-ts/tests": "0.5.18",
+    "@hg-ts/types": "0.5.18",
     "@types/node": "22.19.1",
     "@types/uuid": "10.0.0",
     "@vitest/coverage-v8": "4.0.14",
@@ -38,9 +38,9 @@
     "vitest": "4.0.14"
   },
   "peerDependencies": {
-    "@hg-ts/domain": "0.5.16",
-    "@hg-ts/events": "0.5.16",
-    "@hg-ts/exception": "0.5.16",
+    "@hg-ts/domain": "0.5.18",
+    "@hg-ts/events": "0.5.18",
+    "@hg-ts/exception": "0.5.18",
     "reflect-metadata": "*",
     "tslib": "*",
     "uuid": "*",

package/src/exceptions/aggregate-event.already-exists.exception.ts

@@ -0,0 +1,7 @@
+import { AggregateAlreadyExistsException } from './aggregate.already-exists.exception.js';
+
+export class AggregateEventAlreadyExistsException extends AggregateAlreadyExistsException {
+	public constructor(id?: string) {
+		super('DomainEvent', { id });
+	}
+}

package/src/exceptions/aggregate-event.delete-restricted.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class AggregateEventDeleteRestrictedException extends BaseException {
+	public constructor() {
+		super('Domain event cannot be deleted');
+	}
+}

package/src/exceptions/aggregate-event.not-found.exception.ts

@@ -0,0 +1,7 @@
+import { AggregateNotFoundException } from './aggregate.not-found.exception.js';
+
+export class AggregateEventNotFoundException extends AggregateNotFoundException {
+	public constructor(id?: string) {
+		super('DomainEvent', { id });
+	}
+}

package/src/exceptions/aggregate-event.update-restricted.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class AggregateEventUpdateRestrictedException extends BaseException {
+	public constructor() {
+		super('Domain event updates restricted');
+	}
+}

package/src/exceptions/aggregate.already-exists.exception.ts

@@ -0,0 +1,29 @@
+import { BaseException } from '@hg-ts/exception';
+import { format } from 'util';
+
+export type AggregateAlreadyExistsParams<IdType = unknown> = {
+	id?: IdType;
+	code?: number;
+}
+
+export abstract class AggregateAlreadyExistsException<IdType = unknown> extends BaseException {
+	public readonly id?: IdType;
+
+	public constructor(aggregateName: string, params: AggregateAlreadyExistsParams<IdType> = {}) {
+		const { code, id } = params;
+		const messageParts = [aggregateName];
+
+		if (id) {
+			messageParts.push(`with id ${format(id)}`);
+		}
+
+		messageParts.push('already exists');
+
+		super(messageParts.join(' '), { code });
+
+		// eslint-disable-next-line no-undefined
+		if (id !== undefined) {
+			this.id = id;
+		}
+	}
+}

package/src/exceptions/aggregate.not-found.exception.ts

@@ -0,0 +1,29 @@
+import { BaseException } from '@hg-ts/exception';
+import { format } from 'util';
+
+export type AggregateNotFoundParams<IdType = unknown> = {
+	id?: IdType;
+	code?: number;
+}
+
+export abstract class AggregateNotFoundException<IdType = unknown> extends BaseException {
+	public readonly id?: IdType;
+
+	public constructor(aggregateName: string, params: AggregateNotFoundParams<IdType> = {}) {
+		const { code, id } = params;
+		const messageParts = [aggregateName];
+
+		if (id) {
+			messageParts.push(`with id ${format(id)}`);
+		}
+
+		messageParts.push('not found');
+
+		super(messageParts.join(' '), { code });
+
+		// eslint-disable-next-line no-undefined
+		if (id !== undefined) {
+			this.id = id;
+		}
+	}
+}

package/src/exceptions/index.ts

@@ -0,0 +1,7 @@
+export * from './aggregate.not-found.exception.js';
+export * from './aggregate.already-exists.exception.js';
+
+export * from './aggregate-event.not-found.exception.js';
+export * from './aggregate-event.already-exists.exception.js';
+export * from './aggregate-event.update-restricted.exception.js';
+export * from './aggregate-event.delete-restricted.exception.js';

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './exceptions/index.js';
+export * from './repositories/index.js';

package/src/repositories/base.event.repository.ts

@@ -0,0 +1,59 @@
+import {
+	DomainEvent,
+	DomainEventDto,
+	STORED_PROPERTY,
+} from '@hg-ts/domain';
+
+import {
+	AggregateAlreadyExistsException,
+	AggregateEventAlreadyExistsException,
+	AggregateEventDeleteRestrictedException,
+	AggregateEventNotFoundException,
+	AggregateEventUpdateRestrictedException,
+	AggregateNotFoundException,
+} from '../exceptions/index.js';
+import {
+	BaseRepository,
+	NotEmptyList,
+} from './base.repository.js';
+import {
+	EventFindOptions,
+	EventRepository,
+} from './event.repository.js';
+
+export abstract class BaseEventRepository
+	extends BaseRepository<DomainEvent, EventFindOptions> implements EventRepository {
+	public override async add(eventOrEvents: DomainEvent[] | DomainEvent): Promise<void> {
+		const events = Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents];
+		await super.add(events.filter(item => !item[STORED_PROPERTY]));
+
+		events.forEach(event => {
+			event[STORED_PROPERTY] = true;
+		});
+	}
+
+	public override async getNextId(): Promise<string> {
+		return DomainEvent.generateId();
+	}
+
+	public override async update(_entity: DomainEvent | DomainEvent[]): Promise<void> {
+		throw new AggregateEventUpdateRestrictedException();
+	}
+
+	public override async delete(_entity: DomainEvent | DomainEvent[]): Promise<void> {
+		throw new AggregateEventDeleteRestrictedException();
+	}
+
+	/* v8 ignore next*/
+	protected override async rawUpdate(_entity: NotEmptyList<DomainEventDto>): Promise<void> {
+		throw new AggregateEventUpdateRestrictedException();
+	}
+
+	protected override getNotFoundException(id: string): AggregateNotFoundException {
+		throw new AggregateEventNotFoundException(id);
+	}
+
+	protected override getAlreadyExistsException(id: string): AggregateAlreadyExistsException {
+		throw new AggregateEventAlreadyExistsException(id);
+	}
+}

package/src/repositories/base.memory.repository.ts

@@ -0,0 +1,65 @@
+import type { BaseAggregate } from '@hg-ts/domain';
+import {
+	BaseRepository,
+	NotEmptyList,
+} from './base.repository.js';
+import type {
+	AggregateDto,
+	BaseFindOptions,
+} from './repository.js';
+
+function clone<Aggregate extends BaseAggregate<any>>(aggregate: Aggregate): Aggregate {
+	const aggregatePrototype = Object.getPrototypeOf(aggregate);
+	const result = Object.create(aggregatePrototype);
+
+	Object.assign(result, aggregate);
+
+	return result;
+}
+
+export abstract class BaseMemoryRepository<
+	Aggregate extends BaseAggregate<any>,
+  FindOptions extends BaseFindOptions = BaseFindOptions,
+>
+	extends BaseRepository<Aggregate, FindOptions> {
+	protected readonly entitiesMap = new Map<string, AggregateDto<Aggregate>>();
+
+	public async rawAdd(entities: NotEmptyList<Aggregate>): Promise<void> {
+		for (const entity of entities) {
+			this.entitiesMap.set(entity.id, clone(entity.toDto()));
+		}
+	}
+
+	public async rawUpdate(entities: NotEmptyList<Aggregate>): Promise<void> {
+		for (const entity of entities) {
+			this.entitiesMap.set(entity.id, clone(entity.toDto()));
+		}
+	}
+
+	public override async delete(aggregate: Aggregate | Aggregate[]): Promise<void> {
+		if (Array.isArray(aggregate)) {
+			await Promise.all(aggregate.map(async aggregate => this.delete(aggregate)));
+		} else {
+			this.entitiesMap.delete(aggregate.id);
+		}
+	}
+
+	protected async findEntities(options: FindOptions): Promise<Aggregate[]> {
+		const { id } = options;
+
+		if (Array.isArray(id)) {
+			return id.filter(id => this.entitiesMap.has(id))
+				.map(id => this.entitiesMap.get(id)!).map(dto => this.createAggregate(dto));
+		}
+
+		if (typeof id !== 'undefined') {
+			const item = this.entitiesMap.get(id);
+
+			return item ? [this.createAggregate(item)] : [];
+		}
+
+		return [...this.entitiesMap.values()].map(dto => this.createAggregate(dto));
+	}
+
+	protected abstract createAggregate(dto: AggregateDto<Aggregate>): Aggregate;
+}

package/src/repositories/base.repository.ts

@@ -0,0 +1,107 @@
+import {
+	BaseAggregate,
+	DomainEvent,
+} from '@hg-ts/domain';
+import { WillNeverHappenedException } from '@hg-ts/exception';
+import { v7 as uuid } from 'uuid';
+
+import {
+	AggregateAlreadyExistsException,
+	AggregateNotFoundException,
+} from '../exceptions/index.js';
+import {
+	BaseFindOptions,
+	Repository,
+} from './repository.js';
+
+export type NotEmptyList<T> = [T, ...T[]];
+
+export abstract class BaseRepository<Aggregate extends (BaseAggregate<any> | DomainEvent),
+	FindOptions extends BaseFindOptions = BaseFindOptions>
+	extends Repository<Aggregate, FindOptions> {
+	public async getNextId(): Promise<string> {
+		return uuid();
+	}
+	public async get(id: string): Promise<Nullable<Aggregate>> {
+		// @ts-expect-error почему-то ts не понимает что типы совпадают
+		const [entity] = await this.find({ id });
+
+		return entity || null;
+	}
+
+	public async getOrFail(id: string): Promise<Aggregate> {
+		const entity = await this.get(id);
+
+		if (entity === null) {
+			throw this.getNotFoundException(id);
+		}
+
+		return entity;
+	}
+
+	public async has(id: string): Promise<boolean> {
+		const entity = await this.get(id);
+
+		return entity !== null;
+	}
+
+	public async find(options: Partial<FindOptions> = {}): Promise<Aggregate[]> {
+		return this.findEntities(options);
+	}
+
+	public async add(entityOrEntities: Aggregate[] | Aggregate): Promise<void> {
+		const entities = Array.isArray(entityOrEntities) ? entityOrEntities : [entityOrEntities];
+
+		if (entities.length === 0) {
+			this.onEmptyAdd();
+			return;
+		}
+		const ids = entities.map(({ id }) => id);
+		// @ts-expect-error почему-то ts не понимает что типы совпадают
+		const existEntities = await this.find({ id: ids });
+
+		if (existEntities.length > 0 && existEntities[0]) {
+			throw this.getAlreadyExistsException(existEntities[0].id);
+		}
+
+		await this.rawAdd(entities as NotEmptyList<Aggregate>);
+	}
+
+	public async update(entityOrEntities: Aggregate[] | Aggregate): Promise<void> {
+		const entities = Array.isArray(entityOrEntities)
+			? entityOrEntities
+			: [entityOrEntities];
+
+		if (entities.length === 0) {
+			this.onEmptyUpdate();
+			return;
+		}
+
+		const ids = entities.map(({ id }) => id);
+		// @ts-expect-error почему-то ts не понимает что типы совпадают
+		const existEntities = await this.find({ id: ids });
+
+		if (existEntities.length < entities.length && entities[0]) {
+			throw this.getNotFoundException(existEntities[0]?.id ?? entities[0].id);
+		}
+
+		await this.rawUpdate(entities as NotEmptyList<Aggregate>);
+	}
+
+	/* v8 ignore next */
+	public async delete(_entities: Aggregate[] | Aggregate): Promise<void> {
+		throw new WillNeverHappenedException('The delete method is not implemented, so deleting entities is not allowed.');
+	}
+
+	protected onEmptyAdd(): void {}
+	protected onEmptyUpdate(): void {}
+
+	protected abstract findEntities(options?: Partial<FindOptions>): Promise<Aggregate[]>;
+
+	protected abstract rawAdd(dtos: NotEmptyList<Aggregate>): Promise<void>;
+	protected abstract rawUpdate(dtos: NotEmptyList<Aggregate>): Promise<void>;
+
+	protected abstract getNotFoundException(id: string): AggregateNotFoundException;
+
+	protected abstract getAlreadyExistsException(id: string): AggregateAlreadyExistsException;
+}

package/src/repositories/event.repository.ts

@@ -0,0 +1,15 @@
+import { DomainEvent } from '@hg-ts/domain';
+import {
+	BaseFindOptions,
+	Repository,
+} from './repository.js';
+
+export type EventFindOptions = BaseFindOptions & {
+	entityId?: string | string[];
+	entityName?: string;
+	limit?: number;
+};
+
+export abstract class EventRepository
+	extends Repository<DomainEvent, EventFindOptions> {
+}

package/src/repositories/index.ts

@@ -0,0 +1,6 @@
+export * from './base.repository.js';
+export * from './repository.js';
+export * from './base.memory.repository.js';
+
+export * from './base.event.repository.js';
+export * from './event.repository.js';

package/src/repositories/repository.ts

@@ -0,0 +1,30 @@
+import {
+	BaseAggregate,
+	DomainEvent,
+} from '@hg-ts/domain';
+
+export type AggregateDto<Aggregate extends BaseAggregate<any> | DomainEvent> =
+	ReturnType<Aggregate['toDto']>
+
+export type BaseFindOptions = {
+	id?: string | string[];
+};
+
+export abstract class Repository<Aggregate extends BaseAggregate<any> | DomainEvent,
+	FindOptions extends BaseFindOptions = BaseFindOptions> {
+	public abstract getNextId(): Promise<string>;
+
+	public abstract get(id: string): Promise<Nullable<Aggregate>>;
+
+	public abstract getOrFail(id: string): Promise<Aggregate>;
+
+	public abstract find(options?: FindOptions): Promise<Aggregate[]>;
+
+	public abstract add(entity: Aggregate | Aggregate[]): Promise<void>;
+
+	public abstract update(entity: Aggregate | Aggregate[]): Promise<void>;
+
+	public abstract delete(entity: Aggregate | Aggregate[]): Promise<void>;
+
+	public abstract has(id: string): Promise<boolean>;
+}

package/src/tests/base-event-repository.test.ts

@@ -0,0 +1,107 @@
+import {
+	DomainEvent,
+	STORED_PROPERTY,
+} from '@hg-ts/domain';
+import {
+	Describe,
+	expect,
+	ExpectException,
+	Suite,
+	Test,
+} from '@hg-ts/tests';
+import {
+	v4 as uuid,
+	validate,
+} from 'uuid';
+import {
+	AggregateEventAlreadyExistsException,
+	AggregateEventDeleteRestrictedException,
+	AggregateEventNotFoundException,
+	AggregateEventUpdateRestrictedException,
+} from '../exceptions/index.js';
+import { TestEventMemoryRepository } from './test-event.memory.repository.js';
+
+@Describe()
+export class BaseRepositoryTestSuite extends Suite {
+	private repository: TestEventMemoryRepository;
+
+	@Test()
+	public async getNextId(): Promise<void> {
+		const id = await this.repository.getNextId();
+
+		expect(validate(id)).toBeTruthy();
+	}
+
+	@Test()
+	public async addEmpty(): Promise<void> {
+		await this.repository.add([]);
+	}
+
+	@Test()
+	public async add(): Promise<void> {
+		const event = this.createEvent();
+		await this.repository.add(event);
+
+		const found = await this.repository.getOrFail(event.id);
+
+		expect(found).toMatchObject(event);
+	}
+
+	@Test()
+	@ExpectException(AggregateEventUpdateRestrictedException)
+	public async update(): Promise<void> {
+		const event = this.createEvent();
+		await this.repository.add(event);
+		await this.repository.update(event);
+	}
+
+	@Test()
+	@ExpectException(AggregateEventDeleteRestrictedException)
+	public async delete(): Promise<void> {
+		const event = this.createEvent();
+		await this.repository.add(event);
+		await this.repository.delete(event);
+	}
+
+	@Test()
+	@ExpectException(AggregateEventNotFoundException)
+	public async getNotFound(): Promise<void> {
+		await this.repository.getOrFail(DomainEvent.generateId());
+	}
+
+	@Test()
+	public async addDuplicateAllowed(): Promise<void> {
+		const event = this.createEvent();
+		await this.repository.add(event);
+		await this.repository.add(event);
+	}
+
+	@Test()
+	@ExpectException(AggregateEventAlreadyExistsException)
+	public async addWithDuplicateId(): Promise<void> {
+		const event = this.createEvent();
+		await this.repository.add(event);
+		event[STORED_PROPERTY] = false;
+		await this.repository.add(event);
+	}
+
+	@Test()
+	public async getNotFoundWithoutExceptionTest(): Promise<void> {
+		const id = uuid();
+
+		await this.repository.get(id);
+	}
+
+	public override async beforeEach(): Promise<void> {
+		this.repository = new TestEventMemoryRepository();
+	}
+
+	private createEvent(): DomainEvent {
+		return new DomainEvent({
+			occurredOn: new Date(),
+			entityName: 'Test',
+			entityId: uuid(),
+			body: {},
+		});
+	}
+}

package/src/tests/base-repository.test.ts

@@ -0,0 +1,161 @@
+import {
+	Describe,
+	expect,
+	ExpectException,
+	Suite,
+	Test,
+} from '@hg-ts/tests';
+import {
+	v4 as uuid,
+	validate,
+} from 'uuid';
+
+import { TestAggregate } from './test.aggregate.js';
+import { TestAlreadyExistsException } from './test.already-exists.exception.js';
+import { TestMemoryRepository } from './test.memory.repository.js';
+import { TestNotFoundException } from './test.not-found.exception.js';
+
+@Describe()
+export class BaseRepositoryTestSuite extends Suite {
+	private repository: TestMemoryRepository;
+
+	@Test()
+	public async getNextId(): Promise<void> {
+		const id = await this.repository.getNextId();
+
+		expect(validate(id)).toBeTruthy();
+	}
+
+	@Test()
+	public async has(): Promise<void> {
+		const id = uuid();
+		const aggregate = new TestAggregate(id);
+
+		await this.repository.add(aggregate);
+
+		const exists = await this.repository.has(id);
+
+		expect(exists).toBeTruthy();
+	}
+
+	@Test()
+	public async saveEmpty(): Promise<void> {
+		await this.repository.add([]);
+	}
+
+	@Test()
+	public async save(): Promise<void> {
+		const id = uuid();
+		const aggregate = new TestAggregate(id);
+
+		await this.repository.add(aggregate);
+
+		const savedAggregate = await this.repository.getOrFail(id);
+
+		expect(savedAggregate).toBeInstanceOf(TestAggregate);
+		expect(savedAggregate).not.toBe(aggregate);
+		expect({ ...savedAggregate }).toMatchObject({ ...aggregate });
+
+		const found = await this.repository.find();
+
+		expect(found).toHaveLength(1);
+		expect(found[0]).toMatchObject(savedAggregate);
+	}
+
+	@Test()
+	@ExpectException(TestAlreadyExistsException)
+	public async saveDuplicate(): Promise<void> {
+		const id = uuid();
+		const aggregate = new TestAggregate(id);
+
+		await this.repository.add(aggregate);
+		await this.repository.add(aggregate);
+	}
+
+	@Test()
+	public async updateEmpty(): Promise<void> {
+		await this.repository.update([]);
+	}
+
+	@Test()
+	@ExpectException(TestNotFoundException)
+	public async updateNotFound(): Promise<void> {
+		const id = uuid();
+		const aggregate = new TestAggregate(id);
+		await this.repository.update(aggregate);
+	}
+
+	@Test()
+	public async delete(): Promise<void> {
+		const id = uuid();
+		const aggregate = new TestAggregate(id);
+
+		await this.repository.add(aggregate);
+
+		const savedAggregate = await this.repository.getOrFail(id);
+
+		expect(savedAggregate).toBeInstanceOf(TestAggregate);
+
+		await this.repository.delete(aggregate);
+		const found = await this.repository.get(id);
+
+		expect(found).toBeNull();
+	}
+
+	@Test()
+	public async deleteList(): Promise<void> {
+		await this.repository.add(new TestAggregate(uuid()));
+		await this.repository.add(new TestAggregate(uuid()));
+
+		const found = await this.repository.find();
+
+		await this.repository.delete(found);
+
+		const foundAfterDelete = await this.repository.find();
+
+		expect(foundAfterDelete).toHaveLength(0);
+	}
+
+	@Test()
+	public async updateTest(): Promise<void> {
+		const id = uuid();
+		const initialValue = uuid();
+		const expectedValue = uuid();
+		const aggregate = new TestAggregate(id);
+		aggregate.setSomeField(initialValue);
+
+		await this.repository.add(aggregate);
+
+		const savedAggregate = await this.repository.getOrFail(id);
+
+		expect(savedAggregate).toBeInstanceOf(TestAggregate);
+		expect(savedAggregate.someField).toBe(initialValue);
+		savedAggregate.setSomeField(expectedValue);
+
+		await this.repository.update(savedAggregate);
+
+		const updatedAggregate = await this.repository.getOrFail(id);
+
+		expect(updatedAggregate).toBeInstanceOf(TestAggregate);
+		expect(updatedAggregate.someField).toBe(expectedValue);
+	}
+
+	@Test()
+	@ExpectException(TestNotFoundException)
+	public async getOrFailNotFoundExceptionTest(): Promise<void> {
+		const id = uuid();
+
+		await this.repository.getOrFail(id);
+	}
+
+	@Test()
+	public async getNotFoundWithoutExceptionTest(): Promise<void> {
+		const id = uuid();
+
+		await this.repository.get(id);
+	}
+
+	public override async beforeEach(): Promise<void> {
+		this.repository = new TestMemoryRepository();
+	}
+}

package/src/tests/test-event.memory.repository.ts

@@ -0,0 +1,52 @@
+import { DomainEvent } from '@hg-ts/domain';
+
+import {
+	BaseEventRepository,
+	EventFindOptions,
+	NotEmptyList,
+} from '../repositories/index.js';
+
+export class TestEventMemoryRepository extends BaseEventRepository {
+	private readonly events = new Map<string, DomainEvent>();
+
+	/* v8 ignore next */
+	protected async findEntities(options: Partial<EventFindOptions> = {}): Promise<DomainEvent[]> {
+		const { id, entityId, entityName, limit } = options;
+		const events = [...this.events.values()]
+			.filter(event => {
+				if (id) {
+					if (Array.isArray(id)) {
+						return id.includes(event.id);
+					}
+
+					return event.id === id;
+				}
+
+				if (entityId) {
+					if (Array.isArray(entityId)) {
+						return entityId.includes(event.entityId);
+					}
+
+					return event.entityId === entityId;
+				}
+
+				if (entityName) {
+					return event.entityName === entityName;
+				}
+
+				return true;
+			});
+
+		if (limit && limit > 0) {
+			return events.slice(0, limit);
+		}
+
+		return events;
+	}
+
+	protected async rawAdd(events: NotEmptyList<DomainEvent>): Promise<void> {
+		events.forEach(event => {
+			this.events.set(event.id, event);
+		});
+	}
+}

package/src/tests/test.aggregate.ts

@@ -0,0 +1,24 @@
+import { BaseAggregate } from '@hg-ts/domain';
+
+type TestAggregateDto = {
+	id: string;
+	someField: Nullable<string>;
+};
+
+export class TestAggregate extends BaseAggregate<TestAggregateDto> {
+	public someField: Nullable<string> = null;
+
+	public constructor(id: string, someField: Nullable<string> = null) {
+		super({ id });
+
+		this.someField = someField;
+	}
+
+	public setSomeField(value: Nullable<string>): void {
+		this.someField = value;
+	}
+
+	public toDto(): TestAggregateDto {
+		return { id: this.id, someField: this.someField };
+	}
+}

package/src/tests/test.already-exists.exception.ts

@@ -0,0 +1,8 @@
+import { AggregateAlreadyExistsException } from '../exceptions/index.js';
+import type { TestAggregate } from './test.aggregate.js';
+
+export class TestAlreadyExistsException extends AggregateAlreadyExistsException {
+	public constructor(id: Nullable<TestAggregate['id']> = null) {
+		super('Test', { id, code: 0 });
+	}
+}

package/src/tests/test.memory.repository.ts

@@ -0,0 +1,27 @@
+import {
+	AggregateAlreadyExistsException,
+	AggregateNotFoundException,
+} from '../exceptions/index.js';
+
+import {
+	AggregateDto,
+	BaseMemoryRepository,
+} from '../repositories/index.js';
+
+import { TestAggregate } from './test.aggregate.js';
+import { TestAlreadyExistsException } from './test.already-exists.exception.js';
+import { TestNotFoundException } from './test.not-found.exception.js';
+
+export class TestMemoryRepository extends BaseMemoryRepository<TestAggregate> {
+	protected getNotFoundException(id: TestAggregate['id']): AggregateNotFoundException {
+		return new TestNotFoundException(id);
+	}
+
+	protected getAlreadyExistsException(id: TestAggregate['id']): AggregateAlreadyExistsException {
+		return new TestAlreadyExistsException(id);
+	}
+
+	protected createAggregate(dto: AggregateDto<TestAggregate>): TestAggregate {
+		return new TestAggregate(dto.id, dto.someField);
+	}
+}

package/src/tests/test.not-found.exception.ts

@@ -0,0 +1,8 @@
+import { AggregateNotFoundException } from '../exceptions/index.js';
+import type { TestAggregate } from './test.aggregate.js';
+
+export class TestNotFoundException extends AggregateNotFoundException {
+	public constructor(id: Nullable<TestAggregate['id']> = null) {
+		super('Test', { id, code: 0 });
+	}
+}