@things-factory/board-service 8.0.0 → 9.0.0-beta.3

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

@@ -1,114 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-export enum BoardTemplateStatus {
-  DRAFT = 'DRAFT',
-  RELEASED = 'RELEASED'
-}
-
-registerEnumType(BoardTemplateStatus, {
-  name: 'BoardTemplateStatus',
-  description: 'state enumeration of a boardTemplate'
-})
-
-@Entity()
-@Index('ix_board_template_0', (boardTemplate: BoardTemplate) => [boardTemplate.domain, boardTemplate.name], {
-  unique: true
-})
-@ObjectType({ description: 'Entity for BoardTemplate' })
-export class BoardTemplate {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((boardTemplate: BoardTemplate) => boardTemplate.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column('simple-json', { nullable: true, default: null })
-  @Field(type => ScalarObject, { nullable: true })
-  tags?: string[]
-
-  @Column({ nullable: true, default: 'private' })
-  @Field({ nullable: true })
-  visibility?: string // 'private' | 'public' | 'domain'
-
-  @Column({
-    nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longtext'
-        : DATABASE_TYPE == 'oracle'
-          ? 'clob'
-          : DATABASE_TYPE == 'mssql'
-            ? 'nvarchar'
-            : 'varchar',
-    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
-  })
-  @Field({ nullable: true })
-  model?: string
-
-  @Column({
-    nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longtext'
-        : DATABASE_TYPE == 'oracle'
-          ? 'clob'
-          : DATABASE_TYPE == 'mssql'
-            ? 'nvarchar'
-            : 'varchar',
-    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
-  })
-  @Field({ nullable: true })
-  thumbnail?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((boardTemplate: BoardTemplate) => boardTemplate.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((boardTemplate: BoardTemplate) => boardTemplate.updater)
-  updaterId?: string
-}

package/server/service/board-template/index.ts

@@ -1,7 +0,0 @@
-import { BoardTemplate } from './board-template'
-import { BoardTemplateQuery } from './board-template-query'
-import { BoardTemplateMutation } from './board-template-mutation'
-
-export const entities = [BoardTemplate]
-export const resolvers = [BoardTemplateQuery, BoardTemplateMutation]
-export const subscribers = []

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

@@ -1,82 +0,0 @@
-import { Arg, Ctx, Mutation, Resolver, Directive } from 'type-graphql'
-
-import { Board } from '../board/board'
-import { Group } from './group'
-import { GroupPatch, NewGroup } from './group-type'
-
-@Resolver(Group)
-export class GroupMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Group, { nullable: true, description: 'To create new Group' })
-  async createGroup(@Arg('group') group: NewGroup, @Ctx() context: ResolverContext): Promise<Group> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(Group).save({
-      domain,
-      ...group,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Group, { description: 'To modify Group information' })
-  async updateGroup(
-    @Arg('id') id: string,
-    @Arg('patch') patch: GroupPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Group> {
-    const { domain, user, tx } = context.state
-    const repository = tx.getRepository(Group)
-
-    const group = await repository.findOneBy({ domain: { id: domain.id }, id })
-
-    return await repository.save({
-      ...group,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Group, { description: 'To make the board to join the group' })
-  async joinGroup(
-    @Arg('id') id: string,
-    @Arg('boardIds', type => [String]) boardIds: string[],
-    @Ctx() context: ResolverContext
-  ) {
-    const { domain, tx } = context.state
-    const repository = tx.getRepository(Group)
-    const group = await repository.findOneBy({ domain: { id: domain.id }, id })
-
-    const boardRepository = tx.getRepository(Board)
-
-    await boardIds.forEach(async boardId => {
-      let board = await boardRepository.findOneBy({ domain: { id: domain.id }, id: boardId })
-      board.group = group
-      await boardRepository.save(board)
-    })
-
-    return await repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['boards']
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Group' })
-  async deleteGroup(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    const repository = tx.getRepository(Group)
-
-    /* TODO - 그룹에 소속된 보드가 있는 경우에는 그룹을 지워서는 안된다. */
-    const group = await repository.findOneBy({
-      domain: { id: domain.id },
-      id
-    })
-
-    await repository.delete(id)
-    return true
-  }
-}

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

@@ -1,58 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { Board } from '../board/board'
-import { Group } from './group'
-import { GroupList } from './group-type'
-
-@Resolver(Group)
-export class GroupQuery {
-  @Query(returns => Group, { nullable: true, description: 'To fetch a Group' })
-  async group(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Group> {
-    const { domain } = context.state
-
-    return await getRepository(Group).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => GroupList, { description: 'To fetch multiple Groups' })
-  async groups(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<GroupList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Group),
-      params,
-      domain,
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => [Board])
-  async boards(@Root() group: Group) {
-    return await getRepository(Board).findBy({
-      group: { id: group.id }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() group: Group) {
-    return await getRepository(Domain).findOneBy({ id: group.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() group: Group): Promise<User> {
-    return await getRepository(User).findOneBy({ id: group.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() group: Group): Promise<User> {
-    return await getRepository(User).findOneBy({ id: group.creatorId })
-  }
-}

package/server/service/group/group-type.ts

@@ -1,30 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Group } from './group'
-
-@InputType()
-export class NewGroup {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-}
-
-@InputType()
-export class GroupPatch {
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-}
-
-@ObjectType()
-export class GroupList {
-  @Field(type => [Group])
-  items: Group[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/group/group.ts

@@ -1,69 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Board } from '../board/board'
-import { BoardHistory } from '../board/board-history'
-
-@Entity()
-@Index('ix_group_0', (group: Group) => [group.domain, group.name], { unique: true })
-@ObjectType({ description: 'Entity for Board Management Group' })
-export class Group {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain?: Domain
-
-  @RelationId((group: Group) => group.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description?: string
-
-  @OneToMany(type => Board, board => board.group)
-  @Field(type => [Board], { nullable: true })
-  boards: Board[]
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((group: Group) => group.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((group: Group) => group.updater)
-  updaterId?: string
-}

package/server/service/group/index.ts

@@ -1,6 +0,0 @@
-import { Group } from './group'
-import { GroupQuery } from './group-query'
-import { GroupMutation } from './group-mutation'
-
-export const entities = [Group]
-export const resolvers = [GroupQuery, GroupMutation]

package/server/service/index.ts

@@ -1,56 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './board-template/board-template'
-export * from './theme/theme'
-export * from './board/board'
-export * from './group/group'
-export * from './play-group/play-group'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import {
-  entities as BoardTemplateEntities,
-  resolvers as BoardTemplateResolvers,
-  subscribers as BoardTemplateSubscribers
-} from './board-template'
-import { entities as ThemeEntities, resolvers as ThemeResolvers, subscribers as ThemeSubscribers } from './theme'
-import { entities as BoardEntities, resolvers as BoardResolvers, subscribers as BoardSubscribers } from './board'
-import { entities as GroupEntities, resolvers as GroupResolvers } from './group'
-import {
-  entities as PlayGroupEntities,
-  resolvers as PlayGroupResolvers,
-  subscribers as PlayGroupSubscribers
-} from './play-group'
-import { resolvers as IntegrationAnalysisQuery } from './analysis'
-import { entities as BoardFavoriteEntities, resolvers as BoardFavoriteResolvers } from './board-favorite'
-import { subscribers as PermissionSubscriber } from './permission'
-
-export const entities = [
-  /* ENTITIES */
-  ...BoardTemplateEntities,
-  ...ThemeEntities,
-  ...BoardEntities,
-  ...GroupEntities,
-  ...PlayGroupEntities,
-  ...BoardFavoriteEntities
-]
-
-export const subscribers = [
-  /* SUBSCRIBERS */
-  ...BoardTemplateSubscribers,
-  ...ThemeSubscribers,
-  ...BoardSubscribers,
-  ...PlayGroupSubscribers,
-  ...PermissionSubscriber
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...BoardTemplateResolvers,
-    ...ThemeResolvers,
-    ...BoardResolvers,
-    ...GroupResolvers,
-    ...PlayGroupResolvers,
-    ...IntegrationAnalysisQuery,
-    ...BoardFavoriteResolvers
-  ]
-}

package/server/service/permission/domain-permission-subscriber.ts

@@ -1,27 +0,0 @@
-import { EntitySubscriberInterface, EventSubscriber, InsertEvent } from 'typeorm'
-
-import { checkDomain } from '@things-factory/operato-license-checker'
-import { Domain } from '@things-factory/shell'
-
-import { LicenseError } from '../../errors/license-error'
-
-@EventSubscriber()
-export class DomainPermissionSubscriber implements EntitySubscriberInterface<Domain> {
-  listenTo() {
-    return Domain
-  }
-  /**
-   * Called before domain insertion.
-   */
-  async afterInsert(event: InsertEvent<Domain>) {
-    var entityManager = event.manager
-
-    var count = (await entityManager.createQueryBuilder().select('id').from(Domain, 'domain').getCount()) + 1
-
-    if (!checkDomain(count)) {
-      throw new LicenseError({
-        errorCode: LicenseError.ERROR_CODES.VERIFICATION_ERROR
-      })
-    }
-  }
-}

package/server/service/permission/index.ts

@@ -1,3 +0,0 @@
-import { DomainPermissionSubscriber } from './domain-permission-subscriber'
-
-export const subscribers = [DomainPermissionSubscriber]

package/server/service/play-group/event-subscriber.ts

@@ -1,58 +0,0 @@
-import { EventSubscriber, EntitySubscriberInterface, InsertEvent, UpdateEvent } from 'typeorm'
-
-import { pubsub, getRepository } from '@things-factory/shell'
-
-import { PlayGroup } from './play-group'
-
-@EventSubscriber()
-export class PlayGroupSubscriber implements EntitySubscriberInterface<PlayGroup> {
-  listenTo() {
-    return PlayGroup
-  }
-
-  // afterInsert(event: InsertEvent<PlayGroup>): Promise<any> | void {
-  //   const playGroup = event.entity
-
-  //   pubsub.publish('playGroup', {
-  //     playGroup
-  //   })
-  // }
-
-  async afterUpdate(event: UpdateEvent<PlayGroup>): Promise<any> {
-    var playGroup = event.entity
-
-    playGroup = await getRepository(PlayGroup).findOne({
-      where: { domain: { id: playGroup.domainId }, id: playGroup.id },
-      relations: ['domain', 'boards']
-    })
-
-    if (!playGroup) {
-      return
-    }
-
-    playGroup.boards = playGroup.boards.sort((a, b) => {
-      // 배열 A에 포함된 아이디의 순서를 가져옵니다.
-      const indexOfOrder = (playGroup.order || []).indexOf(a.id)
-      const indexOfBoards = (playGroup.order || []).indexOf(b.id)
-
-      // 두 아이디의 순서를 비교하여 정렬합니다.
-      if (indexOfOrder === -1 && indexOfBoards === -1) {
-        // 두 아이디 모두 배열 A에 없는 경우, 그대로 유지합니다.
-        return 0
-      } else if (indexOfOrder === -1) {
-        // 아이디 A만 배열 A에 없는 경우, 아이디 B를 먼저 정렬합니다.
-        return 1
-      } else if (indexOfBoards === -1) {
-        // 아이디 B만 배열 A에 없는 경우, 아이디 A를 먼저 정렬합니다.
-        return -1
-      } else {
-        // 두 아이디 모두 배열 A에 있는 경우, 배열 A의 아이디 순서대로 정렬합니다.
-        return indexOfOrder - indexOfBoards
-      }
-    })
-
-    pubsub.publish('play-group', {
-      playGroup
-    })
-  }
-}

package/server/service/play-group/index.ts

@@ -1,9 +0,0 @@
-import { PlayGroup } from './play-group'
-import { PlayGroupQuery } from './play-group-query'
-import { PlayGroupMutation } from './play-group-mutation'
-import { PlayGroupSubscription } from './play-group-subscription'
-import { PlayGroupSubscriber } from './event-subscriber'
-
-export const entities = [PlayGroup]
-export const resolvers = [PlayGroupQuery, PlayGroupMutation, PlayGroupSubscription]
-export const subscribers = [PlayGroupSubscriber]

package/server/service/play-group/play-group-mutation.ts

@@ -1,148 +0,0 @@
-import { Data } from '@things-factory/shell'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Board } from '../board/board'
-import { PlayGroup } from './play-group'
-import { NewPlayGroup, PlayGroupPatch } from './play-group-type'
-
-@Resolver(PlayGroup)
-export class PlayGroupMutation {
-  @Mutation(returns => PlayGroup, { description: 'To create new PlayGroup' })
-  @Directive('@transaction')
-  async createPlayGroup(
-    @Arg('playGroup') playGroup: NewPlayGroup,
-    @Ctx() context: ResolverContext
-  ): Promise<PlayGroup> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(PlayGroup).save({
-      domain,
-      ...playGroup,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Mutation(returns => PlayGroup, { description: 'To modify PlayGroup information' })
-  @Directive('@transaction')
-  async updatePlayGroup(
-    @Arg('id') id: string,
-    @Arg('patch') patch: PlayGroupPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<PlayGroup> {
-    const { domain, user, tx } = context.state
-    const repository = tx.getRepository(PlayGroup)
-
-    const playGroup = await repository.findOneBy({ domain: { id: domain.id }, id })
-
-    return await repository.save({
-      ...playGroup,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Mutation(returns => PlayGroup, { description: 'To modify board order of a PlayGroup' })
-  @Directive('@transaction')
-  async reorderPlayGroup(
-    @Arg('id') id: string,
-    @Arg('boardIds', type => [String]) boardIds: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<PlayGroup> {
-    const { domain, user, tx } = context.state
-    const repository = tx.getRepository(PlayGroup)
-
-    const playGroup = await repository.findOneBy({ domain: { id: domain.id }, id })
-
-    return await repository.save({
-      ...playGroup,
-      order: boardIds,
-      updater: user
-    })
-  }
-
-  @Mutation(returns => PlayGroup, { description: 'To make the board to join the play group' })
-  @Directive('@transaction')
-  async joinPlayGroup(
-    @Arg('id') id: string,
-    @Arg('boardIds', type => [String]) boardIds: string[],
-    @Ctx() context: ResolverContext
-  ) {
-    const { tx } = context.state
-
-    const repository = tx.getRepository(PlayGroup)
-    const playGroup = await repository.findOne({
-      where: { id },
-      relations: ['boards']
-    })
-    const order = playGroup.order || []
-
-    const boardIdList = playGroup.boards.map(board => board.id)
-    boardIds.forEach(boardId => {
-      if (boardIdList.indexOf(boardId) == -1) {
-        boardIdList.push(boardId)
-      }
-      if (order.indexOf(boardId) == -1) {
-        order.push(boardId)
-      }
-    })
-
-    const boardRepository = tx.getRepository(Board)
-    playGroup.boards = await boardRepository.findBy({ id: In(boardIdList) })
-    playGroup.updatedAt = new Date()
-    playGroup.order = order
-
-    return await repository.save(playGroup)
-  }
-
-  @Mutation(returns => PlayGroup, { description: 'To make the board to leave from the play group' })
-  @Directive('@transaction')
-  async leavePlayGroup(
-    @Arg('id') id: string,
-    @Arg('boardIds', type => [String]) boardIds: string[],
-    @Ctx() context: ResolverContext
-  ) {
-    const { tx } = context.state
-
-    const repository = tx.getRepository(PlayGroup)
-    const playGroup = await repository.findOne({
-      where: { id },
-      relations: ['boards']
-    })
-    const order = playGroup.order || []
-
-    const boardIdList = playGroup.boards.map(board => board.id)
-    boardIds.forEach(boardId => {
-      let index = boardIdList.indexOf(boardId)
-      if (index !== -1) {
-        boardIdList.splice(index, 1)
-      }
-
-      index = order.indexOf(boardId)
-      if (index !== -1) {
-        order.splice(index, 1)
-      }
-    })
-
-    const boardRepository = tx.getRepository(Board)
-    playGroup.boards = await boardRepository.findBy({ id: In(boardIdList) })
-    playGroup.updatedAt = new Date()
-    playGroup.order = order
-
-    return await repository.save(playGroup)
-  }
-
-  @Mutation(returns => Boolean, { description: 'To delete PlayGroup' })
-  @Directive('@transaction')
-  async deletePlayGroup(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-    const repository = tx.getRepository(PlayGroup)
-
-    /* TODO - 플레이 그룹은 소속된 보드-플레이그룹 관계들도 제거되어야 한다. */
-    const playGroup = await repository.findOneBy({ domain: { id: domain.id }, id })
-
-    await repository.delete(id)
-    return true
-  }
-}