@flusys/nestjs-iam 0.1.0-beta.1 → 0.1.0-beta.2

package/cjs/services/role.service.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RoleService", {
+    enumerable: true,
+    get: function() {
+        return RoleService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _rolewithcompanyentity = require("../entities/role-with-company.entity");
+const _roleentity = require("../entities/role.entity");
+const _iamconfigservice = require("./iam-config.service");
+const _iamdatasourceprovider = require("./iam-datasource.provider");
+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;
+}
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let RoleService = class RoleService extends _classes.RequestScopedApiService {
+    /**
+   * Resolve entity class for this service
+   * @returns Role or RoleWithCompany based on configuration
+   */ resolveEntity() {
+        const enableCompanyFeature = this.iamConfigService.isCompanyFeatureEnabled();
+        return enableCompanyFeature ? _rolewithcompanyentity.RoleWithCompany : _roleentity.Role;
+    }
+    /**
+   * Get DataSource provider for this service
+   * @returns IAMDataSourceProvider instance
+   */ getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    // ==================== Entity Conversion ====================
+    async convertSingleDtoToEntity(dto, user) {
+        const enableCompanyFeature = this.iamConfigService.isCompanyFeatureEnabled();
+        let role = {};
+        let isUpdate = false;
+        if ('id' in dto && dto.id && typeof dto.id === 'string') {
+            const dbData = await this.repository.findOne({
+                where: {
+                    id: dto.id
+                }
+            });
+            if (!dbData) {
+                throw new _common.NotFoundException('Role not found');
+            }
+            role = dbData;
+            isUpdate = true;
+        }
+        // Merge DTO into role
+        role = {
+            ...role,
+            ...dto
+        };
+        // If company feature is enabled, handle companyId
+        if (enableCompanyFeature) {
+            if (isUpdate) {
+                // During update: Only set companyId if explicitly provided in DTO, otherwise keep existing
+                if (dto.companyId !== undefined) {
+                    role.companyId = dto.companyId;
+                }
+                // If companyId is not in role at all (shouldn't happen), set from user
+                if (!('companyId' in role) || role.companyId === undefined) {
+                    role.companyId = user?.companyId ?? null;
+                }
+            } else {
+                // During creation: Use DTO's companyId if provided, otherwise use user's companyId
+                role.companyId = dto.companyId ?? user?.companyId ?? null;
+            }
+        }
+        return role;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select || !select.length) {
+            select = [
+                'id',
+                'name',
+                'description',
+                'isActive',
+                'companyId',
+                'serial',
+                'createdAt'
+            ];
+        }
+        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
+        query.select(selectFields);
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getGlobalSearchQuery(query, search, _user) {
+        query.andWhere('(role.name LIKE :search OR role.description LIKE :search)', {
+            search: `%${search}%`
+        });
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    /**
+   * Override: Extra query manipulation - Auto-filter by user's company
+   */ async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        // If company feature enabled and user has companyId, filter by user's company
+        const enableCompanyFeature = this.iamConfigService.isCompanyFeatureEnabled();
+        if (enableCompanyFeature && user?.companyId) {
+            query.andWhere('role.companyId = :companyId', {
+                companyId: user.companyId
+            });
+        }
+        return result;
+    }
+    /**
+   * Override: Convert entity to response DTO
+   */ convertEntityToResponseDto(entity, _isRaw) {
+        return {
+            id: entity.id,
+            readOnly: entity.readOnly,
+            name: entity.name,
+            description: entity.description,
+            isActive: entity.isActive,
+            serial: entity.serial,
+            companyId: ('companyId' in entity ? entity.companyId : null) ?? null,
+            metadata: entity.metadata,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            deletedAt: entity.deletedAt,
+            createdById: entity.createdById,
+            updatedById: entity.updatedById,
+            deletedById: entity.deletedById
+        };
+    }
+    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    constructor(cacheManager, utilsService, iamConfigService, dataSourceProvider){
+        // Repository will be set asynchronously by RequestScopedApiService
+        super('role', null, cacheManager, utilsService, RoleService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "iamConfigService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "logger", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.iamConfigService = iamConfigService, this.dataSourceProvider = dataSourceProvider, this.logger = new _common.Logger(RoleService.name);
+    }
+};
+RoleService = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_iamconfigservice.IAMConfigService)),
+    _ts_param(3, (0, _common.Inject)(_iamdatasourceprovider.IAMDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _iamconfigservice.IAMConfigService === "undefined" ? Object : _iamconfigservice.IAMConfigService,
+        typeof _iamdatasourceprovider.IAMDataSourceProvider === "undefined" ? Object : _iamdatasourceprovider.IAMDataSourceProvider
+    ])
+], RoleService);

