@iushev/rbac-web-manager 1.0.0

package/.prettierrc

@@ -0,0 +1,3 @@
+{
+  "printWidth": 120
+}

package/eslint.config.mjs

@@ -0,0 +1,57 @@
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import prettier from "eslint-plugin-prettier";
+import globals from "globals";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+});
+
+export default [
+  {
+    ignores: ["**/docs/", "**/lib/", "**/node_modules/"],
+  },
+  ...compat.extends("eslint:recommended", "plugin:@typescript-eslint/recommended", "plugin:prettier/recommended"),
+  {
+    plugins: {
+      "@typescript-eslint": typescriptEslint,
+      prettier,
+    },
+
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        module: false,
+      },
+
+      parser: tsParser,
+      ecmaVersion: 12,
+      sourceType: "module",
+    },
+
+    rules: {
+      "@typescript-eslint/no-namespace": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          args: "all",
+          argsIgnorePattern: "^_",
+          caughtErrors: "all",
+          caughtErrorsIgnorePattern: "^_",
+          destructuredArrayIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          ignoreRestSiblings: true,
+        },
+      ],
+    },
+  },
+];

package/jest.config.js

@@ -0,0 +1,188 @@
+// For a detailed explanation regarding each configuration property, visit:
+// https://jestjs.io/docs/en/configuration.html
+
+module.exports = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // Respect "browser" field in package.json when resolving modules
+  // browser: false,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/tmp/jest_rs",
+
+  // Automatically clear mock calls and instances between every test
+  // clearMocks: false,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  // collectCoverage: false,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  // coverageDirectory: undefined,
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "json",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names that allow to stub out resources with a single module
+  // moduleNameMapper: {
+  //   "^@iushev/rbac$": "<rootDir>/src",
+  // },
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  preset: "ts-jest",
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state between every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state between every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  rootDir: "./src",
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "./src",
+  //   "./tests"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  testEnvironment: "node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  testMatch: ["**/__tests__/**/?(*.)+(spec|test).[jt]s?(x)"],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jasmine2",
+
+  // This option sets the URL for the jsdom environment. It is reflected in properties such as location.href
+  // testURL: "http://localhost",
+
+  // Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"
+  // timers: "real",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};

package/lib/WebManager.d.ts

@@ -0,0 +1,48 @@
+import { AxiosRequestConfig } from "axios";
+import { Assignment, BaseManager, BaseManagerOptions, IItem, ItemType, Permission, Role, Rule } from "@iushev/rbac";
+export type WebManagerOptions = BaseManagerOptions & {
+    path: string;
+    authorization: () => string;
+};
+export default class WebManager extends BaseManager {
+    private readonly axiosInstance;
+    protected assignments: Map<string, Map<string, Assignment>>;
+    constructor(options: WebManagerOptions);
+    load(config?: AxiosRequestConfig): Promise<void>;
+    private getRbacItems;
+    private getRbacParents;
+    private getRbacRules;
+    private getRbacAssignments;
+    getRolesByUser(_username: string): Promise<Map<string, Role>>;
+    getChildRoles(_roleName: string): Promise<Map<string, Role>>;
+    getPermissionsByRole(_roleName: string): Promise<Map<string, Permission>>;
+    getPermissionsByUser(_username: string): Promise<Map<string, Permission>>;
+    getRule(_name: string): Promise<Rule | null>;
+    getRules(): Promise<Map<string, Rule>>;
+    canAddChild(_parent: IItem, _child: IItem): Promise<boolean>;
+    addChild(_parent: IItem, _child: IItem): Promise<boolean>;
+    removeChild(_parent: IItem, _child: IItem): Promise<boolean>;
+    removeChildren(_parent: IItem): Promise<boolean>;
+    hasChild(_parent: IItem, _child: IItem): Promise<boolean>;
+    getChildren(_name: string): Promise<Map<string, IItem>>;
+    assign(_role: Role | Permission, _username: string): Promise<Assignment>;
+    revoke(_role: Role | Permission, _username: string): Promise<boolean>;
+    revokeAll(_username: string): Promise<boolean>;
+    getAssignment(roleName: string, username: string): Promise<Assignment | null>;
+    getAssignments(username: string): Promise<Map<string, Assignment>>;
+    getUsernamesByRole(_roleName: string): Promise<string[]>;
+    removeAll(): Promise<void>;
+    removeAllPermissions(): Promise<void>;
+    removeAllRoles(): Promise<void>;
+    removeAllRules(): Promise<void>;
+    removeAllAssignments(): Promise<void>;
+    getItem(_name: string): Promise<IItem | null>;
+    getItems(_type: ItemType): Promise<Map<string, IItem>>;
+    addItem(_item: IItem): Promise<boolean>;
+    addRule(_rule: Rule): Promise<boolean>;
+    removeItem(_item: IItem): Promise<boolean>;
+    removeRule(_rule: Rule): Promise<boolean>;
+    updateItem(_name: string, _item: IItem): Promise<boolean>;
+    updateRule(_name: string, _rule: Rule): Promise<boolean>;
+}
+//# sourceMappingURL=WebManager.d.ts.map

