@forklaunch/implementation-iam-base 0.1.6 → 0.1.8

package/lib/__test__/schemaEquality.test.js

@@ -8,22 +8,30 @@ import { CreateOrganizationSchema as ZodCreateOrganizationSchema, OrganizationSc
 import { CreatePermissionSchema as ZodCreatePermissionSchema, PermissionSchema as ZodPermissionSchema, UpdatePermissionSchema as ZodUpdatePermissionSchema } from '../schemas/zod/permission.schema';
 import { CreateRoleSchema as ZodCreateRoleSchema, RoleSchema as ZodRoleSchema, UpdateRoleSchema as ZodUpdateRoleSchema } from '../schemas/zod/role.schema';
 import { CreateUserSchema as ZodCreateUserSchema, UpdateUserSchema as ZodUpdateUserSchema, UserSchema as ZodUserSchema } from '../schemas/zod/user.schema';
-const zodUpdatePermissionSchema = ZodUpdatePermissionSchema(false);
-const typeboxUpdatePermissionSchema = TypeboxUpdatePermissionSchema(false);
-const zodPermissionSchema = ZodPermissionSchema(false);
-const typeboxPermissionSchema = TypeboxPermissionSchema(false);
-const zodUpdateRoleSchema = ZodUpdateRoleSchema(false);
-const typeboxUpdateRoleSchema = TypeboxUpdateRoleSchema(false);
-const zodRoleSchema = ZodRoleSchema(false);
-const typeboxRoleSchema = TypeboxRoleSchema(false);
-const zodUpdateUserSchema = ZodUpdateUserSchema(false);
-const typeboxUpdateUserSchema = TypeboxUpdateUserSchema(false);
-const zodUserSchema = ZodUserSchema(false);
-const typeboxUserSchema = TypeboxUserSchema(false);
-const zodUpdateOrganizationSchema = ZodUpdateOrganizationSchema(false);
-const typeboxUpdateOrganizationSchema = TypeboxUpdateOrganizationSchema(false);
-const zodOrganizationSchema = ZodOrganizationSchema(false)(DummyEnum);
-const typeboxOrganizationSchema = TypeboxOrganizationSchema(false)(DummyEnum);
+const zodUpdatePermissionSchema = ZodUpdatePermissionSchema({
+    uuidId: false
+});
+const typeboxUpdatePermissionSchema = TypeboxUpdatePermissionSchema({
+    uuidId: false
+});
+const zodPermissionSchema = ZodPermissionSchema({ uuidId: false });
+const typeboxPermissionSchema = TypeboxPermissionSchema({ uuidId: false });
+const zodUpdateRoleSchema = ZodUpdateRoleSchema({ uuidId: false });
+const typeboxUpdateRoleSchema = TypeboxUpdateRoleSchema({ uuidId: false });
+const zodRoleSchema = ZodRoleSchema({ uuidId: false });
+const typeboxRoleSchema = TypeboxRoleSchema({ uuidId: false });
+const zodUpdateUserSchema = ZodUpdateUserSchema({ uuidId: false });
+const typeboxUpdateUserSchema = TypeboxUpdateUserSchema({ uuidId: false });
+const zodUserSchema = ZodUserSchema({ uuidId: false });
+const typeboxUserSchema = TypeboxUserSchema({ uuidId: false });
+const zodUpdateOrganizationSchema = ZodUpdateOrganizationSchema({
+    uuidId: false
+});
+const typeboxUpdateOrganizationSchema = TypeboxUpdateOrganizationSchema({
+    uuidId: false
+});
+const zodOrganizationSchema = ZodOrganizationSchema({ uuidId: false })(DummyEnum);
+const typeboxOrganizationSchema = TypeboxOrganizationSchema({ uuidId: false })(DummyEnum);
 describe('schema equality', () => {
     it('should be equal for permission', () => {
         expect(isTrue(testSchemaEquality(ZodCreatePermissionSchema, TypeboxCreatePermissionSchema, {

package/lib/eject/{schemas → domain/schemas}/organization.schema.ts

@@ -18,7 +18,7 @@ export const CreateOrganizationSchema = {
   extraFields: optional(unknown)
 };
 
-export const UpdateOrganizationSchema = (uuidId: boolean) => ({
+export const UpdateOrganizationSchema = ({ uuidId }: { uuidId: boolean }) => ({
   id: uuidId ? uuid : string,
   name: optional(string),
   domain: optional(string),
@@ -28,13 +28,13 @@ export const UpdateOrganizationSchema = (uuidId: boolean) => ({
 });
 
 export const OrganizationSchema =
-  (uuidId: boolean) =>
+  ({ uuidId }: { uuidId: boolean }) =>
   <OrganizationStatus extends Record<string, LiteralSchema>>(
     organizationStatus: OrganizationStatus
   ) => ({
     id: uuidId ? uuid : string,
     name: string,
-    users: array(UserSchema(uuidId)),
+    users: array(UserSchema({ uuidId })),
     domain: string,
     subscription: string,
     status: enum_(organizationStatus),
@@ -44,8 +44,10 @@ export const OrganizationSchema =
     updatedAt: optional(date)
   });
 
-export const BaseOrganizationServiceSchemas = (uuidId: boolean) => ({
+export const BaseOrganizationServiceSchemas = (options: {
+  uuidId: boolean;
+}) => ({
   CreateOrganizationSchema,
-  UpdateOrganizationSchema: UpdateOrganizationSchema(uuidId),
-  OrganizationSchema: OrganizationSchema(uuidId)
+  UpdateOrganizationSchema: UpdateOrganizationSchema(options),
+  OrganizationSchema: OrganizationSchema(options)
 });

package/lib/eject/{schemas → domain/schemas}/permission.schema.ts

@@ -13,7 +13,7 @@ export const CreatePermissionSchema = {
   extraFields: optional(unknown)
 };
 
-export const UpdatePermissionSchema = (uuidId: boolean) => ({
+export const UpdatePermissionSchema = ({ uuidId }: { uuidId: boolean }) => ({
   id: uuidId ? uuid : string,
   slug: optional(string),
   extraFields: optional(unknown),
@@ -21,7 +21,7 @@ export const UpdatePermissionSchema = (uuidId: boolean) => ({
   removeFromRolesIds: optional(array(string))
 });
 
-export const PermissionSchema = (uuidId: boolean) => ({
+export const PermissionSchema = ({ uuidId }: { uuidId: boolean }) => ({
   id: uuidId ? uuid : string,
   slug: string,
   extraFields: optional(unknown),
@@ -29,8 +29,8 @@ export const PermissionSchema = (uuidId: boolean) => ({
   updatedAt: optional(date)
 });
 
-export const BasePermissionServiceSchemas = (uuidId: boolean) => ({
+export const BasePermissionServiceSchemas = (options: { uuidId: boolean }) => ({
   CreatePermissionSchema,
-  UpdatePermissionSchema: UpdatePermissionSchema(uuidId),
-  PermissionSchema: PermissionSchema(uuidId)
+  UpdatePermissionSchema: UpdatePermissionSchema(options),
+  PermissionSchema: PermissionSchema(options)
 });

package/lib/eject/{schemas → domain/schemas}/role.schema.ts

@@ -14,24 +14,24 @@ export const CreateRoleSchema = {
   extraFields: optional(unknown)
 };
 
-export const UpdateRoleSchema = (uuidId: boolean) => ({
+export const UpdateRoleSchema = ({ uuidId }: { uuidId: boolean }) => ({
   id: uuidId ? uuid : string,
   name: optional(string),
   permissionIds: optional(array(string)),
   extraFields: optional(unknown)
 });
 
-export const RoleSchema = (uuidId: boolean) => ({
+export const RoleSchema = ({ uuidId }: { uuidId: boolean }) => ({
   id: uuidId ? uuid : string,
   name: string,
-  permissions: array(PermissionSchema(uuidId)),
+  permissions: array(PermissionSchema({ uuidId })),
   extraFields: optional(unknown),
   createdAt: optional(date),
   updatedAt: optional(date)
 });
 
-export const BaseRoleServiceSchemas = (uuidId: boolean) => ({
+export const BaseRoleServiceSchemas = (options: { uuidId: boolean }) => ({
   CreateRoleSchema,
-  UpdateRoleSchema: UpdateRoleSchema(uuidId),
-  RoleSchema: RoleSchema(uuidId)
+  UpdateRoleSchema: UpdateRoleSchema(options),
+  RoleSchema: RoleSchema(options)
 });

package/lib/eject/{schemas → domain/schemas}/user.schema.ts

@@ -21,7 +21,7 @@ export const CreateUserSchema = {
   extraFields: optional(unknown)
 };
 
-export const UpdateUserSchema = (uuidId: boolean) => ({
+export const UpdateUserSchema = ({ uuidId }: { uuidId: boolean }) => ({
   id: uuidId ? uuid : string,
   email: optional(email),
   password: optional(string),
@@ -33,12 +33,12 @@ export const UpdateUserSchema = (uuidId: boolean) => ({
   extraFields: optional(unknown)
 });
 
-export const UserSchema = (uuidId: boolean) => ({
+export const UserSchema = ({ uuidId }: { uuidId: boolean }) => ({
   id: uuidId ? uuid : string,
   email: email,
   firstName: string,
   lastName: string,
-  roles: array(RoleSchema(uuidId)),
+  roles: array(RoleSchema({ uuidId })),
   phoneNumber: optional(string),
   subscription: optional(string),
   extraFields: optional(unknown),
@@ -46,8 +46,8 @@ export const UserSchema = (uuidId: boolean) => ({
   updatedAt: optional(date)
 });
 
-export const BaseUserServiceSchemas = (uuidId: boolean) => ({
+export const BaseUserServiceSchemas = (options: { uuidId: boolean }) => ({
   CreateUserSchema,
-  UpdateUserSchema: UpdateUserSchema(uuidId),
-  UserSchema: UserSchema(uuidId)
+  UpdateUserSchema: UpdateUserSchema(options),
+  UserSchema: UserSchema(options)
 });

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

@@ -4,7 +4,7 @@ import {
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
-} from '@forklaunch/core/dtoMapper';
+} from '@forklaunch/core/mappers';
 import {
   MetricsDefinition,
   OpenTelemetryCollector
@@ -61,8 +61,8 @@ export class BaseOrganizationService<
   }
 > implements OrganizationService<OrganizationStatus>
 {
-  #dtoMappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.dtoMappers>,
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
     Entities,
     Dto
   >;
@@ -71,7 +71,7 @@ export class BaseOrganizationService<
     public em: EntityManager,
     protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected schemaValidator: SchemaValidator,
-    protected dtoMappers: {
+    protected mapperss: {
       OrganizationDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['OrganizationDtoMapper'],
@@ -89,10 +89,7 @@ export class BaseOrganizationService<
       >;
     }
   ) {
-    this.#dtoMappers = transformIntoInternalDtoMapper(
-      dtoMappers,
-      schemaValidator
-    );
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
   }
 
   async createOrganization(
@@ -101,14 +98,14 @@ export class BaseOrganizationService<
   ): Promise<Dto['OrganizationDtoMapper']> {
     this.openTelemetryCollector.log('info', 'Creating organization');
     const organization =
-      this.#dtoMappers.CreateOrganizationDtoMapper.deserializeDtoToEntity(
+      this.#mapperss.CreateOrganizationDtoMapper.deserializeDtoToEntity(
         organizationDto
       );
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(organization);
     });
 
-    return this.#dtoMappers.OrganizationDtoMapper.serializeEntityToDto(
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
       organization
     );
   }
@@ -121,7 +118,7 @@ export class BaseOrganizationService<
       'Organization',
       idDto
     );
-    return this.#dtoMappers.OrganizationDtoMapper.serializeEntityToDto(
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
       organization as Entities['OrganizationDtoMapper']
     );
   }
@@ -131,11 +128,11 @@ export class BaseOrganizationService<
     em?: EntityManager
   ): Promise<Dto['OrganizationDtoMapper']> {
     const updatedOrganization =
-      this.#dtoMappers.UpdateOrganizationDtoMapper.deserializeDtoToEntity(
+      this.#mapperss.UpdateOrganizationDtoMapper.deserializeDtoToEntity(
         organizationDto
       );
     await (em ?? this.em).upsert(updatedOrganization);
-    return this.#dtoMappers.OrganizationDtoMapper.serializeEntityToDto(
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
       updatedOrganization
     );
   }

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

@@ -9,7 +9,7 @@ import {
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
-} from '@forklaunch/core/dtoMapper';
+} from '@forklaunch/core/mappers';
 import {
   MetricsDefinition,
   OpenTelemetryCollector
@@ -51,8 +51,8 @@ export class BasePermissionService<
   }
 > implements PermissionService
 {
-  #dtoMappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.dtoMappers>,
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
     Entities,
     Dto
   >;
@@ -62,7 +62,7 @@ export class BasePermissionService<
     protected roleServiceFactory: () => RoleService,
     protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected schemaValidator: SchemaValidator,
-    protected dtoMappers: {
+    protected mapperss: {
       PermissionDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['PermissionDtoMapper'],
@@ -85,10 +85,7 @@ export class BasePermissionService<
       >;
     }
   ) {
-    this.#dtoMappers = transformIntoInternalDtoMapper(
-      dtoMappers,
-      schemaValidator
-    );
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
   }
 
   // start: global helper functions
@@ -126,7 +123,7 @@ export class BasePermissionService<
       ? (await this.roleServiceFactory().getBatchRoles(roleIds, em)).map(
           (role) => {
             return (em ?? this.em).merge(
-              this.#dtoMappers.RoleDtoMapper.deserializeDtoToEntity(role)
+              this.#mapperss.RoleDtoMapper.deserializeDtoToEntity(role)
             );
           }
         )
@@ -162,7 +159,7 @@ export class BasePermissionService<
   }> {
     return {
       permission: (em ?? this.em).merge(
-        this.#dtoMappers.CreatePermissionDtoMapper.deserializeDtoToEntity(
+        this.#mapperss.CreatePermissionDtoMapper.deserializeDtoToEntity(
           permissionDto
         )
       ),
@@ -183,9 +180,7 @@ export class BasePermissionService<
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist([permission, ...roles]);
     });
-    return this.#dtoMappers.PermissionDtoMapper.serializeEntityToDto(
-      permission
-    );
+    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
   }
 
   async createBatchPermissions(
@@ -225,7 +220,7 @@ export class BasePermissionService<
     });
 
     return permissions.map((permission) =>
-      this.#dtoMappers.PermissionDtoMapper.serializeEntityToDto(permission)
+      this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
     );
   }
 
@@ -234,7 +229,7 @@ export class BasePermissionService<
     em?: EntityManager
   ): Promise<Dto['PermissionDtoMapper']> {
     const permission = await (em ?? this.em).findOneOrFail('Permission', idDto);
-    return this.#dtoMappers.PermissionDtoMapper.serializeEntityToDto(
+    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(
       permission as Entities['PermissionDtoMapper']
     );
   }
@@ -245,7 +240,7 @@ export class BasePermissionService<
   ): Promise<Dto['PermissionDtoMapper'][]> {
     return (await (em ?? this.em).find('Permission', idsDto)).map(
       (permission) =>
-        this.#dtoMappers.PermissionDtoMapper.serializeEntityToDto(
+        this.#mapperss.PermissionDtoMapper.serializeEntityToDto(
           permission as Entities['PermissionDtoMapper']
         )
     );
@@ -260,7 +255,7 @@ export class BasePermissionService<
     roles: Entities['RoleDtoMapper'][];
   }> => {
     const permission =
-      this.#dtoMappers.UpdatePermissionDtoMapper.deserializeDtoToEntity(
+      this.#mapperss.UpdatePermissionDtoMapper.deserializeDtoToEntity(
         permissionDto
       );
     const addToRoles = permissionDto.addToRolesIds
@@ -295,9 +290,7 @@ export class BasePermissionService<
     if (!em) {
       this.em.flush();
     }
-    return this.#dtoMappers.PermissionDtoMapper.serializeEntityToDto(
-      permission
-    );
+    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
   }
 
   async updateBatchPermissions(
@@ -333,7 +326,7 @@ export class BasePermissionService<
     });
 
     return permissions.map((permission) =>
-      this.#dtoMappers.PermissionDtoMapper.serializeEntityToDto(permission)
+      this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
     );
   }
 

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

@@ -11,7 +11,7 @@ import {
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
-} from '@forklaunch/core/dtoMapper';
+} from '@forklaunch/core/mappers';
 import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
 import {
   CreateRoleDto,
@@ -55,8 +55,8 @@ export class BaseRoleService<
   }
 > implements RoleService
 {
-  #dtoMappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.dtoMappers>,
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
     Entities,
     Dto
   >;
@@ -65,7 +65,7 @@ export class BaseRoleService<
     public em: EntityManager,
     protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected schemaValidator: SchemaValidator,
-    protected dtoMappers: {
+    protected mapperss: {
       RoleDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['RoleDtoMapper'],
@@ -83,10 +83,7 @@ export class BaseRoleService<
       >;
     }
   ) {
-    this.#dtoMappers = transformIntoInternalDtoMapper(
-      dtoMappers,
-      schemaValidator
-    );
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
   }
 
   async createRole(
@@ -95,9 +92,9 @@ export class BaseRoleService<
   ): Promise<Dto['RoleDtoMapper']> {
     // TODO: Think about removing static method here, since we need specific args
     const role =
-      this.#dtoMappers.CreateRoleDtoMapper.deserializeDtoToEntity(roleDto);
+      this.#mapperss.CreateRoleDtoMapper.deserializeDtoToEntity(roleDto);
     await (em ?? this.em).transactional((em) => em.persist(role));
-    return this.#dtoMappers.RoleDtoMapper.serializeEntityToDto(
+    return this.#mapperss.RoleDtoMapper.serializeEntityToDto(
       role as Entities['RoleDtoMapper']
     );
   }
@@ -108,12 +105,12 @@ export class BaseRoleService<
   ): Promise<Dto['RoleDtoMapper'][]> {
     const roles = await Promise.all(
       roleDtos.map(async (roleDto) =>
-        this.#dtoMappers.CreateRoleDtoMapper.deserializeDtoToEntity(roleDto)
+        this.#mapperss.CreateRoleDtoMapper.deserializeDtoToEntity(roleDto)
       )
     );
     await (em ?? this.em).transactional((em) => em.persist(roles));
     return roles.map((role) =>
-      this.#dtoMappers.RoleDtoMapper.serializeEntityToDto(
+      this.#mapperss.RoleDtoMapper.serializeEntityToDto(
         role as Entities['RoleDtoMapper']
       )
     );
@@ -123,7 +120,7 @@ export class BaseRoleService<
     const role = await (em ?? this.em).findOneOrFail('Role', idDto, {
       populate: ['id', '*']
     });
-    return this.#dtoMappers.RoleDtoMapper.serializeEntityToDto(
+    return this.#mapperss.RoleDtoMapper.serializeEntityToDto(
       role as Entities['RoleDtoMapper']
     );
   }
@@ -134,7 +131,7 @@ export class BaseRoleService<
         populate: ['id', '*']
       })
     ).map((role) =>
-      this.#dtoMappers.RoleDtoMapper.serializeEntityToDto(
+      this.#mapperss.RoleDtoMapper.serializeEntityToDto(
         role as Entities['RoleDtoMapper']
       )
     );
@@ -144,13 +141,13 @@ export class BaseRoleService<
     roleDto: Dto['UpdateRoleDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['RoleDtoMapper']> {
-    let role = this.#dtoMappers.UpdateRoleDtoMapper.deserializeDtoToEntity(
+    let role = this.#mapperss.UpdateRoleDtoMapper.deserializeDtoToEntity(
       roleDto
     ) as Entities['RoleDtoMapper'];
     await (em ?? this.em).transactional(async (em) => {
       role = (await em.upsert('Role', role)) as Entities['RoleDtoMapper'];
     });
-    return this.#dtoMappers.RoleDtoMapper.serializeEntityToDto(role);
+    return this.#mapperss.RoleDtoMapper.serializeEntityToDto(role);
   }
 
   async updateBatchRoles(
@@ -159,14 +156,14 @@ export class BaseRoleService<
   ): Promise<Dto['RoleDtoMapper'][]> {
     let roles = await Promise.all(
       roleDtos.map(async (roleDto) =>
-        this.#dtoMappers.UpdateRoleDtoMapper.deserializeDtoToEntity(roleDto)
+        this.#mapperss.UpdateRoleDtoMapper.deserializeDtoToEntity(roleDto)
       )
     );
     await (em ?? this.em).transactional(async (em) => {
       roles = await em.upsertMany('Role', roles);
     });
     return roles.map((role) =>
-      this.#dtoMappers.RoleDtoMapper.serializeEntityToDto(
+      this.#mapperss.RoleDtoMapper.serializeEntityToDto(
         role as Entities['RoleDtoMapper']
       )
     );

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

@@ -10,7 +10,7 @@ import {
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
-} from '@forklaunch/core/dtoMapper';
+} from '@forklaunch/core/mappers';
 import {
   MetricsDefinition,
   OpenTelemetryCollector
@@ -48,8 +48,8 @@ export class BaseUserService<
   }
 > implements UserService
 {
-  #dtoMappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.dtoMappers>,
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
     Entities,
     Dto
   >;
@@ -61,7 +61,7 @@ export class BaseUserService<
     protected organizationServiceFactory: () => OrganizationService<OrganizationStatus>,
     protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected schemaValidator: SchemaValidator,
-    protected dtoMappers: {
+    protected mapperss: {
       UserDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['UserDtoMapper'],
@@ -87,10 +87,7 @@ export class BaseUserService<
       >;
     }
   ) {
-    this.#dtoMappers = transformIntoInternalDtoMapper(
-      dtoMappers,
-      schemaValidator
-    );
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
   }
 
   async createUser(
@@ -98,14 +95,14 @@ export class BaseUserService<
     em?: EntityManager
   ): Promise<Dto['UserDtoMapper']> {
     const user =
-      await this.#dtoMappers.CreateUserDtoMapper.deserializeDtoToEntity(
+      await this.#mapperss.CreateUserDtoMapper.deserializeDtoToEntity(
         userDto,
         this.passwordEncryptionPublicKeyPath
       );
     ((await em) ?? this.em).transactional(async (em) => {
       await em.persist(user);
     });
-    return this.#dtoMappers.UserDtoMapper.serializeEntityToDto(user);
+    return this.#mapperss.UserDtoMapper.serializeEntityToDto(user);
   }
 
   async createBatchUsers(
@@ -114,7 +111,7 @@ export class BaseUserService<
   ): Promise<Dto['UserDtoMapper'][]> {
     const users = await Promise.all(
       userDtos.map(async (createUserDto) =>
-        this.#dtoMappers.CreateUserDtoMapper.deserializeDtoToEntity(
+        this.#mapperss.CreateUserDtoMapper.deserializeDtoToEntity(
           createUserDto,
           this.passwordEncryptionPublicKeyPath
         )
@@ -125,7 +122,7 @@ export class BaseUserService<
     });
 
     return users.map((user) =>
-      this.#dtoMappers.UserDtoMapper.serializeEntityToDto(user)
+      this.#mapperss.UserDtoMapper.serializeEntityToDto(user)
     );
   }
 
@@ -136,7 +133,7 @@ export class BaseUserService<
     const user = await (em ?? this.em).findOneOrFail('User', idDto, {
       populate: ['id', '*']
     });
-    return this.#dtoMappers.UserDtoMapper.serializeEntityToDto(
+    return this.#mapperss.UserDtoMapper.serializeEntityToDto(
       user as Entities['UserDtoMapper']
     );
   }
@@ -150,7 +147,7 @@ export class BaseUserService<
         populate: ['id', '*']
       })
     ).map((user) =>
-      this.#dtoMappers.UserDtoMapper.serializeEntityToDto(
+      this.#mapperss.UserDtoMapper.serializeEntityToDto(
         user as Entities['UserDtoMapper']
       )
     );
