@api-client/core 0.6.31 → 0.7.2

package/src/runtime/actions/runnable/SetCookieRunnable.ts

@@ -1,92 +0,0 @@
-import { IHttpRequest } from '../../../models/HttpRequest.js';
-import { IHttpCookie } from '../../../models/HttpCookie.js';
-import { ActionRunnable } from './ActionRunnable.js';
-import { ISetCookieAction } from '../../../models/actions/runnable/SetCookieAction.js';
-import { Events } from '../../../events/Events.js';
-import { RequestDataExtractor } from '../../../data/RequestDataExtractor.js';
-import { IRequestLog } from '../../../models/RequestLog.js';
-
-export class SetCookieRunnable extends ActionRunnable {
-  async request(request: IHttpRequest): Promise<void> {
-    const config = this.config as ISetCookieAction;
-    const value = await this.readRequestValue(request, config);
-    if (typeof value === 'undefined') {
-      throw new Error(`Cannot read value for the action`);
-    }
-    await this.setCookie(request, config, String(value));
-  }
-
-  async readRequestValue(request: IHttpRequest, config: ISetCookieAction): Promise<string | number | undefined> {
-    const { source } = config;
-    let value: string | number | undefined;
-    if (source.source === 'value') {
-      value = source.value;
-    } else {
-      const extractor = new RequestDataExtractor(request);
-      value = await extractor.extract(source);
-    }
-    return value;
-  }
-
-  async setCookie(request: IHttpRequest, config: ISetCookieAction, value: string): Promise<void> {
-    let url;
-    if (config.useRequestUrl) {
-      url = request.url;
-    } else {
-      url = config.url;
-    }
-    if (!url) {
-      throw new Error('The set cookie action has no URL defined.');
-    }
-    const parser = new URL(url);
-    const cookie: IHttpCookie = {
-      name: config.name,
-      value,
-      sameSite: 'unspecified',
-      domain: parser.host, // parser.hostname,
-      path: parser.pathname,
-    };
-    if (config.expires) {
-      const typedNumber = Number(config.expires);
-      if (Number.isNaN(typedNumber)) {
-        const exp = new Date(config.expires);
-        cookie.expirationDate = exp.getTime();
-      } else {
-        const exp = new Date(typedNumber);
-        cookie.expirationDate = exp.getTime();
-      }
-    }
-    if (typeof config.hostOnly === 'boolean') {
-      cookie.hostOnly = config.hostOnly;
-    }
-    if (typeof config.httpOnly === 'boolean') {
-      cookie.httpOnly = config.httpOnly;
-    }
-    if (typeof config.session === 'boolean') {
-      cookie.session = config.session;
-    }
-    if (typeof config.secure === 'boolean') {
-      cookie.secure = config.secure;
-    }
-    Events.Cookie.update(cookie, this.eventTarget);
-  }
-
-  async response(log: IRequestLog): Promise<void> {
-    if (!log.request || !log.response) {
-      return;
-    }
-    const config = this.config as ISetCookieAction;
-    const { source } = config;
-    let value: string | number | undefined;
-    if (source.source === 'value') {
-      value = source.value;
-    } else {
-      const extractor = new RequestDataExtractor(log.request, log.response);
-      value = await extractor.extract(source);
-    }
-    if (typeof value === 'undefined') {
-      throw new Error(`Cannot read value for the action`);
-    }
-    await this.setCookie(log.request, config, String(value));
-  }
-}

package/src/runtime/actions/runnable/SetVariableRunnable.ts

