@things-factory/auth-base 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,7 @@
+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]