@things-factory/board-service 8.0.5 → 9.0.0-beta.12

package/server/service/board/board-mutation.ts

@@ -1,446 +0,0 @@
-import { Arg, Ctx, Mutation, Resolver, Directive } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { Domain, getDataSource, getRedirectSubdomainPath, getRepository } from '@things-factory/shell'
-
-import { thumbnail } from '../../controllers/thumbnail'
-import { Group } from '../group/group'
-import { Board } from './board'
-import { BoardHistory } from './board-history'
-import { BoardPatch, NewBoard } from './board-type'
-
-async function parseJSONFile(uploadedFile: FileUpload): Promise<any> {
-  var { createReadStream } = await uploadedFile
-
-  return new Promise((resolve, reject) => {
-    const chunks: Uint8Array[] = []
-
-    createReadStream()
-      .on('data', (chunk: Uint8Array) => {
-        chunks.push(chunk)
-      })
-      .on('end', () => {
-        try {
-          const fileContents = Buffer.concat(chunks).toString('utf-8')
-          const jsonData = JSON.parse(fileContents)
-          resolve(jsonData)
-        } catch (error) {
-          reject(error)
-        }
-      })
-      .on('error', (error: Error) => {
-        reject(error)
-      })
-  })
-}
-
-@Resolver(Board)
-export class BoardMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Board, { description: 'To create new Board' })
-  async createBoard(@Arg('board') board: NewBoard, @Ctx() context: ResolverContext): Promise<Board> {
-    const { domain, user, notify, tx } = context.state
-    const repository = tx.getRepository(Board)
-    const groupRepository = tx.getRepository(Group)
-
-    const oldBoard: Board = await repository.findOneBy({
-      name: board.name,
-      domain: { id: domain.id }
-    })
-
-    if (oldBoard) {
-      throw new Error(context.t('error.board name is already taken', { name: board.name }))
-    }
-
-    const newBoard: Board = {
-      ...board
-    }
-
-    newBoard.thumbnail ||=
-      'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==' /* empty thumbnail */
-
-    if (board.groupId) {
-      newBoard.group = await groupRepository.findOneBy({
-        id: board.groupId
-      })
-    }
-
-    const created = await repository.save({
-      domain,
-      ...newBoard,
-      state: 'draft',
-      creator: user,
-      updater: user
-    })
-
-    notify &&
-      notify({
-        mode: 'in-app',
-        title: `Board '${created.name}' created`,
-        body: `Board '${created.name}' created by ${user.name}\n${created.description}`,
-        url: getRedirectSubdomainPath(context, domain.subdomain, `/board-viewer/${created.id}`)
-      })
-
-    return created
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Board, { description: 'To clone a Board from existing Board' })
-  async cloneBoard(
-    @Arg('id') id: string,
-    @Arg('patch') patch: BoardPatch,
-    @Arg('targetSubdomain') targetSubdomain: string,
-    @Arg('targetGroupId', { nullable: true }) targetGroupId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Board> {
-    const { domain, user, notify, tx } = context.state
-    const { t } = context
-    const repository = tx.getRepository(Board)
-
-    const board = await repository.findOneBy({ domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id })
-
-    if (!patch.name || (patch.name == board.name && targetSubdomain == domain.subdomain)) {
-      throw t('error.name must be unique from the original board', { name: patch.name })
-    }
-
-    if (targetSubdomain != domain.subdomain) {
-      if ((await repository.count({ where: { domain: { subdomain: targetSubdomain }, name: patch.name } })) > 0) {
-        throw t('error.name must be unique from the original board', { name: patch.name })
-      }
-    }
-
-    var targetDomain = domain
-    if (targetDomain && domain.subdomain != targetSubdomain) {
-      targetDomain = await tx.getRepository(Domain).findOneBy({ subdomain: targetSubdomain })
-      if (!targetDomain) {
-        throw `given subdomain(${targetSubdomain}) not found`
-      }
-    }
-
-    var targetGroup = null
-    if (targetGroupId) {
-      targetGroup = await tx.getRepository(Group).findOneBy({ domain: { id: targetDomain.id }, id: targetGroupId })
-      if (!targetGroup) {
-        throw `given group(${targetGroupId}) in domain(${targetSubdomain}) not found`
-      }
-    }
-
-    const { id: excluded, ...clone } = board
-
-    const cloned = await repository.save({
-      domain: targetDomain,
-      ...clone,
-      ...patch,
-      group: targetGroup,
-      version: 0,
-      state: 'draft',
-      updater: user,
-      creator: user
-    })
-
-    notify &&
-      notify({
-        mode: 'in-app',
-        title: `Board '${cloned.name}' cloned`,
-        body: `Board '${cloned.name}' cloned by ${user.name}\n${cloned.description}`,
-        image: getRedirectSubdomainPath(context, targetSubdomain, `/thumbnail/${cloned.id}`),
-        url: getRedirectSubdomainPath(context, targetSubdomain, `/board-viewer/${cloned.id}`)
-      })
-
-    return cloned
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Board, { description: 'To modify Board information' })
-  async updateBoard(
-    @Arg('id') id: string,
-    @Arg('patch') patch: BoardPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Board> {
-    const { domain, user, notify, tx } = context.state
-    const repository = tx.getRepository(Board)
-
-    const board = await repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['creator']
-    })
-
-    if (patch.model) {
-      const thumbnailPromise = thumbnail({
-        model: patch.model,
-        context
-      })
-
-      try {
-        const thumbnailBase64 = await Promise.race([
-          thumbnailPromise,
-          new Promise((_, reject) => setTimeout(() => reject(new Error('5 seconds timeout')), 5000))
-        ])
-
-        patch.thumbnail = 'data:image/png;base64,' + thumbnailBase64.toString('base64')
-      } catch (e) {
-        console.warn(`Failed to get thumbnail for '${board.name}' in first 5 seconds`)
-        // 5초 안에 썸네일이 생성되지 않았으므로 모델만 저장합니다.
-        patch.thumbnail =
-          'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==' /* empty thumbnail */
-
-        Promise.race([
-          thumbnailPromise,
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Thumbnail extended timeout')), 5000))
-        ])
-          .then(async thumbnailBase64 => {
-            /* use new resource manager */
-            await getDataSource().transaction(async (tx: EntityManager) => {
-              await tx.getRepository(Board).save({
-                id: updated.id,
-                thumbnail: 'data:image/png;base64,' + thumbnailBase64.toString('base64')
-              })
-            })
-          })
-          .catch(error => {
-            console.error(`Failed to save thumbnail for '${board.name}' even after extended time:`, error)
-          })
-      }
-    }
-
-    const { groupId, ...patched } = patch
-
-    if (groupId !== undefined) {
-      const groupRepository = tx.getRepository(Group)
-      board.group = groupId
-        ? (await groupRepository.findOneBy({
-            domain: { id: domain.id },
-            id: groupId
-          })) || null
-        : null
-    }
-
-    const updated = await repository.save({
-      domain,
-      ...board,
-      ...patched,
-      state: 'draft',
-      updater: user
-    })
-
-    notify &&
-      notify({
-        mode: 'in-app',
-        title: `Board '${updated.name}' updated`,
-        body: `Board '${updated.name}' updated by ${user.name}\n${updated.description}`,
-        image: getRedirectSubdomainPath(context, domain.subdomain, `/thumbnail/${updated.id}`),
-        url: getRedirectSubdomainPath(context, domain.subdomain, `/board-viewer/${updated.id}`)
-      })
-
-    return updated
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Board, { description: 'To release a Board' })
-  async releaseBoard(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Board> {
-    const { domain, user, notify, tx } = context.state
-    const repository = tx.getRepository(Board)
-
-    const board = await repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['creator']
-    })
-
-    if (!board) {
-      throw `Board given id(${id}) is not found`
-    }
-
-    if (board.state == 'released') {
-      throw `Board given id(${id}) is already released`
-    }
-
-    const updated = await repository.save({
-      domain,
-      ...board,
-      version: (board.version || 0) + 1,
-      state: 'released',
-      updater: user
-    })
-
-    notify &&
-      notify({
-        mode: 'in-app',
-        title: `Board '${updated.name}' released`,
-        body: `Board '${updated.name}' released by ${user.name}\n${updated.description}`,
-        image: getRedirectSubdomainPath(context, domain.subdomain, `/thumbnail/${updated.id}`),
-        url: getRedirectSubdomainPath(context, domain.subdomain, `/board-viewer/${updated.id}`)
-      })
-
-    return updated
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Board, { description: 'To revert Board version' })
-  async revertBoardVersion(
-    @Arg('id') id: string,
-    @Arg('version') version: number,
-    @Ctx() context: ResolverContext
-  ): Promise<Board> {
-    const { domain, user, notify, tx } = context.state
-    const repository = tx.getRepository(Board)
-
-    const board = await repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['creator']
-    })
-
-    if (!board) {
-      throw `Board with id(${id}) is not found`
-    }
-
-    const historyRepository = tx.getRepository(BoardHistory)
-
-    const boardHistory = await historyRepository.findOne({
-      where: { domain: { id: domain.id }, originalId: id, version },
-      order: { version: 'DESC' }
-    })
-
-    if (!boardHistory) {
-      throw `Board with id:version(${id}:${version}) is not found`
-    }
-
-    const updated = await repository.save({
-      domain,
-      ...board,
-      model: boardHistory.model,
-      thumbnail: boardHistory.thumbnail,
-      state: 'draft',
-      updater: user
-    })
-
-    notify &&
-      notify({
-        mode: 'in-app',
-        title: `Board '${updated.name}' updated`,
-        body: `Board '${updated.name}' updated by ${user.name}\n${updated.description}`,
-        image: getRedirectSubdomainPath(context, domain.subdomain, `/thumbnail/${updated.id}`),
-        url: getRedirectSubdomainPath(context, domain.subdomain, `/board-viewer/${updated.id}`)
-      })
-
-    return updated
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete Board' })
-  async deleteBoard(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, user, notify, tx } = context.state
-    const repository = tx.getRepository(Board)
-    const board = await repository.findOneBy({ domain: { id: domain.id }, id })
-
-    const deleted = await repository.softDelete(id)
-
-    notify &&
-      notify({
-        mode: 'in-app',
-        title: `Board '${board.name}' deleted`,
-        body: `Board '${board.name}' deleted by ${user.name}\n${board.description}`
-      })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => [Board], { description: 'To import some Boards' })
-  async importBoards(
-    @Arg('groupId') groupId: string,
-    @Arg('files', () => [GraphQLUpload]) files: FileUpload[],
-    @Arg('overwrite') overwrite: boolean,
-    @Ctx() context: ResolverContext
-  ): Promise<Board[]> {
-    const { domain, user, notify, tx } = context.state
-    const groupRepository = tx.getRepository(Group)
-    const boardRepository = tx.getRepository(Board)
-    const group = await groupRepository.findOneBy({ domain: { id: domain.id }, id: groupId })
-
-    if (!group) {
-      throw `Group with id(${groupId}) is not found`
-    }
-
-    const boards = []
-
-    for (const file of files) {
-      const { id, name, description, model, thumbnail } = await parseJSONFile(file)
-
-      var sameNameBoard = await boardRepository.findOneBy({ domain: { id: domain.id }, name })
-      var sameIdBoard = await boardRepository.findOneBy({ id })
-
-      if (overwrite) {
-        var board = {} as any
-
-        if (sameIdBoard) {
-          if (overwrite && sameIdBoard.domainId != domain.id) {
-            throw `Board with id(${id}) is already taken in another domain`
-          }
-
-          board = {
-            ...sameIdBoard,
-            name
-          }
-
-          if (sameNameBoard && sameIdBoard.id != sameNameBoard.id) {
-            /* 이름 충돌 회피 */
-            board.name = `${board.name}(${Date.now()})`
-          }
-        } else {
-          board = {
-            id,
-            name: sameNameBoard ? `${name}(${Date.now()})` : name,
-            version: 0,
-            creator: user
-          }
-        }
-      } else {
-        board = {
-          name,
-          version: 0,
-          creator: user
-        }
-
-        /* ID가 없으면, 사용해도 됨 */
-        if (!sameIdBoard) {
-          board.id = id
-        }
-
-        /* 이름 충돌 회피 */
-        if (sameNameBoard) {
-          board.name = `${board.name}(${Date.now()})`
-        }
-      }
-
-      boards.push(
-        await boardRepository.save({
-          ...board,
-          domain,
-          description,
-          model: typeof model != 'string' ? JSON.stringify(model) : model,
-          thumbnail,
-          group,
-          state: 'draft',
-          updater: user
-        })
-      )
-    }
-
-    notify &&
-      notify({
-        mode: 'in-app',
-        title: `${boards.length} Board(s) are imported`,
-        body: `${boards.length} Board(s) are imported into group ${group.name} by ${user.name}`
-      })
-
-    return boards
-  }
-}

