@api-client/core 0.3.3 → 0.3.4

package/src/models/transformers/ArcPouchTransformer.ts

@@ -0,0 +1,184 @@
+import v4 from '../../lib/uuid.js';
+import { BaseTransformer, dataValue } from './BaseTransformer.js';
+import {
+  ArcExportObject,
+  ExportArcProjects,
+  ExportArcSavedRequest,
+  ExportArcHistoryRequest,
+  ExportArcClientCertificateData,
+  ExportArcVariable,
+} from '../legacy/DataExport.js';
+
+/**
+ * Updates `updated` property and ensures `created` property
+ * @param item An item to updated
+ * @returns Shallow copy of the passed item.
+ */
+export function updateItemTimings<T>(item: T): T {
+  const data = { ...item } as any;
+  if (!data.updated || Number.isNaN(data.updated)) {
+    data.updated = Date.now();
+  }
+  if (!data.created) {
+    data.created = data.updated;
+  }
+  return data;
+}
+
+/**
+ * Transforms data exported by the PouchDB system (legacy)
+ */
+export class ArcPouchTransformer extends BaseTransformer {
+  /**
+   * Transforms PouchDB ARC export object based into current export data model.
+   *
+   * @returns New data model object.
+   */
+  async transform(): Promise<ArcExportObject> {
+    const data = /** @type ArcExportObject */ ({ ...this[dataValue] });
+    if (data.projects && data.projects.length) {
+      data.projects = this.transformProjects(data.projects);
+    }
+    if (data.requests && data.requests.length) {
+      data.requests = this.transformRequests(data.requests, data.projects);
+    }
+    if (data.projects && data.projects.length) {
+      (data.projects as any[]).forEach((item) => {
+        // @ts-ignore
+        delete item._referenceId;
+      });
+    }
+    if (data.history && data.history.length) {
+      data.history = this.transformHistory(data.history);
+    }
+    const socketUrls = /** @type ExportArcWebsocketUrl[] */ (data['websocket-url-history'] || data.websocketurlhistory);
+    if (socketUrls && socketUrls.length) {
+      data.websocketurlhistory = socketUrls;
+    }
+    const urls = /** @type ExportArcUrlHistory[] */ (data['url-history'] || data.urlhistory);
+    if (urls && urls.length) {
+      data.urlhistory = urls;
+    }
+    const authData = /** @type ExportArcAuthData[] */ (data['auth-data'] || data.authdata);
+    if (authData && authData.length) {
+      data.authdata = authData;
+    }
+    const hostRules = /** @type ExportArcHostRule[] */ (data['host-rules'] || data.hostrules);
+    if (hostRules && hostRules.length) {
+      data.hostrules = hostRules;
+    }
+    if (Array.isArray(data.variables) && data.variables.length) {
+      data.variables = this.transformVariables(data.variables);
+    }
+    if (!data.loadToWorkspace) {
+      data.kind = 'ARC#Import';
+    }
+    const ccs = /** @type ExportArcClientCertificateData[] */ (data['client-certificates'] || data.clientcertificates);
+    if (ccs && ccs.length) {
+      data.clientcertificates = this.transformClientCertificates(ccs);
+    }
+    return data;
+  }
+
+  /**
+   * Transforms the projects array.
+   *
+   * @param projects Projects list to upgrade
+   * @return Processed list
+   */
+  transformProjects(projects: ExportArcProjects[]): ExportArcProjects[] {
+    return projects.map((item) => {
+      const project = { ...item };
+      if (!project.key) {
+        project.key = v4();
+      }
+      return updateItemTimings(project);
+    });
+  }
+
+  /**
+   * @param requests The list of requests to process
+   * @param projects List of projects
+   * @returns Processed requests.
+   */
+  transformRequests(requests: ExportArcSavedRequest[], projects: ExportArcProjects[]=[]): ExportArcSavedRequest[] {
+    return requests.map((object) => {
+      const request = { ...object };
+      if (!request.key) {
+        // @ts-ignore
+        const refId = request._referenceLegacyProject || request.legacyProject;
+        request.key = this.generateRequestId(request, refId);
+      }
+      // @ts-ignore
+      const refId = request._referenceLegacyProject || request.legacyProject;
+      if (refId) {
+        // @ts-ignore
+        delete request._referenceLegacyProject;
+        // @ts-ignore
+        delete request.legacyProject;
+        // @ts-ignore
+        const project = projects.find((item) => item.key === refId || item._referenceId === refId);
+        if (project) {
+          this.addProjectReference(request, project.key);
+          this.addRequestReference(project, request.key);
+        }
+      }
+      request.name = request.name || 'unnamed';
+      request.url = request.url || 'http://';
+      request.method = request.method || 'GET';
+      request.headers = request.headers || '';
+      request.payload = request.payload || '';
+      request.kind = 'ARC#HttpRequest';
+      return updateItemTimings(request);
+    });
+  }
+
+  transformHistory(history: ExportArcHistoryRequest[]): ExportArcHistoryRequest[] {
+    return history.map((object) => {
+      const item = { ...object };
+      const result = updateItemTimings(item);
+      result.url = item.url || 'http://';
+      result.method = item.method || 'GET';
+      result.headers = item.headers || '';
+      result.payload = item.payload || '';
+      if (!result.key) {
+        result.key = this.generateHistoryId(item.created, item);
+      }
+      return result;
+    });
+  }
+
+  /**
+   * Transforms ARC's client certificate export object into intermediate structure
+   * used by the import panel.
+   *
+   * @param items [description]
+   * @return A list of certificates to import. In each element
+   * first item is the index data and the second is the certificates data.
+   */
+  transformClientCertificates(items: ExportArcClientCertificateData[]): ExportArcClientCertificateData[] {
+    const result: ExportArcClientCertificateData[] = [];
+    items.forEach((item) => {
+      if (item.kind !== 'ARC#ClientCertificate') {
+        return;
+      }
+      const data = updateItemTimings(item);
+      result[result.length] = data;
+    });
+    return result;
+  }
+
+  /**
+   * Maps the old `variable` property to the new `name` property.
+   */
+  transformVariables(variables: ExportArcVariable[]): ExportArcVariable[] {
+    return variables.map((item) => {
+      const variable = { ...item };
+      if (variable.variable && !variable.name) {
+        variable.name = variable.variable;
+        delete variable.variable;
+      }
+      return variable;
+    });
+  }
+}

