@drax/identity-back 0.0.14 → 0.0.16

package/dist/repository/sqlite/RoleSqliteRepository.js

@@ -15,6 +15,7 @@ const roleTableSQL = `
 class RoleSqliteRepository {
     constructor(DATABASE, verbose = false) {
         this.db = new sqlite(DATABASE, { verbose: verbose ? console.log : null });
+        this.table();
     }
     table() {
         this.db.exec(roleTableSQL);
@@ -55,7 +56,7 @@ class RoleSqliteRepository {
     async findById(id) {
         const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
         if (role) {
-            role.permissions = role.permissions ? role.permissions.split(",") : [];
+            await this.populateRole(role);
             return role;
         }
         return undefined;
@@ -63,7 +64,7 @@ class RoleSqliteRepository {
     async findByName(name) {
         const role = this.db.prepare('SELECT * FROM roles WHERE name = ?').get(name);
         if (role) {
-            role.permissions = role.permissions ? role.permissions.split(",") : [];
+            await this.populateRole(role);
             return role;
         }
         return undefined;
@@ -97,20 +98,20 @@ class RoleSqliteRepository {
     async fetchAll() {
         const roles = this.db.prepare('SELECT * FROM roles').all();
         for (const role of roles) {
-            role.permissions = role.permissions ? role.permissions.split(",") : [];
+            await this.populateRole(role);
         }
         return roles;
     }
     async paginate(page = 1, limit = 5, search = "") {
         const offset = page > 1 ? (page - 1) * limit : 0;
-        let where;
+        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(",") : [];
+            await this.populateRole(role);
         }
         return {
             page: page,
@@ -119,5 +120,23 @@ class RoleSqliteRepository {
             items: roles
         };
     }
+    async findWithoutPopulateById(id) {
+        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
+        if (role) {
+            return role;
+        }
+        return undefined;
+    }
+    async populateRole(role) {
+        role.permissions = role.permissions ? role.permissions.split(",") : [];
+        role.childRoles = role.childRoles ? role.childRoles.split(",") : [];
+        const childRoles = [];
+        for (const childRoleId of role.childRoles) {
+            const childRole = await this.findWithoutPopulateById(childRoleId);
+            childRoles.push(childRole);
+        }
+        role.childRoles = childRoles;
+        return role;
+    }
 }
 export default RoleSqliteRepository;

package/dist/repository/sqlite/TenantSqliteRepository.js

@@ -0,0 +1,106 @@
+import sqlite from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { SqliteErrorToValidationError } from "@drax/common-back";
+const tenantTableSQL = `
+    CREATE TABLE IF NOT EXISTS tenants
+    (
+        id TEXT PRIMARY KEY,
+        name TEXT
+    );
+`;
+class TenantSqliteRepository {
+    constructor(DATABASE, verbose = false) {
+        this.db = new sqlite(DATABASE, { verbose: verbose ? console.log : null });
+        this.table();
+    }
+    table() {
+        this.db.exec(tenantTableSQL);
+    }
+    async create(tenantData) {
+        try {
+            if (!tenantData.id) {
+                tenantData.id = randomUUID();
+            }
+            const fields = Object.keys(tenantData)
+                .map(field => `${field}`)
+                .join(', ');
+            const values = Object.keys(tenantData)
+                .map(field => `@${field}`)
+                .join(', ');
+            const stmt = this.db.prepare(`INSERT INTO tenants (${fields}) VALUES (${values})`);
+            stmt.run(tenantData);
+            return this.findById(tenantData.id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, tenantData);
+        }
+    }
+    async findById(id) {
+        const tenant = this.db.prepare('SELECT * FROM tenants WHERE id = ?').get(id);
+        if (tenant) {
+            tenant.permissions = tenant.permissions ? tenant.permissions.split(",") : [];
+            return tenant;
+        }
+        return undefined;
+    }
+    async findByName(name) {
+        const tenant = this.db.prepare('SELECT * FROM tenants WHERE name = ?').get(name);
+        if (tenant) {
+            tenant.permissions = tenant.permissions ? tenant.permissions.split(",") : [];
+            return tenant;
+        }
+        return undefined;
+    }
+    async update(id, tenantData) {
+        try {
+            const setClauses = Object.keys(tenantData)
+                .map(field => `${field} = @${field}`)
+                .join(', ');
+            tenantData.id = id;
+            const stmt = this.db.prepare(`UPDATE tenants SET ${setClauses} WHERE id = @id `);
+            stmt.run(tenantData);
+            return this.findById(id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, tenantData);
+        }
+    }
+    async delete(id) {
+        const stmt = this.db.prepare('DELETE FROM tenants WHERE id = ?');
+        stmt.run(id);
+        return true;
+    }
+    async deleteAll() {
+        const stmt = this.db.prepare('DELETE FROM tenants');
+        stmt.run();
+        return true;
+    }
+    async fetchAll() {
+        const tenants = this.db.prepare('SELECT * FROM tenants').all();
+        for (const tenant of tenants) {
+            tenant.permissions = tenant.permissions ? tenant.permissions.split(",") : [];
+        }
+        return tenants;
+    }
+    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 tenants' + where).get();
+        const tenants = this.db.prepare('SELECT * FROM tenants LIMIT ? OFFSET ?' + where).all([limit, offset]);
+        for (const tenant of tenants) {
+            tenant.permissions = tenant.permissions ? tenant.permissions.split(",") : [];
+        }
+        return {
+            page: page,
+            limit: limit,
+            total: rCount.count,
+            items: tenants
+        };
+    }
+}
+export default TenantSqliteRepository;

package/dist/repository/sqlite/UserSqliteRepository.js

@@ -2,39 +2,29 @@ import sqlite from "better-sqlite3";
 import { randomUUID } from "node:crypto";
 import { SqliteErrorToValidationError, ValidationError } from "@drax/common-back";
 import RoleSqliteRepository from "./RoleSqliteRepository.js";
+import TenantSqliteRepository from "./TenantSqliteRepository.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
+        id TEXT PRIMARY KEY,
+        name TEXT,
+        username TEXT UNIQUE,
+        active INTEGER,
+        password TEXT,
+        email TEXT UNIQUE,
+        phone TEXT,
+        role TEXT,
+        tenant 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);
+        this.tenantRepository = new TenantSqliteRepository(DATABASE, verbose);
+        this.table();
     }
     table() {
         this.db.exec(userTableSQL);
@@ -60,9 +50,6 @@ class UserSqliteRepository {
             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);
@@ -108,6 +95,7 @@ class UserSqliteRepository {
             return null;
         }
         user.role = await this.findRoleById(user.role);
+        user.tenant = await this.findTenantById(user.tenant);
         return user;
     }
     async findByUsername(username) {
@@ -116,24 +104,39 @@ class UserSqliteRepository {
             return null;
         }
         user.role = await this.findRoleById(user.role);
+        user.tenant = await this.findTenantById(user.tenant);
         return user;
     }
-    async paginate(page = 1, limit = 5, search) {
+    async paginate(page = 1, limit = 5, search = "", filters = []) {
         const offset = page > 1 ? (page - 1) * limit : 0;
-        let where;
+        let where = "";
         if (search) {
-            where = ` WHERE name LIKE '%${search}%' OR username LIKE '%${search}%'`;
+            where = ` WHERE (name LIKE '%${search}%' OR username LIKE '%${search}%') `;
         }
+        let whereFilters = [];
+        if (filters && filters.length > 0) {
+            where = where ? ` AND ` : ` WHERE `;
+            for (const filter of filters) {
+                if (filter.operator === '$eq') {
+                    whereFilters.push(` ${filter.field} = '${filter.value}' `);
+                }
+                if (filter.operator === '$ne') {
+                    whereFilters.push(` ${filter.field} != '${filter.value}' `);
+                }
+                if (filter.operator === '$in') {
+                    whereFilters.push(` ${filter.field} LIKE '%${filter.value}%' `);
+                }
+            }
+            where += whereFilters.join(" AND ");
+        }
+        // console.log("paginate where ", where, "search", search, "filters", filters, "whereFilters", whereFilters)
         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]);
+        const users = this.db.prepare('SELECT * FROM users' + where + ' LIMIT ? OFFSET ?').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.role = role ? role : null;
+            let tenant = await this.findTenantById(user.tenant);
+            user.tenant = tenant ? tenant : null;
             user.active = user.active === 1;
         }
         return {
@@ -146,6 +149,9 @@ class UserSqliteRepository {
     async findRoleById(id) {
         return await this.roleRepository.findById(id);
     }
+    async findTenantById(id) {
+        return await this.tenantRepository.findById(id);
+    }
     async changePassword(id, password) {
         const stmt = this.db.prepare(`UPDATE users
                                       SET password = @password

