From ef440a2dbd1a5fcf531ad71dd46166d8fc45510c Mon Sep 17 00:00:00 2001 From: Park Dahyeon Date: Mon, 10 Nov 2025 15:01:31 +0000 Subject: [PATCH] Configures Drizzle ORM with full schema and adds repositories Integrates the Drizzle ORM schema into the database service, enabling type-safe queries across all entities. Establishes the foundation for a repository pattern by providing and exporting specialized repository classes within the database module. This separates concerns, moving specific entity operations out of the core database service. Removes example Drizzle usage from the database service, focusing its responsibility on connection management and providing the configured Drizzle client. --- src/modules/global/database/README.md | 219 ++++++++++++ .../global/database/database.facade.ts | 317 ++++++++++++++++++ .../global/database/database.module.ts | 25 +- .../global/database/database.service.ts | 37 +- .../global/database/repositories/index.ts | 4 + .../database/repositories/page.repository.ts | 246 ++++++++++++++ .../database/repositories/space.repository.ts | 132 ++++++++ .../database/repositories/token.repository.ts | 292 ++++++++++++++++ .../database/repositories/user.repository.ts | 147 ++++++++ 9 files changed, 1385 insertions(+), 34 deletions(-) create mode 100644 src/modules/global/database/README.md create mode 100644 src/modules/global/database/database.facade.ts create mode 100644 src/modules/global/database/repositories/index.ts create mode 100644 src/modules/global/database/repositories/page.repository.ts create mode 100644 src/modules/global/database/repositories/space.repository.ts create mode 100644 src/modules/global/database/repositories/token.repository.ts create mode 100644 src/modules/global/database/repositories/user.repository.ts diff --git a/src/modules/global/database/README.md b/src/modules/global/database/README.md new file mode 100644 index 0000000..550619c --- /dev/null +++ b/src/modules/global/database/README.md @@ -0,0 +1,219 @@ +# Database Layer + +이 디렉토리는 wiki-server의 데이터베이스 레이어를 구성합니다. + +## 구조 + +``` +database/ +├── schema.ts # Drizzle ORM 스키마 정의 +├── database.service.ts # 데이터베이스 연결 관리 +├── database.facade.ts # 고수준 비즈니스 로직 파사드 +├── database.module.ts # NestJS 모듈 정의 +└── repositories/ # 도메인별 Repository 패턴 + ├── user.repository.ts + ├── space.repository.ts + ├── page.repository.ts + ├── token.repository.ts + └── index.ts +``` + +## 사용 방법 + +### 1. Repository 직접 사용 (단순 CRUD) + +```typescript +import { UserRepository } from '@/modules/global/database/repositories'; + +@Injectable() +export class AccountService { + constructor(private readonly userRepository: UserRepository) {} + + async getUser(userId: string) { + return await this.userRepository.findById(userId); + } + + async createUser(data: CreateUserDto) { + return await this.userRepository.create(data); + } +} +``` + +### 2. DatabaseFacade 사용 (복잡한 비즈니스 로직) + +```typescript +import { DatabaseFacade } from '@/modules/global/database/database.facade'; + +@Injectable() +export class PageService { + constructor(private readonly dbFacade: DatabaseFacade) {} + + async createPage(data: CreatePageDto) { + // 부모 페이지 검증 포함 + return await this.dbFacade.createPageWithValidation(data); + } + + async getPageTree(pageId: string) { + // 재귀적으로 자식 페이지 포함 + return await this.dbFacade.getPageTree(pageId); + } +} +``` + +## Repositories + +### UserRepository + +사용자 관리 관련 기능: +- `create(data)` - 사용자 생성 +- `findById(userId)` - ID로 조회 +- `findByEntraObjectId(entraObjectId)` - Entra Object ID로 조회 +- `findByEmail(email)` - 이메일로 조회 +- `findAllActive()` - 모든 활성 사용자 조회 +- `findAllSystemAdmins()` - 시스템 관리자 조회 +- `update(userId, data)` - 사용자 정보 업데이트 +- `updateLastLogin(userId)` - 마지막 로그인 시간 업데이트 +- `activate(userId)` / `deactivate(userId)` - 활성화/비활성화 +- `findOrCreate(data)` - 찾거나 생성 + +### SpaceRepository + +스페이스 관리 관련 기능: +- `create(data)` - 스페이스 생성 +- `findById(spaceId)` - ID로 조회 +- `findByKey(spaceKey)` - Key로 조회 +- `findAll()` - 모든 스페이스 조회 +- `findByCreator(userId)` - 생성자별 조회 +- `findByIdWithCreator(spaceId)` - 생성자 정보 포함 조회 +- `findAllWithCreator()` - 모든 스페이스를 생성자 정보와 함께 조회 +- `update(spaceId, data)` - 스페이스 업데이트 +- `delete(spaceId)` - 스페이스 삭제 +- `existsByKey(spaceKey)` - Key 존재 여부 확인 + +### PageRepository + +페이지 관리 관련 기능: +- `create(data)` - 페이지 생성 +- `findById(pageId)` - ID로 조회 +- `findBySpaceId(spaceId)` - 스페이스의 모든 페이지 조회 +- `findRootPagesBySpaceId(spaceId)` - 루트 페이지들 조회 +- `findChildPages(parentPageId)` - 자식 페이지들 조회 +- `findByIdWithUsers(pageId)` - 생성자/수정자 정보 포함 조회 +- `update(pageId, data)` - 페이지 업데이트 +- `softDelete(pageId, userId)` - 소프트 삭제 +- `restore(pageId, userId)` - 복구 +- `hardDelete(pageId)` - 하드 삭제 +- `findRecentlyUpdatedBySpaceId(spaceId, limit)` - 최근 업데이트된 페이지 +- `findByCreator(userId)` - 생성자별 조회 +- `updateSortOrder(pageId, sortOrder)` - 정렬 순서 업데이트 +- `movePage(pageId, newParentPageId, userId)` - 페이지 이동 + +### TokenRepository + +액세스 토큰 및 권한 관리: +- `createToken(data)` - 토큰 생성 +- `findTokenById(tokenId)` - ID로 조회 +- `findTokenByValue(tokenValue)` - 값으로 조회 +- `findTokensByCreator(userId)` - 생성자별 조회 +- `findActiveTokens()` - 활성 토큰 조회 +- `findExpiredTokens()` - 만료된 토큰 조회 +- `deleteToken(tokenId)` - 토큰 삭제 +- `isTokenValid(tokenValue)` - 토큰 유효성 확인 +- `createPermission(data)` - 권한 생성 +- `findPermissionsByTokenId(tokenId)` - 토큰의 모든 권한 조회 +- `findSpacePermissionsByTokenId(tokenId)` - 스페이스 권한 조회 +- `findPagePermissionsByTokenId(tokenId)` - 페이지 권한 조회 +- `hasSpacePermission(tokenId, spaceId)` - 스페이스 접근 권한 확인 +- `hasPagePermission(tokenId, pageId)` - 페이지 접근 권한 확인 +- `deletePermission(permissionId)` - 권한 삭제 +- `findTokenWithPermissions(tokenValue)` - 토큰 및 권한 전체 조회 + +## DatabaseFacade + +고수준 비즈니스 로직을 제공하는 파사드: + +### User Operations +- `handleUserLogin(userData)` - 로그인 처리 (찾거나 생성 + 마지막 로그인 업데이트) + +### Space Operations +- `createSpaceWithValidation(data)` - 중복 키 검증 포함 생성 +- `getSpaceWithPages(spaceId)` - 스페이스와 모든 페이지 조회 +- `deleteSpaceWithPages(spaceId)` - 스페이스 및 페이지 삭제 +- `getSpaceStatistics(spaceId)` - 스페이스 통계 조회 + +### Page Operations +- `createPageWithValidation(data)` - 부모 페이지 검증 포함 생성 +- `getPageTree(pageId)` - 재귀적 페이지 트리 조회 +- `getSpacePageTree(spaceId)` - 스페이스 전체 페이지 트리 +- `movePageWithValidation(pageId, newParentPageId, userId)` - 순환 참조 검증 포함 이동 + +### Token Operations +- `createTokenWithPermissions(tokenData, permissions)` - 토큰 및 권한 생성 +- `authenticateToken(tokenValue)` - 토큰 인증 +- `canAccessResource(tokenValue, resourceType, resourceId)` - 리소스 접근 권한 확인 +- `cleanupExpiredTokens()` - 만료된 토큰 정리 + +### Combined Operations +- `getUserActivity(userId)` - 사용자의 모든 활동 조회 + +## 데이터베이스 스키마 + +### users +- `userId` (PK) - UUID +- `entraObjectId` (Unique) - Microsoft Entra Object ID +- `entraTenantId` - Microsoft Entra Tenant ID +- `email` - 이메일 +- `displayName` - 표시 이름 +- `isSystemAdmin` - 시스템 관리자 여부 +- `isActive` - 활성 상태 +- `createdAt`, `updatedAt`, `lastLoginAt` - 타임스탬프 + +### spaces +- `spaceId` (PK) - UUID +- `spaceKey` (Unique) - 스페이스 키 +- `name` - 이름 +- `description` - 설명 +- `createdByUserId` (FK) - 생성자 +- `createdAt` - 생성 시간 + +### pages +- `pageId` (PK) - UUID +- `spaceId` (FK) - 스페이스 +- `parentPageId` (FK, nullable) - 부모 페이지 +- `sortOrder` - 정렬 순서 +- `title` - 제목 +- `content` - 내용 +- `createdByUserId` (FK) - 생성자 +- `updatedByUserId` (FK) - 수정자 +- `createdAt`, `updatedAt` - 타임스탬프 +- `isDeleted` - 삭제 여부 (소프트 삭제) + +### accesstokens +- `tokenId` (PK) - UUID +- `tokenValue` (Unique) - 토큰 값 +- `description` - 설명 +- `expiresAt` (nullable) - 만료 시간 +- `createdByUserId` (FK) - 생성자 +- `createdAt` - 생성 시간 + +### tokenpermissions +- `permissionId` (PK) - UUID +- `tokenId` (FK) - 토큰 +- `spaceId` (FK, nullable) - 스페이스 (spaceId 또는 pageId 중 하나만 설정) +- `pageId` (FK, nullable) - 페이지 (spaceId 또는 pageId 중 하나만 설정) +- Constraint: spaceId와 pageId 중 정확히 하나만 NULL이 아니어야 함 + +## 모듈 임포트 + +다른 모듈에서 사용하려면: + +```typescript +import { Module } from '@nestjs/common'; +import { DatabaseModule } from '@/modules/global/database/database.module'; + +@Module({ + imports: [DatabaseModule], + // ... +}) +export class YourModule {} +``` diff --git a/src/modules/global/database/database.facade.ts b/src/modules/global/database/database.facade.ts new file mode 100644 index 0000000..398250f --- /dev/null +++ b/src/modules/global/database/database.facade.ts @@ -0,0 +1,317 @@ +import { Injectable } from "@nestjs/common"; +import { + UserRepository, + SpaceRepository, + PageRepository, + TokenRepository, + CreateUserDto, + CreateSpaceDto, + CreatePageDto, + CreateAccessTokenDto, + CreateTokenPermissionDto, +} from "./repositories"; + +/** + * DatabaseFacade - 여러 repository를 조합한 고수준 비즈니스 로직을 제공 + */ +@Injectable() +export class DatabaseFacade { + constructor( + private readonly userRepository: UserRepository, + private readonly spaceRepository: SpaceRepository, + private readonly pageRepository: PageRepository, + private readonly tokenRepository: TokenRepository, + ) {} + + // ===== User Related Operations ===== + + /** + * 사용자 로그인 처리 (찾거나 생성 + 마지막 로그인 업데이트) + */ + async handleUserLogin(userData: CreateUserDto) { + const user = await this.userRepository.findOrCreate(userData); + await this.userRepository.updateLastLogin(user.userId); + return user; + } + + // ===== Space Related Operations ===== + + /** + * 스페이스 생성 (중복 키 체크 포함) + */ + async createSpaceWithValidation(data: CreateSpaceDto) { + const exists = await this.spaceRepository.existsByKey(data.spaceKey); + if (exists) { + throw new Error(`Space with key '${data.spaceKey}' already exists`); + } + return await this.spaceRepository.create(data); + } + + /** + * 스페이스와 해당 스페이스의 모든 페이지 조회 + */ + async getSpaceWithPages(spaceId: string) { + const space = await this.spaceRepository.findById(spaceId); + if (!space) { + throw new Error(`Space with id '${spaceId}' not found`); + } + + const pages = await this.pageRepository.findBySpaceId(spaceId); + const rootPages = await this.pageRepository.findRootPagesBySpaceId(spaceId); + + return { + space, + allPages: pages, + rootPages, + }; + } + + /** + * 스페이스 삭제 (cascade로 페이지도 함께 삭제됨) + */ + async deleteSpaceWithPages(spaceId: string) { + await this.spaceRepository.delete(spaceId); + } + + // ===== Page Related Operations ===== + + /** + * 페이지 생성 (부모 페이지 존재 여부 검증 포함) + */ + async createPageWithValidation(data: CreatePageDto) { + // 스페이스 존재 확인 + const space = await this.spaceRepository.findById(data.spaceId); + if (!space) { + throw new Error(`Space with id '${data.spaceId}' not found`); + } + + // 부모 페이지 존재 확인 (있는 경우) + if (data.parentPageId) { + const parentPage = await this.pageRepository.findById(data.parentPageId); + if (!parentPage) { + throw new Error(`Parent page with id '${data.parentPageId}' not found`); + } + // 부모 페이지가 같은 스페이스에 있는지 확인 + if (parentPage.spaceId !== data.spaceId) { + throw new Error('Parent page must be in the same space'); + } + } + + return await this.pageRepository.create(data); + } + + /** + * 페이지 트리 구조 조회 (재귀적으로 자식 페이지 포함) + */ + async getPageTree(pageId: string): Promise { + const page = await this.pageRepository.findById(pageId); + if (!page) { + throw new Error(`Page with id '${pageId}' not found`); + } + + const children = await this.pageRepository.findChildPages(pageId); + const childTrees = await Promise.all( + children.map(child => this.getPageTree(child.pageId)) + ); + + return { + ...page, + children: childTrees, + }; + } + + /** + * 스페이스의 전체 페이지 트리 구조 조회 + */ + async getSpacePageTree(spaceId: string) { + const rootPages = await this.pageRepository.findRootPagesBySpaceId(spaceId); + const trees = await Promise.all( + rootPages.map(page => this.getPageTree(page.pageId)) + ); + return trees; + } + + /** + * 페이지 이동 (순환 참조 검증 포함) + */ + async movePageWithValidation( + pageId: string, + newParentPageId: string | null, + updatedByUserId: string + ) { + const page = await this.pageRepository.findById(pageId); + if (!page) { + throw new Error(`Page with id '${pageId}' not found`); + } + + // 자기 자신을 부모로 설정하는 것 방지 + if (newParentPageId === pageId) { + throw new Error('A page cannot be its own parent'); + } + + // 새 부모 페이지가 현재 페이지의 자손인지 확인 (순환 참조 방지) + if (newParentPageId) { + const isDescendant = await this.isPageDescendant(pageId, newParentPageId); + if (isDescendant) { + throw new Error('Cannot move a page to one of its descendants'); + } + + const newParent = await this.pageRepository.findById(newParentPageId); + if (!newParent) { + throw new Error(`New parent page with id '${newParentPageId}' not found`); + } + + // 같은 스페이스 내에서만 이동 가능 + if (newParent.spaceId !== page.spaceId) { + throw new Error('Cannot move page to a different space'); + } + } + + return await this.pageRepository.movePage(pageId, newParentPageId, updatedByUserId); + } + + /** + * 페이지가 다른 페이지의 자손인지 확인 (재귀) + */ + private async isPageDescendant(ancestorId: string, pageId: string): Promise { + const page = await this.pageRepository.findById(pageId); + if (!page || !page.parentPageId) { + return false; + } + + if (page.parentPageId === ancestorId) { + return true; + } + + return await this.isPageDescendant(ancestorId, page.parentPageId); + } + + // ===== Token Related Operations ===== + + /** + * 액세스 토큰 생성 및 권한 설정 + */ + async createTokenWithPermissions( + tokenData: CreateAccessTokenDto, + permissions: CreateTokenPermissionDto[] + ) { + const token = await this.tokenRepository.createToken(tokenData); + + const createdPermissions = await Promise.all( + permissions.map(permission => + this.tokenRepository.createPermission({ + ...permission, + tokenId: token.tokenId, + }) + ) + ); + + return { + token, + permissions: createdPermissions, + }; + } + + /** + * 토큰으로 인증 및 권한 확인 + */ + async authenticateToken(tokenValue: string) { + const isValid = await this.tokenRepository.isTokenValid(tokenValue); + if (!isValid) { + return null; + } + + return await this.tokenRepository.findTokenWithPermissions(tokenValue); + } + + /** + * 토큰이 특정 리소스에 접근 가능한지 확인 + */ + async canAccessResource( + tokenValue: string, + resourceType: 'space' | 'page', + resourceId: string + ): Promise { + const token = await this.tokenRepository.findTokenByValue(tokenValue); + if (!token) return false; + + const isValid = await this.tokenRepository.isTokenValid(tokenValue); + if (!isValid) return false; + + if (resourceType === 'space') { + return await this.tokenRepository.hasSpacePermission(token.tokenId, resourceId); + } else { + // 페이지 권한 확인 + const hasDirectPermission = await this.tokenRepository.hasPagePermission( + token.tokenId, + resourceId + ); + if (hasDirectPermission) return true; + + // 페이지가 속한 스페이스에 대한 권한 확인 + const page = await this.pageRepository.findById(resourceId); + if (!page) return false; + + return await this.tokenRepository.hasSpacePermission(token.tokenId, page.spaceId); + } + } + + /** + * 만료된 토큰 정리 + */ + async cleanupExpiredTokens() { + const expiredTokens = await this.tokenRepository.findExpiredTokens(); + await Promise.all( + expiredTokens.map(token => this.tokenRepository.deleteToken(token.tokenId)) + ); + return expiredTokens.length; + } + + // ===== Combined Operations ===== + + /** + * 사용자의 모든 활동 조회 (생성한 스페이스, 페이지 등) + */ + async getUserActivity(userId: string) { + const user = await this.userRepository.findById(userId); + if (!user) { + throw new Error(`User with id '${userId}' not found`); + } + + const [createdSpaces, createdPages, createdTokens] = await Promise.all([ + this.spaceRepository.findByCreator(userId), + this.pageRepository.findByCreator(userId), + this.tokenRepository.findTokensByCreator(userId), + ]); + + return { + user, + createdSpaces, + createdPages, + createdTokens, + }; + } + + /** + * 스페이스의 전체 통계 조회 + */ + async getSpaceStatistics(spaceId: string) { + const space = await this.spaceRepository.findById(spaceId); + if (!space) { + throw new Error(`Space with id '${spaceId}' not found`); + } + + const allPages = await this.pageRepository.findBySpaceId(spaceId); + const rootPages = await this.pageRepository.findRootPagesBySpaceId(spaceId); + const recentPages = await this.pageRepository.findRecentlyUpdatedBySpaceId(spaceId, 5); + + return { + space, + statistics: { + totalPages: allPages.length, + rootPages: rootPages.length, + recentlyUpdated: recentPages, + }, + }; + } +} diff --git a/src/modules/global/database/database.module.ts b/src/modules/global/database/database.module.ts index bef4f40..cf00b4e 100644 --- a/src/modules/global/database/database.module.ts +++ b/src/modules/global/database/database.module.ts @@ -1,8 +1,29 @@ import { Module } from "@nestjs/common"; import { DatabaseService } from "./database.service"; +import { DatabaseFacade } from "./database.facade"; +import { + UserRepository, + SpaceRepository, + PageRepository, + TokenRepository +} from "./repositories"; @Module({ - providers: [DatabaseService], - exports: [DatabaseService], + providers: [ + DatabaseService, + DatabaseFacade, + UserRepository, + SpaceRepository, + PageRepository, + TokenRepository, + ], + exports: [ + DatabaseService, + DatabaseFacade, + UserRepository, + SpaceRepository, + PageRepository, + TokenRepository, + ], }) export class DatabaseModule {} \ No newline at end of file diff --git a/src/modules/global/database/database.service.ts b/src/modules/global/database/database.service.ts index 8d95a46..4c87dc0 100644 --- a/src/modules/global/database/database.service.ts +++ b/src/modules/global/database/database.service.ts @@ -2,8 +2,7 @@ import { Injectable } from "@nestjs/common"; import { SecretService } from "../secret/secret.service"; import { drizzle, NodePgDatabase } from "drizzle-orm/node-postgres"; import * as pg from 'pg' -import { eq } from "drizzle-orm"; -import { usersTable } from "./schema"; +import * as schema from "./schema"; @@ -14,7 +13,7 @@ export class DatabaseService { private password: string; private databaseName: string; - private dbAdapter: NodePgDatabase> & { $client: pg.Client } + private dbAdapter: NodePgDatabase & { $client: pg.Client } private connection: pg.Client @@ -39,37 +38,11 @@ export class DatabaseService { await this.connection.connect(); - this.dbAdapter = drizzle(this.connection) - await this.test(); + this.dbAdapter = drizzle(this.connection, { schema }); } - async test() { - const user: typeof usersTable.$inferInsert = { - name: 'John', - age: 30, - email: 'john@example.com', - }; - await this.dbAdapter.insert(usersTable).values(user); - console.log('New user created!') - const users = await this.dbAdapter.select().from(usersTable); - console.log('Getting all users from the database: ', users) - /* - const users: { - id: number; - name: string; - age: number; - email: string; - }[] - */ - await this.dbAdapter - .update(usersTable) - .set({ - age: 31, - }) - .where(eq(usersTable.email, user.email)); - console.log('User info updated!') - await this.dbAdapter.delete(usersTable).where(eq(usersTable.email, user.email)); - console.log('User deleted!') + getDb() { + return this.dbAdapter; } } diff --git a/src/modules/global/database/repositories/index.ts b/src/modules/global/database/repositories/index.ts new file mode 100644 index 0000000..1db6981 --- /dev/null +++ b/src/modules/global/database/repositories/index.ts @@ -0,0 +1,4 @@ +export * from './user.repository'; +export * from './space.repository'; +export * from './page.repository'; +export * from './token.repository'; diff --git a/src/modules/global/database/repositories/page.repository.ts b/src/modules/global/database/repositories/page.repository.ts new file mode 100644 index 0000000..a28cbb8 --- /dev/null +++ b/src/modules/global/database/repositories/page.repository.ts @@ -0,0 +1,246 @@ +import { Injectable } from "@nestjs/common"; +import { DatabaseService } from "../database.service"; +import { pages, spaces, users } from "../schema"; +import { eq, and, isNull, desc, asc } from "drizzle-orm"; + +export type CreatePageDto = { + spaceId: string; + parentPageId?: string; + title: string; + content?: string; + createdByUserId: string; + updatedByUserId: string; + sortOrder?: number; +}; + +export type UpdatePageDto = { + title?: string; + content?: string; + updatedByUserId: string; + parentPageId?: string; + sortOrder?: number; +}; + +@Injectable() +export class PageRepository { + constructor(private readonly databaseService: DatabaseService) {} + + /** + * 페이지 생성 + */ + async create(data: CreatePageDto) { + const db = this.databaseService.getDb(); + const [page] = await db.insert(pages).values(data).returning(); + return page; + } + + /** + * Page ID로 페이지 조회 + */ + async findById(pageId: string) { + const db = this.databaseService.getDb(); + const [page] = await db + .select() + .from(pages) + .where(and(eq(pages.pageId, pageId), eq(pages.isDeleted, false))); + return page; + } + + /** + * 삭제된 페이지 포함하여 조회 + */ + async findByIdIncludingDeleted(pageId: string) { + const db = this.databaseService.getDb(); + const [page] = await db + .select() + .from(pages) + .where(eq(pages.pageId, pageId)); + return page; + } + + /** + * 스페이스의 모든 페이지 조회 (삭제되지 않은 것만) + */ + async findBySpaceId(spaceId: string) { + const db = this.databaseService.getDb(); + return await db + .select() + .from(pages) + .where(and(eq(pages.spaceId, spaceId), eq(pages.isDeleted, false))) + .orderBy(asc(pages.sortOrder), asc(pages.createdAt)); + } + + /** + * 스페이스의 루트 페이지들 조회 (부모가 없는 페이지) + */ + async findRootPagesBySpaceId(spaceId: string) { + const db = this.databaseService.getDb(); + return await db + .select() + .from(pages) + .where( + and( + eq(pages.spaceId, spaceId), + isNull(pages.parentPageId), + eq(pages.isDeleted, false) + ) + ) + .orderBy(asc(pages.sortOrder), asc(pages.createdAt)); + } + + /** + * 특정 페이지의 자식 페이지들 조회 + */ + async findChildPages(parentPageId: string) { + const db = this.databaseService.getDb(); + return await db + .select() + .from(pages) + .where( + and( + eq(pages.parentPageId, parentPageId), + eq(pages.isDeleted, false) + ) + ) + .orderBy(asc(pages.sortOrder), asc(pages.createdAt)); + } + + /** + * 페이지를 생성자/수정자 정보와 함께 조회 + */ + async findByIdWithUsers(pageId: string) { + const db = this.databaseService.getDb(); + const [result] = await db + .select({ + page: pages, + creator: { + userId: users.userId, + email: users.email, + displayName: users.displayName, + }, + updater: { + userId: users.userId, + email: users.email, + displayName: users.displayName, + }, + }) + .from(pages) + .leftJoin(users, eq(pages.createdByUserId, users.userId)) + .leftJoin(users, eq(pages.updatedByUserId, users.userId)) + .where(and(eq(pages.pageId, pageId), eq(pages.isDeleted, false))); + return result; + } + + /** + * 페이지 업데이트 + */ + async update(pageId: string, data: UpdatePageDto) { + const db = this.databaseService.getDb(); + const [page] = await db + .update(pages) + .set({ + ...data, + updatedAt: new Date().toISOString(), + }) + .where(eq(pages.pageId, pageId)) + .returning(); + return page; + } + + /** + * 페이지 소프트 삭제 + */ + async softDelete(pageId: string, deletedByUserId: string) { + const db = this.databaseService.getDb(); + const [page] = await db + .update(pages) + .set({ + isDeleted: true, + updatedByUserId: deletedByUserId, + updatedAt: new Date().toISOString(), + }) + .where(eq(pages.pageId, pageId)) + .returning(); + return page; + } + + /** + * 페이지 복구 + */ + async restore(pageId: string, restoredByUserId: string) { + const db = this.databaseService.getDb(); + const [page] = await db + .update(pages) + .set({ + isDeleted: false, + updatedByUserId: restoredByUserId, + updatedAt: new Date().toISOString(), + }) + .where(eq(pages.pageId, pageId)) + .returning(); + return page; + } + + /** + * 페이지 하드 삭제 + */ + async hardDelete(pageId: string) { + const db = this.databaseService.getDb(); + await db.delete(pages).where(eq(pages.pageId, pageId)); + } + + /** + * 스페이스의 최근 업데이트된 페이지 조회 + */ + async findRecentlyUpdatedBySpaceId(spaceId: string, limit: number = 10) { + const db = this.databaseService.getDb(); + return await db + .select() + .from(pages) + .where(and(eq(pages.spaceId, spaceId), eq(pages.isDeleted, false))) + .orderBy(desc(pages.updatedAt)) + .limit(limit); + } + + /** + * 사용자가 생성한 페이지 조회 + */ + async findByCreator(userId: string) { + const db = this.databaseService.getDb(); + return await db + .select() + .from(pages) + .where(and(eq(pages.createdByUserId, userId), eq(pages.isDeleted, false))) + .orderBy(desc(pages.createdAt)); + } + + /** + * 페이지 정렬 순서 업데이트 + */ + async updateSortOrder(pageId: string, sortOrder: number) { + const db = this.databaseService.getDb(); + const [page] = await db + .update(pages) + .set({ sortOrder }) + .where(eq(pages.pageId, pageId)) + .returning(); + return page; + } + + /** + * 페이지 이동 (부모 페이지 변경) + */ + async movePage(pageId: string, newParentPageId: string | null, updatedByUserId: string) { + const db = this.databaseService.getDb(); + const [page] = await db + .update(pages) + .set({ + parentPageId: newParentPageId, + updatedByUserId, + updatedAt: new Date().toISOString(), + }) + .where(eq(pages.pageId, pageId)) + .returning(); + return page; + } +} diff --git a/src/modules/global/database/repositories/space.repository.ts b/src/modules/global/database/repositories/space.repository.ts new file mode 100644 index 0000000..6256dd8 --- /dev/null +++ b/src/modules/global/database/repositories/space.repository.ts @@ -0,0 +1,132 @@ +import { Injectable } from "@nestjs/common"; +import { DatabaseService } from "../database.service"; +import { spaces, users } from "../schema"; +import { eq } from "drizzle-orm"; + +export type CreateSpaceDto = { + spaceKey: string; + name: string; + description?: string; + createdByUserId: string; +}; + +export type UpdateSpaceDto = { + name?: string; + description?: string; +}; + +@Injectable() +export class SpaceRepository { + constructor(private readonly databaseService: DatabaseService) {} + + /** + * 스페이스 생성 + */ + async create(data: CreateSpaceDto) { + const db = this.databaseService.getDb(); + const [space] = await db.insert(spaces).values(data).returning(); + return space; + } + + /** + * Space ID로 스페이스 조회 + */ + async findById(spaceId: string) { + const db = this.databaseService.getDb(); + const [space] = await db + .select() + .from(spaces) + .where(eq(spaces.spaceId, spaceId)); + return space; + } + + /** + * Space Key로 스페이스 조회 + */ + async findByKey(spaceKey: string) { + const db = this.databaseService.getDb(); + const [space] = await db + .select() + .from(spaces) + .where(eq(spaces.spaceKey, spaceKey)); + return space; + } + + /** + * 모든 스페이스 조회 + */ + async findAll() { + const db = this.databaseService.getDb(); + return await db.select().from(spaces); + } + + /** + * 사용자가 생성한 스페이스 조회 + */ + async findByCreator(userId: string) { + const db = this.databaseService.getDb(); + return await db + .select() + .from(spaces) + .where(eq(spaces.createdByUserId, userId)); + } + + /** + * 생성자 정보와 함께 스페이스 조회 + */ + async findByIdWithCreator(spaceId: string) { + const db = this.databaseService.getDb(); + const [result] = await db + .select({ + space: spaces, + creator: users, + }) + .from(spaces) + .leftJoin(users, eq(spaces.createdByUserId, users.userId)) + .where(eq(spaces.spaceId, spaceId)); + return result; + } + + /** + * 모든 스페이스를 생성자 정보와 함께 조회 + */ + async findAllWithCreator() { + const db = this.databaseService.getDb(); + return await db + .select({ + space: spaces, + creator: users, + }) + .from(spaces) + .leftJoin(users, eq(spaces.createdByUserId, users.userId)); + } + + /** + * 스페이스 정보 업데이트 + */ + async update(spaceId: string, data: UpdateSpaceDto) { + const db = this.databaseService.getDb(); + const [space] = await db + .update(spaces) + .set(data) + .where(eq(spaces.spaceId, spaceId)) + .returning(); + return space; + } + + /** + * 스페이스 삭제 + */ + async delete(spaceId: string) { + const db = this.databaseService.getDb(); + await db.delete(spaces).where(eq(spaces.spaceId, spaceId)); + } + + /** + * Space Key 존재 여부 확인 + */ + async existsByKey(spaceKey: string): Promise { + const space = await this.findByKey(spaceKey); + return !!space; + } +} diff --git a/src/modules/global/database/repositories/token.repository.ts b/src/modules/global/database/repositories/token.repository.ts new file mode 100644 index 0000000..2e98d93 --- /dev/null +++ b/src/modules/global/database/repositories/token.repository.ts @@ -0,0 +1,292 @@ +import { Injectable } from "@nestjs/common"; +import { DatabaseService } from "../database.service"; +import { accesstokens, tokenpermissions, spaces, pages } from "../schema"; +import { eq, and, isNull, isNotNull, or, lt, gt } from "drizzle-orm"; + +export type CreateAccessTokenDto = { + tokenValue: string; + description?: string; + expiresAt?: string; + createdByUserId: string; +}; + +export type CreateTokenPermissionDto = { + tokenId: string; + spaceId?: string; + pageId?: string; +}; + +@Injectable() +export class TokenRepository { + constructor(private readonly databaseService: DatabaseService) {} + + // ===== Access Token Methods ===== + + /** + * 액세스 토큰 생성 + */ + async createToken(data: CreateAccessTokenDto) { + const db = this.databaseService.getDb(); + const [token] = await db.insert(accesstokens).values(data).returning(); + return token; + } + + /** + * Token ID로 토큰 조회 + */ + async findTokenById(tokenId: string) { + const db = this.databaseService.getDb(); + const [token] = await db + .select() + .from(accesstokens) + .where(eq(accesstokens.tokenId, tokenId)); + return token; + } + + /** + * Token Value로 토큰 조회 + */ + async findTokenByValue(tokenValue: string) { + const db = this.databaseService.getDb(); + const [token] = await db + .select() + .from(accesstokens) + .where(eq(accesstokens.tokenValue, tokenValue)); + return token; + } + + /** + * 사용자가 생성한 모든 토큰 조회 + */ + async findTokensByCreator(userId: string) { + const db = this.databaseService.getDb(); + return await db + .select() + .from(accesstokens) + .where(eq(accesstokens.createdByUserId, userId)); + } + + /** + * 모든 활성 토큰 조회 (만료되지 않은 토큰) + */ + async findActiveTokens() { + const db = this.databaseService.getDb(); + const now = new Date().toISOString(); + return await db + .select() + .from(accesstokens) + .where( + or( + isNull(accesstokens.expiresAt), + gt(accesstokens.expiresAt, now) + ) + ); + } + + /** + * 만료된 토큰 조회 + */ + async findExpiredTokens() { + const db = this.databaseService.getDb(); + const now = new Date().toISOString(); + return await db + .select() + .from(accesstokens) + .where( + and( + isNotNull(accesstokens.expiresAt), + lt(accesstokens.expiresAt, now) + ) + ); + } + + /** + * 토큰 삭제 + */ + async deleteToken(tokenId: string) { + const db = this.databaseService.getDb(); + await db.delete(accesstokens).where(eq(accesstokens.tokenId, tokenId)); + } + + /** + * 토큰이 유효한지 확인 + */ + async isTokenValid(tokenValue: string): Promise { + const token = await this.findTokenByValue(tokenValue); + if (!token) return false; + + if (!token.expiresAt) return true; + + const now = new Date(); + const expiresAt = new Date(token.expiresAt); + return expiresAt > now; + } + + // ===== Token Permission Methods ===== + + /** + * 토큰 권한 생성 + */ + async createPermission(data: CreateTokenPermissionDto) { + const db = this.databaseService.getDb(); + const [permission] = await db + .insert(tokenpermissions) + .values(data) + .returning(); + return permission; + } + + /** + * 토큰의 모든 권한 조회 + */ + async findPermissionsByTokenId(tokenId: string) { + const db = this.databaseService.getDb(); + return await db + .select() + .from(tokenpermissions) + .where(eq(tokenpermissions.tokenId, tokenId)); + } + + /** + * 토큰의 스페이스 권한 조회 + */ + async findSpacePermissionsByTokenId(tokenId: string) { + const db = this.databaseService.getDb(); + return await db + .select({ + permission: tokenpermissions, + space: spaces, + }) + .from(tokenpermissions) + .leftJoin(spaces, eq(tokenpermissions.spaceId, spaces.spaceId)) + .where( + and( + eq(tokenpermissions.tokenId, tokenId), + isNotNull(tokenpermissions.spaceId) + ) + ); + } + + /** + * 토큰의 페이지 권한 조회 + */ + async findPagePermissionsByTokenId(tokenId: string) { + const db = this.databaseService.getDb(); + return await db + .select({ + permission: tokenpermissions, + page: pages, + }) + .from(tokenpermissions) + .leftJoin(pages, eq(tokenpermissions.pageId, pages.pageId)) + .where( + and( + eq(tokenpermissions.tokenId, tokenId), + isNotNull(tokenpermissions.pageId) + ) + ); + } + + /** + * 토큰이 특정 스페이스에 접근 권한이 있는지 확인 + */ + async hasSpacePermission(tokenId: string, spaceId: string): Promise { + const db = this.databaseService.getDb(); + const [permission] = await db + .select() + .from(tokenpermissions) + .where( + and( + eq(tokenpermissions.tokenId, tokenId), + eq(tokenpermissions.spaceId, spaceId) + ) + ); + return !!permission; + } + + /** + * 토큰이 특정 페이지에 접근 권한이 있는지 확인 + */ + async hasPagePermission(tokenId: string, pageId: string): Promise { + const db = this.databaseService.getDb(); + const [permission] = await db + .select() + .from(tokenpermissions) + .where( + and( + eq(tokenpermissions.tokenId, tokenId), + eq(tokenpermissions.pageId, pageId) + ) + ); + return !!permission; + } + + /** + * 토큰 권한 삭제 + */ + async deletePermission(permissionId: string) { + const db = this.databaseService.getDb(); + await db + .delete(tokenpermissions) + .where(eq(tokenpermissions.permissionId, permissionId)); + } + + /** + * 토큰의 특정 스페이스 권한 삭제 + */ + async deleteSpacePermission(tokenId: string, spaceId: string) { + const db = this.databaseService.getDb(); + await db + .delete(tokenpermissions) + .where( + and( + eq(tokenpermissions.tokenId, tokenId), + eq(tokenpermissions.spaceId, spaceId) + ) + ); + } + + /** + * 토큰의 특정 페이지 권한 삭제 + */ + async deletePagePermission(tokenId: string, pageId: string) { + const db = this.databaseService.getDb(); + await db + .delete(tokenpermissions) + .where( + and( + eq(tokenpermissions.tokenId, tokenId), + eq(tokenpermissions.pageId, pageId) + ) + ); + } + + /** + * 토큰의 모든 권한 삭제 + */ + async deleteAllPermissions(tokenId: string) { + const db = this.databaseService.getDb(); + await db + .delete(tokenpermissions) + .where(eq(tokenpermissions.tokenId, tokenId)); + } + + /** + * 토큰 값으로 전체 토큰 정보 조회 (권한 포함) + */ + async findTokenWithPermissions(tokenValue: string) { + const token = await this.findTokenByValue(tokenValue); + if (!token) return null; + + const permissions = await this.findPermissionsByTokenId(token.tokenId); + const spacePermissions = await this.findSpacePermissionsByTokenId(token.tokenId); + const pagePermissions = await this.findPagePermissionsByTokenId(token.tokenId); + + return { + token, + permissions, + spacePermissions, + pagePermissions, + }; + } +} diff --git a/src/modules/global/database/repositories/user.repository.ts b/src/modules/global/database/repositories/user.repository.ts new file mode 100644 index 0000000..7bc5a87 --- /dev/null +++ b/src/modules/global/database/repositories/user.repository.ts @@ -0,0 +1,147 @@ +import { Injectable } from "@nestjs/common"; +import { DatabaseService } from "../database.service"; +import { users } from "../schema"; +import { eq, and } from "drizzle-orm"; + +export type CreateUserDto = { + entraObjectId: string; + entraTenantId: string; + email: string; + displayName: string; + isSystemAdmin?: boolean; +}; + +export type UpdateUserDto = { + displayName?: string; + isSystemAdmin?: boolean; + isActive?: boolean; + lastLoginAt?: string; +}; + +@Injectable() +export class UserRepository { + constructor(private readonly databaseService: DatabaseService) {} + + /** + * 사용자 생성 + */ + async create(data: CreateUserDto) { + const db = this.databaseService.getDb(); + const [user] = await db.insert(users).values(data).returning(); + return user; + } + + /** + * Entra Object ID로 사용자 조회 + */ + async findByEntraObjectId(entraObjectId: string) { + const db = this.databaseService.getDb(); + const [user] = await db + .select() + .from(users) + .where(eq(users.entraObjectId, entraObjectId)); + return user; + } + + /** + * User ID로 사용자 조회 + */ + async findById(userId: string) { + const db = this.databaseService.getDb(); + const [user] = await db + .select() + .from(users) + .where(eq(users.userId, userId)); + return user; + } + + /** + * 이메일로 사용자 조회 + */ + async findByEmail(email: string) { + const db = this.databaseService.getDb(); + const [user] = await db + .select() + .from(users) + .where(eq(users.email, email)); + return user; + } + + /** + * 모든 활성 사용자 조회 + */ + async findAllActive() { + const db = this.databaseService.getDb(); + return await db + .select() + .from(users) + .where(eq(users.isActive, true)); + } + + /** + * 모든 시스템 관리자 조회 + */ + async findAllSystemAdmins() { + const db = this.databaseService.getDb(); + return await db + .select() + .from(users) + .where(and(eq(users.isSystemAdmin, true), eq(users.isActive, true))); + } + + /** + * 사용자 정보 업데이트 + */ + async update(userId: string, data: UpdateUserDto) { + const db = this.databaseService.getDb(); + const [user] = await db + .update(users) + .set({ + ...data, + updatedAt: new Date().toISOString(), + }) + .where(eq(users.userId, userId)) + .returning(); + return user; + } + + /** + * 마지막 로그인 시간 업데이트 + */ + async updateLastLogin(userId: string) { + const db = this.databaseService.getDb(); + const [user] = await db + .update(users) + .set({ + lastLoginAt: new Date().toISOString(), + }) + .where(eq(users.userId, userId)) + .returning(); + return user; + } + + /** + * 사용자 비활성화 + */ + async deactivate(userId: string) { + return this.update(userId, { isActive: false }); + } + + /** + * 사용자 활성화 + */ + async activate(userId: string) { + return this.update(userId, { isActive: true }); + } + + /** + * Entra 정보로 사용자 찾거나 생성 + */ + async findOrCreate(data: CreateUserDto) { + const existing = await this.findByEntraObjectId(data.entraObjectId); + if (existing) { + return existing; + } + return this.create(data); + } +}