@shizuoka-its/core 0.1.1

package/dist/repositories/member.repository.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberRepository = void 0;
+const base_repository_1 = require("./base.repository");
+class MemberRepository extends base_repository_1.BaseRepository {
+    constructor(prisma) {
+        super(prisma, "member");
+    }
+    async findById(id) {
+        return this.prisma.member.findUnique({
+            where: { id },
+        });
+    }
+    async create(data) {
+        return this.prisma.member.create({
+            data,
+        });
+    }
+    async update(id, data) {
+        return this.prisma.member.update({
+            where: { id },
+            data,
+        });
+    }
+    async delete(id) {
+        return this.prisma.member.delete({
+            where: { id },
+        });
+    }
+    async findMany(params) {
+        return this.prisma.member.findMany(params);
+    }
+    async findByEmail(email) {
+        return this.prisma.member.findUnique({
+            where: { email },
+        });
+    }
+    async findByStudentId(studentId) {
+        return this.prisma.member.findMany({
+            where: { studentId },
+        });
+    }
+}
+exports.MemberRepository = MemberRepository;

package/dist/repositories/memberEvent.repository.d.ts

@@ -0,0 +1,13 @@
+import type { MemberEvent, Prisma, PrismaClient } from "@prisma/client";
+import { BaseRepository } from "./base.repository";
+import type { IMemberEventRepository } from "./interfaces/memberEvent.repository.interface";
+export declare class MemberEventRepository extends BaseRepository<MemberEvent, Prisma.MemberEventCreateInput, Prisma.MemberEventUpdateInput, Prisma.MemberEventFindManyArgs> implements IMemberEventRepository {
+    constructor(prisma: PrismaClient);
+    findById(id: string): Promise<MemberEvent | null>;
+    create(data: Prisma.MemberEventCreateInput): Promise<MemberEvent>;
+    update(id: string, data: Prisma.MemberEventUpdateInput): Promise<MemberEvent>;
+    delete(id: string): Promise<MemberEvent>;
+    findMany(params?: Prisma.MemberEventFindManyArgs): Promise<MemberEvent[]>;
+    findByMemberId(memberId: string): Promise<MemberEvent[]>;
+    findByEventId(eventId: string): Promise<MemberEvent[]>;
+}

package/dist/repositories/memberEvent.repository.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberEventRepository = void 0;
+const base_repository_1 = require("./base.repository");
+class MemberEventRepository extends base_repository_1.BaseRepository {
+    constructor(prisma) {
+        super(prisma, "memberEvent");
+    }
+    async findById(id) {
+        return this.prisma.memberEvent.findUnique({
+            where: { id },
+            include: {
+                member: true,
+                event: true,
+            },
+        });
+    }
+    async create(data) {
+        return this.prisma.memberEvent.create({
+            data,
+            include: {
+                member: true,
+                event: true,
+            },
+        });
+    }
+    async update(id, data) {
+        return this.prisma.memberEvent.update({
+            where: { id },
+            data,
+            include: {
+                member: true,
+                event: true,
+            },
+        });
+    }
+    async delete(id) {
+        return this.prisma.memberEvent.delete({
+            where: { id },
+        });
+    }
+    async findMany(params) {
+        return this.prisma.memberEvent.findMany(params);
+    }
+    async findByMemberId(memberId) {
+        return this.prisma.memberEvent.findMany({
+            where: { memberId },
+            include: {
+                event: true,
+            },
+        });
+    }
+    async findByEventId(eventId) {
+        return this.prisma.memberEvent.findMany({
+            where: { eventId },
+            include: {
+                member: true,
+            },
+        });
+    }
+}
+exports.MemberEventRepository = MemberEventRepository;

package/dist/repositories/memberExhibit.repository.d.ts