package/dist/routes/RoleRoutes.js

@@ -3,7 +3,6 @@ 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 {
@@ -27,6 +26,7 @@ async function RoleRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewRole);
             const id = request.params.id;
+            const roleService = RoleServiceFactory();
             let role = await roleService.findById(id);
             return role;
         }
@@ -50,6 +50,7 @@ async function RoleRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewRole);
             const name = request.params.name;
+            const roleService = RoleServiceFactory();
             let role = await roleService.findByName(name);
             return role;
         }
@@ -72,8 +73,14 @@ async function RoleRoutes(fastify, options) {
     fastify.get('/api/roles/all', async (request, reply) => {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewRole);
+            const roleService = RoleServiceFactory();
             let roles = await roleService.fetchAll();
-            return roles;
+            if (request.rbac.getRole?.childRoles?.length > 0) {
+                return roles.filter(role => request.rbac.getRole.childRoles.some(childRole => childRole.id === role.id));
+            }
+            else {
+                return roles;
+            }
         }
         catch (e) {
             console.error(e);
@@ -97,6 +104,7 @@ async function RoleRoutes(fastify, options) {
             const page = request.query.page;
             const limit = request.query.limit;
             const search = request.query.search;
+            const roleService = RoleServiceFactory();
             let paginateResult = await roleService.paginate(page, limit, search);
             return paginateResult;
         }
@@ -120,6 +128,7 @@ async function RoleRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.CreateRole);
             const payload = request.body;
+            const roleService = RoleServiceFactory();
             let role = await roleService.create(payload);
             return role;
         }
