ddd-ts-kit 0.14.0 → 0.15.0

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

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

@@ -0,0 +1,67 @@
+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 { Invitation } from '{{alias.context}}/domain/aggregates/invitation.aggregate{{alias.ext}}';
+import { InvitationRepository } from '{{alias.context}}/domain/repositories/invitation.repository{{alias.ext}}';
+import { {{context.constant}}_SCHEMA } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { InvitationMapper } from '{{alias.context}}/infrastructure/persistence/invitation.mapper{{alias.ext}}';
+import type { InvitationColumns, InvitationRow } from '{{alias.context}}/infrastructure/persistence/invitation-row.schema{{alias.ext}}';
+
+type VersionedInvitation = InvitationColumns & { readonly version: number };
+
+@Repository(InvitationRepository)
+export class KnexInvitationRepository implements InvitationRepository {
+  constructor(
+    private readonly database: KnexContext,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Invitation | undefined> {
+    const row = await tableOf(this.database).where({ id }).first();
+
+    return row === undefined ? undefined : InvitationMapper.toDomain(row);
+  }
+
+  async findByTokenHash(tokenHash: string): Promise<Invitation | undefined> {
+    const row = await tableOf(this.database).where({ token_hash: tokenHash }).first();
+
+    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 };
+
+      return expected === 0 ? this.insert(state) : this.update(state, expected);
+    });
+  }
+
+  private async insert(state: VersionedInvitation): 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: VersionedInvitation, 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<InvitationRow, InvitationRow[]> {
+{{#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()<InvitationRow, InvitationRow[]>('invitations');
+
+  return table.withSchema({{context.constant}}_SCHEMA);
+}

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

@@ -0,0 +1,82 @@
+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 { 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 { {{context.constant}}_SCHEMA } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { MemberMapper } from '{{alias.context}}/infrastructure/persistence/member.mapper{{alias.ext}}';
+import type { MemberColumns, MemberRow } from '{{alias.context}}/infrastructure/persistence/member-row.schema{{alias.ext}}';
+
+type VersionedMember = MemberColumns & { readonly version: number };
+
+@Repository(MemberRepository)
+export class KnexMemberRepository implements MemberRepository {
+  constructor(
+    private readonly database: KnexContext,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Member | undefined> {
+    const row = await tableOf(this.database).where({ id }).first();
+
+    return row === undefined ? undefined : MemberMapper.toDomain(row);
+  }
+
+  async findOf(organisationId: string, accountId: string): Promise<Member | undefined> {
+    const current = { organisation_id: organisationId, account_id: accountId };
+    const row = await tableOf(this.database).where(current).whereNull('removed_at').first();
+
+    return row === undefined ? undefined : MemberMapper.toDomain(row);
+  }
+
+  async searchCurrentOf(accountId: string): Promise<readonly Member[]> {
+    const rows = await tableOf(this.database).where({ account_id: accountId }).whereNull('removed_at').orderBy('id');
+
+    return rows.map((row) => MemberMapper.toDomain(row));
+  }
+
+  async countOwners(organisationId: string): Promise<number> {
+    const owners = { organisation_id: organisationId, role: MemberRole.Owner };
+    const counted = await tableOf(this.database).where(owners).whereNull('removed_at').count({ total: '*' }).first();
+
+    return Number(counted?.total ?? 0);
+  }
+
+  async save(saved: Member): Promise<void> {
+    await optimisticUpdate(saved, async ({ expected, next }) => {
+      const state = { ...MemberMapper.toRow(saved), version: next };
+
+      return expected === 0 ? this.insert(state) : this.update(state, expected);
+    });
+  }
+
+  private async insert(state: VersionedMember): 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: VersionedMember, 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<MemberRow, MemberRow[]> {
+{{#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()<MemberRow, MemberRow[]>('members');
+
+  return table.withSchema({{context.constant}}_SCHEMA);
+}

package/templates/presets/identity/context/infrastructure/persistence/knex-organisation.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 { Organisation } from '{{alias.context}}/domain/aggregates/organisation.aggregate{{alias.ext}}';
+import { OrganisationRepository } from '{{alias.context}}/domain/repositories/organisation.repository{{alias.ext}}';
+import { {{context.constant}}_SCHEMA } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import { OrganisationMapper } from '{{alias.context}}/infrastructure/persistence/organisation.mapper{{alias.ext}}';
+import type { OrganisationColumns, OrganisationRow } from '{{alias.context}}/infrastructure/persistence/organisation-row.schema{{alias.ext}}';
+
+type VersionedOrganisation = OrganisationColumns & { readonly version: number };
+
+@Repository(OrganisationRepository)
+export class KnexOrganisationRepository implements OrganisationRepository {
+  constructor(
+    private readonly database: KnexContext,
+    private readonly scope: ExecutionScope,
+    private readonly clock: Clock,
+  ) {}
+
+  async findById(id: string): Promise<Organisation | undefined> {
+    const row = await tableOf(this.database).where({ id }).first();
+
+    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 };
+
+      return expected === 0 ? this.insert(state) : this.update(state, expected);
+    });
+  }
+
+  private async insert(state: VersionedOrganisation): 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: VersionedOrganisation, 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<OrganisationRow, OrganisationRow[]> {
+{{#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()<OrganisationRow, OrganisationRow[]>('organisations');
+
+  return table.withSchema({{context.constant}}_SCHEMA);
+}

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

@@ -0,0 +1,77 @@
+import type { Knex } from 'knex';
+import { InvalidPageRequestError, pageOf, type PageRequest } from '@ddd-ts-kit/kernel';
+import { Repository } from '@ddd-ts-kit/kernel/declarations';
+import type { KnexContext } from '@ddd-ts-kit/knex';
+import { 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}}';
+import { {{context.constant}}_SCHEMA } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+import type { MemberRow } from '{{alias.context}}/infrastructure/persistence/member-row.schema{{alias.ext}}';
+
+interface MemberLine extends Pick<MemberRow, 'id' | 'account_id' | 'role' | 'joined_at'> {
+  readonly display_name: string;
+  readonly email: string;
+}
+
+const COLUMNS = [
+  'members.id',
+  'members.account_id',
+  'members.role',
+  'members.joined_at',
+  'accounts.display_name',
+  'accounts.email',
+];
+
+/** 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 KnexSearchMembersReader implements SearchMembersReader {
+  constructor(private readonly database: KnexContext) {}
+
+  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 direction = page.sort[0]?.direction ?? 'asc';
+    const current = { 'members.organisation_id': organisationId, 'members.removed_at': null };
+
+    const rows = await membersOf(this.database)
+      .select<MemberLine[]>(COLUMNS)
+      .join('accounts', 'accounts.id', 'members.account_id')
+      .where(current)
+      .orderBy([
+        { column: 'members.joined_at', order: direction },
+        { column: 'members.id', order: direction },
+      ])
+      .limit(page.limit)
+      .offset(page.offset);
+
+    const counted = await membersOf(this.database).where(current).count<{ total: string | number }[]>({ total: '*' }).first();
+
+    return pageOf(rows.map(toItem), { total: Number(counted?.total ?? 0) });
+  }
+}
+
+/** 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 membersOf(database: KnexContext): Knex.QueryBuilder<MemberLine, MemberLine[]> {
+{{#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 members = database.executor()<MemberLine, MemberLine[]>('members');
+
+  return members.withSchema({{context.constant}}_SCHEMA);
+}
+
+function toItem(line: MemberLine): SearchMembersItem {
+  return {
+    memberId: line.id,
+    accountId: line.account_id,
+    displayName: line.display_name,
+    email: line.email,
+    role: line.role,
+    joinedAt: line.joined_at,
+  };
+}

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

@@ -0,0 +1,15 @@
+import type { AuditRow } from '@ddd-ts-kit/knex';
+import type { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+export interface MemberColumns {
+  readonly id: string;
+  readonly organisation_id: string;
+  readonly account_id: string;
+  readonly role: MemberRole;
+  readonly joined_at: Date;
+  readonly removed_at: Date | null;
+}
+
+export interface MemberRow extends MemberColumns, AuditRow {
+  readonly version: number;
+}

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

@@ -0,0 +1,36 @@
+import type { AuditStamp } from '@ddd-ts-kit/kernel';
+import { Member } from '{{alias.context}}/domain/aggregates/member.aggregate{{alias.ext}}';
+import type { members } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+
+type MemberRow = typeof members.$inferSelect;
+
+export type MemberColumns = Omit<MemberRow, 'version' | keyof AuditStamp>;
+
+export const MemberMapper = {
+  toDomain(row: MemberRow): Member {
+    const loaded = Member.rehydrate(row.id, {
+      organisationId: row.organisationId,
+      accountId: row.accountId,
+      role: row.role,
+      joinedAt: row.joinedAt,
+      removedAt: row.removedAt ?? undefined,
+    });
+
+    loaded.version = row.version;
+
+    return loaded;
+  },
+
+  toRow(saved: Member): MemberColumns {
+    const state = saved.toState();
+
+    return {
+      id: saved.id,
+      organisationId: state.organisationId,
+      accountId: state.accountId,
+      role: state.role,
+      joinedAt: state.joinedAt,
+      removedAt: state.removedAt ?? null,
+    };
+  },
+};

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

@@ -0,0 +1,31 @@
+import { Member } from '{{alias.context}}/domain/aggregates/member.aggregate{{alias.ext}}';
+import type { MemberColumns, MemberRow } from '{{alias.context}}/infrastructure/persistence/member-row.schema{{alias.ext}}';
+
+export const MemberMapper = {
+  toDomain(row: MemberRow): Member {
+    const loaded = Member.rehydrate(row.id, {
+      organisationId: row.organisation_id,
+      accountId: row.account_id,
+      role: row.role,
+      joinedAt: row.joined_at,
+      removedAt: row.removed_at ?? undefined,
+    });
+
+    loaded.version = row.version;
+
+    return loaded;
+  },
+
+  toRow(saved: Member): MemberColumns {
+    const state = saved.toState();
+
+    return {
+      id: saved.id,
+      organisation_id: state.organisationId,
+      account_id: state.accountId,
+      role: state.role,
+      joined_at: state.joinedAt,
+      removed_at: state.removedAt ?? null,
+    };
+  },
+};

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

@@ -0,0 +1,12 @@
+import type { AuditRow } from '@ddd-ts-kit/knex';
+
+export interface OrganisationColumns {
+  readonly id: string;
+  readonly name: string;
+  readonly opened_by: string;
+  readonly opened_at: Date;
+}
+
+export interface OrganisationRow extends OrganisationColumns, AuditRow {
+  readonly version: number;
+}

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

@@ -0,0 +1,28 @@
+import type { AuditStamp } from '@ddd-ts-kit/kernel';
+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 type { organisations } from '{{alias.context}}/infrastructure/persistence/{{context.kebab}}.schema{{alias.ext}}';
+
+type OrganisationRow = typeof organisations.$inferSelect;
+
+export type OrganisationColumns = Omit<OrganisationRow, 'version' | keyof AuditStamp>;
+
+export const OrganisationMapper = {
+  toDomain(row: OrganisationRow): Organisation {
+    const loaded = Organisation.rehydrate(row.id, {
+      name: OrganisationName.create(row.name),
+      openedBy: row.openedBy,
+      openedAt: row.openedAt,
+    });
+
+    loaded.version = row.version;
+
+    return loaded;
+  },
+
+  toRow(saved: Organisation): OrganisationColumns {
+    const state = saved.toState();
+
+    return { id: saved.id, name: state.name.value, openedBy: state.openedBy, openedAt: state.openedAt };
+  },
+};