@drax/identity-back 0.0.8 → 0.0.10

package/dist/repository/mongo/RoleMongoRepository.js

@@ -0,0 +1,41 @@
+import { RoleModel } from "../../models/RoleModel.js";
+class RoleMongoRepository {
+    async create(roleData) {
+        const role = new RoleModel(roleData);
+        await role.save();
+        return role;
+    }
+    async update(id, roleData) {
+        const role = await RoleModel.findOneAndUpdate({ _id: id }, roleData, { new: true }).exec();
+        return role;
+    }
+    async delete(id) {
+        const result = await RoleModel.deleteOne(id).exec();
+        return result.deletedCount == 1;
+    }
+    async findById(id) {
+        const role = await RoleModel.findById(id).exec();
+        return role;
+    }
+    async fetchAll() {
+        const roles = await RoleModel.find().exec();
+        return roles;
+    }
+    async paginate(page = 1, limit = 5, search) {
+        const query = {};
+        if (search) {
+            query['$or'] = [
+                { name: new RegExp(search, 'i') },
+            ];
+        }
+        const options = { page, limit };
+        const roles = await RoleModel.paginate(query, options);
+        return {
+            page: page,
+            limit: limit,
+            total: roles.totalDocs,
+            items: roles.docs
+        };
+    }
+}
+export default RoleMongoRepository;

package/dist/repository/mongo/UserMongoRepository.js

@@ -0,0 +1,82 @@
+import { UserModel } from "../../models/UserModel.js";
+import { mongoose, MongooseErrorToValidationError, MongoServerErrorToValidationError, ValidationError } from "@drax/common-back";
+import { MongoServerError } from "mongodb";
+import RoleMongoRepository from "./RoleMongoRepository.js";
+class UserMongoRepository {
+    constructor() {
+        this.roleRepository = new RoleMongoRepository();
+    }
+    async create(userData) {
+        try {
+            if (!await this.roleRepository.findById(userData.role)) {
+                throw new ValidationError([{ field: 'role', reason: 'validation.notfound', value: userData.role }]);
+            }
+            const user = new UserModel(userData);
+            await user.save();
+            await user.populate('role');
+            return user;
+        }
+        catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e);
+            }
+            throw e;
+        }
+    }
+    async update(id, userData) {
+        try {
+            const user = await UserModel.findOneAndUpdate({ _id: id }, userData, { new: true }).populate('role').exec();
+            return user;
+        }
+        catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e);
+            }
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
+                throw MongoServerErrorToValidationError(e);
+            }
+            throw e;
+        }
+    }
+    async delete(id) {
+        const result = await UserModel.deleteOne({ _id: id }).exec();
+        return result.deletedCount == 1;
+    }
+    async findById(id) {
+        const user = await UserModel.findById(id).populate('role').exec();
+        return user;
+    }
+    async findByUsername(username) {
+        const user = await UserModel.findOne({ username: username }).populate('role').exec();
+        return user;
+    }
+    async paginate(page = 1, limit = 5, search) {
+        const query = {};
+        if (search) {
+            query['$or'] = [
+                { username: new RegExp(search, 'i') },
+                { email: new RegExp(search, 'i') },
+                { name: new RegExp(search, 'i') },
+            ];
+        }
+        const options = { populate: ['role'], page: page, limit: limit };
+        const userPaginated = await UserModel.paginate(query, options);
+        return {
+            page: page,
+            limit: limit,
+            total: userPaginated.totalDocs,
+            items: userPaginated.docs
+        };
+    }
+    async changePassword(id, password) {
+        try {
+            await UserModel.findOneAndUpdate({ _id: id }, { password }).exec();
+            return true;
+        }
+        catch (e) {
+            console.error(e);
+            return false;
+        }
+    }
+}
+export default UserMongoRepository;

package/dist/repository/sqlite/RoleSqliteRepository.js