@@ -1,53 +0,0 @@
-import { IHttpRequest } from '../../../models/HttpRequest.js';
-import { ActionRunnable } from './ActionRunnable.js';
-import { ISetVariableAction } from '../../../models/actions/runnable/SetVariableAction.js';
-import { Events } from '../../../events/Events.js';
-import { RequestDataExtractor } from '../../../data/RequestDataExtractor.js';
-import { IRequestLog } from '../../../models/RequestLog.js';
-
-export class SetVariableRunnable extends ActionRunnable {
-  async request(request: IHttpRequest): Promise<void> {
-    const config = this.config as ISetVariableAction;
-    const value = await this.readRequestValue(request, config);
-    if (typeof value === 'undefined') {
-      throw new Error(`Cannot read value for the action`);
-    }
-    await this.setVariable(config, String(value));
-  }
-
-  async readRequestValue(request: IHttpRequest, config: ISetVariableAction): Promise<string | number | undefined> {
-    const { source } = config;
-    let value: string | number | undefined;
-    if (source.source === 'value') {
-      value = source.value;
-    } else {
-      const extractor = new RequestDataExtractor(request);
-      value = await extractor.extract(source);
-    }
-    return value;
-  }
-
-  async setVariable(config: ISetVariableAction, value: string): Promise<void> {
-    const { name } = config;
-    Events.Environment.set(name, value, this.eventTarget);
-  }
-
-  async response(log: IRequestLog): Promise<void> {
-    if (!log.request || !log.response) {
-      return;
-    }
-    const config = this.config as ISetVariableAction;
-    let value: string | number | undefined;
-    const { source } = config;
-    if (source.source === 'value') {
-      value = source.value;
-    } else {
-      const extractor = new RequestDataExtractor(log.request, log.response);
-      value = await extractor.extract(source);
-    }
-    if (typeof value === 'undefined') {
-      throw new Error(`Cannot read value for the action`);
-    }
-    await this.setVariable(config, String(value));
-  }
-}

package/src/runtime/modules/BasicAuthCache.ts

@@ -1,129 +0,0 @@
-import { Headers } from '../../lib/headers/Headers.js';
-import { IHttpRequest } from '../../models/HttpRequest.js';
-import { INtlmAuthorization, IBasicAuthorization } from '../../models/Authorization.js';
-import { ExecutionContext } from './ModulesRegistry.js';
-import { IRequestAuthorization, Kind as RequestAuthorizationKind } from '../../models/RequestAuthorization.js';
-
-const cache: any = {};
-
-/**
- * Removes query parameters and the fragment part from the URL
- * @param url The URL to process.
- * @returns The canonical URL.
- */
-export function computeUrlPath(url: string): string {
-  if (!url) {
-    return '';
-  }
-  try {
-    const u = new URL(url);
-    u.hash = '';
-    u.search = '';
-    let result = u.toString();
-    // polyfill library has some error and leaves '?#' if was set
-    result = result.replace('?', '');
-    result = result.replace('#', '');
-    return result;
-  } catch (e) {
-    return url;
-  }
-}
-
-/**
- * Finds an auth data for given `url`.
- *
- * @param type Authorization type.
- * @param url The URL of the request.
- * @return Auth data if exists in the cache.
- */
-export function findCachedAuthData(type: string, url: string): IBasicAuthorization|INtlmAuthorization|undefined {
-  const key = computeUrlPath(url);
-  if (!cache || !type || !key || !cache[type]) {
-    return undefined;
-  }
-  return cache[type][key];
-}
-
-/**
- * Updates cached authorization data
- *
- * @param type Authorization type.
- * @param url The URL of the request.
- * @param value Auth data to set
- */
-export function updateCache(type: string, url: string, value: IBasicAuthorization|INtlmAuthorization): void {
-  const key = computeUrlPath(url);
-  if (!cache[type]) {
-    cache[type] = {};
-  }
-  cache[type][key] = value;
-}
-
-/**
- * Applies the basic authorization data to the request.
- *
- * If the header value have changed then it fires `request-headers-changed` custom event.
- * It sets computed value of the readers to the event's detail object.
- *
- * @param request The event's detail object. Changes made here will be propagated to the event.
- * @param data The authorization data to apply.
- */
-export function applyRequestBasicAuthData(request: IHttpRequest, data: IBasicAuthorization): void {
-  const { username='', password='' } = data;
-  const headers = new Headers(request.headers || '');
-  let hash: string;
-  let decoded = `${username}:${password}`;
-  if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
-    hash = Buffer.from(decoded).toString('base64');
-  } else {
-    hash = btoa(decoded);
-  }
-  headers.set('authorization', `Basic ${hash}`);
-  request.headers = headers.toString();
-}
-
-/**
- * Applies the NTLM authorization data to the request.
- *
- * Because NTLM requires certain operations on a socket it's bot just about setting a headers
- * but whole NTLM configuration object.
- *
- * Applied the `auth` object to the event's `detail.auth` object.
- */
-function applyRequestNtlmAuthData(authorization: IRequestAuthorization[], values: INtlmAuthorization): void {
-  let ntlm: IRequestAuthorization | undefined = authorization.find(((method) => method.type === 'ntlm'));
-  if (!ntlm) {
-    ntlm = {
-      kind: RequestAuthorizationKind,
-      enabled: true,
-      type: 'ntlm',
-      config: {},
-      valid: true,
-    };
-    authorization.push(ntlm);
-  }
-  const cnf = ntlm.config as INtlmAuthorization;
-  if (cnf.username) {
-    return;
-  }
-  cnf.username = values.username;
-  cnf.password = values.password;
-  cnf.domain = values.domain;
-}
-
-/**
- * Adds basic authorization data to the request, when during this session basic auth was used
- */
-export default function applyCachedBasicAuthData(request: IHttpRequest, context: ExecutionContext): void {
-  // Try to find an auth data for the URL. If has a match, apply it to the request
-  let authData = findCachedAuthData('basic', request.url);
-  if (authData) {
-    applyRequestBasicAuthData(request, authData);
-    return;
-  }
-  // Try NTLM
-  authData = findCachedAuthData('ntlm', request.url);
-  if (authData && Array.isArray(context.authorization)) {
-    applyRequestNtlmAuthData(context.authorization, authData as INtlmAuthorization);
-  }
-}

