@things-factory/board-service 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -1,92 +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 { PlayGroup } from './play-group'
-import { PlayGroupList } from './play-group-type'
-
-@Resolver(PlayGroup)
-export class PlayGroupQuery {
-  @Query(returns => PlayGroup, { nullable: true, description: 'To fetch a PlayGroup' })
-  async playGroup(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PlayGroup> {
-    const { domain } = context.state
-
-    return await getRepository(PlayGroup).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => PlayGroup, { nullable: true, description: 'To fetch a PlayGroup by name' })
-  async playGroupByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<PlayGroup> {
-    const { domain } = context.state
-
-    return await getRepository(PlayGroup).findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-  }
-
-  @Query(returns => PlayGroupList, { description: 'To fetch multiple PlayGroups' })
-  async playGroups(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<PlayGroupList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(PlayGroup),
-      params,
-      domain,
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => [Board])
-  async boards(@Root() playGroup) {
-    const { order = [], boards = [] } = await getRepository(PlayGroup).findOne({
-      where: { id: playGroup.id },
-      relations: ['boards']
-    })
-
-    return boards.sort((a, b) => {
-      // 배열 A에 포함된 아이디의 순서를 가져옵니다.
-      const indexOfOrder = (order || []).indexOf(a.id)
-      const indexOfBoards = (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
-      }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() playGroup: PlayGroup) {
-    return await getRepository(Domain).findOneBy({ id: playGroup.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() playGroup: PlayGroup): Promise<User> {
-    return await getRepository(User).findOneBy({ id: playGroup.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() playGroup: PlayGroup): Promise<User> {
-    return await getRepository(User).findOneBy({ id: playGroup.creatorId })
-  }
-}

package/server/service/play-group/play-group-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 { PlayGroup } from './play-group'
-
-@Resolver(PlayGroup)
-export class PlayGroupSubscription {
-  @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('play-group'),
-        filter((payload: { playGroup: PlayGroup }) => {
-          const { id: playGroupId, domainId } = payload.playGroup
-
-          if (domainId !== domain.id) {
-            return false
-          }
-
-          if (id !== playGroupId) {
-            return false
-          }
-
-          return true
-        })
-      )
-    }
-  })
-  playGroup(@Root() payload: { playGroup: PlayGroup }, @Arg('id') id: string): PlayGroup {
-    return payload.playGroup
-  }
-}

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

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

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

@@ -1,74 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  JoinTable,
-  ManyToMany,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { Board } from '../board/board'
-
-@Entity()
-@Index('ix_play_group_0', (playGroup: PlayGroup) => [playGroup.domain, playGroup.name], { unique: true })
-@ObjectType({ description: 'Entity for Board PlayGroup' })
-export class PlayGroup {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain?: Domain
-
-  @RelationId((playGroup: PlayGroup) => playGroup.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description?: string
-
-  @ManyToMany(type => Board, board => board.playGroups)
-  @JoinTable({ name: 'play_groups_boards' })
-  @Field(type => [Board], { nullable: true })
-  boards: Board[]
-
-  @Column('simple-json', { nullable: true })
-  order: any
-
-  @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((playGroup: PlayGroup) => playGroup.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((playGroup: PlayGroup) => playGroup.updater)
-  updaterId?: string
-}

package/server/service/theme/index.ts

@@ -1,7 +0,0 @@
-import { Theme } from './theme'
-import { ThemeQuery } from './theme-query'
-import { ThemeMutation } from './theme-mutation'
-
-export const entities = [Theme]
-export const resolvers = [ThemeQuery, ThemeMutation]
-export const subscribers = []

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

@@ -1,128 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Theme } from './theme'
-import { NewTheme, ThemePatch } from './theme-type'
-
-@Resolver(Theme)
-export class ThemeMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Theme, { description: 'To create new Theme' })
-  async createTheme(@Arg('theme') theme: NewTheme, @Ctx() context: ResolverContext): Promise<Theme> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(Theme).save({
-      ...theme,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Theme, { description: 'To modify Theme information' })
-  async updateTheme(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ThemePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Theme> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Theme)
-    const theme = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    return await repository.save({
-      ...theme,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Theme], { description: "To modify multiple Themes' information" })
-  async updateMultipleTheme(
-    @Arg('patches', type => [ThemePatch]) patches: ThemePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Theme[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const themeRepo = tx.getRepository(Theme)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await themeRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const theme = await themeRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await themeRepo.save({
-          ...theme,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Theme' })
-  async deleteTheme(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Theme).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Themes' })
-  async deleteThemes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Theme).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple Themes' })
-  async importThemes(
-    @Arg('themes', type => [ThemePatch]) themes: ThemePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      themes.map(async (theme: ThemePatch) => {
-        const createdTheme: Theme = await tx.getRepository(Theme).save({ domain, ...theme })
-      })
-    )
-
-    return true
-  }
-}

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

@@ -1,48 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Theme } from './theme'
-import { ThemeList } from './theme-type'
-
-@Resolver(Theme)
-export class ThemeQuery {
-  @Query(returns => Theme!, { nullable: true, description: 'To fetch a Theme' })
-  async theme(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Theme> {
-    const { domain } = context.state
-
-    return await getRepository(Theme).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => ThemeList, { description: 'To fetch multiple Themes' })
-  async themes(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<ThemeList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Theme),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() theme: Theme): Promise<Domain> {
-    return theme.domainId && (await getRepository(Domain).findOneBy({ id: theme.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() theme: Theme): Promise<User> {
-    return theme.updaterId && (await getRepository(User).findOneBy({ id: theme.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() theme: Theme): Promise<User> {
-    return theme.creatorId && (await getRepository(User).findOneBy({ id: theme.creatorId }))
-  }
-}

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

@@ -1,55 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-
-import { ScalarObject } from '@things-factory/shell'
-import { Theme } from './theme'
-
-@InputType()
-export class NewTheme {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field(type => ScalarObject, { nullable: true })
-  value?: any
-}
-
-@InputType()
-export class ThemePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field(type => ScalarObject, { nullable: true })
-  value?: any
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class ThemeList {
-  @Field(type => [Theme])
-  items: Theme[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/theme/theme.ts

@@ -1,97 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, ID } from 'type-graphql'
-
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-export interface ThemeType {
-  name: string
-  propType: string
-}
-
-var ThemeTypes: { [name: string]: ThemeType } = {
-  Legend: {
-    name: 'Legend',
-    propType: 'legend'
-  }
-}
-
-@Entity()
-@Index('ix_theme_0', (theme: Theme) => [theme.domain, theme.name, theme.deletedAt], { unique: true })
-@ObjectType({ description: 'Entity for Theme' })
-export class Theme {
-  static registerThemeType(themeType: ThemeType) {
-    ThemeTypes[themeType.name] = themeType
-  }
-
-  static getThemeType(name: string) {
-    return ThemeTypes[name]
-  }
-
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((theme: Theme) => theme.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  type?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  value?: any
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((theme: Theme) => theme.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((theme: Theme) => theme.updater)
-  updaterId?: string
-}