ddd-ts-kit 0.14.0 → 0.16.0

package/templates/presets/identity/context/test/builders/invitation.builder.ts.tpl

@@ -0,0 +1,60 @@
+import { Builder, sequence, type Defaults } from '@ddd-ts-kit/testing';
+import { Invitation } from '{{alias.context}}/domain/aggregates/invitation.aggregate{{alias.ext}}';
+import { EmailAddress } from '{{alias.context}}/domain/value-objects/email-address.vo{{alias.ext}}';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+interface InvitationIngredients {
+  readonly id: string;
+  readonly organisationId: string;
+  readonly email: string;
+  readonly role: MemberRole;
+  readonly tokenHash: string;
+  readonly invitedBy: string;
+  readonly issuedAt: Date;
+}
+
+export class InvitationBuilder extends Builder<InvitationIngredients, Invitation> {
+  identifiedBy(id: string): this {
+    return this.with('id', id);
+  }
+
+  to(organisationId: string): this {
+    return this.with('organisationId', organisationId);
+  }
+
+  addressedTo(email: string): this {
+    return this.with('email', email);
+  }
+
+  as(role: MemberRole): this {
+    return this.with('role', role);
+  }
+
+  withTokenHash(tokenHash: string): this {
+    return this.with('tokenHash', tokenHash);
+  }
+
+  issuedAt(instant: Date): this {
+    return this.with('issuedAt', instant);
+  }
+
+  protected defaults(): Defaults<InvitationIngredients> {
+    return {
+      id: sequence('invitation'),
+      organisationId: 'acme',
+      email: 'grace@example.test',
+      role: MemberRole.Member,
+      tokenHash: sequence('digest'),
+      invitedBy: 'account-founder',
+      issuedAt: new Date('2026-01-01T00:00:00.000Z'),
+    };
+  }
+
+  protected construct({ id, email, issuedAt, ...terms }: InvitationIngredients): Invitation {
+    return Invitation.issue(id, { ...terms, email: EmailAddress.create(email) }, issuedAt);
+  }
+}
+
+export function anInvitation(): InvitationBuilder {
+  return new InvitationBuilder();
+}

package/templates/presets/identity/context/test/builders/member.builder.ts.tpl

@@ -0,0 +1,59 @@
+import { Builder, sequence, type Defaults } from '@ddd-ts-kit/testing';
+import { Member } from '{{alias.context}}/domain/aggregates/member.aggregate{{alias.ext}}';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+interface MemberIngredients {
+  readonly id: string;
+  readonly organisationId: string;
+  readonly accountId: string;
+  readonly role: MemberRole;
+  readonly joinedAt: Date;
+  readonly removedAt: Date | undefined;
+}
+
+export class MemberBuilder extends Builder<MemberIngredients, Member> {
+  identifiedBy(id: string): this {
+    return this.with('id', id);
+  }
+
+  of(organisationId: string, accountId: string): this {
+    return this.with('organisationId', organisationId).with('accountId', accountId);
+  }
+
+  as(role: MemberRole): this {
+    return this.with('role', role);
+  }
+
+  joinedOn(instant: Date): this {
+    return this.with('joinedAt', instant);
+  }
+
+  removedAt(instant: Date): this {
+    return this.with('removedAt', instant);
+  }
+
+  protected defaults(): Defaults<MemberIngredients> {
+    return {
+      id: sequence('member'),
+      organisationId: 'acme',
+      accountId: sequence('account'),
+      role: MemberRole.Member,
+      joinedAt: new Date('2026-01-01T00:00:00.000Z'),
+      removedAt: undefined,
+    };
+  }
+
+  protected construct({ id, organisationId, accountId, role, joinedAt, removedAt }: MemberIngredients): Member {
+    const member = Member.join(id, { organisationId, accountId, role }, joinedAt);
+
+    if (removedAt !== undefined) {
+      member.remove({ by: MemberRole.Owner, byAccount: 'subject-owner', delegationId: undefined, owners: 2 }, removedAt);
+    }
+
+    return member;
+  }
+}
+
+export function aMember(): MemberBuilder {
+  return new MemberBuilder();
+}

package/templates/presets/identity/context/test/builders/organisation.builder.ts.tpl

