@things-factory/auth-base 8.0.0-beta.1 → 8.0.0-beta.4

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

@@ -1,109 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-
-import { getRepository } from '@things-factory/shell'
-
-import { Privilege } from '../privilege/privilege'
-import { User } from '../user/user'
-import { Role } from './role'
-import { NewRole, RolePatch } from './role-types'
-
-@Resolver(Role)
-export class RoleMutation {
-  @Directive('@privilege(category: "user", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => User, { description: 'To create new user' })
-  async createRole(@Arg('role') role: NewRole, @Ctx() context: ResolverContext): Promise<Role> {
-    const { domain, user } = context.state
-    const roleName = role.name.trim()
-
-    const existsRole: Role = await getRepository(Role).findOne({ where: { name: roleName, domain: { id: domain.id } } })
-
-    if (existsRole) {
-      throw new Error('role name is duplicated')
-    }
-
-    if (role.privileges && role.privileges.length) {
-      role.privileges = await getRepository(Privilege).findByIds(role.privileges.map(privilege => privilege.id))
-    }
-
-    if (role.users && role.users.length) {
-      role.users = await getRepository(User).findByIds(role.users.map(user => user.id))
-    }
-
-    return await getRepository(Role).save({
-      domain,
-      updater: user,
-      creator: user,
-      ...role
-    })
-  }
-
-  @Directive('@privilege(category: "user", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Role, { description: 'To modify role information' })
-  async updateRole(
-    @Arg('id') id: string,
-    @Arg('patch') patch: RolePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Role> {
-    const { domain, user } = context.state
-    const { name, description, privileges } = patch
-    const roleRepository = getRepository(Role)
-    const role: Role = await roleRepository.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['privileges', 'creator', 'updater']
-    })
-
-    if (name && role.name !== name) {
-      const roleName = name.trim()
-      const existsRole: Role = await roleRepository.findOne({ where: { name: roleName, domain: { id: domain.id } } })
-      if (existsRole) {
-        throw new Error('role name is duplicated')
-      }
-
-      role.name = roleName
-    }
-
-    if (description) {
-      role.description = description
-    }
-
-    return await roleRepository.save({
-      ...role,
-      ...patch,
-      privileges: await getRepository(Privilege).findByIds(
-        patch.privileges.map((privilege: Privilege) => privilege.id)
-      ),
-      updater: user
-    } as any)
-  }
-
-  @Directive('@privilege(category: "user", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete role' })
-  async deleteRole(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { tx, domain } = context.state
-    let role: Role = await tx
-      .getRepository(Role)
-      .findOne({ where: { domain: { id: domain.id }, id }, relations: ['users', 'privileges'] })
-
-    try {
-      if (role.users.length) throw new Error('cannot delete role because it is currently in use')
-
-      role.privileges = []
-
-      role = await tx.getRepository(Role).save(role)
-
-      await tx.getRepository(Role).delete(role.id)
-
-      return true
-    } catch (e) {
-      context.throw(401, 'cannot delete role because it is currently in use')
-    }
-  }
-
-  @Directive('@privilege(category: "user", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete multiple roles' })
-  async deleteRoles(@Arg('ids', type => [String]) ids: string[], @Ctx() _context: any) {
-    await getRepository(Role).delete(ids)
-    return true
-  }
-}

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

