@drax/identity-back 0.1.0 → 0.1.2

package/dist/services/TenantService.js

@@ -14,6 +14,7 @@ class TenantService {
             return tenant;
         }
         catch (e) {
+            console.error("Error creating tenant", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, tenantData);
             }
@@ -28,6 +29,7 @@ class TenantService {
             return tenant;
         }
         catch (e) {
+            console.error("Error updating tenant", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, tenantData);
             }
@@ -35,25 +37,54 @@ class TenantService {
         }
     }
     async delete(id) {
-        const currentTenant = await this.findById(id);
-        const deletedTenant = await this._repository.delete(id);
-        return deletedTenant;
+        try {
+            const deletedTenant = await this._repository.delete(id);
+            return deletedTenant;
+        }
+        catch (e) {
+            console.error("Error deleting tenant", e);
+            throw e;
+        }
     }
     async findById(id) {
-        const tenant = await this._repository.findById(id);
-        return tenant;
+        try {
+            const tenant = await this._repository.findById(id);
+            return tenant;
+        }
+        catch (e) {
+            console.error("Error finding tenant by id", e);
+            throw e;
+        }
     }
     async findByName(name) {
-        const tenant = await this._repository.findByName(name);
-        return tenant;
+        try {
+            const tenant = await this._repository.findByName(name);
+            return tenant;
+        }
+        catch (e) {
+            console.error("Error finding tenant by name", e);
+            throw e;
+        }
     }
     async fetchAll() {
-        const tenants = await this._repository.fetchAll();
-        return tenants;
+        try {
+            const tenants = await this._repository.fetchAll();
+            return tenants;
+        }
+        catch (e) {
+            console.error("Error fetching all tenants", e);
+            throw e;
+        }
     }
     async paginate({ page = 1, limit = 5, orderBy = '', orderDesc = false, search = '', filters = [] }) {
-        const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
-        return pagination;
+        try {
+            const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
+            return pagination;
+        }
+        catch (e) {
+            console.error("Error paginating tenants", e);
+            throw e;
+        }
     }
 }
 export default TenantService;

package/dist/services/UserApiKeyService.js

@@ -21,6 +21,7 @@ class UserApiKeyService {
             return userApiKey;
         }
         catch (e) {
+            console.error("Error creating userApiKey", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, userApiKeyData);
             }
@@ -36,6 +37,7 @@ class UserApiKeyService {
             return userApiKey;
         }
         catch (e) {
+            console.error("Error updating userApiKey", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, userApiKeyData);
             }
@@ -43,23 +45,46 @@ class UserApiKeyService {
         }
     }
     async delete(id) {
-        const currentUserApiKey = await this.findById(id);
-        const deletedUserApiKey = await this._repository.delete(id);
-        return deletedUserApiKey;
+        try {
+            const deletedUserApiKey = await this._repository.delete(id);
+            return deletedUserApiKey;
+        }
+        catch (e) {
+            console.error("Error deleting userApiKey", e);
+            throw e;
+        }
     }
     async findById(id) {
-        const userApiKey = await this._repository.findById(id);
-        return userApiKey;
+        try {
+            const userApiKey = await this._repository.findById(id);
+            return userApiKey;
+        }
+        catch (e) {
+            console.error("Error finding userApiKey by id", e);
+            throw e;
+        }
     }
     async findBySecret(secret) {
-        const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret);
-        const hashedSecret = AuthUtils.generateHMAC(APIKEY_SECRET, secret);
-        const userApiKey = await this._repository.findBySecret(hashedSecret);
-        return userApiKey;
+        try {
+            const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret);
+            const hashedSecret = AuthUtils.generateHMAC(APIKEY_SECRET, secret);
+            const userApiKey = await this._repository.findBySecret(hashedSecret);
+            return userApiKey;
+        }
+        catch (e) {
+            console.error("Error finding userApiKey by secret", e);
+            throw e;
+        }
     }
     async paginate({ page = 1, limit = 5, orderBy = '', orderDesc = false, search = '', filters = [] }) {
-        const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
-        return pagination;
+        try {
+            const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
+            return pagination;
+        }
+        catch (e) {
+            console.error("Error paginating userApiKeys", e);
+            throw e;
+        }
     }
 }
 export default UserApiKeyService;

