rl-core-api 0.1.0

package/dist/features/rbac/domain/rbac.service.js

@@ -0,0 +1,436 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RbacService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const action_repository_1 = require("../infra/repositories/action.repository");
+const group_repository_1 = require("../infra/repositories/group.repository");
+const permission_repository_1 = require("../infra/repositories/permission.repository");
+const resource_repository_1 = require("../infra/repositories/resource.repository");
+const role_repository_1 = require("../infra/repositories/role.repository");
+const scope_repository_1 = require("../infra/repositories/scope.repository");
+const user_repository_1 = require("../../users/infra/repositories/user.repository");
+let RbacService = class RbacService {
+    constructor(resourceRepo, actionRepo, scopeRepo, permissionRepo, roleRepo, groupRepo, userRepo) {
+        this.resourceRepo = resourceRepo;
+        this.actionRepo = actionRepo;
+        this.scopeRepo = scopeRepo;
+        this.permissionRepo = permissionRepo;
+        this.roleRepo = roleRepo;
+        this.groupRepo = groupRepo;
+        this.userRepo = userRepo;
+    }
+    async getUserPermissionCodes(userId) {
+        const user = await this.userRepo.findOne({
+            where: { id: userId },
+            relations: {
+                directPermissions: true,
+                roles: { permissions: true },
+                groups: { roles: { permissions: true } },
+            },
+        });
+        if (!user) {
+            return [];
+        }
+        const codes = new Set();
+        user.directPermissions?.forEach((p) => codes.add(p.code));
+        user.roles?.forEach((r) => r.permissions?.forEach((p) => codes.add(p.code)));
+        user.groups?.forEach((g) => g.roles?.forEach((r) => r.permissions?.forEach((p) => codes.add(p.code))));
+        return [...codes];
+    }
+    async getUserRoleNames(userId) {
+        const user = await this.userRepo.findOne({
+            where: { id: userId },
+            relations: { roles: true },
+        });
+        return user?.roles?.map((r) => r.name) ?? [];
+    }
+    listResources() {
+        return this.resourceRepo.find({ order: { name: "ASC" } });
+    }
+    async createResource(dto) {
+        const exists = await this.resourceRepo.findOne({
+            where: { name: dto.name },
+            withDeleted: true,
+        });
+        if (exists) {
+            throw new common_1.ConflictException("Já existe um resource com esse nome");
+        }
+        return this.resourceRepo.save(this.resourceRepo.create(dto));
+    }
+    async updateResource(id, dto) {
+        const resource = await this.resourceRepo.findOneBy({ id });
+        if (!resource) {
+            throw new common_1.NotFoundException("Resource não encontrado");
+        }
+        if (dto.name && dto.name !== resource.name) {
+            const taken = await this.resourceRepo.findOne({
+                where: { name: dto.name },
+                withDeleted: true,
+            });
+            if (taken) {
+                throw new common_1.ConflictException("Já existe um resource com esse nome");
+            }
+            resource.name = dto.name;
+        }
+        if (dto.description !== undefined) {
+            resource.description = dto.description;
+        }
+        if (dto.isActive !== undefined) {
+            resource.isActive = dto.isActive;
+        }
+        return this.resourceRepo.save(resource);
+    }
+    async deleteResource(id) {
+        const resource = await this.resourceRepo.findOneBy({ id });
+        if (!resource) {
+            throw new common_1.NotFoundException("Resource não encontrado");
+        }
+        await this.resourceRepo.softRemove(resource);
+    }
+    listActions() {
+        return this.actionRepo.find({ order: { name: "ASC" } });
+    }
+    async createAction(dto) {
+        const exists = await this.actionRepo.findOne({
+            where: { name: dto.name },
+            withDeleted: true,
+        });
+        if (exists) {
+            throw new common_1.ConflictException("Já existe uma action com esse nome");
+        }
+        return this.actionRepo.save(this.actionRepo.create(dto));
+    }
+    async updateAction(id, dto) {
+        const action = await this.actionRepo.findOneBy({ id });
+        if (!action) {
+            throw new common_1.NotFoundException("Action não encontrada");
+        }
+        if (dto.name && dto.name !== action.name) {
+            const taken = await this.actionRepo.findOne({
+                where: { name: dto.name },
+                withDeleted: true,
+            });
+            if (taken) {
+                throw new common_1.ConflictException("Já existe uma action com esse nome");
+            }
+            action.name = dto.name;
+        }
+        if (dto.description !== undefined) {
+            action.description = dto.description;
+        }
+        if (dto.isActive !== undefined) {
+            action.isActive = dto.isActive;
+        }
+        return this.actionRepo.save(action);
+    }
+    async deleteAction(id) {
+        const action = await this.actionRepo.findOneBy({ id });
+        if (!action) {
+            throw new common_1.NotFoundException("Action não encontrada");
+        }
+        await this.actionRepo.softRemove(action);
+    }
+    listScopes() {
+        return this.scopeRepo.find({ order: { name: "ASC" } });
+    }
+    async createScope(dto) {
+        const exists = await this.scopeRepo.findOne({
+            where: { name: dto.name },
+            withDeleted: true,
+        });
+        if (exists) {
+            throw new common_1.ConflictException("Já existe um scope com esse nome");
+        }
+        return this.scopeRepo.save(this.scopeRepo.create(dto));
+    }
+    async updateScope(id, dto) {
+        const scope = await this.scopeRepo.findOneBy({ id });
+        if (!scope) {
+            throw new common_1.NotFoundException("Scope não encontrado");
+        }
+        if (dto.name && dto.name !== scope.name) {
+            const taken = await this.scopeRepo.findOne({
+                where: { name: dto.name },
+                withDeleted: true,
+            });
+            if (taken) {
+                throw new common_1.ConflictException("Já existe um scope com esse nome");
+            }
+            scope.name = dto.name;
+        }
+        if (dto.description !== undefined) {
+            scope.description = dto.description;
+        }
+        if (dto.isActive !== undefined) {
+            scope.isActive = dto.isActive;
+        }
+        return this.scopeRepo.save(scope);
+    }
+    async deleteScope(id) {
+        const scope = await this.scopeRepo.findOneBy({ id });
+        if (!scope) {
+            throw new common_1.NotFoundException("Scope não encontrado");
+        }
+        await this.scopeRepo.softRemove(scope);
+    }
+    listPermissions() {
+        return this.permissionRepo.find({ order: { code: "ASC" } });
+    }
+    async createPermission(dto) {
+        const exists = await this.permissionRepo.findOne({
+            where: { code: dto.code },
+            withDeleted: true,
+        });
+        if (exists) {
+            throw new common_1.ConflictException("Já existe uma permissão com esse código");
+        }
+        const [resourceName, actionName, scopeName] = dto.code.split(":");
+        const [resource, action, scope] = await Promise.all([
+            this.resourceRepo.findOneBy({ name: resourceName }),
+            this.actionRepo.findOneBy({ name: actionName }),
+            this.scopeRepo.findOneBy({ name: scopeName }),
+        ]);
+        if (!resource || !action || !scope) {
+            throw new common_1.NotFoundException("resource, action ou scope do código não existe (cadastre-os antes)");
+        }
+        const permission = this.permissionRepo.create({
+            code: dto.code,
+            description: dto.description,
+            resourceId: resource.id,
+            actionId: action.id,
+            scopeId: scope.id,
+        });
+        return this.permissionRepo.save(permission);
+    }
+    async updatePermission(id, dto) {
+        const permission = await this.permissionRepo.findOneBy({ id });
+        if (!permission) {
+            throw new common_1.NotFoundException("Permissão não encontrada");
+        }
+        if (dto.code && dto.code !== permission.code) {
+            const taken = await this.permissionRepo.findOne({
+                where: { code: dto.code },
+                withDeleted: true,
+            });
+            if (taken) {
+                throw new common_1.ConflictException("Já existe uma permissão com esse código");
+            }
+            const [resourceName, actionName, scopeName] = dto.code.split(":");
+            const [resource, action, scope] = await Promise.all([
+                this.resourceRepo.findOneBy({ name: resourceName }),
+                this.actionRepo.findOneBy({ name: actionName }),
+                this.scopeRepo.findOneBy({ name: scopeName }),
+            ]);
+            if (!resource || !action || !scope) {
+                throw new common_1.NotFoundException("resource, action ou scope do código não existe");
+            }
+            permission.code = dto.code;
+            permission.resourceId = resource.id;
+            permission.actionId = action.id;
+            permission.scopeId = scope.id;
+        }
+        if (dto.description !== undefined) {
+            permission.description = dto.description;
+        }
+        if (dto.isActive !== undefined) {
+            permission.isActive = dto.isActive;
+        }
+        return this.permissionRepo.save(permission);
+    }
+    async deletePermission(id) {
+        const permission = await this.permissionRepo.findOneBy({ id });
+        if (!permission) {
+            throw new common_1.NotFoundException("Permissão não encontrada");
+        }
+        await this.permissionRepo.softRemove(permission);
+    }
+    listRoles() {
+        return this.roleRepo.find({
+            relations: { permissions: true },
+            order: { name: "ASC" },
+        });
+    }
+    async getRole(id) {
+        const role = await this.roleRepo.findOne({
+            where: { id },
+            relations: { permissions: true },
+        });
+        if (!role) {
+            throw new common_1.NotFoundException("Papel não encontrado");
+        }
+        return role;
+    }
+    async createRole(dto) {
+        const exists = await this.roleRepo.findOne({
+            where: { name: dto.name },
+            withDeleted: true,
+        });
+        if (exists) {
+            throw new common_1.ConflictException("Já existe um papel com esse nome");
+        }
+        const permissions = dto.permissionIds?.length
+            ? await this.permissionRepo.findBy({ id: (0, typeorm_1.In)(dto.permissionIds) })
+            : [];
+        const role = this.roleRepo.create({
+            name: dto.name,
+            description: dto.description,
+            permissions,
+        });
+        return this.roleRepo.save(role);
+    }
+    async updateRole(id, dto, actorPermissions) {
+        const role = await this.getRole(id);
+        if (dto.name !== undefined) {
+            role.name = dto.name;
+        }
+        if (dto.description !== undefined) {
+            role.description = dto.description;
+        }
+        if (dto.isActive !== undefined) {
+            role.isActive = dto.isActive;
+        }
+        if (dto.permissionIds) {
+            const permissions = await this.permissionRepo.findBy({
+                id: (0, typeorm_1.In)(dto.permissionIds),
+            });
+            this.assertGrantableByActor(permissions, actorPermissions);
+            role.permissions = permissions;
+        }
+        return this.roleRepo.save(role);
+    }
+    assertGrantableByActor(permissions, actorPermissions) {
+        const granted = new Set(actorPermissions ?? []);
+        const ungrantable = permissions.filter((p) => !granted.has(p.code));
+        if (ungrantable.length) {
+            throw new common_1.ForbiddenException(`Você não pode conceder permissões que não possui: ${ungrantable
+                .map((p) => p.code)
+                .join(", ")}`);
+        }
+    }
+    async deleteRole(id) {
+        const role = await this.getRole(id);
+        await this.roleRepo.softRemove(role);
+    }
+    async addPermissionToRole(roleId, permissionId, actorPermissions) {
+        const role = await this.getRole(roleId);
+        const permission = await this.permissionRepo.findOneBy({
+            id: permissionId,
+        });
+        if (!permission) {
+            throw new common_1.NotFoundException("Permissão não encontrada");
+        }
+        this.assertGrantableByActor([permission], actorPermissions);
+        if (!role.permissions.some((p) => p.id === permissionId)) {
+            role.permissions = [...role.permissions, permission];
+            await this.roleRepo.save(role);
+        }
+        return this.getRole(roleId);
+    }
+    async removePermissionFromRole(roleId, permissionId) {
+        const role = await this.getRole(roleId);
+        role.permissions = role.permissions.filter((p) => p.id !== permissionId);
+        await this.roleRepo.save(role);
+        return this.getRole(roleId);
+    }
+    listGroups() {
+        return this.groupRepo.find({
+            relations: { roles: true },
+            order: { name: "ASC" },
+        });
+    }
+    async getGroup(id) {
+        const group = await this.groupRepo.findOne({
+            where: { id },
+            relations: { roles: true },
+        });
+        if (!group) {
+            throw new common_1.NotFoundException("Grupo não encontrado");
+        }
+        return group;
+    }
+    async createGroup(dto) {
+        const roles = dto.roleIds?.length
+            ? await this.roleRepo.findBy({ id: (0, typeorm_1.In)(dto.roleIds) })
+            : [];
+        const group = this.groupRepo.create({
+            name: dto.name,
+            description: dto.description,
+            type: dto.type ?? "team",
+            parentId: dto.parentId ?? null,
+            roles,
+        });
+        return this.groupRepo.save(group);
+    }
+    async updateGroup(id, dto) {
+        const group = await this.getGroup(id);
+        if (dto.name !== undefined) {
+            group.name = dto.name;
+        }
+        if (dto.description !== undefined) {
+            group.description = dto.description;
+        }
+        if (dto.type !== undefined) {
+            group.type = dto.type;
+        }
+        if (dto.parentId !== undefined) {
+            group.parentId = dto.parentId;
+        }
+        if (dto.isActive !== undefined) {
+            group.isActive = dto.isActive;
+        }
+        if (dto.roleIds) {
+            group.roles = await this.roleRepo.findBy({ id: (0, typeorm_1.In)(dto.roleIds) });
+        }
+        return this.groupRepo.save(group);
+    }
+    async deleteGroup(id) {
+        const group = await this.getGroup(id);
+        await this.groupRepo.softRemove(group);
+    }
+    async addUserToGroup(groupId, userId) {
+        const group = await this.getGroup(groupId);
+        const user = await this.userRepo.findOne({
+            where: { id: userId },
+            relations: { groups: true },
+        });
+        if (!user) {
+            throw new common_1.NotFoundException("Usuário não encontrado");
+        }
+        if (!user.groups?.some((g) => g.id === group.id)) {
+            user.groups = [...(user.groups ?? []), group];
+            await this.userRepo.save(user);
+        }
+    }
+    async removeUserFromGroup(groupId, userId) {
+        const user = await this.userRepo.findOne({
+            where: { id: userId },
+            relations: { groups: true },
+        });
+        if (!user) {
+            throw new common_1.NotFoundException("Usuário não encontrado");
+        }
+        user.groups = (user.groups ?? []).filter((g) => g.id !== groupId);
+        await this.userRepo.save(user);
+    }
+};
+exports.RbacService = RbacService;
+exports.RbacService = RbacService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [resource_repository_1.ResourceRepository,
+        action_repository_1.ActionRepository,
+        scope_repository_1.ScopeRepository,
+        permission_repository_1.PermissionRepository,
+        role_repository_1.RoleRepository,
+        group_repository_1.GroupRepository,
+        user_repository_1.UserRepository])
+], RbacService);