@@ -0,0 +1,44 @@
+import { Builder, sequence, type Defaults } from '@ddd-ts-kit/testing';
+import { Organisation } from '{{alias.context}}/domain/aggregates/organisation.aggregate{{alias.ext}}';
+import { OrganisationName } from '{{alias.context}}/domain/value-objects/organisation-name.vo{{alias.ext}}';
+import { OrganisationSlug } from '{{alias.context}}/domain/value-objects/organisation-slug.vo{{alias.ext}}';
+
+interface OrganisationIngredients {
+  readonly slug: string;
+  readonly name: string;
+  readonly openedBy: string;
+  readonly openedAt: Date;
+}
+
+export class OrganisationBuilder extends Builder<OrganisationIngredients, Organisation> {
+  identifiedBy(slug: string): this {
+    return this.with('slug', slug);
+  }
+
+  named(name: string): this {
+    return this.with('name', name);
+  }
+
+  openedBy(accountId: string): this {
+    return this.with('openedBy', accountId);
+  }
+
+  protected defaults(): Defaults<OrganisationIngredients> {
+    return {
+      slug: sequence('acme'),
+      name: 'Acme',
+      openedBy: 'account-founder',
+      openedAt: new Date('2026-01-01T00:00:00.000Z'),
+    };
+  }
+
+  protected construct(ingredients: OrganisationIngredients): Organisation {
+    const terms = { name: OrganisationName.create(ingredients.name), openedBy: ingredients.openedBy };
+
+    return Organisation.open(OrganisationSlug.create(ingredients.slug), terms, ingredients.openedAt);
+  }
+}
+
+export function anOrganisation(): OrganisationBuilder {
+  return new OrganisationBuilder();
+}

package/templates/presets/identity/context/test/fakes/account.repository.fake.ts.tpl

@@ -0,0 +1,10 @@
+import { InMemoryRepository } from '@ddd-ts-kit/testing';
+import { Account } from '{{alias.context}}/domain/aggregates/account.aggregate{{alias.ext}}';
+import type { AccountRepository } from '{{alias.context}}/domain/repositories/account.repository{{alias.ext}}';
+
+export class FakeAccountRepository extends InMemoryRepository<Account> implements AccountRepository {
+  constructor() {
+    // A copy by rehydration and not a snapshot: a snapshot goes through `structuredClone`, which turns the value objects of the state into plain objects. The state is immutable, so sharing its values between copies is safe.
+    super({ clone: (stored: Account) => Account.rehydrate(stored.id, stored.toState()) });
+  }
+}

package/templates/presets/identity/context/test/fakes/delegation.repository.fake.ts.tpl

@@ -0,0 +1,26 @@
+import { InMemoryRepository } from '@ddd-ts-kit/testing';
+import { Delegation } from '{{alias.context}}/domain/aggregates/delegation.aggregate{{alias.ext}}';
+import type { DelegationRepository } from '{{alias.context}}/domain/repositories/delegation.repository{{alias.ext}}';
+
+export class FakeDelegationRepository extends InMemoryRepository<Delegation> implements DelegationRepository {
+  constructor() {
+    // A copy by rehydration and not a snapshot: a snapshot goes through `structuredClone`, which turns the value objects of the state into plain objects. The state is immutable, so sharing its values between copies is safe.
+    super({ clone: (stored: Delegation) => Delegation.rehydrate(stored.id, stored.toState()) });
+  }
+
+  async findUnendedTo(organisationId: string, delegateId: string): Promise<readonly Delegation[]> {
+    return this.unended(organisationId).filter((stored) => stored.delegateId === delegateId);
+  }
+
+  async findUnendedInvolving(organisationId: string, accountId: string): Promise<readonly Delegation[]> {
+    return this.unended(organisationId).filter(
+      (stored) => stored.delegatorId === accountId || stored.delegateId === accountId,
+    );
+  }
+
+  private unended(organisationId: string): Delegation[] {
+    return this.all().filter(
+      (stored) => stored.organisationId === organisationId && stored.toState().endedAt === undefined,
+    );
+  }
+}

package/templates/presets/identity/context/test/fakes/identity-provider-admin.fake.ts.tpl