@@ -1,155 +0,0 @@
-import { In } from 'typeorm'
-import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { SelectQueryBuilder } from 'typeorm'
-
-import { config } from '@things-factory/env'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { Privilege } from '../privilege/privilege'
-import { User } from '../user/user'
-import { Role } from './role'
-import { RoleList, RolePrivilege, UserRole } from './role-types'
-
-@Resolver(Role)
-export class RoleQuery {
-  @Directive('@privilege(category: "user", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => Role, { description: 'To fetch role' })
-  async role(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Role> {
-    const { domain } = context.state
-    return await getRepository(Role).findOneBy({
-      domain: { id: In([domain.id, domain.parentId].filter(Boolean)) },
-      name
-    })
-  }
-
-  @Directive('@privilege(category: "user", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => RoleList, { description: 'To fetch multiple users' })
-  async roles(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<RoleList> {
-    const { domain } = context.state
-
-    const [items, total] = await getQueryBuilderFromListParams({
-      repository: getRepository(Role),
-      params,
-      domain,
-      searchables: ['name', 'description']
-    }).getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Directive('@privilege(category: "user", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => [RolePrivilege], { description: 'To fetch privileges of a role' })
-  async rolePrivileges(@Arg('roleId') roleId: string, @Ctx() context: ResolverContext): Promise<RolePrivilege[]> {
-    const rolePrivileges = await getRepository(Privilege).query(
-      `
-        SELECT
-          id,
-          name,
-          category,
-          description,
-          CASE WHEN id IN (
-            SELECT
-              P.id
-            FROM
-              privileges P JOIN roles_privileges RP
-            ON
-              P.id = RP.privileges_id
-            WHERE
-              RP.roles_id = '${roleId}'
-          ) THEN true
-            ELSE false
-          END AS assigned
-        FROM
-          privileges
-      `
-    )
-
-    return rolePrivileges
-  }
-
-  @Directive('@privilege(category: "user", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => [UserRole], { description: 'To fetch roles of a user' })
-  async userRoles(@Arg('userId') userId: string, @Ctx() context: ResolverContext): Promise<UserRole[]> {
-    const userRoles = await getRepository(Role).query(
-      `
-        SELECT
-          id,
-          name,
-          description,
-          CASE WHEN id IN (
-            SELECT
-              R.id
-            FROM
-              roles R JOIN users_roles UR
-            ON
-              R.id = UR.roles_id
-            WHERE
-              UR.users_id = '${userId}'
-          ) THEN true
-            ELSE false
-          END AS assigned
-        FROM
-          roles
-      `
-    )
-
-    return userRoles
-  }
-
-  @Query(returns => [Role], { description: 'To fetch roles of current user' })
-  async myRoles(@Ctx() context: ResolverContext): Promise<Role[]> {
-    const { user, domain } = context.state
-
-    const qb: SelectQueryBuilder<User> = await getRepository(User).createQueryBuilder('USER')
-    const { roles }: User = await qb
-      .leftJoinAndSelect('USER.roles', 'ROLE')
-      .leftJoin('ROLE.domain', 'ROLE_DOMAIN')
-      .where('USER.id = :userId', { userId: user.id })
-      .andWhere('ROLE_DOMAIN.id In(:...domainIds)', { domainIds: [domain.id, domain.parentId].filter(Boolean) })
-      .getOne()
-
-    return roles || []
-  }
-
-  @Query(returns => [Role], { description: 'To fetch the preset of role for new user' })
-  async checkRolePreset(@Ctx() context: ResolverContext): Promise<Role[]> {
-    const rolePreset = config.get('rolePreset') || []
-
-    return rolePreset
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() role: Role) {
-    return await getRepository(Domain).findOneBy({ id: role.domainId })
-  }
-
-  @FieldResolver(type => [User])
-  async users(@Root() role: Role) {
-    return (
-      await getRepository(Role).findOne({
-        where: { id: role.id },
-        relations: ['users']
-      })
-    ).users
-  }
-
-  @FieldResolver(type => [Privilege])
-  async privileges(@Root() role: Role) {
-    return (
-      await getRepository(Role).findOne({
-        where: { id: role.id },
-        relations: ['privileges']
-      })
-    ).privileges
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() role: Role): Promise<User> {
-    return await getRepository(User).findOneBy({ id: role.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() role: Role): Promise<User> {
-    return await getRepository(User).findOneBy({ id: role.creatorId })
-  }
-}

package/server/service/role/role-types.ts

@@ -1,81 +0,0 @@
-import { ObjectType, InputType, Field, Int } from 'type-graphql'
-import { ObjectRef } from '@things-factory/shell'
-import { Role } from './role'
-
-@InputType()
-export class NewRole {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => [ObjectRef], { nullable: true })
-  users?: ObjectRef[]
-
-  @Field(type => [ObjectRef], { nullable: true })
-  privileges?: ObjectRef[]
-}
-
-@InputType()
-export class RolePatch {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => [ObjectRef], { nullable: true })
-  users?: ObjectRef[]
-
-  @Field(type => [ObjectRef], { nullable: true })
-  privileges?: ObjectRef[]
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class RoleList {
-  @Field(type => [Role], { nullable: true })
-  items?: Role[]
-
-  @Field(type => Int, { nullable: true })
-  total?: number
-}
-
-@ObjectType()
-export class RolePrivilege {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  category?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  assigned?: boolean
-}
-
-@ObjectType()
-export class UserRole {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  assigned?: boolean
-}

package/server/service/role/role.ts

@@ -1,72 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  JoinTable,
-  ManyToMany,
-  ManyToOne,
-  RelationId,
-  PrimaryGeneratedColumn,
-  UpdateDateColumn
-} from 'typeorm'
-import { ObjectType, Field, ID } from 'type-graphql'
-import { Privilege } from '../privilege/privilege'
-import { User } from '../user/user'
-
-@Entity()
-@Index('ix_role_0', (role: Role) => [role.name, role.domain], { unique: true })
-@ObjectType()
-export class Role {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((role: Role) => role.domain)
-  domainId: string
-
-  @Column()
-  @Field({ nullable: true })
-  name: string
-
-  @ManyToMany(type => User, user => user.roles)
-  @Field(type => [User], { nullable: true })
-  users: User[]
-
-  @ManyToMany(type => Privilege, privilege => privilege.roles)
-  @Field(type => [Privilege], { nullable: true })
-  privileges: Privilege[]
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator: User
-
-  @RelationId((role: Role) => role.creator)
-  creatorId: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater: User
-
-  @RelationId((role: Role) => role.updater)
-  updaterId: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt: Date
-}

package/server/service/user/domain-query.ts

@@ -1,24 +0,0 @@
-import { FieldResolver, Resolver, Root } from 'type-graphql'
-
-import { Domain, getRepository } from '@things-factory/shell'
-import { User } from './user'
-
-@Resolver(Domain)
-export class DomainQuery {
-  @FieldResolver(type => User, { nullable: true })
-  async ownerUser(@Root() domain: Domain): Promise<User | null> {
-    if (!domain.owner) {
-      return
-    }
-
-    const owner = await getRepository(User).findOne({
-      where: { id: domain.owner }
-    })
-
-    if (owner && owner.userType !== 'user' && owner.userType !== 'admin') {
-      throw 'the type of the given user is not suitable for a owner of a domain'
-    }
-
-    return owner
-  }
-}

package/server/service/user/index.ts

@@ -1,7 +0,0 @@
-import { User } from './user'
-import { UserQuery } from './user-query'
-import { UserMutation } from './user-mutation'
-import { DomainQuery } from './domain-query'
-
-export const entities = [User]
-export const resolvers = [UserQuery, UserMutation, DomainQuery]