@api-client/core 0.3.1 → 0.3.4

package/src/models/actions/runnable/DeleteCookieAction.ts

@@ -0,0 +1,113 @@
+import { DeleteCookieConfig } from '../../legacy/actions/Actions.js';
+import { Runnable, IRunnable } from './Runnable.js';
+
+export const Kind = 'ARC#DeleteCookieAction';
+
+export interface IDeleteCookieAction extends IRunnable {
+  kind?: 'ARC#DeleteCookieAction';
+  /**
+   * When set it uses request URL instead of defined URL in the action.
+   */
+  useRequestUrl?: boolean;
+  /**
+   * An URL associated with the cookie.
+   * Only used when `useRequestUrl` is not `true`.
+   * Either `url` or `useRequestUrl` must be set for the action to be considered valid.
+   */
+  url?: string;
+  /**
+   * Name of the cookie to remove.
+   * When not set it removes all cookies.
+   */
+  name?: string;
+}
+
+export class DeleteCookieAction extends Runnable {
+  kind = Kind;
+  /**
+   * When set it uses request URL instead of defined URL in the action.
+   */
+  useRequestUrl?: boolean;
+  /**
+   * An URL associated with the cookie.
+   * Only used when `useRequestUrl` is not `true`.
+   * Either `url` or `useRequestUrl` must be set for the action to be considered valid.
+   */
+  url?: string;
+  /**
+   * Name of the cookie to remove.
+   * When not set it removes all cookies.
+   */
+  name?: string;
+
+  isValid(): boolean {
+    return !!this.useRequestUrl || !!this.url;
+  }
+
+  static fromLegacy(legacy: DeleteCookieConfig): DeleteCookieAction {
+    const init: IDeleteCookieAction = {
+      kind: Kind,
+      name: legacy.name,
+    };
+    if (legacy.url) {
+      init.url = legacy.url;
+    }
+    if (typeof legacy.useRequestUrl === 'boolean') {
+      init.useRequestUrl = legacy.useRequestUrl;
+    }
+    if (legacy.removeAll) {
+      delete init.name;
+    }
+    return new DeleteCookieAction(init);
+  }
+
+  constructor(input?: string | IDeleteCookieAction) {
+    super();
+    let init: IDeleteCookieAction;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: IDeleteCookieAction): void {
+    const { useRequestUrl, url, name } = init;
+    if (typeof useRequestUrl === 'boolean') {
+      this.useRequestUrl = useRequestUrl;
+    } else {
+      this.useRequestUrl = undefined;
+    }
+    if (url) {
+      this.url = url;
+    } else {
+      this.url = undefined;
+    }
+    if (name) {
+      this.name = name;
+    } else {
+      this.name = undefined;
+    }
+  }
+
+  toJSON(): IDeleteCookieAction {
+    const result: IDeleteCookieAction = {
+      kind: Kind,
+    };
+    if (this.url) {
+      result.url = this.url;
+    }
+    if (this.name) {
+      result.name = this.name;
+    }
+    if (typeof this.useRequestUrl === 'boolean') {
+      result.useRequestUrl = this.useRequestUrl;
+    }
+    return result;
+  }
+}

package/src/models/actions/runnable/Runnable.ts

@@ -0,0 +1,9 @@
+export interface IRunnable {
+  kind?: unknown;
+}
+
+export abstract class Runnable {
+  kind: unknown;
+  abstract isValid(): boolean;
+  abstract toJSON(): unknown;
+}

package/src/models/actions/runnable/SetCookieAction.ts

