@drax/identity-back 0.11.5 → 0.12.2

package/src/routes/TenantRoutes.ts

@@ -1,26 +1,42 @@
+import {CrudSchemaBuilder} from "@drax/crud-back";
 import TenantController from '../controllers/TenantController.js'
+import {TenantSchema, TenantBaseSchema} from '../schemas/TenantSchema.js'
+
+
 
 async function TenantRoutes(fastify, options) {
 
     const controller: TenantController = new TenantController()
+    const schemas = new CrudSchemaBuilder(TenantSchema, TenantBaseSchema,TenantBaseSchema, 'tenant', 'openApi3', ['Identity']);
+
+    //Getters
+    fastify.get('/api/tenants/search', {schema: schemas.searchSchema}, (req, rep) => controller.search(req, rep))
+
+    fastify.get('/api/tenants/:id', {schema: schemas.findByIdSchema}, (req, rep) => controller.findById(req, rep))
+
+    fastify.get('/api/tenants/all', {schema: schemas.allSchema}, (req, rep) => controller.all(req, rep))
+
+    fastify.get('/api/tenants/find', {schema: schemas.findSchema}, (req, rep) => controller.find(req, rep))
+
+    fastify.get('/api/tenants/find-one', {schema: schemas.findOneSchema}, (req, rep) => controller.findOne(req, rep))
 
-    fastify.get('/api/tenants/export', (req,rep) => controller.export(req,rep) )
+    fastify.get('/api/tenants/find-by/:field/:value', {schema: schemas.findBySchema}, (req, rep) => controller.findBy(req, rep))
 
-    fastify.get('/api/tenants/search', (req,rep) => controller.search(req,rep) )
+    fastify.get('/api/tenants/find-one-by/:field/:value', {schema: schemas.findOneBySchema}, (req, rep) => controller.findOneBy(req, rep))
 
-    fastify.get('/api/tenants/:id', (req,rep) => controller.findById(req,rep) )
+    fastify.get('/api/tenants', {schema: schemas.paginateSchema}, (req, rep) => controller.paginate(req, rep))
 
-    fastify.get('/api/tenants/name/:name', (req,rep) => controller.findByName(req,rep))
+    //Mutations
+    fastify.post('/api/tenants', {schema: schemas.createSchema}, (req, rep) => controller.create(req, rep))
 
-    fastify.get('/api/tenants/all', (req,rep) => controller.all(req,rep))
+    fastify.put('/api/tenants/:id', {schema: schemas.updateSchema}, (req, rep) => controller.update(req, rep))
 
-    fastify.get('/api/tenants', (req,rep) => controller.paginate(req,rep))
+    fastify.delete('/api/tenants/:id', {schema: schemas.deleteSchema}, (req, rep) => controller.delete(req, rep))
 
-    fastify.post('/api/tenants', (req,rep) => controller.create(req,rep))
+    //Others
+    fastify.get('/api/tenants/export', {schema: schemas.exportSchema}, (req, rep) => controller.export(req, rep))
 
-    fastify.put('/api/tenants/:id', (req,rep) => controller.update(req,rep))
 
-    fastify.delete('/api/tenants/:id', (req,rep) => controller.delete(req,rep))
 
 }
 

package/src/routes/UserApiKeyRoutes.ts

@@ -5,13 +5,29 @@ async function UserApiKeyRoutes(fastify, options) {
 
     const controller: UserApiKeyController = new UserApiKeyController()
 
-    fastify.get('/api/user-api-keys', (req,rep) => controller.paginate(req,rep) )
-
-    fastify.post('/api/user-api-keys', (req,rep) => controller.create(req,rep))
-
-    fastify.put('/api/user-api-keys/:id', (req,rep) => controller.update(req,rep))
-
-    fastify.delete('/api/user-api-keys/:id', (req,rep) => controller.delete(req,rep))
+    fastify.get('/api/user-api-keys', {
+        schema: {
+            tags: ['Identity'],
+        }
+    }, (req,rep) => controller.paginate(req,rep) )
+
+    fastify.post('/api/user-api-keys', {
+        schema: {
+            tags: ['Identity'],
+        }
+    }, (req,rep) => controller.create(req,rep))
+
+    fastify.put('/api/user-api-keys/:id', {
+        schema: {
+            tags: ['Identity'],
+        }
+    }, (req,rep) => controller.update(req,rep))
+
+    fastify.delete('/api/user-api-keys/:id', {
+        schema: {
+            tags: ['Identity'],
+        }
+    }, (req,rep) => controller.delete(req,rep))
 
 
 }

