@drax/identity-back 0.11.5 → 0.12.2

package/src/repository/sqlite/UserApiKeySqliteRepository.ts

@@ -1,188 +1,83 @@
 import {IUserApiKey, IUserApiKeyBase} from '@drax/identity-share'
 import {IUserApiKeyRepository} from '../../interfaces/IUserApiKeyRepository'
-import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
-import {randomUUID} from "node:crypto";
-import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/crud-share";
-import {SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort} from "@drax/common-back";
 import type {SqliteTableField} from "@drax/common-back";
 import UserSqliteRepository from "./UserSqliteRepository.js";
+import {AbstractSqliteRepository} from "@drax/crud-back";
 
 
-const tableFields: SqliteTableField[] = [
-    {name: "secret", type: "TEXT", unique: true, primary: false},
-    {name: "name", type: "TEXT", unique: false, primary: false},
-    {name: "user", type: "TEXT", unique: false, primary: false},
-    {name: "ipv4", type: "TEXT", unique: false, primary: false},
-    {name: "ipv6", type: "TEXT", unique: false, primary: false},
-    {name: "createdBy", type: "TEXT", unique: false, primary: false},
-    {name: "createdAt", type: "TEXT", unique: false, primary: false}
-]
+class UserApiKeySqliteRepository extends AbstractSqliteRepository<IUserApiKey, IUserApiKeyBase, IUserApiKeyBase> implements IUserApiKeyRepository {
 
-class UserApiKeySqliteRepository implements IUserApiKeyRepository {
-
-    private db: any;
-    private dataBaseFile: string;
     private userRepository: UserSqliteRepository;
 
+    protected db: any;
+    protected tableName: string = 'user_api_keys';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = [];
+    protected booleanFields: string[] = [];
+    protected identifier: string = '_id';
+    protected populateFields = []
+    protected tableFields: SqliteTableField[] = [
+        {name: "secret", type: "TEXT", unique: true, primary: false},
+        {name: "name", type: "TEXT", unique: false, primary: false},
+        {name: "user", type: "TEXT", unique: false, primary: false},
+        {name: "ipv4", type: "TEXT", unique: false, primary: false},
+        {name: "ipv6", type: "TEXT", unique: false, primary: false},
+        {name: "createdBy", type: "TEXT", unique: false, primary: false},
+        {name: "createdAt", type: "TEXT", unique: false, primary: false}
+    ]
+    protected verbose: boolean;
+
     constructor(dataBaseFile: string, verbose: boolean = false) {
+        super(dataBaseFile, verbose)
         this.dataBaseFile = dataBaseFile
         this.userRepository = new UserSqliteRepository(dataBaseFile, verbose)
         this.db = new sqlite(dataBaseFile, {verbose: verbose ? console.log : null});
-        this.table()
     }
 
     async findUserById(id: string) {
         return await this.userRepository.findById(id)
     }
 
-    table() {
-        const builder = new SqliteTableBuilder(
-            this.dataBaseFile,
-            'user_api_keys',
-            tableFields,
-            false);
-        builder.build('id')
-    }
-
-
-    async create(userApiKeyData: IUserApiKeyBase): Promise<IUserApiKey> {
-        try {
-
-            if (!userApiKeyData.id) {
-                userApiKeyData.id = randomUUID()
-            }
-
-            if (userApiKeyData.ipv4 && Array.isArray(userApiKeyData.ipv4) && userApiKeyData.ipv4.length > 0) {
-                userApiKeyData.ipv4 = userApiKeyData.ipv4.join(',')
-            }else{
-                userApiKeyData.ipv4 = ""
-            }
+    async prepareItem(item: any): Promise<any> {
+        if (item && item.user) {
+            item.user = await this.findUserById(item.user)
+        }
 
-            if (userApiKeyData.ipv6 && Array.isArray(userApiKeyData.ipv6) && userApiKeyData.ipv6.length > 0) {
-                userApiKeyData.ipv6 = userApiKeyData.ipv6.join(',')
-            }else{
-                userApiKeyData.ipv6 = ""
-            }
+        if (item && item.createdBy) {
+            item.createdBy = await this.findUserById(item.createdBy)
+        }
 
-            userApiKeyData.createdAt = (new Date().toISOString())
+        if (item && item.ipv4) {
+            item.ipv4 = item.ipv4 != "" ? item.ipv4.split(',') : []
+        }
 
-            const fields = Object.keys(userApiKeyData)
-                .map(field => `${field}`)
-                .join(', ');
+        if (item && item.ipv6) {
+            item.ipv6 = item.ipv6 != "" ? item.ipv6.split(',') : []
+        }
+    }
 
-            const values = Object.keys(userApiKeyData)
-                .map(field => `@${field}`)
-                .join(', ');
+    async prepareData(userApiKeyData) {
+        if (userApiKeyData.ipv4 && Array.isArray(userApiKeyData.ipv4) && userApiKeyData.ipv4.length > 0) {
+            userApiKeyData.ipv4 = userApiKeyData.ipv4.join(',')
+        } else {
+            userApiKeyData.ipv4 = ""
+        }
 
-            const stmt = this.db.prepare(`INSERT INTO user_api_keys (${fields})
-                                          VALUES (${values})`);
-            stmt.run(userApiKeyData)
-            return this.findById(userApiKeyData.id as UUID)
-        } catch (e) {
-            console.log(e)
-            throw SqliteErrorToValidationError(e, userApiKeyData)
+        if (userApiKeyData.ipv6 && Array.isArray(userApiKeyData.ipv6) && userApiKeyData.ipv6.length > 0) {
+            userApiKeyData.ipv6 = userApiKeyData.ipv6.join(',')
+        } else {
+            userApiKeyData.ipv6 = ""
         }
     }
 
-    async findById(id: string): Promise<IUserApiKey | null> {
-        const userApiKey = this.db.prepare('SELECT * FROM user_api_keys WHERE id = ?').get(id);
-        userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : []
-        userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : []
-        userApiKey.user = await this.findUserById(userApiKey.user)
-        return userApiKey
-    }
 
     async findBySecret(secret: string): Promise<IUserApiKey | null> {
         const userApiKey = this.db.prepare('SELECT * FROM user_api_keys WHERE secret = ?').get(secret);
-        userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : []
-        userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : []
-        userApiKey.user = await this.findUserById(userApiKey.user)
+        await this.decorate(userApiKey)
         return userApiKey
     }
 
-    async update(id: string, userApiKeyData: IUserApiKeyBase): Promise<IUserApiKey> {
-        try {
-
-            if (userApiKeyData.ipv4 && Array.isArray(userApiKeyData.ipv4) && userApiKeyData.ipv4.length > 0) {
-                userApiKeyData.ipv4 = userApiKeyData.ipv4.join(',')
-            }else{
-                userApiKeyData.ipv4 = ""
-            }
-
-            if (userApiKeyData.ipv6 && Array.isArray(userApiKeyData.ipv6) && userApiKeyData.ipv6.length > 0) {
-                userApiKeyData.ipv6 = userApiKeyData.ipv6.join(',')
-            }else{
-                userApiKeyData.ipv6 = ""
-            }
-
-            delete userApiKeyData.secret
-
-            const setClauses = Object.keys(userApiKeyData)
-                .map(field => `${field} = @${field}`)
-                .join(', ');
-
-            userApiKeyData.id = id
-
-            const stmt = this.db.prepare(`UPDATE user_api_keys
-                                          SET ${setClauses}
-                                          WHERE id = @id `);
-            stmt.run(userApiKeyData);
-            return this.findById(id)
-        } catch (e) {
-            console.log(e)
-            throw SqliteErrorToValidationError(e, userApiKeyData)
-        }
-
-    }
-
-    async delete(id: string): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM user_api_keys WHERE id = ?');
-        stmt.run(id);
-        return true
-    }
-
-
-    async paginate({
-                       page = 1,
-                       limit = 5,
-                       orderBy = '',
-                       order = false,
-                       search = '',
-                       filters = []
-                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
-        const offset = page > 1 ? (page - 1) * limit : 0
-
-        let where = ""
-        if (search) {
-            where = ` WHERE name LIKE '%${search}%'`
-        }
-
-        where = SqlQueryFilter.applyFilters(where, filters)
-        const sort = SqlSort.applySort(orderBy, order)
-
-        console.log("where", where)
-
-        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM user_api_keys' + where).get();
-        where += sort
-        const userApiKeys = this.db.prepare('SELECT * FROM user_api_keys ' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
-
-        for (const userApiKey of userApiKeys) {
-            userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : []
-            userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : []
-            userApiKey.user = await this.findUserById(userApiKey.user)
-            userApiKey.createdBy = await this.findUserById(userApiKey.createdBy)
-        }
-
-        return {
-            page: page,
-            limit: limit,
-            total: rCount.count,
-            items: userApiKeys
-        }
-    }
-
-
 }
 
 export default UserApiKeySqliteRepository

package/src/repository/sqlite/UserSqliteRepository.ts

@@ -1,173 +1,104 @@
 import {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
-import sqlite from "better-sqlite3";
-import {randomUUID} from "node:crypto";
-import {UUID} from "crypto";
 import {IUserRepository} from "../../interfaces/IUserRepository";
-import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/crud-share";
 import {
-    SqliteErrorToValidationError,
-    SqliteTableBuilder,
-    SqlQueryFilter,
-    SqlSort,
+
     ValidationError
 } from "@drax/common-back";
 import type {SqliteTableField} from "@drax/common-back";
 import RoleSqliteRepository from "./RoleSqliteRepository.js";
 import TenantSqliteRepository from "./TenantSqliteRepository.js";
+import {AbstractSqliteRepository} from "@drax/crud-back";
 
-const tableFields: SqliteTableField[] = [
-    {name: "name", type: "TEXT", unique: false, primary: false},
-    {name: "username", type: "TEXT", unique: true, primary: false},
-    {name: "active", type: "INTEGER", unique: false, primary: false},
-    {name: "active", type: "INTEGER", unique: false, primary: false},
-    {name: "password", type: "TEXT", unique: false, primary: false},
-    {name: "email", type: "TEXT", unique: true, primary: false},
-    {name: "phone", type: "TEXT", unique: false, primary: false},
-    {name: "role", type: "TEXT", unique: false, primary: false},
-    {name: "tenant", type: "TEXT", unique: false, primary: false},
-    {name: "groups", type: "TEXT", unique: false, primary: false},
-    {name: "avatar", type: "TEXT", unique: false, primary: false},
-    {name: "origin", type: "TEXT", unique: false, primary: false},
-    {name: "createdAt", type: "TEXT", unique: false, primary: false},
-    {name: "updatedAt", type: "TEXT", unique: false, primary: false},
-    {name: "emailVerified", type: "INTEGER", unique: false, primary: false},
-    {name: "phoneVerified", type: "INTEGER", unique: false, primary: false},
-    {name: "emailCode", type: "TEXT", unique: false, primary: false},
-    {name: "phoneCode", type: "TEXT", unique: false, primary: false},
-]
-
-class UserSqliteRepository implements IUserRepository {
-    private db: any;
+class UserSqliteRepository extends AbstractSqliteRepository<IUser, IUserCreate, IUserUpdate> implements IUserRepository {
     private roleRepository: RoleSqliteRepository;
     private tenantRepository: TenantSqliteRepository;
-    private dataBaseFile: string;
+
+    protected db: any;
+    protected tableName: string = 'users';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = [];
+    protected booleanFields: string[] = ['active'];
+    protected identifier: string = '_id';
+    protected populateFields = []
+    protected tableFields: SqliteTableField[] = [
+        {name: "name", type: "TEXT", unique: false, primary: false},
+        {name: "username", type: "TEXT", unique: true, primary: false},
+        {name: "active", type: "INTEGER", unique: false, primary: false},
+        {name: "password", type: "TEXT", unique: false, primary: false},
+        {name: "email", type: "TEXT", unique: true, primary: false},
+        {name: "phone", type: "TEXT", unique: false, primary: false},
+        {name: "role", type: "TEXT", unique: false, primary: false},
+        {name: "tenant", type: "TEXT", unique: false, primary: false},
+        {name: "groups", type: "TEXT", unique: false, primary: false},
+        {name: "avatar", type: "TEXT", unique: false, primary: false},
+        {name: "origin", type: "TEXT", unique: false, primary: false},
+        {name: "createdAt", type: "TEXT", unique: false, primary: false},
+        {name: "updatedAt", type: "TEXT", unique: false, primary: false},
+        {name: "emailVerified", type: "INTEGER", unique: false, primary: false},
+        {name: "phoneVerified", type: "INTEGER", unique: false, primary: false},
+        {name: "emailCode", type: "TEXT", unique: false, primary: false},
+        {name: "phoneCode", type: "TEXT", unique: false, primary: false},
+    ]
+    protected verbose: boolean;
 
     constructor(dataBaseFile: string, verbose: boolean = false) {
-        this.dataBaseFile = dataBaseFile
-        this.db = new sqlite(dataBaseFile, {verbose: verbose ? console.log : null});
-        this.roleRepository = new RoleSqliteRepository(dataBaseFile, verbose)
-        this.tenantRepository = new TenantSqliteRepository(dataBaseFile, verbose)
-        this.table()
+        super(dataBaseFile, verbose);
+        this.roleRepository = new RoleSqliteRepository(dataBaseFile, verbose);
+        this.tenantRepository = new TenantSqliteRepository(dataBaseFile, verbose);
     }
 
-    table() {
-        const builder = new SqliteTableBuilder(
-            this.dataBaseFile,
-            'users',
-            tableFields,
-            false);
-        builder.build('id')
-    }
 
-    normalizeData(userData: IUserCreate | IUserUpdate): void {
+    async prepareData(userData: any) {
         if (userData.groups && Array.isArray(userData.groups)) {
             userData.groups = userData.groups.join(",")
         }
         userData.active = userData.active ? 1 : 0
-    }
-
-    async create(userData: IUserCreate): Promise<IUser> {
-        if (!userData.id) {
-            userData.id = randomUUID()
-        }
 
         if (!await this.findRoleById(userData.role)) {
             throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
         }
+    }
 
-        userData.createdAt = (new Date().toISOString())
-
-        this.normalizeData(userData)
-
-        try {
-
-            const fields = Object.keys(userData)
-                .map(field => `${field}`)
-                .join(', ');
-
-            const values = Object.keys(userData)
-                .map(field => `@${field}`)
-                .join(', ');
-
-            const stmt = this.db.prepare(`INSERT INTO users (${fields})
-                                          VALUES (${values})`);
-            stmt.run(userData)
-            return this.findById(userData.id as UUID)
-        } catch (e) {
-            throw SqliteErrorToValidationError(e, userData)
+    async prepareItem(user: any) {
+        if (user && user.role) {
+            user.role = await this.findRoleById(user.role)
         }
 
+        if (user && user.tenant) {
+            user.tenant = await this.findTenantById(user.tenant)
+        }
     }
 
+
     async updatePartial(id: string, userData: IUserUpdate): Promise<IUser> {
         return this.update(id, userData)
     }
 
-    async update(id: string, userData: IUserUpdate): Promise<IUser> {
-        try {
-            if (!await this.findRoleById(userData.role)) {
-                throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
-            }
-
-            userData.updatedAt = (new Date().toISOString())
-
-            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: string): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM users WHERE id = ?');
-        stmt.run(id);
-        return true
-    }
-
-    async deleteAll(): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM users');
-        stmt.run();
-        return true
-    }
-
-    async findById(id: string): Promise<IUser> {
-        const user = this.db.prepare('SELECT * FROM users WHERE id = ?').get(id);
+    async findByUsername(username: string): Promise<IUser> {
+        const user = this.db.prepare('SELECT * FROM users WHERE username = ?').get(username);
         if (!user) {
             return null
         }
-        user.role = await this.findRoleById(user.role)
-        user.tenant = await this.findTenantById(user.tenant)
+        await this.decorate(user)
         return user
     }
 
-    async findByUsername(username: string): Promise<IUser> {
+    async findByUsernameWithPassword(username: string): Promise<IUser> {
         const user = this.db.prepare('SELECT * FROM users WHERE username = ?').get(username);
         if (!user) {
             return null
         }
-        user.role = await this.findRoleById(user.role)
-        user.tenant = await this.findTenantById(user.tenant)
+        await this.decorate(user)
         return user
     }
 
-    async findByUsernameWithPassword(username: string): Promise<IUser> {
-        const user = this.db.prepare('SELECT * FROM users WHERE username = ?').get(username);
+    async findByIdWithPassword(id: string): Promise<IUser | null> {
+        const user = this.db.prepare('SELECT * FROM users WHERE ${this.identifier} = ?').get(id);
         if (!user) {
             return null
         }
-        user.role = await this.findRoleById(user.role)
-        user.tenant = await this.findTenantById(user.tenant)
+        await this.decorate(user)
         return user
     }
 
@@ -176,8 +107,7 @@ class UserSqliteRepository implements IUserRepository {
         if (!user) {
             return null
         }
-        user.role = await this.findRoleById(user.role)
-        user.tenant = await this.findTenantById(user.tenant)
+        await this.decorate(user)
         return user
     }
 
@@ -186,8 +116,7 @@ class UserSqliteRepository implements IUserRepository {
         if (!user) {
             return null
         }
-        user.role = await this.findRoleById(user.role)
-        user.tenant = await this.findTenantById(user.tenant)
+        await this.decorate(user)
         return user
     }
 
@@ -196,8 +125,7 @@ class UserSqliteRepository implements IUserRepository {
         if (!user) {
             return null
         }
-        user.role = await this.findRoleById(user.role)
-        user.tenant = await this.findTenantById(user.tenant)
+        await this.decorate(user)
         return user
     }
 
@@ -206,54 +134,10 @@ class UserSqliteRepository implements IUserRepository {
         if (!user) {
             return null
         }
-        user.role = await this.findRoleById(user.role)
-        user.tenant = await this.findTenantById(user.tenant)
+        await this.decorate(user)
         return user
     }
 
-    async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       order= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
-
-        const offset = page > 1 ? (page - 1) * limit : 0
-
-        let where=""
-        if (search) {
-            where = ` WHERE (name LIKE '%${search}%' OR username LIKE '%${search}%') `
-        }
-
-        where = SqlQueryFilter.applyFilters(where, filters)
-        const sort = SqlSort.applySort(orderBy, order)
-
-
-        console.log("paginate where ", where, "search", search, "filters", filters)
-
-        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM users' + where).get();
-        where += sort
-        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)
-            user.role = role ? role : null
-
-            let tenant = await this.findTenantById(user.tenant)
-            user.tenant = tenant ? tenant : null
-
-            user.active = user.active === 1
-        }
-
-        return {
-            page: page,
-            limit: limit,
-            total: rCount.count,
-            items: users
-        }
-    }
 
     async findRoleById(id: string) {
         return await this.roleRepository.findById(id)
@@ -266,7 +150,7 @@ class UserSqliteRepository implements IUserRepository {
     async changePassword(id: string, password: string): Promise<boolean> {
         const stmt = this.db.prepare(`UPDATE users
                                       SET password = @password
-                                      WHERE id = @id `);
+                                      WHERE ${this.identifier} = @id `);
         stmt.run({id: id, password: password});
         return true
     }
@@ -274,10 +158,12 @@ class UserSqliteRepository implements IUserRepository {
     async changeAvatar(id: string, avatar: string): Promise<boolean> {
         const stmt = this.db.prepare(`UPDATE users
                                       SET avatar = @avatar
-                                      WHERE id = @id `);
+                                      WHERE ${this.identifier} = @id `);
         stmt.run({id: id, avatar: avatar});
         return true
     }
+
+
 }
 
 export default UserSqliteRepository

package/src/routes/RoleRoutes.ts

@@ -1,30 +1,53 @@
 import RoleController from "../controllers/RoleController.js";
-
-
+import {CrudSchemaBuilder} from "@drax/crud-back";
+import {RoleBaseSchema, RoleSchema} from "../schemas/RoleSchema.js";
+import {zodToJsonSchema} from "zod-to-json-schema";
+import zod from "zod";
 
 async function RoleRoutes(fastify, options) {
 
     const controller: RoleController = new RoleController()
+    const schemas = new CrudSchemaBuilder(RoleSchema, RoleBaseSchema, RoleBaseSchema, 'role','openApi3', ['Identity']);
 
-    fastify.get('/api/permissions', (req,rep) => controller.permissions(req,rep))
+    fastify.get('/api/roles/search', {schema: schemas.searchSchema}, (req, rep) => controller.search(req, rep))
 
-    fastify.get('/api/roles/export', (req,rep) => controller.export(req,rep) )
+    fastify.get('/api/roles/:id', {schema: schemas.findByIdSchema}, (req, rep) => controller.findById(req, rep))
 
-    fastify.get('/api/roles/search', (req,rep) => controller.search(req,rep))
+    fastify.get('/api/roles/all', {schema: schemas.allSchema}, (req, rep) => controller.all(req, rep))
 
-    fastify.get('/api/roles/:id', (req,rep) => controller.findById(req,rep))
+    fastify.get('/api/roles', {schema: schemas.paginateSchema}, (req, rep) => controller.paginate(req, rep))
 
-    fastify.get('/api/roles/name/:name', (req,rep) => controller.findByName(req,rep))
+    fastify.post('/api/roles', {schema: schemas.createSchema}, (req, rep) => controller.create(req, rep))
 
-    fastify.get('/api/roles/all', (req,rep) => controller.all(req,rep))
+    fastify.put('/api/roles/:id', {schema: schemas.updateSchema}, (req, rep) => controller.update(req, rep))
 
-    fastify.get('/api/roles', (req,rep) => controller.paginate(req,rep))
+    fastify.delete('/api/roles/:id', {schema: schemas.deleteSchema}, (req, rep) => controller.delete(req, rep))
 
-    fastify.post('/api/roles', (req,rep) => controller.create(req,rep))
+    fastify.get('/api/roles/export', {schema: schemas.exportSchema}, (req, rep) => controller.export(req, rep))
 
-    fastify.put('/api/roles/:id', (req,rep) => controller.update(req,rep))
+    fastify.get('/api/permissions', {
+        schema: {
+            tags: ['Identity'],
+            response: {
+                200: zodToJsonSchema(zod.array(zod.string())),
+                401: schemas.jsonErrorBodyResponse,
+                403: schemas.jsonErrorBodyResponse,
+            }
+        }
+    }, (req, rep) => controller.permissions(req, rep))
 
-    fastify.delete('/api/roles/:id', (req,rep) => controller.delete(req,rep))
+    fastify.get('/api/roles/name/:name', {
+        schema: {
+            tags: ['Identity'],
+            params: zodToJsonSchema(zod.object({name: zod.string()})),
+            response: {
+                200: schemas.jsonEntitySchema,
+                401: schemas.jsonErrorBodyResponse,
+                403: schemas.jsonErrorBodyResponse,
+                404: schemas.jsonErrorBodyResponse,
+            }
+        }
+    }, (req, rep) => controller.findByName(req, rep))
 
 }