package/dist/features/rbac/infra/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./repositories/action.repository";
+export * from "./repositories/group.repository";
+export * from "./repositories/permission.repository";
+export * from "./repositories/resource.repository";
+export * from "./repositories/role.repository";
+export * from "./repositories/scope.repository";
+export * from "./schema/action.schema";
+export * from "./schema/group.schema";
+export * from "./schema/permission.schema";
+export * from "./schema/resource.schema";
+export * from "./schema/role.schema";
+export * from "./schema/scope.schema";

package/dist/features/rbac/infra/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./repositories/action.repository"), exports);
+__exportStar(require("./repositories/group.repository"), exports);
+__exportStar(require("./repositories/permission.repository"), exports);
+__exportStar(require("./repositories/resource.repository"), exports);
+__exportStar(require("./repositories/role.repository"), exports);
+__exportStar(require("./repositories/scope.repository"), exports);
+__exportStar(require("./schema/action.schema"), exports);
+__exportStar(require("./schema/group.schema"), exports);
+__exportStar(require("./schema/permission.schema"), exports);
+__exportStar(require("./schema/resource.schema"), exports);
+__exportStar(require("./schema/role.schema"), exports);
+__exportStar(require("./schema/scope.schema"), exports);

package/dist/features/rbac/infra/repositories/action.repository.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, Repository } from "typeorm";
+import { Action } from "../schema/action.schema";
+export declare class ActionRepository extends Repository<Action> {
+    constructor(dataSource: DataSource);
+}

