@api-client/core 0.3.6 → 0.3.9

package/src/lib/parsers/UrlValueParser.ts

@@ -0,0 +1,211 @@
+export interface IUrlValueParserOptions {
+  /**
+   * A query string delimiter to use when processing query parameters.
+   */
+  queryDelimiter?: string;
+}
+
+interface DataValues {
+  /**
+   * A protocol value in format `protocol` + ':'
+   */
+  protocol?: string;
+  /**
+   * The authority part of the URL value
+   */
+  host?: string;
+  /**
+   * Path part of the URL.
+   */
+  path?: string;
+  /**
+   * Anchor part of the URL.
+   */
+  anchor?: string;
+  /**
+   * Search part of the URL.
+   */
+  search?: string;
+  opts?: IUrlValueParserOptions | undefined;
+}
+
+/**
+ * Implements logic for parsing URL string.
+ */
+export class UrlValueParser {
+  protected __data: DataValues;
+
+  constructor(opts?: IUrlValueParserOptions) {
+    this.__data = {};
+    this.opts = opts;
+  }
+
+  /**
+   * @returns Class options.
+   */
+  get opts(): IUrlValueParserOptions {
+    return this.__data.opts || {
+      queryDelimiter: '&',
+    };
+  }
+
+  /**
+   * Sets parser options.
+   * Unknown options are ignored.
+   */
+  set opts(opts: IUrlValueParserOptions | undefined) {
+    const options = (opts || {}) as IUrlValueParserOptions;
+    this.__data.opts = {
+      queryDelimiter: options.queryDelimiter || '&'
+    };
+  }
+
+  /**
+   * Returns protocol value in format `protocol` + ':'
+   *
+   * @param value URL to parse.
+   * @return Value of the protocol or undefined if value not set
+   */
+  protected _parseProtocol(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    const delimiterIndex = value.indexOf('://');
+    if (delimiterIndex !== -1) {
+      return value.substring(0, delimiterIndex + 1);
+    }
+    return undefined;
+  }
+
+  /**
+   * Gets a host value from the url.
+   * It reads the whole authority value of given `value`. It doesn't parses it
+   * to host, port and
+   * credentials parts. For URL panel it's enough.
+   *
+   * @param value The URL to parse
+   * @return Value of the host or undefined.
+   */
+  protected _parseHost(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let result = value;
+    const delimiterIndex = result.indexOf('://');
+    if (delimiterIndex !== -1) {
+      result = result.substring(delimiterIndex + 3);
+    }
+    if (!result) {
+      return undefined;
+    }
+    // We don't need specifics here (username, password, port)
+    const host = result.split('/')[0];
+    return host;
+  }
+
+  /**
+   * Parses the path part of the URL.
+   *
+   * @param value URL value
+   * @returns Path part of the URL
+   */
+  protected _parsePath(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let result = value;
+    const isBasePath = result[0] === '/';
+    if (!isBasePath) {
+      const index = result.indexOf('://');
+      if (index !== -1) {
+        result = result.substring(index + 3);
+      }
+    }
+    let index = result.indexOf('?');
+    if (index !== -1) {
+      result = result.substring(0, index);
+    }
+    index = result.indexOf('#');
+    if (index !== -1) {
+      result = result.substring(0, index);
+    }
+    const lastIsSlash = result[result.length - 1] === '/';
+    const parts = result.split('/').filter((part) => !!part);
+    if (!isBasePath) {
+      parts.shift();
+    }
+    let path = `/${  parts.join('/')}`;
+    if (lastIsSlash && parts.length > 1) {
+      path += '/';
+    }
+    return path;
+  }
+
+  /**
+   * Returns query parameters string (without the '?' sign) as a whole.
+   *
+   * @param value The URL to parse
+   * @returns Value of the search string or undefined.
+   */
+  protected _parseSearch(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let index = value.indexOf('?');
+    if (index === -1) {
+      return undefined;
+    }
+    const result = value.substring(index + 1);
+    index = result.indexOf('#');
+    if (index === -1) {
+      return result;
+    }
+    return result.substring(0, index);
+  }
+
+  /**
+   * Reads a value of the anchor (or hash) parameter without the `#` sign.
+   *
+   * @param value The URL to parse
+   * @returns Value of the anchor (hash) or undefined.
+   */
+  protected _parseAnchor(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    const index = value.indexOf('#');
+    if (index === -1) {
+      return undefined;
+    }
+    return value.substring(index + 1);
+  }
+
+  /**
+   * Returns an array of items where each item is an array where first
+   * item is param name and second is it's value. Both always strings.
+   *
+   * @param search Parsed search parameter
+   * @returns Always returns an array.
+   */
+  protected _parseSearchParams(search?: string): string[][] {
+    const result: string[][] = [];
+    if (!search) {
+      return result;
+    }
+    const parts = search.split(this.opts.queryDelimiter as string);
+    parts.forEach((item) => {
+      const _part = ['', ''];
+      const _params = item.split('=');
+      let _name = _params.shift();
+      if (!_name && _name !== '') {
+        return;
+      }
+      _name = _name.trim();
+      const _value = _params.join('=').trim();
+      _part[0] = _name;
+      _part[1] = _value;
+      result.push(_part);
+    });
+    return result;
+  }
+}