package/src/models/transformers/BaseTransformer.ts

@@ -0,0 +1,116 @@
+import {
+  ExportArcSavedRequest,
+  ExportArcHistoryRequest,
+  ExportArcProjects,
+} from '../legacy/DataExport.js';
+
+export const dataValue = Symbol('dataValue');
+
+/**
+ * Base class for all transformers.
+ * Has common functions for the transformers.
+ */
+export class BaseTransformer {
+  [dataValue]: any;
+  /**
+   * @param data Data to be transformed.
+   */
+  constructor(data: any) {
+    this[dataValue] = data;
+  }
+
+  /**
+   * Generates request's datastore ID value.
+   *
+   * @param item A request object property.
+   * @param projectId If set it adds project information to the ID.
+   * @return Request ID value.
+   */
+  generateRequestId(item: ExportArcSavedRequest | ExportArcHistoryRequest, projectId?: string): string {
+    const assumed = item as ExportArcSavedRequest;
+    const name = (assumed.name || 'unknown name').toLowerCase();
+    const url = (item.url || 'https://').toLowerCase();
+    const method = (item.method || 'GET').toLowerCase();
+
+    const eName = encodeURIComponent(name);
+    const eUrl = encodeURIComponent(url);
+
+    let id = `${eName}/${eUrl}/${method}`;
+    if (projectId) {
+      id += `/${projectId}`;
+    }
+    return id;
+  }
+
+  /**
+   * Computes history item ID
+   *
+   * @param timestamp The timestamp to use
+   * @param item History item
+   * @return Datastore ID
+   */
+  generateHistoryId(timestamp=Date.now(), item: ExportArcHistoryRequest): string {
+    const url = item.url.toLowerCase();
+    const method = item.method.toLowerCase();
+    let today;
+    try {
+      today = this.getDayToday(timestamp);
+    } catch (e) {
+      today = this.getDayToday(Date.now());
+    }
+    return `${today}/${encodeURIComponent(url)}/${method}`;
+  }
+
+  /**
+   * Sets hours, minutes, seconds and ms to 0 and returns timestamp.
+   *
+   * @param timestamp Day's timestamp.
+   * @returns Timestamp to the day.
+   */
+  getDayToday(timestamp: number): number {
+    const d = new Date(timestamp);
+    const tCheck = d.getTime();
+    if (Number.isNaN(tCheck)) {
+      throw new Error(`Invalid timestamp: ${  timestamp}`);
+    }
+    d.setMilliseconds(0);
+    d.setSeconds(0);
+    d.setMinutes(0);
+    d.setHours(0);
+    return d.getTime();
+  }
+
+  /**
+   * Adds project reference to a request object.
+   * @param request Request object to alter
+   * @param id Project id
+   */
+  addProjectReference(request: ExportArcSavedRequest, id?: string): void {
+    if (!id) {
+      return;
+    }
+    if (!request.projects) {
+      request.projects = [];
+    }
+    if (request.projects.indexOf(id) === -1) {
+      request.projects.push(id);
+    }
+  }
+
+  /**
+   * Adds request reference to a project object.
+   * @param project Project object to alter
+   * @param id Request id
+   */
+  addRequestReference(project: ExportArcProjects, id: string): void {
+    if (!id) {
+      return;
+    }
+    if (!project.requests) {
+      project.requests = [];
+    }
+    if (project.requests.indexOf(id) === -1) {
+      project.requests.push(id);
+    }
+  }
+}

