passbolt-browser-extension 5.12.1 → 5.13.0

package/src/all/background_page/model/entity/group/groupsCollection.test.js

@@ -1,227 +0,0 @@
-/**
- * Passbolt ~ Open source password manager for teams
- * Copyright (c) Passbolt SA (https://www.passbolt.com)
- *
- * Licensed under GNU Affero General Public License version 3 of the or any later version.
- * For full copyright and license information, please see the LICENSE.txt
- * Redistributions of files must retain the above copyright notice.
- *
- * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
- * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
- * @link          https://www.passbolt.com Passbolt(tm)
- * @since         3.0.4
- */
-import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
-import GroupsCollection from "./groupsCollection";
-import { defaultGroupDto } from "passbolt-styleguide/src/shared/models/entity/group/groupEntity.test.data";
-import { defaultGroupUser } from "passbolt-styleguide/src/shared/models/entity/groupUser/groupUserEntity.test.data.js";
-import GroupEntity from "./groupEntity";
-import { defaultGroupsDtos } from "./groupsCollection.test.data";
-
-describe("GroupsCollection", () => {
-  it("schema must validate", () => {
-    EntitySchema.validateSchema(GroupsCollection.ENTITY_NAME, GroupsCollection.getSchema());
-  });
-
-  describe("GroupsCollection::constructor", () => {
-    it("works with empty collection", () => {
-      new GroupsCollection([]);
-    });
-
-    it("works if valid minimal DTO is provided", () => {
-      const dto1 = defaultGroupDto({ name: "group1" });
-      const dto2 = defaultGroupDto({ name: "group2" });
-      const dto3 = defaultGroupDto({ name: "group3" });
-      const dtos = [dto1, dto2, dto3];
-      const collection = new GroupsCollection(dtos);
-
-      expect.assertions(10);
-      expect(collection.items).toHaveLength(3);
-      expect(collection.items[0]).toBeInstanceOf(GroupEntity);
-      expect(collection.items[0]._props.id).toEqual(dto1.id);
-      expect(collection.items[0]._props.name).toEqual(dto1.name);
-      expect(collection.items[1]).toBeInstanceOf(GroupEntity);
-      expect(collection.items[1]._props.id).toEqual(dto2.id);
-      expect(collection.items[1]._props.name).toEqual(dto2.name);
-      expect(collection.items[2]).toBeInstanceOf(GroupEntity);
-      expect(collection.items[2]._props.id).toEqual(dto3.id);
-      expect(collection.items[2]._props.name).toEqual(dto3.name);
-    });
-
-    it("works if valid group entities are provided", () => {
-      const entity1 = new GroupEntity(defaultGroupDto({ name: "group1" }));
-      const entity2 = new GroupEntity(defaultGroupDto({ name: "group2" }));
-      const entities = [entity1, entity2];
-      const collection = new GroupsCollection(entities);
-
-      expect.assertions(5);
-      expect(collection.items).toHaveLength(2);
-      expect(collection.items[0]).toBeInstanceOf(GroupEntity);
-      expect(collection.items[0]._props.name).toEqual(entity1.name);
-      expect(collection.items[1]).toBeInstanceOf(GroupEntity);
-      expect(collection.items[1]._props.name).toEqual(entity2.name);
-    });
-
-    it("works if valid maximum DTO is provided", () => {
-      const dto1 = defaultGroupDto({ name: "group1" }, { withGroupsUsers: true });
-      const dto2 = defaultGroupDto({ name: "group2" }, { withGroupsUsers: true });
-      const dto3 = defaultGroupDto({ name: "group3" }, { withGroupsUsers: true });
-      const dtos = [dto1, dto2, dto3];
-      const collection = new GroupsCollection(dtos);
-
-      expect.assertions(13);
-      expect(collection.items).toHaveLength(3);
-      expect(collection.items[0]._props.id).toEqual(dto1.id);
-      expect(collection.items[0]._props.name).toEqual(dto1.name);
-      expect(collection.items[0]._groups_users).toHaveLength(1);
-      expect(collection.items[0]._groups_users.items[0].id).toEqual(dto1.groups_users[0].id);
-      expect(collection.items[1]._props.id).toEqual(dto2.id);
-      expect(collection.items[1]._props.name).toEqual(dto2.name);
-      expect(collection.items[1]._groups_users).toHaveLength(1);
-      expect(collection.items[1]._groups_users.items[0].id).toEqual(dto2.groups_users[0].id);
-      expect(collection.items[2]._props.id).toEqual(dto3.id);
-      expect(collection.items[2]._props.name).toEqual(dto3.name);
-      expect(collection.items[2]._groups_users).toHaveLength(1);
-      expect(collection.items[2]._groups_users.items[0].id).toEqual(dto3.groups_users[0].id);
-    });
-
-    it("should throw if the collection schema does not validate", () => {
-      expect.assertions(1);
-      expect(() => new GroupsCollection({})).toThrowEntityValidationError("items");
-    });
-
-    it("should throw if one of data item does not validate the collection entity schema", () => {
-      const dto1 = defaultGroupDto();
-      const dto2 = defaultGroupDto({ name: 42 });
-
-      expect.assertions(1);
-      expect(() => new GroupsCollection([dto1, dto2])).toThrowCollectionValidationError("1.name.type");
-    });
-
-    /*
-     * @todo Associated entities validation error details to review when collection will aggregate them.
-     * @see EntityV2Collection.pushMany
-     */
-    it("should throw if one of item has an associated item that does not validate the collection associated entity schema", () => {
-      const dto1 = defaultGroupDto();
-      const dto2 = defaultGroupDto({
-        name: "group 2",
-        groups_users: [defaultGroupUser({ group_id: 42, is_admin: true })],
-      });
-
-      expect.assertions(2);
-      // Should not throw
-      expect(() => new GroupsCollection([dto1, dto2])).toThrowCollectionValidationError("1.0.group_id.type");
-      // Should throw
-      expect(() => new GroupsCollection([dto1, dto2])).not.toThrowCollectionValidationError(
-        "1.groups_users.0.group_id.type",
-      );
-    });
-
-    it("should throw if one of data item does not validate the unique id build rule", () => {
-      const dto1 = defaultGroupDto();
-      const dto2 = defaultGroupDto({ name: "group 1" });
-      const dto3 = defaultGroupDto({ id: dto2.id, name: "group 2" });
-
-      expect.assertions(1);
-      expect(() => new GroupsCollection([dto1, dto2, dto3])).toThrowCollectionValidationError("2.id.unique");
-    });
-
-    it("should throw if one of data item does not validate the unique name build rule", () => {
-      const dto1 = defaultGroupDto();
-      const dto2 = defaultGroupDto({ name: "group 1" });
-      const dto3 = defaultGroupDto({ name: "group 1" });
-
-      expect.assertions(1);
-      expect(() => new GroupsCollection([dto1, dto2, dto3])).toThrowCollectionValidationError("2.name.unique");
-    });
-
-    it("should, with enabling the ignore invalid option, ignore items which do not validate their schema", () => {
-      const dto1 = defaultGroupDto();
-      const dto2 = defaultGroupDto({ name: 42 });
-      const dto3 = defaultGroupDto({ name: "group 3" });
-
-      expect.assertions(3);
-      const collection = new GroupsCollection([dto1, dto2, dto3], { ignoreInvalidEntity: true });
-      expect(collection.items).toHaveLength(2);
-      expect(collection.items[0].id).toEqual(dto1.id);
-      expect(collection.items[1].id).toEqual(dto3.id);
-    });
-
-    it("should, with enabling the ignore invalid option, ignore items which do not validate the unique id build rule", () => {
-      const dto1 = defaultGroupDto();
-      const dto2 = defaultGroupDto({ id: dto1.id, name: "group 2" });
-      const dto3 = defaultGroupDto({ name: "group 3" });
-
-      expect.assertions(3);
-      const collection = new GroupsCollection([dto1, dto2, dto3], { ignoreInvalidEntity: true });
-      expect(collection.items).toHaveLength(2);
-      expect(collection.items[0].id).toEqual(dto1.id);
-      expect(collection.items[1].id).toEqual(dto3.id);
-    });
-
-    it("should, with enabling the ignore invalid option, ignore items which do not validate the unique name build rule", () => {
-      const dto1 = defaultGroupDto();
-      const dto2 = defaultGroupDto({ name: dto1.name });
-      const dto3 = defaultGroupDto({ name: "group 3" });
-
-      expect.assertions(3);
-      const collection = new GroupsCollection([dto1, dto2, dto3], { ignoreInvalidEntity: true });
-      expect(collection.items).toHaveLength(2);
-      expect(collection.items[0].id).toEqual(dto1.id);
-      expect(collection.items[1].id).toEqual(dto3.id);
-    });
-
-    it("should, with enabling the ignore invalid option, ignore items associated groups users entities which do not validate the group users same id build rule", () => {
-      const dto1 = defaultGroupDto({}, { withGroupsUsers: true });
-      const dto2 = defaultGroupDto({
-        name: "group 2",
-        groups_users: [defaultGroupUser({ group_id: 42, is_admin: true })],
-      });
-      const dto3 = defaultGroupDto({ name: "group 3" }, { withGroupsUsers: true });
-
-      expect.assertions(7);
-      const collection = new GroupsCollection([dto1, dto2, dto3], { ignoreInvalidEntity: true });
-      expect(collection.items).toHaveLength(3);
-      expect(collection.items[0].id).toEqual(dto1.id);
-      expect(collection.items[0]._groups_users).toHaveLength(1);
-      expect(collection.items[1].id).toEqual(dto2.id);
-      expect(collection.items[1]._groups_users).toHaveLength(0);
-      expect(collection.items[2].id).toEqual(dto3.id);
-      expect(collection.items[2]._groups_users).toHaveLength(1);
-    });
-  });
-
-  describe("GroupsCollection:pushMany", () => {
-    it("[performance] should ensure performance adding large dataset remains effective.", async () => {
-      const groupsCount = 10_000;
-      const groupsUsersPerGroupCount = 5;
-      const groupsDtos = defaultGroupsDtos(groupsCount, {
-        withModifier: true,
-        withCreator: true,
-        withMyGroupUser: true,
-        withGroupsUsers: groupsUsersPerGroupCount,
-      });
-
-      const start = performance.now();
-      const collection = new GroupsCollection(groupsDtos, { ignoreInvalidEntity: true });
-      const time = performance.now() - start;
-      expect(collection).toHaveLength(groupsCount);
-      expect(time).toBeLessThan(5_000);
-    });
-  });
-
-  describe("GroupsCollection:toDto", () => {
-    it("should transform the collection items in dto format", () => {
-      const dto1 = defaultGroupDto({ name: "group1" }, { withGroupsUsers: true });
-      const dto2p = defaultGroupDto({ name: "group2" }, { withGroupsUsers: true });
-      const dto3 = defaultGroupDto({ name: "group3" }, { withGroupsUsers: true });
-      const dtos = [dto1, dto2p, dto3];
-      const collection = new GroupsCollection(dtos);
-
-      expect.assertions(2);
-      expect(collection.toDto()).toEqual(dtos);
-      expect(JSON.stringify(collection)).toEqual(JSON.stringify(dtos));
-    });
-  });
-});

