@drax/identity-back 0.5.3 → 0.5.4

package/src/services/RoleService.ts

@@ -1,15 +1,17 @@
 import {IRoleRepository} from "../interfaces/IRoleRepository";
-import { ZodErrorToValidationError} from "@drax/common-back"
+import {UnauthorizedError, ValidationError, ZodErrorToValidationError} from "@drax/common-back"
+import { AbstractService } from "@drax/crud-back"
 import {roleSchema} from "../zod/RoleZod.js";
 import {ZodError} from "zod";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import type {IRoleBase, IRole} from "@drax/identity-share";
 
-class RoleService {
+class RoleService extends AbstractService<IRole, IRoleBase, IRoleBase> {
 
     _repository: IRoleRepository
 
     constructor(roleRepostitory: IRoleRepository) {
+        super(roleRepostitory, roleSchema)
         this._repository = roleRepostitory
         console.log("RoleService constructor")
     }
@@ -29,11 +31,15 @@ class RoleService {
         }
     }
 
-    async update(id: string, roleData: IRoleBase) {
+    async update(id: string, roleData: IRoleBase): Promise<IRole> {
         try {
             roleData.name = roleData?.name?.trim()
             await roleSchema.parseAsync(roleData)
-            const role = await this._repository.update(id, roleData)
+            const currentRole = await this.findById(id)
+            if(currentRole.readonly){
+                throw new ValidationError([{field:'name', reason:"role.readonly", value:roleData.name}])
+            }
+            const role: IRole = await this._repository.update(id, roleData)
             return role
         } catch (e) {
             console.error("Error updating role", e)
@@ -44,7 +50,36 @@ class RoleService {
         }
     }
 
+    async systemUpdate(id: string, roleData: IRoleBase): Promise<IRole> {
+        try {
+            roleData.name = roleData?.name?.trim()
+            await roleSchema.parseAsync(roleData)
+            const role: IRole = await this._repository.update(id, roleData)
+            return role
+        } catch (e) {
+            console.error("Error systemUpdating role", e)
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, roleData)
+            }
+            throw e
+        }
+    }
+
     async delete(id: string): Promise<boolean> {
+        try {
+            const currentRole = await this.findById(id)
+            if(currentRole.readonly){
+                throw new UnauthorizedError()
+            }
+            const deletedRole = await this._repository.delete(id);
+            return deletedRole;
+        } catch (e) {
+            console.error("Error deleting role", e)
+            throw e
+        }
+    }
+
+    async systemDelete(id: string): Promise<boolean> {
         try {
             const deletedRole = await this._repository.delete(id);
             return deletedRole;
@@ -81,6 +116,12 @@ class RoleService {
         return roles
     }
 
+    async search(value: any): Promise<IRole[]> {
+        const limit = 100
+        const roles: IRole[] = await this._repository.search(value, limit);
+        return roles;
+    }
+
     async paginate({
                        page = 1,
                        limit = 5,

package/src/services/TenantService.ts

@@ -2,7 +2,7 @@ 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} from "@drax/identity-share";
+import {ITenantBase, ITenant, IRole} from "@drax/identity-share";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {AbstractService} from "@drax/crud-back";
 
@@ -90,6 +90,12 @@ class TenantService extends AbstractService<ITenant,ITenantBase,ITenantBase> {
 
     }
 
+    async search(value: any): Promise<ITenant[]> {
+        const limit = 100
+        const tenants: ITenant[] = await this._repository.search(value, limit);
+        return tenants;
+    }
+
     async paginate({
                        page = 1,
                        limit = 5,

package/src/services/UserApiKeyService.ts

@@ -7,12 +7,14 @@ import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import crypto from "node:crypto";
 import AuthUtils from "../utils/AuthUtils.js";
 import IdentityConfig from "../config/IdentityConfig.js";
+import {AbstractService} from "@drax/crud-back";
 
-class UserApiKeyService {
+class UserApiKeyService extends AbstractService<IUserApiKey, IUserApiKeyBase, IUserApiKeyBase>{
 
     _repository: IUserApiKeyRepository
 
     constructor(userApiKeyRepostitory: IUserApiKeyRepository) {
+        super(userApiKeyRepostitory,userApiKeySchema)
         this._repository = userApiKeyRepostitory
         console.log("UserApiKeyService constructor")
     }
@@ -22,6 +24,9 @@ class UserApiKeyService {
             userApiKeyData.name = userApiKeyData?.name?.trim()
             const secret = crypto.randomUUID()
             const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret)
+            if(!APIKEY_SECRET){
+                throw new Error('ApiKey miss configuration')
+            }
             userApiKeyData.secret = AuthUtils.generateHMAC(APIKEY_SECRET, secret)
             await userApiKeySchema.parseAsync(userApiKeyData)
             const userApiKey = await this._repository.create(userApiKeyData)
@@ -74,9 +79,14 @@ class UserApiKeyService {
 
     }
 
+
+
     async findBySecret(secret: string): Promise<IUserApiKey | null> {
         try{
             const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret)
+            if(!APIKEY_SECRET){
+                throw new Error('ApiKey miss configuration')
+            }
             const hashedSecret = AuthUtils.generateHMAC(APIKEY_SECRET, secret)
             const userApiKey: IUserApiKey = await this._repository.findBySecret(hashedSecret);
             return userApiKey

package/src/services/UserService.ts

@@ -3,15 +3,18 @@ import type {IUserRepository} from "../interfaces/IUserRepository";
 import {ZodError} from "zod";
 import {ValidationError, ZodErrorToValidationError} from "@drax/common-back";
 import AuthUtils from "../utils/AuthUtils.js";
-import {createUserSchema, editUserSchema,} from "../zod/UserZod.js";
+import {createUserSchema, editUserSchema, userBaseSchema} from "../zod/UserZod.js";
 import BadCredentialsError from "../errors/BadCredentialsError.js";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {AbstractService} from "@drax/crud-back";
+import {ITenant} from "@drax/identity-share";
 
-class UserService {
+class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate>{
 
     _repository: IUserRepository
 
     constructor(userRepository: IUserRepository) {
+        super(userRepository,userBaseSchema);
         this._repository = userRepository;
         console.log("UserService constructor")
     }
@@ -123,8 +126,11 @@ class UserService {
 
     async delete(id: string): Promise<boolean> {
         try {
-            const deletedRole: boolean = await this._repository.delete(id);
-            return deletedRole;
+            const result: boolean = await this._repository.delete(id);
+            if(!result){
+                throw new Error("error.deletionFailed")
+            }
+            return result;
         } catch (e) {
             console.error("Error deleting user", e)
             throw e
@@ -171,6 +177,12 @@ class UserService {
         }
 
     }
+
+    async search(value: any): Promise<IUser[]> {
+        const limit = 100
+        const users: IUser[] = await this._repository.search(value, limit);
+        return users;
+    }
 }
 
 export default UserService

package/src/setup/CreateOrUpdateRole.ts

@@ -18,7 +18,7 @@ async function CreateOrUpdateRole(roleData: IRoleBase) {
     }
 
     if(role){
-        const r = await roleService.update(role.id, roleData)
+        const r = await roleService.systemUpdate(role.id, roleData)
         console.log("Role Updated. Name: "+ roleData.name)
     }else{
         const r = await roleService.create(roleData)