@@ -144,6 +153,7 @@ async function RoleRoutes(fastify, options) {
             request.rbac.assertPermission(IdentityPermissions.UpdateRole);
             const id = request.params.id;
             const payload = request.body;
+            const roleService = RoleServiceFactory();
             const currentRole = await roleService.findById(id);
             if (currentRole.readonly) {
                 throw new ValidationError([{ field: 'name', reason: "role.readonly", value: payload.name }]);
@@ -171,6 +181,11 @@ async function RoleRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.DeleteRole);
             const id = request.params.id;
+            const roleService = RoleServiceFactory();
+            const currentRole = await roleService.findById(id);
+            if (currentRole.readonly) {
+                throw new UnauthorizedError();
+            }
             let r = await roleService.delete(id);
             return r;
         }

package/dist/routes/TenantRoutes.js

@@ -0,0 +1,183 @@
+import { ValidationError } from "@drax/common-back";
+import TenantServiceFactory from "../factory/TenantServiceFactory.js";
+import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+async function TenantRoutes(fastify, options) {
+    fastify.get('/api/tenants/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewTenant);
+            const id = request.params.id;
+            const tenantService = TenantServiceFactory();
+            let tenant = await tenantService.findById(id);
+            return tenant;
+        }
+        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/tenants/name/:name', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewTenant);
+            const name = request.params.name;
+            const tenantService = TenantServiceFactory();
+            let tenant = await tenantService.findByName(name);
+            return tenant;
+        }
+        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/tenants/all', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewTenant);
+            const tenantService = TenantServiceFactory();
+            let tenants = await tenantService.fetchAll();
+            if (request.rbac.getAuthUser.tenantId) {
+                return tenants.filter(t => t.id === request.rbac.getAuthUser.tenantId);
+            }
+            else {
+                return tenants;
+            }
+        }
+        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/tenants', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewTenant);
+            const page = request.query.page;
+            const limit = request.query.limit;
+            const search = request.query.search;
+            const tenantService = TenantServiceFactory();
+            let paginateResult = await tenantService.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/tenants', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.CreateTenant);
+            const payload = request.body;
+            const tenantService = TenantServiceFactory();
+            let tenant = await tenantService.create(payload);
+            return tenant;
+        }
+        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/tenants/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateTenant);
+            const id = request.params.id;
+            const payload = request.body;
+            const tenantService = TenantServiceFactory();
+            let tenant = await tenantService.update(id, payload);
+            return tenant;
+        }
+        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/tenants/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.DeleteTenant);
+            const id = request.params.id;
+            const tenantService = TenantServiceFactory();
+            let r = await tenantService.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 TenantRoutes;
+export { TenantRoutes };