package/src/models/User.ts

@@ -64,15 +64,7 @@ export interface IUserPicture {
 
 export const Kind = 'ARC#User';
 
-/**
- * Represents a user in the system.
- * This can be embedded in various situations like project's revision history,
- * ACL, Authorization, etc.
- * 
- * Note, the store implementation may have additional fields that support external 
- * identity providers. However, this is not exposed to the user through the API.
- */
-export interface IUser {
+interface BaseUser {
   /**
    * Data store key of the user.
    */
@@ -103,6 +95,21 @@ export interface IUser {
   provider?: unknown;
 }
 
+/**
+ * Represents a user in the system.
+ * This can be embedded in various situations like project's revision history,
+ * ACL, Authorization, etc.
+ * 
+ * Note, the store implementation may have additional fields that support external 
+ * identity providers. However, this is not exposed to the user through the API.
+ */
+export interface IUser extends BaseUser {
+  /**
+   * Optional metadata related to the auth provider.
+   */
+  provider?: unknown;
+}
+
 /**
  * This object may be created for each user in the system.
  * It describes to which spaces user has access to.
@@ -118,3 +125,13 @@ export interface IUserSpaces {
    */
   user: string;
 }
+
+/**
+ * An abstract user object that contains access information to a space.
+ */
+export interface ISpaceUser extends BaseUser {
+  /**
+   * The level that the user has access to.
+   */
+  level: AccessControlLevel;
+}

package/src/runtime/store/StoreSdk.ts

@@ -474,6 +474,36 @@ class SpacesSdk extends SdkBase {
       throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
     }
   }
+
+  /**
+   * Lists uses having access to the user space.
+   * 
+   * @param key The user space key
+   */
+  async listUsers(key: string): Promise<IListResponse> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(`/spaces/${key}/users`);
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to list users in the space. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IListResponse;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!Array.isArray(data.data)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
 }
 
 class HttpClient extends SdkBase {
@@ -835,4 +865,31 @@ class UsersSdk extends SdkBase {
     }
     return data;
   }
+
+  /**
+   * Reads a user information from the store.
+   * @param key The user key.
+   * @returns The user object
+   */
+  async read(key: string): Promise<IUser> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(`/users/${key}`);
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to read the user info. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IUser;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    return data;
+  }
 }

package/src/testing/TestCliHelper.ts

@@ -4,6 +4,12 @@ export interface ITestRunCommandOptions {
 }
 
 export class TestCliHelper {
+  /**
+   * The globally set test timeout.
+   * @default 2000 The mocha default test timeout.
+   */
+  static testTimeout = 2000;
+
   static cleanTerminalOutput(s: string): string {
     let result = s.trim();
     result = result.replace(/[^\x20-\x7E\n]/gm, '');
@@ -37,9 +43,10 @@ export class TestCliHelper {
    * ```
    * 
    * @param fn The function to execute.
+   * @param timeout The test timeout. After this time the output is reset.
    * @returns The terminal output.
    */
-  static async grabOutput(fn: () => Promise<void>): Promise<string> {
+  static async grabOutput(fn: () => Promise<void>, timeout=TestCliHelper.testTimeout): Promise<string> {
     const messages: string[] = [];
     function noop(): void {
       //
@@ -64,11 +71,15 @@ export class TestCliHelper {
     process.stderr.write = messageHandler;
     console.clear = noop;
 
+    const handle = setTimeout(() => stop(), timeout);
+
     try {
       await fn();
       stop();
+      clearTimeout(handle);
     } catch (e) {
       stop();
+      clearTimeout(handle);
       throw e;
     }
     return messages.join('');