@drax/identity-back 0.0.9 → 0.0.10

package/dist/routes/UserRoutes.js

@@ -0,0 +1,199 @@
+import UserServiceFactory from "../factory/UserServiceFactory.js";
+import { 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;
+async function UserRoutes(fastify, options) {
+    fastify.post('/api/auth', async (request, reply) => {
+        try {
+            const username = request.body.username;
+            const password = request.body.password;
+            return await userService.auth(username, password);
+        }
+        catch (e) {
+            console.error('/api/auth error', e);
+            if (e instanceof BadCredentialsError) {
+                reply.code(401);
+                reply.send({ error: e.message });
+            }
+            reply.code(500);
+            reply.send({ error: 'error.server' });
+        }
+    });
+    fastify.get('/api/me', async (request, reply) => {
+        try {
+            if (request.authUser) {
+                let user = await userService.findById(request.authUser.id);
+                delete user.password;
+                return user;
+            }
+            else {
+                throw new UnauthorizedError();
+            }
+        }
+        catch (e) {
+            if (e instanceof UnauthorizedError) {
+                reply.code(401);
+                reply.send({ error: "Unauthorized" });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.get('/api/users', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewUser);
+            const page = request.query.page;
+            const limit = request.query.limit;
+            const search = request.query.search;
+            let paginateResult = await userService.paginate(page, limit, search);
+            return paginateResult;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.post('/api/users', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.CreateUser);
+            const payload = request.body;
+            let user = await userService.create(payload);
+            return user;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.put('/api/users/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateUser);
+            const id = request.params.id;
+            const payload = request.body;
+            let user = await userService.update(id, payload);
+            return user;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.delete('/api/users/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.DeleteUser);
+            const id = request.params.id;
+            let r = await userService.delete(id);
+            return r;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.post('/api/password', async (request, reply) => {
+        try {
+            if (!request.authUser) {
+                throw new UnauthorizedError();
+            }
+            const userId = request.authUser.id;
+            const currentPassword = request.body.currentPassword;
+            const newPassword = request.body.newPassword;
+            return await userService.changeOwnPassword(userId, currentPassword, newPassword);
+        }
+        catch (e) {
+            console.error('/api/password error', e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.post('/api/password/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateUser);
+            const userId = request.params.id;
+            if (!userId) {
+                throw new UnauthorizedError();
+            }
+            const newPassword = request.body.newPassword;
+            return await userService.changeUserPassword(userId, newPassword);
+        }
+        catch (e) {
+            console.error('/api/password error', e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+}
+export default UserRoutes;
+export { UserRoutes };

package/dist/routes/authRoutes.js

@@ -1,21 +1,29 @@
-import AuthServiceFactory from "../factory/AuthServiceFactory.js";
-const authService = AuthServiceFactory();
+import UserServiceFactory from "../factory/UserServiceFactory.js";
+const userService = UserServiceFactory();
 async function authRoutes(fastify, options) {
     fastify.post('/api/auth', async (request, reply) => {
         try {
             const username = request.body.username;
             const password = request.body.password;
-            return await authService.auth(username, password);
+            console.log("/api/auth username", username);
+            return await userService.auth(username, password);
         }
         catch (e) {
             if (e.message === "BadCredentials") {
                 reply.code(401);
                 reply.send({ error: e.message });
             }
-            console.log(e);
+            console.error(e);
             throw e;
         }
     });
+    fastify.get('/api/me', async (request, reply) => {
+        console.log("/api/me request.authUser:", request.authUser);
+        let user = await userService.findById(request.authUser.id);
+        user = user.toObject();
+        delete user.password;
+        return user;
+    });
 }
 export default authRoutes;
 export { authRoutes };

package/dist/services/AuthService.js

@@ -1,21 +1,6 @@
-import AuthUtils from "../utils/AuthUtils.js";
 class AuthService {
     constructor(userService) {
         this._userService = userService;
     }
-    async auth(username, password) {
-        let user = null;
-        user = await this._userService.findByUsername(username);
-        //Si obtuve usuario chequeo la password
-        if (user && AuthUtils.checkPassword(password, user.password)) {
-            //TODO: Generar Sesion
-            const session = '123';
-            const accessToken = AuthUtils.generateToken(user._id.toString(), user.username, session);
-            return { accessToken: accessToken };
-        }
-        else {
-            throw Error('BadCredentials');
-        }
-    }
 }
 export default AuthService;

package/dist/services/PermissionService.js

@@ -0,0 +1,19 @@
+const permissions = [];
+class PermissionService {
+    static addPermission(permission) {
+        if (PermissionService.hasPermission(permission))
+            return;
+        permissions.push(permission);
+    }
+    static removePermission(permission) {
+        permissions.splice(permissions.indexOf(permission), 1);
+    }
+    static hasPermission(permission) {
+        return permissions.includes(permission);
+    }
+    static getPermissions() {
+        return permissions;
+    }
+}
+export default PermissionService;
+export { PermissionService };

package/dist/services/RoleService.js

@@ -1,30 +1,62 @@
+import { ValidationError, ZodErrorToValidationError } from "@drax/common-back";
+import { roleSchema } from "../zod/RoleZod.js";
+import { ZodError } from "zod";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
 class RoleService {
     constructor(roleRepostitory) {
         this._repository = roleRepostitory;
+        console.log("RoleService constructor");
     }
     async create(roleData) {
-        const role = await this._repository.create(roleData);
-        return role;
+        try {
+            roleData.name = roleData?.name?.trim();
+            await roleSchema.parseAsync(roleData);
+            const role = await this._repository.create(roleData);
+            return role;
+        }
+        catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, roleData);
+            }
+            throw e;
+        }
     }
-    async update(_id, roleData) {
-        const role = await this._repository.update(_id, roleData);
-        return role;
+    async update(id, roleData) {
+        try {
+            roleData.name = roleData?.name?.trim();
+            await roleSchema.parseAsync(roleData);
+            const currentRole = await this.findById(id);
+            if (currentRole.readonly) {
+                throw new ValidationError([{ field: 'name', reason: "role.readonly", value: roleData.name }]);
+            }
+            const role = await this._repository.update(id, roleData);
+            return role;
+        }
+        catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, roleData);
+            }
+            throw e;
+        }
     }
-    async delete(_id) {
-        const deletedRole = await this._repository.delete(_id);
+    async delete(id) {
+        const currentRole = await this.findById(id);
+        if (currentRole.readonly) {
+            throw new UnauthorizedError();
+        }
+        const deletedRole = await this._repository.delete(id);
         return deletedRole;
     }
-    async findById(_id) {
-        const role = await this._repository.findById(_id);
+    async findById(id) {
+        const role = await this._repository.findById(id);
         return role;
     }
-    async paginate(filters, page = 1, limit = 10) {
-        const query = {};
-        const options = {
-            page: page,
-            limit: limit
-        };
-        const pagination = await this._repository.paginate(query, options);
+    async fetchAll() {
+        const roles = await this._repository.fetchAll();
+        return roles;
+    }
+    async paginate(page = 1, limit = 5, search, filters) {
+        const pagination = await this._repository.paginate(page, limit, search, filters);
         return pagination;
     }
 }

package/dist/services/UserService.js

@@ -1,42 +1,101 @@
+import { ZodError } from "zod";
+import { ValidationError, ZodErrorToValidationError } from "@drax/common-back";
 import AuthUtils from "../utils/AuthUtils.js";
+import { createUserSchema, editUserSchema, } from "../zod/UserZod.js";
+import BadCredentialsError from "../errors/BadCredentialsError.js";
 class UserService {
     constructor(userRepository) {
         this._repository = userRepository;
+        console.log("UserService constructor");
+    }
+    async auth(username, password) {
+        let user = null;
+        console.log("auth username", username);
+        user = await this.findByUsername(username);
+        if (user && user.active && AuthUtils.checkPassword(password, user.password)) {
+            //TODO: Generar Sesion
+            const session = '123';
+            const accessToken = AuthUtils.generateToken(user.id.toString(), user.username, user.role.id, session);
+            return { accessToken: accessToken };
+        }
+        else {
+            throw new BadCredentialsError();
+        }
+    }
+    async changeUserPassword(userId, newPassword) {
+        const user = await this.findById(userId);
+        if (user) {
+            newPassword = AuthUtils.hashPassword(newPassword);
+            await this._repository.changePassword(userId, newPassword);
+            return true;
+        }
+        else {
+            throw new ValidationError([{ field: 'userId', reason: 'validation.notFound' }]);
+        }
+    }
+    async changeOwnPassword(userId, currentPassword, newPassword) {
+        const user = await this.findById(userId);
+        if (user && user.active) {
+            if (AuthUtils.checkPassword(currentPassword, user.password)) {
+                newPassword = AuthUtils.hashPassword(newPassword);
+                await this._repository.changePassword(userId, newPassword);
+                return true;
+            }
+            else {
+                throw new ValidationError([{ field: 'currentPassword', reason: 'validation.notMatch' }]);
+            }
+        }
+        else {
+            throw new BadCredentialsError();
+        }
     }
     async create(userData) {
-        userData.name = userData?.name?.trim();
-        userData.username = userData.username.trim();
-        userData.password = AuthUtils.hashPassword(userData.password.trim());
-        const user = await this._repository.create(userData);
-        return user;
+        try {
+            userData.name = userData?.name?.trim();
+            userData.username = userData.username.trim();
+            userData.password = userData.password.trim();
+            await createUserSchema.parseAsync(userData);
+            userData.password = AuthUtils.hashPassword(userData.password.trim());
+            const user = await this._repository.create(userData);
+            return user;
+        }
+        catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, userData);
+            }
+            throw e;
+        }
     }
-    async update(_id, userData) {
-        userData.name = userData.name.trim();
-        userData.username = userData.username.trim();
-        delete userData.password;
-        const user = await this._repository.update(_id, userData);
-        return user;
+    async update(id, userData) {
+        try {
+            userData.name = userData.name.trim();
+            userData.username = userData.username.trim();
+            delete userData.password;
+            await editUserSchema.parseAsync(userData);
+            const user = await this._repository.update(id, userData);
+            return user;
+        }
+        catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, userData);
+            }
+            throw e;
+        }
     }
-    async delete(_id) {
-        const deletedRole = await this._repository.delete(_id);
+    async delete(id) {
+        const deletedRole = await this._repository.delete(id);
         return deletedRole;
     }
-    async findById(_id) {
-        const user = await this._repository.findById(_id);
+    async findById(id) {
+        const user = await this._repository.findById(id);
         return user;
     }
     async findByUsername(username) {
         const user = await this._repository.findByUsername(username);
         return user;
     }
-    async paginate(filters, page = 1, limit = 10) {
-        const query = {};
-        const options = {
-            page: page,
-            limit: limit
-        };
-        const pagination = await this._repository.paginate(query, options);
-        console.log("pagination", pagination);
+    async paginate(page = 1, limit = 10, search, filters) {
+        const pagination = await this._repository.paginate(page, limit, search, filters);
         return pagination;
     }
 }

package/dist/utils/AuthUtils.js

@@ -1,6 +1,16 @@
 import bcryptjs from "bcryptjs";
 import jsonwebtoken from "jsonwebtoken";
 class AuthUtils {
+    static verifyToken(token) {
+        const JWT_SECRET = process.env.JWT_SECRET;
+        if (!JWT_SECRET) {
+            throw new Error("JWT_SECRET ENV must be provided");
+        }
+        const options = {
+            algorithms: ['HS256'],
+        };
+        return jsonwebtoken.verify(token, JWT_SECRET, options);
+    }
     static hashPassword(password) {
         if (!password) {
             throw new Error("password must be provided");
@@ -12,22 +22,26 @@ class AuthUtils {
     static checkPassword(password, hashPassword) {
         return bcryptjs.compareSync(password, hashPassword);
     }
-    static tokenSignPayload(userId, username, session) {
+    static tokenSignPayload(userId, username, roleId, session) {
         return {
             id: userId,
             username: username,
+            roleId: roleId,
             session: session
         };
     }
-    static generateToken(userId, username, session) {
-        const payload = AuthUtils.tokenSignPayload(userId, username, session);
-        const JWT_SECRET = process.env.JWT_SECRET ? process.env.JWT_SECRET : 'KRgDV3CeR5lVhsFF';
+    static generateToken(userId, username, roleId, session) {
+        const payload = AuthUtils.tokenSignPayload(userId, username, roleId, session);
+        const JWT_SECRET = process.env.JWT_SECRET;
+        if (!JWT_SECRET) {
+            throw new Error("JWT_SECRET ENV must be provided");
+        }
         const options = {
-            expiresIn: process.env.JWT_LOGIN_EXPIRED_IN || '1h',
+            expiresIn: process.env.JWT_EXPIRATION || '1h',
             jwtid: userId,
             algorithm: 'HS256',
             audience: username,
-            issuer: process.env.ISSUER ? process.env.ISSUER : 'drax'
+            issuer: process.env.JWT_ISSUER ? process.env.JWT_ISSUER : 'drax'
         };
         let token = jsonwebtoken.sign(payload, JWT_SECRET, options);
         return token;

package/dist/utils/DbSetupUtils.js

@@ -0,0 +1,28 @@
+var DbEngine;
+(function (DbEngine) {
+    DbEngine["Sqlite"] = "sqlite";
+    DbEngine["Mongo"] = "mongo";
+})(DbEngine || (DbEngine = {}));
+class DbSetupUtils {
+    static getDbEngine() {
+        if (!process.env.DB_ENGINE) {
+            throw new Error("process.env.DB_ENGINE is not defined");
+        }
+        const dbEngine = process.env.DB_ENGINE;
+        if (!Object.values(DbEngine).includes(dbEngine)) {
+            throw new Error("process.env.DB_ENGINE must be one of " + Object.values(DbEngine).join(", "));
+        }
+        return dbEngine;
+    }
+    static getDbUri() {
+        switch (DbSetupUtils.getDbEngine()) {
+            case DbEngine.Mongo:
+                return process.env.MONGO_URI;
+            case DbEngine.Sqlite:
+                return process.env.SQLITE_DATABASE;
+            default:
+                throw new Error("process.env.DB_ENGINE must be one of " + Object.values(DbEngine).join(", "));
+        }
+    }
+}
+export { DbEngine, DbSetupUtils };

package/dist/zod/RoleZod.js

@@ -0,0 +1,8 @@
+import { object, string } from "zod";
+const roleSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .regex(/^[A-Z]/, "validation.startWithUpperCase"),
+});
+export default roleSchema;
+export { roleSchema };

package/dist/zod/UserZod.js

@@ -0,0 +1,18 @@
+import { object, string } from "zod";
+export const userBaseSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    username: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    email: string({ required_error: "validation.required" })
+        .email("validation.email.invalid"),
+    role: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+});
+export const createUserSchema = userBaseSchema.extend({
+    password: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .min(8, "validation.password.min8")
+        .max(32, "validation.password.max32"),
+});
+export const editUserSchema = userBaseSchema.extend({});

package/package.json

@@ -3,32 +3,38 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
   "type": "module",
   "scripts": {
     "serve": "nodemon --exec node --loader ts-node/esm src/index.ts",
-    "prepublish": "npm run tsc && npm run copygql",
+    "prepublish": "tsc && npm run copygql",
     "clean": "rm -rf dist",
     "copygql": "copyfiles -u 1 ./**/*.graphql dist/",
     "tsc": "tsc -b tsconfig.json",
-    "test": "node --loader tsx --test test/**/*",
-    "testRepositoryRole": "node --loader tsx --test test/repository/role*",
-    "testServiceRole": "node --loader tsx --test test/service/role*",
-    "testRepositoryUser": "node --loader tsx --test test/repository/user*",
-    "testServiceUser": "node --loader tsx --test test/service/user*",
-    "testcoverage": "node --loader tsx --experimental-test-coverage  test/service/*"
+    "test": "node --import tsx --test test/**/*",
+    "testMongoRepositoryRole": "node --import tsx --test test/repository/mongo/role*",
+    "testMongoRepositoryUser": "node --import tsx --test test/repository/mongo/user*",
+    "testSqliteRepositoryUser": "node --import tsx --test test/repository/sqlite/user*",
+    "testSqliteRepositoryRole": "node --import tsx --test test/repository/sqlite/role*",
+    "testServiceRole": "node --import tsx --test test/service/role*",
+    "testServiceUser": "node --import tsx --test test/service/user*",
+    "testcoverage": "node --import tsx --experimental-test-coverage  test/service/*"
   },
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
     "bcryptjs": "^2.4.3",
     "express-jwt": "^8.4.1",
-    "jsonwebtoken": "^9.0.2"
+    "graphql": "^16.8.2",
+    "jsonwebtoken": "^9.0.2",
+    "zod": "^3.23.8"
   },
   "peerDependencies": {
+    "better-sqlite3": "^11.0.0",
+    "fastify": "^4.27.0",
     "mongoose": "^8.3.4",
     "mongoose-paginate-v2": "^1.8.0",
     "mongoose-unique-validator": "^5.0.0"
@@ -41,6 +47,7 @@
     "mongodb-memory-server": "^9.2.0",
     "nodemon": "^3.1.0",
     "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10",
     "tsx": "^3.12.7",
     "typescript": "^5.4.5"
   },
@@ -49,5 +56,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "26465c7ca403bae9b9a67fa249aee660fb4f3dd4"
+  "gitHead": "c30e1965d551cc63001a301b8dc98e26eba3afe1"
 }

package/src/errors/BadCredentialsError.ts

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