package/dist/routes/UserRoutes.js

@@ -3,12 +3,12 @@ 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;
+            const userService = UserServiceFactory();
             return await userService.auth(username, password);
         }
         catch (e) {
@@ -24,6 +24,7 @@ async function UserRoutes(fastify, options) {
     fastify.get('/api/me', async (request, reply) => {
         try {
             if (request.authUser) {
+                const userService = UserServiceFactory();
                 let user = await userService.findById(request.authUser.id);
                 delete user.password;
                 return user;
@@ -53,10 +54,16 @@ async function UserRoutes(fastify, options) {
             const page = request.query.page;
             const limit = request.query.limit;
             const search = request.query.search;
-            let paginateResult = await userService.paginate(page, limit, search);
+            const userService = UserServiceFactory();
+            const filters = [];
+            if (request.rbac.getAuthUser.tenantId) {
+                filters.push({ field: 'tenant', operator: '$eq', value: request.rbac.getAuthUser.tenantId });
+            }
+            let paginateResult = await userService.paginate(page, limit, search, filters);
             return paginateResult;
         }
         catch (e) {
+            console.log("/api/users", e);
             if (e instanceof ValidationError) {
                 reply.statusCode = e.statusCode;
                 reply.send({ error: e.message, inputErrors: e.errors });
@@ -75,6 +82,7 @@ async function UserRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.CreateUser);
             const payload = request.body;
+            const userService = UserServiceFactory();
             let user = await userService.create(payload);
             return user;
         }
@@ -98,6 +106,7 @@ async function UserRoutes(fastify, options) {
             request.rbac.assertPermission(IdentityPermissions.UpdateUser);
             const id = request.params.id;
             const payload = request.body;
+            const userService = UserServiceFactory();
             let user = await userService.update(id, payload);
             return user;
         }
@@ -124,6 +133,7 @@ async function UserRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.DeleteUser);
             const id = request.params.id;
+            const userService = UserServiceFactory();
             let r = await userService.delete(id);
             return r;
         }
@@ -150,6 +160,7 @@ async function UserRoutes(fastify, options) {
             const userId = request.authUser.id;
             const currentPassword = request.body.currentPassword;
             const newPassword = request.body.newPassword;
+            const userService = UserServiceFactory();
             return await userService.changeOwnPassword(userId, currentPassword, newPassword);
         }
         catch (e) {
@@ -176,6 +187,7 @@ async function UserRoutes(fastify, options) {
                 throw new UnauthorizedError();
             }
             const newPassword = request.body.newPassword;
+            const userService = UserServiceFactory();
             return await userService.changeUserPassword(userId, newPassword);
         }
         catch (e) {

package/dist/services/RoleService.js

@@ -1,7 +1,6 @@
 import { 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;
@@ -36,10 +35,6 @@ class RoleService {
         }
     }
     async delete(id) {
-        const currentRole = await this.findById(id);
-        if (currentRole.readonly) {
-            throw new UnauthorizedError();
-        }
         const deletedRole = await this._repository.delete(id);
         return deletedRole;
     }