@flusys/nestjs-iam 7.1.0 → 8.0.0-beta.1

package/fesm/helpers/permission-mode.helper.js

@@ -1,49 +0,0 @@
-import { IAMPermissionMode } from '../enums/permission-type.enum';
-/**
- * Helper for converting permission mode strings to enum values
- *
- * **Purpose:** Centralize the conversion logic from IBootstrapAppConfig.permissionMode
- * (string) to IAMPermissionMode enum to prevent duplication and sync issues.
- *
- * **Used by:**
- * - iam.module.ts (forRoot, forRootAsync)
- * - iam-config.service.ts (getPermissionMode)
- * - main.ts (Swagger setup)
- */ export class PermissionModeHelper {
-    /**
-   * Convert permission mode string to enum value
-   *
-   * @param modeStr - Permission mode string ('FULL', 'RBAC', 'DIRECT')
-   * @returns IAMPermissionMode enum value
-   * @default IAMPermissionMode.FULL if invalid/missing
-   *
-   * @example
-   * ```typescript
-   * const mode = PermissionModeHelper.fromString('RBAC');
-   * // Returns: IAMPermissionMode.RBAC
-   *
-   * const mode = PermissionModeHelper.fromString(undefined);
-   * // Returns: IAMPermissionMode.FULL (default)
-   * ```
-   */ static fromString(modeStr) {
-        if (!modeStr) {
-            return IAMPermissionMode.FULL;
-        }
-        const mode = IAMPermissionMode[modeStr];
-        return mode ?? IAMPermissionMode.FULL;
-    }
-    /**
-   * Convert enum value to string (for serialization/logging)
-   *
-   * @param mode - IAMPermissionMode enum value
-   * @returns String representation
-   *
-   * @example
-   * ```typescript
-   * const str = PermissionModeHelper.toString(IAMPermissionMode.RBAC);
-   * // Returns: 'RBAC'
-   * ```
-   */ static toString(mode) {
-        return IAMPermissionMode[mode];
-    }
-}

package/fesm/helpers/permission-mode.helper.spec.js

@@ -1,50 +0,0 @@
-import { IAMPermissionMode } from '../enums/permission-type.enum';
-import { PermissionModeHelper } from './permission-mode.helper';
-describe('PermissionModeHelper', ()=>{
-    describe('fromString', ()=>{
-        it('converts "RBAC" to IAMPermissionMode.RBAC', ()=>{
-            expect(PermissionModeHelper.fromString('RBAC')).toBe(IAMPermissionMode.RBAC);
-        });
-        it('converts "DIRECT" to IAMPermissionMode.DIRECT', ()=>{
-            expect(PermissionModeHelper.fromString('DIRECT')).toBe(IAMPermissionMode.DIRECT);
-        });
-        it('converts "FULL" to IAMPermissionMode.FULL', ()=>{
-            expect(PermissionModeHelper.fromString('FULL')).toBe(IAMPermissionMode.FULL);
-        });
-        it('defaults to FULL when the string is undefined', ()=>{
-            expect(PermissionModeHelper.fromString(undefined)).toBe(IAMPermissionMode.FULL);
-        });
-        it('defaults to FULL when the string is empty', ()=>{
-            expect(PermissionModeHelper.fromString('')).toBe(IAMPermissionMode.FULL);
-        });
-        it('defaults to FULL when the string is not a known mode', ()=>{
-            expect(PermissionModeHelper.fromString('INVALID_MODE')).toBe(IAMPermissionMode.FULL);
-        });
-        it('is case-sensitive and falls back to FULL for lowercase input', ()=>{
-            expect(PermissionModeHelper.fromString('rbac')).toBe(IAMPermissionMode.FULL);
-        });
-    });
-    describe('toString', ()=>{
-        it('converts IAMPermissionMode.RBAC to "RBAC"', ()=>{
-            expect(PermissionModeHelper.toString(IAMPermissionMode.RBAC)).toBe('RBAC');
-        });
-        it('converts IAMPermissionMode.DIRECT to "DIRECT"', ()=>{
-            expect(PermissionModeHelper.toString(IAMPermissionMode.DIRECT)).toBe('DIRECT');
-        });
-        it('converts IAMPermissionMode.FULL to "FULL"', ()=>{
-            expect(PermissionModeHelper.toString(IAMPermissionMode.FULL)).toBe('FULL');
-        });
-    });
-    describe('round trip', ()=>{
-        it('fromString(toString(mode)) returns the original mode for every enum value', ()=>{
-            const modes = [
-                IAMPermissionMode.RBAC,
-                IAMPermissionMode.DIRECT,
-                IAMPermissionMode.FULL
-            ];
-            for (const mode of modes){
-                expect(PermissionModeHelper.fromString(PermissionModeHelper.toString(mode))).toBe(mode);
-            }
-        });
-    });
-});

