@forklaunch/implementation-iam-base 0.1.12 → 0.1.13

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

@@ -0,0 +1,224 @@
+import {
+  OrganizationService,
+  RoleService,
+  UserService
+} from '@forklaunch/interfaces-iam/interfaces';
+
+import { IdDto, IdsDto, 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 {
+  CreateUserDto,
+  UpdateUserDto,
+  UserDto
+} from '@forklaunch/interfaces-iam/types';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+
+export class BaseUserService<
+  SchemaValidator extends AnySchemaValidator,
+  OrganizationStatus,
+  Metrics extends MetricsDefinition = MetricsDefinition,
+  Dto extends {
+    UserDtoMapper: UserDto;
+    CreateUserDtoMapper: CreateUserDto;
+    UpdateUserDtoMapper: UpdateUserDto;
+  } = {
+    UserDtoMapper: UserDto;
+    CreateUserDtoMapper: CreateUserDto;
+    UpdateUserDtoMapper: UpdateUserDto;
+  },
+  Entities extends {
+    UserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+    CreateUserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+    UpdateUserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+  } = {
+    UserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+    CreateUserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+    UpdateUserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+  }
+> implements UserService
+{
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    public em: EntityManager,
+    protected passwordEncryptionPublicKeyPath: string,
+    protected roleServiceFactory: () => RoleService,
+    protected organizationServiceFactory: () => OrganizationService<OrganizationStatus>,
+    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected schemaValidator: SchemaValidator,
+    protected mapperss: {
+      UserDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UserDtoMapper'],
+        Entities['UserDtoMapper']
+      >;
+      CreateUserDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateUserDtoMapper'],
+        Entities['CreateUserDtoMapper'],
+        (
+          dto: never,
+          passwordEncryptionPublicKeyPath: string
+        ) => Entities['UpdateUserDtoMapper']
+      >;
+      UpdateUserDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateUserDtoMapper'],
+        Entities['UpdateUserDtoMapper'],
+        (
+          dto: never,
+          passwordEncryptionPublicKeyPath: string
+        ) => Entities['UpdateUserDtoMapper']
+      >;
+    }
+  ) {
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  }
+
+  async createUser(
+    userDto: Dto['CreateUserDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper']> {
+    const user =
+      await this.#mapperss.CreateUserDtoMapper.deserializeDtoToEntity(
+        userDto,
+        this.passwordEncryptionPublicKeyPath
+      );
+    ((await em) ?? this.em).transactional(async (em) => {
+      await em.persist(user);
+    });
+    return this.#mapperss.UserDtoMapper.serializeEntityToDto(user);
+  }
+
+  async createBatchUsers(
+    userDtos: Dto['CreateUserDtoMapper'][],
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper'][]> {
+    const users = await Promise.all(
+      userDtos.map(async (createUserDto) =>
+        this.#mapperss.CreateUserDtoMapper.deserializeDtoToEntity(
+          createUserDto,
+          this.passwordEncryptionPublicKeyPath
+        )
+      )
+    );
+    await (em ?? this.em).transactional(async (em) => {
+      await em.persist(users);
+    });
+
+    return users.map((user) =>
+      this.#mapperss.UserDtoMapper.serializeEntityToDto(user)
+    );
+  }
+
+  async getUser(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper']> {
+    const user = await (em ?? this.em).findOneOrFail('User', idDto, {
+      populate: ['id', '*']
+    });
+    return this.#mapperss.UserDtoMapper.serializeEntityToDto(
+      user as Entities['UserDtoMapper']
+    );
+  }
+
+  async getBatchUsers(
+    idsDto: IdsDto,
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper'][]> {
+    return (
+      await (em ?? this.em).find('User', idsDto, {
+        populate: ['id', '*']
+      })
+    ).map((user) =>
+      this.#mapperss.UserDtoMapper.serializeEntityToDto(
+        user as Entities['UserDtoMapper']
+      )
+    );
+  }
+
+  async updateUser(
+    userDto: Dto['UpdateUserDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper']> {
+    let user = this.#mapperss.UpdateUserDtoMapper.deserializeDtoToEntity(
+      userDto,
+      this.passwordEncryptionPublicKeyPath
+    );
+    await (em ?? this.em).transactional(async (localEm) => {
+      user = await localEm.upsert(user);
+    });
+    return this.#mapperss.UserDtoMapper.serializeEntityToDto(user);
+  }
+
+  async updateBatchUsers(
+    userDtos: UpdateUserDto[],
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper'][]> {
+    let users = await Promise.all(
+      userDtos.map(async (updateUserDto) =>
+        this.#mapperss.UpdateUserDtoMapper.deserializeDtoToEntity(
+          updateUserDto,
+          this.passwordEncryptionPublicKeyPath
+        )
+      )
+    );
+    await (em ?? this.em).transactional(async (localEm) => {
+      users = await localEm.upsertMany(users);
+    });
+    return users.map((user) =>
+      this.#mapperss.UserDtoMapper.serializeEntityToDto(user)
+    );
+  }
+
+  async deleteUser(idDto: IdDto, em?: EntityManager): Promise<void> {
+    const entityManager = em || this.em;
+    await entityManager.nativeDelete('User', idDto);
+  }
+
+  async deleteBatchUsers(idsDto: IdsDto, em?: EntityManager): Promise<void> {
+    const entityManager = em || this.em;
+    await entityManager.nativeDelete('User', idsDto);
+  }
+
+  async verifyHasRole(idDto: IdDto, roleId: string): Promise<void> {
+    const user = await this.getUser(idDto);
+    if (
+      user.roles.filter((role) => {
+        return roleId == role.id;
+      }).length === 0
+    ) {
+      throw new Error(`User ${idDto.id} does not have role ${roleId}`);
+    }
+  }
+
+  async verifyHasPermission(idDto: IdDto, permissionId: string): Promise<void> {
+    const user = await this.getUser(idDto);
+    if (
+      user.roles
+        .map((role) => role.permissions.map((permission) => permission.id))
+        .flat()
+        .filter((id) => id == permissionId).length === 0
+    ) {
+      throw new Error(
+        `User ${idDto.id} does not have permission ${permissionId}`
+      );
+    }
+  }
+}