@@ -160,14 +157,14 @@ export class BaseUserService<
     userDto: Dto['UpdateUserDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['UserDtoMapper']> {
-    let user = this.#dtoMappers.UpdateUserDtoMapper.deserializeDtoToEntity(
+    let user = this.#mapperss.UpdateUserDtoMapper.deserializeDtoToEntity(
       userDto,
       this.passwordEncryptionPublicKeyPath
     );
     await (em ?? this.em).transactional(async (localEm) => {
       user = await localEm.upsert(user);
     });
-    return this.#dtoMappers.UserDtoMapper.serializeEntityToDto(user);
+    return this.#mapperss.UserDtoMapper.serializeEntityToDto(user);
   }
 
   async updateBatchUsers(
@@ -176,7 +173,7 @@ export class BaseUserService<
   ): Promise<Dto['UserDtoMapper'][]> {
     let users = await Promise.all(
       userDtos.map(async (updateUserDto) =>
-        this.#dtoMappers.UpdateUserDtoMapper.deserializeDtoToEntity(
+        this.#mapperss.UpdateUserDtoMapper.deserializeDtoToEntity(
           updateUserDto,
           this.passwordEncryptionPublicKeyPath
         )
@@ -186,7 +183,7 @@ export class BaseUserService<
       users = await localEm.upsertMany(users);
     });
     return users.map((user) =>
-      this.#dtoMappers.UserDtoMapper.serializeEntityToDto(user)
+      this.#mapperss.UserDtoMapper.serializeEntityToDto(user)
     );
   }
 