package/src/routes/UserRoutes.ts

@@ -1,42 +1,125 @@
 import UserController from "../controllers/UserController.js";
+import {zodToJsonSchema} from "zod-to-json-schema";
+import {CrudSchemaBuilder} from "@drax/crud-back";
+import {LoginBodyRequestSchema, LoginBodyResponseSchema} from "../schemas/LoginSchema.js"
+import {UserSchema, UserCreateSchema, UserUpdateSchema} from "../schemas/UserSchema.js";
+import {RegisterBodyRequestSchema, RegisterBodyResponseSchema} from "../schemas/RegisterSchema.js";
+import {
+    MyPasswordBodyRequestSchema,
+    PasswordBodyRequestSchema,
+    PasswordBodyResponseSchema
+} from "../schemas/PasswordSchema.js";
 
 async function UserRoutes(fastify, options) {
 
     const controller: UserController = new UserController()
-
-    fastify.post('/api/auth/login', (req,rep) => controller.auth(req,rep))
-
-    fastify.get('/api/auth/me', (req,rep) => controller.me(req,rep))
-
-    fastify.get('/api/users/search', (req,rep) => controller.search(req,rep) )
-
-    fastify.get('/api/users/export', (req,rep) => controller.export(req,rep) )
-
-    fastify.get('/api/users', (req,rep) => controller.paginate(req,rep))
-
-    fastify.post('/api/users', (req,rep) => controller.create(req,rep))
-
-    fastify.put('/api/users/:id', (req,rep) => controller.update(req,rep))
-
-    fastify.delete('/api/users/:id', (req,rep) => controller.delete(req,rep))
-
-    fastify.post('/api/users/register', (req,rep) => controller.register(req,rep))
-
-    fastify.get('/api/users/verify-email/:code', (req,rep) => controller.verifyEmail(req,rep))
-
-    fastify.get('/api/users/verify-phone/:code', (req,rep) => controller.verifyPhone(req,rep))
-
-    fastify.post('/api/users/password/change', (req,rep) => controller.changeMyPassword(req,rep))
-
-    fastify.post('/api/users/password/change/:id', (req,rep) => controller.changePassword(req,rep))
-
-    fastify.post('/api/users/password/recovery/request', (req,rep) => controller.passwordRecoveryRequest(req,rep))
-
-    fastify.post('/api/users/password/recovery/complete', (req,rep) => controller.recoveryPasswordComplete(req,rep))
-
-    fastify.post('/api/users/avatar', (req,rep) => controller.updateAvatar(req,rep))
-
-    fastify.get('/api/users/avatar/:filename', (req,rep) => controller.getAvatar(req,rep))
+    const schemas = new CrudSchemaBuilder(UserSchema, UserCreateSchema, UserUpdateSchema, 'tenant', 'openApi3', ['Identity']);
+
+
+    fastify.get('/api/users/search', {schema: schemas.searchSchema}, async (req, rep) => await controller.search(req, rep))
+
+    fastify.get('/api/users/export', {schema: schemas.exportSchema}, (req, rep) => controller.export(req, rep))
+
+    fastify.get('/api/users', {schema: schemas.paginateSchema}, (req, rep) => controller.paginate(req, rep))
+
+    fastify.post('/api/users', {schema: schemas.createSchema}, (req, rep) => controller.create(req, rep))
+
+    fastify.put('/api/users/:id', {schema: schemas.updateSchema}, (req, rep) => controller.update(req, rep))
+
+    fastify.delete('/api/users/:id', {schema: schemas.deleteSchema}, (req, rep) => controller.delete(req, rep))
+
+    fastify.post('/api/auth/login',
+        {
+            schema: {
+                tags: ['Auth'],
+                body: zodToJsonSchema(LoginBodyRequestSchema),
+                response: {
+                    200: zodToJsonSchema(LoginBodyResponseSchema),
+                    400: schemas.jsonErrorBodyResponse,
+                },
+            },
+        },
+        (req, rep) => controller.auth(req, rep))
+
+    fastify.get('/api/auth/me', {
+        schema: {
+            tags: ['Auth'],
+            response: {
+                200: schemas.jsonEntitySchema,
+                401: schemas.jsonErrorBodyResponse,
+                500: schemas.jsonErrorBodyResponse,
+            },
+        },
+    }, (req, rep) => controller.me(req, rep))
+
+
+    fastify.post('/api/users/register', {
+        schema: {
+            tags: ['Auth'],
+            body: zodToJsonSchema(RegisterBodyRequestSchema),
+            response: {
+                200: zodToJsonSchema(RegisterBodyResponseSchema),
+                400: schemas.jsonErrorBodyResponse,
+                500: schemas.jsonErrorBodyResponse,
+            },
+        },
+    }, (req, rep) => controller.register(req, rep))
+
+    fastify.get('/api/users/verify-email/:code', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.verifyEmail(req, rep))
+
+    fastify.get('/api/users/verify-phone/:code', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.verifyPhone(req, rep))
+
+    fastify.post('/api/users/password/change', {
+        schema: {
+            tags: ['Auth'],
+            body: zodToJsonSchema(MyPasswordBodyRequestSchema),
+            200: zodToJsonSchema(PasswordBodyResponseSchema),
+            400: schemas.jsonErrorBodyResponse,
+            500: schemas.jsonErrorBodyResponse,
+        }
+    }, (req, rep) => controller.changeMyPassword(req, rep))
+
+    fastify.post('/api/users/password/change/:id', {
+        schema: {
+            tags: ['Auth'],
+            body: zodToJsonSchema(PasswordBodyRequestSchema),
+            200: zodToJsonSchema(PasswordBodyResponseSchema),
+            400: schemas.jsonErrorBodyResponse,
+            500: schemas.jsonErrorBodyResponse,
+        }
+    }, (req, rep) => controller.changePassword(req, rep))
+
+    fastify.post('/api/users/password/recovery/request', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.passwordRecoveryRequest(req, rep))
+
+    fastify.post('/api/users/password/recovery/complete', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.recoveryPasswordComplete(req, rep))
+
+    fastify.post('/api/users/avatar', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.updateAvatar(req, rep))
+
+    fastify.get('/api/users/avatar/:filename', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.getAvatar(req, rep))
 
 }
 

