ddd-ts-kit 0.14.0 → 0.15.0

package/templates/presets/identity/context/domain/aggregates/organisation.aggregate.ts.tpl

@@ -0,0 +1,52 @@
+import { AggregateRoot } from '@ddd-ts-kit/kernel';
+import { OrganisationOpened } from '{{alias.context}}/domain/events/organisation-opened.event{{alias.ext}}';
+import type { OrganisationName } from '{{alias.context}}/domain/value-objects/organisation-name.vo{{alias.ext}}';
+import type { OrganisationSlug } from '{{alias.context}}/domain/value-objects/organisation-slug.vo{{alias.ext}}';
+
+export interface OrganisationState {
+  readonly name: OrganisationName;
+  readonly openedBy: string;
+  readonly openedAt: Date;
+}
+
+/**
+ * A group of accounts that work together: a company, a clinic, a school. Its slug is its identity,
+ * and the tenant of its data when the project keeps the data of each organisation apart.
+ */
+export class Organisation extends AggregateRoot<string> {
+  private constructor(
+    id: string,
+    private readonly state: OrganisationState,
+  ) {
+    super(id);
+  }
+
+  /** Opened by an account, which becomes its first owner (see `OpenOrganisationHandler`). */
+  static open(slug: OrganisationSlug, terms: Pick<OrganisationState, 'name' | 'openedBy'>, now: Date): Organisation {
+    const opened = new Organisation(slug.value, { ...terms, openedAt: now });
+
+    opened.record(new OrganisationOpened(slug.value, now, { name: terms.name.value, openedBy: terms.openedBy }));
+
+    return opened;
+  }
+
+  static rehydrate(id: string, state: OrganisationState): Organisation {
+    return new Organisation(id, state);
+  }
+
+  get name(): OrganisationName {
+    return this.state.name;
+  }
+
+  get openedBy(): string {
+    return this.state.openedBy;
+  }
+
+  get openedAt(): Date {
+    return this.state.openedAt;
+  }
+
+  toState(): OrganisationState {
+    return { ...this.state };
+  }
+}

package/templates/presets/identity/context/domain/errors/account.error.ts.tpl

@@ -0,0 +1,40 @@
+import { ConceptError } from '@ddd-ts-kit/kernel';
+
+/** What the accounts refuse: an account is the application's view of one person the identity provider authenticates. */
+export class AccountError extends ConceptError {
+  static notFound(accountId: string) {
+    return AccountError.refusal(
+      'ACCOUNT_NOT_FOUND',
+      `No account ${accountId}: the person signs in once before acting.`,
+      { accountId },
+    ).exposing('accountId');
+  }
+
+  static deactivated(accountId: string) {
+    return AccountError.refusal('ACCOUNT_DEACTIVATED', `The account ${accountId} is deactivated.`, { accountId });
+  }
+
+  static alreadyDeactivated(accountId: string) {
+    return AccountError.refusal('ACCOUNT_ALREADY_DEACTIVATED', `The account ${accountId} is already deactivated.`, {
+      accountId,
+    });
+  }
+
+  static emailNotVerified(accountId: string) {
+    return AccountError.refusal(
+      'EMAIL_NOT_VERIFIED',
+      'The identity provider has not verified the email address of this person: they verify it, then sign in again.',
+      { accountId },
+    );
+  }
+
+  static invalidEmailAddress(raw: string) {
+    return AccountError.refusal('INVALID_EMAIL_ADDRESS', 'An email address is a local part, an @ and a domain.', {
+      raw,
+    });
+  }
+
+  static invalidDisplayName(raw: string) {
+    return AccountError.refusal('INVALID_DISPLAY_NAME', 'A display name holds between 1 and 100 characters.', { raw });
+  }
+}

package/templates/presets/identity/context/domain/errors/delegation.error.ts.tpl

