@api-client/core 0.3.3 → 0.3.6

package/src/models/RequestAuthorization.ts

@@ -0,0 +1,115 @@
+import { IAuthorizationSettingsUnion, AuthorizationType } from './Authorization.js';
+import { RequestAuthorization as LegacyAuthorization } from './legacy/request/ArcRequest.js';
+
+export const Kind = 'ARC#RequestAuthorization';
+
+/**
+ * Authorization configuration for the request.
+ */
+export interface IRequestAuthorization {
+  kind: string;
+  /**
+   * Authorization configuration
+   */
+  config: IAuthorizationSettingsUnion;
+  /**
+   * The name of the authorization
+   */
+  type: AuthorizationType;
+  /**
+   * Whether the authorization is enabled.
+   */
+  enabled: boolean;
+  /**
+   * Whether the authorization is reported to be valid.
+   * The application should take action when the authorization is invalid but possibly allow the request.
+   */
+  valid: boolean;
+}
+
+export class RequestAuthorization {
+  kind = Kind;
+  /**
+   * Authorization configuration
+   */
+  config?: IAuthorizationSettingsUnion;
+  /**
+   * The name of the authorization
+   */
+  type?: AuthorizationType;
+  /**
+   * Whether the authorization is enabled.
+   */
+  enabled?: boolean;
+  /**
+   * Whether the authorization is reported to be valid.
+   * The application should take action when the authorization is invalid but possibly allow the request.
+   */
+  valid?: boolean;
+
+  static fromTypedConfig(type: AuthorizationType, config: IAuthorizationSettingsUnion, valid=true): RequestAuthorization {
+    return new RequestAuthorization({
+      kind: Kind,
+      config,
+      enabled: true,
+      type,
+      valid,
+    });
+  }
+
+  static fromLegacy(info: LegacyAuthorization): RequestAuthorization {
+    return new RequestAuthorization({
+      kind: Kind,
+      config: info.config,
+      enabled: true,
+      type: info.type as AuthorizationType,
+      valid: info.valid,
+    });
+  }
+
+  /**
+   * @param input The provider definition used to restore the state.
+   */
+  constructor(input?: string|IRequestAuthorization) {
+    let init: IRequestAuthorization;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        config: {},
+        enabled: false,
+        type: '' as AuthorizationType,
+        valid: true,
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new provider clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the provider is not an ARC provider object.
+   */
+  new(init: IRequestAuthorization): void {
+    const { config, type, enabled, valid } = init;
+    this.kind = Kind;
+    this.config = config;
+    this.type = type;
+    this.enabled = enabled;
+    this.valid = valid;
+  }
+
+  toJSON(): IRequestAuthorization {
+    const result:IRequestAuthorization = {
+      kind: Kind,
+      config: this.config || {},
+      enabled: this.enabled || false,
+      type: this.type || '' as AuthorizationType,
+      valid: this.valid || true,
+    };
+    return result;
+  }
+}

package/src/models/RequestConfig.ts

@@ -0,0 +1,317 @@
+import { IHostRule, HostRule } from './HostRule.js';
+import { IProperty, Property } from './Property.js';
+import { RequestConfig as LegacyConfig } from './legacy/request/ArcRequest.js';
+
+export const Kind = 'ARC#RequestConfig';
+
+export interface IRequestBaseConfig {
+  /**
+   * Request timeout in milliseconds
+   * Default no timeout.
+   */
+  timeout?: number;
+  /**
+   * When false the request object won't follow redirects.
+   * @default true
+   */
+  followRedirects?: boolean;
+  /**
+   * Hosts table configuration.
+   */
+  hosts?: IHostRule[];
+  /**
+   * A limit of characters to include into the `sentHttpMessage` property
+   * of the request object. 0 to disable limit. Default to 2048.
+   * @default 2048
+   */
+  sentMessageLimit?: number;
+  /**
+   * When set the request adds `accept` and `user-agent` headers if missing.
+   */
+  defaultHeaders?: boolean;
+  /**
+   * Default `user-agent` header to be used with request when `defaultHeaders`
+   * is set.
+   *
+   * @default api-client
+   */
+  defaultUserAgent?: string;
+  /**
+   * Default `accept` header to be used with request when `defaultHeaders`
+   * is set.
+   * @default *\/*
+   */
+  defaultAccept?: string;
+  /**
+   * The proxy URI to connect to when making the connection.
+   * It should contain the host and port. Default port is 80.
+   */
+  proxy?: string;
+  /**
+   * The proxy authorization username value.
+   */
+  proxyUsername?: string;
+  /**
+   * The proxy authorization password value.
+   */
+  proxyPassword?: string;
+  /**
+   * Whether the processor should validate certificates.
+   */
+  validateCertificates?: boolean;
+}
+
+/**
+ * ARC request `config` object.
+ */
+export interface IRequestConfig extends IRequestBaseConfig {
+  kind: string;
+  /**
+   * Whether the processor should use this configuration.
+   */
+  enabled: boolean;
+  /**
+   * Does not set session (saved) cookies to this request
+   */
+  ignoreSessionCookies?: boolean;
+  /**
+   * A list of variables to use with the request.
+   * Note, request variables override application and workspace variables.
+   */
+  variables?: IProperty[];
+}
+
+export class RequestConfig {
+  kind = Kind;
+  /**
+   * Whether the processor should use this configuration.
+   */
+  enabled = false;
+  /**
+   * The request timeout.
+   * Default no timeout.
+   */
+  timeout?: number;
+  /**
+   * Whether or not the request should follow redirects.
+   */
+  followRedirects?: boolean;
+  /**
+   * Does not set session (saved) cookies to this request
+   */
+  ignoreSessionCookies?: boolean;
+  /**
+   * Hosts table configuration.
+   */
+  hosts?: HostRule[];
+  /**
+   * Whether the processor should validate certificates.
+   */
+  validateCertificates?: boolean;
+  /**
+   * Whether to put a "default" headers (accept and user agent)
+   */
+  defaultHeaders?: boolean;
+  /**
+   * Default `user-agent` header to be used with request when `defaultHeaders`
+   * is set.
+   *
+   * @default api-client
+   */
+  defaultUserAgent?: string;
+  /**
+   * Default `accept` header to be used with request when `defaultHeaders`
+   * is set.
+   * @default *\/*
+   */
+  defaultAccept?: string;
+  /**
+   * A list of variables to use with the request.
+   * Note, request variables override application and workspace variables.
+   */
+  variables?: Property[];
+  /**
+   * The proxy URI to connect to when making the connection.
+   * It should contain the host and port. Default port is 80.
+   */
+  proxy?: string;
+  /**
+   * The proxy authorization username value.
+   */
+  proxyUsername?: string;
+  /**
+   * The proxy authorization password value.
+   */
+  proxyPassword?: string;
+  /**
+   * A limit of characters to include into the `sentHttpMessage` property
+   * of the request object. 0 to disable limit. Default to 2048.
+   * @default 2048
+   */
+  sentMessageLimit?: number;
+
+  static withDefaults(): RequestConfig {
+    return new RequestConfig({
+      kind: Kind,
+      enabled: true,
+      timeout: 90,
+      followRedirects: true,
+      ignoreSessionCookies: false,
+      validateCertificates: false,
+    });
+  }
+
+  static fromLegacy(config: LegacyConfig): RequestConfig {
+    const { enabled, defaultHeaders, followRedirects, ignoreSessionCookies, timeout, validateCertificates } = config;
+    const init: IRequestConfig = {
+      kind: Kind,
+      enabled,
+    };
+    if (typeof defaultHeaders === 'boolean') {
+      init.defaultHeaders = defaultHeaders;
+    }
+    if (typeof followRedirects === 'boolean') {
+      init.followRedirects = followRedirects;
+    }
+    if (typeof ignoreSessionCookies === 'boolean') {
+      init.ignoreSessionCookies = ignoreSessionCookies;
+    }
+    if (typeof validateCertificates === 'boolean') {
+      init.validateCertificates = validateCertificates;
+    }
+    if (typeof timeout === 'number') {
+      init.timeout = timeout;
+    }
+    return new RequestConfig(init);
+  }
+
+  /**
+   * @param input The request configuration definition used to restore the state.
+   */
+  constructor(input?: string | IRequestConfig) {
+    let init: IRequestConfig;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        enabled: false,
+      }
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new request configuration clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the object is not an ARC request configuration. 
+   */
+  new(init: IRequestConfig): void {
+    const { 
+      enabled, followRedirects, ignoreSessionCookies, validateCertificates, defaultHeaders, timeout, hosts, variables,
+      defaultAccept, defaultUserAgent, proxy, proxyPassword, proxyUsername, sentMessageLimit,
+    } = init;
+    this.kind = Kind;
+    if (typeof enabled === 'boolean') {
+      this.enabled = enabled;
+    } else {
+      this.enabled = false;
+    }
+    if (typeof followRedirects === 'boolean') {
+      this.followRedirects = followRedirects;
+    } else {
+      this.followRedirects = undefined;
+    }
+    if (typeof ignoreSessionCookies === 'boolean') {
+      this.ignoreSessionCookies = ignoreSessionCookies;
+    } else {
+      this.ignoreSessionCookies = undefined;
+    }
+    if (typeof validateCertificates === 'boolean') {
+      this.validateCertificates = validateCertificates;
+    } else {
+      this.validateCertificates = undefined;
+    }
+    if (typeof defaultHeaders === 'boolean') {
+      this.defaultHeaders = defaultHeaders;
+    } else {
+      this.defaultHeaders = undefined;
+    }
+    if (typeof timeout === 'number') {
+      this.timeout = timeout;
+    } else {
+      this.timeout = undefined;
+    }
+    if (Array.isArray(hosts)) {
+      this.hosts = hosts.map(i => new HostRule(i))
+    } else {
+      this.hosts = [];
+    }
+    if (Array.isArray(variables)) {
+      this.variables = variables.map(i => new Property(i))
+    } else {
+      this.variables = [];
+    }
+    if (typeof defaultAccept === 'string') {
+      this.defaultAccept = defaultAccept;
+    } else {
+      this.defaultAccept = undefined;
+    }
+    if (typeof defaultUserAgent === 'string') {
+      this.defaultUserAgent = defaultUserAgent;
+    } else {
+      this.defaultUserAgent = undefined;
+    }
+    if (typeof proxy === 'string') {
+      this.proxy = proxy;
+    } else {
+      this.proxy = undefined;
+    }
+    if (typeof proxyUsername === 'string') {
+      this.proxyUsername = proxyUsername;
+    } else {
+      this.proxyUsername = undefined;
+    }
+    if (typeof proxyPassword === 'string') {
+      this.proxyPassword = proxyPassword;
+    } else {
+      this.proxyPassword = undefined;
+    }
+    if (typeof sentMessageLimit === 'number') {
+      this.sentMessageLimit = sentMessageLimit;
+    } else {
+      this.sentMessageLimit = undefined;
+    }
+  }
+
+  toJSON(): IRequestConfig {
+    const result: IRequestConfig = {
+      kind: Kind,
+      enabled: this.enabled,
+    };
+    if (typeof this.followRedirects === 'boolean') {
+      result.followRedirects = this.followRedirects;
+    }
+    if (typeof this.ignoreSessionCookies === 'boolean') {
+      result.ignoreSessionCookies = this.ignoreSessionCookies;
+    }
+    if (typeof this.validateCertificates === 'boolean') {
+      result.validateCertificates = this.validateCertificates;
+    }
+    if (typeof this.defaultHeaders === 'boolean') {
+      result.defaultHeaders = this.defaultHeaders;
+    }
+    if (typeof this.timeout === 'number') {
+      result.timeout = this.timeout;
+    }
+    if (Array.isArray(this.hosts)) {
+      result.hosts = this.hosts.map(i => i.toJSON());
+    }
+    if (Array.isArray(this.variables)) {
+      result.variables = this.variables.map(i => i.toJSON());
+    }
+    return result;
+  }
+}

package/src/models/RequestLog.ts

@@ -0,0 +1,159 @@
+import { IResponseRedirect, ResponseRedirect  } from './ResponseRedirect.js';
+import { ISentRequest, SentRequest } from './SentRequest.js';
+import { IErrorResponse, ErrorResponse } from './ErrorResponse.js';
+import { IArcResponse, ArcResponse } from './ArcResponse.js';
+import { IRequestsSize, RequestsSize } from './RequestsSize.js';
+import { ResponseRedirect as LegacyRedirect } from './legacy/request/ArcResponse.js';
+
+export const Kind = 'ARC#ResponseLog';
+
+/**
+ * Describes a request / response pair associated with a request.
+ */
+export interface IRequestLog {
+  kind: 'ARC#ResponseLog';
+  /**
+   * Describes an HTTP request sent by the transport.
+   */
+  request?: ISentRequest;
+  /**
+   * The last response made with this request, if any.
+   */
+  response?: IArcResponse | IErrorResponse;
+  /**
+   * The list of redirects, if any.
+   */
+  redirects?: IResponseRedirect[];
+  /**
+   * Request and response size. Some HTTP clients may not give this information.
+   */
+  size?: IRequestsSize;
+}
+
+/**
+ * A request / response pair associated with a request.
+ */
+export class RequestLog {
+  kind = Kind;
+  /**
+   * Describes an HTTP request sent by the transport.
+   */
+  request?: SentRequest;
+  /**
+   * The last response made with this request, if any.
+   */
+  response?: ArcResponse | ErrorResponse;
+  /**
+   * The list of redirects, if any.
+   */
+  redirects?: ResponseRedirect[];
+  /**
+   * Request and response size. Some HTTP clients may not give this information.
+   */
+  size?: RequestsSize;
+
+  static fromRequest(request: ISentRequest): RequestLog {
+    return new RequestLog({
+      kind: Kind,
+      request,
+    });
+  }
+
+  static fromRequestResponse(request: ISentRequest, response: IArcResponse | IErrorResponse): RequestLog {
+    return new RequestLog({
+      kind: Kind,
+      request,
+      response,
+    });
+  }
+
+  /**
+   * @param input The response definition used to restore the state.
+   */
+  constructor(input?: string|IRequestLog) {
+    let init: IRequestLog;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new response clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the object is not an ARC response.
+   */
+  new(init: IRequestLog): void {
+    const { request, response, redirects, size } = init;
+    this.kind = Kind;
+    if (request) {
+      this.request = new SentRequest(request);
+    }
+    if (response) {
+      if (ArcResponse.isErrorResponse(response)) {
+        this.response = new ErrorResponse(response as IErrorResponse);
+      } else {
+        this.response = new ArcResponse(response as IArcResponse);
+      }
+    } else {
+      this.response = undefined;
+    }
+    if (Array.isArray(redirects)) {
+      this.redirects = redirects.map(i => new ResponseRedirect(i));
+    } else {
+      this.redirects = undefined;
+    }
+    if (size) {
+      this.size = new RequestsSize(size);
+    } else {
+      this.size = undefined;
+    }
+  }
+
+  toJSON(): IRequestLog {
+    const result: IRequestLog = {
+      kind: Kind,
+    };
+    if (this.request) {
+      result.request = this.request.toJSON();
+    }
+    if (Array.isArray(this.redirects)) {
+      result.redirects = this.redirects.map(i => i.toJSON());
+    }
+    if (this.size) {
+      result.size = this.size.toJSON();
+    }
+    if (this.response) {
+      result.response = this.response.toJSON();
+    }
+    return result;
+  }
+
+  /**
+   * Adds a redirect to this log. 
+   * It checks whether the redirects array has been initialized.
+   */
+  addRedirect(redirect: IResponseRedirect): ResponseRedirect {
+    if (!this.redirects) {
+      this.redirects = [];
+    }
+    const instance = new ResponseRedirect(redirect);
+    this.redirects.push(instance);
+    return instance;
+  }
+
+  async addLegacyRedirect(redirect: LegacyRedirect): Promise<ResponseRedirect> {
+    if (!this.redirects) {
+      this.redirects = [];
+    }
+    const info = await ResponseRedirect.fromLegacy(redirect);
+    this.redirects.push(info);
+    return info;
+  }
+}

package/src/models/RequestTime.ts

@@ -0,0 +1,108 @@
+export const Kind = 'ARC#RequestTime';
+
+/**
+ * Schema definition for ARC request timings. This is mostly consistent with HAR timings.
+ */
+export interface IRequestTime {
+  kind?: 'ARC#RequestTime';
+  connect: number;
+  receive: number;
+  send: number;
+  wait: number;
+  blocked: number;
+  dns: number;
+  ssl?: number;
+}
+
+
+export class RequestTime {
+  kind = Kind;
+  connect = -1;
+  receive = -1;
+  send = -1;
+  wait = -1;
+  blocked = -1;
+  dns = -1;
+  ssl?: number;
+
+  /**
+   * @param input The timings definition used to restore the state.
+   */
+  constructor(input?: string|IRequestTime) {
+    let init: IRequestTime;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        connect: -1,
+        receive: -1,
+        send: -1,
+        wait: -1,
+        blocked: -1,
+        dns: -1,
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new thing clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the server is not an ARC thing.
+   */
+  new(init: IRequestTime): void {
+    const { connect=-1, receive=-1, send=-1, wait=-1, blocked=-1, dns=-1, ssl=-1 } = init;
+    this.kind = Kind;
+    this.connect = connect;
+    this.receive = receive;
+    this.send = send;
+    this.wait = wait;
+    this.blocked = blocked;
+    this.dns = dns;
+    this.ssl = ssl;
+  }
+
+  toJSON(): IRequestTime {
+    const result: IRequestTime = {
+      kind: Kind,
+      connect: this.connect,
+      receive: this.receive,
+      send: this.send,
+      wait: this.wait,
+      blocked: this.blocked,
+      dns: this.dns,
+    };
+    if (typeof this.ssl === 'number') {
+      result.ssl = this.ssl;
+    }
+    return result;
+  }
+
+  total(): number {
+    let result = 0;
+    if (typeof this.connect === 'number' && this.connect > 0) {
+      result += this.connect;
+    }
+    if (typeof this.receive === 'number' && this.receive > 0) {
+      result += this.receive;
+    }
+    if (typeof this.send === 'number' && this.send > 0) {
+      result += this.send;
+    }
+    if (typeof this.wait === 'number' && this.wait > 0) {
+      result += this.wait;
+    }
+    if (typeof this.blocked === 'number' && this.blocked > 0) {
+      result += this.blocked;
+    }
+    if (typeof this.dns === 'number' && this.dns > 0) {
+      result += this.dns;
+    }
+    if (typeof this.ssl === 'number' && this.ssl > 0) {
+      result += this.ssl;
+    }
+    return result;
+  }
+}