package/dist/services/UserService.js

@@ -74,6 +74,7 @@ class UserService {
             return user;
         }
         catch (e) {
+            console.error("Error creating user", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, userData);
             }
@@ -91,6 +92,7 @@ class UserService {
             return user;
         }
         catch (e) {
+            console.error("Error updating user", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, userData);
             }
@@ -98,20 +100,44 @@ class UserService {
         }
     }
     async delete(id) {
-        const deletedRole = await this._repository.delete(id);
-        return deletedRole;
+        try {
+            const deletedRole = await this._repository.delete(id);
+            return deletedRole;
+        }
+        catch (e) {
+            console.error("Error deleting user", e);
+            throw e;
+        }
     }
     async findById(id) {
-        const user = await this._repository.findById(id);
-        return user;
+        try {
+            const user = await this._repository.findById(id);
+            return user;
+        }
+        catch (e) {
+            console.error("Error finding user by id", e);
+            throw e;
+        }
     }
     async findByUsername(username) {
-        const user = await this._repository.findByUsername(username);
-        return user;
+        try {
+            const user = await this._repository.findByUsername(username);
+            return user;
+        }
+        catch (e) {
+            console.error("Error finding user by username", e);
+            throw e;
+        }
     }
     async paginate({ page = 1, limit = 5, orderBy = '', orderDesc = false, search = '', filters = [] }) {
-        const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
-        return pagination;
+        try {
+            const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
+            return pagination;
+        }
+        catch (e) {
+            console.error("Error paginating users", e);
+            throw e;
+        }
     }
 }
 export default UserService;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -60,5 +60,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "bec2a22554155ef5deab5a55245878a4449932ad"
+  "gitHead": "79fef47b0aa97b4c46f057396dcafeb132ed1258"
 }

package/src/services/TenantService.ts

@@ -21,6 +21,7 @@ class TenantService {
             const tenant = await this._repository.create(tenantData)
             return tenant
         } catch (e) {
+            console.error("Error creating tenant", e)
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, tenantData)
             }
@@ -35,6 +36,7 @@ class TenantService {
             const tenant = await this._repository.update(id, tenantData)
             return tenant
         } catch (e) {
+            console.error("Error updating tenant", e)
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, tenantData)
             }
@@ -43,35 +45,65 @@ class TenantService {
     }
 
     async delete(id: string): Promise<boolean> {
-        const currentTenant = await this.findById(id)
-        const deletedTenant = await this._repository.delete(id);
-        return deletedTenant;
+        try {
+            const deletedTenant = await this._repository.delete(id);
+            return deletedTenant;
+        } catch (e) {
+            console.error("Error deleting tenant", e)
+            throw e;
+        }
+
     }
 
     async findById(id: string): Promise<ITenant | null> {
-        const tenant: ITenant = await this._repository.findById(id);
-        return tenant
+        try {
+            const tenant: ITenant = await this._repository.findById(id);
+            return tenant
+        } catch (e) {
+            console.error("Error finding tenant by id", e)
+            throw e;
+        }
+
     }
 
     async findByName(name: string): Promise<ITenant | null> {
-        const tenant: ITenant = await this._repository.findByName(name);
-        return tenant
+        try {
+            const tenant: ITenant = await this._repository.findByName(name);
+            return tenant
+        } catch (e) {
+            console.error("Error finding tenant by name", e)
+            throw e;
+        }
+
     }
 
     async fetchAll(): Promise<ITenant[]> {
-        const tenants: ITenant[] = await this._repository.fetchAll();
-        return tenants
+        try {
+            const tenants: ITenant[] = await this._repository.fetchAll();
+            return tenants
+        } catch (e) {
+            console.error("Error fetching all tenants", e)
+            throw e;
+        }
+
     }
 
     async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       orderDesc= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>>{
-        const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
-        return pagination;
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       orderDesc = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
+        try {
+            const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
+            return pagination;
+        } catch (e) {
+            console.error("Error paginating tenants", e)
+            throw e;
+        }
+
     }
 
 