@@ -0,0 +1,13 @@
+import type { MemberExhibit, Prisma, PrismaClient } from "@prisma/client";
+import { BaseRepository } from "./base.repository";
+import type { IMemberExhibitRepository } from "./interfaces/memberExhibit.repository.interface";
+export declare class MemberExhibitRepository extends BaseRepository<MemberExhibit, Prisma.MemberExhibitCreateInput, Prisma.MemberExhibitUpdateInput, Prisma.MemberExhibitFindManyArgs> implements IMemberExhibitRepository {
+    constructor(prisma: PrismaClient);
+    findById(id: string): Promise<MemberExhibit | null>;
+    create(data: Prisma.MemberExhibitCreateInput): Promise<MemberExhibit>;
+    update(id: string, data: Prisma.MemberExhibitUpdateInput): Promise<MemberExhibit>;
+    delete(id: string): Promise<MemberExhibit>;
+    findMany(params?: Prisma.MemberExhibitFindManyArgs): Promise<MemberExhibit[]>;
+    findByMemberId(memberId: string): Promise<MemberExhibit[]>;
+    findByExhibitId(exhibitId: string): Promise<MemberExhibit[]>;
+}

package/dist/repositories/memberExhibit.repository.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberExhibitRepository = void 0;
+const base_repository_1 = require("./base.repository");
+class MemberExhibitRepository extends base_repository_1.BaseRepository {
+    constructor(prisma) {
+        super(prisma, "memberExhibit");
+    }
+    async findById(id) {
+        return this.prisma.memberExhibit.findUnique({
+            where: { id },
+            include: {
+                member: true,
+                exhibit: true,
+            },
+        });
+    }
+    async create(data) {
+        return this.prisma.memberExhibit.create({
+            data,
+            include: {
+                member: true,
+                exhibit: true,
+            },
+        });
+    }
+    async update(id, data) {
+        return this.prisma.memberExhibit.update({
+            where: { id },
+            data,
+            include: {
+                member: true,
+                exhibit: true,
+            },
+        });
+    }
+    async delete(id) {
+        return this.prisma.memberExhibit.delete({
+            where: { id },
+        });
+    }
+    async findMany(params) {
+        return this.prisma.memberExhibit.findMany(params);
+    }
+    async findByMemberId(memberId) {
+        return this.prisma.memberExhibit.findMany({
+            where: { memberId },
+            include: {
+                exhibit: true,
+            },
+        });
+    }
+    async findByExhibitId(exhibitId) {
+        return this.prisma.memberExhibit.findMany({
+            where: { exhibitId },
+            include: {
+                member: true,
+            },
+        });
+    }
+}
+exports.MemberExhibitRepository = MemberExhibitRepository;

package/dist/services/base.service.d.ts

@@ -0,0 +1,17 @@
+import type { IBaseRepository } from "../repositories/interfaces/base.repository.interface";
+import type { IBaseService } from "./interfaces/base.service.interface";
+export declare abstract class BaseService<T, // T: エンティティの型
+CreateDTO, // CreateDTO: エンティティの作成時に必要なデータの型
+UpdateDTO, // UpdateDTO: エンティティの更新時に必要なデータの型
+FindManyArgs, // FindManyArgs: 検索条件の型
+CreateInput = CreateDTO, // CreateInput: リポジトリの作成入力型
+UpdateInput = UpdateDTO, // UpdateInput: リポジトリの更新入力型
+R extends IBaseRepository<T, CreateInput, UpdateInput, FindManyArgs> = IBaseRepository<T, CreateInput, UpdateInput, FindManyArgs>> implements IBaseService<T, CreateDTO, UpdateDTO> {
+    protected readonly repository: R;
+    constructor(repository: R);
+    findById(id: string): Promise<T | null>;
+    abstract create(data: CreateDTO): Promise<T>;
+    abstract update(id: string, data: UpdateDTO): Promise<T>;
+    delete(id: string): Promise<T>;
+    findMany(): Promise<T[]>;
+}

package/dist/services/base.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+class BaseService {
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async findById(id) {
+        return this.repository.findById(id);
+    }
+    async delete(id) {
+        return this.repository.delete(id);
+    }
+    async findMany() {
+        return this.repository.findMany();
+    }
+}
+exports.BaseService = BaseService;

package/dist/services/discordAccount.service.d.ts