@@ -0,0 +1,41 @@
+import type { IdentityProviderAdmin } from '{{alias.context}}/application/ports/identity-provider-admin.port{{alias.ext}}';
+
+/** The identity provider as a list of what it was asked, in order, failing on demand until it answers again. */
+export class FakeIdentityProviderAdmin implements IdentityProviderAdmin {
+  readonly asked: string[] = [];
+
+  private failure: Error | undefined;
+
+  failWith(failure: Error): void {
+    this.failure = failure;
+  }
+
+  /** The provider is reachable again: what the platform delivers again now reaches it. */
+  answerAgain(): void {
+    this.failure = undefined;
+  }
+
+  async openOrganisation(organisation: { readonly id: string; readonly name: string }): Promise<void> {
+    this.record(`open ${organisation.id} named ${organisation.name}`);
+  }
+
+  async addMember(organisationId: string, accountId: string): Promise<void> {
+    this.record(`add ${accountId} to ${organisationId}`);
+  }
+
+  async removeMember(organisationId: string, accountId: string): Promise<void> {
+    this.record(`remove ${accountId} from ${organisationId}`);
+  }
+
+  async disableAccount(accountId: string): Promise<void> {
+    this.record(`disable ${accountId}`);
+  }
+
+  private record(request: string): void {
+    if (this.failure !== undefined) {
+      throw this.failure;
+    }
+
+    this.asked.push(request);
+  }
+}

package/templates/presets/identity/context/test/fakes/invitation-tokens.fake.ts.tpl

@@ -0,0 +1,18 @@
+import type { InvitationTokens } from '{{alias.context}}/application/ports/invitation-tokens.port{{alias.ext}}';
+
+/** Tokens a spec can predict: `token-1`, `token-2`..., each digest `digest-of-<token>`. */
+export class FakeInvitationTokens implements InvitationTokens {
+  private issued = 0;
+
+  issue(): { token: string; digest: string } {
+    this.issued += 1;
+
+    const token = `token-${this.issued}`;
+
+    return { token, digest: this.digestOf(token) };
+  }
+
+  digestOf(token: string): string {
+    return `digest-of-${token}`;
+  }
+}

package/templates/presets/identity/context/test/fakes/invitation.repository.fake.ts.tpl

@@ -0,0 +1,14 @@
+import { InMemoryRepository } from '@ddd-ts-kit/testing';
+import { Invitation } from '{{alias.context}}/domain/aggregates/invitation.aggregate{{alias.ext}}';
+import type { InvitationRepository } from '{{alias.context}}/domain/repositories/invitation.repository{{alias.ext}}';
+
+export class FakeInvitationRepository extends InMemoryRepository<Invitation> implements InvitationRepository {
+  constructor() {
+    // A copy by rehydration and not a snapshot: a snapshot goes through `structuredClone`, which turns the value objects of the state into plain objects. The state is immutable, so sharing its values between copies is safe.
+    super({ clone: (stored: Invitation) => Invitation.rehydrate(stored.id, stored.toState()) });
+  }
+
+  async findByTokenHash(tokenHash: string): Promise<Invitation | undefined> {
+    return this.all().find((stored) => stored.toState().tokenHash === tokenHash);
+  }
+}

package/templates/presets/identity/context/test/fakes/member.repository.fake.ts.tpl

@@ -0,0 +1,29 @@
+import { InMemoryRepository } from '@ddd-ts-kit/testing';
+import { Member } from '{{alias.context}}/domain/aggregates/member.aggregate{{alias.ext}}';
+import type { MemberRepository } from '{{alias.context}}/domain/repositories/member.repository{{alias.ext}}';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+export class FakeMemberRepository extends InMemoryRepository<Member> implements MemberRepository {
+  constructor() {
+    // A copy by rehydration and not a snapshot: a snapshot goes through `structuredClone`, which turns the value objects of the state into plain objects. The state is immutable, so sharing its values between copies is safe.
+    super({ clone: (stored: Member) => Member.rehydrate(stored.id, stored.toState()) });
+  }
+
+  async findOf(organisationId: string, accountId: string): Promise<Member | undefined> {
+    return this.all().find((stored) => stored.isActive && isOf(stored, organisationId, accountId));
+  }
+
+  async searchCurrentOf(accountId: string): Promise<readonly Member[]> {
+    return this.all().filter((stored) => stored.isActive && stored.accountId === accountId);
+  }
+
+  async countOwners(organisationId: string): Promise<number> {
+    return this.all().filter(
+      (stored) => stored.isActive && stored.organisationId === organisationId && stored.role === MemberRole.Owner,
+    ).length;
+  }
+}
+
+function isOf(member: Member, organisationId: string, accountId: string): boolean {
+  return member.organisationId === organisationId && member.accountId === accountId;
+}