package/server/service/board/board-query.ts

@@ -1,180 +0,0 @@
-import { In } from 'typeorm'
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root, Directive } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { checkTarget, checkDomain, getPermission } from '@things-factory/operato-license-checker'
-
-import { Group } from '../group/group'
-import { PlayGroup } from '../play-group/play-group'
-import { Board } from './board'
-import { BoardList } from './board-type'
-import { BoardHistory } from './board-history'
-
-import { LicenseError } from '../../errors/license-error'
-@Resolver(Board)
-export class BoardQuery {
-  @Directive('@privilege(category: "board", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => Board, { description: 'To fetch a board' })
-  async board(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Board> {
-    const { domain } = context.state
-
-    var board = await getRepository(Board).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
-    })
-
-    if (domain) {
-      // 1. check domainSecret is over limit quantity or not
-      var count = await getRepository(Domain)
-        .manager.createQueryBuilder()
-        .select('id')
-        .from(Domain, 'domain')
-        .getCount()
-
-      if (!checkDomain(count)) {
-        throw new LicenseError({
-          errorCode: context.t(LicenseError.ERROR_CODES.OVER_LIMIT)
-        })
-      }
-    }
-
-    if (board) {
-      // 1. check boardSecret is over limit quantity or not
-      var count = await getRepository(Board)
-        .manager.createQueryBuilder()
-        .select('id')
-        .from(Board, 'board')
-        .where('"domain_id" = :domainId', { domainId: domain.id })
-        .getCount()
-
-      if (!checkTarget(count)) {
-        throw new LicenseError({
-          errorCode: context.t(LicenseError.ERROR_CODES.OVER_LIMIT)
-        })
-      }
-    }
-
-    return board
-  }
-
-  @Query(returns => Board, { nullable: true, description: 'To fetch a Board Model by name' })
-  @Directive('@privilege(category: "board", privilege: "query", domainOwnerGranted: true)')
-  async boardByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Board> {
-    const { domain } = context.state
-
-    return await getRepository(Board).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, name }
-    })
-  }
-
-  @Query(returns => BoardList, { description: 'To fetch Boards created by me' })
-  async boardsCreatedByMe(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<BoardList> {
-    const { domain, user } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Board),
-      params,
-      domain,
-      alias: 'board',
-      searchables: ['name', 'description']
-    }).andWhere('board.creator = :user', { user: user.id })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => [BoardHistory], { description: 'To fetch a Board Versions' })
-  @Directive('@privilege(category: "board", privilege: "query", domainOwnerGranted: true)')
-  async boardVersions(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<BoardHistory[]> {
-    const { domain } = context.state
-
-    return await getRepository(BoardHistory).find({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, originalId: id },
-      relations: ['updater'],
-      order: { version: 'DESC' },
-      take: 10
-    })
-  }
-
-  @Query(returns => BoardHistory, { description: 'To fetch the latest Board published' })
-  @Directive('@privilege(category: "board", privilege: "query", domainOwnerGranted: true)')
-  async boardPublished(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<BoardHistory> {
-    const { domain } = context.state
-
-    return await getRepository(BoardHistory).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, originalId: id },
-      order: { version: 'DESC' }
-    })
-  }
-
-  @Query(returns => BoardList, { description: 'To fetch multiple Boards' })
-  @Directive('@privilege(category: "board", privilege: "query", domainOwnerGranted: true)')
-  async boards(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<BoardList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Board),
-      params,
-      domain,
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Group)
-  async group(@Root() board: Board) {
-    return (
-      board.groupId &&
-      (await getRepository(Group).findOneBy({
-        id: board.groupId
-      }))
-    )
-  }
-
-  @FieldResolver(type => [PlayGroup])
-  async playGroups(@Root() board: Board) {
-    return (
-      await getRepository(Board).findOne({
-        where: { id: board.id },
-        relations: ['playGroups']
-      })
-    )?.playGroups
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() board: Board) {
-    return (
-      board.domainId &&
-      (await getRepository(Domain).findOneBy({
-        id: board.domainId
-      }))
-    )
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() board: Board): Promise<User> {
-    return (
-      board.updaterId &&
-      (await getRepository(User).findOneBy({
-        id: board.updaterId
-      }))
-    )
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() board: Board): Promise<User> {
-    return (
-      board.creatorId &&
-      (await getRepository(User).findOneBy({
-        id: board.creatorId
-      }))
-    )
-  }
-}

package/server/service/board/board-subscription.ts

@@ -1,43 +0,0 @@
-import { Resolver, Subscription, Root, Arg } from 'type-graphql'
-import { filter, pipe } from 'graphql-yoga'
-import { pubsub } from '@things-factory/shell'
-import { Board } from './board'
-
-@Resolver(Board)
-export class BoardSubscription {
-  @Subscription({
-    subscribe: ({ args, context, info }) => {
-      const { domain, user } = context.state
-      const { id } = args
-      const subdomain = domain?.subdomain
-
-      if (!domain) {
-        throw new Error('domain required')
-      }
-
-      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
-        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
-      }
-
-      return pipe(
-        pubsub.subscribe('board'),
-        filter((payload: { board: Board }) => {
-          const { domainId, id: boardId } = payload.board
-
-          if (domainId !== domain.id) {
-            return false
-          }
-
-          if (id !== boardId) {
-            return false
-          }
-
-          return true
-        })
-      )
-    }
-  })
-  board(@Root() payload: { board: Board }, @Arg('id') id: string): Board {
-    return payload.board
-  }
-}