@@ -0,0 +1,12 @@
+import type { DiscordAccount, Prisma } from "@prisma/client";
+import type { IDiscordAccountRepository } from "../repositories/interfaces/discordAccount.repository.interface";
+import type { IMemberRepository } from "../repositories/interfaces/member.repository.interface";
+import { BaseService } from "./base.service";
+import type { DiscordAccountCreateDTO, DiscordAccountUpdateDTO, IDiscordAccountService } from "./interfaces/discordAccount.service.interface";
+export declare class DiscordAccountService extends BaseService<DiscordAccount, DiscordAccountCreateDTO, DiscordAccountUpdateDTO, Prisma.DiscordAccountFindManyArgs, Prisma.DiscordAccountCreateInput, Prisma.DiscordAccountUpdateInput, IDiscordAccountRepository> implements IDiscordAccountService {
+    private readonly memberRepository;
+    constructor(discordAccountRepository: IDiscordAccountRepository, memberRepository: IMemberRepository);
+    create(data: DiscordAccountCreateDTO): Promise<DiscordAccount>;
+    update(id: string, data: DiscordAccountUpdateDTO): Promise<DiscordAccount>;
+    findByMemberId(memberId: string): Promise<DiscordAccount[]>;
+}

package/dist/services/discordAccount.service.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordAccountService = void 0;
+const base_service_1 = require("./base.service");
+class DiscordAccountService extends base_service_1.BaseService {
+    constructor(discordAccountRepository, memberRepository) {
+        super(discordAccountRepository);
+        this.memberRepository = memberRepository;
+    }
+    async create(data) {
+        // メンバーの存在確認
+        const member = await this.memberRepository.findById(data.memberId);
+        if (!member) {
+            throw new Error("Member not found");
+        }
+        // Discord IDの重複チェック
+        const existingAccount = await this.repository.findById(data.id);
+        if (existingAccount) {
+            throw new Error("Discord account already exists");
+        }
+        return this.repository.create({
+            id: data.id,
+            nickName: data.nickName,
+            member: { connect: { id: data.memberId } },
+        });
+    }
+    async update(id, data) {
+        // 既存アカウントの確認
+        const existingAccount = await this.repository.findById(id);
+        if (!existingAccount) {
+            throw new Error("Discord account not found");
+        }
+        // メンバーIDが変更される場合、メンバーの存在確認
+        if (data.memberId) {
+            const member = await this.memberRepository.findById(data.memberId);
+            if (!member) {
+                throw new Error("Member not found");
+            }
+        }
+        return this.repository.update(id, {
+            nickName: data.nickName,
+            member: { connect: { id: data.memberId } },
+        });
+    }
+    async findByMemberId(memberId) {
+        // メンバーの存在確認
+        const member = await this.memberRepository.findById(memberId);
+        if (!member) {
+            throw new Error("Member not found");
+        }
+        return this.repository.findByMemberId(memberId);
+    }
+}
+exports.DiscordAccountService = DiscordAccountService;

package/dist/services/event.service.d.ts

@@ -0,0 +1,18 @@
+import type { Event, Prisma } from "@prisma/client";
+import type { IEventRepository } from "../repositories/interfaces/event.repository.interface";
+import type { IMemberRepository } from "../repositories/interfaces/member.repository.interface";
+import type { IMemberEventRepository } from "../repositories/interfaces/memberEvent.repository.interface";
+import { BaseService } from "./base.service";
+import type { EventCreateDTO, EventUpdateDTO, IEventService } from "./interfaces/event.service.interface";
+export declare class EventService extends BaseService<Event, EventCreateDTO, EventUpdateDTO, Prisma.EventFindManyArgs, Prisma.EventCreateInput, Prisma.EventUpdateInput, IEventRepository> implements IEventService {
+    private readonly memberRepository;
+    private readonly memberEventRepository;
+    constructor(eventRepository: IEventRepository, memberRepository: IMemberRepository, memberEventRepository: IMemberEventRepository);
+    create(data: EventCreateDTO): Promise<Event>;
+    update(id: string, data: EventUpdateDTO): Promise<Event>;
+    findUpcoming(limit?: number): Promise<Event[]>;
+    findWithMembers(id: string): Promise<Event | null>;
+    findWithExhibits(id: string): Promise<Event | null>;
+    registerMember(eventId: string, memberId: string): Promise<void>;
+    unregisterMember(eventId: string, memberId: string): Promise<void>;
+}

