ddd-ts-kit 0.13.0 → 0.15.0

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);
+      },
+    ],
+  ];
+}

package/templates/presets/identity/context/test/integration/keycloak-identity-provider-admin.adapter.spec.ts.tpl

@@ -0,0 +1,123 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '{{tests.module}}';
+import type { IdentityProviderConnection } from '{{alias.context}}/application/ports/identity-provider-connection.port{{alias.ext}}';
+import { KeycloakIdentityProviderAdmin } from '{{alias.context}}/infrastructure/external/keycloak-identity-provider-admin.adapter{{alias.ext}}';
+
+/** What the realm was asked, as `<method> <path>` and the body it received. */
+interface Asked {
+  readonly call: string;
+  readonly body: string;
+}
+
+/** As many organizations as one read of the adapter lists. */
+const PAGE = 100;
+
+const asked: Asked[] = [];
+let server: Server;
+let admin: KeycloakIdentityProviderAdmin;
+
+beforeAll(async () => {
+  server = createServer((request, response) => void answer(request, response));
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+
+  const address = server.address();
+  const port = typeof address === 'object' && address !== null ? address.port : 0;
+
+  const connection: IdentityProviderConnection = {
+    settings: async () => ({
+      baseUrl: `http://127.0.0.1:${port}`,
+      realm: 'acme',
+      clientId: 'admin',
+      clientSecret: 'secret',
+    }),
+  };
+
+  admin = new KeycloakIdentityProviderAdmin(connection);
+});
+
+beforeEach(() => {
+  asked.length = 0;
+});
+
+afterAll(async () => {
+  await new Promise((resolve) => server.close(resolve));
+});
+
+describe('KeycloakIdentityProviderAdmin, against a realm of Keycloak 26', () => {
+  it('opens an organisation under its slug as alias, and an organisation already there is done', async () => {
+    await admin.openOrganisation({ id: 'acme', name: 'Acme' });
+    await admin.openOrganisation({ id: 'taken', name: 'Taken' });
+
+    expect(asked.filter((one) => one.call.startsWith('POST /admin'))).toEqual([
+      { call: 'POST /admin/realms/acme/organizations', body: '{"name":"Acme","alias":"acme","enabled":true}' },
+      { call: 'POST /admin/realms/acme/organizations', body: '{"name":"Taken","alias":"taken","enabled":true}' },
+    ]);
+  });
+
+  it('adds and removes a member by the id the realm gives the organisation, found by its alias on any page', async () => {
+    await admin.addMember('acme', 'subject-ada');
+    await admin.removeMember('acme', 'subject-ada');
+
+    expect(asked.map((one) => one.call).filter((call) => !call.includes('token'))).toEqual([
+      'GET /admin/realms/acme/organizations?briefRepresentation=true&first=0&max=100',
+      'GET /admin/realms/acme/organizations?briefRepresentation=true&first=100&max=100',
+      'POST /admin/realms/acme/organizations/org-acme/members',
+      'GET /admin/realms/acme/organizations?briefRepresentation=true&first=0&max=100',
+      'GET /admin/realms/acme/organizations?briefRepresentation=true&first=100&max=100',
+      'DELETE /admin/realms/acme/organizations/org-acme/members/subject-ada',
+    ]);
+  });
+
+  it('disables a user, with a token of the client credentials grant', async () => {
+    await admin.disableAccount('subject-ada');
+
+    expect(asked).toEqual([
+      {
+        call: 'POST /realms/acme/protocol/openid-connect/token',
+        body: 'grant_type=client_credentials&client_id=admin&client_secret=secret',
+      },
+      { call: 'PUT /admin/realms/acme/users/subject-ada', body: '{"enabled":false}' },
+    ]);
+  });
+
+  it('fails when the realm knows no organisation under the slug, or refuses a call', async () => {
+    await expect(admin.addMember('unknown', 'subject-ada')).rejects.toThrow('no organization under the alias unknown');
+    await expect(admin.disableAccount('refused')).rejects.toThrow('Keycloak answered 403 to PUT users/refused');
+  });
+});
+
+/** The few answers of a realm these calls need. */
+async function answer(request: IncomingMessage, response: ServerResponse): Promise<void> {
+  const chunks: Buffer[] = [];
+
+  for await (const chunk of request) {
+    chunks.push(Buffer.from(chunk));
+  }
+
+  const call = `${request.method ?? ''} ${request.url ?? ''}`;
+
+  asked.push({ call, body: Buffer.concat(chunks).toString('utf8') });
+  response.setHeader('content-type', 'application/json');
+
+  if (call.endsWith('/token')) {
+    response.end(JSON.stringify({ access_token: 'token-of-the-client' }));
+  } else if (call.startsWith('GET') && call.includes('first=0&')) {
+    // A full first page of other organizations, named like the one searched: Keycloak searches by name, never by alias.
+    response.end(JSON.stringify(Array.from({ length: PAGE }, (_, index) => ({ id: `org-${index}`, name: 'acme', alias: `other-${index}` }))));
+  } else if (call.startsWith('GET') && call.includes('first=100&')) {
+    response.end(JSON.stringify([{ id: 'org-acme', name: 'Acme', alias: 'acme' }]));
+  } else if (call.startsWith('GET')) {
+    response.end('[]');
+  } else {
+    response.statusCode = statusOf(call);
+    response.end();
+  }
+}
+
+function statusOf(call: string): number {
+  if (call.includes('/users/refused')) {
+    return 403;
+  }
+
+  return call.startsWith('POST') && asked.some((one) => one.body.includes('"alias":"taken"')) ? 409 : 204;
+}

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