package/lib/WebManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebManager.d.ts","sourceRoot":"","sources":["../src/WebManager.ts"],"names":[],"mappings":"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"}

package/lib/WebManager.js

@@ -0,0 +1,236 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const http_status_codes_1 = __importDefault(require("http-status-codes"));
+const rbac_1 = require("@iushev/rbac");
+class WebManager extends rbac_1.BaseManager {
+    constructor(options) {
+        const { path, authorization } = options, restOptions = __rest(options, ["path", "authorization"]);
+        super(restOptions);
+        this.assignments = new Map();
+        this.axiosInstance = axios_1.default.create({
+            baseURL: path,
+        });
+        this.axiosInstance.interceptors.request.use((config) => {
+            if (authorization) {
+                const token = authorization();
+                config.headers.Authorization = "Bearer " + token;
+            }
+            else {
+                config.headers.Authorization = undefined;
+            }
+            return config;
+        });
+    }
+    load(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let _rbac;
+            try {
+                console.log("Load RBAC");
+                const response = yield this.axiosInstance.get("/rbac", config);
+                _rbac = response.data;
+            }
+            catch (err) {
+                if (axios_1.default.isAxiosError(err) && ((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === http_status_codes_1.default.NOT_FOUND) {
+                    _rbac = {
+                        assignments: {},
+                        items: {},
+                        rules: {},
+                    };
+                }
+                else {
+                    throw err;
+                }
+            }
+            this.items = this.getRbacItems(_rbac);
+            this.parents = this.getRbacParents(_rbac);
+            this.rules = this.getRbacRules(_rbac);
+            this.assignments = this.getRbacAssignments(_rbac);
+        });
+    }
+    getRbacItems({ items }) {
+        return Object.keys(items).reduce((prevValue, name) => {
+            var _a, _b;
+            const item = items[name];
+            const ItemClass = item.type === rbac_1.ItemType.permission ? rbac_1.Permission : rbac_1.Role;
+            prevValue.set(name, new ItemClass({
+                name,
+                description: (_a = item.description) !== null && _a !== void 0 ? _a : null,
+                ruleName: (_b = item.ruleName) !== null && _b !== void 0 ? _b : null,
+            }));
+            return prevValue;
+        }, new Map());
+    }
+    getRbacParents({ items }) {
+        return Object.keys(items).reduce((prevValue, name) => {
+            const item = items[name];
+            if (!item.children || item.children.length === 0) {
+                return prevValue;
+            }
+            item.children.forEach((childName) => {
+                if (!this.items.has(childName)) {
+                    return;
+                }
+                let child = prevValue.get(childName);
+                if (!child) {
+                    child = new Map();
+                    prevValue.set(childName, child);
+                }
+                const item = this.items.get(name);
+                if (item) {
+                    child.set(name, item);
+                }
+            });
+            return prevValue;
+        }, new Map());
+    }
+    getRbacRules({ rules }) {
+        return Object.keys(rules).reduce((prevValue, name) => {
+            var _a;
+            const ruleData = rules[name];
+            const RuleClass = (_a = this.ruleClasses.get(ruleData.data.typeName)) !== null && _a !== void 0 ? _a : rbac_1.Rule;
+            const rule = new RuleClass(name, JSON.parse(ruleData.data.ruleData));
+            prevValue.set(name, rule);
+            return prevValue;
+        }, new Map());
+    }
+    getRbacAssignments({ assignments }) {
+        return Object.keys(assignments).reduce((prevValue, username) => {
+            const _assignments = assignments[username];
+            _assignments.forEach((itemName) => {
+                var _a;
+                if (prevValue.has(username)) {
+                    (_a = prevValue.get(username)) === null || _a === void 0 ? void 0 : _a.set(itemName, new rbac_1.Assignment(username, itemName));
+                }
+                else {
+                    prevValue.set(username, new Map([[itemName, new rbac_1.Assignment(username, itemName)]]));
+                }
+            });
+            return prevValue;
+        }, new Map());
+    }
+    getRolesByUser(_username) {
+        throw new Error("Method not implemented.");
+    }
+    getChildRoles(_roleName) {
+        throw new Error("Method not implemented.");
+    }
+    getPermissionsByRole(_roleName) {
+        throw new Error("Method not implemented.");
+    }
+    getPermissionsByUser(_username) {
+        throw new Error("Method not implemented.");
+    }
+    getRule(_name) {
+        throw new Error("Method not implemented.");
+    }
+    getRules() {
+        throw new Error("Method not implemented.");
+    }
+    canAddChild(_parent, _child) {
+        throw new Error("Method not implemented.");
+    }
+    addChild(_parent, _child) {
+        throw new Error("Method not implemented.");
+    }
+    removeChild(_parent, _child) {
+        throw new Error("Method not implemented.");
+    }
+    removeChildren(_parent) {
+        throw new Error("Method not implemented.");
+    }
+    hasChild(_parent, _child) {
+        throw new Error("Method not implemented.");
+    }
+    getChildren(_name) {
+        throw new Error("Method not implemented.");
+    }
+    assign(_role, _username) {
+        throw new Error("Method not implemented.");
+    }
+    revoke(_role, _username) {
+        throw new Error("Method not implemented.");
+    }
+    revokeAll(_username) {
+        throw new Error("Method not implemented.");
+    }
+    getAssignment(roleName, username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return (_b = (_a = this.assignments.get(username)) === null || _a === void 0 ? void 0 : _a.get(roleName)) !== null && _b !== void 0 ? _b : null;
+        });
+    }
+    getAssignments(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.assignments.get(username)) !== null && _a !== void 0 ? _a : new Map();
+        });
+    }
+    getUsernamesByRole(_roleName) {
+        throw new Error("Method not implemented.");
+    }
+    removeAll() {
+        throw new Error("Method not implemented.");
+    }
+    removeAllPermissions() {
+        throw new Error("Method not implemented.");
+    }
+    removeAllRoles() {
+        throw new Error("Method not implemented.");
+    }
+    removeAllRules() {
+        throw new Error("Method not implemented.");
+    }
+    removeAllAssignments() {
+        throw new Error("Method not implemented.");
+    }
+    getItem(_name) {
+        throw new Error("Method not implemented.");
+    }
+    getItems(_type) {
+        throw new Error("Method not implemented.");
+    }
+    addItem(_item) {
+        throw new Error("Method not implemented.");
+    }
+    addRule(_rule) {
+        throw new Error("Method not implemented.");
+    }
+    removeItem(_item) {
+        throw new Error("Method not implemented.");
+    }
+    removeRule(_rule) {
+        throw new Error("Method not implemented.");
+    }
+    updateItem(_name, _item) {
+        throw new Error("Method not implemented.");
+    }
+    updateRule(_name, _rule) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.default = WebManager;

