@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

package/components/permissions/permissions.d.ts

@@ -0,0 +1,111 @@
+import Auth from '../auth/auth__core';
+import PermissionCache, { Permission } from './permissions__cache';
+export interface PermissionsConfig {
+    prefix?: string | null | undefined;
+    namesConverter?: ((name: string) => string) | null | undefined;
+    services?: readonly string[] | null | undefined;
+    datasource?: ((query: string | undefined) => Promise<readonly Permission[] | null | undefined>) | null | undefined;
+}
+interface PermissionsCacheControl {
+    NO_CACHE?: boolean | null | undefined;
+    NO_STORE?: boolean | null | undefined;
+}
+export interface PermissionsLoadOptions {
+    cacheControl?: PermissionsCacheControl | null | undefined;
+}
+/**
+ * <code>
+ *   const permissions = new Permissions(auth, {prefix: 'jetbrains.jetpass.', services: [auth.serviceId]})
+ *   permissions.load().then(function (p) {
+ *     const canReadUser = p.has('read-user');
+ *     ...
+ *   });
+ *
+ *   permissions.check('read-user').then(function(canReadUser) {
+ *     ...
+ *   });
+ * </code>
+ *
+ * @param {Auth} auth instance of well configured Auth object
+ * @param {{
+ *   prefix: string?,
+ *   namesConverter: function?
+ *   serviceId: string?
+ * }=} config permissions loaded configuration.
+ * <code>prefix</code> if provided then this prefix is removed from the permissions names.
+ * <code>namesConverter</code> if provided it maps permission names used on server-side to client-side permission names. It is used only if prefix is undefined.
+ * <code>serviceId</code> if provided then permissions only for the service are loaded.
+ * @constructor
+ */
+export default class Permissions {
+    /**
+     * @const {string}
+     */
+    static API_PERMISSION_CACHE_PATH: string;
+    query: string | undefined;
+    namesConverter: ((name: string) => string) | null | undefined;
+    private _auth;
+    private _datasource;
+    _promise: Promise<PermissionCache> | null;
+    private _subscribed;
+    private _permissionCache;
+    constructor(auth: Auth, config?: PermissionsConfig);
+    private _defaultDatasource;
+    /**
+     * Returns function, which cuts off prefix from server-side permission name
+     *
+     * @param {string} prefix
+     * @returns {Function}
+     */
+    static getDefaultNamesConverter(prefix: string): (storedName: string) => string;
+    static getPermissionQuery(services?: readonly string[] | null | undefined): string | undefined;
+    set(cachedPermissions?: readonly Permission[] | null | undefined): PermissionCache;
+    get(): readonly Permission[] | null | undefined;
+    private _setCache;
+    private _getCache;
+    private _resetCache;
+    /**
+     * Loads logged-in user permissions.
+     * @param {object?} options
+     * @return {Promise.<Permissions>} promise that is resolved when the permissions are loaded
+     */
+    load(options?: PermissionsLoadOptions | null | undefined): Promise<PermissionCache>;
+    _loadPermissions(): Promise<readonly Permission[] | null | undefined>;
+    /**
+     * Reloads permission cache from server
+     * @returns {Promise.<Permissions>} promise that is resolved when the permissions are reloaded
+     */
+    reload(): Promise<PermissionCache>;
+    /**
+     * Waits till the permission cache is loaded then checks if the current user has the
+     * given permissions in the project with the given id.
+     *
+     * @param {string} permissions  space separated list of permissions
+     * @param {string=} projectId     optional projectId. If absent the method checks
+     *  if the given permission is granted in any project.
+     *
+     * @return {Promise.<boolean>}
+     */
+    check(permissions?: string | null | undefined, projectId?: string | null | undefined): Promise<boolean>;
+    /**
+     * Binds a property with the name <code>propertyName</code> of the <code>object</code>
+     * to a boolean value that is true if user has the permissions and false if she doesn't.
+     *
+     * @example
+     * <code>
+     *   userPermissions.bindVariable($scope, 'canReadRole', 'role-read')
+     * </code>
+     *
+     * @param {object} object       an object which property should be bound
+     * @param {string} propertyName a name of a property to bind
+     * @param {string} permissions  space separated list of permissions
+     * @param {string=} projectId     optional projectId. If absent the method checks
+     *  if the given permissions are granted in any project.
+     *
+     * @return {Promise.<boolean>}
+     */
+    bindVariable<K extends string>(object: {
+        [key in K]?: boolean;
+    }, propertyName: K, permissions?: string | null | undefined, projectId?: string | null | undefined): Promise<boolean>;
+}
+export {};

