@shizuoka-its/core 2.1.0 → 2.1.2

package/dist/index.cjs

@@ -0,0 +1,1914 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Department: () => Department,
+  DiscordAccount: () => DiscordAccount,
+  DiscordAccountAlreadyConnectedException: () => DiscordAccountAlreadyConnectedException,
+  DiscordAccountNotConnectedException: () => DiscordAccountNotConnectedException2,
+  DomainException: () => DomainException,
+  Email: () => Email,
+  Event: () => Event,
+  Exhibit: () => Exhibit,
+  ExhibitAlreadyExistsException: () => ExhibitAlreadyExistsException,
+  ExhibitHasMemberException: () => ExhibitHasMemberException,
+  ExhibitNotFoundException: () => ExhibitNotFoundException,
+  InvalidDepartmentException: () => InvalidDepartmentException,
+  InvalidEmailFormatException: () => InvalidEmailFormatException,
+  InvalidLightningTalkDurationException: () => InvalidLightningTalkDurationException,
+  InvalidUniversityEmailException: () => InvalidUniversityEmailException,
+  InvalidUrlException: () => InvalidUrlException,
+  InvalidUrlProtocolException: () => InvalidUrlProtocolException,
+  LightningTalk: () => LightningTalk,
+  LightningTalkDuration: () => LightningTalkDuration,
+  LightningTalkExhibitIdMismatchException: () => LightningTalkExhibitIdMismatchException,
+  LightningTalkNotFoundException: () => LightningTalkNotFoundException,
+  Member: () => Member,
+  UniversityEmail: () => UniversityEmail,
+  Url: () => Url,
+  ValueObject: () => ValueObject,
+  createEventUseCases: () => createEventUseCases,
+  createMemberUseCases: () => createMemberUseCases
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/application/exceptions/ApplicationExceptions.ts
+var ApplicationException = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ApplicationException";
+  }
+};
+var EventNotFoundException = class extends ApplicationException {
+  constructor(eventId) {
+    const message = `\u30A4\u30D9\u30F3\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${eventId}`;
+    super(message);
+    this.name = "EventNotFoundException";
+  }
+};
+var ExhibitNotFoundFromExhibitIdException = class extends ApplicationException {
+  constructor(exhibitId) {
+    const message = `\u6307\u5B9A\u3055\u308C\u305F\u5C55\u793AID\u3067\u5C55\u793A\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${exhibitId}`;
+    super(message);
+    this.name = "ExhibitNotFoundFromExhibitIdException";
+  }
+};
+var MemberEmailAlreadyExistsException = class extends ApplicationException {
+  constructor(email) {
+    const message = `\u3053\u306E\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u65E2\u306B\u767B\u9332\u3055\u308C\u3066\u3044\u307E\u3059: ${email}`;
+    super(message);
+    this.name = "MemberEmailAlreadyExistsException";
+  }
+};
+var MemberNotFoundException = class extends ApplicationException {
+  constructor(memberId) {
+    const message = `\u30E1\u30F3\u30D0\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${memberId}`;
+    super(message);
+    this.name = "MemberNotFoundException";
+  }
+};
+var MemberNotFoundFromDiscordAccountIdException = class extends ApplicationException {
+  constructor(discordAccountId) {
+    const message = `\u6307\u5B9A\u3055\u308C\u305FDiscord\u30A2\u30AB\u30A6\u30F3\u30C8ID\u304B\u3089\u30E1\u30F3\u30D0\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: (Discord\u30A2\u30AB\u30A6\u30F3\u30C8ID) ${discordAccountId}`;
+    super(message);
+    this.name = "MemberNotFoundFromDiscordAccountIdException";
+  }
+};
+var DiscordAccountNotConnectedException = class extends ApplicationException {
+  constructor(userId, discordUserId) {
+    const message = `\u30E6\u30FC\u30B6\u30FC: ${userId} \u306EDiscord\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u7D10\u3065\u3044\u3066\u3044\u307E\u305B\u3093: ${discordUserId}`;
+    super(message);
+    this.name = "DiscordAccountNotConnectedException";
+  }
+};
+
+// src/application/usecase/base.ts
+var IUseCase = class {
+};
+
+// src/application/usecase/member/ChangeDiscordNickName.ts
+var ChangeDiscordNickNameUseCase = class extends IUseCase {
+  constructor(memberRepo) {
+    super();
+    this.memberRepo = memberRepo;
+  }
+  async execute(input) {
+    const member = await this.memberRepo.findByDiscordAccountId(
+      input.discordAccountId
+    );
+    if (!member) {
+      throw new MemberNotFoundFromDiscordAccountIdException(
+        input.discordAccountId
+      );
+    }
+    const discordAccount = member.getDiscordAccountById(input.discordAccountId);
+    if (!discordAccount) {
+      throw new DiscordAccountNotConnectedException(
+        member.id,
+        input.discordAccountId
+      );
+    }
+    discordAccount.setNickName(input.discordNickName);
+    await this.memberRepo.save(member);
+    return { member };
+  }
+};
+
+// src/domain/exceptions/DomainExceptions.ts
+var DomainException = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DomainException";
+  }
+};
+var InvalidEmailFormatException = class extends DomainException {
+  constructor(email) {
+    super(`\u7121\u52B9\u306A\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306E\u5F62\u5F0F\u3067\u3059: ${email}`);
+    this.name = "InvalidEmailFormatException";
+  }
+};
+var DiscordAccountAlreadyConnectedException = class extends DomainException {
+  constructor() {
+    super("\u540C\u3058Discord\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u3059\u3067\u306B\u30E6\u30FC\u30B6\u30FC\u306B\u7D10\u3065\u3044\u3066\u3044\u307E\u3059");
+    this.name = "DiscordAccountAlreadyConnectedException";
+  }
+};
+var DiscordAccountNotConnectedException2 = class extends DomainException {
+  constructor() {
+    super("\u6307\u5B9A\u3055\u308C\u305FDiscord\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u30E6\u30FC\u30B6\u30FC\u306B\u7D10\u3065\u3044\u3066\u3044\u307E\u305B\u3093");
+    this.name = "DiscordAccountNotConnectedException";
+  }
+};
+var InvalidUniversityEmailException = class extends DomainException {
+  constructor(email) {
+    super(`\u7121\u52B9\u306A\u5927\u5B66\u306E\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u3067\u3059: ${email} (\u5927\u5B66\u30C9\u30E1\u30A4\u30F3\u304C\u5FC5\u8981\u3067\u3059)`);
+    this.name = "InvalidUniversityEmailException";
+  }
+};
+var InvalidDepartmentException = class extends DomainException {
+  constructor(department) {
+    super(
+      `\u7121\u52B9\u306A\u5B66\u90E8\u8B58\u5225\u5B50\u3067\u3059: ${department} (\u6709\u52B9\u5024: CS, BI, IA, GRADUATE, ALUMNI, OTHERS)`
+    );
+    this.name = "InvalidDepartmentException";
+  }
+};
+var InvalidLightningTalkDurationException = class extends DomainException {
+  constructor(duration) {
+    super(
+      `\u7121\u52B9\u306A\u30E9\u30A4\u30C8\u30CB\u30F3\u30B0\u30C8\u30FC\u30AF\u306E\u9577\u3055\u3067\u3059: ${duration}\u5206 (\u6B63\u306E\u6570\u5024\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044)`
+    );
+    this.name = "InvalidLightningTalkDurationException";
+  }
+};
+var InvalidUrlException = class extends DomainException {
+  constructor(url) {
+    super(`\u7121\u52B9\u306AURL\u3067\u3059: ${url}`);
+    this.name = "InvalidUrlException";
+  }
+};
+var InvalidUrlProtocolException = class extends DomainException {
+  constructor(url, protocol) {
+    super(
+      `\u6307\u5B9A\u3055\u308C\u305FURL\u306E\u30D7\u30ED\u30C8\u30B3\u30EB\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093: ${url} (\u30D7\u30ED\u30C8\u30B3\u30EB: ${protocol})`
+    );
+    this.name = "InvalidUrlProtocolException";
+  }
+};
+var ExhibitAlreadyExistsException = class extends DomainException {
+  constructor(exhibitId) {
+    super(`\u65E2\u306B\u540C\u4E00\u306E\u5C55\u793A\u304C\u767B\u9332\u3055\u308C\u3066\u3044\u307E\u3059: ${exhibitId}`);
+    this.name = "ExhibitAlreadyExistsException";
+  }
+};
+var ExhibitNotFoundException = class extends DomainException {
+  constructor(exhibitId) {
+    super(`\u6307\u5B9A\u3055\u308C\u305F\u5C55\u793A\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${exhibitId}`);
+    this.name = "ExhibitNotFoundException";
+  }
+};
+var LightningTalkNotFoundException = class extends DomainException {
+  constructor(lightningTalkId) {
+    super(`\u6307\u5B9A\u3055\u308C\u305F\u30E9\u30A4\u30C8\u30CB\u30F3\u30B0\u30C8\u30FC\u30AF\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${lightningTalkId}`);
+    this.name = "LightningTalkNotFoundException";
+  }
+};
+var LightningTalkExhibitIdMismatchException = class extends DomainException {
+  constructor(lightningTalkId, exhibitId) {
+    super(
+      `\u6307\u5B9A\u3055\u308C\u305F\u30E9\u30A4\u30C8\u30CB\u30F3\u30B0\u30C8\u30FC\u30AF\u306Eid\u304C\u5C55\u793A\u306Eid\u3068\u4E00\u81F4\u3057\u3066\u3044\u307E\u305B\u3093: \u30E9\u30A4\u30C8\u30CB\u30F3\u30B0\u30C8\u30FC\u30AFID ${lightningTalkId}, \u5C55\u793AID ${exhibitId}`
+    );
+    this.name = "LightningTalkExhibitIdMismatchException";
+  }
+};
+var ExhibitHasMemberException = class extends DomainException {
+  constructor(exhibitId, memberId) {
+    super(
+      `\u30A4\u30D9\u30F3\u30C8\u306B\u7D10\u3065\u3044\u305F\u5C55\u793A\u306B\u5F53\u8A72\u30E1\u30F3\u30D0\u30FC\u304C\u3044\u308B\u305F\u3081\u3001Event\u304B\u3089\u524A\u9664\u3067\u304D\u307E\u305B\u3093: \u5C55\u793AID ${exhibitId}, \u30E1\u30F3\u30D0\u30FCID ${memberId}`
+    );
+    this.name = "ExhibitHasMemberException";
+  }
+};
+
+// src/domain/value-objects/ValueObject.ts
+var ValueObject = class {
+  constructor(value) {
+    this.value = value;
+    this.validate();
+  }
+  getValue() {
+    return this.value;
+  }
+  equals(vo) {
+    if (vo === null || vo === void 0) {
+      return false;
+    }
+    return JSON.stringify(this.value) === JSON.stringify(vo.value);
+  }
+  throwIfInvalid(isValid, exception) {
+    if (!isValid) {
+      throw exception;
+    }
+  }
+};
+
+// src/domain/value-objects/Departments.ts
+var Department = class _Department extends ValueObject {
+  static fromString(value) {
+    return new _Department(value);
+  }
+  validate() {
+    const validDepartments = [
+      "CS",
+      "BI",
+      "IA",
+      "GRADUATE",
+      "ALUMNI",
+      "OTHERS"
+    ];
+    this.throwIfInvalid(
+      validDepartments.includes(this.value),
+      new InvalidDepartmentException(this.value)
+    );
+  }
+};
+
+// src/domain/value-objects/Email.ts
+var Email = class extends ValueObject {
+  validate() {
+    const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+    this.throwIfInvalid(
+      emailRegex.test(this.value),
+      new InvalidEmailFormatException(this.value)
+    );
+  }
+};
+
+// src/domain/value-objects/LightningTalkDuration.ts
+var LightningTalkDuration = class extends ValueObject {
+  validate() {
+    this.throwIfInvalid(
+      this.value > 0,
+      new InvalidLightningTalkDurationException(this.value)
+    );
+  }
+};
+
+// src/domain/value-objects/UniversityEmail.ts
+var UNIVERSITY_EMAIL_DOMAIN = "@shizuoka.ac.jp";
+var UniversityEmail = class extends Email {
+  validate() {
+    super.validate();
+    this.throwIfInvalid(
+      this.value.endsWith(UNIVERSITY_EMAIL_DOMAIN),
+      new InvalidUniversityEmailException(this.value)
+    );
+  }
+};
+
+// src/domain/value-objects/Url.ts
+var Url = class extends ValueObject {
+  validate() {
+    let parsed;
+    try {
+      parsed = new URL(this.value);
+    } catch {
+      this.throwIfInvalid(false, new InvalidUrlException(this.value));
+      return;
+    }
+    this.throwIfInvalid(
+      ["http:", "https:"].includes(parsed.protocol),
+      new InvalidUrlProtocolException(this.value, parsed.protocol)
+    );
+  }
+};
+
+// src/domain/aggregates/event/Event.ts
+var Event = class {
+  constructor(id, name, date) {
+    this.id = id;
+    this.name = name;
+    this.date = date;
+  }
+  exhibits = [];
+  memberIds = /* @__PURE__ */ new Set();
+  getName() {
+    return this.name;
+  }
+  getDate() {
+    return this.date;
+  }
+  getExhibits() {
+    return this.exhibits;
+  }
+  getMemberIds() {
+    return Array.from(this.memberIds);
+  }
+  changeName(newName) {
+    this.name = newName;
+  }
+  changeDate(newDate) {
+    this.date = newDate;
+  }
+  addExhibit(exhibit) {
+    if (this.exhibits.some((x) => x.id === exhibit.id)) {
+      throw new ExhibitAlreadyExistsException(
+        `Exhibit(id=${exhibit.id}) \u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059`
+      );
+    }
+    for (const memberId of exhibit.getMemberIds()) {
+      this.memberIds.add(memberId);
+    }
+    this.exhibits.push(exhibit);
+  }
+  removeExhibit(exhibitId) {
+    this.getExhibitOrThrow(exhibitId);
+    this.exhibits = this.exhibits.filter((x) => x.id !== exhibitId);
+  }
+  changeExhibitName(exhibitId, newName) {
+    this.getExhibitOrThrow(exhibitId).changeName(newName);
+  }
+  changeExhibitDescription(exhibitId, newDescription) {
+    this.getExhibitOrThrow(exhibitId).changeDescription(newDescription);
+  }
+  changeExhibitMarkdownContent(exhibitId, newMarkdownContent) {
+    this.getExhibitOrThrow(exhibitId).changeMarkdownContent(newMarkdownContent);
+  }
+  changeExhibitUrl(exhibitId, newUrl) {
+    this.getExhibitOrThrow(exhibitId).changeUrl(newUrl);
+  }
+  changeExhibitLightningTalkStartTime(exhibitId, newStartTime) {
+    this.getExhibitOrThrow(exhibitId).changeLightningTalkStartTime(
+      newStartTime
+    );
+  }
+  changeExhibitLightningTalkDuration(exhibitId, newDuration) {
+    this.getExhibitOrThrow(exhibitId).changeLightningTalkDuration(newDuration);
+  }
+  changeExhibitLightningTalkSlideUrl(exhibitId, newSlideUrl) {
+    this.getExhibitOrThrow(exhibitId).changeLightningTalkSlideUrl(newSlideUrl);
+  }
+  getExhibitOrThrow(exhibitId) {
+    const exhibit = this.exhibits.find((x) => x.id === exhibitId);
+    if (!exhibit) {
+      throw new ExhibitNotFoundException(
+        `Exhibit(id=${exhibitId}) \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093`
+      );
+    }
+    return exhibit;
+  }
+  addMemberId(memberId) {
+    this.memberIds.add(memberId);
+  }
+  removeMemberId(memberId) {
+    for (const exhibit of this.exhibits) {
+      if (exhibit.getMemberIds().includes(memberId)) {
+        throw new ExhibitHasMemberException(exhibit.id, memberId);
+      }
+    }
+    this.memberIds.delete(memberId);
+  }
+  addExhibitMemberId(exhibitId, memberId) {
+    this.getExhibitOrThrow(exhibitId).addMemberId(memberId);
+    this.memberIds.add(memberId);
+  }
+  removeExhibitMemberId(exhibitId, memberId) {
+  }
+  toSnapshot() {
+    return {
+      id: this.id,
+      name: this.name,
+      date: this.date,
+      exhibits: this.exhibits.map((exhibit) => exhibit.toSnapshot()),
+      memberIds: Array.from(this.memberIds)
+    };
+  }
+};
+
+// src/domain/aggregates/event/Exhibit.ts
+var Exhibit = class _Exhibit {
+  constructor(id, name, description, markdownContent, url) {
+    this.id = id;
+    this.name = name;
+    this.description = description;
+    this.markdownContent = markdownContent;
+    this.url = url;
+  }
+  lightningTalk;
+  memberIds = /* @__PURE__ */ new Set();
+  // NOTE: LightningTalkのExhibitコンストラクタ(TypeScriptは2つのコンストラクタを持てないため)
+  static createWithLightningTalk(id, name, lt, description, markdownContent, url) {
+    const exhibit = new _Exhibit(id, name, description, markdownContent, url);
+    if (lt.exhibitId !== id) {
+      throw new LightningTalkExhibitIdMismatchException(id, lt.exhibitId);
+    }
+    exhibit.lightningTalk = lt;
+    return exhibit;
+  }
+  getName() {
+    return this.name;
+  }
+  getDescription() {
+    return this.description;
+  }
+  getMarkdownContent() {
+    return this.markdownContent;
+  }
+  getUrl() {
+    return this.url;
+  }
+  getLightningTalk() {
+    return this.lightningTalk;
+  }
+  getMemberIds() {
+    return Array.from(this.memberIds);
+  }
+  changeName(newName) {
+    this.name = newName;
+  }
+  changeDescription(newDescription) {
+    this.description = newDescription;
+  }
+  changeMarkdownContent(newMarkdownContent) {
+    this.markdownContent = newMarkdownContent;
+  }
+  changeUrl(newUrl) {
+    this.url = newUrl;
+  }
+  changeLightningTalkStartTime(newStartTime) {
+    this.getLightningTalkOrThrow().changeStartTime(newStartTime);
+  }
+  changeLightningTalkDuration(newDuration) {
+    this.getLightningTalkOrThrow().changeDuration(newDuration);
+  }
+  changeLightningTalkSlideUrl(newSlideUrl) {
+    this.getLightningTalkOrThrow().changeSlideUrl(newSlideUrl);
+  }
+  addMemberId(memberId) {
+    this.memberIds.add(memberId);
+  }
+  removeMemberId(memberId) {
+    this.memberIds.delete(memberId);
+  }
+  getLightningTalkOrThrow() {
+    if (!this.lightningTalk) {
+      throw new LightningTalkNotFoundException(
+        `Exhibit(id=${this.id}) \u306B\u7D10\u3065\u304F LightningTalk \u304C\u5B58\u5728\u3057\u307E\u305B\u3093`
+      );
+    }
+    return this.lightningTalk;
+  }
+  toSnapshot() {
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      markdownContent: this.markdownContent,
+      url: this.url,
+      lightningTalk: this.lightningTalk?.toSnapshot()
+    };
+  }
+};
+
+// src/domain/aggregates/event/LightningTalk.ts
+var LightningTalk = class {
+  constructor(exhibitId, startTime, durationMinutes, slideUrl) {
+    this.exhibitId = exhibitId;
+    this.startTime = startTime;
+    this.durationMinutes = durationMinutes;
+    this.slideUrl = slideUrl;
+  }
+  getStartTime() {
+    return this.startTime;
+  }
+  getDurationMinutes() {
+    return this.durationMinutes;
+  }
+  getSlideUrl() {
+    return this.slideUrl;
+  }
+  changeSlideUrl(newSlideUrl) {
+    this.slideUrl = newSlideUrl;
+  }
+  changeDuration(newDuration) {
+    this.durationMinutes = newDuration;
+  }
+  // TODO: イベントの期間内かどうかをチェックする必要がある？
+  changeStartTime(newStartTime) {
+    this.startTime = newStartTime;
+  }
+  toSnapshot() {
+    return {
+      exhibitId: this.exhibitId,
+      startTime: this.startTime,
+      durationMinutes: this.durationMinutes,
+      slideUrl: this.slideUrl
+    };
+  }
+};
+
+// src/domain/aggregates/member/Member.ts
+var Member = class {
+  constructor(id, name, studentId, department, email, personalEmail) {
+    this.id = id;
+    this.name = name;
+    this.studentId = studentId;
+    this.department = department;
+    this.email = email;
+    this.personalEmail = personalEmail;
+  }
+  discordAccounts = [];
+  getName() {
+    return this.name;
+  }
+  getStudentId() {
+    return this.studentId;
+  }
+  getDepartment() {
+    return this.department;
+  }
+  getEmail() {
+    return this.email;
+  }
+  getPersonalEmail() {
+    return this.personalEmail;
+  }
+  getDiscordAccounts() {
+    return this.discordAccounts;
+  }
+  setName(newName) {
+    this.name = newName;
+  }
+  setStudentId(newStudentId) {
+    this.studentId = newStudentId;
+  }
+  setDepartment(newDepartment) {
+    this.department = newDepartment;
+  }
+  setEmail(newEmail) {
+    this.email = newEmail;
+  }
+  setPersonalEmail(newPersonalEmail) {
+    this.personalEmail = newPersonalEmail;
+  }
+  addDiscordAccount(discordAccount) {
+    if (this.getDiscordAccountById(discordAccount.id)) {
+      throw new DiscordAccountAlreadyConnectedException();
+    }
+    this.discordAccounts.push(discordAccount);
+  }
+  removeDiscordAccount(discordAccountId) {
+    this.getDiscordAccountOrThrow(discordAccountId);
+    this.discordAccounts = this.discordAccounts.filter(
+      (account) => account.id !== discordAccountId
+    );
+  }
+  getDiscordAccountById(discordAccountId) {
+    return this.discordAccounts.find(
+      (account) => account.id === discordAccountId
+    );
+  }
+  getDiscordAccountOrThrow(discordAccountId) {
+    const account = this.getDiscordAccountById(discordAccountId);
+    if (!account) {
+      throw new DiscordAccountNotConnectedException2();
+    }
+    return account;
+  }
+  setDiscordAccountNickName(discordAccountId, newNickName) {
+    this.getDiscordAccountOrThrow(discordAccountId).setNickName(newNickName);
+  }
+  toSnapshot() {
+    return {
+      id: this.id,
+      name: this.name,
+      studentId: this.studentId,
+      department: this.department,
+      email: this.email,
+      personalEmail: this.personalEmail,
+      discordAccounts: this.discordAccounts.map(
+        (account) => account.toSnapshot()
+      )
+    };
+  }
+};
+
+// src/domain/aggregates/member/DiscordAccount.ts
+var DiscordAccount = class {
+  constructor(id, nickName, memberId) {
+    this.id = id;
+    this.nickName = nickName;
+    this.memberId = memberId;
+  }
+  getNickName() {
+    return this.nickName;
+  }
+  getMemberId() {
+    return this.memberId;
+  }
+  setNickName(newNickName) {
+    this.nickName = newNickName;
+  }
+  toSnapshot() {
+    return {
+      id: this.id,
+      nickName: this.nickName,
+      memberId: this.memberId
+    };
+  }
+};
+
+// src/application/usecase/member/ConnectDiscordAccount.ts
+var ConnectDiscordAccountUseCase = class extends IUseCase {
+  constructor(memberRepo) {
+    super();
+    this.memberRepo = memberRepo;
+  }
+  async execute(input) {
+    const member = await this.memberRepo.findById(input.memberId);
+    if (!member) {
+      throw new MemberNotFoundException(input.memberId);
+    }
+    const discordAccount = new DiscordAccount(
+      input.discordAccountId,
+      input.discordNickName ?? "",
+      member.id
+    );
+    member.addDiscordAccount(discordAccount);
+    await this.memberRepo.save(member);
+    return { member };
+  }
+};
+
+// src/application/usecase/member/GetMember.ts
+var GetMemberUseCase = class extends IUseCase {
+  constructor(memberRepo) {
+    super();
+    this.memberRepo = memberRepo;
+  }
+  async execute(input) {
+    const member = await this.memberRepo.findById(input.id);
+    return { member };
+  }
+};
+
+// src/application/usecase/member/GetMemberByEmail.ts
+var GetMemberByEmailUseCase = class extends IUseCase {
+  constructor(memberRepo) {
+    super();
+    this.memberRepo = memberRepo;
+  }
+  async execute(input) {
+    const member = await this.memberRepo.findByEmail(input.email);
+    return { member };
+  }
+};
+
+// src/application/usecase/member/GetMemberByDiscordId.ts
+var GetMemberByDiscordIdUseCase = class extends IUseCase {
+  constructor(memberRepo) {
+    super();
+    this.memberRepo = memberRepo;
+  }
+  async execute(input) {
+    const member = await this.memberRepo.findByDiscordAccountId(
+      input.discordId
+    );
+    return { member };
+  }
+};
+
+// src/application/usecase/member/GetMemberList.ts
+var GetMemberListUseCase = class extends IUseCase {
+  constructor(memberRepo) {
+    super();
+    this.memberRepo = memberRepo;
+  }
+  async execute(_input) {
+    const members2 = await this.memberRepo.findAll();
+    return { members: members2 };
+  }
+};
+
+// src/application/usecase/member/RegisterMember.ts
+var import_uuid = require("uuid");
+var RegisterMemberUseCase = class extends IUseCase {
+  constructor(memberRepo) {
+    super();
+    this.memberRepo = memberRepo;
+  }
+  async execute(input) {
+    const existingMember = await this.memberRepo.findByEmail(input.email);
+    if (existingMember) {
+      throw new MemberEmailAlreadyExistsException(input.email);
+    }
+    const universityEmail = new UniversityEmail(input.email);
+    const personalEmail = input.personalEmail ? new Email(input.personalEmail) : void 0;
+    const member = new Member(
+      (0, import_uuid.v4)(),
+      input.name,
+      input.studentId,
+      Department.fromString(input.department),
+      universityEmail,
+      personalEmail
+    );
+    if (input.discordInfo) {
+      const discordAccount = new DiscordAccount(
+        input.discordInfo.accountId,
+        input.discordInfo.nickName,
+        member.id
+      );
+      member.addDiscordAccount(discordAccount);
+    }
+    await this.memberRepo.save(member);
+    return { member };
+  }
+};
+
+// src/application/usecase/member/UpdateMember.ts
+var UpdateMemberUseCase = class extends IUseCase {
+  constructor(memberRepo) {
+    super();
+    this.memberRepo = memberRepo;
+  }
+  async execute(input) {
+    const member = await this.memberRepo.findById(input.memberId);
+    if (!member) {
+      throw new MemberNotFoundException(input.memberId);
+    }
+    if (input.name) {
+      member.setName(input.name);
+    }
+    if (input.studentId) {
+      member.setStudentId(input.studentId);
+    }
+    if (input.department) {
+      member.setDepartment(Department.fromString(input.department));
+    }
+    if (input.email) {
+      member.setEmail(new UniversityEmail(input.email));
+    }
+    if (input.personalEmail) {
+      member.setPersonalEmail(new Email(input.personalEmail));
+    }
+    if (input.discordAccountId && input.discordNickName) {
+      const discordAccount = new DiscordAccount(
+        input.discordAccountId,
+        input.discordNickName,
+        member.id
+      );
+      member.addDiscordAccount(discordAccount);
+    }
+    await this.memberRepo.save(member);
+    return { member };
+  }
+};
+
+// src/application/usecase/event/AddExhibitToEvent.ts
+var AddExhibitToEvent = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    const { id, name, description, markdownContent, url } = input.exhibit;
+    const exhibit = new Exhibit(id, name, description, markdownContent, url);
+    event.addExhibit(exhibit);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/ChangeExhibitDescription.ts
+var ChangeExhibitDescription = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.changeExhibitDescription(input.exhibitId, input.newDescription);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/ChangeExhibitMarkdownContent.ts
+var ChangeExhibitMarkdownContent = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.changeExhibitMarkdownContent(
+      input.exhibitId,
+      input.newMarkdownContent
+    );
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/ChangeExhibitName.ts
+var ChangeExhibitName = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.changeExhibitName(input.exhibitId, input.newName);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/ChangeExhibitUrl.ts
+var ChangeExhibitUrl = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.changeExhibitUrl(input.exhibitId, input.newUrl);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/ChangeLightningTalkDuration.ts
+var ChangeLightningTalkDuration = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.changeExhibitLightningTalkDuration(
+      input.exhibitId,
+      input.newDuration
+    );
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/ChangeLightningTalkSlideUrl.ts
+var ChangeLightningTalkSlideUrl = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.changeExhibitLightningTalkSlideUrl(
+      input.exhibitId,
+      input.newSlideUrl
+    );
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/ChangeLightningTalkStartTime.ts
+var ChangeLightningTalkStartTime = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.changeExhibitLightningTalkStartTime(
+      input.exhibitId,
+      input.newStartTime
+    );
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/CreateEvent.ts
+var CreateEvent = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const { id, name, date } = input;
+    const event = new Event(id, name, date);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/DeleteEvent.ts
+var DeleteEvent = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    await this.eventRepository.delete(input.eventId);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/GetEvent.ts
+var GetEvent = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/GetEventList.ts
+var GetEventList = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(_input) {
+    const events2 = await this.eventRepository.findAll();
+    return { events: events2 };
+  }
+};
+
+// src/application/usecase/event/RemoveExhibitFromEvent.ts
+var RemoveExhibitFromEvent = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.removeExhibit(input.exhibitId);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/event/UpdateEvent.ts
+var UpdateEvent = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    if (input.name !== void 0) {
+      event.changeName(input.name);
+    }
+    if (input.date !== void 0) {
+      event.changeDate(input.date);
+    }
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/eventParticipation/RegisterMemberToEvent.ts
+var RegisterMemberToEvent = class extends IUseCase {
+  constructor(eventRepository, memberRepository) {
+    super();
+    this.eventRepository = eventRepository;
+    this.memberRepository = memberRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    const member = await this.memberRepository.findById(input.memberId);
+    if (!member) {
+      throw new MemberNotFoundException(input.memberId);
+    }
+    event.addMemberId(input.memberId);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/eventParticipation/RemoveMemberFromEvent.ts
+var RemoveMemberFromEvent = class extends IUseCase {
+  constructor(eventRepository, memberRepository) {
+    super();
+    this.eventRepository = eventRepository;
+    this.memberRepository = memberRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    event.removeMemberId(input.memberId);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/eventParticipation/GetEventsByMember.ts
+var GetEventsByMember = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const events2 = await this.eventRepository.findByParticipantMemberId(
+      input.memberId
+    );
+    return { events: events2 };
+  }
+};
+
+// src/application/usecase/eventParticipation/GetMembersByEvent.ts
+var GetMembersByEvent = class extends IUseCase {
+  constructor(eventRepository, memberRepository) {
+    super();
+    this.eventRepository = eventRepository;
+    this.memberRepository = memberRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findById(input.eventId);
+    if (!event) {
+      throw new EventNotFoundException(input.eventId);
+    }
+    const members2 = (await Promise.all(
+      event.getMemberIds().map((memberId) => this.memberRepository.findById(memberId))
+    )).filter((member) => member !== null);
+    return { members: members2 };
+  }
+};
+
+// src/application/usecase/eventParticipation/RegisterMemberToExhibit.ts
+var RegisterMemberToExhibit = class extends IUseCase {
+  constructor(eventRepository, memberRepository) {
+    super();
+    this.eventRepository = eventRepository;
+    this.memberRepository = memberRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findByExhibitId(input.exhibitId);
+    if (!event) {
+      throw new EventNotFoundException(input.exhibitId);
+    }
+    const member = await this.memberRepository.findById(input.memberId);
+    if (!member) {
+      throw new MemberNotFoundException(input.memberId);
+    }
+    event.addExhibitMemberId(input.exhibitId, input.memberId);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/eventParticipation/RemoveMemberFromExhibit.ts
+var RemoveMemberFromExhibit = class extends IUseCase {
+  constructor(memberRepository, eventRepository) {
+    super();
+    this.memberRepository = memberRepository;
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findByExhibitId(input.exhibitId);
+    if (!event) {
+      throw new EventNotFoundException(input.exhibitId);
+    }
+    event.removeExhibitMemberId(input.exhibitId, input.memberId);
+    await this.eventRepository.save(event);
+    return { event };
+  }
+};
+
+// src/application/usecase/eventParticipation/GetExhibitsByMember.ts
+var GetExhibitsByMember = class extends IUseCase {
+  constructor(eventRepository) {
+    super();
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const events2 = await this.eventRepository.findByParticipantMemberId(
+      input.memberId
+    );
+    const exhibits2 = [];
+    for (const event of events2) {
+      for (const exhibit of event.getExhibits()) {
+        if (exhibit.getMemberIds().includes(input.memberId)) {
+          exhibits2.push(exhibit);
+        }
+      }
+    }
+    return { exhibits: exhibits2 };
+  }
+};
+
+// src/application/usecase/eventParticipation/GetMembersByExhibit.ts
+var GetMembersByExhibit = class extends IUseCase {
+  constructor(memberRepository, eventRepository) {
+    super();
+    this.memberRepository = memberRepository;
+    this.eventRepository = eventRepository;
+  }
+  async execute(input) {
+    const event = await this.eventRepository.findByExhibitId(input.exhibitId);
+    if (!event) {
+      throw new ExhibitNotFoundFromExhibitIdException(input.exhibitId);
+    }
+    const memberResults = await Promise.all(
+      event.getMemberIds().map((memberId) => this.memberRepository.findById(memberId))
+    );
+    const members2 = memberResults.filter((m) => m !== null);
+    return { members: members2 };
+  }
+};
+
+// src/infrastructure/drizzle/DrizzleMemberRepository.ts
+var import_drizzle_orm3 = require("drizzle-orm");
+
+// src/infrastructure/drizzle/client.ts
+var import_node_postgres = require("drizzle-orm/node-postgres");
+var import_pg = require("pg");
+
+// src/infrastructure/drizzle/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  discordAccounts: () => discordAccounts,
+  discordAccountsRelations: () => discordAccountsRelations,
+  events: () => events,
+  eventsRelations: () => eventsRelations,
+  exhibits: () => exhibits,
+  exhibitsRelations: () => exhibitsRelations,
+  lightningTalks: () => lightningTalks,
+  lightningTalksRelations: () => lightningTalksRelations,
+  memberEvents: () => memberEvents,
+  memberEventsRelations: () => memberEventsRelations,
+  memberExhibits: () => memberExhibits,
+  memberExhibitsRelations: () => memberExhibitsRelations,
+  members: () => members,
+  membersRelations: () => membersRelations,
+  prismaMigrations: () => prismaMigrations
+});
+var import_drizzle_orm = require("drizzle-orm");
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_pg_core = require("drizzle-orm/pg-core");
+var members = (0, import_pg_core.pgTable)(
+  "members",
+  {
+    id: (0, import_pg_core.text)().primaryKey().notNull(),
+    name: (0, import_pg_core.text)().notNull(),
+    studentId: (0, import_pg_core.text)("student_id").notNull(),
+    department: (0, import_pg_core.text)().notNull(),
+    email: (0, import_pg_core.text)().notNull(),
+    personalEmail: (0, import_pg_core.text)("personal_email"),
+    createdAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).default(import_drizzle_orm2.sql`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).notNull()
+  },
+  (table) => [
+    (0, import_pg_core.uniqueIndex)("members_email_key").using(
+      "btree",
+      table.email.asc().nullsLast().op("text_ops")
+    )
+  ]
+);
+var discordAccounts = (0, import_pg_core.pgTable)(
+  "discord_accounts",
+  {
+    discordId: (0, import_pg_core.text)("discord_id").primaryKey().notNull(),
+    nickName: (0, import_pg_core.text)("nick_name").notNull(),
+    memberId: (0, import_pg_core.text)("member_id").notNull(),
+    createdAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).default(import_drizzle_orm2.sql`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).notNull()
+  },
+  (table) => [
+    (0, import_pg_core.foreignKey)({
+      columns: [table.memberId],
+      foreignColumns: [members.id],
+      name: "discord_accounts_member_id_fkey"
+    }).onUpdate("cascade").onDelete("restrict")
+  ]
+);
+var events = (0, import_pg_core.pgTable)("events", {
+  id: (0, import_pg_core.text)().primaryKey().notNull(),
+  name: (0, import_pg_core.text)().notNull(),
+  date: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).notNull(),
+  createdAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).default(import_drizzle_orm2.sql`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).notNull()
+});
+var exhibits = (0, import_pg_core.pgTable)(
+  "exhibits",
+  {
+    id: (0, import_pg_core.text)().primaryKey().notNull(),
+    name: (0, import_pg_core.text)().notNull(),
+    description: (0, import_pg_core.text)(),
+    url: (0, import_pg_core.text)(),
+    eventId: (0, import_pg_core.text)("event_id").notNull(),
+    createdAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).default(import_drizzle_orm2.sql`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).notNull(),
+    markdownContent: (0, import_pg_core.text)("markdown_content")
+  },
+  (table) => [
+    (0, import_pg_core.foreignKey)({
+      columns: [table.eventId],
+      foreignColumns: [events.id],
+      name: "exhibits_event_id_fkey"
+    }).onUpdate("cascade").onDelete("restrict")
+  ]
+);
+var lightningTalks = (0, import_pg_core.pgTable)(
+  "lightning_talks",
+  {
+    exhibitId: (0, import_pg_core.text)("exhibit_id").primaryKey().notNull(),
+    startTime: (0, import_pg_core.timestamp)("start_time", {
+      precision: 3,
+      mode: "string"
+    }).notNull(),
+    duration: (0, import_pg_core.integer)().notNull(),
+    slideUrl: (0, import_pg_core.text)("slide_url"),
+    createdAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).default(import_drizzle_orm2.sql`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).notNull()
+  },
+  (table) => [
+    (0, import_pg_core.foreignKey)({
+      columns: [table.exhibitId],
+      foreignColumns: [exhibits.id],
+      name: "lightning_talks_exhibit_id_fkey"
+    }).onUpdate("cascade").onDelete("restrict")
+  ]
+);
+var memberEvents = (0, import_pg_core.pgTable)(
+  "member_events",
+  {
+    id: (0, import_pg_core.text)().primaryKey().notNull(),
+    memberId: (0, import_pg_core.text)("member_id").notNull(),
+    eventId: (0, import_pg_core.text)("event_id").notNull(),
+    createdAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).default(import_drizzle_orm2.sql`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).notNull()
+  },
+  (table) => [
+    (0, import_pg_core.uniqueIndex)("member_events_member_id_event_id_key").using(
+      "btree",
+      table.memberId.asc().nullsLast().op("text_ops"),
+      table.eventId.asc().nullsLast().op("text_ops")
+    ),
+    (0, import_pg_core.foreignKey)({
+      columns: [table.eventId],
+      foreignColumns: [events.id],
+      name: "member_events_event_id_fkey"
+    }).onUpdate("cascade").onDelete("restrict"),
+    (0, import_pg_core.foreignKey)({
+      columns: [table.memberId],
+      foreignColumns: [members.id],
+      name: "member_events_member_id_fkey"
+    }).onUpdate("cascade").onDelete("restrict")
+  ]
+);
+var memberExhibits = (0, import_pg_core.pgTable)(
+  "member_exhibits",
+  {
+    id: (0, import_pg_core.text)().primaryKey().notNull(),
+    memberId: (0, import_pg_core.text)("member_id").notNull(),
+    exhibitId: (0, import_pg_core.text)("exhibit_id").notNull(),
+    createdAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).default(import_drizzle_orm2.sql`CURRENT_TIMESTAMP`).notNull(),
+    updatedAt: (0, import_pg_core.timestamp)({ precision: 3, mode: "string" }).notNull()
+  },
+  (table) => [
+    (0, import_pg_core.uniqueIndex)("member_exhibits_member_id_exhibit_id_key").using(
+      "btree",
+      table.memberId.asc().nullsLast().op("text_ops"),
+      table.exhibitId.asc().nullsLast().op("text_ops")
+    ),
+    (0, import_pg_core.foreignKey)({
+      columns: [table.exhibitId],
+      foreignColumns: [exhibits.id],
+      name: "member_exhibits_exhibit_id_fkey"
+    }).onUpdate("cascade").onDelete("restrict"),
+    (0, import_pg_core.foreignKey)({
+      columns: [table.memberId],
+      foreignColumns: [members.id],
+      name: "member_exhibits_member_id_fkey"
+    }).onUpdate("cascade").onDelete("restrict")
+  ]
+);
+var prismaMigrations = (0, import_pg_core.pgTable)("_prisma_migrations", {
+  id: (0, import_pg_core.varchar)({ length: 36 }).primaryKey().notNull(),
+  checksum: (0, import_pg_core.varchar)({ length: 64 }).notNull(),
+  finishedAt: (0, import_pg_core.timestamp)("finished_at", { withTimezone: true, mode: "string" }),
+  migrationName: (0, import_pg_core.varchar)("migration_name", { length: 255 }).notNull(),
+  logs: (0, import_pg_core.text)(),
+  rolledBackAt: (0, import_pg_core.timestamp)("rolled_back_at", {
+    withTimezone: true,
+    mode: "string"
+  }),
+  startedAt: (0, import_pg_core.timestamp)("started_at", { withTimezone: true, mode: "string" }).defaultNow().notNull(),
+  appliedStepsCount: (0, import_pg_core.integer)("applied_steps_count").default(0).notNull()
+});
+var membersRelations = (0, import_drizzle_orm.relations)(members, ({ many }) => ({
+  discordAccounts: many(discordAccounts),
+  memberEvents: many(memberEvents),
+  memberExhibits: many(memberExhibits)
+}));
+var discordAccountsRelations = (0, import_drizzle_orm.relations)(
+  discordAccounts,
+  ({ one }) => ({
+    member: one(members, {
+      fields: [discordAccounts.memberId],
+      references: [members.id]
+    })
+  })
+);
+var eventsRelations = (0, import_drizzle_orm.relations)(events, ({ many }) => ({
+  memberEvents: many(memberEvents),
+  exhibits: many(exhibits)
+}));
+var exhibitsRelations = (0, import_drizzle_orm.relations)(exhibits, ({ one, many }) => ({
+  event: one(events, {
+    fields: [exhibits.eventId],
+    references: [events.id]
+  }),
+  lightningTalk: one(lightningTalks, {
+    fields: [exhibits.id],
+    references: [lightningTalks.exhibitId]
+  }),
+  memberExhibits: many(memberExhibits)
+}));
+var lightningTalksRelations = (0, import_drizzle_orm.relations)(lightningTalks, ({ one }) => ({
+  exhibit: one(exhibits, {
+    fields: [lightningTalks.exhibitId],
+    references: [exhibits.id]
+  })
+}));
+var memberEventsRelations = (0, import_drizzle_orm.relations)(memberEvents, ({ one }) => ({
+  member: one(members, {
+    fields: [memberEvents.memberId],
+    references: [members.id]
+  }),
+  event: one(events, {
+    fields: [memberEvents.eventId],
+    references: [events.id]
+  })
+}));
+var memberExhibitsRelations = (0, import_drizzle_orm.relations)(memberExhibits, ({ one }) => ({
+  member: one(members, {
+    fields: [memberExhibits.memberId],
+    references: [members.id]
+  }),
+  exhibit: one(exhibits, {
+    fields: [memberExhibits.exhibitId],
+    references: [exhibits.id]
+  })
+}));
+
+// src/infrastructure/drizzle/client.ts
+var pool = null;
+function getPool() {
+  if (!pool) {
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString) {
+      throw new Error("DATABASE_URL environment variable is not set");
+    }
+    pool = new import_pg.Pool({ connectionString });
+  }
+  return pool;
+}
+function getDb() {
+  return (0, import_node_postgres.drizzle)(getPool(), { schema: schema_exports });
+}
+
+// src/infrastructure/drizzle/DrizzleMemberRepository.ts
+var DrizzleMemberRepository = class {
+  /**
+   * Converts a database record to a domain Member entity.
+   * Accepts the exact type returned by Drizzle's relational query.
+   */
+  toDomain(record) {
+    const member = new Member(
+      record.id,
+      record.name,
+      record.studentId,
+      Department.fromString(record.department),
+      new UniversityEmail(record.email),
+      record.personalEmail ? new Email(record.personalEmail) : void 0
+    );
+    for (const discordAccount of record.discordAccounts) {
+      member.addDiscordAccount(
+        new DiscordAccount(
+          discordAccount.discordId,
+          discordAccount.nickName,
+          discordAccount.memberId
+        )
+      );
+    }
+    return member;
+  }
+  // ==========================================================================
+  // Query Methods
+  // ==========================================================================
+  async findByDiscordAccountId(discordAccountId) {
+    const db = getDb();
+    const discordAccount = await db.query.discordAccounts.findFirst({
+      where: (0, import_drizzle_orm3.eq)(discordAccounts.discordId, discordAccountId)
+    });
+    if (!discordAccount) return null;
+    return this.findById(discordAccount.memberId);
+  }
+  async findById(id) {
+    const db = getDb();
+    const record = await db.query.members.findFirst({
+      where: (0, import_drizzle_orm3.eq)(members.id, id),
+      with: { discordAccounts: true }
+    });
+    if (!record) return null;
+    return this.toDomain(record);
+  }
+  async findByEmail(email) {
+    const db = getDb();
+    const record = await db.query.members.findFirst({
+      where: (0, import_drizzle_orm3.eq)(members.email, email),
+      with: { discordAccounts: true }
+    });
+    if (!record) return null;
+    return this.toDomain(record);
+  }
+  async findByStudentId(studentId) {
+    const db = getDb();
+    const record = await db.query.members.findFirst({
+      where: (0, import_drizzle_orm3.eq)(members.studentId, studentId),
+      with: { discordAccounts: true }
+    });
+    if (!record) return null;
+    return this.toDomain(record);
+  }
+  async findAll() {
+    const db = getDb();
+    const records = await db.query.members.findMany({
+      with: { discordAccounts: true }
+    });
+    return records.map((record) => this.toDomain(record));
+  }
+  // ==========================================================================
+  // Persistence Methods
+  // ==========================================================================
+  async save(member) {
+    const db = getDb();
+    const snapshot = member.toSnapshot();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await db.insert(members).values({
+      id: snapshot.id,
+      name: snapshot.name,
+      studentId: snapshot.studentId,
+      department: snapshot.department.getValue(),
+      email: snapshot.email.getValue(),
+      personalEmail: snapshot.personalEmail?.getValue() ?? null,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: members.id,
+      set: {
+        name: snapshot.name,
+        studentId: snapshot.studentId,
+        department: snapshot.department.getValue(),
+        email: snapshot.email.getValue(),
+        personalEmail: snapshot.personalEmail?.getValue() ?? null,
+        updatedAt: now
+      }
+    });
+    for (const discordAccount of snapshot.discordAccounts) {
+      await db.insert(discordAccounts).values({
+        discordId: discordAccount.id,
+        nickName: discordAccount.nickName,
+        memberId: discordAccount.memberId,
+        updatedAt: now
+      }).onConflictDoUpdate({
+        target: discordAccounts.discordId,
+        set: {
+          nickName: discordAccount.nickName,
+          updatedAt: now
+        }
+      });
+    }
+  }
+  async delete(memberId) {
+    const db = getDb();
+    await db.delete(discordAccounts).where((0, import_drizzle_orm3.eq)(discordAccounts.memberId, memberId));
+    await db.delete(members).where((0, import_drizzle_orm3.eq)(members.id, memberId));
+  }
+};
+
+// src/infrastructure/drizzle/DrizzleEventRepository.ts
+var import_node_crypto = require("crypto");
+var import_drizzle_orm4 = require("drizzle-orm");
+var DrizzleEventRepository = class {
+  /**
+   * Converts a database record to a domain Event entity.
+   */
+  toDomain(record) {
+    const event = new Event(record.id, record.name, new Date(record.date));
+    for (const memberEvent of record.memberEvents) {
+      event.addMemberId(memberEvent.memberId);
+    }
+    for (const exhibitRecord of record.exhibits) {
+      const exhibit = this.createExhibitFromRecord(exhibitRecord);
+      for (const memberExhibit of exhibitRecord.memberExhibits) {
+        exhibit.addMemberId(memberExhibit.memberId);
+      }
+      event.addExhibit(exhibit);
+    }
+    return event;
+  }
+  /**
+   * Creates an Exhibit domain entity from a database record.
+   */
+  createExhibitFromRecord(record) {
+    if (record.lightningTalk) {
+      const lt = record.lightningTalk;
+      const lightningTalk = new LightningTalk(
+        lt.exhibitId,
+        new Date(lt.startTime),
+        new LightningTalkDuration(lt.duration),
+        lt.slideUrl ? new Url(lt.slideUrl) : void 0
+      );
+      return Exhibit.createWithLightningTalk(
+        record.id,
+        record.name,
+        lightningTalk,
+        record.description ?? void 0,
+        record.markdownContent ?? void 0,
+        record.url ? new Url(record.url) : void 0
+      );
+    }
+    return new Exhibit(
+      record.id,
+      record.name,
+      record.description ?? void 0,
+      record.markdownContent ?? void 0,
+      record.url ? new Url(record.url) : void 0
+    );
+  }
+  // ==========================================================================
+  // Persistence Methods
+  // ==========================================================================
+  async persistEvent(event) {
+    const db = getDb();
+    const snapshot = event.toSnapshot();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const dateStr = snapshot.date instanceof Date ? snapshot.date.toISOString() : snapshot.date;
+    await db.insert(events).values({
+      id: snapshot.id,
+      name: snapshot.name,
+      date: dateStr,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: events.id,
+      set: {
+        name: snapshot.name,
+        date: dateStr,
+        updatedAt: now
+      }
+    });
+    const snapshotExhibitIds = snapshot.exhibits.map((ex) => ex.id);
+    await this.deleteObsoleteExhibits(db, snapshot.id, snapshotExhibitIds);
+    for (const ex of snapshot.exhibits) {
+      await this.upsertExhibit(db, snapshot.id, ex);
+    }
+    await this.syncMemberEvents(db, snapshot.id, event.getMemberIds());
+    for (const exhibitDomain of event.getExhibits()) {
+      await this.syncMemberExhibits(
+        db,
+        exhibitDomain.id,
+        exhibitDomain.getMemberIds()
+      );
+    }
+  }
+  async deleteObsoleteExhibits(db, eventId, keptExhibitIds) {
+    const existingExhibits = await db.select({ id: exhibits.id }).from(exhibits).where((0, import_drizzle_orm4.eq)(exhibits.eventId, eventId));
+    const existingIdSet = new Set(existingExhibits.map((r) => r.id));
+    const keptIdSet = new Set(keptExhibitIds);
+    const obsoleteIds = [...existingIdSet].filter((id) => !keptIdSet.has(id));
+    if (obsoleteIds.length > 0) {
+      await db.delete(lightningTalks).where((0, import_drizzle_orm4.inArray)(lightningTalks.exhibitId, obsoleteIds));
+      await db.delete(memberExhibits).where((0, import_drizzle_orm4.inArray)(memberExhibits.exhibitId, obsoleteIds));
+      await db.delete(exhibits).where((0, import_drizzle_orm4.inArray)(exhibits.id, obsoleteIds));
+    }
+  }
+  async upsertExhibit(db, eventId, ex) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await db.insert(exhibits).values({
+      id: ex.id,
+      name: ex.name,
+      description: ex.description ?? null,
+      markdownContent: ex.markdownContent ?? null,
+      url: ex.url?.getValue() ?? null,
+      eventId,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: exhibits.id,
+      set: {
+        name: ex.name,
+        description: ex.description ?? null,
+        markdownContent: ex.markdownContent ?? null,
+        url: ex.url?.getValue() ?? null,
+        updatedAt: now
+      }
+    });
+    if (ex.lightningTalk) {
+      const startTimeStr = ex.lightningTalk.startTime instanceof Date ? ex.lightningTalk.startTime.toISOString() : ex.lightningTalk.startTime;
+      await db.insert(lightningTalks).values({
+        exhibitId: ex.id,
+        startTime: startTimeStr,
+        duration: ex.lightningTalk.durationMinutes.getValue(),
+        slideUrl: ex.lightningTalk.slideUrl?.getValue() ?? null,
+        updatedAt: now
+      }).onConflictDoUpdate({
+        target: lightningTalks.exhibitId,
+        set: {
+          startTime: startTimeStr,
+          duration: ex.lightningTalk.durationMinutes.getValue(),
+          slideUrl: ex.lightningTalk.slideUrl?.getValue() ?? null,
+          updatedAt: now
+        }
+      });
+    } else {
+      await db.delete(lightningTalks).where((0, import_drizzle_orm4.eq)(lightningTalks.exhibitId, ex.id));
+    }
+  }
+  async syncMemberEvents(db, eventId, memberIds) {
+    await db.delete(memberEvents).where((0, import_drizzle_orm4.eq)(memberEvents.eventId, eventId));
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const memberId of memberIds) {
+      await db.insert(memberEvents).values({
+        id: (0, import_node_crypto.randomUUID)(),
+        memberId,
+        eventId,
+        updatedAt: now
+      }).onConflictDoNothing();
+    }
+  }
+  async syncMemberExhibits(db, exhibitId, memberIds) {
+    await db.delete(memberExhibits).where((0, import_drizzle_orm4.eq)(memberExhibits.exhibitId, exhibitId));
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const memberId of memberIds) {
+      await db.insert(memberExhibits).values({
+        id: (0, import_node_crypto.randomUUID)(),
+        memberId,
+        exhibitId,
+        updatedAt: now
+      }).onConflictDoNothing();
+    }
+  }
+  // ==========================================================================
+  // Query Methods
+  // ==========================================================================
+  async findById(id) {
+    const db = getDb();
+    const record = await db.query.events.findFirst({
+      where: (0, import_drizzle_orm4.eq)(events.id, id),
+      with: {
+        memberEvents: true,
+        exhibits: {
+          with: {
+            lightningTalk: true,
+            memberExhibits: true
+          }
+        }
+      }
+    });
+    if (!record) return null;
+    return this.toDomain(record);
+  }
+  async findByParticipantMemberId(memberId) {
+    const db = getDb();
+    const participations = await db.select({ eventId: memberEvents.eventId }).from(memberEvents).where((0, import_drizzle_orm4.eq)(memberEvents.memberId, memberId));
+    if (participations.length === 0) return [];
+    const eventIds = participations.map((p) => p.eventId);
+    const records = await db.query.events.findMany({
+      where: (0, import_drizzle_orm4.inArray)(events.id, eventIds),
+      with: {
+        memberEvents: true,
+        exhibits: {
+          with: {
+            lightningTalk: true,
+            memberExhibits: true
+          }
+        }
+      }
+    });
+    return records.map((r) => this.toDomain(r));
+  }
+  async findByExhibitId(exhibitId) {
+    const db = getDb();
+    const exhibit = await db.select({ eventId: exhibits.eventId }).from(exhibits).where((0, import_drizzle_orm4.eq)(exhibits.id, exhibitId)).limit(1);
+    if (exhibit.length === 0) return null;
+    return this.findById(exhibit[0].eventId);
+  }
+  async findAll() {
+    const db = getDb();
+    const records = await db.query.events.findMany({
+      with: {
+        memberEvents: true,
+        exhibits: {
+          with: {
+            lightningTalk: true,
+            memberExhibits: true
+          }
+        }
+      }
+    });
+    return records.map((r) => this.toDomain(r));
+  }
+  async save(event) {
+    await this.persistEvent(event);
+  }
+  async delete(eventId) {
+    const db = getDb();
+    const exhibitRecords = await db.select({ id: exhibits.id }).from(exhibits).where((0, import_drizzle_orm4.eq)(exhibits.eventId, eventId));
+    const exhibitIds = exhibitRecords.map((ex) => ex.id);
+    if (exhibitIds.length > 0) {
+      await db.delete(lightningTalks).where((0, import_drizzle_orm4.inArray)(lightningTalks.exhibitId, exhibitIds));
+      await db.delete(memberExhibits).where((0, import_drizzle_orm4.inArray)(memberExhibits.exhibitId, exhibitIds));
+    }
+    await db.delete(memberEvents).where((0, import_drizzle_orm4.eq)(memberEvents.eventId, eventId));
+    await db.delete(exhibits).where((0, import_drizzle_orm4.eq)(exhibits.eventId, eventId));
+    await db.delete(events).where((0, import_drizzle_orm4.eq)(events.id, eventId));
+  }
+};
+
+// src/executable/member.ts
+function createMemberUseCases() {
+  const memberRepo = new DrizzleMemberRepository();
+  return {
+    registerMember: new RegisterMemberUseCase(memberRepo),
+    updateMember: new UpdateMemberUseCase(memberRepo),
+    getMember: new GetMemberUseCase(memberRepo),
+    getMemberByDiscordId: new GetMemberByDiscordIdUseCase(memberRepo),
+    getMemberByEmail: new GetMemberByEmailUseCase(memberRepo),
+    getMemberList: new GetMemberListUseCase(memberRepo),
+    changeDiscordNickName: new ChangeDiscordNickNameUseCase(memberRepo),
+    connectDiscordAccount: new ConnectDiscordAccountUseCase(memberRepo)
+  };
+}
+
+// src/executable/event.ts
+function createEventUseCases() {
+  const eventRepo = new DrizzleEventRepository();
+  const memberRepo = new DrizzleMemberRepository();
+  return {
+    createEvent: new CreateEvent(eventRepo),
+    updateEvent: new UpdateEvent(eventRepo),
+    deleteEvent: new DeleteEvent(eventRepo),
+    getEvent: new GetEvent(eventRepo),
+    getEventList: new GetEventList(eventRepo),
+    addExhibitToEvent: new AddExhibitToEvent(eventRepo),
+    changeExhibitDescription: new ChangeExhibitDescription(
+      eventRepo
+    ),
+    changeExhibitMarkdownContent: new ChangeExhibitMarkdownContent(eventRepo),
+    changeExhibitName: new ChangeExhibitName(eventRepo),
+    changeExhibitUrl: new ChangeExhibitUrl(eventRepo),
+    changeLightningTalkDuration: new ChangeLightningTalkDuration(
+      eventRepo
+    ),
+    changeLightningTalkSlideUrl: new ChangeLightningTalkSlideUrl(
+      eventRepo
+    ),
+    changeLightningTalkStartTime: new ChangeLightningTalkStartTime(eventRepo),
+    removeExhibitFromEvent: new RemoveExhibitFromEvent(eventRepo),
+    registerMemberToEvent: new RegisterMemberToEvent(
+      eventRepo,
+      memberRepo
+    ),
+    removeMemberFromEvent: new RemoveMemberFromEvent(
+      eventRepo,
+      memberRepo
+    ),
+    getEventsByMember: new GetEventsByMember(
+      eventRepo
+    ),
+    getMembersByEvent: new GetMembersByEvent(
+      eventRepo,
+      memberRepo
+    ),
+    registerMemberToExhibit: new RegisterMemberToExhibit(
+      eventRepo,
+      memberRepo
+    ),
+    removeMemberFromExhibit: new RemoveMemberFromExhibit(
+      memberRepo,
+      eventRepo
+    ),
+    getExhibitsByMember: new GetExhibitsByMember(
+      eventRepo
+    ),
+    getMembersByExhibit: new GetMembersByExhibit(
+      memberRepo,
+      eventRepo
+    )
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Department,
+  DiscordAccount,
+  DiscordAccountAlreadyConnectedException,
+  DiscordAccountNotConnectedException,
+  DomainException,
+  Email,
+  Event,
+  Exhibit,
+  ExhibitAlreadyExistsException,
+  ExhibitHasMemberException,
+  ExhibitNotFoundException,
+  InvalidDepartmentException,
+  InvalidEmailFormatException,
+  InvalidLightningTalkDurationException,
+  InvalidUniversityEmailException,
+  InvalidUrlException,
+  InvalidUrlProtocolException,
+  LightningTalk,
+  LightningTalkDuration,
+  LightningTalkExhibitIdMismatchException,
+  LightningTalkNotFoundException,
+  Member,
+  UniversityEmail,
+  Url,
+  ValueObject,
+  createEventUseCases,
+  createMemberUseCases
+});
+//# sourceMappingURL=index.cjs.map