@flusys/nestjs-iam 0.1.0-alpha.1

package/services/action.service.d.ts

@@ -0,0 +1,35 @@
+import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { Logger } from '@nestjs/common';
+import { EntityTarget, Repository, SelectQueryBuilder } from 'typeorm';
+import { CreateActionDto, UpdateActionDto } from '../dtos/action.dto';
+import { ActionBase } from '../entities/action-base.entity';
+import { IAction, IActionTree } from '../interfaces/action.interface';
+import { IAMConfigService } from './iam-config.service';
+import { IAMDataSourceProvider } from './iam-datasource.provider';
+import { PermissionService } from './permission.service';
+export declare class ActionService extends RequestScopedApiService<CreateActionDto, UpdateActionDto, IAction, ActionBase, Repository<ActionBase>> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly iamConfigService;
+    private readonly dataSourceProvider;
+    private readonly permissionService;
+    protected logger: Logger;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, iamConfigService: IAMConfigService, dataSourceProvider: IAMDataSourceProvider, permissionService: PermissionService);
+    protected resolveEntity(): EntityTarget<ActionBase>;
+    protected getDataSourceProvider(): IAMDataSourceProvider;
+    convertSingleDtoToEntity(dto: CreateActionDto | UpdateActionDto, _user: ILoggedUserInfo): Promise<ActionBase>;
+    getSelectQuery(query: SelectQueryBuilder<ActionBase>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<ActionBase>;
+        isRaw: boolean;
+    }>;
+    protected getGlobalSearchQuery(query: SelectQueryBuilder<ActionBase>, search: string, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<ActionBase>;
+        isRaw: boolean;
+    }>;
+    protected convertEntityToResponseDto(entity: ActionBase, _isRaw: boolean): IAction;
+    getActionsForPermission(user: ILoggedUserInfo): Promise<IAction[]>;
+    getActionTree(user: ILoggedUserInfo, search?: string, isActive?: boolean, withDeleted?: boolean): Promise<IActionTree[]>;
+    private buildActionTree;
+}

package/services/iam-config.service.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseMode } from '@flusys/nestjs-core';
+import { IAMPermissionMode } from '../enums/permission-type.enum';
+import { IAMModuleOptions } from '../interfaces/iam-module-options.interface';
+export declare class IAMConfigService {
+    private readonly options;
+    constructor(injectedOptions?: IAMModuleOptions);
+    getDatabaseMode(): DatabaseMode;
+    isMultiTenant(): boolean;
+    getEnableCompanyFeature(): boolean;
+    isCompanyFeatureEnabled(): boolean;
+    getPermissionMode(): IAMPermissionMode;
+    isRbacEnabled(): boolean;
+    isDirectPermissionEnabled(): boolean;
+    getOptions(): IAMModuleOptions;
+}

package/services/iam-datasource.provider.d.ts