package/templates/presets/identity/context/test/fakes/organisation.repository.fake.ts.tpl

@@ -0,0 +1,10 @@
+import { InMemoryRepository } from '@ddd-ts-kit/testing';
+import { Organisation } from '{{alias.context}}/domain/aggregates/organisation.aggregate{{alias.ext}}';
+import type { OrganisationRepository } from '{{alias.context}}/domain/repositories/organisation.repository{{alias.ext}}';
+
+export class FakeOrganisationRepository extends InMemoryRepository<Organisation> implements OrganisationRepository {
+  constructor() {
+    // A copy by rehydration and not a snapshot: a snapshot goes through `structuredClone`, which turns the value objects of the state into plain objects. The state is immutable, so sharing its values between copies is safe.
+    super({ clone: (stored: Organisation) => Organisation.rehydrate(stored.id, stored.toState()) });
+  }
+}

package/templates/presets/identity/context/test/fakes/search-members-reader.fake.ts.tpl

@@ -0,0 +1,25 @@
+import { pageOf, type PageRequest } from '@ddd-ts-kit/kernel';
+import type { SearchMembersReader } from '{{alias.context}}/application/ports/search-members-reader.port{{alias.ext}}';
+import type {
+  SearchMembersItem,
+  SearchMembersResult,
+  SearchMembersSort,
+} from '{{alias.context}}/application/queries/search-members/search-members.result{{alias.ext}}';
+
+/** The members a spec gives it, by organisation, read back in the order they joined. */
+export class FakeSearchMembersReader implements SearchMembersReader {
+  private readonly members = new Map<string, SearchMembersItem[]>();
+
+  given(organisationId: string, ...members: readonly SearchMembersItem[]): this {
+    this.members.set(organisationId, [...(this.members.get(organisationId) ?? []), ...members]);
+
+    return this;
+  }
+
+  async search(organisationId: string, page: PageRequest<SearchMembersSort>): Promise<SearchMembersResult> {
+    const all = this.members.get(organisationId) ?? [];
+    const offset = page.kind === 'offset' ? page.offset : 0;
+
+    return pageOf(all.slice(offset, offset + page.limit), { total: all.length });
+  }
+}

package/templates/presets/identity/context/test/integration/account.repository.contract.spec.ts.tpl

@@ -0,0 +1,48 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from '{{tests.module}}';
+import { FixedClock, FixedExecutionScope, executionContext, type Actor } from '@ddd-ts-kit/kernel';
+import { repositoryContract } from '@ddd-ts-kit/testing/contracts';
+import type { Account } from '{{alias.context}}/domain/aggregates/account.aggregate{{alias.ext}}';
+import { {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}AccountRepository } from '{{alias.context}}/infrastructure/persistence/{{#if orm.knex}}knex{{/if}}{{#if orm.drizzle}}drizzle{{/if}}-account.repository{{alias.ext}}';
+import { openTestDatabase, type TestDatabase } from '{{alias.platform}}/database/open-test-database{{alias.ext}}';
+import { anAccount } from '{{alias.context}}/test/builders/account.builder{{alias.ext}}';
+import { FakeAccountRepository } from '{{alias.context}}/test/fakes/account.repository.fake{{alias.ext}}';
+
+const runner = { describe, it, expect, beforeEach, afterEach };
+const clock = new FixedClock(new Date('2026-01-01T00:00:00.000Z'));
+const actor: Actor = { id: 'subject-ada', type: 'user', roles: [], attributes: {} };
+const scope = new FixedExecutionScope(executionContext({ correlationId: 'contract-spec', actor, origin: 'test' }));
+
+const expectations = {
+  createAggregate: () => anAccount().build(),
+  mutate: (changed: Account) => {
+    changed.deactivate(new Date('2026-02-01T00:00:00.000Z'));
+  },
+  idOf: (subject: Account) => subject.id,
+  stateOf: (subject: Account) => subject.toState(),
+};
+
+let database: TestDatabase;
+
+beforeAll(async () => {
+  database = await openTestDatabase();
+});
+
+afterAll(async () => {
+  await database.close();
+});
+
+repositoryContract<Account>(runner, {
+  ...expectations,
+  name: 'FakeAccountRepository',
+  createRepository: () => new FakeAccountRepository(),
+});
+
+repositoryContract<Account>(runner, {
+  ...expectations,
+  name: '{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}AccountRepository',
+  createRepository: async () => {
+    await database.reset();
+
+    return new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}AccountRepository(database.persistence.database, scope, clock);
+  },
+});