package/components/permissions/permissions.js

@@ -1,5 +1,4 @@
 import PermissionCache from './permissions__cache';
-
 /**
  * <code>
  *   const permissions = new Permissions(auth, {prefix: 'jetbrains.jetpass.', services: [auth.serviceId]})
@@ -25,169 +24,154 @@ import PermissionCache from './permissions__cache';
  * @constructor
  */
 export default class Permissions {
-  /**
-   * @const {string}
-   */
-  static API_PERMISSION_CACHE_PATH = 'permissions/cache';
-
-  constructor(auth, config = {}) {
-    this.query = Permissions.getPermissionQuery(config.services);
-    this.namesConverter = config.prefix
-      ? Permissions.getDefaultNamesConverter(config.prefix)
-      : config.namesConverter;
-
-    if (!auth) {
-      throw new Error('Parameter auth is required');
+    /**
+     * @const {string}
+     */
+    static API_PERMISSION_CACHE_PATH = 'permissions/cache';
+    query;
+    namesConverter;
+    _auth;
+    _datasource;
+    _promise;
+    _subscribed;
+    _permissionCache;
+    constructor(auth, config = {}) {
+        this.query = Permissions.getPermissionQuery(config.services);
+        this.namesConverter = config.prefix
+            ? Permissions.getDefaultNamesConverter(config.prefix)
+            : config.namesConverter;
+        if (!auth) {
+            throw new Error('Parameter auth is required');
+        }
+        this._auth = auth;
+        this._datasource = config.datasource || this._defaultDatasource;
+        this._promise = null;
+        this._subscribed = false;
+        this._permissionCache = new PermissionCache(null, this.namesConverter);
     }
-
-    this._auth = auth;
-    this._datasource = config.datasource || this._defaultDatasource;
-    this._promise = null;
-    this._subscribed = false;
-    this._permissionCache = new PermissionCache(null, this.namesConverter);
-  }
-
-  _defaultDatasource = query => (
-    this._auth.http.get(Permissions.API_PERMISSION_CACHE_PATH, {
-      query: {
-        fields: 'permission/key,global,projects(id)',
-        query
-      }
-    })
-  );
-
-  /**
-   * Returns function, which cuts off prefix from server-side permission name
-   *
-   * @param {string} prefix
-   * @returns {Function}
-   */
-  static getDefaultNamesConverter(prefix) {
-    return storedName => {
-      if (storedName.indexOf(prefix) !== 0) {
-        return storedName;
-      } else {
-        return storedName.substr(prefix.length);
-      }
-    };
-  }
-
-  static getPermissionQuery(services) {
-    if (!services || !services.length) {
-      return undefined;
+    _defaultDatasource = (query) => (this._auth.http.get(Permissions.API_PERMISSION_CACHE_PATH, {
+        query: {
+            fields: 'permission/key,global,projects(id)',
+            query
+        }
+    }));
+    /**
+     * Returns function, which cuts off prefix from server-side permission name
+     *
+     * @param {string} prefix
+     * @returns {Function}
+     */
+    static getDefaultNamesConverter(prefix) {
+        return (storedName) => {
+            if (storedName.indexOf(prefix) !== 0) {
+                return storedName;
+            }
+            else {
+                return storedName.substr(prefix.length);
+            }
+        };
     }
-    return services.map(service => `service:{${service}}`).join(' or ');
-  }
-
-  set(cachedPermissions) {
-    this._permissionCache.set(cachedPermissions);
-    this._setCache(Promise.resolve(this._permissionCache));
-    return this._permissionCache;
-  }
-
-  get() {
-    return this._permissionCache.get();
-  }
-
-  _setCache(value) {
-    this._promise = value;
-    return value;
-  }
-
-  _getCache() {
-    return this._promise;
-  }
-
-  _resetCache() {
-    this._setCache(null);
-  }
-
-  /**
-   * Loads logged-in user permissions.
-   * @param {object?} options
-   * @return {Promise.<Permissions>} promise that is resolved when the permissions are loaded
-   */
-  load(options) {
-    if (this._subscribed === false) {
-      this._auth.addListener('userChange', () => {
-        this.reload();
-      });
-      this._subscribed = true;
+    static getPermissionQuery(services) {
+        if (!services || !services.length) {
+            return undefined;
+        }
+        return services.map(service => `service:{${service}}`).join(' or ');
     }
-
-    if (!hasCacheControl('NO_CACHE', options) && this._getCache()) {
-      return this._getCache();
+    set(cachedPermissions) {
+        this._permissionCache.set(cachedPermissions);
+        this._setCache(Promise.resolve(this._permissionCache));
+        return this._permissionCache;
     }
-
-    if (hasCacheControl('NO_STORE', options)) {
-      return this._loadPermissions().
-        then(cachedPermissions => new PermissionCache(cachedPermissions, this.namesConverter));
+    get() {
+        return this._permissionCache.get();
     }
-
-    return this._setCache(
-      this._loadPermissions().
-        then(cachedPermissions => this.set(cachedPermissions))
-    );
-
-    function hasCacheControl(value, _options) {
-      if (_options && _options.cacheControl) {
-        return _options.cacheControl[value];
-      }
-      return false;
+    _setCache(value) {
+        this._promise = value;
+    }
+    _getCache() {
+        return this._promise;
+    }
+    _resetCache() {
+        this._setCache(null);
+    }
+    /**
+     * Loads logged-in user permissions.
+     * @param {object?} options
+     * @return {Promise.<Permissions>} promise that is resolved when the permissions are loaded
+     */
+    load(options) {
+        if (this._subscribed === false) {
+            this._auth.addListener('userChange', () => {
+                this.reload();
+            });
+            this._subscribed = true;
+        }
+        const cache = this._getCache();
+        if (!hasCacheControl('NO_CACHE', options) && cache) {
+            return cache;
+        }
+        if (hasCacheControl('NO_STORE', options)) {
+            return this._loadPermissions().
+                then(cachedPermissions => new PermissionCache(cachedPermissions, this.namesConverter));
+        }
+        const permissions = this._loadPermissions().
+            then(cachedPermissions => this.set(cachedPermissions));
+        this._setCache(permissions);
+        return permissions;
+        function hasCacheControl(value, _options) {
+            if (_options && _options.cacheControl) {
+                return _options.cacheControl[value];
+            }
+            return false;
+        }
+    }
+    _loadPermissions() {
+        return this._datasource(this.query);
+    }
+    /**
+     * Reloads permission cache from server
+     * @returns {Promise.<Permissions>} promise that is resolved when the permissions are reloaded
+     */
+    reload() {
+        this._resetCache();
+        return this.load();
+    }
+    /**
+     * Waits till the permission cache is loaded then checks if the current user has the
+     * given permissions in the project with the given id.
+     *
+     * @param {string} permissions  space separated list of permissions
+     * @param {string=} projectId     optional projectId. If absent the method checks
+     *  if the given permission is granted in any project.
+     *
+     * @return {Promise.<boolean>}
+     */
+    check(permissions, projectId) {
+        return this.load().then(permissionCache => permissionCache.has(permissions, projectId));
+    }
+    /**
+     * Binds a property with the name <code>propertyName</code> of the <code>object</code>
+     * to a boolean value that is true if user has the permissions and false if she doesn't.
+     *
+     * @example
+     * <code>
+     *   userPermissions.bindVariable($scope, 'canReadRole', 'role-read')
+     * </code>
+     *
+     * @param {object} object       an object which property should be bound
+     * @param {string} propertyName a name of a property to bind
+     * @param {string} permissions  space separated list of permissions
+     * @param {string=} projectId     optional projectId. If absent the method checks
+     *  if the given permissions are granted in any project.
+     *
+     * @return {Promise.<boolean>}
+     */
+    bindVariable(object, propertyName, permissions, projectId) {
+        object[propertyName] = false;
+        return this.check(permissions, projectId).
+            then(permitted => {
+            object[propertyName] = permitted;
+            return permitted;
+        });
     }
-  }
-
-  _loadPermissions() {
-    return this._datasource(this.query);
-  }
-
-  /**
-   * Reloads permission cache from server
-   * @returns {Promise.<Permissions>} promise that is resolved when the permissions are reloaded
-   */
-  reload() {
-    this._resetCache();
-    return this.load();
-  }
-
-  /**
-   * Waits till the permission cache is loaded then checks if the current user has the
-   * given permissions in the project with the given id.
-   *
-   * @param {string} permissions  space separated list of permissions
-   * @param {string=} projectId     optional projectId. If absent the method checks
-   *  if the given permission is granted in any project.
-   *
-   * @return {Promise.<boolean>}
-   */
-  check(permissions, projectId) {
-    return this.load().then(permissionCache => permissionCache.has(permissions, projectId));
-  }
-
-  /**
-   * Binds a property with the name <code>propertyName</code> of the <code>object</code>
-   * to a boolean value that is true if user has the permissions and false if she doesn't.
-   *
-   * @example
-   * <code>
-   *   userPermissions.bindVariable($scope, 'canReadRole', 'role-read')
-   * </code>
-   *
-   * @param {object} object       an object which property should be bound
-   * @param {string} propertyName a name of a property to bind
-   * @param {string} permissions  space separated list of permissions
-   * @param {string=} projectId     optional projectId. If absent the method checks
-   *  if the given permissions are granted in any project.
-   *
-   * @return {Promise.<boolean>}
-   */
-  bindVariable(object, propertyName, permissions, projectId) {
-    object[propertyName] = false;
-
-    return this.check(permissions, projectId).
-      then(permitted => {
-        object[propertyName] = permitted;
-        return permitted;
-      });
-  }
 }

package/components/permissions/permissions__cache.d.ts

@@ -0,0 +1,93 @@
+export interface PermissionType {
+    key: string;
+}
+export interface Project {
+    id: string;
+}
+export interface Permission {
+    permission: PermissionType;
+    global?: boolean | null | undefined;
+    projects?: readonly Project[] | null | undefined;
+}
+interface PermissionCacheItem {
+    global: boolean | null | undefined;
+    projectIdSet: Record<string, boolean> | null;
+}
+/**
+ * Converts an array of cached permissions to a a map of a permission key
+ * to the respective cached permission.
+ *
+ * @param { {
+ *   permission: {key: string},
+ *   global: boolean?,
+ *   projects: {id: string}[]?
+ * }[] } permissions
+ * @param {function} namesConverter a function, which maps a server-side permission name to client-side permission name
+ * @return {object} permission cache
+ * @private
+ */
+export default class PermissionCache {
+    static GLOBAL_PROJECT_ID: string;
+    /**
+     * Convert an array of projects to a set of project ids.
+     *
+     * @param {object[]=} projects
+     * @return {object} a set of project ids
+     * @private
+     */
+    private static _toProjectIdSet;
+    namesConverter: (name: string) => string | null | undefined;
+    constructor(permissions?: readonly Permission[] | null | undefined, namesConverter?: ((name: string) => string | null | undefined) | null | undefined);
+    private _permissions?;
+    permissionCache?: Record<string, PermissionCacheItem>;
+    set(permissions?: readonly Permission[] | null | undefined): this;
+    get(): readonly Permission[] | null | undefined;
+    /**
+     * Checks if the current user has the given permissions in the project with the given id.
+     *
+     * @param {string} permissions  space separated list of permissions
+     * @param {string=} projectId     optional projectId. If absent the method checks
+     *  if the given permission is granted in any project.
+     *
+     * @return {boolean}
+     */
+    has(permissions?: string | null | undefined, projectId?: string | null | undefined): boolean;
+    /**
+     * Lexes permission query string to an array of lexems.
+     *
+     * @param {string} query
+     * @return {string[]}
+     */
+    lex(query?: string | null | undefined): string[];
+    /**
+     * @param {string[]} lexems
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    or(lexems: string[], projectId?: string | null | undefined): boolean;
+    /**
+     * @param {string[]} lexems
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    and(lexems: string[], projectId?: string | null | undefined): boolean;
+    /**
+     * @param {string[]} lexems
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    not(lexems: string[], projectId?: string | null | undefined): boolean;
+    /**
+     * @param {string[]} lexems
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    term(lexems: string[], projectId?: string | null | undefined): boolean;
+    /**
+     * @param {string} permissionName
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    testPermission(permissionName: string, projectId?: string | null | undefined): boolean;
+}
+export {};