@@ -0,0 +1,115 @@
+import sqlite from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { SqliteErrorToValidationError } from "@drax/common-back";
+const roleTableSQL = `
+    CREATE TABLE IF NOT EXISTS roles
+    (
+        id TEXT PRIMARY KEY,
+        name TEXT,
+        permissions TEXT,
+        readonly INTEGER,
+        childRoles TEXT
+        
+    );
+`;
+class RoleSqliteRepository {
+    constructor(DATABASE, verbose = false) {
+        this.db = new sqlite(DATABASE, { verbose: verbose ? console.log : null });
+    }
+    table() {
+        this.db.exec(roleTableSQL);
+    }
+    normalizeData(roleData) {
+        roleData.readonly = roleData.readonly ? 1 : 0;
+        if (roleData.permissions && Array.isArray(roleData.permissions)) {
+            roleData.permissions = roleData.permissions.join(",");
+        }
+        if (roleData.childRoles && Array.isArray(roleData.childRoles)) {
+            roleData.childRoles = roleData.childRoles.join(",");
+        }
+    }
+    async create(roleData) {
+        try {
+            if (!roleData.id) {
+                roleData.id = randomUUID();
+            }
+            this.normalizeData(roleData);
+            const fields = Object.keys(roleData)
+                .map(field => `${field}`)
+                .join(', ');
+            const values = Object.keys(roleData)
+                .map(field => `@${field}`)
+                .join(', ');
+            /* console.log("fields", fields)
+             console.log("values",values)
+             console.log("userData",roleData)*/
+            const stmt = this.db.prepare(`INSERT INTO roles (${fields}) VALUES (${values})`);
+            stmt.run(roleData);
+            return this.findById(roleData.id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, roleData);
+        }
+    }
+    async findById(id) {
+        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
+        if (role) {
+            role.permissions = role.permissions ? role.permissions.split(",") : [];
+            return role;
+        }
+        return undefined;
+    }
+    async update(id, roleData) {
+        try {
+            this.normalizeData(roleData);
+            const setClauses = Object.keys(roleData)
+                .map(field => `${field} = @${field}`)
+                .join(', ');
+            roleData.id = id;
+            const stmt = this.db.prepare(`UPDATE roles SET ${setClauses} WHERE id = @id `);
+            stmt.run(roleData);
+            return this.findById(id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, roleData);
+        }
+    }
+    async delete(id) {
+        const stmt = this.db.prepare('DELETE FROM roles WHERE id = ?');
+        stmt.run(id);
+        return true;
+    }
+    async deleteAll() {
+        const stmt = this.db.prepare('DELETE FROM roles');
+        stmt.run();
+        return true;
+    }
+    async fetchAll() {
+        const roles = this.db.prepare('SELECT * FROM roles').all();
+        for (const role of roles) {
+            role.permissions = role.permissions ? role.permissions.split(",") : [];
+        }
+        return roles;
+    }
+    async paginate(page = 1, limit = 5, search = "") {
+        const offset = page > 1 ? (page - 1) * limit : 0;
+        let where;
+        if (search) {
+            where = ` WHERE name LIKE '%${search}%'`;
+        }
+        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM roles' + where).get();
+        const roles = this.db.prepare('SELECT * FROM roles LIMIT ? OFFSET ?' + where).all([limit, offset]);
+        for (const role of roles) {
+            role.permissions = role.permissions ? role.permissions.split(",") : [];
+        }
+        return {
+            page: page,
+            limit: limit,
+            total: rCount.count,
+            items: roles
+        };
+    }
+}
+export default RoleSqliteRepository;

package/dist/repository/sqlite/UserSqliteRepository.js

