ddd-ts-kit 0.13.0 → 0.15.0

package/templates/presets/identity/context/infrastructure/persistence/drizzle-account.repository.drizzle.ts.tpl

@@ -0,0 +1,59 @@
+import { and, eq } from 'drizzle-orm';
+import { optimisticUpdate } from '@ddd-ts-kit/drizzle/postgres';
+import { stampCreation, stampUpdate, type Clock, type ExecutionScope } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import type { Account } from '{{alias.context}}/domain/aggregates/account.aggregate{{alias.ext}}';
+import { AccountRepository } from '{{alias.context}}/domain/repositories/account.repository{{alias.ext}}';
+import type { Database } from '{{alias.platform}}/database/database{{alias.ext}}';
+import { accounts } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { AccountMapper, type AccountColumns } from '{{alias.context}}/infrastructure/persistence/account.mapper{{alias.ext}}';
+
+type VersionedAccount = AccountColumns & { readonly version: number };
+
+@Repository(AccountRepository)
+export class DrizzleAccountRepository implements AccountRepository {
+  constructor(
+    private readonly database: Database,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Account | undefined> {
+    const [row] = await executorOf(this.database).select().from(accounts).where(eq(accounts.id, id));
+
+    return row === undefined ? undefined : AccountMapper.toDomain(row);
+  }
+
+  async save(saved: Account): Promise<void> {
+    await optimisticUpdate(saved, async ({ expected, next }) => {
+      const state = { ...AccountMapper.toRow(saved), version: next };
+      const written = expected === 0 ? await this.insert(state) : await this.update(state, expected);
+
+      return written.length;
+    });
+  }
+
+  private insert(state: VersionedAccount) {
+    const row = { ...state, ...stampCreation(this.scope, this.clock) };
+
+    return executorOf(this.database).insert(accounts).values(row).onConflictDoNothing().returning({ id: accounts.id });
+  }
+
+  private update(state: VersionedAccount, expected: number) {
+    const sameVersion = and(eq(accounts.id, state.id), eq(accounts.version, expected));
+
+    return executorOf(this.database)
+      .update(accounts)
+      .set({ ...state, ...stampUpdate(this.scope, this.clock) })
+      .where(sameVersion)
+      .returning({ id: accounts.id });
+  }
+}
+
+/** The executor of the unit of work, which every statement of this file goes through. */
+function executorOf(database: Database): ReturnType<Database['executor']> {
+{{#if tenancy.any}}
+  // ddd-ts-kit-disable-next-line tenancy/scoped-statement -- {{preset.adr}}: the {{context.kebab}} context is the control plane of the tenants, and its rows belong to none of them.
+{{/if}}
+  return database.executor();
+}

package/templates/presets/identity/context/infrastructure/persistence/drizzle-delegation.repository.drizzle.ts.tpl

@@ -0,0 +1,77 @@
+import { and, eq, isNull, or } from 'drizzle-orm';
+import { optimisticUpdate } from '@ddd-ts-kit/drizzle/postgres';
+import { stampCreation, stampUpdate, type Clock, type ExecutionScope } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import type { Delegation } from '{{alias.context}}/domain/aggregates/delegation.aggregate{{alias.ext}}';
+import { DelegationRepository } from '{{alias.context}}/domain/repositories/delegation.repository{{alias.ext}}';
+import type { Database } from '{{alias.platform}}/database/database{{alias.ext}}';
+import { delegations } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { DelegationMapper, type DelegationColumns } from '{{alias.context}}/infrastructure/persistence/delegation.mapper{{alias.ext}}';
+
+type VersionedDelegation = DelegationColumns & { readonly version: number };
+
+@Repository(DelegationRepository)
+export class DrizzleDelegationRepository implements DelegationRepository {
+  constructor(
+    private readonly database: Database,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Delegation | undefined> {
+    const [row] = await executorOf(this.database).select().from(delegations).where(eq(delegations.id, id));
+
+    return row === undefined ? undefined : DelegationMapper.toDomain(row);
+  }
+
+  async findUnendedTo(organisationId: string, delegateId: string): Promise<readonly Delegation[]> {
+    const lentTo = and(unended(organisationId), eq(delegations.delegateId, delegateId));
+    const rows = await executorOf(this.database).select().from(delegations).where(lentTo).orderBy(delegations.id);
+
+    return rows.map((row) => DelegationMapper.toDomain(row));
+  }
+
+  async findUnendedInvolving(organisationId: string, accountId: string): Promise<readonly Delegation[]> {
+    const either = or(eq(delegations.delegatorId, accountId), eq(delegations.delegateId, accountId));
+    const rows = await executorOf(this.database).select().from(delegations).where(and(unended(organisationId), either)).orderBy(delegations.id);
+
+    return rows.map((row) => DelegationMapper.toDomain(row));
+  }
+
+  async save(saved: Delegation): Promise<void> {
+    await optimisticUpdate(saved, async ({ expected, next }) => {
+      const state = { ...DelegationMapper.toRow(saved), version: next };
+      const written = expected === 0 ? await this.insert(state) : await this.update(state, expected);
+
+      return written.length;
+    });
+  }
+
+  private insert(state: VersionedDelegation) {
+    const row = { ...state, ...stampCreation(this.scope, this.clock) };
+
+    return executorOf(this.database).insert(delegations).values(row).onConflictDoNothing().returning({ id: delegations.id });
+  }
+
+  private update(state: VersionedDelegation, expected: number) {
+    const sameVersion = and(eq(delegations.id, state.id), eq(delegations.version, expected));
+
+    return executorOf(this.database)
+      .update(delegations)
+      .set({ ...state, ...stampUpdate(this.scope, this.clock) })
+      .where(sameVersion)
+      .returning({ id: delegations.id });
+  }
+}
+
+function unended(organisationId: string) {
+  return and(eq(delegations.organisationId, organisationId), isNull(delegations.endedAt));
+}
+
+/** The executor of the unit of work, which every statement of this file goes through. */
+function executorOf(database: Database): ReturnType<Database['executor']> {
+{{#if tenancy.any}}
+  // ddd-ts-kit-disable-next-line tenancy/scoped-statement -- {{preset.adr}}: the {{context.kebab}} context is the control plane of the tenants, and its rows belong to none of them.
+{{/if}}
+  return database.executor();
+}

package/templates/presets/identity/context/infrastructure/persistence/drizzle-invitation.repository.drizzle.ts.tpl

@@ -0,0 +1,65 @@
+import { and, eq } from 'drizzle-orm';
+import { optimisticUpdate } from '@ddd-ts-kit/drizzle/postgres';
+import { stampCreation, stampUpdate, type Clock, type ExecutionScope } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import type { Invitation } from '{{alias.context}}/domain/aggregates/invitation.aggregate{{alias.ext}}';
+import { InvitationRepository } from '{{alias.context}}/domain/repositories/invitation.repository{{alias.ext}}';
+import type { Database } from '{{alias.platform}}/database/database{{alias.ext}}';
+import { invitations } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { InvitationMapper, type InvitationColumns } from '{{alias.context}}/infrastructure/persistence/invitation.mapper{{alias.ext}}';
+
+type VersionedInvitation = InvitationColumns & { readonly version: number };
+
+@Repository(InvitationRepository)
+export class DrizzleInvitationRepository implements InvitationRepository {
+  constructor(
+    private readonly database: Database,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Invitation | undefined> {
+    const [row] = await executorOf(this.database).select().from(invitations).where(eq(invitations.id, id));
+
+    return row === undefined ? undefined : InvitationMapper.toDomain(row);
+  }
+
+  async findByTokenHash(tokenHash: string): Promise<Invitation | undefined> {
+    const [row] = await executorOf(this.database).select().from(invitations).where(eq(invitations.tokenHash, tokenHash));
+
+    return row === undefined ? undefined : InvitationMapper.toDomain(row);
+  }
+
+  async save(saved: Invitation): Promise<void> {
+    await optimisticUpdate(saved, async ({ expected, next }) => {
+      const state = { ...InvitationMapper.toRow(saved), version: next };
+      const written = expected === 0 ? await this.insert(state) : await this.update(state, expected);
+
+      return written.length;
+    });
+  }
+
+  private insert(state: VersionedInvitation) {
+    const row = { ...state, ...stampCreation(this.scope, this.clock) };
+
+    return executorOf(this.database).insert(invitations).values(row).onConflictDoNothing().returning({ id: invitations.id });
+  }
+
+  private update(state: VersionedInvitation, expected: number) {
+    const sameVersion = and(eq(invitations.id, state.id), eq(invitations.version, expected));
+
+    return executorOf(this.database)
+      .update(invitations)
+      .set({ ...state, ...stampUpdate(this.scope, this.clock) })
+      .where(sameVersion)
+      .returning({ id: invitations.id });
+  }
+}
+
+/** The executor of the unit of work, which every statement of this file goes through. */
+function executorOf(database: Database): ReturnType<Database['executor']> {
+{{#if tenancy.any}}
+  // ddd-ts-kit-disable-next-line tenancy/scoped-statement -- {{preset.adr}}: the {{context.kebab}} context is the control plane of the tenants, and its rows belong to none of them.
+{{/if}}
+  return database.executor();
+}

package/templates/presets/identity/context/infrastructure/persistence/drizzle-member.repository.drizzle.ts.tpl

@@ -0,0 +1,84 @@
+import { and, count, eq, isNull } from 'drizzle-orm';
+import { optimisticUpdate } from '@ddd-ts-kit/drizzle/postgres';
+import { stampCreation, stampUpdate, type Clock, type ExecutionScope } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import type { Member } from '{{alias.context}}/domain/aggregates/member.aggregate{{alias.ext}}';
+import { MemberRepository } from '{{alias.context}}/domain/repositories/member.repository{{alias.ext}}';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+import type { Database } from '{{alias.platform}}/database/database{{alias.ext}}';
+import { members } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { MemberMapper, type MemberColumns } from '{{alias.context}}/infrastructure/persistence/member.mapper{{alias.ext}}';
+
+type VersionedMember = MemberColumns & { readonly version: number };
+
+@Repository(MemberRepository)
+export class DrizzleMemberRepository implements MemberRepository {
+  constructor(
+    private readonly database: Database,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Member | undefined> {
+    const [row] = await executorOf(this.database).select().from(members).where(eq(members.id, id));
+
+    return row === undefined ? undefined : MemberMapper.toDomain(row);
+  }
+
+  async findOf(organisationId: string, accountId: string): Promise<Member | undefined> {
+    const [row] = await executorOf(this.database).select().from(members).where(current(organisationId, accountId));
+
+    return row === undefined ? undefined : MemberMapper.toDomain(row);
+  }
+
+  async searchCurrentOf(accountId: string): Promise<readonly Member[]> {
+    const ofAccount = and(eq(members.accountId, accountId), isNull(members.removedAt));
+    const rows = await executorOf(this.database).select().from(members).where(ofAccount).orderBy(members.id);
+
+    return rows.map((row) => MemberMapper.toDomain(row));
+  }
+
+  async countOwners(organisationId: string): Promise<number> {
+    const owners = and(eq(members.organisationId, organisationId), eq(members.role, MemberRole.Owner), isNull(members.removedAt));
+    const [counted] = await executorOf(this.database).select({ total: count() }).from(members).where(owners);
+
+    return counted?.total ?? 0;
+  }
+
+  async save(saved: Member): Promise<void> {
+    await optimisticUpdate(saved, async ({ expected, next }) => {
+      const state = { ...MemberMapper.toRow(saved), version: next };
+      const written = expected === 0 ? await this.insert(state) : await this.update(state, expected);
+
+      return written.length;
+    });
+  }
+
+  private insert(state: VersionedMember) {
+    const row = { ...state, ...stampCreation(this.scope, this.clock) };
+
+    return executorOf(this.database).insert(members).values(row).onConflictDoNothing().returning({ id: members.id });
+  }
+
+  private update(state: VersionedMember, expected: number) {
+    const sameVersion = and(eq(members.id, state.id), eq(members.version, expected));
+
+    return executorOf(this.database)
+      .update(members)
+      .set({ ...state, ...stampUpdate(this.scope, this.clock) })
+      .where(sameVersion)
+      .returning({ id: members.id });
+  }
+}
+
+function current(organisationId: string, accountId: string) {
+  return and(eq(members.organisationId, organisationId), eq(members.accountId, accountId), isNull(members.removedAt));
+}
+
+/** The executor of the unit of work, which every statement of this file goes through. */
+function executorOf(database: Database): ReturnType<Database['executor']> {
+{{#if tenancy.any}}
+  // ddd-ts-kit-disable-next-line tenancy/scoped-statement -- {{preset.adr}}: the {{context.kebab}} context is the control plane of the tenants, and its rows belong to none of them.
+{{/if}}
+  return database.executor();
+}

package/templates/presets/identity/context/infrastructure/persistence/drizzle-organisation.repository.drizzle.ts.tpl

@@ -0,0 +1,59 @@
+import { and, eq } from 'drizzle-orm';
+import { optimisticUpdate } from '@ddd-ts-kit/drizzle/postgres';
+import { stampCreation, stampUpdate, type Clock, type ExecutionScope } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import type { Organisation } from '{{alias.context}}/domain/aggregates/organisation.aggregate{{alias.ext}}';
+import { OrganisationRepository } from '{{alias.context}}/domain/repositories/organisation.repository{{alias.ext}}';
+import type { Database } from '{{alias.platform}}/database/database{{alias.ext}}';
+import { organisations } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { OrganisationMapper, type OrganisationColumns } from '{{alias.context}}/infrastructure/persistence/organisation.mapper{{alias.ext}}';
+
+type VersionedOrganisation = OrganisationColumns & { readonly version: number };
+
+@Repository(OrganisationRepository)
+export class DrizzleOrganisationRepository implements OrganisationRepository {
+  constructor(
+    private readonly database: Database,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Organisation | undefined> {
+    const [row] = await executorOf(this.database).select().from(organisations).where(eq(organisations.id, id));
+
+    return row === undefined ? undefined : OrganisationMapper.toDomain(row);
+  }
+
+  async save(saved: Organisation): Promise<void> {
+    await optimisticUpdate(saved, async ({ expected, next }) => {
+      const state = { ...OrganisationMapper.toRow(saved), version: next };
+      const written = expected === 0 ? await this.insert(state) : await this.update(state, expected);
+
+      return written.length;
+    });
+  }
+
+  private insert(state: VersionedOrganisation) {
+    const row = { ...state, ...stampCreation(this.scope, this.clock) };
+
+    return executorOf(this.database).insert(organisations).values(row).onConflictDoNothing().returning({ id: organisations.id });
+  }
+
+  private update(state: VersionedOrganisation, expected: number) {
+    const sameVersion = and(eq(organisations.id, state.id), eq(organisations.version, expected));
+
+    return executorOf(this.database)
+      .update(organisations)
+      .set({ ...state, ...stampUpdate(this.scope, this.clock) })
+      .where(sameVersion)
+      .returning({ id: organisations.id });
+  }
+}
+
+/** The executor of the unit of work, which every statement of this file goes through. */
+function executorOf(database: Database): ReturnType<Database['executor']> {
+{{#if tenancy.any}}
+  // ddd-ts-kit-disable-next-line tenancy/scoped-statement -- {{preset.adr}}: the {{context.kebab}} context is the control plane of the tenants, and its rows belong to none of them.
+{{/if}}
+  return database.executor();
+}

package/templates/presets/identity/context/infrastructure/persistence/drizzle-search-members-reader.repository.drizzle.ts.tpl

@@ -0,0 +1,53 @@
+import { and, asc, count, desc, eq, isNull } from 'drizzle-orm';
+import { InvalidPageRequestError, pageOf, type PageRequest } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import { SearchMembersReader } from '{{alias.context}}/application/ports/search-members-reader.port{{alias.ext}}';
+import type {
+  SearchMembersResult,
+  SearchMembersSort,
+} from '{{alias.context}}/application/queries/search-members/search-members.result{{alias.ext}}';
+import type { Database } from '{{alias.platform}}/database/database{{alias.ext}}';
+import { accounts, members } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+
+/** The current members of an organisation joined to the profile of their account: one statement, the page applied by the database. */
+@Repository(SearchMembersReader)
+export class DrizzleSearchMembersReader implements SearchMembersReader {
+  constructor(private readonly database: Database) {}
+
+  async search(organisationId: string, page: PageRequest<SearchMembersSort>): Promise<SearchMembersResult> {
+    if (page.kind !== 'offset') {
+      throw new InvalidPageRequestError('The members of an organisation are read by offset');
+    }
+
+    const order = page.sort[0]?.direction === 'desc' ? desc : asc;
+    const current = and(eq(members.organisationId, organisationId), isNull(members.removedAt));
+
+    const items = await executorOf(this.database)
+      .select({
+        memberId: members.id,
+        accountId: members.accountId,
+        displayName: accounts.displayName,
+        email: accounts.email,
+        role: members.role,
+        joinedAt: members.joinedAt,
+      })
+      .from(members)
+      .innerJoin(accounts, eq(accounts.id, members.accountId))
+      .where(current)
+      .orderBy(order(members.joinedAt), order(members.id))
+      .limit(page.limit)
+      .offset(page.offset);
+
+    const [counted] = await executorOf(this.database).select({ total: count() }).from(members).where(current);
+
+    return pageOf(items, { total: counted?.total ?? 0 });
+  }
+}
+
+/** The executor of the unit of work, which every statement of this file goes through. */
+function executorOf(database: Database): ReturnType<Database['executor']> {
+{{#if tenancy.any}}
+  // ddd-ts-kit-disable-next-line tenancy/scoped-statement -- {{preset.adr}}: the {{context.kebab}} context is the control plane of the tenants, and its rows belong to none of them.
+{{/if}}
+  return database.executor();
+}

package/templates/presets/identity/context/infrastructure/persistence/invitation-row.schema.knex.ts.tpl

@@ -0,0 +1,20 @@
+import type { AuditRow } from '@ddd-ts-kit/knex';
+import type { InvitationStatus } from '{{alias.context}}/domain/vocabularies/invitation-status.vocabulary{{alias.ext}}';
+import type { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+export interface InvitationColumns {
+  readonly id: string;
+  readonly organisation_id: string;
+  readonly email: string;
+  readonly role: MemberRole;
+  readonly token_hash: string;
+  readonly invited_by: string;
+  readonly issued_at: Date;
+  readonly expires_at: Date;
+  readonly status: InvitationStatus;
+  readonly answered_at: Date | null;
+}
+
+export interface InvitationRow extends InvitationColumns, AuditRow {
+  readonly version: number;
+}

package/templates/presets/identity/context/infrastructure/persistence/invitation.mapper.drizzle.ts.tpl

@@ -0,0 +1,45 @@
+import type { AuditStamp } from '@ddd-ts-kit/kernel';
+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 type { invitations } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+
+type InvitationRow = typeof invitations.$inferSelect;
+
+export type InvitationColumns = Omit<InvitationRow, 'version' | keyof AuditStamp>;
+
+export const InvitationMapper = {
+  toDomain(row: InvitationRow): Invitation {
+    const loaded = Invitation.rehydrate(row.id, {
+      organisationId: row.organisationId,
+      email: EmailAddress.create(row.email),
+      role: row.role,
+      tokenHash: row.tokenHash,
+      invitedBy: row.invitedBy,
+      issuedAt: row.issuedAt,
+      expiresAt: row.expiresAt,
+      status: row.status,
+      answeredAt: row.answeredAt ?? undefined,
+    });
+
+    loaded.version = row.version;
+
+    return loaded;
+  },
+
+  toRow(saved: Invitation): InvitationColumns {
+    const state = saved.toState();
+
+    return {
+      id: saved.id,
+      organisationId: state.organisationId,
+      email: state.email.value,
+      role: state.role,
+      tokenHash: state.tokenHash,
+      invitedBy: state.invitedBy,
+      issuedAt: state.issuedAt,
+      expiresAt: state.expiresAt,
+      status: state.status,
+      answeredAt: state.answeredAt ?? null,
+    };
+  },
+};

package/templates/presets/identity/context/infrastructure/persistence/invitation.mapper.knex.ts.tpl

@@ -0,0 +1,40 @@
+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 type { InvitationColumns, InvitationRow } from '{{alias.context}}/infrastructure/persistence/invitation-row.schema{{alias.ext}}';
+
+export const InvitationMapper = {
+  toDomain(row: InvitationRow): Invitation {
+    const loaded = Invitation.rehydrate(row.id, {
+      organisationId: row.organisation_id,
+      email: EmailAddress.create(row.email),
+      role: row.role,
+      tokenHash: row.token_hash,
+      invitedBy: row.invited_by,
+      issuedAt: row.issued_at,
+      expiresAt: row.expires_at,
+      status: row.status,
+      answeredAt: row.answered_at ?? undefined,
+    });
+
+    loaded.version = row.version;
+
+    return loaded;
+  },
+
+  toRow(saved: Invitation): InvitationColumns {
+    const state = saved.toState();
+
+    return {
+      id: saved.id,
+      organisation_id: state.organisationId,
+      email: state.email.value,
+      role: state.role,
+      token_hash: state.tokenHash,
+      invited_by: state.invitedBy,
+      issued_at: state.issuedAt,
+      expires_at: state.expiresAt,
+      status: state.status,
+      answered_at: state.answeredAt ?? null,
+    };
+  },
+};

package/templates/presets/identity/context/infrastructure/persistence/knex-account.repository.knex.ts.tpl

@@ -0,0 +1,61 @@
+import type { Knex } from 'knex';
+import { stampCreation, stampUpdate, type Clock, type ExecutionScope } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import { type KnexContext, auditRow, insertIgnoringConflict, optimisticUpdate } from '@ddd-ts-kit/knex';
+import type { Account } from '{{alias.context}}/domain/aggregates/account.aggregate{{alias.ext}}';
+import { AccountRepository } from '{{alias.context}}/domain/repositories/account.repository{{alias.ext}}';
+import { {{context.constant}}_SCHEMA } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { AccountMapper } from '{{alias.context}}/infrastructure/persistence/account.mapper{{alias.ext}}';
+import type { AccountColumns, AccountRow } from '{{alias.context}}/infrastructure/persistence/account-row.schema{{alias.ext}}';
+
+type VersionedAccount = AccountColumns & { readonly version: number };
+
+@Repository(AccountRepository)
+export class KnexAccountRepository implements AccountRepository {
+  constructor(
+    private readonly database: KnexContext,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Account | undefined> {
+    const row = await tableOf(this.database).where({ id }).first();
+
+    return row === undefined ? undefined : AccountMapper.toDomain(row);
+  }
+
+  async save(saved: Account): Promise<void> {
+    await optimisticUpdate(saved, async ({ expected, next }) => {
+      const state = { ...AccountMapper.toRow(saved), version: next };
+
+      return expected === 0 ? this.insert(state) : this.update(state, expected);
+    });
+  }
+
+  private async insert(state: VersionedAccount): Promise<number> {
+    const row = { ...state, ...auditRow(stampCreation(this.scope, this.clock)) };
+
+    const inserted = await insertIgnoringConflict(this.database.executor(), tableOf(this.database), {
+      row,
+      conflict: 'id',
+    });
+
+    return inserted ? 1 : 0;
+  }
+
+  private async update(state: VersionedAccount, expected: number): Promise<number> {
+    return tableOf(this.database)
+      .where({ id: state.id, version: expected })
+      .update({ ...state, ...auditRow(stampUpdate(this.scope, this.clock)) });
+  }
+}
+
+/** A function and not a method: a query builder is thenable, and a method that answers one is read as asynchronous by whatever wraps the adapter (tracing), which then answers a promise. */
+function tableOf(database: KnexContext): Knex.QueryBuilder<AccountRow, AccountRow[]> {
+{{#if tenancy.any}}
+  // ddd-ts-kit-disable-next-line tenancy/scoped-statement -- {{preset.adr}}: the {{context.kebab}} context is the control plane of the tenants, and its rows belong to none of them.
+{{/if}}
+  const table = database.executor()<AccountRow, AccountRow[]>('accounts');
+
+  return table.withSchema({{context.constant}}_SCHEMA);
+}

package/templates/presets/identity/context/infrastructure/persistence/knex-delegation.repository.knex.ts.tpl

@@ -0,0 +1,80 @@
+import type { Knex } from 'knex';
+import { stampCreation, stampUpdate, type Clock, type ExecutionScope } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import { type KnexContext, auditRow, insertIgnoringConflict, optimisticUpdate } from '@ddd-ts-kit/knex';
+import type { Delegation } from '{{alias.context}}/domain/aggregates/delegation.aggregate{{alias.ext}}';
+import { DelegationRepository } from '{{alias.context}}/domain/repositories/delegation.repository{{alias.ext}}';
+import { {{context.constant}}_SCHEMA } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { DelegationMapper } from '{{alias.context}}/infrastructure/persistence/delegation.mapper{{alias.ext}}';
+import type { DelegationColumns, DelegationRow } from '{{alias.context}}/infrastructure/persistence/delegation-row.schema{{alias.ext}}';
+
+type VersionedDelegation = DelegationColumns & { readonly version: number };
+
+@Repository(DelegationRepository)
+export class KnexDelegationRepository implements DelegationRepository {
+  constructor(
+    private readonly database: KnexContext,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Delegation | undefined> {
+    const row = await tableOf(this.database).where({ id }).first();
+
+    return row === undefined ? undefined : DelegationMapper.toDomain(row);
+  }
+
+  async findUnendedTo(organisationId: string, delegateId: string): Promise<readonly Delegation[]> {
+    const lentTo = { organisation_id: organisationId, delegate_id: delegateId };
+    const rows = await tableOf(this.database).where(lentTo).whereNull('ended_at').orderBy('id');
+
+    return rows.map((row) => DelegationMapper.toDomain(row));
+  }
+
+  async findUnendedInvolving(organisationId: string, accountId: string): Promise<readonly Delegation[]> {
+    const rows = await tableOf(this.database)
+      .where({ organisation_id: organisationId })
+      .whereNull('ended_at')
+      .where((either) => {
+        void either.where({ delegator_id: accountId }).orWhere({ delegate_id: accountId });
+      })
+      .orderBy('id');
+
+    return rows.map((row) => DelegationMapper.toDomain(row));
+  }
+
+  async save(saved: Delegation): Promise<void> {
+    await optimisticUpdate(saved, async ({ expected, next }) => {
+      const state = { ...DelegationMapper.toRow(saved), version: next };
+
+      return expected === 0 ? this.insert(state) : this.update(state, expected);
+    });
+  }
+
+  private async insert(state: VersionedDelegation): Promise<number> {
+    const row = { ...state, ...auditRow(stampCreation(this.scope, this.clock)) };
+
+    const inserted = await insertIgnoringConflict(this.database.executor(), tableOf(this.database), {
+      row,
+      conflict: 'id',
+    });
+
+    return inserted ? 1 : 0;
+  }
+
+  private async update(state: VersionedDelegation, expected: number): Promise<number> {
+    return tableOf(this.database)
+      .where({ id: state.id, version: expected })
+      .update({ ...state, ...auditRow(stampUpdate(this.scope, this.clock)) });
+  }
+}
+
+/** A function and not a method: a query builder is thenable, and a method that answers one is read as asynchronous by whatever wraps the adapter (tracing), which then answers a promise. */
+function tableOf(database: KnexContext): Knex.QueryBuilder<DelegationRow, DelegationRow[]> {
+{{#if tenancy.any}}
+  // ddd-ts-kit-disable-next-line tenancy/scoped-statement -- {{preset.adr}}: the {{context.kebab}} context is the control plane of the tenants, and its rows belong to none of them.
+{{/if}}
+  const table = database.executor()<DelegationRow, DelegationRow[]>('delegations');
+
+  return table.withSchema({{context.constant}}_SCHEMA);
+}