package/dist/features/rbac/infra/repositories/action.repository.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const action_schema_1 = require("../schema/action.schema");
+let ActionRepository = class ActionRepository extends typeorm_1.Repository {
+    constructor(dataSource) {
+        super(action_schema_1.Action, dataSource.createEntityManager());
+    }
+};
+exports.ActionRepository = ActionRepository;
+exports.ActionRepository = ActionRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], ActionRepository);

package/dist/features/rbac/infra/repositories/group.repository.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, Repository } from "typeorm";
+import { Group } from "../schema/group.schema";
+export declare class GroupRepository extends Repository<Group> {
+    constructor(dataSource: DataSource);
+}

package/dist/features/rbac/infra/repositories/group.repository.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const group_schema_1 = require("../schema/group.schema");
+let GroupRepository = class GroupRepository extends typeorm_1.Repository {
+    constructor(dataSource) {
+        super(group_schema_1.Group, dataSource.createEntityManager());
+    }
+};
+exports.GroupRepository = GroupRepository;
+exports.GroupRepository = GroupRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], GroupRepository);

package/dist/features/rbac/infra/repositories/permission.repository.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, Repository } from "typeorm";
+import { Permission } from "../schema/permission.schema";
+export declare class PermissionRepository extends Repository<Permission> {
+    constructor(dataSource: DataSource);
+}