package/src/runtime/modules/ExecutionResponse.ts

@@ -1,4 +0,0 @@
-export enum ExecutionResponse {
-  OK,
-  ABORT,
-}

package/src/runtime/modules/ModulesRegistry.ts

@@ -1,136 +0,0 @@
-import { IHttpRequest } from '../../models/HttpRequest.js';
-import { EnvironmentEvents } from '../../events/environment/EnvironmentEvents.js';
-import { CookieEvents } from '../../events/cookies/CookieEvents.js';
-import { EncryptionEvents } from '../../events/encryption/EncryptionEvents.js';
-import { ProcessEvents } from '../../events/process/ProcessEvents.js';
-import { AuthorizationEvents } from '../../events/authorization/AuthorizationEvents.js';
-import { ClientCertificateEvents } from '../../events/models/ClientCertificateEvents.js';
-import { IRequestAuthorization } from '../../models/RequestAuthorization.js';
-import { IRequestConfig } from '../../models/RequestConfig.js';
-import { IRequestLog } from '../../models/RequestLog.js';
-import { HttpCertificate } from '../../models/ClientCertificate.js';
-
-export interface RegisteredRequestModule {
-  fn: (request: IHttpRequest, context: ExecutionContext) => Promise<number>;
-  permissions: RegistryPermission[];
-}
-
-export interface RegisteredResponseModule {
-  fn: (log: IRequestLog, context: ExecutionContext) => Promise<number>;
-  permissions: RegistryPermission[];
-}
-
-export enum RegistryPermission {
-  environment = 'environment',
-  events = 'events',
-}
-
-export interface ExecutionContext {
-  /**
-   * The event target for events
-   */
-  eventsTarget: EventTarget;
-  /**
-   * The events to use to communicate with the context store(s)
-   */
-  Events?: ExecutionEvents;
-  /**
-   * The environment variables to use when executing the module.
-   */
-  variables?: Record<string, string>;
-  /**
-   * Request authorization configuration
-   */
-  authorization?: IRequestAuthorization[];
-  /**
-   * Optional request configuration.
-   */
-  config?: IRequestConfig;
-  /**
-   * Can be altered by the actions.
-   */
-  certificates?: HttpCertificate[];
-}
-
-export interface ExecutionEvents {
-  Authorization: typeof AuthorizationEvents;
-  Environment: typeof EnvironmentEvents;
-  Cookie: typeof CookieEvents;
-  Encryption: typeof EncryptionEvents;
-  Process: typeof ProcessEvents;
-  ClientCertificate: typeof ClientCertificateEvents;
-}
-
-/**
- * The list of registered request processing modules.
- */
-const requestModules = new Map<string, RegisteredRequestModule>();
-
-/**
- * The list of registered response processing modules.
- */
-const responseModules = new Map<string, RegisteredResponseModule>();
-
-export type RequestModule = 'request';
-export type ResponseModule = 'response';
-
-/**
- * A registry for modules.
- */
-export class ModulesRegistry {
-  static get request(): RequestModule { return 'request' }
-
-  static get response(): ResponseModule { return 'response' }
-
-  /**
-   * Registers a new request or response module in the registry.
-   * @param context The name of the execution context
-   * @param id The identifier of the module
-   * @param fn The function to execute
-   * @param permissions The list of permissions for the module
-   * @throws {Error} When the module is already registered
-   */
-  static register(context: ResponseModule|RequestModule, id: string, fn: Function, permissions?: string[]): void {
-    const data = {
-      fn,
-      permissions: Array.isArray(permissions) ? permissions : [],
-    };
-    const map = context === ModulesRegistry.request ? requestModules : responseModules;
-    if (map.has(id)) {
-      throw new Error(`Module ${id} already exists`);
-    }
-    // @ts-ignore
-    map.set(id, data);
-  }
-
-  /**
-   * Checks whether a module is already registered for the given context.
-   * @param {ModulesRegistry.request|ModulesRegistry.response} context The name of the execution context
-   * @param id The identifier of the module
-   */
-  static has(context: ResponseModule|RequestModule, id: string): boolean {
-    const map = context === ModulesRegistry.request ? requestModules : responseModules;
-    return map.has(id);
-  }
-
-  /**
-   * Removes a registered module
-   * @param {ModulesRegistry.request|ModulesRegistry.response} context The name of the execution context
-   * @param {string} id The identifier of the module
-   */
-  static unregister(context: ResponseModule|RequestModule, id: string): void {
-    const map = context === ModulesRegistry.request ? requestModules : responseModules;
-    map.delete(id);
-  }
-
-  /**
-   * Reads the list of registered modules
-   * @param  context The name of the execution context
-   * @returns The copy of the map of actions.
-   */
-  static get(context: ResponseModule|RequestModule): Map<string, RegisteredRequestModule|RegisteredResponseModule> {
-    const map = context === ModulesRegistry.request ? requestModules : responseModules;
-    // @ts-ignore
-    return new Map(map);
-  }
-}