package/lib/schemas/organization.schema.d.ts

@@ -1,4 +1,10 @@
-export declare const BaseOrganizationServiceSchemas: <SchemaValidator extends import("@forklaunch/validator").AnySchemaValidator>(schemaValidator: SchemaValidator, uuidId: boolean) => import("@forklaunch/core/dtoMapper").SchemasByValidator<SchemaValidator, (uuidId: boolean) => {
+export declare const BaseOrganizationServiceSchemas: <SchemaValidator extends import("@forklaunch/validator").AnySchemaValidator>(options: {
+    uuidId: boolean;
+} & {
+    validator: SchemaValidator;
+}) => import("@forklaunch/core/mappers").SchemasByValidator<SchemaValidator, (options: {
+    uuidId: boolean;
+}) => {
     CreateOrganizationSchema: {
         name: import("@sinclair/typebox").TString;
         domain: import("@sinclair/typebox").TString;
@@ -50,7 +56,9 @@ export declare const BaseOrganizationServiceSchemas: <SchemaValidator extends im
         createdAt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TDate, import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull]>, Date>>;
         updatedAt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TDate, import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull]>, Date>>;
     };
-}, (uuidId: boolean) => {
+}, (options: {
+    uuidId: boolean;
+}) => {
     CreateOrganizationSchema: {
         name: import("zod").ZodString;
         domain: import("zod").ZodString;

package/lib/schemas/organization.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"organization.schema.d.ts","sourceRoot":"","sources":["../../schemas/organization.schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1C,CAAC"}
+{"version":3,"file":"organization.schema.d.ts","sourceRoot":"","sources":["../../schemas/organization.schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1C,CAAC"}

package/lib/schemas/organization.schema.js

@@ -1,4 +1,4 @@
-import { serviceSchemaResolver } from '@forklaunch/core/dtoMapper';
+import { serviceSchemaResolver } from '@forklaunch/core/mappers';
 import { BaseOrganizationServiceSchemas as TypeBoxSchemas } from './typebox/organization.schema';
 import { BaseOrganizationServiceSchemas as ZodSchemas } from './zod/organization.schema';
 export const BaseOrganizationServiceSchemas = serviceSchemaResolver(TypeBoxSchemas, ZodSchemas);