ddd-ts-kit 0.13.0 → 0.15.0

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

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

@@ -0,0 +1,26 @@
+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 {
+  OrganisationColumns,
+  OrganisationRow,
+} from '{{alias.context}}/infrastructure/persistence/organisation-row.schema{{alias.ext}}';
+
+export const OrganisationMapper = {
+  toDomain(row: OrganisationRow): Organisation {
+    const loaded = Organisation.rehydrate(row.id, {
+      name: OrganisationName.create(row.name),
+      openedBy: row.opened_by,
+      openedAt: row.opened_at,
+    });
+
+    loaded.version = row.version;
+
+    return loaded;
+  },
+
+  toRow(saved: Organisation): OrganisationColumns {
+    const state = saved.toState();
+
+    return { id: saved.id, name: state.name.value, opened_by: state.openedBy, opened_at: state.openedAt };
+  },
+};

package/templates/presets/identity/context/presentation/http/accounts/deactivate-account/deactivate-account.accepted.class-validator.per-route.ts.tpl

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class DeactivateAccountAccepted {
+  @IsString()
+  id = '';
+}

package/templates/presets/identity/context/presentation/http/accounts/deactivate-account/deactivate-account.controller.ts.tpl

@@ -0,0 +1,71 @@
+{{#if validation.classValidator}}
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+{{#if schemas.perRoute}}
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+{{/if}}
+import { DeactivateAccountCommand } from '{{alias.context}}/application/commands/deactivate-account/deactivate-account.command{{alias.ext}}';
+{{#if schemas.perRoute}}
+import { DeactivateAccountAccepted } from '{{alias.context}}/presentation/http/accounts/deactivate-account/deactivate-account.accepted{{alias.ext}}';
+{{/if}}
+import { AccountsRoutes } from '{{alias.context}}/presentation/http/accounts.routes{{alias.ext}}';
+{{/if}}
+{{#if validation.zod}}
+{{#if schemas.perRoute}}
+import { z } from 'zod';
+{{/if}}
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+{{#if schemas.perRoute}}
+import type { Infer } from '@ddd-ts-kit/validation';
+{{/if}}
+{{#if schemas.perRoute}}
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+{{/if}}
+import { DeactivateAccountCommand } from '{{alias.context}}/application/commands/deactivate-account/deactivate-account.command{{alias.ext}}';
+import { AccountsRoutes } from '{{alias.context}}/presentation/http/accounts.routes{{alias.ext}}';
+{{/if}}
+
+{{#if validation.classValidator}}
+{{#if schemas.perRoute}}
+const accepted = classSchema(DeactivateAccountAccepted);
+{{/if}}
+{{/if}}
+{{#if validation.zod}}
+{{#if schemas.perRoute}}
+const accepted = zodSchema(z.object({ id: z.string() }), { io: 'output' });
+{{/if}}
+{{/if}}
+
+@Controller({
+  group: AccountsRoutes,
+  method: 'POST',
+  path: '/me/deactivation',
+  summary: 'Deactivate my account',
+  response: { status: 200, description: 'The account is deactivated; the body carries its identifier.', body: {{#if schemas.shared}}acceptedSchema{{/if}}{{#if schemas.perRoute}}accepted{{/if}} },
+  errors: ['ACCOUNT_NOT_FOUND', 'ACCOUNT_ALREADY_DEACTIVATED', 'ORGANISATION_NOT_FOUND', 'LAST_OWNER'],
+})
+export class DeactivateAccountController {
+  constructor(private readonly commands: CommandBus) {}
+
+{{#if validation.classValidator}}
+  async handle(request: HttpRequest<object>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}DeactivateAccountAccepted{{/if}}> {
+{{/if}}
+{{#if validation.zod}}
+  async handle(request: HttpRequest<object>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}Infer<typeof accepted>{{/if}}> {
+{{/if}}
+    const id = await this.commands.execute(new DeactivateAccountCommand(request.actor));
+
+    return { id };
+  }
+}

package/templates/presets/identity/context/presentation/http/accounts/provision-account/provision-account.accepted.class-validator.per-route.ts.tpl

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class ProvisionAccountAccepted {
+  @IsString()
+  id = '';
+}

package/templates/presets/identity/context/presentation/http/accounts/provision-account/provision-account.body.class-validator.ts.tpl

@@ -0,0 +1,9 @@
+import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class ProvisionAccountBody {
+  /** Left out, the name the token gives; the email address is always the one of the token. */
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  displayName?: string;
+}

package/templates/presets/identity/context/presentation/http/accounts/provision-account/provision-account.controller.ts.tpl

@@ -0,0 +1,85 @@
+{{#if validation.classValidator}}
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { Actor, CommandBus } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { ProvisionAccountCommand } from '{{alias.context}}/application/commands/provision-account/provision-account.command{{alias.ext}}';
+import { ProvisionAccountBody } from '{{alias.context}}/presentation/http/accounts/provision-account/provision-account.body{{alias.ext}}';
+{{#if schemas.perRoute}}
+import { ProvisionAccountAccepted } from '{{alias.context}}/presentation/http/accounts/provision-account/provision-account.accepted{{alias.ext}}';
+{{/if}}
+import { AccountsRoutes } from '{{alias.context}}/presentation/http/accounts.routes{{alias.ext}}';
+{{/if}}
+{{#if validation.zod}}
+import { z } from 'zod';
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { Actor, CommandBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+import { ProvisionAccountCommand } from '{{alias.context}}/application/commands/provision-account/provision-account.command{{alias.ext}}';
+import { AccountsRoutes } from '{{alias.context}}/presentation/http/accounts.routes{{alias.ext}}';
+{{/if}}
+
+{{#if validation.classValidator}}
+const body = classSchema(ProvisionAccountBody);
+{{#if schemas.perRoute}}
+const accepted = classSchema(ProvisionAccountAccepted);
+{{/if}}
+{{/if}}
+{{#if validation.zod}}
+const body = zodSchema(
+  z.object({
+    displayName: z.string().min(1).optional(),
+  }),
+);
+
+{{#if schemas.perRoute}}
+const accepted = zodSchema(z.object({ id: z.string() }), { io: 'output' });
+{{/if}}
+{{/if}}
+
+@Controller({
+  group: AccountsRoutes,
+  method: 'PUT',
+  path: '/me',
+  summary: 'Provision my account',
+  body,
+  response: { status: 200, description: 'The account, provisioned or refreshed; the body carries its identifier.', body: {{#if schemas.shared}}acceptedSchema{{/if}}{{#if schemas.perRoute}}accepted{{/if}} },
+  errors: ['EMAIL_NOT_VERIFIED', 'INVALID_EMAIL_ADDRESS', 'INVALID_DISPLAY_NAME', 'ACCOUNT_DEACTIVATED'],
+})
+export class ProvisionAccountController {
+  constructor(private readonly commands: CommandBus) {}
+
+{{#if validation.classValidator}}
+  async handle(request: HttpRequest<{ body: ProvisionAccountBody }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}ProvisionAccountAccepted{{/if}}> {
+{{/if}}
+{{#if validation.zod}}
+  async handle(request: HttpRequest<{ body: Infer<typeof body> }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}Infer<typeof accepted>{{/if}}> {
+{{/if}}
+    const id = await this.commands.execute(new ProvisionAccountCommand(request.actor, profileOf(request.actor, request.body.displayName)));
+
+    return { id };
+  }
+}
+
+/**
+ * The token is the authority on who the person is: their address comes from it, never from the
+ * body, and with whether the provider verified it (`email_verified`), so that nobody accepts an
+ * invitation sent to someone else by registering their address unverified.
+ */
+function profileOf(actor: Actor, displayName: string | undefined): ProvisionAccountCommand['profile'] {
+  const { email, emailVerified, username } = actor.attributes;
+  const address = typeof email === 'string' ? email : '';
+  const named = displayName ?? (typeof username === 'string' ? username : address);
+
+  return { email: address, emailVerified: emailVerified === true, displayName: named };
+}

package/templates/presets/identity/context/presentation/http/accounts.routes.ts.tpl

@@ -0,0 +1,5 @@
+import { Authenticated, RouteGroup } from '@ddd-ts-kit/http';
+
+/** The account of the person who calls: every route is about the caller, named by their token. */
+@RouteGroup({ prefix: '/accounts', tags: ['{{context.kebab}}'], guards: [Authenticated], errors: ['FORBIDDEN'] })
+export class AccountsRoutes {}

package/templates/presets/identity/context/presentation/http/invitations/accept-invitation/accept-invitation.accepted.class-validator.per-route.ts.tpl

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class AcceptInvitationAccepted {
+  @IsString()
+  id = '';
+}

package/templates/presets/identity/context/presentation/http/invitations/accept-invitation/accept-invitation.body.class-validator.per-route.ts.tpl

@@ -0,0 +1,8 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class AcceptInvitationBody {
+  /** The token the invitation was sent with. */
+  @IsString()
+  @IsNotEmpty()
+  token = '';
+}