ddd-ts-kit 0.14.0 → 0.15.0

package/templates/presets/identity/context/infrastructure/persistence/create-__context__-tables.schema.knex.ts.tpl

@@ -0,0 +1,107 @@
+// ddd-ts-kit:imports
+import type { Knex } from 'knex';
+import { {{context.constant}}_SCHEMA } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { auditColumns } from '@ddd-ts-kit/knex';
+// /ddd-ts-kit:imports
+
+/**
+ * The tables of {{context.kebab}}: what the provider authenticates stays with it, no password is stored.
+{{#if tenancy.any}}
+ * They hold no tenant column: the organisations are the tenants, and this context decides who
+ * belongs to which ({{preset.adr}}).
+{{/if}}
+ */
+export async function create{{context.pascal}}Tables(knex: Knex): Promise<void> {
+  await knex.schema.createSchemaIfNotExists({{context.constant}}_SCHEMA);
+  // ddd-ts-kit:tables
+  await createAccountTable(knex);
+  await createOrganisationTable(knex);
+  await createMemberTable(knex);
+  await createInvitationTable(knex);
+  await createDelegationTable(knex);
+  // /ddd-ts-kit:tables
+}
+
+// ddd-ts-kit:definitions
+/** Keyed by the subject the identity provider gives the person. */
+function createAccountTable(knex: Knex): Promise<void> {
+  return knex.schema.withSchema({{context.constant}}_SCHEMA).createTable('accounts', (table) => {
+    table.text('id').primary();
+    table.text('email').notNullable();
+    table.text('display_name').notNullable();
+    table.text('status').notNullable();
+    table.timestamp('provisioned_at', { useTz: true }).notNullable();
+    table.timestamp('deactivated_at', { useTz: true });
+    table.integer('version').notNullable();
+    auditColumns(table);
+  });
+}
+
+/** Keyed by the slug, which is also the tenant id when the project has tenants. */
+function createOrganisationTable(knex: Knex): Promise<void> {
+  return knex.schema.withSchema({{context.constant}}_SCHEMA).createTable('organisations', (table) => {
+    table.text('id').primary();
+    table.text('name').notNullable();
+    table.text('opened_by').notNullable();
+    table.timestamp('opened_at', { useTz: true }).notNullable();
+    table.integer('version').notNullable();
+    auditColumns(table);
+  });
+}
+
+/** One current membership per account and organisation: the partial unique index is the guard. */
+function createMemberTable(knex: Knex): Promise<void> {
+  return knex.schema.withSchema({{context.constant}}_SCHEMA).createTable('members', (table) => {
+    table.text('id').primary();
+    table.text('organisation_id').notNullable();
+    table.text('account_id').notNullable();
+    table.text('role').notNullable();
+    table.timestamp('joined_at', { useTz: true }).notNullable();
+    table.timestamp('removed_at', { useTz: true });
+
+    table.unique(['organisation_id', 'account_id'], {
+      indexName: 'members_current_idx',
+      predicate: knex.whereNull('removed_at'),
+    });
+
+    table.index(['account_id']);
+    table.integer('version').notNullable();
+    auditColumns(table);
+  });
+}
+
+function createInvitationTable(knex: Knex): Promise<void> {
+  return knex.schema.withSchema({{context.constant}}_SCHEMA).createTable('invitations', (table) => {
+    table.text('id').primary();
+    table.text('organisation_id').notNullable();
+    table.text('email').notNullable();
+    table.text('role').notNullable();
+    table.text('token_hash').notNullable().unique();
+    table.text('invited_by').notNullable();
+    table.timestamp('issued_at', { useTz: true }).notNullable();
+    table.timestamp('expires_at', { useTz: true }).notNullable();
+    table.text('status').notNullable();
+    table.timestamp('answered_at', { useTz: true });
+    table.index(['organisation_id', 'status']);
+    table.integer('version').notNullable();
+    auditColumns(table);
+  });
+}
+
+function createDelegationTable(knex: Knex): Promise<void> {
+  return knex.schema.withSchema({{context.constant}}_SCHEMA).createTable('delegations', (table) => {
+    table.text('id').primary();
+    table.text('organisation_id').notNullable();
+    table.text('delegator_id').notNullable();
+    table.text('delegate_id').notNullable();
+    table.text('rights').notNullable();
+    table.timestamp('starts_at', { useTz: true }).notNullable();
+    table.timestamp('ends_at', { useTz: true }).notNullable();
+    table.timestamp('ended_at', { useTz: true });
+    table.index(['organisation_id', 'delegate_id']);
+    table.index(['organisation_id', 'delegator_id']);
+    table.integer('version').notNullable();
+    auditColumns(table);
+  });
+}
+// /ddd-ts-kit:definitions

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