package/src/services/UserApiKeyService.ts

@@ -28,6 +28,7 @@ class UserApiKeyService {
             userApiKey.secret = secret
             return userApiKey
         } catch (e) {
+            console.error("Error creating userApiKey", e)
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, userApiKeyData)
             }
@@ -43,6 +44,7 @@ class UserApiKeyService {
             const userApiKey = await this._repository.update(id, userApiKeyData)
             return userApiKey
         } catch (e) {
+            console.error("Error updating userApiKey", e)
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, userApiKeyData)
             }
@@ -51,33 +53,56 @@ class UserApiKeyService {
     }
 
     async delete(id: string): Promise<boolean> {
-        const currentUserApiKey = await this.findById(id)
-        const deletedUserApiKey = await this._repository.delete(id);
-        return deletedUserApiKey;
+        try {
+            const deletedUserApiKey = await this._repository.delete(id);
+            return deletedUserApiKey;
+        } catch (e) {
+            console.error("Error deleting userApiKey", e)
+            throw e
+        }
+
     }
 
     async findById(id: string): Promise<IUserApiKey | null> {
-        const userApiKey: IUserApiKey = await this._repository.findById(id);
-        return userApiKey
+        try{
+            const userApiKey: IUserApiKey = await this._repository.findById(id);
+            return userApiKey
+        }catch (e){
+            console.error("Error finding userApiKey by id", e)
+            throw e
+        }
+
     }
 
     async findBySecret(secret: string): Promise<IUserApiKey | null> {
-        const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret)
-        const hashedSecret = AuthUtils.generateHMAC(APIKEY_SECRET, secret)
-        const userApiKey: IUserApiKey = await this._repository.findBySecret(hashedSecret);
-        return userApiKey
+        try{
+            const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret)
+            const hashedSecret = AuthUtils.generateHMAC(APIKEY_SECRET, secret)
+            const userApiKey: IUserApiKey = await this._repository.findBySecret(hashedSecret);
+            return userApiKey
+        }catch (e){
+            console.error("Error finding userApiKey by secret", e)
+            throw e
+        }
+
     }
 
 
     async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       orderDesc= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>>{
-        const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
-        return pagination;
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       orderDesc = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
+        try {
+            const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
+            return pagination;
+        } catch (e) {
+            console.error("Error paginating userApiKeys", e)
+            throw e
+        }
     }
 
 

package/src/services/UserService.ts

@@ -16,68 +16,68 @@ class UserService {
         console.log("UserService constructor")
     }
 