package/dist/services/event.service.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventService = void 0;
+const base_service_1 = require("./base.service");
+class EventService extends base_service_1.BaseService {
+    constructor(eventRepository, memberRepository, memberEventRepository) {
+        super(eventRepository);
+        this.memberRepository = memberRepository;
+        this.memberEventRepository = memberEventRepository;
+    }
+    async create(data) {
+        // 日付の検証
+        if (data.date < new Date()) {
+            throw new Error("Event date cannot be in the past");
+        }
+        return this.repository.create({
+            name: data.name,
+            date: data.date,
+        });
+    }
+    async update(id, data) {
+        // イベントの存在確認
+        const existingEvent = await this.repository.findById(id);
+        if (!existingEvent) {
+            throw new Error("Event not found");
+        }
+        // 日付の検証（日付が更新される場合）
+        if (data.date && data.date < new Date()) {
+            throw new Error("Event date cannot be in the past");
+        }
+        return this.repository.update(id, data);
+    }
+    async findUpcoming(limit) {
+        return this.repository.findUpcoming(limit);
+    }
+    async findWithMembers(id) {
+        const event = await this.repository.findWithMembers(id);
+        if (!event) {
+            throw new Error("Event not found");
+        }
+        return event;
+    }
+    async findWithExhibits(id) {
+        const event = await this.repository.findWithExhibits(id);
+        if (!event) {
+            throw new Error("Event not found");
+        }
+        return event;
+    }
+    async registerMember(eventId, memberId) {
+        // イベントの存在確認
+        const event = await this.repository.findById(eventId);
+        if (!event) {
+            throw new Error("Event not found");
+        }
+        // メンバーの存在確認
+        const member = await this.memberRepository.findById(memberId);
+        if (!member) {
+            throw new Error("Member not found");
+        }
+        // 既に登録済みかチェック
+        const existingRegistration = await this.memberEventRepository.findMany({
+            where: {
+                eventId,
+                memberId,
+            },
+        });
+        if (existingRegistration.length > 0) {
+            throw new Error("Member already registered to this event");
+        }
+        await this.memberEventRepository.create({
+            event: { connect: { id: eventId } },
+            member: { connect: { id: memberId } },
+        });
+    }
+    async unregisterMember(eventId, memberId) {
+        // 登録の存在確認
+        const registration = await this.memberEventRepository.findMany({
+            where: {
+                eventId,
+                memberId,
+            },
+        });
+        if (registration.length === 0) {
+            throw new Error("Member is not registered to this event");
+        }
+        await this.memberEventRepository.delete(registration[0].id);
+    }
+}
+exports.EventService = EventService;

package/dist/services/exhibit.service.d.ts

@@ -0,0 +1,19 @@
+import type { Exhibit, Prisma } from "@prisma/client";
+import type { IEventRepository } from "../repositories/interfaces/event.repository.interface";
+import type { IExhibitRepository } from "../repositories/interfaces/exhibit.repository.interface";
+import type { IMemberRepository } from "../repositories/interfaces/member.repository.interface";
+import type { IMemberExhibitRepository } from "../repositories/interfaces/memberExhibit.repository.interface";
+import { BaseService } from "./base.service";
+import type { ExhibitCreateDTO, ExhibitUpdateDTO, IExhibitService } from "./interfaces/exhibit.service.interface";
+export declare class ExhibitService extends BaseService<Exhibit, ExhibitCreateDTO, ExhibitUpdateDTO, Prisma.ExhibitFindManyArgs, Prisma.ExhibitCreateInput, Prisma.ExhibitUpdateInput, IExhibitRepository> implements IExhibitService {
+    private readonly eventRepository;
+    private readonly memberRepository;
+    private readonly memberExhibitRepository;
+    constructor(exhibitRepository: IExhibitRepository, eventRepository: IEventRepository, memberRepository: IMemberRepository, memberExhibitRepository: IMemberExhibitRepository);
+    create(data: ExhibitCreateDTO): Promise<Exhibit>;
+    update(id: string, data: ExhibitUpdateDTO): Promise<Exhibit>;
+    findByEventId(eventId: string): Promise<Exhibit[]>;
+    findWithMembers(id: string): Promise<Exhibit | null>;
+    registerMember(exhibitId: string, memberId: string): Promise<void>;
+    unregisterMember(exhibitId: string, memberId: string): Promise<void>;
+}