@@ -0,0 +1,157 @@
+import sqlite from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { SqliteErrorToValidationError, ValidationError } from "@drax/common-back";
+import RoleSqliteRepository from "./RoleSqliteRepository.js";
+const userTableSQL = `
+    CREATE TABLE IF NOT EXISTS users
+    (
+        id
+        TEXT
+        PRIMARY
+        KEY,
+        name
+        TEXT,
+        username
+        TEXT
+        UNIQUE,
+        active
+        INTEGER,
+        password
+        TEXT,
+        email
+        TEXT
+        UNIQUE,
+        phone
+        TEXT,
+        role
+        TEXT,
+        groups
+        TEXT,
+        avatar
+        TEXT
+    );
+`;
+class UserSqliteRepository {
+    constructor(DATABASE, verbose = false) {
+        this.db = new sqlite(DATABASE, { verbose: verbose ? console.log : null });
+        this.roleRepository = new RoleSqliteRepository(DATABASE, verbose);
+    }
+    table() {
+        this.db.exec(userTableSQL);
+    }
+    normalizeData(userData) {
+        if (userData.groups && Array.isArray(userData.groups)) {
+            userData.groups = userData.groups.join(",");
+        }
+        userData.active = userData.active ? 1 : 0;
+    }
+    async create(userData) {
+        if (!userData.id) {
+            userData.id = randomUUID();
+        }
+        if (!await this.findRoleById(userData.role)) {
+            throw new ValidationError([{ field: 'role', reason: 'validation.notfound', value: userData.role }]);
+        }
+        this.normalizeData(userData);
+        try {
+            const fields = Object.keys(userData)
+                .map(field => `${field}`)
+                .join(', ');
+            const values = Object.keys(userData)
+                .map(field => `@${field}`)
+                .join(', ');
+            /*console.log("fields", fields)
+            console.log("values",values)
+            console.log("userData",userData)*/
+            const stmt = this.db.prepare(`INSERT INTO users (${fields})
+                                          VALUES (${values})`);
+            stmt.run(userData);
+            return this.findById(userData.id);
+        }
+        catch (e) {
+            throw SqliteErrorToValidationError(e, userData);
+        }
+    }
+    async update(id, userData) {
+        try {
+            if (!await this.findRoleById(userData.role)) {
+                throw new ValidationError([{ field: 'role', reason: 'validation.notfound', value: userData.role }]);
+            }
+            this.normalizeData(userData);
+            const setClauses = Object.keys(userData)
+                .map(field => `${field} = @${field}`)
+                .join(', ');
+            userData.id = id;
+            const stmt = this.db.prepare(`UPDATE users
+                                          SET ${setClauses}
+                                          WHERE id = @id `);
+            stmt.run(userData);
+        }
+        catch (e) {
+            throw SqliteErrorToValidationError(e, userData);
+        }
+        return this.findById(id);
+    }
+    async delete(id) {
+        const stmt = this.db.prepare('DELETE FROM users WHERE id = ?');
+        stmt.run(id);
+        return true;
+    }
+    async deleteAll() {
+        const stmt = this.db.prepare('DELETE FROM users');
+        stmt.run();
+        return true;
+    }
+    async findById(id) {
+        const user = this.db.prepare('SELECT * FROM users WHERE id = ?').get(id);
+        if (!user) {
+            return null;
+        }
+        user.role = await this.findRoleById(user.role);
+        return user;
+    }
+    async findByUsername(username) {
+        const user = this.db.prepare('SELECT * FROM users WHERE username = ?').get(username);
+        if (!user) {
+            return null;
+        }
+        user.role = await this.findRoleById(user.role);
+        return user;
+    }
+    async paginate(page = 1, limit = 5, search) {
+        const offset = page > 1 ? (page - 1) * limit : 0;
+        let where;
+        if (search) {
+            where = ` WHERE name LIKE '%${search}%' OR username LIKE '%${search}%'`;
+        }
+        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM users' + where).get();
+        const users = this.db.prepare('SELECT * FROM users LIMIT ? OFFSET ?' + where).all([limit, offset]);
+        for (const user of users) {
+            let role = await this.findRoleById(user.role);
+            if (role) {
+                user.role = role;
+            }
+            else {
+                user.role = null;
+            }
+            user.active = user.active === 1;
+        }
+        return {
+            page: page,
+            limit: limit,
+            total: rCount.count,
+            items: users
+        };
+    }
+    async findRoleById(id) {
+        return await this.roleRepository.findById(id);
+    }
+    async changePassword(id, password) {
+        const stmt = this.db.prepare(`UPDATE users
+                                      SET password = @password
+                                      WHERE id = @id `);
+        stmt.run({ id: id, password: password });
+        return true;
+    }
+}
+export default UserSqliteRepository;

package/dist/routes/RoleRoutes.js

@@ -0,0 +1,145 @@
+import { ValidationError } from "@drax/common-back";
+import RoleServiceFactory from "../factory/RoleServiceFactory.js";
+import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
+import { PermissionService } from "../services/PermissionService.js";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+const roleService = RoleServiceFactory;
+async function RoleRoutes(fastify, options) {
+    fastify.get('/api/permissions', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.PermissionsRole);
+            let permissions = PermissionService.getPermissions();
+            return permissions;
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    });
+    fastify.get('/api/roles/all', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewRole);
+            let roles = await roleService.fetchAll();
+            return roles;
+        }
+        catch (e) {
+            console.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: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    });
+    fastify.get('/api/roles', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewRole);
+            const page = request.query.page;
+            const limit = request.query.limit;
+            const search = request.query.search;
+            let paginateResult = await roleService.paginate(page, limit, search);
+            return paginateResult;
+        }
+        catch (e) {
+            console.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: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    });
+    fastify.post('/api/roles', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.CreateRole);
+            const payload = request.body;
+            let role = await roleService.create(payload);
+            return role;
+        }
+        catch (e) {
+            console.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: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    });
+    fastify.put('/api/roles/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateRole);
+            const id = request.params.id;
+            const payload = request.body;
+            let role = await roleService.update(id, payload);
+            return role;
+        }
+        catch (e) {
+            console.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: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    });
+    fastify.delete('/api/roles/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.DeleteRole);
+            const id = request.params.id;
+            let r = await roleService.delete(id);
+            return r;
+        }
+        catch (e) {
+            console.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: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    });
+}
+export default RoleRoutes;
+export { RoleRoutes };