@forklaunch/implementation-iam-base 0.1.12 → 0.1.13

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,183 @@
+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({
+    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, {
+            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/lib/eject/domain/schemas/index.ts

@@ -0,0 +1,4 @@
+export * from './organization.schema';
+export * from './permission.schema';
+export * from './role.schema';
+export * from './user.schema';

package/lib/eject/domain/schemas/organization.schema.ts

@@ -0,0 +1,53 @@
+import { LiteralSchema } from '@forklaunch/validator';
+import {
+  array,
+  date,
+  enum_,
+  optional,
+  string,
+  unknown,
+  uuid
+} from '@{{app_name}}/core';
+import { UserSchema } from './user.schema';
+
+export const CreateOrganizationSchema = {
+  name: string,
+  domain: string,
+  subscription: string,
+  logoUrl: optional(string),
+  extraFields: optional(unknown)
+};
+
+export const UpdateOrganizationSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  name: optional(string),
+  domain: optional(string),
+  subscription: optional(string),
+  logoUrl: optional(string),
+  extraFields: optional(unknown)
+});
+
+export const OrganizationSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <OrganizationStatus extends Record<string, LiteralSchema>>(
+    organizationStatus: OrganizationStatus
+  ) => ({
+    id: uuidId ? uuid : string,
+    name: string,
+    users: array(UserSchema({ uuidId })),
+    domain: string,
+    subscription: string,
+    status: enum_(organizationStatus),
+    logoUrl: optional(string),
+    extraFields: optional(unknown),
+    createdAt: optional(date),
+    updatedAt: optional(date)
+  });
+
+export const BaseOrganizationServiceSchemas = (options: {
+  uuidId: boolean;
+}) => ({
+  CreateOrganizationSchema,
+  UpdateOrganizationSchema: UpdateOrganizationSchema(options),
+  OrganizationSchema: OrganizationSchema(options)
+});

package/lib/eject/domain/schemas/permission.schema.ts

@@ -0,0 +1,36 @@
+import {
+  array,
+  date,
+  optional,
+  string,
+  unknown,
+  uuid
+} from '@{{app_name}}/core';
+
+export const CreatePermissionSchema = {
+  slug: string,
+  addToRolesIds: optional(array(string)),
+  extraFields: optional(unknown)
+};
+
+export const UpdatePermissionSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  slug: optional(string),
+  extraFields: optional(unknown),
+  addToRolesIds: optional(array(string)),
+  removeFromRolesIds: optional(array(string))
+});
+
+export const PermissionSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  slug: string,
+  extraFields: optional(unknown),
+  createdAt: optional(date),
+  updatedAt: optional(date)
+});
+
+export const BasePermissionServiceSchemas = (options: { uuidId: boolean }) => ({
+  CreatePermissionSchema,
+  UpdatePermissionSchema: UpdatePermissionSchema(options),
+  PermissionSchema: PermissionSchema(options)
+});

package/lib/eject/domain/schemas/role.schema.ts

@@ -0,0 +1,37 @@
+import {
+  array,
+  date,
+  optional,
+  string,
+  unknown,
+  uuid
+} from '@{{app_name}}/core';
+import { PermissionSchema } from './permission.schema';
+
+export const CreateRoleSchema = {
+  name: string,
+  permissionIds: optional(array(string)),
+  extraFields: optional(unknown)
+};
+
+export const UpdateRoleSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  name: optional(string),
+  permissionIds: optional(array(string)),
+  extraFields: optional(unknown)
+});
+
+export const RoleSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  name: string,
+  permissions: array(PermissionSchema({ uuidId })),
+  extraFields: optional(unknown),
+  createdAt: optional(date),
+  updatedAt: optional(date)
+});
+
+export const BaseRoleServiceSchemas = (options: { uuidId: boolean }) => ({
+  CreateRoleSchema,
+  UpdateRoleSchema: UpdateRoleSchema(options),
+  RoleSchema: RoleSchema(options)
+});

package/lib/eject/domain/schemas/user.schema.ts

@@ -0,0 +1,53 @@
+import {
+  array,
+  date,
+  email,
+  optional,
+  string,
+  unknown,
+  uuid
+} from '@{{app_name}}/core';
+import { RoleSchema } from './role.schema';
+
+export const CreateUserSchema = {
+  email: email,
+  password: string,
+  firstName: string,
+  lastName: string,
+  organizationId: string,
+  roleIds: array(string),
+  phoneNumber: optional(string),
+  subscription: optional(string),
+  extraFields: optional(unknown)
+};
+
+export const UpdateUserSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  email: optional(email),
+  password: optional(string),
+  firstName: optional(string),
+  lastName: optional(string),
+  roleIds: optional(array(string)),
+  phoneNumber: optional(string),
+  subscription: optional(string),
+  extraFields: optional(unknown)
+});
+
+export const UserSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  email: email,
+  firstName: string,
+  lastName: string,
+  roles: array(RoleSchema({ uuidId })),
+  phoneNumber: optional(string),
+  subscription: optional(string),
+  extraFields: optional(unknown),
+  createdAt: optional(date),
+  updatedAt: optional(date)
+});
+
+export const BaseUserServiceSchemas = (options: { uuidId: boolean }) => ({
+  CreateUserSchema,
+  UpdateUserSchema: UpdateUserSchema(options),
+  UserSchema: UserSchema(options)
+});

package/lib/eject/services/index.ts

@@ -0,0 +1,4 @@
+export * from './organization.service';
+export * from './permission.service';
+export * from './role.service';
+export * from './user.service';

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

@@ -0,0 +1,143 @@
+import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+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 {
+  CreateOrganizationDto,
+  OrganizationDto,
+  UpdateOrganizationDto
+} from '@forklaunch/interfaces-iam/types';
+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>
+{
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    public em: EntityManager,
+    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected schemaValidator: SchemaValidator,
+    protected mapperss: {
+      OrganizationDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['OrganizationDtoMapper'],
+        Entities['OrganizationDtoMapper']
+      >;
+      CreateOrganizationDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateOrganizationDtoMapper'],
+        Entities['CreateOrganizationDtoMapper']
+      >;
+      UpdateOrganizationDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateOrganizationDtoMapper'],
+        Entities['UpdateOrganizationDtoMapper']
+      >;
+    }
+  ) {
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  }
+
+  async createOrganization(
+    organizationDto: Dto['CreateOrganizationDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['OrganizationDtoMapper']> {
+    this.openTelemetryCollector.log('info', 'Creating organization');
+    const organization =
+      this.#mapperss.CreateOrganizationDtoMapper.deserializeDtoToEntity(
+        organizationDto
+      );
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(organization);
+    });
+
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+      organization
+    );
+  }
+
+  async getOrganization(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['OrganizationDtoMapper']> {
+    const organization = await (em ?? this.em).findOneOrFail(
+      'Organization',
+      idDto
+    );
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+      organization as Entities['OrganizationDtoMapper']
+    );
+  }
+
+  async updateOrganization(
+    organizationDto: Dto['UpdateOrganizationDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['OrganizationDtoMapper']> {
+    const updatedOrganization =
+      this.#mapperss.UpdateOrganizationDtoMapper.deserializeDtoToEntity(
+        organizationDto
+      );
+    await (em ?? this.em).upsert(updatedOrganization);
+    return this.#mapperss.OrganizationDtoMapper.serializeEntityToDto(
+      updatedOrganization
+    );
+  }
+
+  async deleteOrganization(idDto: IdDto, em?: EntityManager): Promise<void> {
+    await (em ?? this.em).nativeDelete('Organization', idDto);
+  }
+}