@@ -0,0 +1,92 @@
+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 { 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}}';
+import { {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}MemberRepository } from '{{alias.context}}/infrastructure/persistence/{{#if orm.knex}}knex{{/if}}{{#if orm.drizzle}}drizzle{{/if}}-member.repository{{alias.ext}}';
+import { openTestDatabase, type TestDatabase } from '{{alias.platform}}/database/open-test-database{{alias.ext}}';
+import { aMember } from '{{alias.context}}/test/builders/member.builder{{alias.ext}}';
+import { FakeMemberRepository } from '{{alias.context}}/test/fakes/member.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: () => aMember().build(),
+  mutate: (changed: Member) => {
+    changed.changeRole(MemberRole.Admin, { by: MemberRole.Owner, byAccount: 'subject-owner', delegationId: undefined, owners: 2 }, new Date('2026-02-01T00:00:00.000Z'));
+  },
+  idOf: (subject: Member) => subject.id,
+  stateOf: (subject: Member) => subject.toState(),
+};
+
+let database: TestDatabase;
+
+beforeAll(async () => {
+  database = await openTestDatabase();
+});
+
+afterAll(async () => {
+  await database.close();
+});
+
+repositoryContract<Member>(runner, {
+  ...expectations,
+  name: 'FakeMemberRepository',
+  createRepository: () => new FakeMemberRepository(),
+});
+
+repositoryContract<Member>(runner, {
+  ...expectations,
+  name: '{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}MemberRepository',
+  createRepository: async () => {
+    await database.reset();
+
+    return new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}MemberRepository(database.persistence.database, scope, clock);
+  },
+});
+
+describe.each(adapters())('%s, read by what a use case needs', (_name, create) => {
+  it('finds the current membership of an account in an organisation, and counts its owners', async () => {
+    const repository = await create();
+
+    await repository.save(aMember().of('acme', 'subject-ada').as(MemberRole.Owner).build());
+    await repository.save(aMember().of('acme', 'subject-grace').as(MemberRole.Owner).removedAt(new Date('2026-02-01T00:00:00.000Z')).build());
+    await repository.save(aMember().of('globex', 'subject-alan').as(MemberRole.Owner).build());
+
+    expect((await repository.findOf('acme', 'subject-ada'))?.role).toBe(MemberRole.Owner);
+    expect(await repository.findOf('acme', 'subject-grace')).toBeUndefined();
+    expect(await repository.countOwners('acme')).toBe(1);
+  });
+
+  it('searches the current memberships of an account across organisations', async () => {
+    const repository = await create();
+
+    await repository.save(aMember().of('acme', 'subject-ada').build());
+    await repository.save(aMember().of('globex', 'subject-ada').as(MemberRole.Admin).build());
+    await repository.save(aMember().of('initech', 'subject-ada').removedAt(new Date('2026-02-01T00:00:00.000Z')).build());
+    await repository.save(aMember().of('acme', 'subject-alan').build());
+
+    const current = await repository.searchCurrentOf('subject-ada');
+
+    expect(current.map((member) => member.organisationId).sort()).toEqual(['acme', 'globex']);
+  });
+});
+
+/** The fake and the adapter, each given as the use cases get it. */
+function adapters(): [string, () => Promise<MemberRepository>][] {
+  return [
+    ['FakeMemberRepository', async () => new FakeMemberRepository()],
+    [
+      '{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}MemberRepository',
+      async () => {
+        await database.reset();
+
+        return new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}MemberRepository(database.persistence.database, scope, clock);
+      },
+    ],
+  ];
+}

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