@@ -0,0 +1,17 @@
+import type { AuditRow } from '@ddd-ts-kit/knex';
+
+export interface DelegationColumns {
+  readonly id: string;
+  readonly organisation_id: string;
+  readonly delegator_id: string;
+  readonly delegate_id: string;
+  /** The rights lent, separated by commas: a right is a word of `MemberRight`, which holds none. */
+  readonly rights: string;
+  readonly starts_at: Date;
+  readonly ends_at: Date;
+  readonly ended_at: Date | null;
+}
+
+export interface DelegationRow extends DelegationColumns, AuditRow {
+  readonly version: number;
+}

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

@@ -0,0 +1,50 @@
+import type { AuditStamp } from '@ddd-ts-kit/kernel';
+import { Delegation } from '{{alias.context}}/domain/aggregates/delegation.aggregate{{alias.ext}}';
+import { DelegationPeriod } from '{{alias.context}}/domain/value-objects/delegation-period.vo{{alias.ext}}';
+import { MemberRight } from '{{alias.context}}/domain/vocabularies/member-right.vocabulary{{alias.ext}}';
+import type { delegations } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+
+const SEPARATOR = ',';
+
+type DelegationRow = typeof delegations.$inferSelect;
+
+export type DelegationColumns = Omit<DelegationRow, 'version' | keyof AuditStamp>;
+
+export const DelegationMapper = {
+  toDomain(row: DelegationRow): Delegation {
+    const loaded = Delegation.rehydrate(row.id, {
+      organisationId: row.organisationId,
+      delegatorId: row.delegatorId,
+      delegateId: row.delegateId,
+      rights: rightsOf(row.rights),
+      period: DelegationPeriod.create(row.startsAt, row.endsAt),
+      endedAt: row.endedAt ?? undefined,
+    });
+
+    loaded.version = row.version;
+
+    return loaded;
+  },
+
+  toRow(saved: Delegation): DelegationColumns {
+    const state = saved.toState();
+
+    return {
+      id: saved.id,
+      organisationId: state.organisationId,
+      delegatorId: state.delegatorId,
+      delegateId: state.delegateId,
+      rights: state.rights.join(SEPARATOR),
+      startsAt: state.period.startsAt,
+      endsAt: state.period.endsAt,
+      endedAt: state.endedAt ?? null,
+    };
+  },
+};
+
+/** The rights of a stored delegation, those the vocabulary no longer names left out. */
+function rightsOf(stored: string): MemberRight[] {
+  const lent = stored.split(SEPARATOR);
+
+  return Object.values(MemberRight).filter((right) => lent.includes(right));
+}

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

@@ -0,0 +1,45 @@
+import { Delegation } from '{{alias.context}}/domain/aggregates/delegation.aggregate{{alias.ext}}';
+import { DelegationPeriod } from '{{alias.context}}/domain/value-objects/delegation-period.vo{{alias.ext}}';
+import { MemberRight } from '{{alias.context}}/domain/vocabularies/member-right.vocabulary{{alias.ext}}';
+import type { DelegationColumns, DelegationRow } from '{{alias.context}}/infrastructure/persistence/delegation-row.schema{{alias.ext}}';
+
+const SEPARATOR = ',';
+
+export const DelegationMapper = {
+  toDomain(row: DelegationRow): Delegation {
+    const loaded = Delegation.rehydrate(row.id, {
+      organisationId: row.organisation_id,
+      delegatorId: row.delegator_id,
+      delegateId: row.delegate_id,
+      rights: rightsOf(row.rights),
+      period: DelegationPeriod.create(row.starts_at, row.ends_at),
+      endedAt: row.ended_at ?? undefined,
+    });
+
+    loaded.version = row.version;
+
+    return loaded;
+  },
+
+  toRow(saved: Delegation): DelegationColumns {
+    const state = saved.toState();
+
+    return {
+      id: saved.id,
+      organisation_id: state.organisationId,
+      delegator_id: state.delegatorId,
+      delegate_id: state.delegateId,
+      rights: state.rights.join(SEPARATOR),
+      starts_at: state.period.startsAt,
+      ends_at: state.period.endsAt,
+      ended_at: state.endedAt ?? null,
+    };
+  },
+};
+
+/** The rights of a stored delegation, those the vocabulary no longer names left out. */
+function rightsOf(stored: string): MemberRight[] {
+  const lent = stored.split(SEPARATOR);
+
+  return Object.values(MemberRight).filter((right) => lent.includes(right));
+}

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;
+}