package/lib/jest.config.d.ts

@@ -0,0 +1,4 @@
+import type { JestConfigWithTsJest } from 'ts-jest';
+declare const jestConfig: JestConfigWithTsJest;
+export default jestConfig;
+//# sourceMappingURL=jest.config.d.ts.map

package/lib/jest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../jest.config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,oBAiBjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/lib/jest.config.js

@@ -0,0 +1,19 @@
+const jestConfig = {
+    preset: 'ts-jest/presets/default-esm', // or other ESM presets
+    moduleNameMapper: {
+        '^(\\.{1,2}/.*)\\.js$': '$1'
+    },
+    transform: {
+        // '^.+\\.[tj]sx?$' to process ts,js,tsx,jsx with `ts-jest`
+        // '^.+\\.m?[tj]sx?$' to process ts,js,tsx,jsx,mts,mjs,mtsx,mjsx with `ts-jest`
+        '^.+\\.[tj]sx?$': [
+            'ts-jest',
+            {
+                useESM: true
+            }
+        ],
+        '^.+\\.js$': 'babel-jest'
+    },
+    testPathIgnorePatterns: ['.*dist/', '.*node_modules/']
+};
+export default jestConfig;

package/lib/schemas/index.d.ts

@@ -0,0 +1,5 @@
+export * from './organization.schema';
+export * from './permission.schema';
+export * from './role.schema';
+export * from './user.schema';
+//# sourceMappingURL=index.d.ts.map

package/lib/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}

package/lib/schemas/index.js

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

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

