@drax/identity-back 0.0.9 → 0.0.11

package/src/errors/UnauthorizedError.ts

@@ -0,0 +1,13 @@
+class UnauthorizedError extends Error {
+    constructor() {
+        super('UNAUTHORIZED');
+        this.name = 'UnauthorizedError';
+    }
+
+    get statusCode(){
+        return 401
+    }
+
+}
+
+export default UnauthorizedError

package/src/factory/RoleServiceFactory.ts

@@ -1,10 +1,27 @@
 import RoleService from "../services/RoleService.js";
-import RoleRepository from "../repository/RoleRepository.js";
+import RoleMongoRepository from "../repository/mongo/RoleMongoRepository.js";
+import RoleSqliteRepository from "../repository/sqlite/RoleSqliteRepository.js";
+import {DbSetupUtils, DbEngine} from "../utils/DbSetupUtils.js";
+import type {IRoleRepository} from "../interfaces/IRoleRepository";
 
 const RoleServiceFactory = () : RoleService => {
-    const roleRepository = new RoleRepository
+
+    let roleRepository: IRoleRepository
+
+    switch (DbSetupUtils.getDbEngine()) {
+        case DbEngine.Mongo:
+            console.log("RoleServiceFactory DB ENGINE MONGODB")
+            roleRepository = new RoleMongoRepository()
+            break;
+        case DbEngine.Sqlite:
+            console.log("RoleServiceFactory DB ENGINE SQLITE")
+            roleRepository = new RoleSqliteRepository(process.env.SQLITE_DATABASE, false)
+            roleRepository.table()
+            break;
+    }
+
     const roleService = new RoleService(roleRepository)
     return roleService
 }
 
- export default RoleServiceFactory
+ export default RoleServiceFactory()

package/src/factory/UserServiceFactory.ts

@@ -1,10 +1,27 @@
-import UserRepository from "../repository/UserRepository.js";
+import UserMongoRepository from "../repository/mongo/UserMongoRepository.js";
 import UserService from "../services/UserService.js";
+import UserSqliteRepository from "../repository/sqlite/UserSqliteRepository.js";
+import process from "node:process";
+import {DbEngine, DbSetupUtils} from "../utils/DbSetupUtils.js";
+import {IUserRepository} from "../interfaces/IUserRepository";
 
 const UserServiceFactory = () : UserService => {
-    const userRepository = new UserRepository
+
+    let userRepository: IUserRepository
+    switch (DbSetupUtils.getDbEngine()) {
+        case DbEngine.Mongo:
+            console.log("UserServiceFactory DB ENGINE MONGODB")
+            userRepository = new UserMongoRepository()
+            break;
+        case DbEngine.Sqlite:
+            console.log("UserServiceFactory DB ENGINE SQLITE")
+            userRepository = new UserSqliteRepository(process.env.SQLITE_DATABASE,false)
+            userRepository.table()
+            break;
+    }
+
     const userService = new UserService(userRepository)
     return userService
 }
 
- export default UserServiceFactory
+ export default UserServiceFactory()

package/src/graphql/resolvers/role.resolvers.ts

@@ -1,25 +1,106 @@
 import RoleServiceFactory from "../../factory/RoleServiceFactory.js";
+import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
+import {ValidationError, ValidationErrorToGraphQLError} from "@drax/common-back";
+import {GraphQLError} from "graphql";
+import {PermissionService} from "../../services/PermissionService.js";
+import UnauthorizedError from "../../errors/UnauthorizedError.js";
 
