@api-client/core 0.3.1 → 0.3.4

package/src/models/transformers/LegacyExportProcessor.ts

@@ -0,0 +1,252 @@
+import {
+  ExportOptionsInternal,
+  ArcExportObject,
+  ExportArcSavedRequest,
+  ExportArcHistoryRequest,
+  ExportArcProjects,
+  ExportArcWebsocketUrl,
+  ExportArcUrlHistory,
+  ExportArcHostRule,
+  ExportArcVariable,
+  ExportArcAuthData,
+  ArcExportProcessedData,
+  ArcNativeDataExport,
+  ArcExportClientCertificateData,
+  ExportArcClientCertificateData,
+} from '../legacy/DataExport.js';
+import { ARCProject } from '../legacy/models/ArcLegacyProject.js';
+import { ARCAuthData } from '../legacy/models/AuthData.js';
+import { ARCWebsocketUrlHistory, ARCUrlHistory } from '../legacy/models/UrlHistory.js';
+import { ARCHostRule } from '../legacy/models/HostRule.js';
+import { ARCVariable } from '../legacy/models/Variable.js';
+import { ARCHistoryRequest, ARCSavedRequest } from '../legacy/request/ArcRequest.js';
+
+/**
+ * A class that processes ARC data to create a standard export object.
+ */
+export class LegacyExportProcessor {
+  electronCookies: boolean;
+  /**
+   * @param electronCookies True if the cookies were read from electron storage
+   */
+  constructor(electronCookies: boolean) {
+    this.electronCookies = electronCookies;
+  }
+
+  /**
+   * Creates an export object for the data.
+   *
+   * @param exportData
+   * @param options Export configuration object
+   * @returns ARC export object declaration.
+   */
+  createExportObject(exportData: ArcExportProcessedData[], options: ExportOptionsInternal): ArcExportObject {
+    const result: ArcExportObject = {
+      createdAt: new Date().toISOString(),
+      version: options.appVersion,
+      kind: options.kind || '',
+      electronCookies: this.electronCookies,
+    };
+    if (options.skipImport) {
+      result.loadToWorkspace = true;
+    }
+    exportData.forEach(({ key, data }) => {
+      if (!data) {
+        return;
+      }
+      result[key] = this.prepareItem(key, data);
+    });
+    return result;
+  }
+
+  prepareItem(key: keyof ArcNativeDataExport, values: any[]): any[]|undefined {
+    switch (key) {
+      case 'authdata': return this.prepareAuthData(values);
+      case 'clientcertificates': return this.prepareClientCertData(values);
+      case 'cookies': return this.prepareCookieData(values);
+      case 'history': return this.prepareHistoryDataList(values);
+      case 'hostrules': return this.prepareHostRulesData(values);
+      case 'projects': return this.prepareProjectsList(values);
+      case 'requests': return this.prepareRequestsList(values);
+      case 'urlhistory': return this.prepareUrlHistoryData(values);
+      case 'variables': return this.prepareVariablesData(values);
+      case 'websocketurlhistory': return this.prepareWsUrlHistoryData(values);
+      default: return undefined;
+    }
+  }
+
+  /**
+   * Maps list of request to the export object.
+   * @param requests The list of requests to process.
+   */
+  prepareRequestsList(requests: ARCSavedRequest[]): ExportArcSavedRequest[] {
+    const result = requests.map((item) => {
+      const request = { ...item } as ExportArcSavedRequest;
+      // @ts-ignore
+      if (item.legacyProject) {
+        if (item.projects) {
+          // @ts-ignore
+          request.projects[item.projects.length] = item.legacyProject;
+        } else {
+          // @ts-ignore
+          request.projects = [request.legacyProject];
+        }
+        // @ts-ignore
+        delete request.legacyProject;
+      }
+      request.kind = 'ARC#HttpRequest';
+      request.key = item._id as string;
+      delete request._rev;
+      delete request._id;
+      return request;
+    });
+    return result;
+  }
+
+  prepareProjectsList(projects: ARCProject[]): ExportArcProjects[] {
+    return projects.map((item) => {
+      const project = { ...item } as ExportArcProjects;
+      project.kind = 'ARC#ProjectData';
+      project.key = item._id as string;
+      // @ts-ignore
+      delete project._rev;
+      // @ts-ignore
+      delete project._id;
+      return project;
+    });
+  }
+
+  /**
+   * @param history The list of requests to process.
+   */
+  prepareHistoryDataList(history: ARCHistoryRequest[]): ExportArcHistoryRequest[] {
+    const result = history.map((item) => {
+      const request = { ...item } as ExportArcHistoryRequest;
+      request.kind = 'ARC#HttpRequest';
+      request.key = item._id as string;
+      // @ts-ignore
+      delete request._rev;
+      // @ts-ignore
+      delete request._id;
+      return request;
+    });
+    return result;
+  }
+
+  prepareWsUrlHistoryData(data: ARCWebsocketUrlHistory[]): ExportArcWebsocketUrl[] {
+    const result = data.map((item) => {
+      const history = { ...item } as ExportArcWebsocketUrl;
+      history.key = item._id as string;
+      // @ts-ignore
+      delete history._rev;
+      // @ts-ignore
+      delete history._id;
+      history.kind = 'ARC#WebsocketHistoryData';
+      return history;
+    });
+    return result;
+  }
+
+  prepareUrlHistoryData(data: ARCUrlHistory[]): ExportArcUrlHistory[] {
+    const result = data.map((item) => {
+      const history = { ...item } as ExportArcUrlHistory;
+      history.key = item._id as string;
+      // @ts-ignore
+      delete history._rev;
+      // @ts-ignore
+      delete history._id;
+      history.kind = 'ARC#UrlHistoryData';
+      return history;
+    });
+    return result;
+  }
+
+  prepareVariablesData(data: ARCVariable[]): ExportArcVariable[] {
+    const result: ExportArcVariable[] = [];
+    data.forEach((item) => {
+      const value = { ...item } as ExportArcVariable;
+      if (!value.environment) {
+        // PouchDB creates some views in the main datastore and it is added to
+        // get all docs function without any reason. It should be eliminated
+        return;
+      }
+      if (value.variable) {
+        value.name = value.variable;
+        delete value.variable;
+      }
+      value.key = item._id as string;
+      // @ts-ignore
+      delete value._rev;
+      // @ts-ignore
+      delete value._id;
+      value.kind = 'ARC#Variable';
+      result.push(value);
+    });
+    return result;
+  }
+
+  prepareAuthData(authData: ARCAuthData[]): ExportArcAuthData[] {
+    const result = authData.map((item) => {
+      const value = item as ExportArcAuthData;
+      value.key = item._id as string;
+      // @ts-ignore
+      delete value._rev;
+      // @ts-ignore
+      delete value._id;
+      value.kind = 'ARC#AuthData';
+      return value;
+    });
+    return result;
+  }
+
+  prepareCookieData(cookies: any[]): any[] {
+    const isElectron = this.electronCookies;
+    const result = cookies.map((item) => {
+      const value = item as any;
+      if (!isElectron) {
+        value.key = item._id as string;
+        // @ts-ignore
+        delete value._rev;
+        // @ts-ignore
+        delete value._id;
+      }
+      value.kind = 'ARC#Cookie';
+      return item;
+    });
+    return result;
+  }
+
+  /**
+   * @param {ARCHostRule[]} hostRules
+   * @return {ExportArcHostRule[]}
+   */
+  prepareHostRulesData(hostRules: ARCHostRule[]): ExportArcHostRule[] {
+    return hostRules.map((item) => {
+      const value = item as ExportArcHostRule;
+      value.key = value._id as string;
+      // @ts-ignore
+      delete value._rev;
+      // @ts-ignore
+      delete value._id;
+      value.kind = 'ARC#HostRule';
+      return value;
+    });
+  }
+
+  prepareClientCertData(items: ArcExportClientCertificateData[]): ExportArcClientCertificateData[] {
+    return items.map(({ item, data }) => {
+      const value = item as ExportArcClientCertificateData;
+      value.key = item._id as string;
+      // @ts-ignore
+      delete value._rev;
+      // @ts-ignore
+      delete value._id;
+      value.kind = 'ARC#ClientCertificate';
+      value.cert = data.cert;
+      if (data.key) {
+        value.pKey = data.key;
+      }
+      return value;
+    });
+  }
+}

