@api-client/core 0.3.1 → 0.3.4

package/src/models/RequestUiMeta.ts

@@ -0,0 +1,258 @@
+import { IProperty, Property } from './Property.js';
+import { IMultipartBody } from '../lib/transformers/PayloadSerializer.js';
+import { RequestUiMeta as LegacyRequestUiMeta } from './legacy/request/ArcRequest.js';
+
+export const Kind = 'ARC#RequestUiMeta';
+
+/**
+ * URL editor meta data.
+ */
+export interface IUrlMeta {
+  /**
+   * The model generated for the URL parameters.
+   */
+  model?: IProperty[];
+  /**
+   * The query params delimiter. By default it is `&`.
+   */
+  delimiter?: string;
+}
+
+/**
+ * Headers editor meta data.
+ */
+export interface IHeadersMeta {
+  /**
+   * The model generated for the headers editor.
+   */
+  model?: IProperty[];
+  /**
+   * Whether the source editor is opened.
+   */
+  source?: boolean;
+}
+
+export interface IAuthMeta {
+  /**
+   * The index of the selected authorization method.
+   */
+  selected?: number;
+}
+
+export interface IActionsMeta {
+  /**
+   * The index of the selected arc actions view.
+   */
+  selected?: number;
+}
+
+export interface IResponseUiMeta {
+  /**
+   * The list of activated panels in the response view.
+   */
+  activePanels?: string[];
+  /**
+   * The name of the selected response panel.
+   */
+  selectedPanel?: string;
+}
+
+/**
+ * The body editor may produce multiple view models
+ * for the UI. Each editor can store it's data in here
+ * to restore it after opening a request,
+ */
+export interface IBodyMetaModel {
+  /**
+   * The id of the editor. Each editor in ARC has own id.
+   */
+  type: string;
+  /**
+   * Generated view model.
+   */
+  viewModel: (IProperty | IMultipartBody | IRawBody)[];
+}
+
+/**
+ * Body editor meta data.
+ */
+export interface IBodyMeta {
+  /**
+   * The model generated for the body editor.
+   */
+  model?: IBodyMetaModel[];
+  /**
+   * The selected editor
+   */
+  selected?: string;
+}
+
+export interface IRawBody {
+  /**
+   * The last used body value.
+   */
+  value: string;
+  /**
+   * True when the generator was used to build the value
+   */
+  isGenerator?: boolean;
+  /**
+   * The schema for the generator. Work in progress.
+   */
+  generatorSchema?: unknown;
+}
+
+/**
+ * UI configuration for the request.
+ */
+export interface IRequestUiMeta {
+  kind?: typeof Kind;
+  /**
+   * Body editor metadata.
+   */
+  body?: IBodyMeta;
+  /**
+   * URL editor metadata.
+   */
+  url?: IUrlMeta;
+  /**
+   * Headers editor metadata.
+   */
+  headers?: IHeadersMeta;
+  /**
+   * Authorization editor meta.
+   */
+  authorization?: IAuthMeta;
+  /**
+   * ARC request actions editor UI config.
+   */
+  actions?: IActionsMeta;
+  /**
+   * The currently selected editor in the request editor UI.
+   */
+  selectedEditor?: number;
+  /**
+   * Optional configuration of the response view
+   */
+  response?: IResponseUiMeta;
+}
+
+export class RequestUiMeta {
+  kind = Kind;
+  /**
+   * Body editor metadata.
+   */
+  body?: IBodyMeta;
+  /**
+   * URL editor metadata.
+   */
+  url?: IUrlMeta;
+  /**
+   * Headers editor metadata.
+   */
+  headers?: IHeadersMeta;
+  /**
+   * Authorization editor meta.
+   */
+  authorization?: IAuthMeta;
+  /**
+   * ARC request actions editor UI config.
+   */
+  actions?: IActionsMeta;
+  /**
+   * The currently selected editor in the request editor UI.
+   */
+  selectedEditor?: number;
+  /**
+   * Optional configuration of the response view
+   */
+  response?: IResponseUiMeta;
+
+  static fromLegacy(old: LegacyRequestUiMeta): RequestUiMeta {
+    const { actions, authorization, body, headers, response, selectedEditor, url } = old;
+    const init: IRequestUiMeta = {
+      actions,
+      authorization,
+      body,
+      response,
+      selectedEditor,
+    };
+    if (url) {
+      const initUrl: IUrlMeta = {};
+      if (url.delimiter) {
+        initUrl.delimiter = url.delimiter;
+      }
+      if (Array.isArray(url.model) && url.model.length) {
+        initUrl.model = url.model.map(i => Property.fromApiType(i).toJSON());
+      }
+      init.url = initUrl;
+    }
+    if (headers) {
+      const headersUrl: IHeadersMeta = {};
+      if (typeof headers.source === 'boolean') {
+        headersUrl.source = headers.source;
+      }
+      if (Array.isArray(headers.model) && headers.model.length) {
+        headersUrl.model = headers.model.map(i => Property.fromApiType(i).toJSON());
+      }
+      init.url = headersUrl;
+    }
+    return new RequestUiMeta(init);
+  }
+
+  /**
+   * @param input The project item definition used to restore the state.
+   */
+  constructor(input?: string | IRequestUiMeta) {
+    let init: IRequestUiMeta;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {};
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new object clearing anything that is so far defined.
+   */
+  new(init: IRequestUiMeta): void {
+    this.body = init.body;
+    this.url = init.url;
+    this.headers = init.headers;
+    this.authorization = init.authorization;
+    this.actions = init.actions;
+    this.selectedEditor = init.selectedEditor;
+    this.response = init.response;
+  }
+
+  toJSON(): IRequestUiMeta {
+    const result: IRequestUiMeta = {
+      kind: Kind,
+    };
+    if (this.body) {
+      result.body = this.body;
+    }
+    if (this.url) {
+      result.url = this.url;
+    }
+    if (this.headers) {
+      result.headers = this.headers;
+    }
+    if (this.authorization) {
+      result.authorization = this.authorization;
+    }
+    if (this.actions) {
+      result.actions = this.actions;
+    }
+    if (this.response) {
+      result.response = this.response;
+    }
+    if (typeof this.selectedEditor === 'number') {
+      result.selectedEditor = this.selectedEditor;
+    }
+    return result;
+  }
+}

package/src/models/RequestsSize.ts

@@ -0,0 +1,65 @@
+export const Kind = 'ARC#ResponseSize';
+
+export interface IRequestsSize {
+  kind?: typeof Kind;
+  /**
+   * The size of the request in bytes
+   */
+  request: number;
+  /**
+   * The size of the response in bytes
+   */
+  response: number;
+}
+
+export class RequestsSize {
+  kind = Kind;
+  /**
+   * The size of the request in bytes
+   */
+  request = 0;
+  /**
+   * The size of the response in bytes
+   */
+  response = 0;
+
+  /**
+   * @param input The response size definition used to restore the state.
+   */
+  constructor(input?: string|IRequestsSize) {
+    let init: IRequestsSize;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        request: 0,
+        response: 0,
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new response size clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the object is not an ARC response size.
+   */
+  new(init: IRequestsSize): void {
+    const { request, response } = init;
+    this.kind = Kind;
+    this.request = request;
+    this.response = response;
+  }
+
+  toJSON(): IRequestsSize {
+    const result: IRequestsSize = {
+      kind: Kind,
+      request: this.request,
+      response: this.response,
+    };
+    return result;
+  }
+}

package/src/models/ResponseAuthorization.ts

@@ -0,0 +1,104 @@
+export const Kind = 'ARC#ResponseAuthorization';
+
+export interface IResponseAuthorization {
+  kind: 'ARC#ResponseAuthorization';
+  /**
+   * The requested by the authorization server authentication method
+   */
+  method: string;
+  /**
+   * The current state if the authorization process. This is used by NTLM authorization helper.
+   */
+  state?: number;
+  /**
+   * The headers association with the response.
+   */
+  headers?: string;
+  /**
+   * When returned by the server, the value of the challenge.
+   */
+  challengeHeader?: string;
+}
+
+export class ResponseAuthorization {
+  kind = Kind;
+  /**
+   * The requested by the authorization server authentication method
+   */
+  method = 'unknown';
+  /**
+   * The current state if the authorization process. This is used by NTLM authorization helper.
+   */
+  state?: number;
+  /**
+   * The headers association with the response.
+   */
+  headers?: string;
+  /**
+   * When returned by the server, the value of the challenge.
+   */
+  challengeHeader?: string;
+
+  /**
+   * @param input The response authorization definition used to restore the state.
+   */
+  constructor(input?: string|IResponseAuthorization) {
+    let init: IResponseAuthorization;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        method: 'unknown',
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new response authorization clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the object is not an ARC response authorization.
+   */
+  new(init: IResponseAuthorization): void {
+    if (!ResponseAuthorization.isResponseAuthorization(init)) {
+      throw new Error(`Not an ARC response authorization.`);
+    }
+    const { method, state, headers, challengeHeader } = init;
+    this.kind = Kind;
+    this.method = method;
+    this.state = state;
+    this.headers = headers;
+    this.challengeHeader = challengeHeader;
+  }
+
+  /**
+   * Checks whether the input is a definition of a response authorization.
+   */
+  static isResponseAuthorization(input: unknown): boolean {
+    const typed = input as IResponseAuthorization;
+    if (!input || !typed.method) {
+      return false;
+    }
+    return true;
+  }
+
+  toJSON(): IResponseAuthorization {
+    const result: IResponseAuthorization = {
+      kind: Kind,
+      method: this.method,
+    };
+    if (typeof this.state === 'number') {
+      result.state = this.state;
+    }
+    if (this.headers) {
+      result.headers = this.headers;
+    }
+    if (this.challengeHeader) {
+      result.challengeHeader = this.challengeHeader;
+    }
+    return result;
+  }
+}

package/src/models/ResponseRedirect.ts

@@ -0,0 +1,158 @@
+import { IHttpResponse, HttpResponse, Kind as ResponseKind } from './HttpResponse.js';
+import { IRequestTime, RequestTime } from './RequestTime.js';
+import { ResponseRedirect as LegacyRedirect } from './legacy/request/ArcResponse.js';
+
+export const Kind = 'ARC#HttpResponseRedirect';
+
+/**
+ * An information about a redirect
+ */
+export interface IResponseRedirect {
+  kind: string;
+  /**
+   * Redirection response
+   */
+  response: IHttpResponse;
+  /**
+   * Redirection timings, if available.
+   */
+  timings?: IRequestTime;
+  /**
+   * The timestamp when the request was started (before the connection is made)
+   */
+  startTime: number;
+  /**
+   * The timestamp of when the response ended.
+   */
+  endTime: number;
+  /**
+   * The URL the request was redirected to
+   */
+  url: string;
+}
+
+
+export class ResponseRedirect {
+  kind = Kind;
+  /**
+   * Redirection response
+   */
+  response?: HttpResponse;
+  /**
+   * Redirection timings, if available.
+   */
+  timings?: RequestTime;
+  /**
+   * The timestamp when the request was started (before the connection is made)
+   */
+  startTime = 0;
+  /**
+   * The timestamp of when the response ended.
+   */
+  endTime = 0;
+  /**
+   * The URL the request was redirected to
+   */
+  url = '';
+
+  /**
+   * Creates a redirect object from basic values.
+   * @param url The redirect URL
+   * @param response The response object created by the transport
+   * @param startTime The time when the request started
+   * @param endTime The time when the request ended
+   */
+  static fromValues(url: string, response: IHttpResponse, startTime = 0, endTime = 0): ResponseRedirect {
+    return new ResponseRedirect({
+      kind: Kind,
+      url,
+      startTime,
+      endTime,
+      response,
+    });
+  }
+
+  static async fromLegacy(redirect: LegacyRedirect): Promise<ResponseRedirect> {
+    const init: IResponseRedirect = {
+      kind: Kind,
+      endTime: redirect.endTime || 0,
+      startTime: redirect.startTime || 0,
+      url: redirect.url || '',
+      response: {
+        kind: ResponseKind,
+        status: 0,
+      },
+    };
+    if (redirect.response) {
+      const response = await HttpResponse.fromLegacy(redirect.response);
+      init.response = response.toJSON();
+    }
+    if (redirect.timings) {
+      init.timings = new RequestTime(redirect.timings).toJSON();
+    }
+    return new ResponseRedirect(init);
+  }
+
+  /**
+   * @param input The redirect definition used to restore the state.
+   */
+  constructor(input?: string|IResponseRedirect) {
+    let init: IResponseRedirect;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        endTime: 0,
+        startTime: 0,
+        url: '',
+        response: {
+          kind: ResponseKind,
+          status: 0,
+        },
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new redirect clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the object is not an ARC redirect.
+   */
+  new(init: IResponseRedirect): void {
+    const { response, timings, startTime=0, endTime=0, url='', kind=Kind } = init;
+    this.kind = kind;
+    this.startTime = startTime;
+    this.endTime = endTime;
+    this.url = url;
+    this.response = new HttpResponse(response);
+    if (timings) {
+      this.timings = new RequestTime(timings);
+    } else {
+      this.timings = undefined;
+    }
+  }
+
+  toJSON(): IResponseRedirect {
+    const result: IResponseRedirect = {
+      kind: this.kind,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      url: this.url,
+      response: {
+        kind: ResponseKind,
+        status: 0,
+      } as IHttpResponse,
+    };
+    if (this.response) {
+      result.response = this.response.toJSON();
+    }
+    if (this.timings) {
+      result.timings = this.timings.toJSON();
+    }
+    return result;
+  }
+}

package/src/models/RevisionInfo.ts

@@ -0,0 +1,37 @@
+export const Kind = 'ARC#Revision';
+
+/**
+ * The definition of a patch revision.
+ * The revision is created with the `json8-patch` library.
+ */
+export interface IRevisionInfo {
+  /**
+   * The datastore key for this patch object.
+   */
+  id: string;
+  /**
+   * The key of the object which this patch was applied to.
+   */
+  key: string;
+  /**
+   * The kind of the object.
+   */
+  kind: string;
+  /**
+   * The timestamp when the patch was created.
+   */
+  created: number;
+  /**
+   * A flag determining that the revision is inactive.
+   * This may happen when a previous revision has been restored. This revision is then
+   * detached from the latest revision tree. It can be user to move forward in the history though.
+   * 
+   * Implementations! Revisions should be removed from the storage when a new revision has been created
+   * that has diverged from the tree.
+   */
+  deleted?: boolean;
+  /**
+   * The `json8-patch` revisions object used to restore the previous state.
+   */
+  patch: any[];
+}