package/templates/presets/identity/context/test/integration/delegation.repository.contract.spec.ts.tpl

@@ -0,0 +1,84 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from '{{tests.module}}';
+import { FixedClock, FixedExecutionScope, executionContext, type Actor } from '@ddd-ts-kit/kernel';
+import { repositoryContract } from '@ddd-ts-kit/testing/contracts';
+import type { Delegation } from '{{alias.context}}/domain/aggregates/delegation.aggregate{{alias.ext}}';
+import type { DelegationRepository } from '{{alias.context}}/domain/repositories/delegation.repository{{alias.ext}}';
+import { {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}DelegationRepository } from '{{alias.context}}/infrastructure/persistence/{{#if orm.knex}}knex{{/if}}{{#if orm.drizzle}}drizzle{{/if}}-delegation.repository{{alias.ext}}';
+import { openTestDatabase, type TestDatabase } from '{{alias.platform}}/database/open-test-database{{alias.ext}}';
+import { aDelegation } from '{{alias.context}}/test/builders/delegation.builder{{alias.ext}}';
+import { FakeDelegationRepository } from '{{alias.context}}/test/fakes/delegation.repository.fake{{alias.ext}}';
+
+const runner = { describe, it, expect, beforeEach, afterEach };
+const clock = new FixedClock(new Date('2026-01-01T00:00:00.000Z'));
+const actor: Actor = { id: 'subject-ada', type: 'user', roles: [], attributes: {} };
+const scope = new FixedExecutionScope(executionContext({ correlationId: 'contract-spec', actor, origin: 'test' }));
+
+const expectations = {
+  createAggregate: () => aDelegation().build(),
+  mutate: (changed: Delegation) => {
+    changed.revoke(new Date('2026-01-02T00:00:00.000Z'));
+  },
+  idOf: (subject: Delegation) => subject.id,
+  stateOf: (subject: Delegation) => subject.toState(),
+};
+
+let database: TestDatabase;
+
+beforeAll(async () => {
+  database = await openTestDatabase();
+});
+
+afterAll(async () => {
+  await database.close();
+});
+
+repositoryContract<Delegation>(runner, {
+  ...expectations,
+  name: 'FakeDelegationRepository',
+  createRepository: () => new FakeDelegationRepository(),
+});
+
+repositoryContract<Delegation>(runner, {
+  ...expectations,
+  name: '{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}DelegationRepository',
+  createRepository: async () => {
+    await database.reset();
+
+    return new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}DelegationRepository(database.persistence.database, scope, clock);
+  },
+});
+
+describe.each(adapters())('%s, read by what a use case needs', (_name, create) => {
+  it('finds the delegations not ended yet, lent to a member or involving them', async () => {
+    const repository = await create();
+    const revoked = aDelegation().identifiedBy('delegation-3').from('subject-ada').to('subject-grace').build();
+
+    revoked.revoke(new Date('2026-01-02T00:00:00.000Z'));
+    await repository.save(aDelegation().identifiedBy('delegation-1').from('subject-ada').to('subject-grace').build());
+    await repository.save(aDelegation().identifiedBy('delegation-2').from('subject-grace').to('subject-alan').build());
+    await repository.save(revoked);
+    await repository.save(aDelegation().identifiedBy('delegation-4').in('globex').from('subject-ada').to('subject-grace').build());
+
+    expect((await repository.findUnendedTo('acme', 'subject-grace')).map((found) => found.id)).toEqual(['delegation-1']);
+
+    expect((await repository.findUnendedInvolving('acme', 'subject-grace')).map((found) => found.id).sort()).toEqual([
+      'delegation-1',
+      'delegation-2',
+    ]);
+  });
+});
+
+/** The fake and the adapter, each given as the use cases get it. */
+function adapters(): [string, () => Promise<DelegationRepository>][] {
+  return [
+    ['FakeDelegationRepository', async () => new FakeDelegationRepository()],
+    [
+      '{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}DelegationRepository',
+      async () => {
+        await database.reset();
+
+        return new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}DelegationRepository(database.persistence.database, scope, clock);
+      },
+    ],
+  ];
+}

