ddd-ts-kit 0.14.0 → 0.16.0

package/templates/presets/identity/context/presentation/http/organisations/search-members/search-members.controller.ts.tpl

@@ -0,0 +1,86 @@
+{{#if validation.classValidator}}
+import {
+  Controller,
+  pageQuerySchema,
+  pageResponse,
+  pageSchemaOf,
+  type HttpRequest,
+  type PageBody,
+} from '@ddd-ts-kit/http';
+import type { QueryBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { SearchMembersQuery } from '{{alias.context}}/application/queries/search-members/search-members.query{{alias.ext}}';
+import type { SearchMembersItem } from '{{alias.context}}/application/queries/search-members/search-members.result{{alias.ext}}';
+import { SearchMembersLine } from '{{alias.context}}/presentation/http/organisations/search-members/search-members.line{{alias.ext}}';
+import { SearchMembersParams } from '{{alias.context}}/presentation/http/organisations/search-members/search-members.params{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+
+const params = classSchema(SearchMembersParams);
+const query = pageQuerySchema({ sortable: ['joinedAt'], maxSize: 100, kind: 'offset' });
+const line = classSchema(SearchMembersLine);
+{{/if}}
+{{#if validation.zod}}
+import { z } from 'zod';
+import {
+  Controller,
+  pageQuerySchema,
+  pageResponse,
+  pageSchemaOf,
+  type HttpRequest,
+  type PageBody,
+} from '@ddd-ts-kit/http';
+import type { QueryBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+import { SearchMembersQuery } from '{{alias.context}}/application/queries/search-members/search-members.query{{alias.ext}}';
+import type { SearchMembersItem } from '{{alias.context}}/application/queries/search-members/search-members.result{{alias.ext}}';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+
+const params = zodSchema(z.object({ organisationId: z.string().min(1) }));
+const query = pageQuerySchema({ sortable: ['joinedAt'], maxSize: 100, kind: 'offset' });
+
+const line = zodSchema(
+  z.object({
+    memberId: z.string(),
+    accountId: z.string(),
+    displayName: z.string(),
+    email: z.string(),
+    role: z.enum(MemberRole),
+    joinedAt: z.iso.datetime(),
+  }),
+  { io: 'output' },
+);
+
+type SearchMembersLine = Infer<typeof line>;
+{{/if}}
+
+/** A page of the current members of an organisation, for its members. */
+@Controller({
+  group: OrganisationsRoutes,
+  method: 'GET',
+  path: '/:organisationId/members',
+  summary: 'Search the members of an organisation',
+  params,
+  query,
+  response: { status: 200, description: 'One page of the members.', body: pageSchemaOf(line) },
+  errors: [],
+})
+export class SearchMembersController {
+  constructor(private readonly queries: QueryBus) {}
+
+  async handle(
+    request: HttpRequest<{ params: Infer<typeof params>; query: Infer<typeof query> }>,
+  ): Promise<PageBody<SearchMembersLine>> {
+    const page = await this.queries.execute(
+      new SearchMembersQuery(request.actor, request.params.organisationId, request.query),
+    );
+
+    return pageResponse(page, toLine);
+  }
+}
+
+function toLine(item: SearchMembersItem): SearchMembersLine {
+  return { ...item, joinedAt: item.joinedAt.toISOString() };
+}

package/templates/presets/identity/context/presentation/http/organisations/search-members/search-members.line.class-validator.ts.tpl

@@ -0,0 +1,22 @@
+import { IsEmail, IsIn, IsISO8601, IsString } from 'class-validator';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+export class SearchMembersLine {
+  @IsString()
+  memberId = '';
+
+  @IsString()
+  accountId = '';
+
+  @IsString()
+  displayName = '';
+
+  @IsEmail()
+  email = '';
+
+  @IsIn(Object.values(MemberRole))
+  role = '';
+
+  @IsISO8601()
+  joinedAt = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/search-members/search-members.params.class-validator.ts.tpl

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class SearchMembersParams {
+  @IsString()
+  @IsNotEmpty()
+  organisationId = '';
+}

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

@@ -0,0 +1,5 @@
+import { Authenticated, RouteGroup } from '@ddd-ts-kit/http';
+
+/** The organisations, their members, their invitations and their delegations: inside one, the policies of the context decide. */
+@RouteGroup({ prefix: '/organisations', tags: ['{{context.kebab}}'], guards: [Authenticated], errors: ['FORBIDDEN'] })
+export class OrganisationsRoutes {}

package/templates/presets/identity/context/presentation/http/shared/invitation-token.schema.class-validator.shared.ts.tpl

@@ -0,0 +1,9 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+/** What a person names an invitation by, to accept or to decline it: declared once, the contract documents it once. */
+export class InvitationToken {
+  /** The token the invitation was sent with. */
+  @IsString()
+  @IsNotEmpty()
+  token = '';
+}

package/templates/presets/identity/context/presentation/http/shared/invitation-token.schema.zod.shared.ts.tpl

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+/** What a person names an invitation by, to accept or to decline it: declared once, the contract documents it once. */
+export const invitationTokenSchema = z
+  .object({
+    /** The token the invitation was sent with. */
+    token: z.string().min(1),
+  })
+  .meta({ id: 'InvitationToken' });

package/templates/presets/identity/context/published-language/account-deactivated.v1.integration-event.ts.tpl

@@ -0,0 +1,33 @@
+{{#if validation.zod}}
+import { z } from 'zod';
+import { defineIntegrationEvent, type PayloadOf } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+{{/if}}
+{{#if validation.classValidator}}
+import { defineIntegrationEvent } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { AccountDeactivatedV1Payload } from '{{alias.context}}/published-language/account-deactivated.v1.payload{{alias.ext}}';
+{{/if}}
+
+export const accountDeactivatedV1 = defineIntegrationEvent({
+  type: '{{context.kebab}}.account.deactivated',
+  version: 1,
+  description: 'An account was deactivated: its person signs in no more, and every context stops acting for it.',
+{{#if validation.zod}}
+  payload: zodSchema(
+    z.object({
+      accountId: z.string(),
+    }),
+  ),
+{{/if}}
+{{#if validation.classValidator}}
+  payload: classSchema(AccountDeactivatedV1Payload),
+{{/if}}
+});
+
+{{#if validation.zod}}
+export type AccountDeactivatedV1Payload = PayloadOf<typeof accountDeactivatedV1>;
+{{/if}}
+export type AccountDeactivatedV1 = IntegrationEvent<AccountDeactivatedV1Payload>;

package/templates/presets/identity/context/published-language/account-deactivated.v1.payload.class-validator.ts.tpl

@@ -0,0 +1,7 @@
+import { IsString } from 'class-validator';
+
+/** An account was deactivated: its person signs in no more, and every context stops acting for it. Version 1: a field may be added, never renamed nor removed. */
+export class AccountDeactivatedV1Payload {
+  @IsString()
+  accountId = '';
+}

package/templates/presets/identity/context/published-language/delegation-granted.v1.integration-event.ts.tpl

@@ -0,0 +1,39 @@
+{{#if validation.zod}}
+import { z } from 'zod';
+import { defineIntegrationEvent, type PayloadOf } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+{{/if}}
+{{#if validation.classValidator}}
+import { defineIntegrationEvent } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { DelegationGrantedV1Payload } from '{{alias.context}}/published-language/delegation-granted.v1.payload{{alias.ext}}';
+{{/if}}
+
+export const delegationGrantedV1 = defineIntegrationEvent({
+  type: '{{context.kebab}}.delegation.granted',
+  version: 1,
+  description: 'A member lent rights to another member of the organisation, from an instant to another.',
+{{#if validation.zod}}
+  payload: zodSchema(
+    z.object({
+      delegationId: z.string(),
+      organisationId: z.string(),
+      delegatorId: z.string(),
+      delegateId: z.string(),
+      rights: z.array(z.string()),
+      startsAt: z.iso.datetime(),
+      endsAt: z.iso.datetime(),
+    }),
+  ),
+{{/if}}
+{{#if validation.classValidator}}
+  payload: classSchema(DelegationGrantedV1Payload),
+{{/if}}
+});
+
+{{#if validation.zod}}
+export type DelegationGrantedV1Payload = PayloadOf<typeof delegationGrantedV1>;
+{{/if}}
+export type DelegationGrantedV1 = IntegrationEvent<DelegationGrantedV1Payload>;

package/templates/presets/identity/context/published-language/delegation-granted.v1.payload.class-validator.ts.tpl

@@ -0,0 +1,28 @@
+import { IsArray, IsISO8601, IsString } from 'class-validator';
+
+/** A member lent rights to another member of the organisation, from an instant to another. Version 1: a field may be added, never renamed nor removed. */
+export class DelegationGrantedV1Payload {
+  @IsString()
+  delegationId = '';
+
+  @IsString()
+  organisationId = '';
+
+  @IsString()
+  delegatorId = '';
+
+  @IsString()
+  delegateId = '';
+
+  @IsArray()
+  @IsString({ each: true })
+  rights: string[] = [];
+
+  /** An ISO 8601 instant. */
+  @IsISO8601()
+  startsAt = '';
+
+  /** An ISO 8601 instant. */
+  @IsISO8601()
+  endsAt = '';
+}

package/templates/presets/identity/context/published-language/delegation-revoked.v1.integration-event.ts.tpl

@@ -0,0 +1,36 @@
+{{#if validation.zod}}
+import { z } from 'zod';
+import { defineIntegrationEvent, type PayloadOf } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+{{/if}}
+{{#if validation.classValidator}}
+import { defineIntegrationEvent } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { DelegationRevokedV1Payload } from '{{alias.context}}/published-language/delegation-revoked.v1.payload{{alias.ext}}';
+{{/if}}
+
+export const delegationRevokedV1 = defineIntegrationEvent({
+  type: '{{context.kebab}}.delegation.revoked',
+  version: 1,
+  description: 'A delegation ended before its period: what it lent, the delegate holds no more.',
+{{#if validation.zod}}
+  payload: zodSchema(
+    z.object({
+      delegationId: z.string(),
+      organisationId: z.string(),
+      delegatorId: z.string(),
+      delegateId: z.string(),
+    }),
+  ),
+{{/if}}
+{{#if validation.classValidator}}
+  payload: classSchema(DelegationRevokedV1Payload),
+{{/if}}
+});
+
+{{#if validation.zod}}
+export type DelegationRevokedV1Payload = PayloadOf<typeof delegationRevokedV1>;
+{{/if}}
+export type DelegationRevokedV1 = IntegrationEvent<DelegationRevokedV1Payload>;

package/templates/presets/identity/context/published-language/delegation-revoked.v1.payload.class-validator.ts.tpl

@@ -0,0 +1,16 @@
+import { IsString } from 'class-validator';
+
+/** A delegation ended before its period: what it lent, the delegate holds no more. Version 1: a field may be added, never renamed nor removed. */
+export class DelegationRevokedV1Payload {
+  @IsString()
+  delegationId = '';
+
+  @IsString()
+  organisationId = '';
+
+  @IsString()
+  delegatorId = '';
+
+  @IsString()
+  delegateId = '';
+}

package/templates/presets/identity/context/published-language/member-joined.v1.integration-event.ts.tpl

@@ -0,0 +1,36 @@
+{{#if validation.zod}}
+import { z } from 'zod';
+import { defineIntegrationEvent, type PayloadOf } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+{{/if}}
+{{#if validation.classValidator}}
+import { defineIntegrationEvent } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { MemberJoinedV1Payload } from '{{alias.context}}/published-language/member-joined.v1.payload{{alias.ext}}';
+{{/if}}
+
+export const memberJoinedV1 = defineIntegrationEvent({
+  type: '{{context.kebab}}.member.joined',
+  version: 1,
+  description: 'An account became a member of an organisation, in a role.',
+{{#if validation.zod}}
+  payload: zodSchema(
+    z.object({
+      memberId: z.string(),
+      organisationId: z.string(),
+      accountId: z.string(),
+      role: z.string(),
+    }),
+  ),
+{{/if}}
+{{#if validation.classValidator}}
+  payload: classSchema(MemberJoinedV1Payload),
+{{/if}}
+});
+
+{{#if validation.zod}}
+export type MemberJoinedV1Payload = PayloadOf<typeof memberJoinedV1>;
+{{/if}}
+export type MemberJoinedV1 = IntegrationEvent<MemberJoinedV1Payload>;

package/templates/presets/identity/context/published-language/member-joined.v1.payload.class-validator.ts.tpl

@@ -0,0 +1,16 @@
+import { IsString } from 'class-validator';
+
+/** An account became a member of an organisation, in a role. Version 1: a field may be added, never renamed nor removed. */
+export class MemberJoinedV1Payload {
+  @IsString()
+  memberId = '';
+
+  @IsString()
+  organisationId = '';
+
+  @IsString()
+  accountId = '';
+
+  @IsString()
+  role = '';
+}

package/templates/presets/identity/context/published-language/member-removed.v1.integration-event.ts.tpl

@@ -0,0 +1,36 @@
+{{#if validation.zod}}
+import { z } from 'zod';
+import { defineIntegrationEvent, type PayloadOf } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+{{/if}}
+{{#if validation.classValidator}}
+import { defineIntegrationEvent } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { MemberRemovedV1Payload } from '{{alias.context}}/published-language/member-removed.v1.payload{{alias.ext}}';
+{{/if}}
+
+export const memberRemovedV1 = defineIntegrationEvent({
+  type: '{{context.kebab}}.member.removed',
+  version: 1,
+  description: 'A member left an organisation: what they reached there through it, they reach no more.',
+{{#if validation.zod}}
+  payload: zodSchema(
+    z.object({
+      memberId: z.string(),
+      organisationId: z.string(),
+      accountId: z.string(),
+      delegationId: z.string().optional(),
+    }),
+  ),
+{{/if}}
+{{#if validation.classValidator}}
+  payload: classSchema(MemberRemovedV1Payload),
+{{/if}}
+});
+
+{{#if validation.zod}}
+export type MemberRemovedV1Payload = PayloadOf<typeof memberRemovedV1>;
+{{/if}}
+export type MemberRemovedV1 = IntegrationEvent<MemberRemovedV1Payload>;

package/templates/presets/identity/context/published-language/member-removed.v1.payload.class-validator.ts.tpl

@@ -0,0 +1,18 @@
+import { IsOptional, IsString } from 'class-validator';
+
+/** A member left an organisation: what they reached there through it, they reach no more. Version 1: a field may be added, never renamed nor removed. */
+export class MemberRemovedV1Payload {
+  @IsString()
+  memberId = '';
+
+  @IsString()
+  organisationId = '';
+
+  @IsString()
+  accountId = '';
+
+  /** The delegation that lent the right to decide it, when the role of who decided did not grant it. */
+  @IsOptional()
+  @IsString()
+  delegationId?: string;
+}

package/templates/presets/identity/context/published-language/member-role-changed.v1.integration-event.ts.tpl

@@ -0,0 +1,38 @@
+{{#if validation.zod}}
+import { z } from 'zod';
+import { defineIntegrationEvent, type PayloadOf } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+{{/if}}
+{{#if validation.classValidator}}
+import { defineIntegrationEvent } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { MemberRoleChangedV1Payload } from '{{alias.context}}/published-language/member-role-changed.v1.payload{{alias.ext}}';
+{{/if}}
+
+export const memberRoleChangedV1 = defineIntegrationEvent({
+  type: '{{context.kebab}}.member.role-changed',
+  version: 1,
+  description: 'The role of a member of an organisation changed.',
+{{#if validation.zod}}
+  payload: zodSchema(
+    z.object({
+      memberId: z.string(),
+      organisationId: z.string(),
+      accountId: z.string(),
+      from: z.string(),
+      to: z.string(),
+      delegationId: z.string().optional(),
+    }),
+  ),
+{{/if}}
+{{#if validation.classValidator}}
+  payload: classSchema(MemberRoleChangedV1Payload),
+{{/if}}
+});
+
+{{#if validation.zod}}
+export type MemberRoleChangedV1Payload = PayloadOf<typeof memberRoleChangedV1>;
+{{/if}}
+export type MemberRoleChangedV1 = IntegrationEvent<MemberRoleChangedV1Payload>;

package/templates/presets/identity/context/published-language/member-role-changed.v1.payload.class-validator.ts.tpl

@@ -0,0 +1,24 @@
+import { IsOptional, IsString } from 'class-validator';
+
+/** The role of a member of an organisation changed. Version 1: a field may be added, never renamed nor removed. */
+export class MemberRoleChangedV1Payload {
+  @IsString()
+  memberId = '';
+
+  @IsString()
+  organisationId = '';
+
+  @IsString()
+  accountId = '';
+
+  @IsString()
+  from = '';
+
+  @IsString()
+  to = '';
+
+  /** The delegation that lent the right to decide it, when the role of who decided did not grant it. */
+  @IsOptional()
+  @IsString()
+  delegationId?: string;
+}

package/templates/presets/identity/context/published-language/organisation-opened.v1.integration-event.ts.tpl

@@ -0,0 +1,35 @@
+{{#if validation.zod}}
+import { z } from 'zod';
+import { defineIntegrationEvent, type PayloadOf } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+{{/if}}
+{{#if validation.classValidator}}
+import { defineIntegrationEvent } from '@ddd-ts-kit/events';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { OrganisationOpenedV1Payload } from '{{alias.context}}/published-language/organisation-opened.v1.payload{{alias.ext}}';
+{{/if}}
+
+export const organisationOpenedV1 = defineIntegrationEvent({
+  type: '{{context.kebab}}.organisation.opened',
+  version: 1,
+  description: 'An organisation was opened; with tenants, it is a new tenant.',
+{{#if validation.zod}}
+  payload: zodSchema(
+    z.object({
+      organisationId: z.string(),
+      name: z.string(),
+      openedBy: z.string(),
+    }),
+  ),
+{{/if}}
+{{#if validation.classValidator}}
+  payload: classSchema(OrganisationOpenedV1Payload),
+{{/if}}
+});
+
+{{#if validation.zod}}
+export type OrganisationOpenedV1Payload = PayloadOf<typeof organisationOpenedV1>;
+{{/if}}
+export type OrganisationOpenedV1 = IntegrationEvent<OrganisationOpenedV1Payload>;

package/templates/presets/identity/context/published-language/organisation-opened.v1.payload.class-validator.ts.tpl

@@ -0,0 +1,13 @@
+import { IsString } from 'class-validator';
+
+/** An organisation was opened; with tenants, it is a new tenant. Version 1: a field may be added, never renamed nor removed. */
+export class OrganisationOpenedV1Payload {
+  @IsString()
+  organisationId = '';
+
+  @IsString()
+  name = '';
+
+  @IsString()
+  openedBy = '';
+}

package/templates/presets/identity/context/test/builders/account.builder.ts.tpl

@@ -0,0 +1,59 @@
+import { Builder, sequence, type Defaults } from '@ddd-ts-kit/testing';
+import { Account } from '{{alias.context}}/domain/aggregates/account.aggregate{{alias.ext}}';
+import { DisplayName } from '{{alias.context}}/domain/value-objects/display-name.vo{{alias.ext}}';
+import { EmailAddress } from '{{alias.context}}/domain/value-objects/email-address.vo{{alias.ext}}';
+
+interface AccountIngredients {
+  readonly subject: string;
+  readonly email: string;
+  readonly displayName: string;
+  readonly provisionedAt: Date;
+  readonly deactivatedAt: Date | undefined;
+}
+
+export class AccountBuilder extends Builder<AccountIngredients, Account> {
+  identifiedBy(subject: string): this {
+    return this.with('subject', subject);
+  }
+
+  reachedAt(email: string): this {
+    return this.with('email', email);
+  }
+
+  named(displayName: string): this {
+    return this.with('displayName', displayName);
+  }
+
+  provisionedAt(instant: Date): this {
+    return this.with('provisionedAt', instant);
+  }
+
+  deactivatedAt(instant: Date): this {
+    return this.with('deactivatedAt', instant);
+  }
+
+  protected defaults(): Defaults<AccountIngredients> {
+    return {
+      subject: sequence('account'),
+      email: sequence('person', (n) => `person-${n}@example.test`),
+      displayName: 'Ada Lovelace',
+      provisionedAt: new Date('2026-01-01T00:00:00.000Z'),
+      deactivatedAt: undefined,
+    };
+  }
+
+  protected construct(ingredients: AccountIngredients): Account {
+    const profile = { email: EmailAddress.create(ingredients.email), displayName: DisplayName.create(ingredients.displayName) };
+    const account = Account.provision(ingredients.subject, profile, ingredients.provisionedAt);
+
+    if (ingredients.deactivatedAt !== undefined) {
+      account.deactivate(ingredients.deactivatedAt);
+    }
+
+    return account;
+  }
+}
+
+export function anAccount(): AccountBuilder {
+  return new AccountBuilder();
+}

package/templates/presets/identity/context/test/builders/delegation.builder.ts.tpl

@@ -0,0 +1,67 @@
+import { Builder, sequence, type Defaults } from '@ddd-ts-kit/testing';
+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 { OrganisationRights } from '{{alias.context}}/domain/value-objects/organisation-rights.vo{{alias.ext}}';
+import { MemberRight } from '{{alias.context}}/domain/vocabularies/member-right.vocabulary{{alias.ext}}';
+
+interface DelegationIngredients {
+  readonly id: string;
+  readonly organisationId: string;
+  readonly delegatorId: string;
+  readonly delegateId: string;
+  readonly rights: readonly MemberRight[];
+  readonly startsAt: Date;
+  readonly endsAt: Date;
+  readonly grantedAt: Date;
+}
+
+export class DelegationBuilder extends Builder<DelegationIngredients, Delegation> {
+  identifiedBy(id: string): this {
+    return this.with('id', id);
+  }
+
+  in(organisationId: string): this {
+    return this.with('organisationId', organisationId);
+  }
+
+  from(delegatorId: string): this {
+    return this.with('delegatorId', delegatorId);
+  }
+
+  to(delegateId: string): this {
+    return this.with('delegateId', delegateId);
+  }
+
+  lending(...rights: readonly MemberRight[]): this {
+    return this.with('rights', rights);
+  }
+
+  between(startsAt: Date, endsAt: Date): this {
+    return this.with('startsAt', startsAt).with('endsAt', endsAt);
+  }
+
+  protected defaults(): Defaults<DelegationIngredients> {
+    return {
+      id: sequence('delegation'),
+      organisationId: 'acme',
+      delegatorId: 'account-owner',
+      delegateId: 'account-deputy',
+      rights: [MemberRight.InviteMembers],
+      startsAt: new Date('2026-01-01T00:00:00.000Z'),
+      endsAt: new Date('2026-01-31T00:00:00.000Z'),
+      grantedAt: new Date('2026-01-01T00:00:00.000Z'),
+    };
+  }
+
+  protected construct(ingredients: DelegationIngredients): Delegation {
+    const { id, organisationId, delegatorId, delegateId, rights } = ingredients;
+    const period = DelegationPeriod.create(ingredients.startsAt, ingredients.endsAt);
+    const held = OrganisationRights.of(organisationId, delegatorId, Object.values(MemberRight));
+
+    return Delegation.grant(id, { organisationId, delegatorId, delegateId, rights, period, held }, ingredients.grantedAt);
+  }
+}
+
+export function aDelegation(): DelegationBuilder {
+  return new DelegationBuilder();
+}