-    async auth(username : string, password : string){
+    async auth(username: string, password: string) {
         let user = null
-        console.log("auth username",username)
+        console.log("auth username", username)
         user = await this.findByUsername(username)
         if (user && user.active && AuthUtils.checkPassword(password, user.password)) {
             //TODO: Generar Sesion
             const session = '123'
             const accessToken = AuthUtils.generateToken(user.id.toString(), user.username, user.role.id, user.tenant?.id, session)
             return {accessToken: accessToken}
-        }else{
+        } else {
             throw new BadCredentialsError()
         }
     }
 
-    async changeUserPassword(userId : string, newPassword : string){
+    async changeUserPassword(userId: string, newPassword: string) {
         const user = await this.findById(userId)
-        if(user){
-            newPassword =  AuthUtils.hashPassword(newPassword)
+        if (user) {
+            newPassword = AuthUtils.hashPassword(newPassword)
             await this._repository.changePassword(userId, newPassword)
             return true
-        }else{
+        } else {
             throw new ValidationError([{field: 'userId', reason: 'validation.notFound'}])
         }
     }
 
 
-    async changeOwnPassword(userId : string, currentPassword : string, newPassword : string){
+    async changeOwnPassword(userId: string, currentPassword: string, newPassword: string) {
         const user = await this.findById(userId)
 
 
-        if(user && user.active){
+        if (user && user.active) {
 
-            if(currentPassword === newPassword){
+            if (currentPassword === newPassword) {
                 throw new ValidationError([{field: 'newPassword', reason: 'validation.password.currentDifferent'}])
             }
 
             if (AuthUtils.checkPassword(currentPassword, user.password)) {
-                newPassword =  AuthUtils.hashPassword(newPassword)
+                newPassword = AuthUtils.hashPassword(newPassword)
                 await this._repository.changePassword(userId, newPassword)
                 return true
-            }else{
+            } else {
                 throw new ValidationError([{field: 'currentPassword', reason: 'validation.notMatch'}])
             }
 
-        }else{
+        } else {
             throw new BadCredentialsError()
         }
     }
 
-    async changeAvatar(userId : string, avatar: string){
+    async changeAvatar(userId: string, avatar: string) {
         const user = await this.findById(userId)
-        if(user && user.active){
-                await this._repository.changeAvatar(userId, avatar)
-                return true
-        }else{
+        if (user && user.active) {
+            await this._repository.changeAvatar(userId, avatar)
+            return true
+        } else {
             throw new BadCredentialsError()
         }
     }
 
 
     async create(userData: IUserCreate): Promise<IUser> {
-        try{
+        try {
             userData.name = userData?.name?.trim()
             userData.username = userData.username.trim()
             userData.password = userData.password.trim()
@@ -89,9 +89,10 @@ class UserService {
 
             const user: IUser = await this._repository.create(userData)
             return user
-        }catch (e){
-            if(e instanceof ZodError){
-                throw ZodErrorToValidationError(e,userData)
+        } catch (e) {
+            console.error("Error creating user", e)
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, userData)
             }
             throw e
         }
@@ -100,50 +101,75 @@ class UserService {
     }
 
     async update(id: string, userData: IUserUpdate) {
-        try{
-        userData.name = userData.name.trim()
-        userData.username = userData.username.trim()
-        delete userData.password
-        userData.tenant = userData.tenant === "" ? null : userData.tenant
+        try {
+            userData.name = userData.name.trim()
+            userData.username = userData.username.trim()
+            delete userData.password
+            userData.tenant = userData.tenant === "" ? null : userData.tenant
 
-        await editUserSchema.parseAsync(userData)
+            await editUserSchema.parseAsync(userData)
 
 
-        const user: IUser = await this._repository.update(id, userData)
-        return user
-        }catch (e){
-            if(e instanceof ZodError){
-                throw ZodErrorToValidationError(e,userData)
+            const user: IUser = await this._repository.update(id, userData)
+            return user
+        } catch (e) {
+            console.error("Error updating user", e)
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, userData)
             }
             throw e
         }
     }
 
     async delete(id: string): Promise<boolean> {
-        const deletedRole: boolean = await this._repository.delete(id);
-        return deletedRole;
+        try {
+            const deletedRole: boolean = await this._repository.delete(id);
+            return deletedRole;
+        } catch (e) {
+            console.error("Error deleting user", e)
+            throw e
+        }
+
     }
 
     async findById(id: string): Promise<IUser> {
-        const user: IUser = await this._repository.findById(id);
-        return user
+        try {
+            const user: IUser = await this._repository.findById(id);
+            return user
+        } catch (e) {
+            console.error("Error finding user by id", e)
+            throw e
+        }
+
     }
 
     async findByUsername(username: string): Promise<IUser | null> {
-        const user: IUser = await this._repository.findByUsername(username);
-        return user
+        try {
+            const user: IUser = await this._repository.findByUsername(username);
+            return user
+        } catch (e) {
+            console.error("Error finding user by username", e)
+            throw e
+        }
+
     }
 
     async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       orderDesc= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>>{
-
-        const pagination = await this._repository.paginate( {page, limit, orderBy, orderDesc, search, filters});
-        return pagination;
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       orderDesc = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
+        try {
+            const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
+            return pagination;
+        } catch (e) {
+            console.error("Error paginating users", e)
+            throw e;
+        }
+
     }
 }