package/templates/presets/identity/context/test/integration/invitation.repository.contract.spec.ts.tpl

@@ -0,0 +1,76 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from '{{tests.module}}';
+import { FixedClock, FixedExecutionScope, executionContext, type Actor } from '@ddd-ts-kit/kernel';
+import { repositoryContract } from '@ddd-ts-kit/testing/contracts';
+import type { Invitation } from '{{alias.context}}/domain/aggregates/invitation.aggregate{{alias.ext}}';
+import type { InvitationRepository } from '{{alias.context}}/domain/repositories/invitation.repository{{alias.ext}}';
+import { {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}InvitationRepository } from '{{alias.context}}/infrastructure/persistence/{{#if orm.knex}}knex{{/if}}{{#if orm.drizzle}}drizzle{{/if}}-invitation.repository{{alias.ext}}';
+import { openTestDatabase, type TestDatabase } from '{{alias.platform}}/database/open-test-database{{alias.ext}}';
+import { anInvitation } from '{{alias.context}}/test/builders/invitation.builder{{alias.ext}}';
+import { FakeInvitationRepository } from '{{alias.context}}/test/fakes/invitation.repository.fake{{alias.ext}}';
+
+const runner = { describe, it, expect, beforeEach, afterEach };
+const clock = new FixedClock(new Date('2026-01-01T00:00:00.000Z'));
+const actor: Actor = { id: 'subject-ada', type: 'user', roles: [], attributes: {} };
+const scope = new FixedExecutionScope(executionContext({ correlationId: 'contract-spec', actor, origin: 'test' }));
+
+const expectations = {
+  createAggregate: () => anInvitation().build(),
+  mutate: (changed: Invitation) => {
+    changed.revoke(new Date('2026-02-01T00:00:00.000Z'));
+  },
+  idOf: (subject: Invitation) => subject.id,
+  stateOf: (subject: Invitation) => subject.toState(),
+};
+
+let database: TestDatabase;
+
+beforeAll(async () => {
+  database = await openTestDatabase();
+});
+
+afterAll(async () => {
+  await database.close();
+});
+
+repositoryContract<Invitation>(runner, {
+  ...expectations,
+  name: 'FakeInvitationRepository',
+  createRepository: () => new FakeInvitationRepository(),
+});
+
+repositoryContract<Invitation>(runner, {
+  ...expectations,
+  name: '{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}InvitationRepository',
+  createRepository: async () => {
+    await database.reset();
+
+    return new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}InvitationRepository(database.persistence.database, scope, clock);
+  },
+});
+
+describe.each(adapters())('%s, read by what a use case needs', (_name, create) => {
+  it('finds an invitation by the digest of its token', async () => {
+    const repository = await create();
+
+    await repository.save(anInvitation().identifiedBy('invitation-1').withTokenHash('digest-1').build());
+    await repository.save(anInvitation().identifiedBy('invitation-2').withTokenHash('digest-2').build());
+
+    expect((await repository.findByTokenHash('digest-2'))?.id).toBe('invitation-2');
+    expect(await repository.findByTokenHash('digest-9')).toBeUndefined();
+  });
+});
+
+/** The fake and the adapter, each given as the use cases get it. */
+function adapters(): [string, () => Promise<InvitationRepository>][] {
+  return [
+    ['FakeInvitationRepository', async () => new FakeInvitationRepository()],
+    [
+      '{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}InvitationRepository',
+      async () => {
+        await database.reset();
+
+        return new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}InvitationRepository(database.persistence.database, scope, clock);
+      },
+    ],
+  ];
+}