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); + } +}