@@ -0,0 +1,45 @@
+import { ConceptError } from '@ddd-ts-kit/kernel';
+
+/** What the delegations refuse: a member lends some of their rights to another, for a bounded time. */
+export class DelegationError extends ConceptError {
+  static notFound(delegationId: string) {
+    return DelegationError.refusal('DELEGATION_NOT_FOUND', `No delegation ${delegationId}.`, {
+      delegationId,
+    }).exposing('delegationId');
+  }
+
+  static notActive(delegationId: string) {
+    return DelegationError.refusal('DELEGATION_NOT_ACTIVE', `The delegation ${delegationId} already ended.`, {
+      delegationId,
+    });
+  }
+
+  static toOneself(accountId: string) {
+    return DelegationError.refusal('DELEGATION_TO_ONESELF', 'A member delegates to another member.', { accountId });
+  }
+
+  static withoutRights() {
+    return DelegationError.refusal('DELEGATION_WITHOUT_RIGHTS', 'A delegation lends at least one right.');
+  }
+
+  static beyondRights(right: string) {
+    return DelegationError.refusal('DELEGATION_BEYOND_RIGHTS', `A member lends only the rights they hold: ${right}.`, {
+      right,
+    }).exposing('right');
+  }
+
+  static periodInverted(startsAt: Date, endsAt: Date) {
+    return DelegationError.refusal('DELEGATION_PERIOD_INVERTED', 'A delegation ends after it starts.', {
+      startsAt,
+      endsAt,
+    }).exposing('startsAt', 'endsAt');
+  }
+
+  static tooLong(longestDays: number) {
+    return DelegationError.refusal(
+      'DELEGATION_TOO_LONG',
+      `A delegation lasts ${longestDays} days at most: a longer one is a role.`,
+      { longestDays },
+    ).exposing('longestDays');
+  }
+}

package/templates/presets/identity/context/domain/errors/invitation.error.ts.tpl

@@ -0,0 +1,30 @@
+import { ConceptError } from '@ddd-ts-kit/kernel';
+
+/** What the invitations refuse. The token of an invitation is never a fact of a refusal. */
+export class InvitationError extends ConceptError {
+  static notFound() {
+    return InvitationError.refusal('INVITATION_NOT_FOUND', 'No invitation answers this token or this identifier.');
+  }
+
+  static expired(invitationId: string, expiresAt: Date) {
+    return InvitationError.refusal('INVITATION_EXPIRED', `The invitation ${invitationId} expired.`, {
+      invitationId,
+      expiresAt,
+    }).exposing('expiresAt');
+  }
+
+  static notPending(invitationId: string, status: string) {
+    return InvitationError.refusal('INVITATION_NOT_PENDING', `The invitation ${invitationId} is already ${status}.`, {
+      invitationId,
+      status,
+    }).exposing('status');
+  }
+
+  static addressedToAnother(invitationId: string) {
+    return InvitationError.refusal(
+      'INVITATION_ADDRESSED_TO_ANOTHER',
+      `The invitation ${invitationId} is addressed to another email address than the account's.`,
+      { invitationId },
+    );
+  }
+}

package/templates/presets/identity/context/domain/errors/member.error.ts.tpl

@@ -0,0 +1,50 @@
+import { ConceptError } from '@ddd-ts-kit/kernel';
+
+/** What the members of an organisation refuse. */
+export class MemberError extends ConceptError {
+  static notFound(organisationId: string, accountId: string) {
+    return MemberError.refusal('MEMBER_NOT_FOUND', `The account ${accountId} is not a member of ${organisationId}.`, {
+      organisationId,
+      accountId,
+    }).exposing('organisationId', 'accountId');
+  }
+
+  static alreadyMember(organisationId: string, accountId: string) {
+    return MemberError.refusal('ALREADY_MEMBER', `The account ${accountId} is already a member of ${organisationId}.`, {
+      organisationId,
+      accountId,
+    }).exposing('organisationId', 'accountId');
+  }
+
+  static lastOwner(organisationId: string) {
+    return MemberError.refusal('LAST_OWNER', `${organisationId} keeps at least one owner.`, {
+      organisationId,
+    }).exposing('organisationId');
+  }
+
+  static ownersOnly(organisationId: string) {
+    return MemberError.refusal('OWNERS_ONLY', `Only an owner of ${organisationId} appoints or changes an owner.`, {
+      organisationId,
+    });
+  }
+
+  static ownRole(organisationId: string) {
+    return MemberError.refusal(
+      'OWN_ROLE',
+      `A member of ${organisationId} does not change their own role: another member does.`,
+      {
+        organisationId,
+      },
+    );
+  }
+
+  static aboveOwnRole(organisationId: string) {
+    return MemberError.refusal(
+      'ABOVE_OWN_ROLE',
+      `A member of ${organisationId} appoints, changes or removes no one above their own role.`,
+      {
+        organisationId,
+      },
+    );
+  }
+}