package/fesm/interfaces/action.interface.js

@@ -1,3 +0,0 @@
-/**
- * Action with children (tree structure)
- */ export { };

package/fesm/interfaces/iam-module-options.interface.js

@@ -1,3 +0,0 @@
-/**
- * Async options for IAMModule registration
- */ export { };

package/fesm/interfaces/role.interface.js

@@ -1,4 +0,0 @@
-/**
- * Role Interface
- * Represents a role entity in responses
- */ export { };

package/fesm/modules/iam.module.js

@@ -1,176 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { PERMISSION_GUARD_CONFIG, PERMISSIONS_CACHE_PREFIX } from '@flusys/nestjs-shared';
-import { CacheModule, UtilsModule, createModuleEventsProvider } from '@flusys/nestjs-shared/modules';
-import { Module } from '@nestjs/common';
-import { IAM_MODULE_OPTIONS } from '../config/iam.constants';
-import { ActionController, CompanyActionPermissionController, MyPermissionController, RoleController, RolePermissionController, UserActionPermissionController } from '../controllers';
-import { IAMPermissionMode } from '../enums/permission-type.enum';
-import { PermissionModeHelper } from '../helpers';
-import { ActionService, PermissionService, RoleService } from '../services';
-import { IAMConfigService } from '../services/iam-config.service';
-import { IAMDataSourceService } from '../services/iam-datasource.service';
-import { PermissionCacheService } from '../services/permission-cache.service';
-export class IAMModule {
-    static getControllers(permissionMode, enableCompanyFeature) {
-        const baseControllers = [
-            ActionController,
-            MyPermissionController
-        ];
-        // Direct permission mode - user actions only
-        if (permissionMode === IAMPermissionMode.DIRECT) {
-            baseControllers.push(UserActionPermissionController);
-        }
-        // RBAC mode - role actions and user roles only
-        if (permissionMode === IAMPermissionMode.RBAC) {
-            baseControllers.push(RoleController);
-            baseControllers.push(RolePermissionController);
-        }
-        // FULL mode - all permission controllers
-        if (permissionMode === IAMPermissionMode.FULL) {
-            baseControllers.push(RoleController);
-            baseControllers.push(UserActionPermissionController);
-            baseControllers.push(RolePermissionController);
-        }
-        // Company action permissions - only if company feature enabled
-        if (enableCompanyFeature) {
-            baseControllers.push(CompanyActionPermissionController);
-        }
-        return baseControllers;
-    }
-    static getServices(permissionMode) {
-        const services = [
-            ActionService,
-            PermissionService,
-            PermissionCacheService
-        ];
-        // RoleService - Only for RBAC or FULL mode
-        if (permissionMode === IAMPermissionMode.RBAC || permissionMode === IAMPermissionMode.FULL) {
-            services.push(RoleService);
-        }
-        return services;
-    }
-    static getPermissionGuardConfigProvider(enableCompanyFeature) {
-        return {
-            provide: PERMISSION_GUARD_CONFIG,
-            useValue: {
-                enableCompanyFeature,
-                userPermissionKeyFormat: `${PERMISSIONS_CACHE_PREFIX}:user:{userId}`,
-                companyPermissionKeyFormat: `${PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`
-            }
-        };
-    }
-    static getExports(permissionMode) {
-        const baseExports = [
-            IAMConfigService,
-            IAMDataSourceService,
-            ActionService,
-            PermissionService,
-            PermissionCacheService,
-            PERMISSION_GUARD_CONFIG
-        ];
-        if (permissionMode === IAMPermissionMode.RBAC || permissionMode === IAMPermissionMode.FULL) {
-            baseExports.push(RoleService);
-        }
-        return baseExports;
-    }
-    static forRoot(options = {}) {
-        const { global = false, includeController = false } = options;
-        const enableCompanyFeature = options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-        const permissionMode = PermissionModeHelper.fromString(options.bootstrapAppConfig?.permissionMode);
-        const controllers = includeController ? this.getControllers(permissionMode, enableCompanyFeature) : [];
-        const providers = [
-            {
-                provide: IAM_MODULE_OPTIONS,
-                useValue: options
-            },
-            IAMConfigService,
-            IAMDataSourceService,
-            ...this.getServices(permissionMode),
-            this.getPermissionGuardConfigProvider(enableCompanyFeature),
-            createModuleEventsProvider('iam', IAM_MODULE_OPTIONS)
-        ];
-        const module = {
-            module: IAMModule,
-            imports: [
-                CacheModule,
-                UtilsModule
-            ],
-            controllers,
-            providers,
-            exports: this.getExports(permissionMode)
-        };
-        return global ? {
-            ...module,
-            global: true
-        } : module;
-    }
-    static forRootAsync(asyncOptions) {
-        const { global = false, includeController = false, imports: externalImports = [] } = asyncOptions;
-        const enableCompanyFeature = asyncOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
-        const permissionMode = PermissionModeHelper.fromString(asyncOptions.bootstrapAppConfig?.permissionMode);
-        const controllers = includeController ? this.getControllers(permissionMode, enableCompanyFeature) : [];
-        const providers = [
-            ...this.createAsyncProviders(asyncOptions),
-            IAMConfigService,
-            IAMDataSourceService,
-            ...this.getServices(permissionMode),
-            this.getPermissionGuardConfigProvider(enableCompanyFeature),
-            createModuleEventsProvider('iam', IAM_MODULE_OPTIONS)
-        ];
-        const module = {
-            module: IAMModule,
-            imports: [
-                ...externalImports,
-                CacheModule,
-                UtilsModule
-            ],
-            controllers,
-            providers,
-            exports: this.getExports(permissionMode)
-        };
-        return global ? {
-            ...module,
-            global: true
-        } : module;
-    }
-    static createAsyncProviders(options) {
-        if (options.useExisting || options.useFactory) {
-            return [
-                this.createAsyncOptionsProvider(options)
-            ];
-        }
-        const useClass = options.useClass;
-        return [
-            this.createAsyncOptionsProvider(options),
-            {
-                provide: useClass,
-                useClass
-            }
-        ];
-    }
-    static createAsyncOptionsProvider(options) {
-        if (options.useFactory) {
-            return {
-                provide: IAM_MODULE_OPTIONS,
-                useFactory: options.useFactory,
-                inject: options.inject || []
-            };
-        }
-        const inject = [
-            options.useClass || options.useExisting
-        ];
-        return {
-            provide: IAM_MODULE_OPTIONS,
-            useFactory: async (optionsFactory)=>optionsFactory.createIAMOptions(),
-            inject
-        };
-    }
-}
-IAMModule = _ts_decorate([
-    Module({})
-], IAMModule);

