@forklaunch/implementation-iam-base 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 forklaunch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__test__/schemaEquality.test.ts

@@ -0,0 +1,293 @@
+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/index.ts

@@ -0,0 +1,8 @@
+export * from './schemas/organization.schema';
+export * from './schemas/permission.schema';
+export * from './schemas/role.schema';
+export * from './schemas/user.schema';
+export * from './services/organization.service';
+export * from './services/permission.service';
+export * from './services/role.service';
+export * from './services/user.service';

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@forklaunch/implementation-iam-base",
+  "version": "0.1.0",
+  "description": "Billing basic implementation for forklaunch",
+  "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
+  "bugs": {
+    "url": "https://github.com/forklaunch/forklaunch-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/forklaunch/forklaunch-js.git"
+  },
+  "license": "MIT",
+  "author": "Forklift Technologies, Inc.",
+  "main": "server.ts",
+  "dependencies": {
+    "@forklaunch/common": "^0.2.5",
+    "@forklaunch/core": "^0.6.0",
+    "@forklaunch/validator": "^0.4.8",
+    "@mikro-orm/core": "^6.4.11",
+    "@sinclair/typebox": "^0.34.33",
+    "ajv": "^8.17.1",
+    "zod": "^3.24.2",
+    "@forklaunch/interfaces-iam": "0.1.0"
+  },
+  "devDependencies": {
+    "depcheck": "^1.4.7",
+    "prettier": "^3.5.3",
+    "typedoc": "^0.28.1"
+  },
+  "mikro-orm": {
+    "configPaths": [
+      "./mikro-orm.config.ts",
+      "./dist/mikro-orm.config.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist pnpm.lock.yaml node_modules",
+    "docs": "typedoc --out docs *",
+    "format": "prettier --ignore-path=.prettierignore --config .prettierrc '**/*.{ts,tsx,json}' --write",
+    "lint": "eslint . -c eslint.config.mjs",
+    "lint:fix": "eslint . -c eslint.config.mjs --fix",
+    "start": "ENV_FILE_PATH=.env.local NODE_OPTIONS='--import=tsx' node dist/server.js",
+    "start:bun": "bun run migrate:up && bun dist/server.js",
+    "test": "vitest --passWithNoTests"
+  }
+}

package/schemas/organization.schema.ts

@@ -0,0 +1,28 @@
+import { serviceSchemaResolver } from '@forklaunch/core/dtoMapper';
+import {
+  CreateOrganizationSchema as TypeBoxCreateOrganizationSchema,
+  OrganizationSchema as TypeBoxOrganizationSchema,
+  UpdateOrganizationSchema as TypeBoxUpdateOrganizationSchema
+} from './typebox/organization.schema';
+import {
+  CreateOrganizationSchema as ZodCreateOrganizationSchema,
+  OrganizationSchema as ZodOrganizationSchema,
+  UpdateOrganizationSchema as ZodUpdateOrganizationSchema
+} from './zod/organization.schema';
+
+const TypeBoxSchemas = (uuidId: boolean) => ({
+  CreateOrganizationSchema: TypeBoxCreateOrganizationSchema,
+  UpdateOrganizationSchema: TypeBoxUpdateOrganizationSchema(uuidId),
+  OrganizationSchema: TypeBoxOrganizationSchema(uuidId)
+});
+
+const ZodSchemas = (uuidId: boolean) => ({
+  CreateOrganizationSchema: ZodCreateOrganizationSchema,
+  UpdateOrganizationSchema: ZodUpdateOrganizationSchema(uuidId),
+  OrganizationSchema: ZodOrganizationSchema(uuidId)
+});
+
+export const BaseOrganizationServiceSchemas = serviceSchemaResolver(
+  TypeBoxSchemas,
+  ZodSchemas
+);

package/schemas/permission.schema.ts

@@ -0,0 +1,28 @@
+import { serviceSchemaResolver } from '@forklaunch/core/dtoMapper';
+import {
+  CreatePermissionSchema as TypeBoxCreatePermissionSchema,
+  PermissionSchema as TypeBoxPermissionSchema,
+  UpdatePermissionSchema as TypeBoxUpdatePermissionSchema
+} from './typebox/permission.schema';
+import {
+  CreatePermissionSchema as ZodCreatePermissionSchema,
+  PermissionSchema as ZodPermissionSchema,
+  UpdatePermissionSchema as ZodUpdatePermissionSchema
+} from './zod/permission.schema';
+
+const TypeBoxSchemas = (uuidId: boolean) => ({
+  CreatePermissionSchema: TypeBoxCreatePermissionSchema,
+  UpdatePermissionSchema: TypeBoxUpdatePermissionSchema(uuidId),
+  PermissionSchema: TypeBoxPermissionSchema(uuidId)
+});
+
+const ZodSchemas = (uuidId: boolean) => ({
+  CreatePermissionSchema: ZodCreatePermissionSchema,
+  UpdatePermissionSchema: ZodUpdatePermissionSchema(uuidId),
+  PermissionSchema: ZodPermissionSchema(uuidId)
+});
+
+export const BasePermissionServiceSchemas = serviceSchemaResolver(
+  TypeBoxSchemas,
+  ZodSchemas
+);

package/schemas/role.schema.ts