package/cjs/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./logic-node.type"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/cjs/types/logic-node.type.js

@@ -0,0 +1,54 @@
+/**
+ * LogicNode - Represents a node in a permission logic tree
+ *
+ * Used for complex permission evaluation with AND/OR logic.
+ * Supports hierarchical permission structures.
+ *
+ * Example:
+ * ```typescript
+ * const logic: LogicNode = {
+ *   id: 'root',
+ *   type: 'group',
+ *   operator: 'AND',
+ *   children: [
+ *     { id: '1', type: 'action', actionId: 'create-user' },
+ *     {
+ *       id: '2',
+ *       type: 'group',
+ *       operator: 'OR',
+ *       children: [
+ *         { id: '2-1', type: 'action', actionId: 'view-reports' },
+ *         { id: '2-2', type: 'action', actionId: 'view-dashboard' }
+ *       ]
+ *     }
+ *   ]
+ * };
+ * ```
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get LogicNodeType () {
+        return LogicNodeType;
+    },
+    get LogicOperator () {
+        return LogicOperator;
+    }
+});
+var LogicOperator = /*#__PURE__*/ function(LogicOperator) {
+    LogicOperator["AND"] = "AND";
+    LogicOperator["OR"] = "OR";
+    return LogicOperator;
+}({});
+var LogicNodeType = /*#__PURE__*/ function(LogicNodeType) {
+    LogicNodeType["GROUP"] = "group";
+    LogicNodeType["ACTION"] = "action";
+    return LogicNodeType;
+}({});

package/fesm/config/iam.constants.js

@@ -0,0 +1 @@
+export const IAM_MODULE_OPTIONS = 'IAM_MODULE_OPTIONS';

package/fesm/config/index.js

@@ -0,0 +1 @@
+export * from './iam.constants';

package/fesm/controllers/action.controller.js

