@api-client/core 0.3.1 → 0.3.4

package/src/models/legacy/request/RequestBody.ts

@@ -0,0 +1,87 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ApiType } from "../models/ApiTypes.js";
+
+/**
+ * @deprecated
+ */
+export interface MultipartBody {
+  /**
+   * When true a this entry represent a file part
+   */
+  isFile: boolean;
+  /**
+   * The name of the filed
+   */
+  name: string;
+  /**
+   * Converted value
+   */
+  value: string;
+  /**
+   * A content type entered by the user to the text part of the text part input.
+   * This can only be set when `isFile` is false.
+   */
+  type?: string;
+  /**
+   * The original file name used with the part
+   */
+  fileName?: string;
+  /**
+   * Whether the parameter is enabled. Default to true.
+   */
+  enabled?: boolean;
+  /**
+   * When `isFile` is true then this is the size of the selected file.
+   */
+  size?: number;
+}
+
+/**
+ * @deprecated
+ */
+export interface RawBody {
+  /**
+   * 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?: any;
+}
+
+/**
+ * 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,
+ * @deprecated
+ */
+export interface BodyMetaModel {
+  /**
+   * The id of the editor. Each editor in ARC has own id.
+   */
+  type: string;
+  /**
+   * Generated view model.
+   */
+  viewModel: (ApiType | MultipartBody | RawBody)[];
+}
+
+/**
+ * Body editor meta data.
+ * @deprecated
+ */
+export interface BodyMeta {
+  /**
+   * The model generated for the body editor.
+   */
+  model?: BodyMetaModel[];
+  /**
+   * The selected editor
+   */
+  selected?: string;
+}

package/src/models/transformers/ArcDexieTransformer.ts

@@ -0,0 +1,323 @@
+import v4 from '../../lib/uuid.js';
+import { BaseTransformer, dataValue } from './BaseTransformer.js';
+import { Creator, Browser, Page, Entry } from './har.js';
+import {
+  ArcExportObject,
+  ExportArcProjects,
+  ExportArcSavedRequest,
+  ExportArcHistoryRequest,
+} from '../legacy/DataExport.js';
+
+interface DexieExport {
+  kind: string;
+  createdAt: string;
+  version: string;
+  requests?: DexieRequest[];
+  projects?: DexieProject[];
+}
+interface DexieRequest {
+  order: number;
+  url: string;
+  method: string;
+  type: string;
+  updateTime: number;
+  id: string;
+  kind: string;
+  har: DexieHar;
+  _har?: DexieHar;
+  name?: string;
+  _name?: string;
+  referenceEntry?: number;
+  driveId?: string;
+}
+
+interface DexieHar {
+  comment: string;
+  version: string;
+  creator: Creator;
+  browser: Browser;
+  pages: Page[];
+  entries: Entry[];
+}
+
+interface DexieProject {
+  order: number;
+  created: number;
+  updateTime: number;
+  requestIds: string[];
+  name: string;
+  kind: string;
+  id: number;
+}
+
+interface ProjectItem {
+  updateData: string[];
+  legacyProject: ExportArcProjects;
+}
+
+interface RequestProcessItem {
+  origin: string;
+  request: ExportArcSavedRequest | ExportArcHistoryRequest;
+}
+
+interface ProcessedRequests {
+  saved: RequestProcessItem[];
+  history: RequestProcessItem[];
+}
+
+/**
+ * Transforms Dexie system (legacy system) into the legacy PouchDB system.
+ */
+export class ArcDexieTransformer extends BaseTransformer {
+  /**
+   * Transforms legacy ARC export object based on Dexie data store
+   * into current export data model.
+   *
+   * @returns New data model object.
+   */
+  async transform(): Promise<ArcExportObject> {
+    const raw = this[dataValue] as DexieExport;
+
+    const requests = await this.parseRequests(raw.requests || []);
+    const pData = this.processProjects(raw.projects || []);
+    const data = this.associateProjects(requests, pData);
+    const result = {
+      createdAt: new Date().toISOString(),
+      version: 'unknown',
+      kind: 'ARC#Import',
+      requests: data.saved ? (data.saved as any[]).map((item) => item.request as ExportArcSavedRequest) : [],
+      projects: pData ? pData.map((item) => item.legacyProject as ExportArcProjects) : [],
+      history: data.history ? (data.history as any[]).map((item) => item.request as ExportArcHistoryRequest) : []
+    };
+    // TODO: handle history data.
+    return result;
+  }
+
+  /**
+   * In new structure projects do not have a reference to request ids. It's
+   * the other way around in previous system.
+   * It's a bad pattern for object stores but it must suffice for now.
+   *
+   * @param projects List of projects in the import.
+   * @returns Preprocessed projects array
+   */
+  processProjects(projects: DexieProject[]): ProjectItem[] {
+    if (!projects || !projects.length) {
+      return [];
+    }
+    const list: ProjectItem[] = [];
+    projects.forEach((item) => {
+      const result = this.processProjectItem(item);
+      if (result) {
+        list.push(result);
+      }
+    });
+    return list;
+  }
+
+  /**
+   * Creates a pre-processed project data.
+   *
+   * @param item Project object from the Dexie import.
+   * @return Pre-processed project object with project store data
+   * under the `legacyProject` property and list of requests IDs under
+   * the `updateData` property.
+   */
+  processProjectItem(item: DexieProject): ProjectItem|undefined {
+    if (!item.requestIds || !item.requestIds.length) {
+      return undefined;
+    }
+    return {
+      updateData: item.requestIds,
+      legacyProject: {
+        kind: 'ARC#Project',
+        key: v4(),
+        name: item.name,
+        order: item.order,
+        updated: item.updateTime,
+        created: item.created,
+      }
+    };
+  }
+
+  /**
+   * History is placed in its own store, saved items has own store.
+   * Har data are not imported this way as user cannot actually use it.
+   *
+   * @param requests List of requests objects from the import file.
+   * @returns A promise resolved when import is ready.
+   */
+  async parseRequests(requests: DexieRequest[]): Promise<ProcessedRequests> {
+    const data = await this.parseRequestsDeffered(requests);
+    // remove duplicates from the history.
+    const ids: string[] = [];
+    data.history = (data.history as any[]).filter((item) => {
+      if (ids.indexOf(item.request.key) === -1) {
+        ids[ids.length] = item.request.key;
+        return true;
+      }
+      return false;
+    });
+    return data;
+  }
+
+  /**
+   * Parses the request data.
+   * It takes only portion of the data to parse so the script release the
+   * event loop and ANR screen won't appear.
+   *
+   * @param requests List of requests from the import.
+   * @param saved Final list of saved requests
+   * @param history Final list of history items.
+   */
+  async parseRequestsDeffered(requests: DexieRequest[], saved: RequestProcessItem[]=[], history: RequestProcessItem[]=[]): Promise<ProcessedRequests> {
+    if (requests.length === 0) {
+      return {
+        saved,
+        history,
+      };
+    }
+    const len = Math.min(requests.length, 200);
+    // Up to 200 loop iteration at once.
+    // Then the function return and release main loop.
+    for (let i = 0; i < len; i++) {
+      const item = requests[i];
+      if (item.type === 'history') {
+        const result = this.parseHistoryItem(item);
+        history.push(result);
+      } else if (item.type === 'saved') {
+        const result = this.parseSavedItem(item);
+        saved.push(result);
+      } else if (item.type === 'drive') {
+        const result = this.parseDriveItem(item);
+        saved.push(result);
+      }
+    }
+    requests.splice(0, len);
+    return this.parseRequestsDeffered(requests, saved, history);
+  }
+
+  parseHistoryItem(item: DexieRequest): RequestProcessItem {
+    const updated = { ...item };
+    updated.updateTime = updated.updateTime || Date.now();
+    const obj: ExportArcHistoryRequest = {
+      key: v4(),
+      method: updated.method,
+      url: updated.url,
+      updated: new Date(updated.updateTime).getTime()
+    };
+    // payload and headers
+    const har = updated._har || updated.har;
+    const {entries} = har;
+    const entry = entries[entries.length - 1];
+    if (entry) {
+      const harRequest = entry.request;
+      obj.headers = this.parseHarHeaders(harRequest.headers);
+      obj.payload = harRequest.postData?.text;
+      let t = new Date(entry.startedDateTime).getTime();
+      if (Number.isNaN(t)) {
+        t = Date.now();
+      }
+      obj.created = t;
+    } else {
+      obj.created = obj.updated;
+    }
+    obj.updated = Date.now();
+    return {
+      origin: updated.id,
+      request: obj
+    };
+  }
+
+  parseSavedItem(item: DexieRequest): RequestProcessItem {
+    const requestName = item.name || item._name;
+    let keyName = requestName;
+    if (keyName && keyName[0] === '_') {
+      keyName = keyName.substr(1);
+    }
+    const obj: ExportArcSavedRequest = {
+      name: requestName || '',
+      method: item.method,
+      url: item.url,
+      type: 'saved',
+      kind: 'ARC#HttpRequest',
+      key: v4(),
+    };
+    // payload and headers
+    const harIndex = item.referenceEntry || 0;
+    const har = item._har || item.har;
+    if (har) {
+      const {entries} = har;
+      let entry;
+      if (harIndex || harIndex === 0) {
+        entry = entries[harIndex];
+      } else {
+        [entry] = entries;
+      }
+      if (entry) {
+        const harRequest = entry.request;
+        obj.headers = this.parseHarHeaders(harRequest.headers);
+        obj.payload = harRequest.postData?.text;
+        let t = new Date(entry.startedDateTime).getTime();
+        if (Number.isNaN(t)) {
+          t = Date.now();
+        }
+        obj.created = t;
+      }
+    }
+    obj.updated = Date.now();
+
+    return {
+      origin: item.id,
+      request: obj
+    };
+  }
+
+  parseDriveItem(item: DexieRequest): RequestProcessItem {
+    const result = this.parseSavedItem(item);
+    result.request.driveId = item.driveId;
+    return result;
+  }
+
+  parseHarHeaders(arr: any[]): string {
+    if (!arr || !arr.length) {
+      return '';
+    }
+    return arr.map((item) => `${item.name}: ${item.value}`).join('\n');
+  }
+
+  /**
+   * Associate requests with project data.
+   *
+   * @param {ProcessedRequests} data Parsed requests object
+   * @param {ProjectItem[]} projects List of projects
+   * @return {ProcessedRequests} Parsed requests object
+   */
+  associateProjects(data: ProcessedRequests, projects: ProjectItem[]): ProcessedRequests {
+    if (!projects || !projects.length) {
+      return data;
+    }
+    if (!data.saved) {
+      data.saved = [];
+    }
+    const savedLen = data.saved.length;
+    const projectsLen = projects.length;
+    for (let i = 0; i < projectsLen; i++) {
+      const project = projects[i];
+      const newProjectId = project.legacyProject.key;
+      for (let j = 0, rLen = project.updateData.length; j < rLen; j++) {
+        const rId = project.updateData[j];
+        for (let k = 0; k < savedLen; k++) {
+          if (data.saved[k].origin === rId) {
+            const {request} = data.saved[k];
+            request.key += `/${newProjectId}`;
+            this.addProjectReference(request as ExportArcSavedRequest, newProjectId);
+            this.addRequestReference(project.legacyProject, request.key);
+            break;
+          }
+        }
+      }
+    }
+    return data;
+  }
+}

package/src/models/transformers/ArcLegacyNormalizer.ts

@@ -0,0 +1,85 @@
+/* eslint-disable class-methods-use-this */
+import { isArcFile, prepareImportObject, } from './ImportUtils.js';
+import { ArcLegacyTransformer } from './ArcLegacyTransformer.js';
+import { ArcDexieTransformer } from './ArcDexieTransformer.js';
+import { ArcPouchTransformer } from './ArcPouchTransformer.js';
+import { ArcExportObject } from '../legacy/DataExport.js';
+
+/**
+ * Normalizes all legacy ARC export objects to the `ArcExportObject`.
+ * This is also a legacy format. Use the `LegacyDataExportToApiProject` class
+ * to transform it to `HttpProject`(s).
+ */
+export class ArcLegacyNormalizer {
+  /**
+   * Transforms any previous ARC export file to the current export object.
+   *
+   * Note, the data has to be decrypted before running this function.
+   *
+   * @param data Data from the import file.
+   * @returns Normalized data import object.
+   */
+  async normalize(data: any): Promise<ArcExportObject> {
+    const processed = prepareImportObject(data);
+    if (isArcFile(processed)) {
+      return this.normalizeArcData(processed);
+    }
+    throw new Error('File not recognized');
+  }
+
+  /**
+   * Normalizes any previous and current ARC file export data to common model.
+   *
+   * @param data Imported data.
+   * @return A promise resolved to ARC data export object.
+   */
+  async normalizeArcData(data: any): Promise<ArcExportObject> {
+    switch (data.kind) {
+      case 'ARC#SavedHistoryDataExport':
+      case 'ARC#AllDataExport':
+      case 'ARC#SavedDataExport':
+      case 'ARC#SavedExport':
+      case 'ARC#HistoryDataExport':
+      case 'ARC#HistoryExport':
+      case 'ARC#Project':
+      case 'ARC#SessionCookies':
+      case 'ARC#HostRules':
+      case 'ARC#ProjectExport':
+        return this.normalizeArcPouchSystem(data);
+      case 'ARC#requestsDataExport':
+        return this.normalizeArcDexieSystem(data);
+      default:
+        return this.normalizeArcLegacyData(data);
+    }
+  }
+
+  /**
+   * Normalizes export data from the GWT system.
+   * @param data Parsed data
+   * @returns Normalized import object
+   */
+  normalizeArcLegacyData(data: any): Promise<ArcExportObject> {
+    const transformer = new ArcLegacyTransformer(data);
+    return transformer.transform();
+  }
+
+  /**
+   * Normalizes export data from Dexie powered data store.
+   * @param data Parsed data
+   * @returns Normalized import object
+   */
+  normalizeArcDexieSystem(data: any): Promise<ArcExportObject> {
+    const transformer = new ArcDexieTransformer(data);
+    return transformer.transform();
+  }
+
+  /**
+   * Normalizes ARC's data exported in PouchDB system
+   * @param data Parsed data
+   * @returns Normalized import object
+   */
+  normalizeArcPouchSystem(data: any): Promise<ArcExportObject> {
+    const transformer = new ArcPouchTransformer(data);
+    return transformer.transform();
+  }
+}

package/src/models/transformers/ArcLegacyTransformer.ts

@@ -0,0 +1,200 @@
+import v4 from '../../lib/uuid.js';
+import { BaseTransformer, dataValue } from './BaseTransformer.js';
+import {
+  ArcExportObject,
+  ExportArcProjects,
+  ExportArcSavedRequest,
+} from '../legacy/DataExport.js';
+
+interface LegacyExport {
+  requests: LegacyRequest[];
+  projects: LegacyProject[];
+}
+
+interface LegacyRequest {
+  id: number;
+  name: string;
+  project: number;
+  url: string;
+  method: string;
+  encoding: string|null;
+  headers: string|null;
+  payload: string|null;
+  skipProtocol: boolean;
+  skipServer: boolean;
+  skipParams: boolean;
+  skipHistory: boolean;
+  skipMethod: boolean;
+  skipPayload: boolean;
+  skipHeaders: boolean;
+  skipPath: boolean;
+  time: number;
+  driveId?: string|null;
+}
+
+interface LegacyProject {
+  created: number;
+  id: number;
+  name: string;
+}
+
+interface LegacyProjectProcessing extends ExportArcProjects {
+  originId: number;
+}
+
+/**
+ * Tests if the data import is a single request export.
+ *
+ * @param data Imported data
+ * @return True if `data` represents single request
+ */
+export function isSingleRequest(data: any): boolean {
+  if ('requests' in data || 'projects' in data) {
+    return false;
+  }
+  return true;
+}
+
+
+/**
+ * Transforms the first ARC data object to current schema.
+ */
+export class ArcLegacyTransformer extends BaseTransformer {
+  /**
+   * Transforms legacy ARC export object into current export data model.
+   *
+   * @return New data model object.
+   */
+  async transform(): Promise<ArcExportObject> {
+    const raw = this[dataValue] as any;
+
+    let projects: ExportArcProjects[] | undefined;
+    let requests: ExportArcSavedRequest[] | undefined;
+    if (isSingleRequest(raw)) {
+      const item = raw as LegacyRequest;
+      projects = [];
+      requests = [this.transformRequest(item)];
+    } else {
+      const data = raw as LegacyExport;
+      const tmp = projects = this.transformProjects(data.projects);
+      requests = this.transformRequests(data.requests, tmp);
+      projects = projects.map((item) => {
+        // @ts-ignore
+        delete item.originId;
+        return item;
+      });
+    }
+
+    const result: ArcExportObject = {
+      createdAt: new Date().toISOString(),
+      version: 'unknown',
+      kind: 'ARC#Import',
+      requests,
+      projects,
+    };
+
+    return result;
+  }
+
+  /**
+   * Returns a list of projects from a legacy export file.
+   *
+   * Each project will have newly generated ID to not make conflicts with
+   * existing projects. Old project id is moved to the `originId` property.
+   *
+   * @param projects List of legacy project objects
+   * @returns List of project object in current data model. It can be
+   * empty array.
+   */
+  transformProjects(projects: LegacyProject[]): LegacyProjectProcessing[] {
+    if (!projects || !(projects instanceof Array) || !projects.length) {
+      return [];
+    }
+    return projects.map((item) => {
+      let created = Number(item.created);
+      if (Number.isNaN(created)) {
+        created = Date.now();
+      }
+      return {
+        kind: 'ARC#ProjectData',
+        key: v4(),
+        created,
+        name: item.name || 'unnamed',
+        order: 0,
+        updated: Date.now(),
+        originId: item.id,
+      };
+    });
+  }
+
+  /**
+   * Transform the list of requests into new data model.
+   */
+  transformRequests(requests: LegacyRequest[], projects?: LegacyProjectProcessing[]): ExportArcSavedRequest[] {
+    if (!requests || !(requests instanceof Array) || !requests.length) {
+      return [];
+    }
+    return requests.map((item) => this.transformRequest(item, projects));
+  }
+
+  /**
+   * Transforms a single request object into current data model.
+   *
+   * Note that required properties will be default to the following:
+   * -   `name` - "unnamed"
+   * -   `url` - "http://"
+   * -   `method` - "GET"
+   *
+   * @param item Legacy request definition
+   * @param projects List of projects in the import file.
+   * @return Current model of the request object.
+   */
+  transformRequest(item: LegacyRequest, projects?: LegacyProjectProcessing[]): ExportArcSavedRequest {
+    // LegacyRequest may have `null` values.
+    item.name = item.name || 'unnamed';
+    item.url = item.url || 'http://';
+    item.method = item.method || 'GET';
+
+    const project = this.findProject(item.project, projects);
+    const projectId = project ? project.key : undefined;
+    const id = v4();
+    let created = Number(item.time);
+    if (Number.isNaN(created)) {
+      created = Date.now();
+    }
+    const result: ExportArcSavedRequest = {
+      kind: 'ARC#HttpRequest',
+      key: id,
+      created,
+      updated: Date.now(),
+      headers: item.headers || '',
+      method: item.method,
+      name: item.name,
+      payload: item.payload || '',
+      type: 'saved',
+      url: item.url,
+    };
+    if (project && projectId) {
+      result.projects = [projectId];
+      this.addRequestReference(project, id);
+    }
+    if (item.driveId) {
+      result.driveId = item.driveId;
+    }
+    return result;
+  }
+
+  /**
+   * Finds a project in the list of projects.
+   *
+   * @param projectId A project ID to search for
+   * @param projects List of project to look into. It compares the `originId` property of the list items.
+   * @returns A project object or null if not found.
+   */
+  findProject(projectId: number, projects?: LegacyProjectProcessing[]): LegacyProjectProcessing|undefined {
+    if (!projectId || !Array.isArray(projects)) {
+      return undefined;
+    }
+    return projects.find((p) => p.originId === projectId);
+  }
+}