package/src/runtime/modules/RequestAuthorization.ts

@@ -1,106 +0,0 @@
-import { Headers } from '../../lib/headers/Headers.js';
-import { ExecutionResponse } from './ExecutionResponse.js';
-import applyCachedBasicAuthData, { applyRequestBasicAuthData } from './BasicAuthCache.js';
-import { IHttpRequest } from '../../models/HttpRequest.js';
-import { IBearerAuthorization, IBasicAuthorization, IOidcAuthorization, IOAuth2Authorization, ICCAuthorization } from '../../models/Authorization.js';
-import { ExecutionContext } from './ModulesRegistry.js';
-
-/**
- * Injects client certificate object into the request object
- */
-async function processClientCertificate(config: ICCAuthorization, context: ExecutionContext): Promise<void> {
-  const { certificate } = config;
-  if (!certificate) {
-    return;
-  }
-  if (!Array.isArray(context.certificates)) {
-    context.certificates = [];
-  }
-  context.certificates.push(certificate);
-}
-
-/**
- * Injects basic auth header into the request headers.
- */
-function processBasicAuth(request: IHttpRequest, config: IBasicAuthorization): void {
-  const { username } = config;
-  if (!username) {
-    return;
-  }
-  applyRequestBasicAuthData(request, config);
-}
-
-/**
- * Injects oauth 2 auth header into the request headers.
- */
-function processOAuth2(request: IHttpRequest, config: IOAuth2Authorization): void {
-  const { accessToken, tokenType='Bearer', deliveryMethod='header', deliveryName='authorization' } = config;
-  if (!accessToken) {
-    return;
-  }
-  const value = `${tokenType} ${accessToken}`;
-  if (deliveryMethod === 'header') {
-    const headers = new Headers(request.headers || '');
-    headers.append(deliveryName, value);
-    request.headers = headers.toString();
-  } else if (deliveryMethod === 'query') {
-    const { url } = request;
-    try {
-      const parsed = new URL(url);
-      parsed.searchParams.append(deliveryName, value);
-      request.url = parsed.toString();
-    } catch (e) {
-      // ...
-    }
-  }
-}
-
-/**
- * Injects OpenID Connect auth header into the request headers.
- */
-function processOpenId(request: IHttpRequest, config: IOidcAuthorization): void {
-  const { accessToken } = config;
-  if (accessToken) {
-    processOAuth2(request, config);
-  }
-  // todo - if AT is missing find the current token from the tokens list in the passed configuration.
-  // Currently the authorization method UI sets the token when the requests is generated so it's not as much important.
-}
-
-/**
- * Injects bearer auth header into the request headers.
- */
-function processBearer(request: IHttpRequest, config: IBearerAuthorization): void {
-  const { token } = config;
-  const value = `Bearer ${token}`;
-  const headers = new Headers(request.headers || '');
-  headers.append('authorization', value);
-  request.headers = headers.toString();
-}
-
-/**
- * Processes authorization data from the authorization configuration and injects data into the request object when necessary.
- */
-export default async function processAuth(request: IHttpRequest, context: ExecutionContext): Promise<number> {
-  if (!Array.isArray(context.authorization) || !context.authorization.length) {
-    return ExecutionResponse.OK;
-  }
-  for (const auth of context.authorization) {
-    if (!auth.enabled || !auth.config) {
-      continue;
-    }
-    switch (auth.type) {
-      case 'client certificate': await processClientCertificate(auth.config as ICCAuthorization, context); break;
-      case 'basic': processBasicAuth(request, auth.config as IBasicAuthorization); break;
-      case 'oauth 2': processOAuth2(request, auth.config as IOAuth2Authorization); break;
-      case 'open id': processOpenId(request, auth.config as IOidcAuthorization); break;
-      case 'bearer': processBearer(request, auth.config as IBearerAuthorization); break;
-      default:
-    }
-  }
-  if (request.url && !/^authorization:\s?.+$/gim.test(request.headers || '')) {
-    // Try to apply basic auth from the cached during this session values.
-    applyCachedBasicAuthData(request, context);
-  }
-  return ExecutionResponse.OK;
-}