@@ -0,0 +1,216 @@
+import { SetCookieConfig } from '../../legacy/actions/Actions.js';
+import { Runnable, IRunnable } from './Runnable.js';
+import { IDataSource } from '../Condition.js';
+import { RequestDataSourceEnum } from '../Enums.js';
+
+export const Kind = 'ARC#SetCookieAction';
+
+export interface ISetCookieAction extends IRunnable {
+  kind?: 'ARC#SetCookieAction';
+  /**
+   * Name of the cookie
+   */
+  name: string;
+  /**
+   * Source of the cookie value
+   */
+  source: IDataSource;
+  /**
+   * When set it uses request URL instead of defined URL in the action
+   */
+  useRequestUrl?: boolean;
+  /**
+   * An URL associated with the cookie
+   */
+  url?: string;
+  /**
+   * The cookie expiration time
+   */
+  expires?: string;
+  /**
+   * Whether the cookie is host only
+   */
+  hostOnly?: boolean;
+  /**
+   * Whether the cookie is HTTP only
+   */
+  httpOnly?: boolean;
+  /**
+   * Whether the cookie is HTTPS only
+   */
+  secure?: boolean;
+  /**
+   * Whether the cookie is a session cookie
+   */
+  session?: boolean;
+}
+
+export class SetCookieAction extends Runnable {
+  kind = Kind;
+  /**
+   * Name of the cookie
+   */
+  name = '';
+  /**
+   * Source of the cookie value
+   */
+  source: IDataSource = { source: RequestDataSourceEnum.url, };
+  /**
+   * When set it uses request URL instead of defined URL in the action
+   */
+  useRequestUrl?: boolean;
+  /**
+   * An URL associated with the cookie
+   */
+  url?: string;
+  /**
+   * The cookie expiration time
+   */
+  expires?: string;
+  /**
+   * Whether the cookie is host only
+   */
+  hostOnly?: boolean;
+  /**
+   * Whether the cookie is HTTP only
+   */
+  httpOnly?: boolean;
+  /**
+   * Whether the cookie is HTTPS only
+   */
+  secure?: boolean;
+  /**
+   * Whether the cookie is a session cookie
+   */
+  session?: boolean;
+
+  static fromLegacy(legacy: SetCookieConfig): SetCookieAction {
+    const source = ({ ...legacy.source } as unknown) as IDataSource;
+    // @ts-ignore
+    delete source.iterator;
+    // @ts-ignore
+    delete source.iteratorEnabled;
+    const init: ISetCookieAction = {
+      kind: Kind,
+      name: legacy.name,
+      source,
+    };
+    if (legacy.url) {
+      init.url = legacy.url;
+    }
+    if (typeof legacy.useRequestUrl === 'boolean') {
+      init.useRequestUrl = legacy.useRequestUrl;
+    }
+    if (legacy.expires) {
+      init.expires = legacy.expires;
+    }
+    if (typeof legacy.hostOnly === 'boolean') {
+      init.hostOnly = legacy.hostOnly;
+    }
+    if (typeof legacy.httpOnly === 'boolean') {
+      init.httpOnly = legacy.httpOnly;
+    }
+    if (typeof legacy.secure === 'boolean') {
+      init.secure = legacy.secure;
+    }
+    if (typeof legacy.session === 'boolean') {
+      init.session = legacy.session;
+    }
+    return new SetCookieAction(init);
+  }
+
+  constructor(input?: string | ISetCookieAction) {
+    super();
+    let init: ISetCookieAction;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        name: '',
+        source: { source: RequestDataSourceEnum.url, },
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: ISetCookieAction): void {
+    const { source={ source: RequestDataSourceEnum.url, }, name, useRequestUrl, url, expires, hostOnly, httpOnly, secure, session } = init;
+    this.source = source;
+    this.name = name;
+    if (typeof useRequestUrl === 'boolean') {
+      this.useRequestUrl = useRequestUrl;
+    }
+    if (url) {
+      this.url = url;
+    } else {
+      this.url = undefined;
+    }
+    if (expires) {
+      this.expires = expires;
+    } else {
+      this.expires = undefined;
+    }
+    if (typeof hostOnly === 'boolean') {
+      this.hostOnly = hostOnly;
+    } else {
+      this.hostOnly = undefined;
+    }
+    if (typeof httpOnly === 'boolean') {
+      this.httpOnly = httpOnly;
+    } else {
+      this.httpOnly = undefined;
+    }
+    if (typeof secure === 'boolean') {
+      this.secure = secure;
+    } else {
+      this.secure = undefined;
+    }
+    if (typeof session === 'boolean') {
+      this.session = session;
+    } else {
+      this.session = undefined;
+    }
+  }
+
+  toJSON(): ISetCookieAction {
+    const result: ISetCookieAction = {
+      kind: Kind,
+      source: this.source,
+      name: this.name,
+    };
+    if (this.url) {
+      result.url = this.url;
+    }
+    if (this.expires) {
+      result.expires = this.expires;
+    }
+    if (typeof this.useRequestUrl === 'boolean') {
+      result.useRequestUrl = this.useRequestUrl;
+    }
+    if (typeof this.hostOnly === 'boolean') {
+      result.hostOnly = this.hostOnly;
+    }
+    if (typeof this.httpOnly === 'boolean') {
+      result.httpOnly = this.httpOnly;
+    }
+    if (typeof this.secure === 'boolean') {
+      result.secure = this.secure;
+    }
+    if (typeof this.session === 'boolean') {
+      result.session = this.session;
+    }
+    return result;
+  }
+
+  isValid(): boolean {
+    const hasTarget = !!this.useRequestUrl || !!this.url;
+    if (!hasTarget) {
+      return hasTarget;
+    }
+    const { source } = this.source;
+    return !!source;
+  }
+}