@@ -0,0 +1,200 @@
+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;
+        subscription: import("@sinclair/typebox").TString;
+        logoUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+    };
+    UpdateOrganizationSchema: {
+        id: import("@sinclair/typebox").TString;
+        name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        domain: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        subscription: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        logoUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+    };
+    OrganizationSchema: <OrganizationStatus extends Record<string, import("@forklaunch/validator").LiteralSchema>>(organizationStatus: OrganizationStatus) => {
+        id: import("@sinclair/typebox").TString;
+        name: import("@sinclair/typebox").TString;
+        users: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            id: import("@sinclair/typebox").TString;
+            email: import("@sinclair/typebox").TString;
+            firstName: import("@sinclair/typebox").TString;
+            lastName: import("@sinclair/typebox").TString;
+            roles: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                id: import("@sinclair/typebox").TString;
+                name: import("@sinclair/typebox").TString;
+                permissions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    id: import("@sinclair/typebox").TString;
+                    slug: import("@sinclair/typebox").TString;
+                    extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+                    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>>;
+                }>>;
+                extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+                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>>;
+            }>>;
+            phoneNumber: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            subscription: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+            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>>;
+        }>>;
+        domain: import("@sinclair/typebox").TString;
+        subscription: import("@sinclair/typebox").TString;
+        status: import("@sinclair/typebox").TUnion<[{ [K in keyof OrganizationStatus]: import("@sinclair/typebox").TLiteral<OrganizationStatus[K]>; }[keyof OrganizationStatus]]>;
+        logoUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+        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>>;
+    };
+}, (options: {
+    uuidId: boolean;
+}) => {
+    CreateOrganizationSchema: {
+        name: import("zod").ZodString;
+        domain: import("zod").ZodString;
+        subscription: import("zod").ZodString;
+        logoUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    };
+    UpdateOrganizationSchema: {
+        id: import("zod").ZodString;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        domain: import("zod").ZodOptional<import("zod").ZodString>;
+        subscription: import("zod").ZodOptional<import("zod").ZodString>;
+        logoUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    };
+    OrganizationSchema: <OrganizationStatus extends Record<string, import("@forklaunch/validator").LiteralSchema>>(organizationStatus: OrganizationStatus) => {
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        users: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            email: import("zod").ZodString;
+            firstName: import("zod").ZodString;
+            lastName: import("zod").ZodString;
+            roles: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                name: import("zod").ZodString;
+                permissions: import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    slug: import("zod").ZodString;
+                    extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
+                    updatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+                }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+                    id: string;
+                    slug: string;
+                    extraFields?: unknown;
+                    createdAt?: Date | undefined;
+                    updatedAt?: Date | undefined;
+                }, {
+                    id: string;
+                    slug: string;
+                    extraFields?: unknown;
+                    createdAt?: Date | undefined;
+                    updatedAt?: Date | undefined;
+                }>, "many">;
+                extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
+                updatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+            }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+                id: string;
+                name: string;
+                permissions: {
+                    id: string;
+                    slug: string;
+                    extraFields?: unknown;
+                    createdAt?: Date | undefined;
+                    updatedAt?: Date | undefined;
+                }[];
+                extraFields?: unknown;
+                createdAt?: Date | undefined;
+                updatedAt?: Date | undefined;
+            }, {
+                id: string;
+                name: string;
+                permissions: {
+                    id: string;
+                    slug: string;
+                    extraFields?: unknown;
+                    createdAt?: Date | undefined;
+                    updatedAt?: Date | undefined;
+                }[];
+                extraFields?: unknown;
+                createdAt?: Date | undefined;
+                updatedAt?: Date | undefined;
+            }>, "many">;
+            phoneNumber: import("zod").ZodOptional<import("zod").ZodString>;
+            subscription: import("zod").ZodOptional<import("zod").ZodString>;
+            extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            id: string;
+            email: string;
+            firstName: string;
+            lastName: string;
+            roles: {
+                id: string;
+                name: string;
+                permissions: {
+                    id: string;
+                    slug: string;
+                    extraFields?: unknown;
+                    createdAt?: Date | undefined;
+                    updatedAt?: Date | undefined;
+                }[];
+                extraFields?: unknown;
+                createdAt?: Date | undefined;
+                updatedAt?: Date | undefined;
+            }[];
+            extraFields?: unknown;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+            phoneNumber?: string | undefined;
+            subscription?: string | undefined;
+        }, {
+            id: string;
+            email: string;
+            firstName: string;
+            lastName: string;
+            roles: {
+                id: string;
+                name: string;
+                permissions: {
+                    id: string;
+                    slug: string;
+                    extraFields?: unknown;
+                    createdAt?: Date | undefined;
+                    updatedAt?: Date | undefined;
+                }[];
+                extraFields?: unknown;
+                createdAt?: Date | undefined;
+                updatedAt?: Date | undefined;
+            }[];
+            extraFields?: unknown;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+            phoneNumber?: string | undefined;
+            subscription?: string | undefined;
+        }>, "many">;
+        domain: import("zod").ZodString;
+        subscription: import("zod").ZodString;
+        status: import("zod").ZodUnion<[{ [K in keyof OrganizationStatus]: import("zod").ZodLiteral<OrganizationStatus[K]>; }[keyof OrganizationStatus]]>;
+        logoUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
+        updatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+    };
+}>;
+//# sourceMappingURL=organization.schema.d.ts.map

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

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

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

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