package/lib/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/lib/index.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@iushev/rbac-web-manager",
+  "version": "1.0.0",
+  "private": false,
+  "author": "Ivaylo Ushev",
+  "description": "RBAC Web Manager",
+  "license": "ISC",
+  "keywords": [],
+  "main": "lib/index",
+  "types": "lib/index",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w --preserveWatchOutput",
+    "test": "jest --runInBand",
+    "test:watch": "jest --watch --runInBand",
+    "coverage": "jest --coverage --runInBand",
+    "lint": "eslint src",
+    "preversion": "rimraf ./lib && npm run build"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.4",
+    "@typescript-eslint/eslint-plugin": "^8.49.0",
+    "@typescript-eslint/parser": "^8.49.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^30.2.0",
+    "prettier": "^3.7.4",
+    "rimraf": "^6.1.2",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@iushev/rbac": "^1.0.53",
+    "axios": "^1.13.2",
+    "http-status-codes": "^2.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/WebManager.ts

@@ -0,0 +1,230 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
+import statusCodes from "http-status-codes";
+
+import {
+  Assignment,
+  BaseManager,
+  BaseManagerOptions,
+  IItem,
+  ItemType,
+  Permission,
+  RBACResponse,
+  Role,
+  Rule,
+} from "@iushev/rbac";
+
+export type WebManagerOptions = BaseManagerOptions & {
+  path: string;
+  authorization: () => string;
+};
+
+export default class WebManager extends BaseManager {
+  private readonly axiosInstance: AxiosInstance;
+
+  protected assignments: Map<string, Map<string, Assignment>> = new Map();
+
+  constructor(options: WebManagerOptions) {
+    const { path, authorization, ...restOptions } = options;
+    super(restOptions);
+
+    this.axiosInstance = axios.create({
+      baseURL: path,
+    });
+
+    this.axiosInstance.interceptors.request.use((config) => {
+      if (authorization) {
+        const token = authorization();
+        config.headers.Authorization = "Bearer " + token;
+      } else {
+        config.headers.Authorization = undefined;
+      }
+      return config;
+    });
+  }
+
+  async load(config?: AxiosRequestConfig): Promise<void> {
+    let _rbac: RBACResponse;
+    try {
+      console.log("Load RBAC");
+      const response = await this.axiosInstance.get<RBACResponse>("/rbac", config);
+      _rbac = response.data;
+    } catch (err) {
+      if (axios.isAxiosError(err) && err.response?.status === statusCodes.NOT_FOUND) {
+        _rbac = {
+          assignments: {},
+          items: {},
+          rules: {},
+        };
+      } else {
+        throw err;
+      }
+    }
+
+    this.items = this.getRbacItems(_rbac);
+    this.parents = this.getRbacParents(_rbac);
+    this.rules = this.getRbacRules(_rbac);
+    this.assignments = this.getRbacAssignments(_rbac);
+  }
+
+  private getRbacItems({ items }: RBACResponse) {
+    return Object.keys(items).reduce<Map<string, IItem>>((prevValue, name) => {
+      const item = items[name];
+      const ItemClass = item.type === ItemType.permission ? Permission : Role;
+      prevValue.set(
+        name,
+        new ItemClass({
+          name,
+          description: item.description ?? null,
+          ruleName: item.ruleName ?? null,
+        }),
+      );
+      return prevValue;
+    }, new Map());
+  }
+
+  private getRbacParents({ items }: RBACResponse) {
+    return Object.keys(items).reduce<Map<string, Map<string, IItem>>>((prevValue, name) => {
+      const item = items[name];
+      if (!item.children || item.children.length === 0) {
+        return prevValue;
+      }
+      item.children.forEach((childName: string) => {
+        if (!this.items.has(childName)) {
+          return;
+        }
+
+        let child = prevValue.get(childName);
+
+        if (!child) {
+          child = new Map();
+          prevValue.set(childName, child);
+        }
+
+        const item = this.items.get(name);
+        if (item) {
+          child.set(name, item);
+        }
+      });
+
+      return prevValue;
+    }, new Map());
+  }
+
+  private getRbacRules({ rules }: RBACResponse) {
+    return Object.keys(rules).reduce<Map<string, Rule>>((prevValue, name) => {
+      const ruleData = rules[name];
+      const RuleClass = this.ruleClasses.get(ruleData.data.typeName) ?? Rule;
+      const rule = new RuleClass(name, JSON.parse(ruleData.data.ruleData));
+      prevValue.set(name, rule);
+      return prevValue;
+    }, new Map());
+  }
+
+  private getRbacAssignments({ assignments }: RBACResponse) {
+    return Object.keys(assignments).reduce<Map<string, Map<string, Assignment>>>((prevValue, username) => {
+      const _assignments = assignments[username];
+      _assignments.forEach((itemName) => {
+        if (prevValue.has(username)) {
+          prevValue.get(username)?.set(itemName, new Assignment(username, itemName));
+        } else {
+          prevValue.set(username, new Map([[itemName, new Assignment(username, itemName)]]));
+        }
+      });
+      return prevValue;
+    }, new Map());
+  }
+
+  getRolesByUser(_username: string): Promise<Map<string, Role>> {
+    throw new Error("Method not implemented.");
+  }
+  getChildRoles(_roleName: string): Promise<Map<string, Role>> {
+    throw new Error("Method not implemented.");
+  }
+  getPermissionsByRole(_roleName: string): Promise<Map<string, Permission>> {
+    throw new Error("Method not implemented.");
+  }
+  getPermissionsByUser(_username: string): Promise<Map<string, Permission>> {
+    throw new Error("Method not implemented.");
+  }
+  getRule(_name: string): Promise<Rule | null> {
+    throw new Error("Method not implemented.");
+  }
+  getRules(): Promise<Map<string, Rule>> {
+    throw new Error("Method not implemented.");
+  }
+  canAddChild(_parent: IItem, _child: IItem): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  addChild(_parent: IItem, _child: IItem): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  removeChild(_parent: IItem, _child: IItem): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  removeChildren(_parent: IItem): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  hasChild(_parent: IItem, _child: IItem): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  getChildren(_name: string): Promise<Map<string, IItem>> {
+    throw new Error("Method not implemented.");
+  }
+  assign(_role: Role | Permission, _username: string): Promise<Assignment> {
+    throw new Error("Method not implemented.");
+  }
+  revoke(_role: Role | Permission, _username: string): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  revokeAll(_username: string): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  async getAssignment(roleName: string, username: string): Promise<Assignment | null> {
+    return this.assignments.get(username)?.get(roleName) ?? null;
+  }
+  async getAssignments(username: string): Promise<Map<string, Assignment>> {
+    return this.assignments.get(username) ?? new Map();
+  }
+  getUsernamesByRole(_roleName: string): Promise<string[]> {
+    throw new Error("Method not implemented.");
+  }
+  removeAll(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  removeAllPermissions(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  removeAllRoles(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  removeAllRules(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  removeAllAssignments(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  getItem(_name: string): Promise<IItem | null> {
+    throw new Error("Method not implemented.");
+  }
+  getItems(_type: ItemType): Promise<Map<string, IItem>> {
+    throw new Error("Method not implemented.");
+  }
+  addItem(_item: IItem): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  addRule(_rule: Rule): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  removeItem(_item: IItem): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  removeRule(_rule: Rule): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  updateItem(_name: string, _item: IItem): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  updateRule(_name: string, _rule: Rule): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+}

package/tsconfig.json

@@ -0,0 +1,103 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+    // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+
+    /* Modules */
+    "module": "commonjs" /* Specify what module code is generated. */,
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+    /* Emit */
+    "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+    "declarationMap": true /* Create sourcemaps for d.ts files. */,
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./lib" /* Specify an output folder for all emitted files. */,
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
+    // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src"],
+  "exclude": ["lib", "node_modules", "src/__tests__"]
+}