@@ -0,0 +1,25 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { IDatabaseConfig, ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { Logger } from '@nestjs/common';
+import { Request } from 'express';
+import { DataSource } from 'typeorm';
+import { IAMModuleOptions } from '../interfaces/iam-module-options.interface';
+export declare class IAMDataSourceProvider extends MultiTenantDataSourceService {
+    private readonly iamOptions;
+    protected readonly logger: Logger;
+    protected static readonly tenantConnections: Map<string, DataSource>;
+    protected static singleDataSource: DataSource | null;
+    protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;
+    protected static initialized: boolean;
+    protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
+    protected static singleConnectionLock: Promise<DataSource> | null;
+    constructor(iamOptions: IAMModuleOptions, request?: Request);
+    private static buildParentOptions;
+    getEnableCompanyFeature(): boolean;
+    getEnableCompanyFeatureForTenant(tenant?: ITenantDatabaseConfig): boolean;
+    getEnableCompanyFeatureForCurrentTenant(): boolean;
+    getIAMEntities(): Promise<any[]>;
+    protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
+    protected getSingleDataSource(): Promise<DataSource>;
+    protected getOrCreateTenantConnection(tenant: ITenantDatabaseConfig): Promise<DataSource>;
+}

package/services/index.d.ts

@@ -0,0 +1,6 @@
+export * from './action.service';
+export * from './iam-config.service';
+export * from './iam-datasource.provider';
+export * from './permission-cache.service';
+export * from './permission.service';
+export * from './role.service';

package/services/permission-cache.service.d.ts

@@ -0,0 +1,41 @@
+import { HybridCache } from '@flusys/nestjs-shared';
+export interface PermissionCacheKeyOptions {
+    userId: string;
+    companyId?: string | null;
+    branchId?: string | null;
+    enableCompanyFeature: boolean;
+}
+export interface CachedMyPermissions {
+    frontendActions: Array<{
+        id: string;
+        code: string;
+        name: string;
+        description: string | null;
+        parentId: string | null;
+    }>;
+    backendCodes: string[];
+}
+export declare class PermissionCacheService {
+    private readonly cacheManager;
+    private readonly logger;
+    private readonly TTL;
+    private readonly ACTION_CODE_TTL;
+    private readonly CACHE_PREFIX;
+    private readonly MY_PERMISSIONS_PREFIX;
+    private readonly ACTION_CODE_PREFIX;
+    constructor(cacheManager: HybridCache);
+    generateCacheKey(options: PermissionCacheKeyOptions): string;
+    generateMyPermissionsCacheKey(options: PermissionCacheKeyOptions): string;
+    setPermissions(options: PermissionCacheKeyOptions, permissions: string[]): Promise<void>;
+    getPermissions(options: PermissionCacheKeyOptions): Promise<string[] | null>;
+    setMyPermissions(options: PermissionCacheKeyOptions, data: CachedMyPermissions): Promise<void>;
+    getMyPermissions(options: PermissionCacheKeyOptions): Promise<CachedMyPermissions | null>;
+    setActionCodeMap(codeToIdMap: Record<string, string>): Promise<void>;
+    getActionIdsByCodes(codes: string[]): Promise<Record<string, string> | null>;
+    invalidateActionCodeCache(): Promise<void>;
+    invalidateUser(userId: string, companyId?: string | null, branchIds?: (string | null)[]): Promise<void>;
+    invalidateUsers(userIds: string[], companyId?: string | null, branchIds?: (string | null)[]): Promise<number>;
+    invalidateCompany(companyId: string): Promise<number>;
+    invalidateRole(roleId: string, userIds: string[], companyId?: string | null, branchIds?: (string | null)[]): Promise<number>;
+    clearAll(): Promise<void>;
+}

package/services/permission.service.d.ts

@@ -0,0 +1,37 @@
+import { AssignCompanyActionsDto, AssignRoleActionsDto, AssignUserActionsDto, AssignUserRolesDto, CompanyActionResponseDto, MyPermissionsResponseDto, PermissionOperationResultDto, RoleActionResponseDto, UserActionResponseDto, UserRoleResponseDto } from '../dtos/permission.dto';
+import { PermissionEvaluatorHelper } from '../helpers/permission-evaluator.helper';
+import { IAMConfigService } from './iam-config.service';
+import { IAMDataSourceProvider } from './iam-datasource.provider';
+import { PermissionCacheService } from './permission-cache.service';
+export declare class PermissionService {
+    private readonly permissionEvaluator;
+    private readonly permissionCacheService;
+    private readonly iamConfigService;
+    private readonly dataSourceProvider;
+    private readonly logger;
+    constructor(permissionEvaluator: PermissionEvaluatorHelper, permissionCacheService: PermissionCacheService, iamConfigService: IAMConfigService, dataSourceProvider: IAMDataSourceProvider);
+    private getPermissionRepository;
+    private getActionRepository;
+    private getRoleRepository;
+    assignUserActions(dto: AssignUserActionsDto): Promise<PermissionOperationResultDto>;
+    getUserActions(userId: string, branchId: string | undefined, companyId?: string | undefined): Promise<UserActionResponseDto[]>;
+    assignRoleActions(dto: AssignRoleActionsDto): Promise<PermissionOperationResultDto>;
+    getRoleActions(roleId: string): Promise<RoleActionResponseDto[]>;
+    assignCompanyActions(dto: AssignCompanyActionsDto): Promise<PermissionOperationResultDto>;
+    private addCompanyActions;
+    private removeCompanyActionsWithCascade;
+    getCompanyActions(companyId: string): Promise<CompanyActionResponseDto[]>;
+    getCompanyActionIds(companyId: string): Promise<string[]>;
+    assignUserRoles(dto: AssignUserRolesDto): Promise<PermissionOperationResultDto>;
+    getUserRoles(userId: string, branchId?: string | undefined, companyId?: string | undefined): Promise<UserRoleResponseDto[]>;
+    getMyPermissions(userId: string, branchId: string | null, companyId?: string | null, parentCodes?: string[]): Promise<MyPermissionsResponseDto>;
+    private buildResponseFromCache;
+    private getParentIdsByCodesWithCache;
+    private fetchAndCachePermissions;
+    private getUserRoleIds;
+    private getRoleActionIds;
+    private getUserActionIds;
+    private invalidateUserPermissionCache;
+    private invalidateRoleMembersCache;
+    private invalidateCompanyMembersCache;
+}

package/services/role.service.d.ts

@@ -0,0 +1,35 @@
+import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { Logger } from '@nestjs/common';
+import { EntityTarget, Repository, SelectQueryBuilder } from 'typeorm';
+import { CreateRoleDto, UpdateRoleDto } from '../dtos/role.dto';
+import { RoleBase } from '../entities/role-base.entity';
+import { IRole } from '../interfaces/role.interface';
+import { IAMConfigService } from './iam-config.service';
+import { IAMDataSourceProvider } from './iam-datasource.provider';
+export declare class RoleService extends RequestScopedApiService<CreateRoleDto, UpdateRoleDto, IRole, RoleBase, Repository<RoleBase>> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly iamConfigService;
+    private readonly dataSourceProvider;
+    protected logger: Logger;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, iamConfigService: IAMConfigService, dataSourceProvider: IAMDataSourceProvider);
+    protected resolveEntity(): EntityTarget<RoleBase>;
+    protected getDataSourceProvider(): IAMDataSourceProvider;
+    convertSingleDtoToEntity(dto: CreateRoleDto | UpdateRoleDto, user: ILoggedUserInfo | null): Promise<RoleBase>;
+    getSelectQuery(query: SelectQueryBuilder<RoleBase>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<RoleBase>;
+        isRaw: boolean;
+    }>;
+    protected getGlobalSearchQuery(query: SelectQueryBuilder<RoleBase>, search: string, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<RoleBase>;
+        isRaw: boolean;
+    }>;
+    protected getExtraManipulateQuery(query: SelectQueryBuilder<RoleBase>, filterDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<RoleBase>;
+        isRaw: boolean;
+    }>;
+    protected convertEntityToResponseDto(entity: RoleBase, _isRaw: boolean): IRole;
+}

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from './logic-node.type';

package/types/logic-node.type.d.ts

@@ -0,0 +1,15 @@
+export interface LogicNode {
+    id: string;
+    type: 'group' | 'action';
+    operator?: 'AND' | 'OR';
+    actionId?: string;
+    children?: LogicNode[];
+}
+export declare enum LogicOperator {
+    AND = "AND",
+    OR = "OR"
+}
+export declare enum LogicNodeType {
+    GROUP = "group",
+    ACTION = "action"
+}