@forklaunch/implementation-iam-base 0.1.2 → 0.1.4

package/lib/__test__/schemaEquality.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemaEquality.test.d.ts.map

package/lib/__test__/schemaEquality.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaEquality.test.d.ts","sourceRoot":"","sources":["../../__test__/schemaEquality.test.ts"],"names":[],"mappings":""}

package/lib/__test__/schemaEquality.test.js

@@ -0,0 +1,175 @@
+import { isTrue } from '@forklaunch/common';
+import { DummyEnum, testSchemaEquality } from '@forklaunch/core/test';
+import { CreateOrganizationSchema as TypeboxCreateOrganizationSchema, OrganizationSchema as TypeboxOrganizationSchema, UpdateOrganizationSchema as TypeboxUpdateOrganizationSchema } from '../schemas/typebox/organization.schema';
+import { CreatePermissionSchema as TypeboxCreatePermissionSchema, PermissionSchema as TypeboxPermissionSchema, UpdatePermissionSchema as TypeboxUpdatePermissionSchema } from '../schemas/typebox/permission.schema';
+import { CreateRoleSchema as TypeboxCreateRoleSchema, RoleSchema as TypeboxRoleSchema, UpdateRoleSchema as TypeboxUpdateRoleSchema } from '../schemas/typebox/role.schema';
+import { CreateUserSchema as TypeboxCreateUserSchema, UpdateUserSchema as TypeboxUpdateUserSchema, UserSchema as TypeboxUserSchema } from '../schemas/typebox/user.schema';
+import { CreateOrganizationSchema as ZodCreateOrganizationSchema, OrganizationSchema as ZodOrganizationSchema, UpdateOrganizationSchema as ZodUpdateOrganizationSchema } from '../schemas/zod/organization.schema';
+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)(zodPermissionSchema);
+const typeboxRoleSchema = TypeboxRoleSchema(false)(typeboxPermissionSchema);
+const zodUpdateUserSchema = ZodUpdateUserSchema(false);
+const typeboxUpdateUserSchema = TypeboxUpdateUserSchema(false);
+const zodUserSchema = ZodUserSchema(false)(zodRoleSchema);
+const typeboxUserSchema = TypeboxUserSchema(false)(typeboxRoleSchema);
+const zodUpdateOrganizationSchema = ZodUpdateOrganizationSchema(false);
+const typeboxUpdateOrganizationSchema = TypeboxUpdateOrganizationSchema(false);
+const zodOrganizationSchema = ZodOrganizationSchema(false)(zodUserSchema, DummyEnum);
+const typeboxOrganizationSchema = TypeboxOrganizationSchema(false)(typeboxUserSchema, DummyEnum);
+describe('schema equality', () => {
+    it('should be equal for permission', () => {
+        expect(isTrue(testSchemaEquality(ZodCreatePermissionSchema, TypeboxCreatePermissionSchema, {
+            slug: 'test',
+            addToRolesIds: ['test'],
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdatePermissionSchema, typeboxUpdatePermissionSchema, {
+            id: 'test',
+            slug: 'test',
+            addToRolesIds: ['test'],
+            removeFromRolesIds: ['test'],
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodPermissionSchema, typeboxPermissionSchema, {
+            id: 'test',
+            slug: 'test',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+    });
+    it('should be equal for role', () => {
+        expect(isTrue(testSchemaEquality(ZodCreateRoleSchema, TypeboxCreateRoleSchema, {
+            name: 'test',
+            permissionIds: ['test'],
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdateRoleSchema, typeboxUpdateRoleSchema, {
+            id: 'test',
+            name: 'test',
+            permissionIds: ['test'],
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodRoleSchema, typeboxRoleSchema, {
+            id: 'test',
+            name: 'test',
+            permissions: [
+                {
+                    id: 'test',
+                    slug: 'test',
+                    extraFields: { test: 'test' }
+                }
+            ],
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+    });
+    it('should be equal for user', () => {
+        expect(isTrue(testSchemaEquality(ZodCreateUserSchema, TypeboxCreateUserSchema, {
+            email: 'test@test.com',
+            password: 'test',
+            firstName: 'test',
+            lastName: 'test',
+            organizationId: 'test',
+            roleIds: ['test'],
+            phoneNumber: 'test',
+            subscription: 'test',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdateUserSchema, typeboxUpdateUserSchema, {
+            id: 'test',
+            email: 'test@test.com',
+            password: 'test',
+            firstName: 'test',
+            lastName: 'test',
+            roleIds: ['test'],
+            phoneNumber: 'test',
+            subscription: 'test',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUserSchema, typeboxUserSchema, {
+            id: 'test',
+            email: 'test@test.com',
+            firstName: 'test',
+            lastName: 'test',
+            roles: [
+                {
+                    id: 'test',
+                    name: 'test',
+                    permissions: [{ id: 'test', slug: 'test' }],
+                    extraFields: {
+                        test: 'test'
+                    }
+                }
+            ],
+            phoneNumber: 'test',
+            subscription: 'test',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+    });
+    it('should be equal for organization', () => {
+        expect(isTrue(testSchemaEquality(ZodCreateOrganizationSchema, TypeboxCreateOrganizationSchema, {
+            name: 'test',
+            domain: 'test',
+            subscription: 'test',
+            logoUrl: 'test',
+            extraFields: { test: 'test' }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdateOrganizationSchema, typeboxUpdateOrganizationSchema, {
+            id: 'test',
+            name: 'test',
+            domain: 'test',
+            subscription: 'test',
+            logoUrl: 'test',
+            extraFields: { test: 'test' }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodOrganizationSchema, typeboxOrganizationSchema, {
+            id: 'test',
+            name: 'test',
+            domain: 'test',
+            subscription: 'test',
+            logoUrl: 'test',
+            extraFields: { test: 'test' },
+            status: DummyEnum.A,
+            users: [
+                {
+                    id: 'test',
+                    email: 'test@test.com',
+                    firstName: 'test',
+                    lastName: 'test',
+                    roles: [
+                        {
+                            id: 'test',
+                            name: 'test',
+                            permissions: [{ id: 'test', slug: 'test' }],
+                            extraFields: { test: 'test' }
+                        }
+                    ]
+                }
+            ]
+        }))).toBeTruthy();
+    });
+});

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

@@ -5,10 +5,10 @@ import {
   enum_,
   optional,
   string,
-  TypeboxSchemaValidator,
   unknown,
-  uuid
-} from '@forklaunch/validator/typebox';
+  uuid,
+  ZodSchemaValidator
+} from '@forklaunch/validator/zod';
 
 export const CreateOrganizationSchema = {
   name: string,
@@ -30,7 +30,7 @@ export const UpdateOrganizationSchema = (uuidId: boolean) => ({
 export const OrganizationSchema =
   (uuidId: boolean) =>
   <
-    UserDtoSchema extends IdiomaticSchema<TypeboxSchemaValidator>,
+    UserDtoSchema extends IdiomaticSchema<ZodSchemaValidator>,
     OrganizationStatus extends Record<string, LiteralSchema>
   >(
     UserDtoSchema: UserDtoSchema,

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

@@ -5,7 +5,7 @@ import {
   string,
   unknown,
   uuid
-} from '@forklaunch/validator/typebox';
+} from '@forklaunch/validator/zod';
 
 export const CreatePermissionSchema = {
   slug: string,

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

@@ -4,10 +4,10 @@ import {
   date,
   optional,
   string,
-  TypeboxSchemaValidator,
   unknown,
-  uuid
-} from '@forklaunch/validator/typebox';
+  uuid,
+  ZodSchemaValidator
+} from '@forklaunch/validator/zod';
 
 export const CreateRoleSchema = {
   name: string,
@@ -24,7 +24,7 @@ export const UpdateRoleSchema = (uuidId: boolean) => ({
 
 export const RoleSchema =
   (uuidId: boolean) =>
-  <PermissionSchema extends IdiomaticSchema<TypeboxSchemaValidator>>(
+  <PermissionSchema extends IdiomaticSchema<ZodSchemaValidator>>(
     PermissionSchema: PermissionSchema
   ) => ({
     id: uuidId ? uuid : string,

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

@@ -5,10 +5,10 @@ import {
   email,
   optional,
   string,
-  TypeboxSchemaValidator,
   unknown,
-  uuid
-} from '@forklaunch/validator/typebox';
+  uuid,
+  ZodSchemaValidator
+} from '@forklaunch/validator/zod';
 
 export const CreateUserSchema = {
   email: email,
@@ -36,7 +36,7 @@ export const UpdateUserSchema = (uuidId: boolean) => ({
 
 export const UserSchema =
   (uuidId: boolean) =>
-  <RoleDtoSchema extends IdiomaticSchema<TypeboxSchemaValidator>>(
+  <RoleDtoSchema extends IdiomaticSchema<ZodSchemaValidator>>(
     RoleDtoSchema: RoleDtoSchema
   ) => ({
     id: uuidId ? uuid : string,

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

@@ -0,0 +1,146 @@
+import {
+  CreateOrganizationDto,
+  OrganizationDto,
+  OrganizationService,
+  UpdateOrganizationDto
+} from '@forklaunch/interfaces-iam';
+import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  InternalDtoMapper,
+  RequestDtoMapperConstructor,
+  ResponseDtoMapperConstructor,
+  transformIntoInternalDtoMapper
+} from '@forklaunch/core/dtoMapper';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector
+} from '@forklaunch/core/http';
+import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+
+export class BaseOrganizationService<
+  SchemaValidator extends AnySchemaValidator,
+  OrganizationStatus,
+  Metrics extends MetricsDefinition = MetricsDefinition,
+  Dto extends {
+    OrganizationDtoMapper: OrganizationDto<OrganizationStatus>;
+    CreateOrganizationDtoMapper: CreateOrganizationDto;
+    UpdateOrganizationDtoMapper: UpdateOrganizationDto;
+  } = {
+    OrganizationDtoMapper: OrganizationDto<OrganizationStatus>;
+    CreateOrganizationDtoMapper: CreateOrganizationDto;
+    UpdateOrganizationDtoMapper: UpdateOrganizationDto;
+  },
+  Entities extends {
+    OrganizationDtoMapper: MapNestedDtoArraysToCollections<
+      OrganizationDto<OrganizationStatus>,
+      'users'
+    >;
+    CreateOrganizationDtoMapper: MapNestedDtoArraysToCollections<
+      OrganizationDto<OrganizationStatus>,
+      'users'
+    >;
+    UpdateOrganizationDtoMapper: MapNestedDtoArraysToCollections<
+      OrganizationDto<OrganizationStatus>,
+      'users'
+    >;
+  } = {
+    OrganizationDtoMapper: MapNestedDtoArraysToCollections<
+      OrganizationDto<OrganizationStatus>,
+      'users'
+    >;
+    CreateOrganizationDtoMapper: MapNestedDtoArraysToCollections<
+      OrganizationDto<OrganizationStatus>,
+      'users'
+    >;
+    UpdateOrganizationDtoMapper: MapNestedDtoArraysToCollections<
+      OrganizationDto<OrganizationStatus>,
+      'users'
+    >;
+  }
+> implements OrganizationService<OrganizationStatus>
+{
+  #dtoMappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.dtoMappers>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    public em: EntityManager,
+    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected schemaValidator: SchemaValidator,
+    protected dtoMappers: {
+      OrganizationDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['OrganizationDtoMapper'],
+        Entities['OrganizationDtoMapper']
+      >;
+      CreateOrganizationDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateOrganizationDtoMapper'],
+        Entities['CreateOrganizationDtoMapper']
+      >;
+      UpdateOrganizationDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateOrganizationDtoMapper'],
+        Entities['UpdateOrganizationDtoMapper']
+      >;
+    }
+  ) {
+    this.#dtoMappers = transformIntoInternalDtoMapper(
+      dtoMappers,
+      schemaValidator
+    );
+  }
+
+  async createOrganization(
+    organizationDto: Dto['CreateOrganizationDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['OrganizationDtoMapper']> {
+    this.openTelemetryCollector.log('info', 'Creating organization');
+    const organization =
+      this.#dtoMappers.CreateOrganizationDtoMapper.deserializeDtoToEntity(
+        organizationDto
+      );
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(organization);
+    });
+
+    return this.#dtoMappers.OrganizationDtoMapper.serializeEntityToDto(
+      organization
+    );
+  }
+
+  async getOrganization(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['OrganizationDtoMapper']> {
+    const organization = await (em ?? this.em).findOneOrFail(
+      'Organization',
+      idDto
+    );
+    return this.#dtoMappers.OrganizationDtoMapper.serializeEntityToDto(
+      organization as Entities['OrganizationDtoMapper']
+    );
+  }
+
+  async updateOrganization(
+    organizationDto: Dto['UpdateOrganizationDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['OrganizationDtoMapper']> {
+    const updatedOrganization =
+      this.#dtoMappers.UpdateOrganizationDtoMapper.deserializeDtoToEntity(
+        organizationDto
+      );
+    await (em ?? this.em).upsert(updatedOrganization);
+    return this.#dtoMappers.OrganizationDtoMapper.serializeEntityToDto(
+      updatedOrganization
+    );
+  }
+
+  async deleteOrganization(idDto: IdDto, em?: EntityManager): Promise<void> {
+    await (em ?? this.em).nativeDelete('Organization', idDto);
+  }
+}