// membership/aggregate/Member.ts

export class Member {

private constructor(

public readonly id: string,

private email: Email,

private status: MemberStatus,

private subscription: Subscription | null,

) {}

static subscribe(email: Email, type: MembershipType): Member {

return new Member(crypto.randomUUID(), email, "active", new Subscription(type));

}

suspend(): void {

if (this.status === "suspended") throw new Error("Déjà suspendu");

this.status = "suspended";

}

}

// membership/value-objects/MembershipType.ts

export class MembershipType {

private static readonly VALUES = ["monthly", "annual"] as const;

constructor(private readonly value: string) {

if (!MembershipType.VALUES.includes(value as any)) {

throw new Error("Type invalide");

}

}

isAnnual(): boolean {

return this.value === "annual";

}

price(): number {

return this.isAnnual() ? 480 : 45;

}

equals(other: MembershipType): boolean {

return this.value === other.value;

}

}

// membership/events/MemberSubscribed.ts

export class MemberSubscribed {

constructor(

public readonly memberId: string,

public readonly email: string,

public readonly membershipType: string,

public readonly occurredAt: Date = new Date(),

) {}

static from(member: Member): MemberSubscribed {

return new MemberSubscribed(

member.id,

member.email.toString(),

member.subscription?.type.value ?? "none",

);

}

}

// membership/usecases/SubscribeMember.ts

export class SubscribeMember {

constructor(

private memberRepo: MemberRepository,

private eventBus: EventBus,

) {}

async execute(cmd: { email: string; type: string }): Promise<string> {

const email = new Email(cmd.email);

const type = new MembershipType(cmd.type);

const member = Member.subscribe(email, type);

await this.memberRepo.save(member);

await this.eventBus.publish(MemberSubscribed.from(member));

return member.id;

}

}