package/src/runtime/modules/RequestCookies.ts

@@ -1,146 +0,0 @@
-import { CookieEvents } from '../../events/cookies/CookieEvents.js';
-import { Cookies } from '../../lib/cookies/Cookies.js';
-import { Headers } from '../../lib/headers/Headers.js';
-import { IHttpRequest } from '../../models/HttpRequest.js';
-import { ExecutionContext } from './ModulesRegistry.js';
-import { IResponseRedirect } from '../../models/ResponseRedirect.js';
-import { IResponse } from '../../models/Response.js';
-import { IErrorResponse } from '../../models/ErrorResponse.js';
-import { IRequestLog } from '../../models/RequestLog.js';
-import { HttpCookie } from '../../models/HttpCookie.js';
-import { Kind as RequestConfigKind } from '../../models/RequestConfig.js';
-import { Cookie } from '../../lib/cookies/Cookie.js';
-
-/**
- * Get cookies header value for given URL.
- *
- * @param eventsTarget
- * @param url An URL for cookies.
- * @returns A promise that resolves to header value string.
- */
-async function getCookiesHeaderValue(eventsTarget: EventTarget, url: string): Promise<string> {
-  const cookies = await CookieEvents.listUrl(url, eventsTarget);
-  if (!cookies || !cookies.length) {
-    return '';
-  }
-  return cookies.map((c) => `${c.name}=${c.value}`).join('; ');
-}
-
-/**
- * Applies cookie header value to current request headers.
- * If header to be applied is computed then it will alter headers string.
- *
- * Note, this element do not sends `request-headers-changed` event.
- *
- * @param header Computed headers string
- * @param request The request object from the event.
- */
-function applyCookieHeader(header: string, request: IHttpRequest): void {
-  const trimmed = header.trim();
-  if (!trimmed) {
-    return;
-  }
-  const headers = new Headers(request.headers);
-  headers.append('cookie', trimmed);
-  request.headers = headers.toString();
-}
-
-/**
- * Extracts cookies from the `response` object and returns an object with `cookies` and `expired` properties containing array of cookies, each.
- *
- * @param url The request URL.
- * @param redirects List of redirect responses 
- * @returns An object with `cookies` and `expired` arrays of cookies.
- */
-function extract(response: IResponse, url: string, redirects?: IResponseRedirect[]): Record<'expired'|'cookies', Cookie[]> {
-  let expired: Cookie[] = [];
-  let parser;
-  let exp;
-  const parsers = [];
-  if (redirects && redirects.length) {
-    redirects.forEach((r) => {
-      const headers = new Headers(r.response.headers);
-      if (headers.has('set-cookie')) {
-        parser = new Cookies(headers.get('set-cookie'), r.url);
-        parser.filter();
-        exp = parser.clearExpired();
-        if (exp && exp.length) {
-          expired = expired.concat(exp);
-        }
-        parsers.push(parser);
-      }
-    });
-  }
-  const headers = new Headers(response.headers);
-  if (headers.has('set-cookie')) {
-    parser = new Cookies(headers.get('set-cookie'), url);
-    parser.filter();
-    exp = parser.clearExpired();
-    if (exp && exp.length) {
-      expired = expired.concat(exp);
-    }
-    parsers.push(parser);
-  }
-  let mainParser: Cookies|undefined;
-  parsers.forEach((item) => {
-    if (!mainParser) {
-      mainParser = item;
-      return;
-    }
-    mainParser.merge(item);
-  });
-  return {
-    cookies: mainParser ? mainParser.cookies : [],
-    expired
-  };
-}
-
-/**
- * A request engine request module to apply session cookies to a request.
- * It adds stored session cookies when application configuration applies for it (or request configuration, when apply)
- * 
- * Unregister this module when the application settings change to not to use session storage.
- * 
- * In electron the session storage is a chrome persistent partition with a session shared with the "log in to a web service".
- * This way cookies can be acquired in through the browser login and store in the application to use them with the request.
- */
-export async function processRequestCookies(request: IHttpRequest, context: ExecutionContext): Promise<void> {
-  const editorRequest = request;
-  const { config } = context;
-  const ignore = config && config.enabled === true && config.ignoreSessionCookies === true;
-  if (ignore) {
-    return;
-  }
-  const cookie = await getCookiesHeaderValue(context.eventsTarget, editorRequest.url);
-  applyCookieHeader(cookie, editorRequest);
-}
-
-/**
- * Processes cookies data from the response and inserts them into the session storage
- */
-export async function processResponseCookies(log: IRequestLog, context: ExecutionContext): Promise<void> {
-  if (!log.response || !log.request) {
-    return;
-  }
-  const typedError = log.response as IErrorResponse;
-  if (typedError.error) {
-    return;
-  }
-  const config = context.config || {
-    kind: RequestConfigKind,
-    enabled: false,
-  };
-  let ignore = false; 
-  if (config.enabled !== false && config.ignoreSessionCookies) {
-    ignore = true;
-  }
-  
-  if (ignore) {
-    return;
-  }
-  const typedResponse = log.response as IResponse;
-  const result = extract(typedResponse, log.request.url, log.redirects);
-  if (result.cookies.length) {
-    await CookieEvents.updateBulk(result.cookies.map(c => HttpCookie.fromCookieParser(c).toJSON()), context.eventsTarget);
-  }
-}