@forklaunch/implementation-iam-base 0.5.8 → 0.6.1

package/lib/services/index.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -8,18 +8,14 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
-  if ((from && typeof from === 'object') || typeof from === 'function') {
+  if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, {
-          get: () => from[key],
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
-var __toCommonJS = (mod) =>
-  __copyProps(__defProp({}, '__esModule', { value: true }), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // services/index.ts
 var services_exports = {};
@@ -32,10 +28,9 @@ __export(services_exports, {
 module.exports = __toCommonJS(services_exports);
 
 // services/organization.service.ts
-var import_http = require('@forklaunch/core/http');
-var import_internal = require('@forklaunch/internal');
+var import_http = require("@forklaunch/core/http");
 var BaseOrganizationService = class {
-  _mappers;
+  // protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   evaluatedTelemetryOptions;
   em;
   openTelemetryCollector;
@@ -46,118 +41,97 @@ var BaseOrganizationService = class {
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = (0, import_internal.transformIntoInternalMapper)(
-      mappers,
-      schemaValidator
-    );
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? (0, import_http.evaluateTelemetryOptions)(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
-  }
-  async createOrganization(organizationDto, em) {
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  async createOrganization(organizationDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Creating organization',
+        "Creating organization",
         organizationDto
       );
     }
-    const organization =
-      await this._mappers.CreateOrganizationMapper.deserializeDtoToEntity(
-        organizationDto,
-        em ?? this.em
-      );
+    const organization = await this.mappers.CreateOrganizationMapper.toEntity(
+      organizationDto,
+      em ?? this.em,
+      ...args
+    );
     if (em) {
       await em.persist(organization);
     } else {
       await this.em.persistAndFlush(organization);
     }
-    return this._mappers.OrganizationMapper.serializeEntityToDto(organization);
+    return this.mappers.OrganizationMapper.toDto(organization);
   }
   async getOrganization(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Getting organization', idDto);
+      this.openTelemetryCollector.info("Getting organization", idDto);
     }
     const organization = await (em ?? this.em).findOneOrFail(
-      'Organization',
+      "Organization",
       idDto,
       {
-        populate: ['id', '*']
+        populate: ["id", "*"]
       }
     );
-    return this._mappers.OrganizationMapper.serializeEntityToDto(organization);
+    return this.mappers.OrganizationMapper.toDto(
+      organization
+    );
   }
-  async updateOrganization(organizationDto, em) {
+  async updateOrganization(organizationDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Updating organization',
+        "Updating organization",
         organizationDto
       );
     }
-    const updatedOrganization =
-      await this._mappers.UpdateOrganizationMapper.deserializeDtoToEntity(
-        organizationDto,
-        em ?? this.em
-      );
+    const updatedOrganization = await this.mappers.UpdateOrganizationMapper.toEntity(
+      organizationDto,
+      em ?? this.em,
+      ...args
+    );
     if (em) {
       await em.persist(updatedOrganization);
     } else {
       await this.em.persistAndFlush(updatedOrganization);
     }
-    return this._mappers.OrganizationMapper.serializeEntityToDto(
-      updatedOrganization
-    );
+    return this.mappers.OrganizationMapper.toDto(updatedOrganization);
   }
   async deleteOrganization(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Deleting organization', idDto);
+      this.openTelemetryCollector.info("Deleting organization", idDto);
     }
     if (em) {
-      await em.nativeDelete('Organization', idDto);
+      await em.nativeDelete("Organization", idDto);
     } else {
-      await this.em.nativeDelete('Organization', idDto);
+      await this.em.nativeDelete("Organization", idDto);
     }
   }
 };
 
 // services/permission.service.ts
-var import_http2 = require('@forklaunch/core/http');
-var import_internal2 = require('@forklaunch/internal');
+var import_http2 = require("@forklaunch/core/http");
 var BasePermissionService = class {
-  _mappers;
   evaluatedTelemetryOptions;
   em;
   roleServiceFactory;
   openTelemetryCollector;
   schemaValidator;
   mappers;
-  constructor(
-    em,
-    roleServiceFactory,
-    openTelemetryCollector,
-    schemaValidator,
-    mappers,
-    options
-  ) {
+  constructor(em, roleServiceFactory, openTelemetryCollector, schemaValidator, mappers, options) {
     this.em = em;
     this.roleServiceFactory = roleServiceFactory;
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = (0, import_internal2.transformIntoInternalMapper)(
-      mappers,
-      schemaValidator
-    );
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? (0, import_http2.evaluateTelemetryOptions)(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http2.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
   }
   // start: global helper functions
   async updateRolesWithPermissions(roles, permissions) {
@@ -171,90 +145,105 @@ var BasePermissionService = class {
   async removePermissionsFromRoles(roles, permissions) {
     return Promise.all(
       roles.map(async (role) => {
-        permissions.forEach((permission) =>
-          role.permissions.remove(permission)
+        permissions.forEach(
+          (permission) => role.permissions.remove(permission)
         );
         return role;
       })
     );
   }
   async getBatchRoles(roles, em) {
-    return roles
-      ? await Promise.all(
-          (await this.roleServiceFactory().getBatchRoles(roles, em)).map(
-            async (role) => {
-              return (em ?? this.em).merge(
-                await this._mappers.RoleEntityMapper.deserializeDtoToEntity(
-                  role,
-                  em ?? this.em
-                )
-              );
-            }
-          )
-        )
-      : [];
+    return roles ? await Promise.all(
+      (await this.roleServiceFactory().getBatchRoles(roles, em)).map(
+        async (role) => {
+          return (em ?? this.em).merge(
+            await this.mappers.RoleEntityMapper.toEntity(
+              role,
+              em ?? this.em
+            )
+          );
+        }
+      )
+    ) : [];
   }
   // end: global helper functions
   // start: createPermission helper functions
-  async createPermissionDto({ permission, addToRoles }) {
+  async createPermissionEntity({
+    permission,
+    addToRoles
+  }) {
     let roles = [];
     if (addToRoles) {
       roles = await this.updateRolesWithPermissions(addToRoles, [permission]);
     }
     return { permission, roles };
   }
-  async extractCreatePermissionDtoToEntityData(permissionDto, em) {
+  async extractCreatePermissionEntityToEntityData(permissionDto, em, ...args) {
     return {
       permission: (em ?? this.em).merge(
-        await this._mappers.CreatePermissionMapper.deserializeDtoToEntity(
+        await this.mappers.CreatePermissionMapper.toEntity(
           permissionDto,
-          em ?? this.em
+          em ?? this.em,
+          ...args
         )
       ),
-      addToRoles: permissionDto.addToRolesIds
-        ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
-        : []
+      addToRoles: permissionDto.addToRolesIds ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em) : []
     };
   }
   // end: createPermission helper functions
-  async createPermission(createPermissionDto, em) {
+  async createPermission(createPermissionEntity, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Creating permission',
-        createPermissionDto
+        "Creating permission",
+        createPermissionEntity
       );
     }
-    const { permission, roles } = await this.createPermissionDto(
-      await this.extractCreatePermissionDtoToEntityData(createPermissionDto, em)
+    const { permission, roles } = await this.createPermissionEntity(
+      await this.extractCreatePermissionEntityToEntityData(
+        createPermissionEntity,
+        em,
+        ...args
+      )
     );
     if (em) {
       await em.persist([permission, ...roles]);
     } else {
       await this.em.persistAndFlush([permission, ...roles]);
     }
-    return this._mappers.PermissionMapper.serializeEntityToDto(permission);
+    return this.mappers.PermissionMapper.toDto(permission);
   }
   async createBatchPermissions(permissionDtos, em) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Creating batch permissions',
+        "Creating batch permissions",
         permissionDtos
       );
     }
     const rolesCache = {};
     const permissions = [];
-    permissionDtos.map(async (createPermissionDto) => {
-      const { permission, roles } = await this.createPermissionDto(
-        await this.extractCreatePermissionDtoToEntityData(
-          createPermissionDto,
+    permissionDtos.map(async (createPermissionEntity) => {
+      const { permission, roles } = await this.createPermissionEntity(
+        await this.extractCreatePermissionEntityToEntityData(
+          createPermissionEntity,
           em
         )
       );
+      await Promise.all(
+        roles.map(async (role) => {
+          if (role.permissions.isInitialized()) {
+            return role.permissions.init();
+          }
+        })
+      );
+      await Promise.all(
+        roles.map(async (role) => {
+          if (role.permissions.isInitialized()) {
+            return role.permissions.init();
+          }
+        })
+      );
       roles.forEach((role) => {
-        if (
-          rolesCache[role.id] &&
-          role.permissions !== rolesCache[role.id].permissions
-        ) {
+        if (rolesCache[role.id] && role.permissions !== rolesCache[role.id].permissions) {
           role.permissions.getItems().forEach((permission2) => {
             if (!rolesCache[role.id].permissions.contains(permission2)) {
               rolesCache[role.id].permissions.add(permission2);
@@ -273,41 +262,41 @@ var BasePermissionService = class {
       await this.em.persistAndFlush(entities);
     }
     return Promise.all(
-      permissions.map(async (permission) =>
-        this._mappers.PermissionMapper.serializeEntityToDto(permission)
+      permissions.map(
+        async (permission) => this.mappers.PermissionMapper.toDto(permission)
       )
     );
   }
   async getPermission(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Getting permission', idDto);
+      this.openTelemetryCollector.info("Getting permission", idDto);
     }
-    const permission = await (em ?? this.em).findOneOrFail('Permission', idDto);
-    return this._mappers.PermissionMapper.serializeEntityToDto(permission);
+    const permission = await (em ?? this.em).findOneOrFail("Permission", idDto);
+    return this.mappers.PermissionMapper.toDto(
+      permission
+    );
   }
   async getBatchPermissions(idsDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Getting batch permissions', idsDto);
+      this.openTelemetryCollector.info("Getting batch permissions", idsDto);
     }
     return Promise.all(
-      (await (em ?? this.em).find('Permission', idsDto)).map((permission) =>
-        this._mappers.PermissionMapper.serializeEntityToDto(permission)
+      (await (em ?? this.em).find("Permission", idsDto)).map(
+        (permission) => this.mappers.PermissionMapper.toDto(
+          permission
+        )
       )
     );
   }
   // start: updatePermission helper functions
-  updatePermissionDto = async (permissionDto, em) => {
-    const permission =
-      await this._mappers.UpdatePermissionMapper.deserializeDtoToEntity(
-        permissionDto,
-        em ?? this.em
-      );
-    const addToRoles = permissionDto.addToRolesIds
-      ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
-      : [];
-    const removeFromRoles = permissionDto.removeFromRolesIds
-      ? await this.getBatchRoles({ ids: permissionDto.removeFromRolesIds }, em)
-      : [];
+  updatePermissionDto = async (permissionDto, em, ...args) => {
+    const permission = await this.mappers.UpdatePermissionMapper.toEntity(
+      permissionDto,
+      em ?? this.em,
+      ...args
+    );
+    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])
@@ -323,7 +312,7 @@ var BasePermissionService = class {
   // end: updatePermission helper functions
   async updatePermission(permissionDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Updating permission', permissionDto);
+      this.openTelemetryCollector.info("Updating permission", permissionDto);
     }
     const { permission, roles } = await this.updatePermissionDto(permissionDto);
     const entities = await (em ?? this.em).upsertMany([permission, ...roles]);
@@ -332,12 +321,12 @@ var BasePermissionService = class {
     } else {
       await this.em.persistAndFlush(entities);
     }
-    return this._mappers.PermissionMapper.serializeEntityToDto(permission);
+    return this.mappers.PermissionMapper.toDto(permission);
   }
   async updateBatchPermissions(permissionDtos, em) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Updating batch permissions',
+        "Updating batch permissions",
         permissionDtos
       );
     }
@@ -345,13 +334,9 @@ var BasePermissionService = class {
     const permissions = [];
     await (em ?? this.em).transactional(async (em2) => {
       permissionDtos.map(async (updatePermissionDto) => {
-        const { permission, roles } =
-          await this.updatePermissionDto(updatePermissionDto);
+        const { permission, roles } = await this.updatePermissionDto(updatePermissionDto);
         roles.forEach((role) => {
-          if (
-            rolesCache[role.id] &&
-            role.permissions !== rolesCache[role.id].permissions
-          ) {
+          if (rolesCache[role.id] && role.permissions !== rolesCache[role.id].permissions) {
             role.permissions.getItems().forEach((permission2) => {
               if (!rolesCache[role.id].permissions.contains(permission2)) {
                 rolesCache[role.id].permissions.add(permission2);
@@ -371,32 +356,30 @@ var BasePermissionService = class {
       }
     });
     return Promise.all(
-      permissions.map((permission) =>
-        this._mappers.PermissionMapper.serializeEntityToDto(permission)
+      permissions.map(
+        (permission) => this.mappers.PermissionMapper.toDto(permission)
       )
     );
   }
   async deletePermission(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Deleting permission', idDto);
+      this.openTelemetryCollector.info("Deleting permission", idDto);
     }
-    await (em ?? this.em).nativeDelete('Permission', idDto);
+    await (em ?? this.em).nativeDelete("Permission", idDto);
   }
   async deleteBatchPermissions(idsDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Deleting batch permissions', idsDto);
+      this.openTelemetryCollector.info("Deleting batch permissions", idsDto);
     }
-    await (em ?? this.em).nativeDelete('Permission', {
+    await (em ?? this.em).nativeDelete("Permission", {
       id: { $in: idsDto.ids }
     });
   }
 };
 
 // services/role.service.ts
-var import_http3 = require('@forklaunch/core/http');
-var import_internal3 = require('@forklaunch/internal');
+var import_http3 = require("@forklaunch/core/http");
 var BaseRoleService = class {
-  _mappers;
   evaluatedTelemetryOptions;
   em;
   openTelemetryCollector;
@@ -407,43 +390,35 @@ var BaseRoleService = class {
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = (0, import_internal3.transformIntoInternalMapper)(
-      mappers,
-      schemaValidator
-    );
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? (0, import_http3.evaluateTelemetryOptions)(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
-  }
-  async createRole(roleDto, em) {
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http3.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  async createRole(roleDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Creating role', roleDto);
+      this.openTelemetryCollector.info("Creating role", roleDto);
     }
-    const role = await this._mappers.CreateRoleMapper.deserializeDtoToEntity(
+    const role = await this.mappers.CreateRoleMapper.toEntity(
       roleDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
     if (em) {
       await em.persist(role);
     } else {
       await this.em.persistAndFlush(role);
     }
-    return this._mappers.RoleMapper.serializeEntityToDto(role);
+    return this.mappers.RoleMapper.toDto(role);
   }
-  async createBatchRoles(roleDtos, em) {
+  async createBatchRoles(roleDtos, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Creating batch roles', roleDtos);
+      this.openTelemetryCollector.info("Creating batch roles", roleDtos);
     }
     const roles = await Promise.all(
-      roleDtos.map(async (roleDto) =>
-        this._mappers.CreateRoleMapper.deserializeDtoToEntity(
-          roleDto,
-          em ?? this.em
-        )
+      roleDtos.map(
+        async (roleDto) => this.mappers.CreateRoleMapper.toEntity(roleDto, em ?? this.em, ...args)
       )
     );
     if (em) {
@@ -452,61 +427,59 @@ var BaseRoleService = class {
       await this.em.persistAndFlush(roles);
     }
     return Promise.all(
-      roles.map((role) => this._mappers.RoleMapper.serializeEntityToDto(role))
+      roles.map((role) => this.mappers.RoleMapper.toDto(role))
     );
   }
   async getRole({ id }, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Getting role', { id });
+      this.openTelemetryCollector.info("Getting role", { id });
     }
-    const role = await (em ?? this.em).findOneOrFail('Role', id, {
-      populate: ['id', '*']
+    const role = await (em ?? this.em).findOneOrFail("Role", id, {
+      populate: ["id", "*"]
     });
-    return this._mappers.RoleMapper.serializeEntityToDto(role);
+    return this.mappers.RoleMapper.toDto(role);
   }
   async getBatchRoles({ ids }, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Getting batch roles', { ids });
+      this.openTelemetryCollector.info("Getting batch roles", { ids });
     }
     return Promise.all(
-      (
-        await (em ?? this.em).find(
-          'Role',
-          {
-            id: { $in: ids }
-          },
-          {
-            populate: ['id', '*']
-          }
-        )
-      ).map((role) => this._mappers.RoleMapper.serializeEntityToDto(role))
+      (await (em ?? this.em).find(
+        "Role",
+        {
+          id: { $in: ids }
+        },
+        {
+          populate: ["id", "*"]
+        }
+      )).map(
+        (role) => this.mappers.RoleMapper.toDto(role)
+      )
     );
   }
-  async updateRole(roleDto, em) {
+  async updateRole(roleDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Updating role', roleDto);
+      this.openTelemetryCollector.info("Updating role", roleDto);
     }
-    const role = await this._mappers.UpdateRoleMapper.deserializeDtoToEntity(
+    const role = await this.mappers.UpdateRoleMapper.toEntity(
       roleDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
     if (em) {
       await em.persist(role);
     } else {
       await this.em.persistAndFlush(role);
     }
-    return this._mappers.RoleMapper.serializeEntityToDto(role);
+    return this.mappers.RoleMapper.toDto(role);
   }
-  async updateBatchRoles(roleDtos, em) {
+  async updateBatchRoles(roleDtos, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Updating batch roles', roleDtos);
+      this.openTelemetryCollector.info("Updating batch roles", roleDtos);
     }
     const roles = await Promise.all(
-      roleDtos.map(async (roleDto) =>
-        this._mappers.UpdateRoleMapper.deserializeDtoToEntity(
-          roleDto,
-          em ?? this.em
-        )
+      roleDtos.map(
+        async (roleDto) => this.mappers.UpdateRoleMapper.toEntity(roleDto, em ?? this.em, ...args)
       )
     );
     if (em) {
@@ -515,58 +488,28 @@ var BaseRoleService = class {
       await this.em.persistAndFlush(roles);
     }
     return Promise.all(
-      roles.map((role) => this._mappers.RoleMapper.serializeEntityToDto(role))
+      roles.map(
+        (role) => this.mappers.RoleMapper.toDto(role)
+      )
     );
   }
   async deleteRole(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Deleting role', idDto);
+      this.openTelemetryCollector.info("Deleting role", idDto);
     }
-    await (em ?? this.em).nativeDelete('Role', idDto);
+    await (em ?? this.em).nativeDelete("Role", idDto);
   }
   async deleteBatchRoles(idsDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Deleting batch roles', idsDto);
+      this.openTelemetryCollector.info("Deleting batch roles", idsDto);
     }
-    await (em ?? this.em).nativeDelete('Role', { id: { $in: idsDto.ids } });
+    await (em ?? this.em).nativeDelete("Role", { id: { $in: idsDto.ids } });
   }
 };
 
 // services/user.service.ts
-var import_http4 = require('@forklaunch/core/http');
-var import_internal4 = require('@forklaunch/internal');
+var import_http4 = require("@forklaunch/core/http");
 var BaseUserService = class {
-  constructor(
-    em,
-    passwordEncryptionPublicKeyPath,
-    roleServiceFactory,
-    organizationServiceFactory,
-    openTelemetryCollector,
-    schemaValidator,
-    mappers,
-    options
-  ) {
-    this.options = options;
-    this.em = em;
-    this.passwordEncryptionPublicKeyPath = passwordEncryptionPublicKeyPath;
-    this.roleServiceFactory = roleServiceFactory;
-    this.organizationServiceFactory = organizationServiceFactory;
-    this.openTelemetryCollector = openTelemetryCollector;
-    this.schemaValidator = schemaValidator;
-    this.mappers = mappers;
-    this._mappers = (0, import_internal4.transformIntoInternalMapper)(
-      mappers,
-      schemaValidator
-    );
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? (0, import_http4.evaluateTelemetryOptions)(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
-  }
-  _mappers;
   evaluatedTelemetryOptions;
   em;
   passwordEncryptionPublicKeyPath;
@@ -575,30 +518,46 @@ var BaseUserService = class {
   openTelemetryCollector;
   schemaValidator;
   mappers;
-  async createUser(userDto, em) {
+  constructor(em, passwordEncryptionPublicKeyPath, roleServiceFactory, organizationServiceFactory, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.passwordEncryptionPublicKeyPath = passwordEncryptionPublicKeyPath;
+    this.roleServiceFactory = roleServiceFactory;
+    this.organizationServiceFactory = organizationServiceFactory;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http4.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  async createUser(userDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Creating user', userDto);
+      this.openTelemetryCollector.info("Creating user", userDto);
     }
-    const user = await this._mappers.CreateUserMapper.deserializeDtoToEntity(
+    const user = await this.mappers.CreateUserMapper.toEntity(
       userDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
     if (em) {
       await em.persist(user);
     } else {
       await this.em.persistAndFlush(user);
     }
-    return this._mappers.UserMapper.serializeEntityToDto(user);
+    return this.mappers.UserMapper.toDto(user);
   }
-  async createBatchUsers(userDtos, em) {
+  async createBatchUsers(userDtos, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Creating batch users', userDtos);
+      this.openTelemetryCollector.info("Creating batch users", userDtos);
     }
     const users = await Promise.all(
-      userDtos.map(async (createUserDto) =>
-        this._mappers.CreateUserMapper.deserializeDtoToEntity(
+      userDtos.map(
+        async (createUserDto) => this.mappers.CreateUserMapper.toEntity(
           createUserDto,
-          em ?? this.em
+          em ?? this.em,
+          ...args
         )
       )
     );
@@ -608,54 +567,56 @@ var BaseUserService = class {
       await this.em.persistAndFlush(users);
     }
     return Promise.all(
-      users.map((user) => this._mappers.UserMapper.serializeEntityToDto(user))
+      users.map((user) => this.mappers.UserMapper.toDto(user))
     );
   }
   async getUser(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Getting user', idDto);
+      this.openTelemetryCollector.info("Getting user", idDto);
     }
-    const user = await (em ?? this.em).findOneOrFail('User', idDto, {
-      populate: ['id', '*']
+    const user = await (em ?? this.em).findOneOrFail("User", idDto, {
+      populate: ["id", "*"]
     });
-    return this._mappers.UserMapper.serializeEntityToDto(user);
+    return this.mappers.UserMapper.toDto(user);
   }
   async getBatchUsers(idsDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Getting batch users', idsDto);
+      this.openTelemetryCollector.info("Getting batch users", idsDto);
     }
     return Promise.all(
-      (
-        await (em ?? this.em).find('User', idsDto, {
-          populate: ['id', '*']
-        })
-      ).map((user) => this._mappers.UserMapper.serializeEntityToDto(user))
+      (await (em ?? this.em).find("User", idsDto, {
+        populate: ["id", "*"]
+      })).map(
+        (user) => this.mappers.UserMapper.toDto(user)
+      )
     );
   }
-  async updateUser(userDto, em) {
+  async updateUser(userDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Updating user', userDto);
+      this.openTelemetryCollector.info("Updating user", userDto);
     }
-    const user = await this._mappers.UpdateUserMapper.deserializeDtoToEntity(
+    const user = await this.mappers.UpdateUserMapper.toEntity(
       userDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
     if (em) {
       await em.persist(user);
     } else {
       await this.em.persistAndFlush(user);
     }
-    return this._mappers.UserMapper.serializeEntityToDto(user);
+    return this.mappers.UserMapper.toDto(user);
   }
-  async updateBatchUsers(userDtos, em) {
+  async updateBatchUsers(userDtos, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Updating batch users', userDtos);
+      this.openTelemetryCollector.info("Updating batch users", userDtos);
     }
     const users = await Promise.all(
-      userDtos.map(async (updateUserDto) =>
-        this._mappers.UpdateUserMapper.deserializeDtoToEntity(
+      userDtos.map(
+        async (updateUserDto) => this.mappers.UpdateUserMapper.toEntity(
           updateUserDto,
-          em ?? this.em
+          em ?? this.em,
+          ...args
         )
       )
     );
@@ -665,51 +626,44 @@ var BaseUserService = class {
       await this.em.persistAndFlush(users);
     }
     return Promise.all(
-      users.map((user) => this._mappers.UserMapper.serializeEntityToDto(user))
+      users.map((user) => this.mappers.UserMapper.toDto(user))
     );
   }
   async deleteUser(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Deleting user', idDto);
+      this.openTelemetryCollector.info("Deleting user", idDto);
     }
-    await (em ?? this.em).nativeDelete('User', idDto);
+    await (em ?? this.em).nativeDelete("User", idDto);
   }
   async deleteBatchUsers(idsDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Deleting batch users', idsDto);
+      this.openTelemetryCollector.info("Deleting batch users", idsDto);
     }
-    await (em ?? this.em).nativeDelete('User', idsDto);
+    await (em ?? this.em).nativeDelete("User", idsDto);
   }
   async verifyHasRole(idDto, roleId) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Verifying user has role', {
+      this.openTelemetryCollector.info("Verifying user has role", {
         idDto,
         roleId
       });
     }
     const user = await this.getUser(idDto);
-    if (
-      user.roles.filter((role) => {
-        return roleId == role.id;
-      }).length === 0
-    ) {
+    if (user.roles.filter((role) => {
+      return roleId == role.id;
+    }).length === 0) {
       throw new Error(`User ${idDto.id} does not have role ${roleId}`);
     }
   }
   async verifyHasPermission(idDto, permissionId) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Verifying user has permission', {
+      this.openTelemetryCollector.info("Verifying user has permission", {
         idDto,
         permissionId
       });
     }
     const user = await this.getUser(idDto);
-    if (
-      user.roles
-        .map((role) => role.permissions.map((permission) => permission.id))
-        .flat()
-        .filter((id) => id == permissionId).length === 0
-    ) {
+    if (user.roles.map((role) => role.permissions.map((permission) => permission.id)).flat().filter((id) => id == permissionId).length === 0) {
       throw new Error(
         `User ${idDto.id} does not have permission ${permissionId}`
       );
@@ -717,10 +671,9 @@ var BaseUserService = class {
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
-0 &&
-  (module.exports = {
-    BaseOrganizationService,
-    BasePermissionService,
-    BaseRoleService,
-    BaseUserService
-  });
+0 && (module.exports = {
+  BaseOrganizationService,
+  BasePermissionService,
+  BaseRoleService,
+  BaseUserService
+});