package/src/schemas/LoginSchema.ts

@@ -0,0 +1,12 @@
+import z from "zod"
+
+const LoginBodyRequestSchema = z.object({
+    username: z.string(),
+    password: z.string(),
+});
+
+const LoginBodyResponseSchema = z.object({
+    accessToken: z.string()
+});
+
+export {LoginBodyRequestSchema, LoginBodyResponseSchema}

package/src/schemas/PasswordSchema.ts

@@ -0,0 +1,16 @@
+import z from "zod"
+
+const MyPasswordBodyRequestSchema = z.object({
+    currentPassword: z.string(),
+    newPassword: z.string(),
+});
+
+const PasswordBodyRequestSchema = z.object({
+    newPassword: z.string()
+});
+
+const PasswordBodyResponseSchema = z.object({
+    message: z.string()
+});
+
+export {MyPasswordBodyRequestSchema, PasswordBodyRequestSchema, PasswordBodyResponseSchema}

package/src/{zod/UserZod.ts → schemas/RegisterSchema.ts}

@@ -1,26 +1,23 @@
-import { object, string } from "zod"
+import z, {string} from "zod"
 
-export const userBaseSchema = object({
+const RegisterBodyRequestSchema = z.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({
+    phone: string({ required_error: "validation.required" }).optional(),
     password: string({ required_error: "validation.required" })
         .min(1, "validation.required")
         .min(8, "validation.password.min8")
         .max(64, "validation.password.max64"),
 });
 
-
-export const editUserSchema = userBaseSchema.extend({
+const RegisterBodyResponseSchema = z.object({
+    success: z.boolean(),
+    message: z.string().optional(),
 
 });
 
+export {RegisterBodyRequestSchema, RegisterBodyResponseSchema}

package/src/schemas/RoleSchema.ts

@@ -0,0 +1,29 @@
+import {date, object, string, array, boolean} from "zod"
+
+const RoleBaseSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .regex(/^[A-Z]/, "validation.startWithUpperCase"),
+    permissions: array(string()).optional(),
+    childRoles: array(string()).optional(),
+})
+
+const RoleSchema = RoleBaseSchema.extend({
+    _id: string(),
+    id: string().optional(),
+    permissions: array(string()).optional(),
+    readonly: boolean(),
+    childRoles: array(object({
+        _id: string(),
+        id: string().optional(),
+        name: string()
+    })).optional(),
+    createdAt: date().optional(),
+    updatedAt: date().optional()
+})
+
+
+
+export default RoleSchema
+
+export {RoleSchema, RoleBaseSchema}

package/src/schemas/TenantSchema.ts

@@ -0,0 +1,22 @@
+import { object, string, date } from "zod"
+
+const TenantBaseSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .regex(/^[A-Z]/, "validation.startWithUpperCase"),
+})
+
+
+const TenantSchema = TenantBaseSchema.extend({
+    _id: string(),
+    id: string().optional(),
+    createdAt: date(),
+    updatedAt: date()
+});
+
+
+
+export {
+    TenantSchema,
+    TenantBaseSchema
+}

