@drax/identity-back 0.0.8 → 0.0.10

package/dist/errors/BadCredentialsError.js

@@ -0,0 +1,10 @@
+class BadCredentialsError extends Error {
+    constructor() {
+        super('error.badCredentials');
+        this.name = 'BadCredentialsError';
+    }
+    get statusCode() {
+        return 401;
+    }
+}
+export default BadCredentialsError;

package/dist/errors/UnauthorizedError.js

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

package/dist/factory/RoleServiceFactory.js

@@ -1,8 +1,21 @@
 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";
 const RoleServiceFactory = () => {
-    const roleRepository = new RoleRepository;
+    let roleRepository;
+    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/dist/factory/UserServiceFactory.js

@@ -1,8 +1,22 @@
-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";
 const UserServiceFactory = () => {
-    const userRepository = new UserRepository;
+    let userRepository;
+    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/dist/graphql/resolvers/role.resolvers.js

@@ -1,23 +1,110 @@
 import RoleServiceFactory from "../../factory/RoleServiceFactory.js";
-const roleService = RoleServiceFactory();
+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;
 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/dist/graphql/resolvers/user.resolvers.js

@@ -1,26 +1,145 @@
 import UserServiceFactory from "../../factory/UserServiceFactory.js";
-const userService = UserServiceFactory();
+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;
 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);
+            }
         },
-        paginateUser: async () => {
-            console.log("paginateUser");
-            return await userService.paginate();
+        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 (_, { 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');
+            }
+        },
+        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');
+            }
         },
-        deleteUser: async (_, { id }) => {
-            return await userService.delete(id);
-        }
     }
 };

package/dist/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/dist/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/dist/i18n/messages/validation-i18n.js

@@ -0,0 +1,21 @@
+const messages = {
+    en: {
+        validation: {
+            required: "{field} is required",
+            minCharacteres: "{field} must be more than {min} characters",
+            maxCharacteres: "{field} must be less than {max} characters",
+            email: "{field} is not a valid email",
+            unique: "{field} must be unique",
+        }
+    },
+    es: {
+        validation: {
+            required: "{field} es requerido",
+            minCharacteres: "{field} debe tener mas de {min} caracteres",
+            maxCharacteres: "{field} debe tener menos de {max} caracteres",
+            email: "{field} no es un email valido",
+            unique: "{field} debe ser unico",
+        }
+    }
+};
+export default messages;

package/dist/index.js

@@ -1,19 +1,34 @@
 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";
 const graphqlMergeResult = await GraphqlMerge();
 const identityTypeDefs = await graphqlMergeResult.typeDefs;
 const identityResolvers = await graphqlMergeResult.resolvers;
-const userService = UserServiceFactory();
-const roleService = RoleServiceFactory();
-const authService = AuthServiceFactory();
 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 };
 /// <reference types="index.d.ts" />

package/dist/interfaces/IID.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IJwtUser.js

@@ -0,0 +1 @@
+export {};

package/dist/middleware/jwtMiddleware.js

@@ -0,0 +1,19 @@
+import AuthUtils from "../utils/AuthUtils.js";
+function jwtMiddleware(request, reply, done) {
+    try {
+        const token = request.headers?.authorization?.replace(/Bearer /i, "");
+        if (token) {
+            const authUser = AuthUtils.verifyToken(token);
+            if (authUser) {
+                request.authUser = authUser;
+            }
+        }
+        done();
+    }
+    catch (e) {
+        console.error(e);
+        reply.code(401).send({ error: 'Token JWT inválido' });
+    }
+}
+export default jwtMiddleware;
+export { jwtMiddleware };

package/dist/middleware/rbacMiddleware.js

@@ -0,0 +1,36 @@
+import { DraxCache } from "@drax/common-back";
+import RoleServiceFactory from "../factory/RoleServiceFactory.js";
+import Rbac from "../rbac/Rbac.js";
+const cacheTTL = process.env.RBAC_CACHE_TTL ? parseInt(process.env.RBAC_CACHE_TTL) : 10000;
+const draxCache = new DraxCache(cacheTTL);
+const roleService = RoleServiceFactory;
+async function roleLoader(k) {
+    const role = await roleService.findById(k);
+    if (role) {
+        return { id: role.id, name: role.name, permissions: role.permissions };
+    }
+    return null;
+}
+async function rbacMiddleware(request, reply) {
+    try {
+        //console.log("rbacMiddleware authUser",request.authUser)
+        if (request.authUser) {
+            const authUser = request.authUser;
+            const cacheKey = authUser.roleId;
+            const role = await draxCache.getOrLoad(cacheKey, roleLoader);
+            const rbac = new Rbac(authUser, role);
+            request.rbac = rbac;
+        }
+        else {
+            const rbac = new Rbac(null, null);
+            request.rbac = rbac;
+        }
+        return;
+    }
+    catch (e) {
+        console.error(e);
+        reply.code(500).send({ error: 'RBAC ERROR' });
+    }
+}
+export default rbacMiddleware;
+export { rbacMiddleware };

package/dist/models/RoleModel.js

@@ -5,14 +5,6 @@ const Schema = mongoose.Schema;
 const RoleSchema = new Schema({
     name: {
         type: String, unique: true, required: true, index: true,
-        validate: [
-            {
-                validator: function (v) {
-                    return !/(\s){2}/.test(v);
-                },
-                message: props => `Role name cant contain two spaces`
-            },
-        ],
     },
     permissions: [{ type: String, required: true }],
     childRoles: [{

package/dist/models/UserModel.js

@@ -45,7 +45,6 @@ const UserSchema = new mongoose.Schema({
         }
     },
     avatar: { type: String, required: false },
-    avatarurl: { type: String, required: false },
     role: {
         type: mongoose.Schema.Types.ObjectId,
         ref: 'Role',
@@ -65,7 +64,7 @@ const UserSchema = new mongoose.Schema({
               }
           ],
           default: [],
-          _id: false
+          id: false
       }*/
 }, { timestamps: true });
 UserSchema.set('toJSON', { getters: true });

package/dist/permissions/IdentityPermissions.js

@@ -0,0 +1,16 @@
+var IdentityPermissions;
+(function (IdentityPermissions) {
+    IdentityPermissions["CreateUser"] = "user:create";
+    IdentityPermissions["UpdateUser"] = "user:update";
+    IdentityPermissions["DeleteUser"] = "user:delete";
+    IdentityPermissions["ViewUser"] = "user:view";
+    IdentityPermissions["ManageUser"] = "user:manage";
+    IdentityPermissions["CreateRole"] = "role:create";
+    IdentityPermissions["UpdateRole"] = "role:update";
+    IdentityPermissions["DeleteRole"] = "role:delete";
+    IdentityPermissions["ViewRole"] = "role:view";
+    IdentityPermissions["ManageRole"] = "role:manage";
+    IdentityPermissions["PermissionsRole"] = "role:permissions";
+})(IdentityPermissions || (IdentityPermissions = {}));
+export default IdentityPermissions;
+export { IdentityPermissions };

package/dist/rbac/Rbac.js

@@ -0,0 +1,20 @@
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+class Rbac {
+    constructor(authUser, role) {
+        this.authUser = authUser;
+        this.role = role;
+    }
+    hasPermission(requiredPermission) {
+        if (!this.authUser || !this.role || !this.role.permissions || this.role.permissions.length === 0) {
+            return false;
+        }
+        return this.role.permissions.includes(requiredPermission);
+    }
+    assertPermission(requiredPermission) {
+        if (!this.hasPermission(requiredPermission)) {
+            throw new UnauthorizedError();
+        }
+    }
+}
+export default Rbac;
+export { Rbac };