package/dist/services/exhibit.service.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExhibitService = void 0;
+const base_service_1 = require("./base.service");
+class ExhibitService extends base_service_1.BaseService {
+    constructor(exhibitRepository, eventRepository, memberRepository, memberExhibitRepository) {
+        super(exhibitRepository);
+        this.eventRepository = eventRepository;
+        this.memberRepository = memberRepository;
+        this.memberExhibitRepository = memberExhibitRepository;
+    }
+    async create(data) {
+        // イベントの存在確認
+        const event = await this.eventRepository.findById(data.eventId);
+        if (!event) {
+            throw new Error("Event not found");
+        }
+        // URLの形式チェック（もし提供されている場合）
+        if (data.url) {
+            try {
+                new URL(data.url);
+            }
+            catch (_a) {
+                throw new Error("Invalid URL format");
+            }
+        }
+        return this.repository.create({
+            name: data.name,
+            description: data.description,
+            url: data.url,
+            event: { connect: { id: data.eventId } },
+        });
+    }
+    async update(id, data) {
+        // 展示の存在確認
+        const existingExhibit = await this.repository.findById(id);
+        if (!existingExhibit) {
+            throw new Error("Exhibit not found");
+        }
+        // イベントIDが変更される場合、イベントの存在確認
+        if (data.eventId) {
+            const event = await this.eventRepository.findById(data.eventId);
+            if (!event) {
+                throw new Error("Event not found");
+            }
+        }
+        // URLの形式チェック（もし更新される場合）
+        if (data.url) {
+            try {
+                new URL(data.url);
+            }
+            catch (_a) {
+                throw new Error("Invalid URL format");
+            }
+        }
+        return this.repository.update(id, data);
+    }
+    async findByEventId(eventId) {
+        // イベントの存在確認
+        const event = await this.eventRepository.findById(eventId);
+        if (!event) {
+            throw new Error("Event not found");
+        }
+        return this.repository.findByEventId(eventId);
+    }
+    async findWithMembers(id) {
+        const exhibit = await this.repository.findWithMembers(id);
+        if (!exhibit) {
+            throw new Error("Exhibit not found");
+        }
+        return exhibit;
+    }
+    async registerMember(exhibitId, memberId) {
+        // 展示の存在確認
+        const exhibit = await this.repository.findById(exhibitId);
+        if (!exhibit) {
+            throw new Error("Exhibit not found");
+        }
+        // メンバーの存在確認
+        const member = await this.memberRepository.findById(memberId);
+        if (!member) {
+            throw new Error("Member not found");
+        }
+        // 既に登録済みかチェック
+        const existingRegistration = await this.memberExhibitRepository.findMany({
+            where: {
+                exhibitId,
+                memberId,
+            },
+        });
+        if (existingRegistration.length > 0) {
+            throw new Error("Member already registered to this exhibit");
+        }
+        // イベントへの参加確認も追加するかもしれない
+        // TODO: 確認
+        // const event = await this.eventRepository.findById(exhibit.eventId)
+        // const isMemberRegisteredToEvent = ...
+        await this.memberExhibitRepository.create({
+            exhibit: { connect: { id: exhibitId } },
+            member: { connect: { id: memberId } },
+        });
+    }
+    async unregisterMember(exhibitId, memberId) {
+        // 登録の存在確認
+        const registration = await this.memberExhibitRepository.findMany({
+            where: {
+                exhibitId,
+                memberId,
+            },
+        });
+        if (registration.length === 0) {
+            throw new Error("Member is not registered to this exhibit");
+        }
+        await this.memberExhibitRepository.delete(registration[0].id);
+    }
+}
+exports.ExhibitService = ExhibitService;