package/src/{zod/UserApiKeyZod.ts → schemas/UserApiKeySchema.ts}

@@ -1,15 +1,20 @@
 import {array, object, string} from "zod"
 
-const userApiKeySchema = object({
+const UserApiKeyBaseSchema = object({
     name: string({ required_error: "validation.required" })
         .min(1, "validation.required"),
     ipv4: array(string().ip({version: "v4", message: 'validation.invalidIpv4'})),
     ipv6: array(string().ip({version: "v6", message: 'validation.invalidIpv6'})),
 
+})
 
+const UserApiKeySchema = UserApiKeyBaseSchema.extend({
+    _id: string(),
+    id: string().optional(),
+    createdBy: string(),
 })
 
 
-export default userApiKeySchema
+export default UserApiKeyBaseSchema
 
-export {userApiKeySchema}
+export {UserApiKeyBaseSchema, UserApiKeySchema}

package/src/schemas/UserSchema.ts

@@ -0,0 +1,57 @@
+import {date, object, string, boolean, array} from "zod"
+import {RoleSchema} from "./RoleSchema.js"
+import {TenantSchema} from "./TenantSchema.js"
+
+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"),
+    phone: string({ required_error: "validation.required" }).optional(),
+    active: boolean().optional(),
+    role: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    tenant: string({ required_error: "validation.required" }).nullable().optional()
+
+
+})
+
+const UserCreateSchema = UserBaseSchema.extend({
+    password: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .min(8, "validation.password.min8")
+        .max(64, "validation.password.max64"),
+});
+
+
+const UserUpdateSchema = UserBaseSchema.extend({
+
+});
+
+const UserSchema = UserBaseSchema
+    .extend({
+    _id: string(),
+    role: object({
+        _id: string(),
+        id: string().optional(),
+        name: string(),
+        permissions: array(string())
+    }).optional(),
+    active: boolean(),
+    tenant: object({
+        _id: string(),
+        id: string().optional(),
+        name: string(),
+    }).nullable().optional(),
+    createdAt: date().optional()
+});
+
+
+export {
+    UserBaseSchema,
+    UserSchema,
+    UserCreateSchema,
+    UserUpdateSchema,
+}

