@forklaunch/implementation-iam-base 0.1.11 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/implementation-iam-base",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Billing basic implementation for forklaunch",
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "bugs": {
@@ -28,14 +28,14 @@
     "lib/**"
   ],
   "dependencies": {
-    "@forklaunch/common": "link:../../../../framework/common",
-    "@forklaunch/core": "link:../../../../framework/core",
-    "@forklaunch/validator": "link:../../../../framework/validator",
+    "@forklaunch/common": "^0.2.11",
+    "@forklaunch/core": "^0.7.4",
+    "@forklaunch/validator": "^0.5.4",
     "@mikro-orm/core": "^6.4.13",
     "@sinclair/typebox": "^0.34.33",
     "ajv": "^8.17.1",
     "zod": "^3.24.3",
-    "@forklaunch/interfaces-iam": "0.1.11"
+    "@forklaunch/interfaces-iam": "0.1.12"
   },
   "devDependencies": {
     "depcheck": "^1.4.7",

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

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

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

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

package/lib/__test__/schemaEquality.test.js

@@ -1,283 +0,0 @@
-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

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

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

@@ -1,53 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

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

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

@@ -1,143 +0,0 @@
-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);
-  }
-}