@things-factory/menu-base 8.0.0-beta.1 → 8.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/menu-base",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.2",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,7 +24,7 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.1"
+    "@things-factory/auth-base": "^8.0.0-beta.2"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "f03431a09435511b2595515658f9cb8f78ba4ebb"
 }

package/server/index.ts

@@ -1 +0,0 @@
-export * from './service'

package/server/service/index.ts

@@ -1,37 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './menu-detail-column/menu-detail-column'
-export * from './menu-detail-button/menu-detail-button'
-export * from './menu-column/menu-column'
-export * from './menu-button/menu-button'
-export * from './menu-detail/menu-detail'
-export * from './menu/menu'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import { entities as MenuDetailColumnEntities, resolvers as MenuDetailColumnResolvers } from './menu-detail-column'
-import { entities as MenuDetailButtonEntities, resolvers as MenuDetailButtonResolvers } from './menu-detail-button'
-import { entities as MenuColumnEntities, resolvers as MenuColumnResolvers } from './menu-column'
-import { entities as MenuButtonEntities, resolvers as MenuButtonResolvers } from './menu-button'
-import { entities as MenuDetailEntities, resolvers as MenuDetailResolvers } from './menu-detail'
-import { entities as MenuEntities, resolvers as MenuResolvers } from './menu'
-
-export const entities = [
-  /* ENTITIES */
-  ...MenuDetailColumnEntities,
-  ...MenuDetailButtonEntities,
-  ...MenuColumnEntities,
-  ...MenuButtonEntities,
-  ...MenuDetailEntities,
-  ...MenuEntities
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...MenuDetailColumnResolvers,
-    ...MenuDetailButtonResolvers,
-    ...MenuColumnResolvers,
-    ...MenuButtonResolvers,
-    ...MenuDetailResolvers,
-    ...MenuResolvers
-  ]
-}

package/server/service/menu/index.ts

@@ -1,6 +0,0 @@
-import { Menu } from './menu'
-import { MenuQuery } from './menu-query'
-import { MenuMutation } from './menu-mutation'
-
-export const entities = [Menu]
-export const resolvers = [MenuQuery, MenuMutation]

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