package/src/services/PermissionService.ts

@@ -1,22 +1,23 @@
-const permissions: string[] = []
 
 class PermissionService{
 
+    protected static permissions: string[] = []
+
     static addPermission(permission: string){
         if(PermissionService.hasPermission(permission)) return;
-        permissions.push(permission)
+        PermissionService.permissions.push(permission)
     }
 
     static removePermission(permission: string){
-        permissions.splice(permissions.indexOf(permission), 1)
+        PermissionService.permissions.splice(PermissionService.permissions.indexOf(permission), 1)
     }
 
     static hasPermission(permission: string): boolean{
-        return permissions.includes(permission)
+        return PermissionService.permissions.includes(permission)
     }
 
     static getPermissions(): string[]{
-        return permissions
+        return PermissionService.permissions
     }
 
 }

package/src/services/RoleService.ts

@@ -1,7 +1,7 @@
 import {IRoleRepository} from "../interfaces/IRoleRepository";
 import {UnauthorizedError, ValidationError, ZodErrorToValidationError} from "@drax/common-back"
 import { AbstractService } from "@drax/crud-back"
-import {roleSchema} from "../zod/RoleZod.js";
+import {RoleBaseSchema} from "../schemas/RoleSchema.js";
 import {ZodError} from "zod";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import type {IRoleBase, IRole} from "@drax/identity-share";