package/src/models/transformers/ImportUtils.ts

@@ -0,0 +1,141 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-plusplus */
+/**
+ * User can export single request in ARC. In this case ARC opens new tab
+ * rather actually imports the data. This function tests if this is the case.
+ * @param data Normalized import data
+ */
+export function isSingleRequest(data: any): boolean {
+  if (!data.requests || !data.requests.length) {
+    return false;
+  }
+  if (data.requests.length !== 1) {
+    return false;
+  }
+  if (data.projects && data.projects.length === 0) {
+    delete data.projects;
+  }
+  if (data.history && data.history.length === 0) {
+    delete data.history;
+  }
+  if (Object.keys(data).length === 4) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * First export / import system had single request data only. This function checks if given
+ * file is from this ancient system.
+ *
+ * @param object Decoded JSON data.
+ */
+export function isOldImport(object: any): boolean {
+  if (!(object.projects || object.requests || object.history)) {
+    if ('headers' in object && 'url' in object && 'method' in object) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Checks if the passed argument is an Object.
+ *
+ * @param object A value to test.
+ */
+export function isObject(object: any): boolean {
+  return (
+    object !== null &&
+    typeof object === 'object' &&
+    Object.prototype.toString.call(object) === '[object Object]'
+  );
+}
+
+/**
+ * Tests if data is a Postman file data
+ * @param data Parsed file.
+ */
+export function isPostman(data: any): boolean {
+  if (data.version && data.collections) {
+    return true;
+  }
+  if (data.info && data.info.schema) {
+    return true;
+  }
+  if (data.folders && data.requests) {
+    return true;
+  }
+  if (data._postman_variable_scope) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Checks if passed `object` is the ARC export data.
+ *
+ * @param object A parsed JSON data.
+ * @return true if the passed object is an ARC file.
+ */
+export function isArcFile(object: any): boolean {
+  if (!object || !isObject(object)) {
+    return false;
+  }
+  if (object.kind) {
+    if (object.kind.indexOf('ARC#') === 0) {
+      return true;
+    }
+  }
+  // Old export system does not have kind property.
+  // Have to check if it has required properties.
+  const arcEntries = [
+    'projects',
+    'requests',
+    'history',
+    'url-history',
+    'websocket-url-history',
+    'variables',
+    'headers-sets',
+    'auth-data',
+    'cookies',
+  ];
+  for (let i = 0, len = arcEntries.length; i < len; i++) {
+    if (arcEntries[i] in object) {
+      return true;
+    }
+  }
+  if (isOldImport(object)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Parses file data with JSON parser and throws an error if not a JSON.
+ * If the passed `data` is JS object it does nothing.
+ *
+ * @param {string|object} data File content
+ * @return {object} Parsed data.
+ */
+export function prepareImportObject(data: any): any {
+  if (typeof data === 'string') {
+    try {
+      data = JSON.parse(data);
+    } catch (e) {
+      const err = e as Error;
+      throw new Error(`Unable to read the file. Not a JSON: ${err.message}`);
+    }
+  }
+  return data;
+}
+
+/**
+ * Returns a promise resolved after a timeout.
+ * @param timeout A timeout to wait.
+ */
+export async function aTimeout(timeout=0): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeout);
+  });
+}

package/src/models/transformers/LegacyDataExportToApiProject.ts

@@ -0,0 +1,76 @@
+import { HttpProject } from '../HttpProject.js';
+import { ArcExportObject, ExportArcSavedRequest, ExportArcProjects, ExportArcVariable } from '../legacy/DataExport.js';
+import { ARCProject } from '../legacy/models/ArcLegacyProject.js';
+import { ARCSavedRequest } from '../legacy/request/ArcRequest.js';
+import { Environment, IEnvironment } from '../Environment.js';
+
+/**
+ * A class that transforms legacy export objects into API projects.
+ * Note, this only cares about the HttpProject data. All other data are discarded.
+ */
+export class LegacyDataExportToApiProject {
+  async readProjects(data: ArcExportObject): Promise<HttpProject[]> {
+    const result: HttpProject[] = [];
+    const { variables } = data;
+    const projects = this.mapProjects(data.projects);
+    const requests = this.mapRequests(data.requests);
+    if (!projects.length || !requests.length) {
+      return result;
+    }
+    const environments = this.createEnvironments(variables);
+    const ps = projects.map(async (oldProject) => {
+      const project = await HttpProject.fromLegacy(oldProject, [...requests]);
+      environments.forEach(e => project.addEnvironment(e));
+      result.push(project);
+    });
+    await Promise.all(ps);
+    return result;
+  }
+
+  mapRequests(items?: ExportArcSavedRequest[]): ARCSavedRequest[] {
+    if (!Array.isArray(items)) {
+      return [];
+    }
+    return items.map((item) => {
+      const cp = { ...item } as ARCSavedRequest;
+      cp._id = item.key;
+      // @ts-ignore
+      delete cp.key;
+      return cp;
+    });
+  }
+
+  mapProjects(items?: ExportArcProjects[]): ARCProject[] {
+    if (!Array.isArray(items)) {
+      return [];
+    }
+    return items.map((item) => {
+      const cp = { ...item } as ARCProject;
+      cp._id = item.key;
+      // @ts-ignore
+      delete cp.key;
+      return cp;
+    });
+  }
+
+  createEnvironments(vars?: ExportArcVariable[]): IEnvironment[] {
+    if (!Array.isArray(vars) || !vars.length) {
+      return [];
+    }
+    const tmp: Record<string, ExportArcVariable[]> = {};
+    vars.forEach((variable) => {
+      const { environment='default' } = variable;
+      if (!tmp[environment]) {
+        tmp[environment] = [];
+      }
+      tmp[environment].push(variable);
+    });
+    const result:IEnvironment[] = [];
+    Object.keys(tmp).forEach((name) => {
+      const envVars = tmp[name];
+      const environment = Environment.fromLegacyVariables(name, envVars);
+      result.push(environment.toJSON());
+    });
+    return result;
+  }
+}