@@ -0,0 +1,107 @@
+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;
+}
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
+import { createApiController, CurrentUser, ILoggedUserInfo, SingleResponseDto } from '@flusys/nestjs-shared';
+import { Body, Controller, Get, Inject, Post, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { ActionResponseDto, ActionTreeQueryDto, CreateActionDto, UpdateActionDto } from '../dtos/action.dto';
+import { ActionService } from '../services/action.service';
+export class ActionController extends createApiController(CreateActionDto, UpdateActionDto, ActionResponseDto) {
+    async getActionsForPermission(user) {
+        const actions = await this.actionService.getActionsForPermission(user);
+        return {
+            success: true,
+            message: 'Actions retrieved successfully',
+            data: actions
+        };
+    }
+    async getActionTree(query, user) {
+        const tree = await this.actionService.getActionTree(user, query.search, query.isActive, query.withDeleted);
+        return {
+            success: true,
+            message: 'Action tree retrieved successfully',
+            data: tree
+        };
+    }
+    constructor(actionService){
+        super(actionService), _define_property(this, "actionService", void 0), this.actionService = actionService;
+    }
+}
+_ts_decorate([
+    Get('tree-for-permission'),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    ApiOperation({
+        summary: 'Get actions for permission assignment',
+        description: 'Returns actions available for permission assignment. If company feature enabled, filtered by company whitelist.'
+    }),
+    ApiResponse({
+        status: 200,
+        type: SingleResponseDto
+    }),
+    _ts_param(0, CurrentUser()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ActionController.prototype, "getActionsForPermission", null);
+_ts_decorate([
+    Post('tree'),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    ApiOperation({
+        summary: 'Get actions in hierarchical tree structure',
+        description: 'Returns all actions organized in a parent-child tree structure. Supports optional search and filtering.'
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'Actions tree retrieved successfully',
+        type: SingleResponseDto
+    }),
+    ApiBody({
+        type: ActionTreeQueryDto
+    }),
+    _ts_param(0, Body()),
+    _ts_param(1, CurrentUser()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ActionTreeQueryDto === "undefined" ? Object : ActionTreeQueryDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ActionController.prototype, "getActionTree", null);
+ActionController = _ts_decorate([
+    ApiTags('IAM - Actions'),
+    Controller('iam/actions'),
+    _ts_param(0, Inject(ActionService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ActionService === "undefined" ? Object : ActionService
+    ])
+], ActionController);

package/fesm/controllers/company-action-permission.controller.js

@@ -0,0 +1,100 @@
+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;
+}
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { JwtAuthGuard, SingleResponseDto } from '@flusys/nestjs-shared';
+import { Body, Controller, Get, Inject, Param, Post, Query, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { AssignCompanyActionsDto, GetCompanyActionsDto, PermissionOperationResultDto } from '../dtos/permission.dto';
+import { PermissionService } from '../services/permission.service';
+export class CompanyActionPermissionController {
+    async assignCompanyActions(dto) {
+        return this.permissionService.assignCompanyActions(dto);
+    }
+    async getCompanyActions(companyId, query) {
+        const actions = await this.permissionService.getCompanyActions(companyId);
+        return {
+            success: true,
+            message: 'Company actions retrieved successfully',
+            data: actions
+        };
+    }
+    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    constructor(permissionService){
+        _define_property(this, "permissionService", void 0);
+        this.permissionService = permissionService;
+    }
+}
+_ts_decorate([
+    Post('company-actions/assign'),
+    ApiOperation({
+        summary: 'Whitelist actions for company',
+        description: 'Controls which actions are available to company users/roles.'
+    }),
+    ApiResponse({
+        status: 200,
+        type: PermissionOperationResultDto
+    }),
+    ApiBody({
+        type: AssignCompanyActionsDto
+    }),
+    _ts_param(0, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof AssignCompanyActionsDto === "undefined" ? Object : AssignCompanyActionsDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], CompanyActionPermissionController.prototype, "assignCompanyActions", null);
+_ts_decorate([
+    Get('company-actions/:companyId'),
+    ApiOperation({
+        summary: 'Get company whitelisted actions',
+        description: 'Returns actions available to company.'
+    }),
+    ApiResponse({
+        status: 200,
+        type: SingleResponseDto
+    }),
+    _ts_param(0, Param('companyId')),
+    _ts_param(1, Query()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        typeof GetCompanyActionsDto === "undefined" ? Object : GetCompanyActionsDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], CompanyActionPermissionController.prototype, "getCompanyActions", null);
+CompanyActionPermissionController = _ts_decorate([
+    ApiTags('IAM - Company Action Permissions'),
+    Controller('iam/permissions'),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    _ts_param(0, Inject(PermissionService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof PermissionService === "undefined" ? Object : PermissionService
+    ])
+], CompanyActionPermissionController);

package/fesm/controllers/index.js

@@ -0,0 +1,7 @@
+export * from './action.controller';
+export * from './role.controller';
+// Legacy permission controllers (deprecated - use PermissionController instead)
+export * from './company-action-permission.controller';
+export * from './my-permission.controller';
+export * from './role-permission.controller';
+export * from './user-action-permission.controller';

package/fesm/controllers/my-permission.controller.js

@@ -0,0 +1,80 @@
+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;
+}
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { CurrentUser, ILoggedUserInfo } from '@flusys/nestjs-shared';
+import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
+import { Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { MyPermissionsQueryDto, MyPermissionsResponseDto } from '../dtos/permission.dto';
+import { PermissionService } from '../services/permission.service';
+export class MyPermissionController {
+    async getMyPermissions(query, user) {
+        return this.permissionService.getMyPermissions(user.id, user.branchId ?? null, user.companyId ?? null, query.parentCodes);
+    }
+    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    constructor(permissionService){
+        _define_property(this, "permissionService", void 0);
+        this.permissionService = permissionService;
+    }
+}
+_ts_decorate([
+    Post('my-permissions'),
+    ApiOperation({
+        summary: 'Get current user permissions',
+        description: 'Returns complete permissions for authenticated user. Includes menus, frontend actions, and caches endpoint permissions. Optionally filter by parent codes.'
+    }),
+    ApiResponse({
+        status: 200,
+        type: MyPermissionsResponseDto
+    }),
+    ApiResponse({
+        status: 401,
+        description: 'Unauthorized'
+    }),
+    ApiBody({
+        type: MyPermissionsQueryDto
+    }),
+    _ts_param(0, Body()),
+    _ts_param(1, CurrentUser()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof MyPermissionsQueryDto === "undefined" ? Object : MyPermissionsQueryDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], MyPermissionController.prototype, "getMyPermissions", null);
+MyPermissionController = _ts_decorate([
+    ApiTags('IAM - My Permissions'),
+    Controller('iam/permissions'),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    _ts_param(0, Inject(PermissionService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof PermissionService === "undefined" ? Object : PermissionService
+    ])
+], MyPermissionController);