package/templates/presets/identity/context/domain/errors/organisation.error.ts.tpl

@@ -0,0 +1,32 @@
+import { ConceptError } from '@ddd-ts-kit/kernel';
+
+/** What the organisations refuse: an organisation is a group of accounts, and the tenant of its data when the project has tenants. */
+export class OrganisationError extends ConceptError {
+  static notFound(organisationId: string) {
+    return OrganisationError.refusal('ORGANISATION_NOT_FOUND', `No organisation ${organisationId}.`, {
+      organisationId,
+    }).exposing('organisationId');
+  }
+
+  static slugTaken(slug: string) {
+    return OrganisationError.refusal('ORGANISATION_SLUG_TAKEN', `An organisation is already named ${slug}.`, {
+      slug,
+    }).exposing('slug');
+  }
+
+  static invalidOrganisationName(raw: string) {
+    return OrganisationError.refusal(
+      'INVALID_ORGANISATION_NAME',
+      'The name of an organisation holds between 1 and 100 characters.',
+      { raw },
+    );
+  }
+
+  static invalidOrganisationSlug(raw: string) {
+    return OrganisationError.refusal(
+      'INVALID_ORGANISATION_SLUG',
+      'A slug is 2 to 63 lower-case letters, digits and hyphens, starting with a letter or a digit.',
+      { raw },
+    );
+  }
+}

package/templates/presets/identity/context/domain/events/account-deactivated.event.ts.tpl

@@ -0,0 +1,13 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+/** An account was deactivated: its person signs in no more. */
+export class AccountDeactivated implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.account.deactivated';
+
+  readonly name = AccountDeactivated.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+  ) {}
+}

package/templates/presets/identity/context/domain/events/account-provisioned.event.ts.tpl

@@ -0,0 +1,17 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+/** An account was provisioned at the first sign-in of its person. */
+export class AccountProvisioned implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.account.provisioned';
+
+  readonly name = AccountProvisioned.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly email: string;
+      readonly displayName: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/delegation-granted.event.ts.tpl

@@ -0,0 +1,22 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+import type { MemberRight } from '{{alias.context}}/domain/vocabularies/member-right.vocabulary{{alias.ext}}';
+
+/** A member lent some of their rights to another, for a period. */
+export class DelegationGranted implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.delegation.granted';
+
+  readonly name = DelegationGranted.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+      readonly delegatorId: string;
+      readonly delegateId: string;
+      readonly rights: readonly MemberRight[];
+      readonly startsAt: Date;
+      readonly endsAt: Date;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/delegation-revoked.event.ts.tpl

@@ -0,0 +1,18 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+/** A delegation ended before its period: revoked, or its delegator lost the standing it was granted with. */
+export class DelegationRevoked implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.delegation.revoked';
+
+  readonly name = DelegationRevoked.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+      readonly delegatorId: string;
+      readonly delegateId: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/invitation-accepted.event.ts.tpl

@@ -0,0 +1,17 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+/** The person an invitation was addressed to accepted it. */
+export class InvitationAccepted implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.invitation.accepted';
+
+  readonly name = InvitationAccepted.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+      readonly accountId: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/invitation-declined.event.ts.tpl

@@ -0,0 +1,16 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+/** The person an invitation was addressed to declined it. */
+export class InvitationDeclined implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.invitation.declined';
+
+  readonly name = InvitationDeclined.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/invitation-issued.event.ts.tpl