package/dist/services/factory.d.ts

@@ -0,0 +1,12 @@
+import type { Repositories } from "../repositories";
+import { DiscordAccountService } from "./discordAccount.service";
+import { EventService } from "./event.service";
+import { ExhibitService } from "./exhibit.service";
+import { MemberService } from "./member.service";
+export declare const createServices: (repositories: Repositories) => {
+    member: MemberService;
+    discordAccount: DiscordAccountService;
+    event: EventService;
+    exhibit: ExhibitService;
+};
+export type Services = ReturnType<typeof createServices>;

package/dist/services/factory.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServices = void 0;
+const discordAccount_service_1 = require("./discordAccount.service");
+const event_service_1 = require("./event.service");
+const exhibit_service_1 = require("./exhibit.service");
+const member_service_1 = require("./member.service");
+const createServices = (repositories) => {
+    return {
+        member: new member_service_1.MemberService(repositories.member, repositories.discordAccount),
+        discordAccount: new discordAccount_service_1.DiscordAccountService(repositories.discordAccount, repositories.member),
+        event: new event_service_1.EventService(repositories.event, repositories.member, repositories.memberEvent),
+        exhibit: new exhibit_service_1.ExhibitService(repositories.exhibit, repositories.event, repositories.member, repositories.memberExhibit),
+    };
+};
+exports.createServices = createServices;

package/dist/services/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./interfaces";
+export * from "./base.service";
+export * from "./member.service";
+export * from "./discordAccount.service";
+export * from "./event.service";
+export * from "./exhibit.service";
+export * from "./factory";

package/dist/services/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./base.service"), exports);
+__exportStar(require("./member.service"), exports);
+__exportStar(require("./discordAccount.service"), exports);
+__exportStar(require("./event.service"), exports);
+__exportStar(require("./exhibit.service"), exports);
+__exportStar(require("./factory"), exports);

package/dist/services/interfaces/base.service.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IBaseService<T, CreateDTO, UpdateDTO> {
+    findById(id: string): Promise<T | null>;
+    create(data: CreateDTO): Promise<T>;
+    update(id: string, data: UpdateDTO): Promise<T>;
+    delete(id: string): Promise<T>;
+    findMany(): Promise<T[]>;
+}

package/dist/services/interfaces/base.service.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/interfaces/discordAccount.service.interface.d.ts

@@ -0,0 +1,14 @@
+import type { DiscordAccount } from "@prisma/client";
+import type { IBaseService } from "./base.service.interface";
+export interface DiscordAccountCreateDTO {
+    id: string;
+    nickName: string;
+    memberId: string;
+}
+export interface DiscordAccountUpdateDTO {
+    nickName?: string;
+    memberId?: string;
+}
+export interface IDiscordAccountService extends IBaseService<DiscordAccount, DiscordAccountCreateDTO, DiscordAccountUpdateDTO> {
+    findByMemberId(memberId: string): Promise<DiscordAccount[]>;
+}

package/dist/services/interfaces/discordAccount.service.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/interfaces/event.service.interface.d.ts

@@ -0,0 +1,15 @@
+import type { Event } from "@prisma/client";
+import type { IBaseService } from "./base.service.interface";
+export interface EventCreateDTO {
+    name: string;
+    date: Date;
+}
+export interface EventUpdateDTO extends Partial<EventCreateDTO> {
+}
+export interface IEventService extends IBaseService<Event, EventCreateDTO, EventUpdateDTO> {
+    findUpcoming(limit?: number): Promise<Event[]>;
+    findWithMembers(id: string): Promise<Event | null>;
+    findWithExhibits(id: string): Promise<Event | null>;
+    registerMember(eventId: string, memberId: string): Promise<void>;
+    unregisterMember(eventId: string, memberId: string): Promise<void>;
+}