@@ -0,0 +1,46 @@
+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 { Organisation } from '{{alias.context}}/domain/aggregates/organisation.aggregate{{alias.ext}}';
+import { {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}OrganisationRepository } from '{{alias.context}}/infrastructure/persistence/{{#if orm.knex}}knex{{/if}}{{#if orm.drizzle}}drizzle{{/if}}-organisation.repository{{alias.ext}}';
+import { openTestDatabase, type TestDatabase } from '{{alias.platform}}/database/open-test-database{{alias.ext}}';
+import { anOrganisation } from '{{alias.context}}/test/builders/organisation.builder{{alias.ext}}';
+import { FakeOrganisationRepository } from '{{alias.context}}/test/fakes/organisation.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: () => anOrganisation().build(),
+  mutate: () => undefined,
+  idOf: (subject: Organisation) => subject.id,
+  stateOf: (subject: Organisation) => subject.toState(),
+};
+
+let database: TestDatabase;
+
+beforeAll(async () => {
+  database = await openTestDatabase();
+});
+
+afterAll(async () => {
+  await database.close();
+});
+
+repositoryContract<Organisation>(runner, {
+  ...expectations,
+  name: 'FakeOrganisationRepository',
+  createRepository: () => new FakeOrganisationRepository(),
+});
+
+repositoryContract<Organisation>(runner, {
+  ...expectations,
+  name: '{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}OrganisationRepository',
+  createRepository: async () => {
+    await database.reset();
+
+    return new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}OrganisationRepository(database.persistence.database, scope, clock);
+  },
+});

package/templates/presets/identity/context/test/integration/search-members-reader.spec.ts.tpl

@@ -0,0 +1,86 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '{{tests.module}}';
+import { FixedClock, FixedExecutionScope, executionContext, offsetPage, type Actor } from '@ddd-ts-kit/kernel';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{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 { {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}MemberRepository } from '{{alias.context}}/infrastructure/persistence/{{#if orm.knex}}knex{{/if}}{{#if orm.drizzle}}drizzle{{/if}}-member.repository{{alias.ext}}';
+import { {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}SearchMembersReader } from '{{alias.context}}/infrastructure/persistence/{{#if orm.knex}}knex{{/if}}{{#if orm.drizzle}}drizzle{{/if}}-search-members-reader.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 { aMember } from '{{alias.context}}/test/builders/member.builder{{alias.ext}}';
+
+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: 'reader-spec', actor, origin: 'test' }));
+
+let database: TestDatabase;
+
+beforeAll(async () => {
+  database = await openTestDatabase();
+});
+
+beforeEach(async () => {
+  await database.reset();
+
+  const accounts = new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}AccountRepository(database.persistence.database, scope, clock);
+  const members = new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}MemberRepository(database.persistence.database, scope, clock);
+
+  for (const [id, name] of [
+    ['subject-ada', 'Ada'],
+    ['subject-grace', 'Grace'],
+    ['subject-alan', 'Alan'],
+  ] as const) {
+    await accounts.save(anAccount().identifiedBy(id).named(name).reachedAt(`${id}@example.test`).build());
+  }
+
+  await members.save(aMember().identifiedBy('member-1').of('acme', 'subject-ada').as(MemberRole.Owner).joinedOn(joined(1)).build());
+  await members.save(aMember().identifiedBy('member-2').of('acme', 'subject-grace').joinedOn(joined(2)).build());
+  await members.save(aMember().identifiedBy('member-3').of('acme', 'subject-alan').joinedOn(joined(3)).removedAt(joined(4)).build());
+  await members.save(aMember().identifiedBy('member-4').of('globex', 'subject-alan').joinedOn(joined(4)).build());
+});
+
+afterAll(async () => {
+  await database.close();
+});
+
+describe('{{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}SearchMembersReader', () => {
+  it('reads the current members of one organisation, with the profile of their account, earliest first', async () => {
+    const reader = new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}SearchMembersReader(database.persistence.database);
+
+    const page = await reader.search('acme', offsetPage({ limit: 10 }));
+
+    expect(page).toEqual({
+      items: [
+        {
+          memberId: 'member-1',
+          accountId: 'subject-ada',
+          displayName: 'Ada',
+          email: 'subject-ada@example.test',
+          role: MemberRole.Owner,
+          joinedAt: joined(1),
+        },
+        {
+          memberId: 'member-2',
+          accountId: 'subject-grace',
+          displayName: 'Grace',
+          email: 'subject-grace@example.test',
+          role: MemberRole.Member,
+          joinedAt: joined(2),
+        },
+      ],
+      total: 2,
+    });
+  });
+
+  it('answers a page of them, latest first when asked, with the total', async () => {
+    const reader = new {{#if orm.knex}}Knex{{/if}}{{#if orm.drizzle}}Drizzle{{/if}}SearchMembersReader(database.persistence.database);
+
+    const page = await reader.search('acme', offsetPage({ limit: 1, offset: 1, sort: [{ field: 'joinedAt', direction: 'desc' }] }));
+
+    expect(page.items.map((item) => item.memberId)).toEqual(['member-1']);
+    expect(page.total).toBe(2);
+  });
+});
+
+function joined(day: number): Date {
+  return new Date(Date.UTC(2026, 0, day));
+}