-const roleService = RoleServiceFactory()
+const roleService = RoleServiceFactory
 export default {
     Query: {
-        findRoleById:  async (_,{id}) => {
-            return await roleService.findById(id)
+        findRoleById: async (_, {id}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.ViewRole)
+                return await roleService.findById(id)
+            } catch (e) {
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
         },
-        paginateRole: async () => {
-            return await roleService.paginate()
+        fetchRole: async (_, {}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.ViewRole)
+                return await roleService.fetchAll()
+            } catch (e) {
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+        },
+        fetchPermissions: async (_, {}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.PermissionsRole)
+                return PermissionService.getPermissions()
+            } catch (e) {
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+        },
+        paginateRole: async (_, {page, limit, seach}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.ViewRole)
+                return await roleService.paginate(page, limit, seach)
+            } catch (e) {
+                console.error("paginateRole",e)
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
         }
     },
     Mutation: {
-        createRole: async (_,{input}) => {
-            return await roleService.create(input)
+        createRole: async (_, {input}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.CreateRole)
+                return await roleService.create(input)
+            } catch (e) {
+                console.error("createRole",e)
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
 
         },
-        updateRole: async (_,{id, input}) => {
-            return await roleService.update(id, input)
+        updateRole: async (_, {id, input}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.UpdateRole)
+                return await roleService.update(id, input)
+            } catch (e) {
+                console.error("updateRole",e)
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
         },
-        deleteRole: async (_,{id}) => {
-            return await roleService.delete(id)
+        deleteRole: async (_, {id}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.DeleteRole)
+                return await roleService.delete(id)
+            } catch (e) {
+                console.error("deleteRole",e)
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+
         }
     }
 }

package/src/graphql/resolvers/user.resolvers.ts

@@ -1,27 +1,140 @@
 import UserServiceFactory from "../../factory/UserServiceFactory.js";
+import {GraphQLError} from "graphql";
+import {ValidationErrorToGraphQLError, ValidationError} from "@drax/common-back";
+import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
+import UnauthorizedError from "../../errors/UnauthorizedError.js";
+import BadCredentialsError from "../../errors/BadCredentialsError.js";
+
+const userService = UserServiceFactory
 
-const userService = UserServiceFactory()
 export default {
     Query: {
-        findUserById:  async (_,{id}) => {
-            return await userService.findById(id)
+        me: async (_, {}, {authUser}) => {
+            try {
+                if (authUser) {
+                    let user = await userService.findById(authUser.id)
+                    delete user.password
+                    return user
+                }
+                throw new UnauthorizedError()
+            } catch (e) {
+                console.log(e)
+                throw new GraphQLError(e.message)
+            }
+
+        },
+        findUserById: async (_, {id}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.ViewUser)
+                return await userService.findById(id)
+            } catch (e) {
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+
         },
-        paginateUser: async () => {
-            console.log("paginateUser")
-            return await userService.paginate()
+        paginateUser: async (_, {page, limit, search}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.ViewUser)
+                return await userService.paginate(page, limit, search)
+            } catch (e) {
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
         }
     },
     Mutation: {
-        createUser: async (_,{input}) => {
-            console.log("createUser")
-            const user =  await userService.create(input)
-            return user
+        auth: async (_, {input}) => {
+            try {
+                return await userService.auth(input.username, input.password)
+            } catch (e) {
+                console.error("auth", e)
+                if (e instanceof BadCredentialsError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+
         },
-        updateUser: async (_,{id, input}) => {
-            return await userService.update(id, input)
+        createUser: async (_, {input}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.CreateUser)
+                const user = await userService.create(input)
+                return user
+            } catch (e) {
+                console.error("createUser", e)
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                } else if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+
         },
-        deleteUser: async (_,{id}) => {
-            return await userService.delete(id)
-        }
+        updateUser: async (_, {id, input}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.UpdateUser)
+
+                const user = await userService.update(id, input)
+                return user
+            } catch (e) {
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                } else if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+        },
+        deleteUser: async (_, {id}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.DeleteUser)
+                return await userService.delete(id)
+            } catch (e) {
+                console.error("deleteUser", e)
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                } else if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+        },
+        changeOwnPassword: async (_, {currentPassword, newPassword}, {authUser}) => {
+            try {
+                if (!authUser) {
+                    throw new UnauthorizedError()
+                }
+                let userId = authUser.id
+                return await userService.changeOwnPassword(userId, currentPassword, newPassword)
+            } catch (e) {
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                } else if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+        },
+        changeUserPassword: async (_, {userId, newPassword}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.UpdateUser)
+
+                return await userService.changeUserPassword(userId, newPassword)
+            } catch (e) {
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                } else if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+        },
+
     }
 }

package/src/graphql/types/role.graphql