package/src/models/transformers/PostmanBackupTransformer.ts

@@ -0,0 +1,306 @@
+/* eslint-disable no-unused-vars */
+import { PostmanTransformer, dataValue, paramValue } from './PostmanTransformer.js';
+import { HttpProject, IHttpProject, Kind as ProjectKind } from '../HttpProject.js';
+import { ProjectFolder } from '../ProjectFolder.js';
+import { ProjectRequest } from '../ProjectRequest.js';
+import { IMultipartBody } from '../../lib/transformers/PayloadSerializer.js';
+import { Environment } from '../Environment.js';
+
+interface PostmanBackupV1 {
+  version: number;
+  collections?: PostmanCollection[];
+  environments?: PostmanEnvironment[];
+  headerPresets?: PostmanHeadersPreset[];
+  globals?: PostmanVariable[];
+}
+
+interface PostmanCollection {
+  id: string;
+  name: string;
+  description: string;
+  order: string[];
+  folders?: PostmanFolder[];
+  folders_order: string[];
+  timestamp: number;
+  synced: boolean;
+  remote_id: number;
+  owner: number;
+  sharedWithTeam: boolean;
+  subscribed: boolean;
+  remoteLink: string;
+  remoteLinkUpdatedAt: string;
+  public: boolean;
+  createdAt: number;
+  updatedAt: number;
+  write: boolean;
+  published: boolean;
+  favorite: boolean;
+  requests: PostmanRequest[];
+  variables?: PostmanVariable[];
+}
+interface PostmanRequest {
+  id: string;
+  name: string;
+  time: number;
+  headers: string;
+  url: string;
+  queryParams: PostmanParameter[];
+  headerData: PostmanParameter[];
+  pathVariableData: PostmanParameter[];
+  preRequestScript: string;
+  method: string;
+  collectionId: string;
+  data: string|PostmanBodyParam[]|null;
+  dataMode: string;
+  description: string;
+  descriptionFormat: string;
+  version: number;
+  tests: string;
+  currentHelper: string;
+  rawModeData?: string;
+}
+interface PostmanEnvironment {
+  id: string;
+  name: string;
+  timestamp: number;
+  synced: boolean;
+  values: PostmanParameter[];
+}
+interface PostmanHeadersPreset {
+  id: string;
+  name: string;
+  headers: PostmanHeader[];
+  timestamp: number;
+}
+
+interface PostmanVariable {
+  disabled: boolean;
+  key: string;
+  value: string;
+}
+
+interface PostmanParameter {
+  enabled: boolean;
+  key: string;
+  value: string;
+  type: string;
+}
+interface PostmanBodyParam extends PostmanParameter {
+  description: string;
+}
+interface PostmanHeader extends PostmanParameter {
+  description: string;
+  warning: string;
+}
+interface PostmanFolder {
+  name: string;
+  description: string;
+  collectionId: string;
+  collection: string;
+  order: string[];
+  owner: number;
+  folders_order: string[];
+  createdAt: number;
+  updatedAt: number;
+  id: string;
+  collection_id: string;
+}
+
+/**
+ * Transformer for Postman backup file.
+ */
+export class PostmanBackupTransformer extends PostmanTransformer {
+  async transform(): Promise<HttpProject[]> {
+    const raw = this[dataValue] as PostmanBackupV1;
+    const result: HttpProject[] = [];
+    if (!raw.collections) {
+      return result;
+    }
+    for (const collection of raw.collections) {
+      const project = await this.transformCollection(collection);
+      result.push(project);
+    }
+    return result;
+  }
+
+  async transformCollection(collection: PostmanCollection): Promise<HttpProject> {
+    const { folders_order, order } = collection;
+    const project = this.createProject(collection);
+    this.setProjectVariables(project, collection);
+    if (Array.isArray(folders_order)) {
+      for (const id of folders_order) {
+        await this.addFolder(project, collection, id);
+      }
+    }
+    if (Array.isArray(order)) {
+      for (const id of order) {
+        await this.addRequest(project, collection, id);
+      }
+    }
+    return project;
+  }
+
+  createProject(collection: PostmanCollection): HttpProject {
+    const { description, id, name } = collection;
+    const init: IHttpProject = {
+      kind: ProjectKind,
+      definitions: {},
+      environments: [],
+      info: {
+        kind: 'ARC#Thing',
+        name,
+      },
+      items: [],
+      key: id,
+    };
+    if (description) {
+      init.info.description = description;
+    }
+    const project = new HttpProject(init);
+    return project;
+  }
+
+  setProjectVariables(project: HttpProject, collection: PostmanCollection): void {
+    const { variables } = collection;
+    if (!Array.isArray(variables)) {
+      return;
+    }
+    const env = Environment.fromName('Default');
+    project.addEnvironment(env);
+    variables.forEach((param) => {
+      const { disabled=false, key, value } = param;
+
+      const parsed = this.ensureVariablesSyntax(value) as string;
+      const created = env.addVariable(key, parsed);
+      created.enabled = !disabled;
+    });
+  }
+
+  async addFolder(current: HttpProject | ProjectFolder, collection: PostmanCollection, id: string): Promise<void> {
+    const { folders } = collection;
+    const folder = folders?.find(i => i.id === id);
+    if (!folder) {
+      this.addLog('warning', `Folder ${id} not found in the collection.`);
+      return;
+    }
+    const created = current.addFolder(folder.name);
+    if (folder.description) {
+      created.info.description = folder.description;
+    }
+    if (Array.isArray(folder.folders_order)) {
+      for (const id of folder.folders_order) {
+        await this.addFolder(created, collection, id);
+      }
+    }
+    if (Array.isArray(folder.order)) {
+      for (const id of folder.order) {
+        await this.addRequest(created, collection, id);
+      }
+    }
+  }
+
+  async addRequest(current: HttpProject | ProjectFolder, collection: PostmanCollection, id: string): Promise<void> {
+    const { requests } = collection;
+    const request = requests?.find(i => i.id === id);
+    if (!request) {
+      this.addLog('warning', `Request ${id} not found in the collection.`);
+      return;
+    }
+
+    const name = request.name || 'unnamed';
+    let url = request.url || 'http://';
+    url = this.ensureVariablesSyntax(url) as string;
+    let method = request.method || 'GET';
+    method = this.ensureVariablesSyntax(method) as string;
+    let headers = request.headers || '';
+    headers = this.ensureVariablesSyntax(headers) as string;
+
+    let createdTime = Number(request.time);
+    if (Number.isNaN(createdTime)) {
+      createdTime = Date.now();
+    }
+
+    const created = current.addRequest(url);
+    created.info.name = name;
+    if (request.description) {
+      created.info.description = request.description;
+    }
+    created.expects.method = method;
+    if (headers) {
+      created.expects.headers = headers;
+    }
+
+    await this.addRequestBody(created, request);
+  }
+
+  async addRequestBody(created: ProjectRequest, request: PostmanRequest): Promise<void> {
+    switch (request.dataMode) {
+      case 'urlencoded': return this.addUrlencodedBody(created, request);
+      case 'binary': return this.addBinaryBody(created, request);
+      case 'params': return this.addParamsBody(created, request);
+      case 'raw': return this.addRawBody(created, request);
+    }
+  }
+
+  async addUrlencodedBody(created: ProjectRequest, request: PostmanRequest): Promise<void> {
+    if (!Array.isArray(request.data)) {
+      return;
+    }
+    const data = request.data as PostmanBodyParam[];
+    const body =  data.map(i => `${paramValue(i.key)}=${paramValue(i.value)}`).join('&');
+    await created.expects.writePayload(body);
+  }
+
+  async addBinaryBody(created: ProjectRequest, request: PostmanRequest): Promise<void> {
+    // Postman sets the `rawModeData` property with the path to the file
+    // but not data itself. Because of that this method is a stub that can be extended
+    // by particular implementation (like node, CLI).
+  }
+
+  async addParamsBody(created: ProjectRequest, request: PostmanRequest): Promise<void> {
+    // "params" is Postman's FormData implementation.
+    // Similarly to the `addBinaryBody()`, file parts carry no data.
+    // Override the `addParamsFilePart()` to handle file read from the filesystem.
+    if (!Array.isArray(request.data)) {
+      return;
+    }
+    const data = request.data as PostmanBodyParam[];
+    const body: IMultipartBody[] = [];
+    for (const part of data) {
+      if (part.type === 'text') {
+        await this.addParamsTextPart(body, part);
+      } else if (part.type === 'file') {
+        await this.addParamsFilePart(body, part);
+      }
+    }
+    created.expects.payload = {
+      type: 'formdata',
+      data: body,
+    };
+  }
+
+  async addParamsTextPart(body: IMultipartBody[], param: PostmanBodyParam): Promise<void> {
+    const { key, value, enabled=true } = param;
+    body.push({
+      isFile: false,
+      name: key,
+      value,
+      enabled,
+    });
+  }
+
+  async addParamsFilePart(body: IMultipartBody[], param: PostmanBodyParam): Promise<void> {
+    // Postman sets the `value` property with the path to the file
+    // but not data itself. Because of that this method is a stub that can be extended
+    // by particular implementation (like node, CLI).
+  }
+
+  async addRawBody(created: ProjectRequest, request: PostmanRequest): Promise<void> {
+    const { rawModeData, data } = request;
+    if (rawModeData && typeof rawModeData === 'string') {
+      await created.expects.writePayload(rawModeData);
+    } else if (data && typeof data === 'string') {
+      await created.expects.writePayload(data);
+    }
+  }
+}