@@ -1,244 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In, Repository } from 'typeorm'
-
-import { Role } from '@things-factory/auth-base'
-
-import { Menu } from './menu'
-import { MenuPatch, NewMenu } from './menu-type'
-
-async function appendRoleToMenu(roleRepo, roles, targetRole) {
-  let roleIds: string[] = roles.map(role => role.id)
-  roleIds = Array.from(new Set([...roleIds, targetRole.id]))
-
-  return await roleRepo.findByIds(roleIds)
-}
-
-function removeRoleToMenu(roles, targetRole) {
-  return roles.filter(role => targetRole.id !== role.id)
-}
-
-@Resolver(Menu)
-export class MenuMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Menu, { description: 'To create new Menu' })
-  async createMenu(@Arg('menu') menu: NewMenu, @Ctx() context: ResolverContext): Promise<Menu> {
-    const { domain, user, tx } = context.state
-    const menuRepo = tx?.getRepository(Menu)
-
-    if (menu?.parent?.id) {
-      menu.parent = await menuRepo.findOneBy({
-        domain: { id: domain.id },
-        id: menu.parent.id
-      })
-    }
-
-    return await tx.getRepository(Menu).save({
-      ...menu,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Menu, { description: 'To modify Menu information' })
-  async updateMenu(
-    @Arg('id') id: string,
-    @Arg('patch') patch: MenuPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Menu> {
-    const { domain, user, tx } = context.state
-
-    const menuRepo = tx.getRepository(Menu)
-
-    const menu: Menu = await menuRepo.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['children', 'parent']
-    })
-
-    if (patch?.parent?.id) {
-      patch.parent = await menuRepo.findOneBy({ id: patch.parent.id })
-    }
-
-    if (patch?.children?.length) {
-      const childrenIds: string[] = patch.children.map((children: Menu) => children.id)
-      patch.children = await menuRepo.findByIds(childrenIds)
-    }
-
-    return await menuRepo.save({
-      ...menu,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Menu], { description: "To modify multiple Menus' information" })
-  async updateMultipleMenu(
-    @Arg('patches', type => [MenuPatch]) patches: MenuPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Menu[]> {
-    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 menuRepo = tx.getRepository(Menu)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (newRecord?.parent?.id) {
-          newRecord.parent = await menuRepo.findOneBy({
-            domain: { id: domain.id },
-            id: newRecord.parent.id
-          })
-        }
-
-        const result = await menuRepo.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 { id } = updateRecord
-
-        const menu: Menu = await menuRepo.findOne({
-          where: { domain: { id: domain.id }, id },
-          relations: ['children', 'parent']
-        })
-
-        if (updateRecord?.parent?.id) {
-          updateRecord.parent = await menuRepo.findOneBy({ id: updateRecord.parent.id })
-        }
-
-        if (updateRecord?.children?.length) {
-          const childrenIds: string[] = updateRecord.children.map((children: Menu) => children.id)
-          updateRecord.children = await menuRepo.findBy({ id: In(childrenIds) })
-        }
-
-        const result = await menuRepo.save({
-          ...menu,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Menu' })
-  async deleteMenu(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Menu).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Menus' })
-  async deleteMenus(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Menu).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Menu, { description: 'To update role Menu' })
-  async updateRoleMenu(
-    @Arg('roleId') roleId: string,
-    @Arg('targetMenuId') targetMenuId: string,
-    @Arg('isCheckedMenu') isCheckedMenu: boolean,
-    @Ctx() context: ResolverContext
-  ): Promise<Menu> {
-    const { domain, tx } = context.state
-
-    const menuRepo: Repository<Menu> = tx?.getRepository(Menu)
-    const roleRepo: Repository<Role> = tx?.getRepository(Role)
-
-    const menu: Menu = await menuRepo.findOne({
-      where: { domain: { id: domain.id }, id: targetMenuId },
-      relations: ['roles']
-    })
-    const targetRole: Role = await roleRepo.findOne({ where: { domain: { id: domain.id }, id: roleId } })
-
-    if (isCheckedMenu) {
-      menu.roles = await appendRoleToMenu(roleRepo, menu.roles, targetRole)
-    } else {
-      menu.roles = removeRoleToMenu(menu.roles, targetRole)
-    }
-
-    return await menuRepo.save({
-      ...menu
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Menu], { description: 'To update role Menu' })
-  async updateRoleMenus(
-    @Arg('roleId') roleId: string,
-    @Arg('parentMenuId') parentMenuId: string,
-    @Arg('isCheckedAll') isCheckedAll: boolean,
-    @Ctx() context: ResolverContext
-  ): Promise<Menu[]> {
-    const { domain, tx } = context.state
-
-    const menuRepo: Repository<Menu> = tx?.getRepository(Menu)
-    const roleRepo: Repository<Role> = tx?.getRepository(Role)
-
-    const targetParentMenu: Menu = await menuRepo.findOne({
-      where: { domain: { id: domain.id }, id: parentMenuId },
-      relations: ['children', 'children.roles']
-    })
-    let childMenus: Menu[] = targetParentMenu.children
-
-    const targetRole: Role = await roleRepo.findOne({ where: { domain: { id: domain.id }, id: roleId } })
-
-    if (isCheckedAll) {
-      childMenus.forEach(async child => {
-        child.roles = await appendRoleToMenu(roleRepo, child.roles, targetRole)
-      })
-    } else {
-      childMenus.forEach(child => {
-        child.roles = removeRoleToMenu(child.roles, targetRole)
-      })
-    }
-
-    return await menuRepo.save([...childMenus])
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple Menus' })
-  async importMenus(
-    @Arg('menus', type => [MenuPatch]) menus: MenuPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      menus.map(async (menu: MenuPatch) => {
-        const createdMenu: Menu = await tx.getRepository(Menu).save({ domain, ...menu })
-      })
-    )
-
-    return true
-  }
-}

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

@@ -1,249 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { In, Repository, Brackets, SelectQueryBuilder } from 'typeorm'
-
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { Role, User } from '@things-factory/auth-base'
-
-import { MenuButton } from '../menu-button/menu-button'
-import { MenuColumn } from '../menu-column/menu-column'
-import { Menu } from './menu'
-import { MenuList } from './menu-type'
-
-async function getNonRestrictedMenus(domain: Domain): Promise<Menu[]> {
-  const menus: Menu[] = await getRepository(Menu).find({
-    where: { domain: { id: domain.id }, hiddenFlag: false, menuType: 'MENU' },
-    relations: ['parent', 'children', 'children.roles'],
-    order: { rank: 'ASC' }
-  })
-
-  menus.forEach(menu => {
-    menu.children = menu.children.filter(child => !child.roles?.length)
-  })
-
-  return menus
-}
-
-async function getRestrictedMenus(roleIds: string[], domain: Domain): Promise<Menu[]> {
-  const menus: Menu[] = await getRepository(Menu).find({
-    where: { domain: { id: domain.id }, hiddenFlag: false, menuType: 'MENU' },
-    relations: ['parent', 'children', 'children.roles'],
-    order: { rank: 'ASC' }
-  })
-  const userRoles: Role[] = await getRepository(Role).find({ where: { domain: { id: domain.id }, id: In(roleIds) } })
-
-  menus.forEach(menu => {
-    menu.children = menu.children.filter(child => {
-      const childRoleIds = child.roles?.map(role => role.id) || []
-
-      return userRoles.find(role => childRoleIds.includes(role.id)) || false
-    })
-  })
-
-  return menus
-}
-
-@Resolver(Menu)
-export class MenuQuery {
-  @Query(returns => Menu, { description: 'To fetch a Menu' })
-  async menu(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Menu> {
-    const { domain } = context.state
-
-    return await getRepository(Menu).findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['roles']
-    })
-  }
-
-  @Query(returns => Menu, { description: 'To fetch a Menu by routing' })
-  async menuByRouting(@Arg('routing') routing: string, context) {
-    const { domain } = context.state
-
-    return await getRepository(Menu).findOne({
-      where: { domain: { id: domain.id }, routing }
-    })
-  }
-
-  @Query(returns => MenuList, { description: 'To fetch multiple Menus' })
-  async menus(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<MenuList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Menu),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => MenuList, { description: 'To fetch my own Menus' })
-  async myMenus(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<MenuList> {
-    const { domain, user } = context.state
-
-    const me = await getRepository(User).findOne({
-      where: { id: user.id },
-      relations: ['roles']
-    })
-
-    const roles = me.roles
-      .filter(role => role.domainId === domain.id || (domain.parentId && role.domainId === domain.parentId))
-      .map(role => role.id)
-
-    const [items, total] = await getQueryBuilderFromListParams({
-      repository: getRepository(Menu),
-      params,
-      domain,
-      alias: 'menu',
-      searchables: ['name', 'description']
-    })
-      .andWhere(
-        new Brackets(qb => {
-          qb.where('menu.role IN (:...roles)').orWhere('menu.role is null')
-        })
-      )
-      .setParameter('roles', roles)
-      .getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => MenuList, { description: 'To fetch Menus by role' })
-  async roleMenus(@Arg('roleId') roleId: string, @Ctx() context: ResolverContext) {
-    const { domain } = context.state
-
-    const menuRepo: Repository<Menu> = getRepository(Menu)
-    const menus: Menu[] = await menuRepo.find({
-      where: { domain: { id: domain.id } },
-      relations: ['parent', 'roles']
-    })
-    const role: Role = await getRepository(Role).findOne({ where: { domain: { id: domain.id }, id: roleId } })
-
-    let newChildMenus: Menu[] = []
-
-    menus.forEach(menu => {
-      if (menu.roles) {
-        const menuRoleIds = menu.roles.map(role => role.id)
-
-        if (menuRoleIds.includes(role.id)) {
-          newChildMenus.push(menu)
-        }
-      }
-    })
-
-    return { items: newChildMenus, total: newChildMenus.length }
-  }
-
-  @Query(returns => [Menu], { description: 'To fetch Menus by role' })
-  async userMenus(@Ctx() context: ResolverContext): Promise<Menu[]> {
-    const { domain, user } = context.state
-
-    var menus: Menu[] = []
-
-    try {
-      const qb: SelectQueryBuilder<User> = getRepository(User).createQueryBuilder('USER')
-      const user: User = await qb
-        .leftJoinAndSelect('USER.roles', 'ROLES')
-        .leftJoinAndSelect('ROLES.domain', 'ROLES_DOMAIN')
-        .where('USER.id = :userId', { userId: context.state.user.id })
-        .andWhere('ROLES_DOMAIN.id = :domainId', { domainId: context.state.domain.id })
-        .getOne()
-
-      // get menus which are non-restricted by any role.
-      menus.push(...(await getNonRestrictedMenus(context.state.domain)))
-
-      const userRoleIds: string[] = user.roles.map((role: Role) => role.id)
-      let restrictedMenus: Menu[] = []
-      if (userRoleIds?.length) {
-        // get menus which are restricted by role ()
-        restrictedMenus = [...(await getRestrictedMenus(userRoleIds, context.state.domain))]
-      }
-
-      const restrictedMenuIds: string[] = restrictedMenus.map((restrictedMenu: Menu) => restrictedMenu.id)
-      menus.forEach(menu => {
-        const idx = restrictedMenuIds.indexOf(menu.id)
-        if (idx !== -1) {
-          menu.children = Array.from(new Set([...restrictedMenus[idx].children, ...menu.children]))
-        }
-      })
-
-      return menus.filter((groupMenu: Menu) => groupMenu?.children?.length)
-    } catch (e) {
-      throw e
-    }
-  }
-
-  @FieldResolver(type => [Menu])
-  async children(
-    @Root() menu: Menu,
-    @Arg('permittedOnly', { defaultValue: false }) permittedOnly: boolean,
-    @Ctx() context: ResolverContext
-  ): Promise<Menu[]> {
-    if (!permittedOnly) {
-      return (
-        menu.children ||
-        (await getRepository(Menu).findBy({
-          parent: { id: menu.id }
-        }))
-      )
-    }
-
-    const { domain, user } = context.state
-
-    const me = await getRepository(User).findOne({
-      where: { id: user.id },
-      relations: ['roles']
-    })
-
-    const roles = me.roles
-      .filter(role => role.domainId === domain.id || (domain.parentId && role.domainId === domain.parentId))
-      .map(role => role.id)
-
-    return await getRepository(Menu)
-      .createQueryBuilder('menu')
-      .where('menu.parent = :parentId', { parentId: menu.id })
-      .andWhere(
-        new Brackets(qb => {
-          qb.where('menu.role IN (:...roles)').orWhere('menu.role is null')
-        })
-      )
-      .setParameter('roles', roles)
-      .getMany()
-  }
-
-  @FieldResolver(type => [MenuButton])
-  async buttons(@Root() menu: Menu): Promise<MenuButton[]> {
-    return await getRepository(MenuButton).findBy({
-      menu: { id: menu.id }
-    })
-  }
-
-  @FieldResolver(type => [MenuColumn])
-  async columns(@Root() menu: Menu): Promise<MenuColumn[]> {
-    return await getRepository(MenuColumn).findBy({
-      menu: { id: menu.id }
-    })
-  }
-
-  @FieldResolver(type => Role)
-  async role(@Root() menu: Menu) {
-    return menu.roleId && (await getRepository(Role).findOneBy({ id: menu.roleId }))
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() menu: Menu): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: menu.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() menu: Menu): Promise<User> {
-    return await getRepository(User).findOneBy({ id: menu.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() menu: Menu): Promise<User> {
-    return await getRepository(User).findOneBy({ id: menu.creatorId })
-  }
-}

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

@@ -1,78 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { Menu } from './menu'
-
-@InputType()
-export class NewMenu {
-  @Field() name: string
-  @Field() menuType: string
-
-  @Field({ nullable: true }) description?: string
-  @Field({ nullable: true }) category: string
-  @Field(type => Int, { nullable: true }) rank?: number
-  @Field({ nullable: true }) routing?: string
-  @Field({ nullable: true }) routingType?: string
-  @Field({ nullable: true }) resourceType?: string
-  @Field({ nullable: true }) resourceId?: string
-  @Field({ nullable: true }) resourceUrl?: string
-  @Field({ nullable: true }) resourceName?: string
-  @Field({ nullable: true }) idField?: string
-  @Field({ nullable: true }) titleField?: string
-  @Field({ nullable: true }) gridSaveUrl?: string
-  @Field({ nullable: true }) pagination?: boolean
-  @Field({ nullable: true }) detailFormId?: string
-  @Field({ nullable: true }) detailLayout?: string
-  @Field({ nullable: true }) template?: string
-  @Field({ nullable: true }) hiddenFlag?: boolean
-  @Field({ nullable: true }) itemsProp?: string
-  @Field({ nullable: true }) totalProp?: string
-  @Field(type => Int, { nullable: true }) fixedColumns?: number
-  @Field({ nullable: true }) iconPath?: string
-  @Field({ nullable: true }) role?: ObjectRef
-  @Field({ nullable: true }) parent?: ObjectRef
-  @Field(type => [ObjectRef], { nullable: true }) children?: ObjectRef[]
-  @Field(type => [ObjectRef], { nullable: true }) buttons?: ObjectRef[]
-  @Field(type => [ObjectRef], { nullable: true }) columns?: ObjectRef[]
-}
-
-@InputType()
-export class MenuPatch {
-  @Field(type => ID, { nullable: true }) id?: string
-  @Field({ nullable: true }) category?: string
-  @Field({ nullable: true }) name?: string
-  @Field({ nullable: true }) description?: string
-  @Field({ nullable: true }) menuType?: string
-  @Field(type => Int, { nullable: true }) rank?: number
-  @Field({ nullable: true }) routing?: string
-  @Field({ nullable: true }) routingType?: string
-  @Field({ nullable: true }) resourceType?: string
-  @Field({ nullable: true }) resourceId?: string
-  @Field({ nullable: true }) resourceUrl?: string
-  @Field({ nullable: true }) resourceName?: string
-  @Field({ nullable: true }) idField?: string
-  @Field({ nullable: true }) titleField?: string
-  @Field({ nullable: true }) gridSaveUrl?: string
-  @Field({ nullable: true }) pagination?: boolean
-  @Field({ nullable: true }) detailFormId?: string
-  @Field({ nullable: true }) detailLayout?: string
-  @Field({ nullable: true }) template?: string
-  @Field({ nullable: true }) hiddenFlag?: boolean
-  @Field({ nullable: true }) itemsProp?: string
-  @Field({ nullable: true }) totalProp?: string
-  @Field(type => Int, { nullable: true }) fixedColumns?: number
-  @Field({ nullable: true }) iconPath?: string
-  @Field({ nullable: true }) role?: ObjectRef
-  @Field({ nullable: true }) parent?: ObjectRef
-  @Field(type => [ObjectRef], { nullable: true }) children?: ObjectRef[]
-  @Field(type => [ObjectRef], { nullable: true }) buttons?: ObjectRef[]
-  @Field(type => [ObjectRef], { nullable: true }) columns?: ObjectRef[]
-  @Field({ nullable: true }) cuFlag?: string
-}
-
-@ObjectType()
-export class MenuList {
-  @Field(type => [Menu]) items: Menu[]
-  @Field(type => Int) total: number
-}