package/src/models/actions/runnable/SetVariableAction.ts

@@ -0,0 +1,81 @@
+import { SetVariableConfig } from '../../legacy/actions/Actions.js';
+import { Runnable, IRunnable } from './Runnable.js';
+import { IDataSource } from '../Condition.js';
+import { RequestDataSourceEnum } from '../Enums.js';
+
+export const Kind = 'ARC#SetVariableAction';
+
+export interface ISetVariableAction extends IRunnable {
+  kind?: 'ARC#SetVariableAction';
+  /**
+   * Name of the variable to set
+   */
+  name: string;
+  /**
+   * Source of the cookie value
+   */
+  source: IDataSource;
+}
+
+export class SetVariableAction extends Runnable {
+  kind = Kind;
+  /**
+   * Name of the variable to set
+   */
+  name = '';
+  /**
+   * Source of the cookie value
+   */
+  source: IDataSource = { source: RequestDataSourceEnum.url, };
+
+  static fromLegacy(legacy: SetVariableConfig): SetVariableAction {
+    const source = ({ ...legacy.source } as unknown) as IDataSource;
+    // @ts-ignore
+    delete source.iterator;
+    // @ts-ignore
+    delete source.iteratorEnabled;
+    const init: ISetVariableAction = {
+      kind: Kind,
+      name: legacy.name,
+      source,
+    };
+    return new SetVariableAction(init);
+  }
+
+  constructor(input?: string | ISetVariableAction) {
+    super();
+    let init: ISetVariableAction;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        name: '',
+        source: { source: RequestDataSourceEnum.url, },
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: ISetVariableAction): void {
+    const { source={ source: RequestDataSourceEnum.url, }, name, } = init;
+    this.kind = Kind;
+    this.source = source;
+    this.name = name;
+  }
+
+  toJSON(): ISetVariableAction {
+    const result: ISetVariableAction = {
+      kind: Kind,
+      source: this.source,
+      name: this.name,
+    };
+    return result;
+  }
+
+  isValid(): boolean {
+    return !!this.name && !!this.source;
+  }
+}

package/src/models/legacy/DataExport.ts