package/src/models/transformers/PostmanDataTransformer.ts

@@ -0,0 +1,50 @@
+import { PostmanBackupTransformer } from './PostmanBackupTransformer.js';
+
+import { PostmanV2Transformer } from './PostmanV2Transformer.js';
+import { PostmanV21Transformer } from './PostmanV21Transformer.js';
+import { PostmanTransformer } from './PostmanTransformer.js';
+import { HttpProject } from '../HttpProject.js';
+
+/**
+ * Transforms Postman collections (v2 and v2.1) and Postman's data export 
+ * into an HTTP Project (or projects for data export).
+ */
+export class PostmanDataTransformer {
+  static transform(init: any): Promise<HttpProject|HttpProject[]> {
+    let data = init;
+    if (typeof init === 'string') {
+      data = JSON.parse(init);
+    }
+    const version = this.recognizeVersion(data);
+    let instance: PostmanTransformer;
+    switch (version) {
+      case 'backup':
+        instance = new PostmanBackupTransformer(data);
+        break;
+      case 'collection-v2':
+        instance = new PostmanV2Transformer(data);
+        break;
+      case 'collection-v2.1':
+        instance = new PostmanV21Transformer(data);
+        break;
+      default: return Promise.reject(new Error('Unsupported Postman version.'));
+    }
+    return instance.transform();
+  }
+
+  static recognizeVersion(data: any): string | undefined {
+    if (data.version) {
+      return 'backup';
+    }
+    if (data.info.schema) {
+      switch (data.info.schema) {
+        case 'https://schema.getpostman.com/json/collection/v2.0.0/collection.json':
+          return 'collection-v2';
+        case 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json':
+          return 'collection-v2.1';
+        default: return undefined;
+      }
+    }
+    return undefined;
+  }
+}