package/fesm/modules/iam.module.spec.js

@@ -1,278 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { PERMISSION_GUARD_CONFIG } from '@flusys/nestjs-shared';
-import { IAMModule } from './iam.module';
-import { IAM_MODULE_OPTIONS } from '../config/iam.constants';
-import { ActionController, CompanyActionPermissionController, MyPermissionController, RoleController, RolePermissionController, UserActionPermissionController } from '../controllers';
-import { ActionService, PermissionService, RoleService } from '../services';
-import { IAMConfigService } from '../services/iam-config.service';
-import { IAMDataSourceService } from '../services/iam-datasource.service';
-import { PermissionCacheService } from '../services/permission-cache.service';
-function providerTokens(providers) {
-    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
-}
-describe('IAMModule', ()=>{
-    describe('forRoot - controller/service registration matrix', ()=>{
-        it('should register no controllers by default (includeController defaults to false)', ()=>{
-            const dynamicModule = IAMModule.forRoot();
-            expect(dynamicModule.controllers).toEqual([]);
-        });
-        it('DIRECT mode: registers only UserActionPermissionController beyond the base set', ()=>{
-            const dynamicModule = IAMModule.forRoot({
-                includeController: true,
-                bootstrapAppConfig: {
-                    permissionMode: 'DIRECT'
-                }
-            });
-            expect(dynamicModule.controllers).toEqual([
-                ActionController,
-                MyPermissionController,
-                UserActionPermissionController
-            ]);
-            expect(providerTokens(dynamicModule.providers)).not.toContain(RoleService);
-        });
-        it('RBAC mode: registers RoleController + RolePermissionController but not UserActionPermissionController', ()=>{
-            const dynamicModule = IAMModule.forRoot({
-                includeController: true,
-                bootstrapAppConfig: {
-                    permissionMode: 'RBAC'
-                }
-            });
-            expect(dynamicModule.controllers).toEqual([
-                ActionController,
-                MyPermissionController,
-                RoleController,
-                RolePermissionController
-            ]);
-            expect(providerTokens(dynamicModule.providers)).toContain(RoleService);
-        });
-        it('FULL mode: registers every permission controller', ()=>{
-            const dynamicModule = IAMModule.forRoot({
-                includeController: true,
-                bootstrapAppConfig: {
-                    permissionMode: 'FULL'
-                }
-            });
-            expect(dynamicModule.controllers).toEqual([
-                ActionController,
-                MyPermissionController,
-                RoleController,
-                UserActionPermissionController,
-                RolePermissionController
-            ]);
-        });
-        it('defaults to FULL mode when permissionMode is omitted', ()=>{
-            const dynamicModule = IAMModule.forRoot({
-                includeController: true
-            });
-            expect(dynamicModule.controllers).toEqual(expect.arrayContaining([
-                RoleController,
-                UserActionPermissionController,
-                RolePermissionController
-            ]));
-        });
-        it('defaults to FULL mode when permissionMode is an unrecognized string', ()=>{
-            const dynamicModule = IAMModule.forRoot({
-                includeController: true,
-                bootstrapAppConfig: {
-                    permissionMode: 'BOGUS'
-                }
-            });
-            expect(dynamicModule.controllers).toEqual(expect.arrayContaining([
-                RoleController,
-                UserActionPermissionController,
-                RolePermissionController
-            ]));
-        });
-        it('adds CompanyActionPermissionController only when enableCompanyFeature is true', ()=>{
-            const withCompany = IAMModule.forRoot({
-                includeController: true,
-                bootstrapAppConfig: {
-                    enableCompanyFeature: true
-                }
-            });
-            const withoutCompany = IAMModule.forRoot({
-                includeController: true,
-                bootstrapAppConfig: {
-                    enableCompanyFeature: false
-                }
-            });
-            expect(withCompany.controllers).toContain(CompanyActionPermissionController);
-            expect(withoutCompany.controllers).not.toContain(CompanyActionPermissionController);
-        });
-        it('excludes RoleService for DIRECT mode but includes it for RBAC/FULL', ()=>{
-            const direct = IAMModule.forRoot({
-                bootstrapAppConfig: {
-                    permissionMode: 'DIRECT'
-                }
-            });
-            const rbac = IAMModule.forRoot({
-                bootstrapAppConfig: {
-                    permissionMode: 'RBAC'
-                }
-            });
-            const full = IAMModule.forRoot({
-                bootstrapAppConfig: {
-                    permissionMode: 'FULL'
-                }
-            });
-            expect(providerTokens(direct.providers)).not.toContain(RoleService);
-            expect(providerTokens(rbac.providers)).toContain(RoleService);
-            expect(providerTokens(full.providers)).toContain(RoleService);
-            expect(providerTokens(direct.exports)).not.toContain(RoleService);
-            expect(providerTokens(rbac.exports)).toContain(RoleService);
-        });
-        it('always registers the base providers/exports (ActionService, PermissionService, PermissionCacheService)', ()=>{
-            const dynamicModule = IAMModule.forRoot();
-            expect(providerTokens(dynamicModule.providers)).toEqual(expect.arrayContaining([
-                IAMConfigService,
-                IAMDataSourceService,
-                ActionService,
-                PermissionService,
-                PermissionCacheService
-            ]));
-            expect(dynamicModule.exports).toEqual(expect.arrayContaining([
-                IAMConfigService,
-                IAMDataSourceService,
-                ActionService,
-                PermissionService,
-                PermissionCacheService,
-                PERMISSION_GUARD_CONFIG
-            ]));
-        });
-    });
-    describe('forRoot - options/global handling', ()=>{
-        it('should not set `global` on the returned module when global is false/omitted', ()=>{
-            const dynamicModule = IAMModule.forRoot();
-            expect(dynamicModule.global).toBeUndefined();
-        });
-        it('should set global: true when requested', ()=>{
-            const dynamicModule = IAMModule.forRoot({
-                global: true
-            });
-            expect(dynamicModule.global).toBe(true);
-        });
-        it('should register IAM_MODULE_OPTIONS with the given options', ()=>{
-            const options = {
-                includeController: true
-            };
-            const dynamicModule = IAMModule.forRoot(options);
-            const provider = dynamicModule.providers.find((p)=>p.provide === IAM_MODULE_OPTIONS);
-            expect(provider.useValue).toBe(options);
-        });
-        it('should build a company-aware PERMISSION_GUARD_CONFIG provider', ()=>{
-            const dynamicModule = IAMModule.forRoot({
-                bootstrapAppConfig: {
-                    enableCompanyFeature: true
-                }
-            });
-            const provider = dynamicModule.providers.find((p)=>p.provide === PERMISSION_GUARD_CONFIG);
-            expect(provider.useValue.enableCompanyFeature).toBe(true);
-            expect(provider.useValue.userPermissionKeyFormat).toContain('{userId}');
-            expect(provider.useValue.companyPermissionKeyFormat).toContain('{companyId}');
-        });
-    });
-    describe('forRootAsync', ()=>{
-        it('mirrors the controller/service registration matrix of forRoot', ()=>{
-            const dynamicModule = IAMModule.forRootAsync({
-                includeController: true,
-                bootstrapAppConfig: {
-                    permissionMode: 'DIRECT'
-                }
-            });
-            expect(dynamicModule.controllers).toEqual([
-                ActionController,
-                MyPermissionController,
-                UserActionPermissionController
-            ]);
-        });
-        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
-            let FakeImportedModule = class FakeImportedModule {
-            };
-            const dynamicModule = IAMModule.forRootAsync({
-                imports: [
-                    FakeImportedModule
-                ]
-            });
-            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
-                FakeImportedModule
-            ]));
-        });
-        it('useFactory: registers a single options provider using the given inject tokens', async ()=>{
-            const useFactory = jest.fn().mockResolvedValue({
-                foo: 'bar'
-            });
-            const dynamicModule = IAMModule.forRootAsync({
-                useFactory,
-                inject: [
-                    'SOME_TOKEN'
-                ]
-            });
-            const optionsProviders = dynamicModule.providers.filter((p)=>p.provide === IAM_MODULE_OPTIONS);
-            expect(optionsProviders).toHaveLength(1);
-            const provider = optionsProviders[0];
-            expect(provider.useFactory).toBe(useFactory);
-            expect(provider.inject).toEqual([
-                'SOME_TOKEN'
-            ]);
-        });
-        it('useClass: registers both the class provider and an options provider that calls createIAMOptions()', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createIAMOptions", jest.fn().mockResolvedValue({
-                        foo: 'from-class'
-                    }));
-                }
-            };
-            const dynamicModule = IAMModule.forRootAsync({
-                useClass: MyOptionsFactory
-            });
-            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
-            expect(classProvider.useClass).toBe(MyOptionsFactory);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === IAM_MODULE_OPTIONS);
-            expect(optionsProvider.inject).toEqual([
-                MyOptionsFactory
-            ]);
-            const instance = new MyOptionsFactory();
-            const resolved = await optionsProvider.useFactory(instance);
-            expect(instance.createIAMOptions).toHaveBeenCalled();
-            expect(resolved).toEqual({
-                foo: 'from-class'
-            });
-        });
-        it('useExisting: registers a single options provider injecting the existing factory', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createIAMOptions", jest.fn().mockResolvedValue({
-                        foo: 'from-existing'
-                    }));
-                }
-            };
-            const dynamicModule = IAMModule.forRootAsync({
-                useExisting: MyOptionsFactory
-            });
-            const optionsProviders = dynamicModule.providers.filter((p)=>p.provide === IAM_MODULE_OPTIONS);
-            expect(optionsProviders).toHaveLength(1);
-            const provider = optionsProviders[0];
-            expect(provider.inject).toEqual([
-                MyOptionsFactory
-            ]);
-            const instance = new MyOptionsFactory();
-            const resolved = await provider.useFactory(instance);
-            expect(resolved).toEqual({
-                foo: 'from-existing'
-            });
-        });
-    });
-});