@@ -0,0 +1,172 @@
+import { ARCHistoryRequest, ARCSavedRequest, ArcBaseRequest } from './request/ArcRequest.js';
+import { ArcLegacyProject, ARCProject } from './models/ArcLegacyProject.js';
+import { ARCWebsocketUrlHistory, ARCUrlHistory } from './models/UrlHistory.js';
+import { ARCHostRule } from './models/HostRule.js';
+import { ARCVariable } from './models/Variable.js';
+import { ARCAuthData } from './models/AuthData.js';
+import { ARCCertificateIndex, Certificate, ARCRequestCertificate } from './models/ClientCertificate.js';
+import { ARCCookie } from './models/Cookies.js';
+
+/**
+ * @deprecated
+ */
+export interface ExportArcHistoryRequest extends ARCHistoryRequest, ExportEntity {}
+/**
+ * @deprecated
+ */
+export interface ExportArcProjects extends ArcLegacyProject, ExportEntity {}
+/**
+ * @deprecated
+ */
+export interface ExportArcWebsocketUrl extends ARCWebsocketUrlHistory, ExportEntity {}
+/**
+ * @deprecated
+ */
+export interface ExportArcUrlHistory extends ARCUrlHistory, ExportEntity {}
+/**
+ * @deprecated
+ */
+export interface ExportArcHostRule extends ARCHostRule, ExportEntity {}
+/**
+ * @deprecated
+ */
+export interface ExportArcVariable extends ARCVariable, ExportEntity {}
+/**
+ * @deprecated
+ */
+export interface ExportArcAuthData extends ARCAuthData, ExportEntity {}
+/**
+ * @deprecated
+ */
+export interface ExportArcClientCertificateData extends ExportEntity, ARCCertificateIndex {
+  cert?: Certificate | Certificate[];
+  pKey?: Certificate | Certificate[];
+}
+
+/**
+ * @deprecated
+ */
+export interface ExportEntity {
+  /**
+   * The object kind
+   */
+  kind?: string;
+  /**
+   * The original datastore key.
+   * Note that the `_id` and `_rev` are deleted.
+   */
+  key: string;
+}
+
+/**
+ * @deprecated
+ */
+export interface ExportArcSavedRequest extends ARCSavedRequest, ExportEntity {}
+
+/**
+ * @deprecated
+ */
+export interface ArcExportObject {
+  createdAt: string;
+  version: string;
+  kind: string;
+  loadToWorkspace?: boolean;
+  /**
+   * When true the export object was created with a Electron based cookie storage.
+   */
+  electronCookies?: boolean;
+  requests?: ExportArcSavedRequest[];
+  history?: ExportArcHistoryRequest[];
+  projects?: ExportArcProjects[];
+  websocketurlhistory?: ExportArcWebsocketUrl[];
+  urlhistory?: ExportArcUrlHistory[];
+  clientcertificates?: ExportArcClientCertificateData[];
+  cookies?: ExportArcCookie[];
+  hostrules?: ExportArcHostRule[];
+  variables?: ExportArcVariable[];
+  authdata?: ExportArcAuthData[];
+}
+
+/**
+ * @deprecated
+ */
+export interface ExportArcCookie extends ARCCookie {
+  /**
+   * The object kind
+   */
+  kind: string;
+  /**
+   * Datastore ID if a data store other than Electron was used.
+   */
+  key?: string;
+}
+
+/**
+ * @deprecated
+ */
+export interface EncryptionOptions {
+  /**
+   * When set it encrypts the data before export.
+   * This library does not support any particular encryption. It dispatches
+   * `encryptionencode` to request for data encryption.
+   */
+  encrypt?: boolean;
+  /**
+   * Passphrase to use to encode the data.
+   */
+  passphrase?: string;
+}
+
+/**
+ * @deprecated
+ */
+export interface ExportOptions extends EncryptionOptions {
+  /**
+   * Name of the export provider.
+   * ARC supports Google Drive (`drive`) and `file` providers at the moment.
+   */
+  provider: string;
+
+  /**
+   * Adds flag to the export file to skip import table and storing the data
+   * to the data store when opening the file.
+   */
+  skipImport?: boolean;
+
+  /**
+   * Sets the `kind` property of export object.
+   */
+  kind?: string;
+}
+
+/**
+ * @deprecated
+ */
+export interface ExportOptionsInternal extends ExportOptions {
+  /**
+   * The application version used to generate the export
+   */
+  appVersion: string;
+}
+
+export interface ArcExportProcessedData {
+  key: keyof ArcNativeDataExport;
+  data: any[];
+}
+export interface ArcExportClientCertificateData {
+  item: ARCCertificateIndex;
+  data: ARCRequestCertificate;
+}
+
+export interface ArcNativeDataExport {
+  authdata?: boolean | ARCAuthData[];
+  clientcertificates?: boolean;
+  cookies?: boolean | ARCCookie[];
+  history?: boolean | ARCHistoryRequest[];
+  hostrules?: boolean | ARCHostRule[];
+  projects?: boolean | ARCProject[];
+  requests?: boolean | (ARCSavedRequest | ArcBaseRequest | ARCHistoryRequest)[];
+  variables?: boolean | ARCVariable[];
+  websocketurlhistory?: boolean | ARCWebsocketUrlHistory[];
+  urlhistory?: boolean | ARCUrlHistory[];
+}