package/src/models/transformers/PostmanTransformer.ts

@@ -0,0 +1,106 @@
+import { HttpProject } from '../HttpProject.js';
+
+export const postmanVarRegex = /\{\{(.*?)\}\}/gim;
+
+/**
+ * Replacer function for regex replace to be used to replace variables
+ * notation to ARC's
+ *
+ * @param match
+ * @param value
+ * @return Value to be replaced in the string.
+ */
+export function variablesReplacerFunction(match: string, value: string): string {
+  switch (value) {
+    case '$randomInt': value = 'random()'; break;
+    case '$guid': value = 'uuid()'; break;
+    case '$timestamp': value = 'now()'; break;
+    default:
+  }
+  return `\${${value}}`;
+}
+
+/**
+ * Parse input string as a payload param key or value.
+ *
+ * @param input An input to parse.
+ * @return Trimmed string
+ */
+export function paramValue(input: string): string {
+  if (!input) {
+    return String();
+  }
+  input = String(input);
+  input = input.trim();
+  return input;
+}
+
+export const dataValue = Symbol('dataValue');
+
+export type PostmanImportLogLevel = 'error' | 'warning' | 'info';
+
+export interface PostmanImportLog {
+  type: PostmanImportLogLevel;
+  message: string;
+}
+
+/**
+ * Base class for all Postman transformers
+ */
+export abstract class PostmanTransformer {
+  [dataValue]: any;
+  logs: PostmanImportLog[] = [];
+
+  /**
+   * @param data Data to be transformed.
+   */
+  constructor(data: any) {
+    this[dataValue] = data;
+  }
+
+  addLog(type: PostmanImportLogLevel, message: string): void {
+    this.logs.push({
+      type,
+      message,
+    });
+  }
+
+  /**
+   * Replaces any occurrence of {{STRING}} with ARC's variables syntax.
+   *
+   * @param str A string value to check for variables.
+   * @return The same string with ARC's variables syntax
+   */
+  ensureVariablesSyntax(str?: string): string|undefined {
+    if (!str || !str.indexOf) {
+      return str;
+    }
+    // https://jsperf.com/regex-replace-with-test-conditions
+    if (str.indexOf('{{') !== -1) {
+      str = str.replace(postmanVarRegex, variablesReplacerFunction);
+    }
+    return str;
+  }
+
+  ensureVarsRecursively(obj: any): any {
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.ensureVarsRecursively(item));
+    }
+    if (obj === Object(obj)) {
+      Object.keys(obj).forEach((key) => {
+        obj[key] = this.ensureVarsRecursively(obj[key]);
+      });
+      return obj;
+    }
+    if (typeof obj === 'string') {
+      return this.ensureVariablesSyntax(obj);
+    }
+    return obj;
+  }
+
+  /**
+   * Transforms the data into ARC data model.
+   * @returns Promise resolved when data are transformed.
+   */
+  abstract transform(): Promise<HttpProject|HttpProject[]>;
+}