@forklaunch/implementation-iam-base 0.1.13 → 0.1.15

package/lib/services/organization.service.js

@@ -1,35 +1,50 @@
 import { transformIntoInternalDtoMapper } from '@forklaunch/core/mappers';
 export class BaseOrganizationService {
-    em;
-    openTelemetryCollector;
-    schemaValidator;
-    mapperss;
-    #mapperss;
-    constructor(em, openTelemetryCollector, schemaValidator, mapperss) {
-        this.em = em;
-        this.openTelemetryCollector = openTelemetryCollector;
-        this.schemaValidator = schemaValidator;
-        this.mapperss = mapperss;
-        this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
-    }
-    async createOrganization(organizationDto, em) {
-        this.openTelemetryCollector.log('info', 'Creating organization');
-        const organization = this.#mapperss.CreateOrganizationDtoMapper.deserializeDtoToEntity(organizationDto);
-        await (em ?? this.em).transactional(async (innerEm) => {
-            await innerEm.persist(organization);
-        });
-        return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(organization);
-    }
-    async getOrganization(idDto, em) {
-        const organization = await (em ?? this.em).findOneOrFail('Organization', idDto);
-        return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(organization);
-    }
-    async updateOrganization(organizationDto, em) {
-        const updatedOrganization = this.#mapperss.UpdateOrganizationDtoMapper.deserializeDtoToEntity(organizationDto);
-        await (em ?? this.em).upsert(updatedOrganization);
-        return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(updatedOrganization);
-    }
-    async deleteOrganization(idDto, em) {
-        await (em ?? this.em).nativeDelete('Organization', idDto);
-    }
+  em;
+  openTelemetryCollector;
+  schemaValidator;
+  mapperss;
+  #mapperss;
+  constructor(em, openTelemetryCollector, schemaValidator, mapperss) {
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mapperss = mapperss;
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  }
+  async createOrganization(organizationDto, em) {
+    this.openTelemetryCollector.log('info', 'Creating organization');
+    const organization =
+      this.#mapperss.CreateOrganizationDtoMapper.deserializeDtoToEntity(
+        organizationDto
+      );
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(organization);
+    });
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+      organization
+    );
+  }
+  async getOrganization(idDto, em) {
+    const organization = await (em ?? this.em).findOneOrFail(
+      'Organization',
+      idDto
+    );
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+      organization
+    );
+  }
+  async updateOrganization(organizationDto, em) {
+    const updatedOrganization =
+      this.#mapperss.UpdateOrganizationDtoMapper.deserializeDtoToEntity(
+        organizationDto
+      );
+    await (em ?? this.em).upsert(updatedOrganization);
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+      updatedOrganization
+    );
+  }
+  async deleteOrganization(idDto, em) {
+    await (em ?? this.em).nativeDelete('Organization', idDto);
+  }
 }

package/lib/services/permission.service.d.ts

@@ -1,62 +1,138 @@
-import { PermissionService, RoleService } from '@forklaunch/interfaces-iam/interfaces';
+import {
+  PermissionService,
+  RoleService
+} from '@forklaunch/interfaces-iam/interfaces';
 import { IdDto, IdsDto } from '@forklaunch/common';
-import { RequestDtoMapperConstructor, ResponseDtoMapperConstructor } from '@forklaunch/core/mappers';
-import { MetricsDefinition, OpenTelemetryCollector } from '@forklaunch/core/http';
+import {
+  RequestDtoMapperConstructor,
+  ResponseDtoMapperConstructor
+} from '@forklaunch/core/mappers';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector
+} from '@forklaunch/core/http';
 import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
-import { CreatePermissionDto, PermissionDto, RoleDto, UpdatePermissionDto } from '@forklaunch/interfaces-iam/types';
+import {
+  CreatePermissionDto,
+  PermissionDto,
+  RoleDto,
+  UpdatePermissionDto
+} from '@forklaunch/interfaces-iam/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
-export declare class BasePermissionService<SchemaValidator extends AnySchemaValidator, Metrics extends MetricsDefinition = MetricsDefinition, Dto extends {
+export declare class BasePermissionService<
+  SchemaValidator extends AnySchemaValidator,
+  Metrics extends MetricsDefinition = MetricsDefinition,
+  Dto extends {
     PermissionDtoMapper: PermissionDto;
     CreatePermissionDtoMapper: CreatePermissionDto;
     UpdatePermissionDtoMapper: UpdatePermissionDto;
     RoleDtoMapper: RoleDto;
-} = {
+  } = {
     PermissionDtoMapper: PermissionDto;
     CreatePermissionDtoMapper: CreatePermissionDto;
     UpdatePermissionDtoMapper: UpdatePermissionDto;
     RoleDtoMapper: RoleDto;
-}, Entities extends {
+  },
+  Entities extends {
     PermissionDtoMapper: PermissionDto;
     CreatePermissionDtoMapper: PermissionDto;
     UpdatePermissionDtoMapper: PermissionDto;
     RoleDtoMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-} = {
+  } = {
     PermissionDtoMapper: PermissionDto;
     CreatePermissionDtoMapper: PermissionDto;
     UpdatePermissionDtoMapper: PermissionDto;
     RoleDtoMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-}> implements PermissionService {
-    #private;
-    em: EntityManager;
-    protected roleServiceFactory: () => RoleService;
-    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>;
-    protected schemaValidator: SchemaValidator;
-    protected mapperss: {
-        PermissionDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['PermissionDtoMapper'], Entities['PermissionDtoMapper']>;
-        CreatePermissionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreatePermissionDtoMapper'], Entities['CreatePermissionDtoMapper']>;
-        UpdatePermissionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdatePermissionDtoMapper'], Entities['UpdatePermissionDtoMapper']>;
-        RoleDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['RoleDtoMapper'], Entities['RoleDtoMapper']>;
-    };
-    constructor(em: EntityManager, roleServiceFactory: () => RoleService, openTelemetryCollector: OpenTelemetryCollector<Metrics>, schemaValidator: SchemaValidator, mapperss: {
-        PermissionDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['PermissionDtoMapper'], Entities['PermissionDtoMapper']>;
-        CreatePermissionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreatePermissionDtoMapper'], Entities['CreatePermissionDtoMapper']>;
-        UpdatePermissionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdatePermissionDtoMapper'], Entities['UpdatePermissionDtoMapper']>;
-        RoleDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['RoleDtoMapper'], Entities['RoleDtoMapper']>;
-    });
-    private updateRolesWithPermissions;
-    private removePermissionsFromRoles;
-    private getBatchRoles;
-    private createPermissionDto;
-    private extractCreatePermissionDtoToEntityData;
-    createPermission(createPermissionDto: Dto['CreatePermissionDtoMapper'], em?: EntityManager): Promise<Dto['PermissionDtoMapper']>;
-    createBatchPermissions(permissionDtos: Dto['CreatePermissionDtoMapper'][], em?: EntityManager): Promise<Dto['PermissionDtoMapper'][]>;
-    getPermission(idDto: IdDto, em?: EntityManager): Promise<Dto['PermissionDtoMapper']>;
-    getBatchPermissions(idsDto: IdsDto, em?: EntityManager): Promise<Dto['PermissionDtoMapper'][]>;
-    private updatePermissionDto;
-    updatePermission(permissionDto: Dto['UpdatePermissionDtoMapper'], em?: EntityManager): Promise<Dto['PermissionDtoMapper']>;
-    updateBatchPermissions(permissionDtos: Dto['UpdatePermissionDtoMapper'][], em?: EntityManager): Promise<Dto['PermissionDtoMapper'][]>;
-    deletePermission(idDto: IdDto, em?: EntityManager): Promise<void>;
-    deleteBatchPermissions(idsDto: IdsDto, em?: EntityManager): Promise<void>;
+  }
+> implements PermissionService
+{
+  #private;
+  em: EntityManager;
+  protected roleServiceFactory: () => RoleService;
+  protected openTelemetryCollector: OpenTelemetryCollector<Metrics>;
+  protected schemaValidator: SchemaValidator;
+  protected mapperss: {
+    PermissionDtoMapper: ResponseDtoMapperConstructor<
+      SchemaValidator,
+      Dto['PermissionDtoMapper'],
+      Entities['PermissionDtoMapper']
+    >;
+    CreatePermissionDtoMapper: RequestDtoMapperConstructor<
+      SchemaValidator,
+      Dto['CreatePermissionDtoMapper'],
+      Entities['CreatePermissionDtoMapper']
+    >;
+    UpdatePermissionDtoMapper: RequestDtoMapperConstructor<
+      SchemaValidator,
+      Dto['UpdatePermissionDtoMapper'],
+      Entities['UpdatePermissionDtoMapper']
+    >;
+    RoleDtoMapper: RequestDtoMapperConstructor<
+      SchemaValidator,
+      Dto['RoleDtoMapper'],
+      Entities['RoleDtoMapper']
+    >;
+  };
+  constructor(
+    em: EntityManager,
+    roleServiceFactory: () => RoleService,
+    openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    schemaValidator: SchemaValidator,
+    mapperss: {
+      PermissionDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['PermissionDtoMapper'],
+        Entities['PermissionDtoMapper']
+      >;
+      CreatePermissionDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreatePermissionDtoMapper'],
+        Entities['CreatePermissionDtoMapper']
+      >;
+      UpdatePermissionDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdatePermissionDtoMapper'],
+        Entities['UpdatePermissionDtoMapper']
+      >;
+      RoleDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['RoleDtoMapper'],
+        Entities['RoleDtoMapper']
+      >;
+    }
+  );
+  private updateRolesWithPermissions;
+  private removePermissionsFromRoles;
+  private getBatchRoles;
+  private createPermissionDto;
+  private extractCreatePermissionDtoToEntityData;
+  createPermission(
+    createPermissionDto: Dto['CreatePermissionDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['PermissionDtoMapper']>;
+  createBatchPermissions(
+    permissionDtos: Dto['CreatePermissionDtoMapper'][],
+    em?: EntityManager
+  ): Promise<Dto['PermissionDtoMapper'][]>;
+  getPermission(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['PermissionDtoMapper']>;
+  getBatchPermissions(
+    idsDto: IdsDto,
+    em?: EntityManager
+  ): Promise<Dto['PermissionDtoMapper'][]>;
+  private updatePermissionDto;
+  updatePermission(
+    permissionDto: Dto['UpdatePermissionDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['PermissionDtoMapper']>;
+  updateBatchPermissions(
+    permissionDtos: Dto['UpdatePermissionDtoMapper'][],
+    em?: EntityManager
+  ): Promise<Dto['PermissionDtoMapper'][]>;
+  deletePermission(idDto: IdDto, em?: EntityManager): Promise<void>;
+  deleteBatchPermissions(idsDto: IdsDto, em?: EntityManager): Promise<void>;
 }
-//# sourceMappingURL=permission.service.d.ts.map
+//# sourceMappingURL=permission.service.d.ts.map

package/lib/services/permission.service.js

@@ -1,159 +1,203 @@
 import { transformIntoInternalDtoMapper } from '@forklaunch/core/mappers';
 export class BasePermissionService {
-    em;
-    roleServiceFactory;
-    openTelemetryCollector;
-    schemaValidator;
-    mapperss;
-    #mapperss;
-    constructor(em, roleServiceFactory, openTelemetryCollector, schemaValidator, mapperss) {
-        this.em = em;
-        this.roleServiceFactory = roleServiceFactory;
-        this.openTelemetryCollector = openTelemetryCollector;
-        this.schemaValidator = schemaValidator;
-        this.mapperss = mapperss;
-        this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  em;
+  roleServiceFactory;
+  openTelemetryCollector;
+  schemaValidator;
+  mapperss;
+  #mapperss;
+  constructor(
+    em,
+    roleServiceFactory,
+    openTelemetryCollector,
+    schemaValidator,
+    mapperss
+  ) {
+    this.em = em;
+    this.roleServiceFactory = roleServiceFactory;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mapperss = mapperss;
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  }
+  // start: global helper functions
+  async updateRolesWithPermissions(roles, permissions) {
+    return await Promise.all(
+      roles.map(async (role) => {
+        permissions.forEach((permission) => role.permissions.add(permission));
+        return role;
+      })
+    );
+  }
+  async removePermissionsFromRoles(roles, permissions) {
+    return await Promise.all(
+      roles.map(async (role) => {
+        permissions.forEach((permission) =>
+          role.permissions.remove(permission)
+        );
+        return role;
+      })
+    );
+  }
+  async getBatchRoles(roleIds, em) {
+    return roleIds
+      ? (await this.roleServiceFactory().getBatchRoles(roleIds, em)).map(
+          (role) => {
+            return (em ?? this.em).merge(
+              this.#mapperss.RoleDtoMapper.deserializeDtoToEntity(role)
+            );
+          }
+        )
+      : [];
+  }
+  // end: global helper functions
+  // start: createPermission helper functions
+  async createPermissionDto({ permission, addToRoles }) {
+    let roles = [];
+    if (addToRoles) {
+      roles = await this.updateRolesWithPermissions(addToRoles, [permission]);
     }
-    // start: global helper functions
-    async updateRolesWithPermissions(roles, permissions) {
-        return await Promise.all(roles.map(async (role) => {
-            permissions.forEach((permission) => role.permissions.add(permission));
-            return role;
-        }));
-    }
-    async removePermissionsFromRoles(roles, permissions) {
-        return await Promise.all(roles.map(async (role) => {
-            permissions.forEach((permission) => role.permissions.remove(permission));
-            return role;
-        }));
-    }
-    async getBatchRoles(roleIds, em) {
-        return roleIds
-            ? (await this.roleServiceFactory().getBatchRoles(roleIds, em)).map((role) => {
-                return (em ?? this.em).merge(this.#mapperss.RoleDtoMapper.deserializeDtoToEntity(role));
-            })
-            : [];
-    }
-    // end: global helper functions
-    // start: createPermission helper functions
-    async createPermissionDto({ permission, addToRoles }) {
-        let roles = [];
-        if (addToRoles) {
-            roles = await this.updateRolesWithPermissions(addToRoles, [permission]);
-        }
-        return { permission, roles };
-    }
-    async extractCreatePermissionDtoToEntityData(permissionDto, em) {
-        return {
-            permission: (em ?? this.em).merge(this.#mapperss.CreatePermissionDtoMapper.deserializeDtoToEntity(permissionDto)),
-            addToRoles: permissionDto.addToRolesIds
-                ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
-                : []
-        };
-    }
-    // end: createPermission helper functions
-    async createPermission(createPermissionDto, em) {
-        const { permission, roles } = await this.createPermissionDto(await this.extractCreatePermissionDtoToEntityData(createPermissionDto, em));
-        await (em ?? this.em).transactional(async (innerEm) => {
-            await innerEm.persist([permission, ...roles]);
-        });
-        return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
-    }
-    async createBatchPermissions(permissionDtos, em) {
-        const rolesCache = {};
-        const permissions = [];
-        await (em ?? this.em).transactional(async (em) => {
-            permissionDtos.map(async (createPermissionDto) => {
-                const { permission, roles } = await this.createPermissionDto(await this.extractCreatePermissionDtoToEntityData(createPermissionDto, em));
-                roles.forEach((role) => {
-                    if (rolesCache[role.id] &&
-                        role.permissions !== rolesCache[role.id].permissions) {
-                        role.permissions.getItems().forEach((permission) => {
-                            if (!rolesCache[role.id].permissions.contains(permission)) {
-                                rolesCache[role.id].permissions.add(permission);
-                            }
-                        });
-                    }
-                    else {
-                        rolesCache[role.id] = role;
-                    }
-                });
-                permissions.push(permission);
+    return { permission, roles };
+  }
+  async extractCreatePermissionDtoToEntityData(permissionDto, em) {
+    return {
+      permission: (em ?? this.em).merge(
+        this.#mapperss.CreatePermissionDtoMapper.deserializeDtoToEntity(
+          permissionDto
+        )
+      ),
+      addToRoles: permissionDto.addToRolesIds
+        ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
+        : []
+    };
+  }
+  // end: createPermission helper functions
+  async createPermission(createPermissionDto, em) {
+    const { permission, roles } = await this.createPermissionDto(
+      await this.extractCreatePermissionDtoToEntityData(createPermissionDto, em)
+    );
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist([permission, ...roles]);
+    });
+    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
+  }
+  async createBatchPermissions(permissionDtos, em) {
+    const rolesCache = {};
+    const permissions = [];
+    await (em ?? this.em).transactional(async (em) => {
+      permissionDtos.map(async (createPermissionDto) => {
+        const { permission, roles } = await this.createPermissionDto(
+          await this.extractCreatePermissionDtoToEntityData(
+            createPermissionDto,
+            em
+          )
+        );
+        roles.forEach((role) => {
+          if (
+            rolesCache[role.id] &&
+            role.permissions !== rolesCache[role.id].permissions
+          ) {
+            role.permissions.getItems().forEach((permission) => {
+              if (!rolesCache[role.id].permissions.contains(permission)) {
+                rolesCache[role.id].permissions.add(permission);
+              }
             });
-            await (em ?? this.em).persist([
-                ...permissions,
-                ...Object.values(rolesCache)
-            ]);
+          } else {
+            rolesCache[role.id] = role;
+          }
         });
-        return permissions.map((permission) => this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission));
-    }
-    async getPermission(idDto, em) {
-        const permission = await (em ?? this.em).findOneOrFail('Permission', idDto);
-        return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
-    }
-    async getBatchPermissions(idsDto, em) {
-        return (await (em ?? this.em).find('Permission', idsDto)).map((permission) => this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission));
-    }
-    // start: updatePermission helper functions
-    updatePermissionDto = async (permissionDto, em) => {
-        const permission = this.#mapperss.UpdatePermissionDtoMapper.deserializeDtoToEntity(permissionDto);
-        const addToRoles = permissionDto.addToRolesIds
-            ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
-            : [];
-        const removeFromRoles = permissionDto.removeFromRolesIds
-            ? await this.getBatchRoles({ ids: permissionDto.removeFromRolesIds }, em)
-            : [];
-        let roles = [];
-        roles = roles.concat(await this.updateRolesWithPermissions(addToRoles, [permission]));
-        roles = roles.concat(await this.removePermissionsFromRoles(removeFromRoles, [permission]));
-        return {
-            permission,
-            roles
-        };
+        permissions.push(permission);
+      });
+      await (em ?? this.em).persist([
+        ...permissions,
+        ...Object.values(rolesCache)
+      ]);
+    });
+    return permissions.map((permission) =>
+      this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
+    );
+  }
+  async getPermission(idDto, em) {
+    const permission = await (em ?? this.em).findOneOrFail('Permission', idDto);
+    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
+  }
+  async getBatchPermissions(idsDto, em) {
+    return (await (em ?? this.em).find('Permission', idsDto)).map(
+      (permission) =>
+        this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
+    );
+  }
+  // start: updatePermission helper functions
+  updatePermissionDto = async (permissionDto, em) => {
+    const permission =
+      this.#mapperss.UpdatePermissionDtoMapper.deserializeDtoToEntity(
+        permissionDto
+      );
+    const addToRoles = permissionDto.addToRolesIds
+      ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
+      : [];
+    const removeFromRoles = permissionDto.removeFromRolesIds
+      ? await this.getBatchRoles({ ids: permissionDto.removeFromRolesIds }, em)
+      : [];
+    let roles = [];
+    roles = roles.concat(
+      await this.updateRolesWithPermissions(addToRoles, [permission])
+    );
+    roles = roles.concat(
+      await this.removePermissionsFromRoles(removeFromRoles, [permission])
+    );
+    return {
+      permission,
+      roles
     };
-    // end: updatePermission helper functions
-    async updatePermission(permissionDto, em) {
-        const { permission, roles } = await this.updatePermissionDto(permissionDto);
-        await (em ?? this.em).upsertMany([permission, ...roles]);
-        if (!em) {
-            this.em.flush();
-        }
-        return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
+  };
+  // end: updatePermission helper functions
+  async updatePermission(permissionDto, em) {
+    const { permission, roles } = await this.updatePermissionDto(permissionDto);
+    await (em ?? this.em).upsertMany([permission, ...roles]);
+    if (!em) {
+      this.em.flush();
     }
-    async updateBatchPermissions(permissionDtos, em) {
-        const rolesCache = {};
-        const permissions = [];
-        await (em ?? this.em).transactional(async (em) => {
-            permissionDtos.map(async (updatePermissionDto) => {
-                const { permission, roles } = await this.updatePermissionDto(updatePermissionDto);
-                roles.forEach((role) => {
-                    if (rolesCache[role.id] &&
-                        role.permissions !== rolesCache[role.id].permissions) {
-                        role.permissions.getItems().forEach((permission) => {
-                            if (!rolesCache[role.id].permissions.contains(permission)) {
-                                rolesCache[role.id].permissions.add(permission);
-                            }
-                        });
-                    }
-                    else {
-                        rolesCache[role.id] = role;
-                    }
-                });
-                permissions.push(permission);
+    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
+  }
+  async updateBatchPermissions(permissionDtos, em) {
+    const rolesCache = {};
+    const permissions = [];
+    await (em ?? this.em).transactional(async (em) => {
+      permissionDtos.map(async (updatePermissionDto) => {
+        const { permission, roles } =
+          await this.updatePermissionDto(updatePermissionDto);
+        roles.forEach((role) => {
+          if (
+            rolesCache[role.id] &&
+            role.permissions !== rolesCache[role.id].permissions
+          ) {
+            role.permissions.getItems().forEach((permission) => {
+              if (!rolesCache[role.id].permissions.contains(permission)) {
+                rolesCache[role.id].permissions.add(permission);
+              }
             });
-            await (em ?? this.em).persist([
-                ...permissions,
-                ...Object.values(rolesCache)
-            ]);
+          } else {
+            rolesCache[role.id] = role;
+          }
         });
-        return permissions.map((permission) => this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission));
-    }
-    async deletePermission(idDto, em) {
-        await (em ?? this.em).nativeDelete('Permission', idDto);
-    }
-    async deleteBatchPermissions(idsDto, em) {
-        await (em ?? this.em).nativeDelete('Permission', {
-            id: { $in: idsDto.ids }
-        });
-    }
+        permissions.push(permission);
+      });
+      await (em ?? this.em).persist([
+        ...permissions,
+        ...Object.values(rolesCache)
+      ]);
+    });
+    return permissions.map((permission) =>
+      this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
+    );
+  }
+  async deletePermission(idDto, em) {
+    await (em ?? this.em).nativeDelete('Permission', idDto);
+  }
+  async deleteBatchPermissions(idsDto, em) {
+    await (em ?? this.em).nativeDelete('Permission', {
+      id: { $in: idsDto.ids }
+    });
+  }
 }