package/src/models/legacy/Normalizer.ts

@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ARCHistoryRequest, ARCSavedRequest } from './request/ArcRequest.js';
+import { TransformedPayload as LegacyTransformedPayload } from './request/ArcResponse.js';
+import { IRequestAuthorization, Kind as AuthKind } from '../RequestAuthorization.js';
+import { hasBuffer } from '../../lib/transformers/PayloadSerializer.js';
+
+export class Normalizer {
+  static normalizeRequest(request: unknown): ARCHistoryRequest | ARCSavedRequest | undefined {
+    if (!request) {
+      return undefined;
+    }
+    const typed = { ...request as object } as any;
+    if (typed.legacyProject) {
+      const saved = typed as ARCSavedRequest;
+      if (!saved.projects) {
+        saved.projects = [];
+      }
+      saved.projects[saved.projects.length] = typed.legacyProject;
+      delete typed.legacyProject;
+    }
+    const skipKeys = ['_id', '_rev', '_deleted'];
+    Object.keys(typed).forEach((key) => {
+      if (key[0] === '_' && skipKeys.indexOf(key) === -1) {
+        delete typed[key];
+      }
+    });
+    if (!typed.created) {
+      typed.created = Date.now();
+    }
+    if (!typed.updated) {
+      typed.updated = typed.created;
+    }
+    if (!typed.midnight) {
+      const day = new Date(typed.updated);
+      day.setHours(0, 0, 0, 0);
+      typed.midnight = day.getTime();
+    }
+
+    if (!typed.type) {
+      if (typed.name) {
+        typed.type = 'saved';
+      } else {
+        typed.type = 'history';
+      }
+    } else if (typed.type === 'drive' || typed.type === 'google-drive') {
+      typed.type = 'saved';
+    }
+    if (typed.type === 'history' && !typed._id) {
+      typed._id = Normalizer.generateHistoryId(typed);
+    }
+
+    return Normalizer.normalizeAuthorization(typed as ARCHistoryRequest | ARCSavedRequest);
+  }
+
+  static generateHistoryId(request: ARCHistoryRequest): string {
+    const { method, url } = request;
+    const d = new Date();
+    d.setHours(0, 0, 0, 0);
+    const time = d.getTime();
+    const encUrl = encodeURIComponent(url);
+    return `${time}/${encUrl}/${method}`;
+  }
+
+  static normalizeAuthorization<T>(request: T): T {
+    const typed = request as any;
+    const { auth = {}, authType } = typed;
+    if (!authType) {
+      return request;
+    }
+    const requestAuth: IRequestAuthorization = {
+      config: auth,
+      enabled: true,
+      type: authType,
+      valid: true,
+      kind: AuthKind,
+    };
+    const copy = { ...typed };
+    copy.authorization = [requestAuth];
+    delete copy.auth;
+    delete copy.authType;
+    return copy;
+  }
+
+  /**
+   * Transforms the `TransformedPayload` object to its original data type.
+   */
+  static restoreTransformedPayload(body: string | ArrayBuffer | Buffer | LegacyTransformedPayload): string | Buffer | ArrayBuffer | undefined {
+    if (!body) {
+      return body;
+    }
+    if (typeof body === 'string') {
+      return body;
+    }
+    if (hasBuffer && body instanceof Buffer) {
+      return body;
+    }
+    if (body instanceof ArrayBuffer) {
+      return body;
+    }
+    const typed = body as LegacyTransformedPayload;
+    if (typed.type === 'ArrayBuffer' || (typed.type === 'Buffer' && !hasBuffer)) {
+      const { buffer } = new Uint8Array(typed.data);
+      return buffer;
+    }
+    if (hasBuffer && typed.type === 'Buffer') {
+      return Buffer.from(typed.data);
+    }
+    return undefined;
+  }
+}