@@ -0,0 +1,28 @@
+import { serviceSchemaResolver } from '@forklaunch/core/dtoMapper';
+import {
+  CreateRoleSchema as TypeBoxCreateRoleSchema,
+  RoleSchema as TypeBoxRoleSchema,
+  UpdateRoleSchema as TypeBoxUpdateRoleSchema
+} from './typebox/role.schema';
+import {
+  CreateRoleSchema as ZodCreateRoleSchema,
+  RoleSchema as ZodRoleSchema,
+  UpdateRoleSchema as ZodUpdateRoleSchema
+} from './zod/role.schema';
+
+const TypeBoxSchemas = (uuidId: boolean) => ({
+  CreateRoleSchema: TypeBoxCreateRoleSchema,
+  UpdateRoleSchema: TypeBoxUpdateRoleSchema(uuidId),
+  RoleSchema: TypeBoxRoleSchema(uuidId)
+});
+
+const ZodSchemas = (uuidId: boolean) => ({
+  CreateRoleSchema: ZodCreateRoleSchema,
+  UpdateRoleSchema: ZodUpdateRoleSchema(uuidId),
+  RoleSchema: ZodRoleSchema(uuidId)
+});
+
+export const BaseRoleServiceSchemas = serviceSchemaResolver(
+  TypeBoxSchemas,
+  ZodSchemas
+);

package/schemas/typebox/organization.schema.ts

@@ -0,0 +1,49 @@
+import { IdiomaticSchema, LiteralSchema } from '@forklaunch/validator';
+import {
+  array,
+  date,
+  enum_,
+  optional,
+  string,
+  TypeboxSchemaValidator,
+  unknown,
+  uuid
+} from '@forklaunch/validator/typebox';
+
+export const CreateOrganizationSchema = {
+  name: string,
+  domain: string,
+  subscription: string,
+  logoUrl: optional(string),
+  extraFields: optional(unknown)
+};
+
+export const UpdateOrganizationSchema = (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: boolean) =>
+  <
+    UserDtoSchema extends IdiomaticSchema<TypeboxSchemaValidator>,
+    OrganizationStatus extends Record<string, LiteralSchema>
+  >(
+    UserDtoSchema: UserDtoSchema,
+    OrganizationStatus: OrganizationStatus
+  ) => ({
+    id: uuidId ? uuid : string,
+    name: string,
+    users: array(UserDtoSchema),
+    domain: string,
+    subscription: string,
+    status: enum_(OrganizationStatus),
+    logoUrl: optional(string),
+    extraFields: optional(unknown),
+    createdAt: optional(date),
+    updatedAt: optional(date)
+  });

package/schemas/typebox/permission.schema.ts

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

package/schemas/typebox/role.schema.ts

@@ -0,0 +1,36 @@
+import { IdiomaticSchema } from '@forklaunch/validator';
+import {
+  array,
+  date,
+  optional,
+  string,
+  TypeboxSchemaValidator,
+  unknown,
+  uuid
+} from '@forklaunch/validator/typebox';
+
+export const CreateRoleSchema = {
+  name: string,
+  permissionIds: optional(array(string)),
+  extraFields: optional(unknown)
+};
+
+export const UpdateRoleSchema = (uuidId: boolean) => ({
+  id: uuidId ? uuid : string,
+  name: optional(string),
+  permissionIds: optional(array(string)),
+  extraFields: optional(unknown)
+});
+
+export const RoleSchema =
+  (uuidId: boolean) =>
+  <PermissionSchema extends IdiomaticSchema<TypeboxSchemaValidator>>(
+    PermissionSchema: PermissionSchema
+  ) => ({
+    id: uuidId ? uuid : string,
+    name: string,
+    permissions: array(PermissionSchema),
+    extraFields: optional(unknown),
+    createdAt: optional(date),
+    updatedAt: optional(date)
+  });

package/schemas/typebox/user.schema.ts

@@ -0,0 +1,52 @@
+import { IdiomaticSchema } from '@forklaunch/validator';
+import {
+  array,
+  date,
+  email,
+  optional,
+  string,
+  TypeboxSchemaValidator,
+  unknown,
+  uuid
+} from '@forklaunch/validator/typebox';
+
+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: 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: boolean) =>
+  <RoleDtoSchema extends IdiomaticSchema<TypeboxSchemaValidator>>(
+    RoleDtoSchema: RoleDtoSchema
+  ) => ({
+    id: uuidId ? uuid : string,
+    email: email,
+    firstName: string,
+    lastName: string,
+    roles: array(RoleDtoSchema),
+    phoneNumber: optional(string),
+    subscription: optional(string),
+    extraFields: optional(unknown),
+    createdAt: optional(date),
+    updatedAt: optional(date)
+  });

package/schemas/user.schema.ts

@@ -0,0 +1,28 @@
+import { serviceSchemaResolver } from '@forklaunch/core/dtoMapper';
+import {
+  CreateUserSchema as TypeBoxCreateUserSchema,
+  UpdateUserSchema as TypeBoxUpdateUserSchema,
+  UserSchema as TypeBoxUserSchema
+} from './typebox/user.schema';
+import {
+  CreateUserSchema as ZodCreateUserSchema,
+  UpdateUserSchema as ZodUpdateUserSchema,
+  UserSchema as ZodUserSchema
+} from './zod/user.schema';
+
+const TypeBoxSchemas = (uuidId: boolean) => ({
+  CreateUserSchema: TypeBoxCreateUserSchema,
+  UpdateUserSchema: TypeBoxUpdateUserSchema(uuidId),
+  UserSchema: TypeBoxUserSchema(uuidId)
+});
+
+const ZodSchemas = (uuidId: boolean) => ({
+  CreateUserSchema: ZodCreateUserSchema,
+  UpdateUserSchema: ZodUpdateUserSchema(uuidId),
+  UserSchema: ZodUserSchema(uuidId)
+});
+
+export const BaseUserServiceSchemas = serviceSchemaResolver(
+  TypeBoxSchemas,
+  ZodSchemas
+);