@@ -0,0 +1,22 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+import type { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+/** An invitation was issued to an email address. */
+export class InvitationIssued implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.invitation.issued';
+
+  readonly name = InvitationIssued.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+      readonly email: string;
+      readonly role: MemberRole;
+      readonly expiresAt: Date;
+      /** The delegation that lent the right to invite, when the role of the inviter did not grant it. */
+      readonly delegationId?: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/invitation-revoked.event.ts.tpl

@@ -0,0 +1,16 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+/** The organisation took an invitation back before it was answered. */
+export class InvitationRevoked implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.invitation.revoked';
+
+  readonly name = InvitationRevoked.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/member-joined.event.ts.tpl

@@ -0,0 +1,19 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+import type { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+/** An account became a member of an organisation, in a role. */
+export class MemberJoined implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.member.joined';
+
+  readonly name = MemberJoined.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+      readonly accountId: string;
+      readonly role: MemberRole;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/member-removed.event.ts.tpl

@@ -0,0 +1,19 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+/** A member left an organisation, or was removed from it. */
+export class MemberRemoved implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.member.removed';
+
+  readonly name = MemberRemoved.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+      readonly accountId: string;
+      /** The delegation that lent the right to decide it, when the role of who decided did not grant it. */
+      readonly delegationId?: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/member-role-changed.event.ts.tpl

@@ -0,0 +1,22 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+import type { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+/** A member holds another role: what they may do in the organisation follows from it from now on. */
+export class MemberRoleChanged implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.member.role-changed';
+
+  readonly name = MemberRoleChanged.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly organisationId: string;
+      readonly accountId: string;
+      readonly from: MemberRole;
+      readonly to: MemberRole;
+      /** The delegation that lent the right to decide it, when the role of who decided did not grant it. */
+      readonly delegationId?: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/events/organisation-opened.event.ts.tpl

@@ -0,0 +1,17 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+/** An organisation was opened, its opener its first owner. */
+export class OrganisationOpened implements DomainEvent {
+  static readonly eventName = '{{context.kebab}}.organisation.opened';
+
+  readonly name = OrganisationOpened.eventName;
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    readonly facts: {
+      readonly name: string;
+      readonly openedBy: string;
+    },
+  ) {}
+}

package/templates/presets/identity/context/domain/repositories/account.repository.ts.tpl

@@ -0,0 +1,5 @@
+import { Repository } from '@ddd-ts-kit/kernel';
+import type { Account } from '{{alias.context}}/domain/aggregates/account.aggregate{{alias.ext}}';
+
+/** The accounts, by the subject the identity provider gives each person. */
+export abstract class AccountRepository extends Repository<Account> {}

package/templates/presets/identity/context/domain/repositories/delegation.repository.ts.tpl

@@ -0,0 +1,10 @@
+import { Repository } from '@ddd-ts-kit/kernel';
+import type { Delegation } from '{{alias.context}}/domain/aggregates/delegation.aggregate{{alias.ext}}';
+
+export abstract class DelegationRepository extends Repository<Delegation> {
+  /** The delegations not ended yet that lend rights to this member of the organisation, started or not. */
+  abstract findUnendedTo(organisationId: string, delegateId: string): Promise<readonly Delegation[]>;
+
+  /** The delegations not ended yet that this member of the organisation gave or received. */
+  abstract findUnendedInvolving(organisationId: string, accountId: string): Promise<readonly Delegation[]>;
+}

package/templates/presets/identity/context/domain/repositories/invitation.repository.ts.tpl

@@ -0,0 +1,7 @@
+import { Repository } from '@ddd-ts-kit/kernel';
+import type { Invitation } from '{{alias.context}}/domain/aggregates/invitation.aggregate{{alias.ext}}';
+
+export abstract class InvitationRepository extends Repository<Invitation> {
+  /** The invitation whose token has this digest. */
+  abstract findByTokenHash(tokenHash: string): Promise<Invitation | undefined>;
+}

package/templates/presets/identity/context/domain/repositories/member.repository.ts.tpl

@@ -0,0 +1,13 @@
+import { Repository } from '@ddd-ts-kit/kernel';
+import type { Member } from '{{alias.context}}/domain/aggregates/member.aggregate{{alias.ext}}';
+
+export abstract class MemberRepository extends Repository<Member> {
+  /** The current membership of an account in an organisation: there is at most one. */
+  abstract findOf(organisationId: string, accountId: string): Promise<Member | undefined>;
+
+  /** The current memberships of an account, in every organisation. */
+  abstract searchCurrentOf(accountId: string): Promise<readonly Member[]>;
+
+  /** How many current members of the organisation are owners. */
+  abstract countOwners(organisationId: string): Promise<number>;
+}

package/templates/presets/identity/context/domain/repositories/organisation.repository.ts.tpl

@@ -0,0 +1,5 @@
+import { Repository } from '@ddd-ts-kit/kernel';
+import type { Organisation } from '{{alias.context}}/domain/aggregates/organisation.aggregate{{alias.ext}}';
+
+/** The organisations, by their slug. */
+export abstract class OrganisationRepository extends Repository<Organisation> {}

package/templates/presets/identity/context/domain/services/role-rights.service.ts.tpl

@@ -0,0 +1,59 @@
+import type { Delegation } from '{{alias.context}}/domain/aggregates/delegation.aggregate{{alias.ext}}';
+import type { Member } from '{{alias.context}}/domain/aggregates/member.aggregate{{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}}';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+/** What each role grants. Changing a role here changes what every member of that role may do. */
+const GRANTED: Readonly<Record<MemberRole, readonly MemberRight[]>> = {
+  [MemberRole.Owner]: [
+    MemberRight.ReadMembers,
+    MemberRight.InviteMembers,
+    MemberRight.ManageMembers,
+    MemberRight.GrantDelegations,
+  ],
+  [MemberRole.Admin]: [MemberRight.ReadMembers, MemberRight.InviteMembers, MemberRight.ManageMembers],
+  [MemberRole.Member]: [MemberRight.ReadMembers],
+};
+
+/** What an account holds in an organisation at an instant: its membership, the delegations lent to it. */
+export interface HeldRights {
+  readonly member: Member | undefined;
+  readonly lent: readonly Delegation[];
+  readonly now: Date;
+}
+
+/** The rights of the roles, and what an account may do in an organisation once its delegations are counted. */
+export class RoleRightsService {
+  rightsOf(role: MemberRole): readonly MemberRight[] {
+    return GRANTED[role];
+  }
+
+  /**
+   * The rights of an account in an organisation at `now`: none without a current membership (a
+   * member removed, or whose account was deactivated, which ends its memberships), those of its
+   * role otherwise, plus those every delegation active at `now` lends it there.
+   */
+  rightsIn(organisationId: string, accountId: string, held: HeldRights): OrganisationRights {
+    if (!held.member?.isActive) {
+      return OrganisationRights.of(organisationId, accountId, []);
+    }
+
+    const lent = activeAt(held).flatMap((given) => given.rights);
+
+    return OrganisationRights.of(organisationId, accountId, [...GRANTED[held.member.role], ...lent]);
+  }
+
+  /** The delegation `right` is used under, when the role of the member does not grant it: what the facts it leads to name. */
+  delegationUsedFor(right: MemberRight, held: HeldRights): string | undefined {
+    if (held.member === undefined || GRANTED[held.member.role].includes(right)) {
+      return undefined;
+    }
+
+    return activeAt(held).find((given) => given.rights.includes(right))?.id;
+  }
+}
+
+function activeAt(held: HeldRights): readonly Delegation[] {
+  return held.lent.filter((delegation) => delegation.isActiveAt(held.now));
+}

package/templates/presets/identity/context/domain/value-objects/delegation-period.vo.ts.tpl

@@ -0,0 +1,42 @@
+import { ValueObject } from '@ddd-ts-kit/kernel';
+import { DelegationError } from '{{alias.context}}/domain/errors/delegation.error{{alias.ext}}';
+
+/** A delegation is a stand-in for an absence: past this, the right belongs in a role. */
+const LONGEST_DAYS = 90;
+const DAY_MS = 86_400_000;
+
+export type DelegationPeriodProps = {
+  readonly startsAt: Date;
+  readonly endsAt: Date;
+};
+
+/** When a delegation holds: from its start, included, to its end, excluded, for at most ninety days. */
+export class DelegationPeriod extends ValueObject<DelegationPeriodProps> {
+  private constructor(props: DelegationPeriodProps) {
+    super(props);
+  }
+
+  static create(startsAt: Date, endsAt: Date): DelegationPeriod {
+    if (endsAt.getTime() <= startsAt.getTime()) {
+      throw DelegationError.periodInverted(startsAt, endsAt);
+    }
+
+    if (endsAt.getTime() - startsAt.getTime() > LONGEST_DAYS * DAY_MS) {
+      throw DelegationError.tooLong(LONGEST_DAYS);
+    }
+
+    return new DelegationPeriod({ startsAt, endsAt });
+  }
+
+  includes(instant: Date): boolean {
+    return this.props.startsAt.getTime() <= instant.getTime() && instant.getTime() < this.props.endsAt.getTime();
+  }
+
+  get startsAt(): Date {
+    return this.props.startsAt;
+  }
+
+  get endsAt(): Date {
+    return this.props.endsAt;
+  }
+}