package/dist/features/rbac/infra/repositories/permission.repository.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const permission_schema_1 = require("../schema/permission.schema");
+let PermissionRepository = class PermissionRepository extends typeorm_1.Repository {
+    constructor(dataSource) {
+        super(permission_schema_1.Permission, dataSource.createEntityManager());
+    }
+};
+exports.PermissionRepository = PermissionRepository;
+exports.PermissionRepository = PermissionRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], PermissionRepository);

package/dist/features/rbac/infra/repositories/resource.repository.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, Repository } from "typeorm";
+import { Resource } from "../schema/resource.schema";
+export declare class ResourceRepository extends Repository<Resource> {
+    constructor(dataSource: DataSource);
+}

package/dist/features/rbac/infra/repositories/resource.repository.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const resource_schema_1 = require("../schema/resource.schema");
+let ResourceRepository = class ResourceRepository extends typeorm_1.Repository {
+    constructor(dataSource) {
+        super(resource_schema_1.Resource, dataSource.createEntityManager());
+    }
+};
+exports.ResourceRepository = ResourceRepository;
+exports.ResourceRepository = ResourceRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], ResourceRepository);

package/dist/features/rbac/infra/repositories/role.repository.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, Repository } from "typeorm";
+import { Role } from "../schema/role.schema";
+export declare class RoleRepository extends Repository<Role> {
+    constructor(dataSource: DataSource);
+}

package/dist/features/rbac/infra/repositories/role.repository.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const role_schema_1 = require("../schema/role.schema");
+let RoleRepository = class RoleRepository extends typeorm_1.Repository {
+    constructor(dataSource) {
+        super(role_schema_1.Role, dataSource.createEntityManager());
+    }
+};
+exports.RoleRepository = RoleRepository;
+exports.RoleRepository = RoleRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], RoleRepository);

package/dist/features/rbac/infra/repositories/scope.repository.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, Repository } from "typeorm";
+import { Scope } from "../schema/scope.schema";
+export declare class ScopeRepository extends Repository<Scope> {
+    constructor(dataSource: DataSource);
+}