@@ -0,0 +1,50 @@
+export declare const BasePermissionServiceSchemas: <SchemaValidator extends import("@forklaunch/validator").AnySchemaValidator>(options: {
+    uuidId: boolean;
+} & {
+    validator: SchemaValidator;
+}) => import("@forklaunch/core/mappers").SchemasByValidator<SchemaValidator, (options: {
+    uuidId: boolean;
+}) => {
+    CreatePermissionSchema: {
+        slug: import("@sinclair/typebox").TString;
+        addToRolesIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+    };
+    UpdatePermissionSchema: {
+        id: import("@sinclair/typebox").TString;
+        slug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+        addToRolesIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        removeFromRolesIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    };
+    PermissionSchema: {
+        id: import("@sinclair/typebox").TString;
+        slug: import("@sinclair/typebox").TString;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+        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>>;
+    };
+}, (options: {
+    uuidId: boolean;
+}) => {
+    CreatePermissionSchema: {
+        slug: import("zod").ZodString;
+        addToRolesIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    };
+    UpdatePermissionSchema: {
+        id: import("zod").ZodString;
+        slug: import("zod").ZodOptional<import("zod").ZodString>;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        addToRolesIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        removeFromRolesIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    };
+    PermissionSchema: {
+        id: import("zod").ZodString;
+        slug: import("zod").ZodString;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
+        updatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+    };
+}>;
+//# sourceMappingURL=permission.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permission.schema.d.ts","sourceRoot":"","sources":["../../schemas/permission.schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxC,CAAC"}

package/lib/schemas/permission.schema.js

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

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

@@ -0,0 +1,74 @@
+export declare const BaseRoleServiceSchemas: <SchemaValidator extends import("@forklaunch/validator").AnySchemaValidator>(options: {
+    uuidId: boolean;
+} & {
+    validator: SchemaValidator;
+}) => import("@forklaunch/core/mappers").SchemasByValidator<SchemaValidator, (options: {
+    uuidId: boolean;
+}) => {
+    CreateRoleSchema: {
+        name: import("@sinclair/typebox").TString;
+        permissionIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+    };
+    UpdateRoleSchema: {
+        id: import("@sinclair/typebox").TString;
+        name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        permissionIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+    };
+    RoleSchema: {
+        id: import("@sinclair/typebox").TString;
+        name: import("@sinclair/typebox").TString;
+        permissions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            id: import("@sinclair/typebox").TString;
+            slug: import("@sinclair/typebox").TString;
+            extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+            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>>;
+        }>>;
+        extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+        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>>;
+    };
+}, (options: {
+    uuidId: boolean;
+}) => {
+    CreateRoleSchema: {
+        name: import("zod").ZodString;
+        permissionIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    };
+    UpdateRoleSchema: {
+        id: import("zod").ZodString;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        permissionIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    };
+    RoleSchema: {
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        permissions: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            slug: import("zod").ZodString;
+            extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            id: string;
+            slug: string;
+            extraFields?: unknown;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+        }, {
+            id: string;
+            slug: string;
+            extraFields?: unknown;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+        }>, "many">;
+        extraFields: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
+        updatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+    };
+}>;
+//# sourceMappingURL=role.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"role.schema.d.ts","sourceRoot":"","sources":["../../schemas/role.schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlC,CAAC"}

package/lib/schemas/role.schema.js

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