@@ -11,7 +11,7 @@ class RoleService extends AbstractService<IRole, IRoleBase, IRoleBase> {
     _repository: IRoleRepository
 
     constructor(roleRepostitory: IRoleRepository) {
-        super(roleRepostitory, roleSchema)
+        super(roleRepostitory, RoleBaseSchema)
         this._repository = roleRepostitory
         console.log("RoleService constructor")
     }
@@ -19,7 +19,7 @@ class RoleService extends AbstractService<IRole, IRoleBase, IRoleBase> {
     async create(roleData: IRoleBase): Promise<IRole> {
         try {
             roleData.name = roleData?.name?.trim()
-            await roleSchema.parseAsync(roleData)
+            await RoleBaseSchema.parseAsync(roleData)
             const role = await this._repository.create(roleData)
             return role
         } catch (e) {
@@ -34,7 +34,7 @@ class RoleService extends AbstractService<IRole, IRoleBase, IRoleBase> {
     async update(id: string, roleData: IRoleBase): Promise<IRole> {
         try {
             roleData.name = roleData?.name?.trim()
-            await roleSchema.parseAsync(roleData)
+            await RoleBaseSchema.parseAsync(roleData)
             const currentRole = await this.findById(id)
             if(currentRole.readonly){
                 throw new ValidationError([{field:'name', reason:"role.readonly", value:roleData.name}])
@@ -53,7 +53,7 @@ class RoleService extends AbstractService<IRole, IRoleBase, IRoleBase> {
     async systemUpdate(id: string, roleData: IRoleBase): Promise<IRole> {
         try {
             roleData.name = roleData?.name?.trim()
-            await roleSchema.parseAsync(roleData)
+            await RoleBaseSchema.parseAsync(roleData)
             const role: IRole = await this._repository.update(id, roleData)
             return role
         } catch (e) {
@@ -125,7 +125,7 @@ class RoleService extends AbstractService<IRole, IRoleBase, IRoleBase> {
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       order = false,
+                       order = "asc",
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {

package/src/services/TenantService.ts

@@ -1,17 +1,17 @@
-import {ITenantRepository} from "../interfaces/ITenantRepository";
-import {ValidationError, ZodErrorToValidationError} from "@drax/common-back"
-import {tenantSchema} from "../zod/TenantZod.js";
-import {ZodError} from "zod";
-import {ITenantBase, ITenant, IRole} from "@drax/identity-share";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {ZodErrorToValidationError} from "@drax/common-back"
 import {AbstractService} from "@drax/crud-back";
+import {TenantBaseSchema} from "../schemas/TenantSchema.js";
+import {ZodError} from "zod";
+import type {ITenantBase, ITenant} from "@drax/identity-share";
+import type {ITenantRepository} from "../interfaces/ITenantRepository";
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 
 class TenantService extends AbstractService<ITenant,ITenantBase,ITenantBase> {
 
     _repository: ITenantRepository
 
     constructor(tenantRepostitory: ITenantRepository) {
-        super(tenantRepostitory, tenantSchema)
+        super(tenantRepostitory, TenantBaseSchema)
         this._repository = tenantRepostitory
         console.log("TenantService constructor")
     }
@@ -19,7 +19,7 @@ class TenantService extends AbstractService<ITenant,ITenantBase,ITenantBase> {
     async create(tenantData: ITenantBase): Promise<ITenant> {
         try {
             tenantData.name = tenantData?.name?.trim()
-            await tenantSchema.parseAsync(tenantData)
+            await TenantBaseSchema.parseAsync(tenantData)
             const tenant = await this._repository.create(tenantData)
             return tenant
         } catch (e) {
@@ -34,7 +34,7 @@ class TenantService extends AbstractService<ITenant,ITenantBase,ITenantBase> {
     async update(id: string, tenantData: ITenantBase) {
         try {
             tenantData.name = tenantData?.name?.trim()
-            await tenantSchema.parseAsync(tenantData)
+            await TenantBaseSchema.parseAsync(tenantData)
             const tenant = await this._repository.update(id, tenantData)
             return tenant
         } catch (e) {
@@ -99,7 +99,7 @@ class TenantService extends AbstractService<ITenant,ITenantBase,ITenantBase> {
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       order = false,
+                       order = "asc",
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {

package/src/services/UserApiKeyService.ts

@@ -1,6 +1,6 @@
 import {IUserApiKeyRepository} from "../interfaces/IUserApiKeyRepository";
 import {DraxConfig, ValidationError, ZodErrorToValidationError} from "@drax/common-back"
-import {userApiKeySchema} from "../zod/UserApiKeyZod.js";
+import {UserApiKeyBaseSchema} from "../schemas/UserApiKeySchema.js";
 import {ZodError} from "zod";
 import {IUserApiKeyBase, IUserApiKey} from "@drax/identity-share";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
@@ -14,7 +14,7 @@ class UserApiKeyService extends AbstractService<IUserApiKey, IUserApiKeyBase, IU
     _repository: IUserApiKeyRepository
 
     constructor(userApiKeyRepostitory: IUserApiKeyRepository) {
-        super(userApiKeyRepostitory,userApiKeySchema)
+        super(userApiKeyRepostitory,UserApiKeyBaseSchema)
         this._repository = userApiKeyRepostitory
         console.log("UserApiKeyService constructor")
     }
@@ -28,7 +28,7 @@ class UserApiKeyService extends AbstractService<IUserApiKey, IUserApiKeyBase, IU
                 throw new Error('ApiKey miss configuration')
             }
             userApiKeyData.secret = AuthUtils.generateHMAC(APIKEY_SECRET, secret)
-            await userApiKeySchema.parseAsync(userApiKeyData)
+            await UserApiKeyBaseSchema.parseAsync(userApiKeyData)
             const userApiKey = await this._repository.create(userApiKeyData)
             userApiKey.secret = secret
             return userApiKey
@@ -45,7 +45,7 @@ class UserApiKeyService extends AbstractService<IUserApiKey, IUserApiKeyBase, IU
         try {
             userApiKeyData.name = userApiKeyData?.name?.trim()
             delete userApiKeyData.secret
-            await userApiKeySchema.parseAsync(userApiKeyData)
+            await UserApiKeyBaseSchema.parseAsync(userApiKeyData)
             const userApiKey = await this._repository.update(id, userApiKeyData)
             return userApiKey
         } catch (e) {
@@ -102,7 +102,7 @@ class UserApiKeyService extends AbstractService<IUserApiKey, IUserApiKeyBase, IU
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       order = false,
+                       order = "asc",
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {