@forklaunch/implementation-iam-base 0.1.17 → 0.2.1

package/lib/eject/services/organization.service.ts

@@ -1,14 +1,16 @@
 import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  evaluateTelemetryOptions,
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
 import {
   InternalDtoMapper,
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
 } from '@forklaunch/core/mappers';
-import {
-  MetricsDefinition,
-  OpenTelemetryCollector
-} from '@forklaunch/core/http';
 import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
 import { OrganizationService } from '@forklaunch/interfaces-iam/interfaces';
 import {
@@ -61,17 +63,22 @@ export class BaseOrganizationService<
   }
 > implements OrganizationService<OrganizationStatus>
 {
-  #mapperss: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mapperss>,
+  #mappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mappers>,
     Entities,
     Dto
   >;
+  private evaluatedTelemetryOptions: {
+    logging?: boolean;
+    metrics?: boolean;
+    tracing?: boolean;
+  };
 
   constructor(
     public em: EntityManager,
     protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected schemaValidator: SchemaValidator,
-    protected mapperss: {
+    protected mappers: {
       OrganizationDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['OrganizationDtoMapper'],
@@ -87,25 +94,45 @@ export class BaseOrganizationService<
         Dto['UpdateOrganizationDtoMapper'],
         Entities['UpdateOrganizationDtoMapper']
       >;
+    },
+    options?: {
+      telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry
+      ? evaluateTelemetryOptions(options.telemetry).enabled
+      : {
+          logging: false,
+          metrics: false,
+          tracing: false
+        };
   }
 
   async createOrganization(
     organizationDto: Dto['CreateOrganizationDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['OrganizationDtoMapper']> {
-    this.openTelemetryCollector.log('info', 'Creating organization');
-    const organization =
-      this.#mapperss.CreateOrganizationDtoMapper.deserializeDtoToEntity(
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Creating organization',
         organizationDto
       );
-    await (em ?? this.em).transactional(async (innerEm) => {
-      await innerEm.persist(organization);
-    });
+    }
+
+    const organization =
+      await this.#mappers.CreateOrganizationDtoMapper.deserializeDtoToEntity(
+        organizationDto,
+        em ?? this.em
+      );
 
-    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+    if (em) {
+      await em.persist(organization);
+    } else {
+      await this.em.persistAndFlush(organization);
+    }
+
+    return this.#mappers.OrganizationDtoMapper.serializeEntityToDto(
       organization
     );
   }
@@ -114,11 +141,16 @@ export class BaseOrganizationService<
     idDto: IdDto,
     em?: EntityManager
   ): Promise<Dto['OrganizationDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Getting organization', idDto);
+    }
+
     const organization = await (em ?? this.em).findOneOrFail(
       'Organization',
       idDto
     );
-    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+
+    return this.#mappers.OrganizationDtoMapper.serializeEntityToDto(
       organization as Entities['OrganizationDtoMapper']
     );
   }
@@ -127,17 +159,39 @@ export class BaseOrganizationService<
     organizationDto: Dto['UpdateOrganizationDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['OrganizationDtoMapper']> {
-    const updatedOrganization =
-      this.#mapperss.UpdateOrganizationDtoMapper.deserializeDtoToEntity(
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Updating organization',
         organizationDto
       );
-    await (em ?? this.em).upsert(updatedOrganization);
-    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+    }
+
+    const updatedOrganization =
+      await this.#mappers.UpdateOrganizationDtoMapper.deserializeDtoToEntity(
+        organizationDto,
+        em ?? this.em
+      );
+
+    if (em) {
+      await em.persist(updatedOrganization);
+    } else {
+      await this.em.persistAndFlush(updatedOrganization);
+    }
+
+    return this.#mappers.OrganizationDtoMapper.serializeEntityToDto(
       updatedOrganization
     );
   }
 
   async deleteOrganization(idDto: IdDto, em?: EntityManager): Promise<void> {
-    await (em ?? this.em).nativeDelete('Organization', idDto);
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Deleting organization', idDto);
+    }
+
+    if (em) {
+      await em.nativeDelete('Organization', idDto);
+    } else {
+      await this.em.nativeDelete('Organization', idDto);
+    }
   }
 }

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

@@ -4,22 +4,24 @@ import {
 } from '@forklaunch/interfaces-iam/interfaces';
 
 import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  evaluateTelemetryOptions,
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
 import {
   InternalDtoMapper,
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
 } from '@forklaunch/core/mappers';
-import {
-  MetricsDefinition,
-  OpenTelemetryCollector
-} from '@forklaunch/core/http';
 import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
 import {
   CreatePermissionDto,
   PermissionDto,
-  RoleDto,
-  UpdatePermissionDto
+  UpdatePermissionDto,
+  UpdateRoleDto
 } from '@forklaunch/interfaces-iam/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
@@ -31,38 +33,49 @@ export class BasePermissionService<
     PermissionDtoMapper: PermissionDto;
     CreatePermissionDtoMapper: CreatePermissionDto;
     UpdatePermissionDtoMapper: UpdatePermissionDto;
-    RoleDtoMapper: RoleDto;
+    RoleEntityMapper: UpdateRoleDto;
   } = {
     PermissionDtoMapper: PermissionDto;
     CreatePermissionDtoMapper: CreatePermissionDto;
     UpdatePermissionDtoMapper: UpdatePermissionDto;
-    RoleDtoMapper: RoleDto;
+    RoleEntityMapper: UpdateRoleDto;
   },
   Entities extends {
     PermissionDtoMapper: PermissionDto;
     CreatePermissionDtoMapper: PermissionDto;
     UpdatePermissionDtoMapper: PermissionDto;
-    RoleDtoMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
+    RoleEntityMapper: MapNestedDtoArraysToCollections<
+      UpdateRoleDto,
+      'permissions'
+    >;
   } = {
     PermissionDtoMapper: PermissionDto;
     CreatePermissionDtoMapper: PermissionDto;
     UpdatePermissionDtoMapper: PermissionDto;
-    RoleDtoMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
+    RoleEntityMapper: MapNestedDtoArraysToCollections<
+      UpdateRoleDto,
+      'permissions'
+    >;
   }
 > implements PermissionService
 {
-  #mapperss: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mapperss>,
+  #mappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mappers>,
     Entities,
     Dto
   >;
+  private evaluatedTelemetryOptions: {
+    logging?: boolean;
+    metrics?: boolean;
+    tracing?: boolean;
+  };
 
   constructor(
     public em: EntityManager,
     protected roleServiceFactory: () => RoleService,
     protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected schemaValidator: SchemaValidator,
-    protected mapperss: {
+    protected mappers: {
       PermissionDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['PermissionDtoMapper'],
@@ -78,22 +91,32 @@ export class BasePermissionService<
         Dto['UpdatePermissionDtoMapper'],
         Entities['UpdatePermissionDtoMapper']
       >;
-      RoleDtoMapper: RequestDtoMapperConstructor<
+      RoleEntityMapper: RequestDtoMapperConstructor<
         SchemaValidator,
-        Dto['RoleDtoMapper'],
-        Entities['RoleDtoMapper']
+        Dto['RoleEntityMapper'],
+        Entities['RoleEntityMapper']
       >;
+    },
+    options?: {
+      telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry
+      ? evaluateTelemetryOptions(options.telemetry).enabled
+      : {
+          logging: false,
+          metrics: false,
+          tracing: false
+        };
   }
 
   // start: global helper functions
   private async updateRolesWithPermissions(
-    roles: Entities['RoleDtoMapper'][],
+    roles: Entities['RoleEntityMapper'][],
     permissions: Entities['PermissionDtoMapper'][]
-  ): Promise<Entities['RoleDtoMapper'][]> {
-    return await Promise.all(
+  ): Promise<Entities['RoleEntityMapper'][]> {
+    return Promise.all(
       roles.map(async (role) => {
         permissions.forEach((permission) => role.permissions.add(permission));
         return role;
@@ -102,10 +125,10 @@ export class BasePermissionService<
   }
 
   private async removePermissionsFromRoles(
-    roles: Entities['RoleDtoMapper'][],
+    roles: Entities['RoleEntityMapper'][],
     permissions: Entities['PermissionDtoMapper'][]
-  ): Promise<Entities['RoleDtoMapper'][]> {
-    return await Promise.all(
+  ): Promise<Entities['RoleEntityMapper'][]> {
+    return Promise.all(
       roles.map(async (role) => {
         permissions.forEach((permission) =>
           role.permissions.remove(permission)
@@ -118,14 +141,19 @@ export class BasePermissionService<
   private async getBatchRoles(
     roleIds?: IdsDto,
     em?: EntityManager
-  ): Promise<Entities['RoleDtoMapper'][]> {
+  ): Promise<Entities['RoleEntityMapper'][]> {
     return roleIds
-      ? (await this.roleServiceFactory().getBatchRoles(roleIds, em)).map(
-          (role) => {
-            return (em ?? this.em).merge(
-              this.#mapperss.RoleDtoMapper.deserializeDtoToEntity(role)
-            );
-          }
+      ? await Promise.all(
+          (await this.roleServiceFactory().getBatchRoles(roleIds, em)).map(
+            async (role) => {
+              return (em ?? this.em).merge(
+                await this.#mappers.RoleEntityMapper.deserializeDtoToEntity(
+                  role,
+                  em ?? this.em
+                )
+              );
+            }
+          )
         )
       : [];
   }
@@ -137,12 +165,12 @@ export class BasePermissionService<
     addToRoles
   }: {
     permission: Entities['PermissionDtoMapper'];
-    addToRoles: Entities['RoleDtoMapper'][];
+    addToRoles: Entities['RoleEntityMapper'][];
   }): Promise<{
     permission: Entities['PermissionDtoMapper'];
-    roles: Entities['RoleDtoMapper'][];
+    roles: Entities['RoleEntityMapper'][];
   }> {
-    let roles: Entities['RoleDtoMapper'][] = [];
+    let roles: Entities['RoleEntityMapper'][] = [];
     if (addToRoles) {
       roles = await this.updateRolesWithPermissions(addToRoles, [permission]);
     }
@@ -155,12 +183,13 @@ export class BasePermissionService<
     em?: EntityManager
   ): Promise<{
     permission: Entities['PermissionDtoMapper'];
-    addToRoles: Entities['RoleDtoMapper'][];
+    addToRoles: Entities['RoleEntityMapper'][];
   }> {
     return {
       permission: (em ?? this.em).merge(
-        this.#mapperss.CreatePermissionDtoMapper.deserializeDtoToEntity(
-          permissionDto
+        await this.#mappers.CreatePermissionDtoMapper.deserializeDtoToEntity(
+          permissionDto,
+          em ?? this.em
         )
       ),
       addToRoles: permissionDto.addToRolesIds
@@ -174,53 +203,72 @@ export class BasePermissionService<
     createPermissionDto: Dto['CreatePermissionDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['PermissionDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Creating permission',
+        createPermissionDto
+      );
+    }
     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);
+
+    if (em) {
+      await em.persist([permission, ...roles]);
+    } else {
+      await this.em.persistAndFlush([permission, ...roles]);
+    }
+
+    return this.#mappers.PermissionDtoMapper.serializeEntityToDto(permission);
   }
 
   async createBatchPermissions(
     permissionDtos: Dto['CreatePermissionDtoMapper'][],
     em?: EntityManager
   ): Promise<Dto['PermissionDtoMapper'][]> {
-    const rolesCache: Record<string, Entities['RoleDtoMapper']> = {};
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Creating batch permissions',
+        permissionDtos
+      );
+    }
+    const rolesCache: Record<string, Entities['RoleEntityMapper']> = {};
     const permissions: Entities['PermissionDtoMapper'][] = [];
-    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);
+    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;
+        }
       });
-      await (em ?? this.em).persist([
-        ...permissions,
-        ...Object.values(rolesCache)
-      ]);
+      permissions.push(permission);
     });
+    const entities = [...permissions, ...Object.values(rolesCache)];
 
-    return permissions.map((permission) =>
-      this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
+    if (em) {
+      await em.persist(entities);
+    } else {
+      await this.em.persistAndFlush(entities);
+    }
+
+    return Promise.all(
+      permissions.map(async (permission) =>
+        this.#mappers.PermissionDtoMapper.serializeEntityToDto(permission)
+      )
     );
   }
 
@@ -228,8 +276,11 @@ export class BasePermissionService<
     idDto: IdDto,
     em?: EntityManager
   ): Promise<Dto['PermissionDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Getting permission', idDto);
+    }
     const permission = await (em ?? this.em).findOneOrFail('Permission', idDto);
-    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(
+    return this.#mappers.PermissionDtoMapper.serializeEntityToDto(
       permission as Entities['PermissionDtoMapper']
     );
   }
@@ -238,11 +289,15 @@ export class BasePermissionService<
     idsDto: IdsDto,
     em?: EntityManager
   ): Promise<Dto['PermissionDtoMapper'][]> {
-    return (await (em ?? this.em).find('Permission', idsDto)).map(
-      (permission) =>
-        this.#mapperss.PermissionDtoMapper.serializeEntityToDto(
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Getting batch permissions', idsDto);
+    }
+    return Promise.all(
+      (await (em ?? this.em).find('Permission', idsDto)).map((permission) =>
+        this.#mappers.PermissionDtoMapper.serializeEntityToDto(
           permission as Entities['PermissionDtoMapper']
         )
+      )
     );
   }
 
@@ -252,11 +307,12 @@ export class BasePermissionService<
     em?: EntityManager
   ): Promise<{
     permission: Entities['PermissionDtoMapper'];
-    roles: Entities['RoleDtoMapper'][];
+    roles: Entities['RoleEntityMapper'][];
   }> => {
     const permission =
-      this.#mapperss.UpdatePermissionDtoMapper.deserializeDtoToEntity(
-        permissionDto
+      await this.#mappers.UpdatePermissionDtoMapper.deserializeDtoToEntity(
+        permissionDto,
+        em ?? this.em
       );
     const addToRoles = permissionDto.addToRolesIds
       ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
@@ -265,7 +321,7 @@ export class BasePermissionService<
       ? await this.getBatchRoles({ ids: permissionDto.removeFromRolesIds }, em)
       : [];
 
-    let roles: Entities['RoleDtoMapper'][] = [];
+    let roles: Entities['RoleEntityMapper'][] = [];
 
     roles = roles.concat(
       await this.updateRolesWithPermissions(addToRoles, [permission])
@@ -285,19 +341,32 @@ export class BasePermissionService<
     permissionDto: Dto['UpdatePermissionDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['PermissionDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Updating permission', permissionDto);
+    }
     const { permission, roles } = await this.updatePermissionDto(permissionDto);
-    await (em ?? this.em).upsertMany([permission, ...roles]);
-    if (!em) {
-      this.em.flush();
+    const entities = await (em ?? this.em).upsertMany([permission, ...roles]);
+
+    if (em) {
+      await em.persist(entities);
+    } else {
+      await this.em.persistAndFlush(entities);
     }
-    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
+
+    return this.#mappers.PermissionDtoMapper.serializeEntityToDto(permission);
   }
 
   async updateBatchPermissions(
     permissionDtos: Dto['UpdatePermissionDtoMapper'][],
     em?: EntityManager
   ): Promise<Dto['PermissionDtoMapper'][]> {
-    const rolesCache: Record<string, Entities['RoleDtoMapper']> = {};
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Updating batch permissions',
+        permissionDtos
+      );
+    }
+    const rolesCache: Record<string, Entities['RoleEntityMapper']> = {};
     const permissions: Entities['PermissionDtoMapper'][] = [];
     await (em ?? this.em).transactional(async (em) => {
       permissionDtos.map(async (updatePermissionDto) => {
@@ -319,18 +388,26 @@ export class BasePermissionService<
         });
         permissions.push(permission);
       });
-      await (em ?? this.em).persist([
-        ...permissions,
-        ...Object.values(rolesCache)
-      ]);
+      const entities = [...permissions, ...Object.values(rolesCache)];
+
+      if (em) {
+        await em.persist(entities);
+      } else {
+        await this.em.persistAndFlush(entities);
+      }
     });
 
-    return permissions.map((permission) =>
-      this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
+    return Promise.all(
+      permissions.map((permission) =>
+        this.#mappers.PermissionDtoMapper.serializeEntityToDto(permission)
+      )
     );
   }
 
   async deletePermission(idDto: IdDto, em?: EntityManager): Promise<void> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Deleting permission', idDto);
+    }
     await (em ?? this.em).nativeDelete('Permission', idDto);
   }
 
@@ -338,6 +415,9 @@ export class BasePermissionService<
     idsDto: IdsDto,
     em?: EntityManager
   ): Promise<void> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Deleting batch permissions', idsDto);
+    }
     await (em ?? this.em).nativeDelete('Permission', {
       id: { $in: idsDto.ids }
     });