@@ -1,5 +1,5 @@
 type Role {
-    _id: ID!
+    id: ID!
     name: String
     readonly: Boolean
     childRoles: [Role]
@@ -7,14 +7,16 @@ type Role {
 }
 
 type RolePaginated{
-    totalDocs: Int
+    total: Int
     page: Int
     limit: Int
-    docs: [Role]
+    items: [Role]
 }
 
 type Query{
-    paginateRole: RolePaginated
+    paginateRole(page:Int, limit:Int, search:String): RolePaginated
+    fetchRole: [Role]
+    fetchPermissions: [String]
     findRoleById(id: ID): Role
 }
 

package/src/graphql/types/user.graphql

@@ -1,34 +1,61 @@
 type User {
-    _id: ID!
+    id: ID!
     username: String!
+    name: String
     email: String
     role: Role
     phone: String
-
+    avatar: String
+    active: Boolean
 }
 
 type UserPaginated{
-    totalDocs: Int
+    total: Int
     page: Int
     limit: Int
-    docs: [User]
+    items: [User]
 }
 
 type Query{
+    me: User
     findUserByUsername(username: String!): User
     findUserById(id: ID!): User
-    paginateUser: UserPaginated
+    paginateUser(page: Int, limit: Int, search: String): UserPaginated
 }
 
-input UserInput{
+input UserCreateInput{
+    name: String
     username: String!
-    email: String!
     password: String!
     role: ID
+    email: String!
+    phone: String
+    active: Boolean
+}
+
+input UserUpdateInput{
+    name: String
+    username: String!
+    role: ID
+    email: String!
+    phone: String
+    active: Boolean
+}
+
+type Auth{
+    accessToken: String
+}
+
+input AuthInput{
+    username: String!
+    password: String!
 }
 
 type Mutation{
-    createUser(input: UserInput): User
-    updateUser(id: ID!, input: UserInput): User
+    auth(input: AuthInput): Auth
+    createUser(input: UserCreateInput): User
+    updateUser(id: ID!, input: UserUpdateInput): User
     deleteUser(id: ID!): Boolean
+    changeOwnPassword(currentPassword:String!, newPassword: String!): Boolean
+    changeUserPassword(userId:ID!, newPassword:String!): Boolean
 }

package/src/index.ts

@@ -1,30 +1,70 @@
 import GraphqlMerge from "./graphql/index.js"
 import UserServiceFactory from "./factory/UserServiceFactory.js";
 import RoleServiceFactory from "./factory/RoleServiceFactory.js";
-import AuthServiceFactory from "./factory/AuthServiceFactory.js";
-import {authRoutes} from "./routes/authRoutes.js";
+import RoleService from "./services/RoleService.js";
+import UserService from "./services/UserService.js";
+import PermissionService from "./services/PermissionService.js";
+import Rbac from "./rbac/Rbac.js";
+import {UserRoutes} from "./routes/UserRoutes.js";
+import {RoleRoutes} from "./routes/RoleRoutes.js";
+import AuthUtils from "./utils/AuthUtils.js";
+import {jwtMiddleware} from "./middleware/jwtMiddleware.js";
+import {rbacMiddleware} from "./middleware/rbacMiddleware.js";
+
+import IdentityPermissions from "./permissions/IdentityPermissions.js";
+import UnauthorizedError from "./errors/UnauthorizedError.js";
+import BadCredentialsError from "./errors/BadCredentialsError.js";
+
+import type {IJwtUser} from "./interfaces/IJwtUser";
+import type {IRole, IRoleBase} from "./interfaces/IRole";
+import type {IUser} from "./interfaces/IUser";
+import type {IUserRepository} from "./interfaces/IUserRepository";
+import type {IRoleRepository} from "./interfaces/IRoleRepository";
 
 const graphqlMergeResult = await GraphqlMerge()
 const identityTypeDefs = await graphqlMergeResult.typeDefs;
 const identityResolvers = await graphqlMergeResult.resolvers;
 
-const userService = UserServiceFactory()
-const roleService = RoleServiceFactory()
-
-const authService = AuthServiceFactory()
+export type {
+    IJwtUser,
+    IRole,
+    IRoleBase,
+    IRoleRepository,
+    IUser,
+    IUserRepository
+}
 
 export {
     //Service
-    userService,
-    roleService,
-    authService,
+    UserService,
+    RoleService,
+    PermissionService,
+    Rbac,
+
+    //Factories
+    UserServiceFactory,
+    RoleServiceFactory,
 
     //GQL
     identityTypeDefs,
     identityResolvers,
 
     //API REST
-    authRoutes
+    UserRoutes,
+    RoleRoutes,
+
+    AuthUtils,
+
+    //API MIDDLEWARE
+    jwtMiddleware,
+    rbacMiddleware,
+
+    //Permissions
+    IdentityPermissions,
+
+    //Errors
+    UnauthorizedError,
+    BadCredentialsError
 }
 
 

package/src/interfaces/IID.ts

@@ -0,0 +1,5 @@
+import {mongoose} from "@drax/common-back";
+import {UUID} from "crypto";
+
+export type IID = mongoose.Types.ObjectId | UUID | string | number;
+

package/src/interfaces/IJwtUser.ts

@@ -0,0 +1,7 @@
+interface IJwtUser {
+    id: string
+    username: string;
+    roleId: string
+}
+
+export {IJwtUser}

package/src/interfaces/IRole.ts

@@ -1,11 +1,21 @@
 import {mongoose} from "@drax/common-back";
+import {IID} from "./IID";
 
-interface IRole{
-    _id?: mongoose.Types.ObjectId
+type IPermissions = string[] | string;
+
+interface IRoleBase{
+    id: IID
     name: string
     permissions: string[]
-    childRoles?: mongoose.Types.ObjectId[]
-    readonly: boolean
 }
 
-export {IRole}
+interface IRole{
+    id?: IID
+    name: string
+    permissions: IPermissions
+    childRoles?: mongoose.Types.ObjectId[] | string
+    readonly: boolean | number
+}
+
+
+export {IRole, IRoleBase, IPermissions}

package/src/interfaces/IRoleRepository.ts

@@ -1,11 +1,14 @@
 import {IRole} from './IRole'
+import {IPaginateFilter, IPaginateResult} from "@drax/common-back";
+import {IID} from "./IID";
 interface IRoleRepository{
     create(role: IRole): Promise<IRole>;
-    update(_id: any, updatedRole: IRole): Promise<IRole | null>;
-    delete(_id: any): Promise<boolean>;
-    findById(_id: any): Promise<IRole | null>;
-
-    paginate(query: any, options: any): any;
+    update(id: IID, updatedRole: IRole): Promise<IRole | null>;
+    delete(id: IID): Promise<boolean>;
+    findById(id: IID): Promise<IRole | null>;
+    fetchAll(): Promise<IRole[]>;
+    paginate(page?: number, limit?: number, search?:string, filters?: IPaginateFilter[]): Promise<IPaginateResult>;
+    table?():void
 }
 
 export {IRoleRepository}

package/src/interfaces/IUser.ts

@@ -1,21 +1,45 @@
 import {mongoose} from "@drax/common-back";
 import {IRole} from "./IRole";
 import {IUserGroup} from "./IUserGroup";
+import {IID} from "./IID";
 
 interface IUser {
-    _id?: mongoose.Types.ObjectId
+    id?: IID
     username: string
     email: string
     password: string
-    active: boolean
+    active: boolean | number
     name?: string
     phone?: string
     avatar?: string
-    avatarurl?: string
     code?: string
-    role: mongoose.Types.ObjectId | IRole
-    groups: mongoose.Types.ObjectId[] | IUserGroup[]
+    role: IRole | IID
+    groups: IID[] | IUserGroup[] | string[] | string
+    toObject(): IUser;
+}
+
+interface IUserCreate {
+    id?: IID
+    name: string
+    username: string
+    password: string
+    email: string
+    active: boolean | number
+    phone: string
+    role: IID
+    groups: IID[] | string
+}
 
+interface IUserUpdate {
+    id?: IID
+    name: string
+    username: string
+    email: string
+    active: boolean
+    phone: string
+    role: IID
+    groups: IID[]
+    password?: string
 }
 
-export {IUser}
+export {IUser, IUserCreate, IUserUpdate}

package/src/interfaces/IUserGroup.ts

@@ -1,8 +1,9 @@
 import {mongoose} from "@drax/common-back";
 import {IUser} from "./IUser";
+import {IID} from "./IID";
 
 interface IUserGroup{
-    _id?: mongoose.Types.ObjectId
+    id?: IID
     name: string
     users: mongoose.Types.ObjectId[] | IUser[]
 }