Rings, and the Rule That Points Inward

// use case ring — owns the port and the data shapes crossing its boundary.
export interface EnrolmentRepository {
  activeEnrolmentCount(learnerId: LearnerId): Promise<number>;
  save(enrolment: Enrolment): Promise<void>;
}

export interface EnrolInput { readonly learnerId: string; readonly courseId: string; }
export interface EnrolOutput { readonly enrolmentId: string; readonly startsOn: string; }

export class EnrolLearner {
  constructor(
    private readonly enrolments: EnrolmentRepository,
    private readonly clock: Clock,
  ) {}

  async execute(input: EnrolInput): Promise<EnrolOutput> {
    const learnerId = LearnerId.parse(input.learnerId);
    const active = await this.enrolments.activeEnrolmentCount(learnerId);

    // The entity holds the rule; the use case holds the sequence.
    const enrolment = Enrolment.open(learnerId, CourseId.parse(input.courseId), active, this.clock.now());
    await this.enrolments.save(enrolment);

    return { enrolmentId: enrolment.id.toString(), startsOn: enrolment.startsOn.toISOString() };
  }
}

// adapter ring — knows about HTTP and about the use case. The use case knows
// nothing about HTTP, which is why the same use case serves a CLI and a job.