package/src/all/background_page/model/entity/permission/permissionEntity.js

@@ -1,485 +0,0 @@
-/**
- * Passbolt ~ Open source password manager for teams
- * Copyright (c) Passbolt SA (https://www.passbolt.com)
- *
- * Licensed under GNU Affero General Public License version 3 of the or any later version.
- * For full copyright and license information, please see the LICENSE.txt
- * Redistributions of files must retain the above copyright notice.
- *
- * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
- * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
- * @link          https://www.passbolt.com Passbolt(tm)
- * @since         2.13.0
- */
-import GroupEntity from "../group/groupEntity";
-import UserEntity from "../user/userEntity";
-import Validator from "validator";
-import EntityV2 from "passbolt-styleguide/src/shared/models/entity/abstract/entityV2";
-
-const ENTITY_NAME = "Permission";
-const PERMISSION_OWNER = 15;
-const PERMISSION_UPDATE = 7;
-const PERMISSION_READ = 1;
-const ARO_GROUP = "Group";
-const ARO_USER = "User";
-const ACO_RESOURCE = "Resource";
-const ACO_FOLDER = "Folder";
-
-class PermissionEntity extends EntityV2 {
-  /**
-   * @inheritDoc
-   */
-  constructor(dto, options = {}) {
-    super(dto, options);
-
-    // Associated models
-    if (this._props.user) {
-      this._user = new UserEntity(this._props.user, { ...options, clone: false });
-      delete this._props.user;
-    }
-    if (this._props.group) {
-      this._group = new GroupEntity(this._props.group, { ...options, clone: false });
-      delete this._props.group;
-    }
-  }
-
-  /**
-   * Get permission entity schema
-   *
-   * @returns {Object} schema
-   */
-  static getSchema() {
-    return {
-      type: "object",
-      required: ["aco", "aro", "aco_foreign_key", "aro_foreign_key", "type"],
-      properties: {
-        id: {
-          type: "string",
-          format: "uuid",
-        },
-        aco: {
-          type: "string",
-          enum: [PermissionEntity.ACO_FOLDER, PermissionEntity.ACO_RESOURCE],
-        },
-        aco_foreign_key: {
-          type: "string",
-          format: "uuid",
-        },
-        aro: {
-          type: "string",
-          enum: [PermissionEntity.ARO_GROUP, PermissionEntity.ARO_USER],
-        },
-        aro_foreign_key: {
-          type: "string",
-          format: "uuid",
-        },
-        type: {
-          type: "integer",
-          enum: PermissionEntity.PERMISSION_TYPES,
-        },
-        created: {
-          type: "string",
-          format: "date-time",
-        },
-        modified: {
-          type: "string",
-          format: "date-time",
-        },
-        // Associated models
-        user: UserEntity.getSchema(),
-        group: GroupEntity.getSchema(),
-      },
-    };
-  }
-
-  /*
-   * ==================================================
-   * Serialization
-   * ==================================================
-   */
-  /**
-   * Return a DTO ready to be sent to API
-   *
-   * @param {object} [contain] optional
-   * @returns {object}
-   */
-  toDto(contain) {
-    const result = Object.assign({}, this._props);
-    if (!contain) {
-      return result;
-    }
-    if (this._user && contain.user) {
-      if (contain.user === true) {
-        result.user = this._user.toDto();
-      } else {
-        result.user = this._user.toDto(contain.user);
-      }
-    }
-    if (this._group && contain.group) {
-      result.group = this._group.toDto();
-    }
-    return result;
-  }
-
-  /**
-   * Customizes JSON stringification behavior
-   * @returns {*}
-   */
-  toJSON() {
-    return this.toDto(PermissionEntity.ALL_CONTAIN_OPTIONS);
-  }
-
-  /*
-   * ==================================================
-   * Dynamic properties getters
-   * ==================================================
-   */
-  /**
-   * Get permission id
-   * @returns {(string|null)} uuid if set
-   */
-  get id() {
-    return this._props.id || null;
-  }
-
-  /**
-   * Get ACO - Access Control Object
-   * @returns {string} Folder or Resource
-   */
-  get aco() {
-    return this._props.aco;
-  }
-
-  /**
-   * Get ARO - Access Request Object
-   * @returns {string} Groups or User
-   */
-  get aro() {
-    return this._props.aro;
-  }
-
-  /**
-   * Get ARO id
-   * @returns {string} uuid
-   */
-  get aroForeignKey() {
-    return this._props.aro_foreign_key;
-  }
-
-  /**
-   * Get ACO id
-   * @returns {string} uuid
-   */
-  get acoForeignKey() {
-    return this._props.aco_foreign_key;
-  }
-
-  /**
-   * Get permission type
-   * @returns {int} 1: read, 5: update, 15: admin
-   */
-  get type() {
-    return this._props.type;
-  }
-
-  /**
-   * Return true if owner permission
-   * @returns {boolean}
-   */
-  isOwner() {
-    return this.type === PermissionEntity.PERMISSION_OWNER;
-  }
-
-  /*
-   * ==================================================
-   * Static properties getters
-   * ==================================================
-   */
-  /**
-   * PermissionEntity.ENTITY_NAME
-   * @returns {string}
-   */
-  static get ENTITY_NAME() {
-    return ENTITY_NAME;
-  }
-
-  /**
-   * PermissionEntity.PERMISSION_OWNER
-   * @returns {number}
-   */
-  static get PERMISSION_OWNER() {
-    return PERMISSION_OWNER;
-  }
-
-  /**
-   * PermissionEntity.PERMISSION_UPDATE
-   * @returns {number}
-   */
-  static get PERMISSION_UPDATE() {
-    return PERMISSION_UPDATE;
-  }
-
-  /**
-   * PermissionEntity.PERMISSION_READ
-   * @returns {number}
-   */
-  static get PERMISSION_READ() {
-    return PERMISSION_READ;
-  }
-
-  /**
-   * PermissionEntity.ARO_GROUP
-   * @returns {string}
-   */
-  static get ARO_GROUP() {
-    return ARO_GROUP;
-  }
-
-  /**
-   * PermissionEntity.ARO_USER
-   * @returns {string}
-   */
-  static get ARO_USER() {
-    return ARO_USER;
-  }
-
-  /**
-   * PermissionEntity.ACO_RESOURCE
-   * @returns {string}
-   */
-  static get ACO_RESOURCE() {
-    return ACO_RESOURCE;
-  }
-
-  /**
-   * PermissionEntity.ACO_FOLDER
-   * @returns {string}
-   */
-  static get ACO_FOLDER() {
-    return ACO_FOLDER;
-  }
-
-  /**
-   * PermissionEntity.ALL_CONTAIN_OPTIONS
-   * @returns {object} all contain options that can be used in toDto()
-   */
-  static get ALL_CONTAIN_OPTIONS() {
-    return { user: { profile: { avatar: true } }, group: true };
-  }
-
-  /**
-   * PermissionEntity.PERMISSION_TYPES
-   * @returns {number[]}
-   */
-  static get PERMISSION_TYPES() {
-    return [PermissionEntity.PERMISSION_READ, PermissionEntity.PERMISSION_UPDATE, PermissionEntity.PERMISSION_OWNER];
-  }
-
-  /*
-   * ==================================================
-   * Associated properties getters
-   * ==================================================
-   */
-  /**
-   * Get associated user data
-   * @returns {(UserEntity|null)} user
-   */
-  get user() {
-    return this._user || null;
-  }
-
-  /**
-   * Get associated group data
-   * @returns {(GroupEntity|null)} group
-   */
-  get group() {
-    return this._group || null;
-  }
-
-  /*
-   * ==================================================
-   * Dynamic properties setters
-   * ==================================================
-   */
-  /**
-   * Set the permission id
-   *
-   * @param {string} id
-   * @throws {TypeError} if permissions id is not UUID
-   */
-  set id(id) {
-    if (!Validator.isUUID(id)) {
-      throw new TypeError("The permission id should be a valid UUID.");
-    }
-    this._props.id = id;
-  }
-
-  /**
-   * Set the permission type
-   *
-   * @param {int} type
-   * @param type
-   */
-  set type(type) {
-    if (!type || !PermissionEntity.PERMISSION_TYPES.includes(type)) {
-      throw new TypeError("The type should be a valid integer.");
-    }
-    this._props.type = type;
-  }
-
-  /*
-   * ==================================================
-   * Assertions
-   * ==================================================
-   */
-  /**
-   * Basic type assertion helper
-   *
-   * @param {PermissionEntity} permission
-   */
-  static assertIsPermission(permission) {
-    if (!permission || !(permission instanceof PermissionEntity)) {
-      throw new TypeError("Failed to assert the parameter is a valid permission");
-    }
-  }
-
-  /**
-   * Basic type assertion helper
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   */
-  static assertArePermissions(p1, p2) {
-    PermissionEntity.assertIsPermission(p1);
-    PermissionEntity.assertIsPermission(p2);
-  }
-
-  /*
-   * ==================================================
-   * Permission comparison operators
-   * ==================================================
-   */
-  /**
-   * Return true if two given permission have the same id
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   * @returns {boolean} true if permission ids match
-   */
-  static isIdMatching(p1, p2) {
-    PermissionEntity.assertArePermissions(p1, p2);
-    return p1.id === p2.id;
-  }
-
-  /**
-   * Return true if two given permission are about the same user or group
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   * @returns {boolean} true if permissions match
-   */
-  static isAroMatching(p1, p2) {
-    PermissionEntity.assertArePermissions(p1, p2);
-    return p1.aro === p2.aro && p1.aroForeignKey === p2.aroForeignKey;
-  }
-
-  /**
-   * Return true if two given permission are about the same folder or resource
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   * @returns {boolean} true if permissions match
-   */
-  static isAcoMatching(p1, p2) {
-    PermissionEntity.assertArePermissions(p1, p2);
-    return p1.aco === p2.aco && p1.acoForeignKey === p2.acoForeignKey;
-  }
-
-  /**
-   * Return true if two given permission are about the same folder/resource and group/user
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   * @returns {boolean} true if permissions match
-   */
-  static isAcoAndAroMatching(p1, p2) {
-    PermissionEntity.assertArePermissions(p1, p2);
-    return PermissionEntity.isAcoMatching(p1, p2) && PermissionEntity.isAroMatching(p1, p2);
-  }
-
-  /**
-   * Return true if two given permission are the same type
-   * Example both permission are about an update right
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   * @returns {boolean} true if permissions match
-   */
-  static isTypeMatching(p1, p2) {
-    PermissionEntity.assertArePermissions(p1, p2);
-    return p1.type === p2.type;
-  }
-
-  /**
-   * Return true if two given permission aco, aro and type matches
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   * @returns {boolean} true if permissions match
-   */
-  static isMatchingAroAcoType(p1, p2) {
-    PermissionEntity.assertArePermissions(p1, p2);
-    return PermissionEntity.isAcoAndAroMatching(p1, p2) && PermissionEntity.isTypeMatching(p1, p2);
-  }
-
-  /**
-   * Return the highest permission type
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   * @returns {int} highest permission type
-   */
-  static getHighestPermissionType(p1, p2) {
-    PermissionEntity.assertArePermissions(p1, p2);
-    return p1.type > p2.type ? p1.type : p2.type;
-  }
-
-  /**
-   * Return true if two given permission are the same type
-   * Example both permission are about an update right
-   *
-   * @param {PermissionEntity} p1
-   * @param {PermissionEntity} p2
-   * @returns {PermissionEntity} the permission with highest type
-   */
-  static getHighestPermission(p1, p2) {
-    PermissionEntity.assertArePermissions(p1, p2);
-    return p1.type > p2.type ? p1 : p2;
-  }
-
-  /*
-   * ==================================================
-   * Permission factories
-   * ==================================================
-   */
-  /**
-   * Create a permission copy to be used by another aco
-   * Useful for example when you want to reuse a permission from a folder
-   * and apply it to a resource. For example on a move or a share operation.
-   *
-   * @param aco
-   * @param acoForeignKey
-   * @returns {PermissionEntity}
-   */
-  copyForAnotherAco(aco, acoForeignKey) {
-    return new PermissionEntity({
-      aro: this.aro,
-      aro_foreign_key: this.aroForeignKey,
-      aco: aco,
-      aco_foreign_key: acoForeignKey,
-      type: this.type,
-    });
-  }
-}
-
-export default PermissionEntity;