@api-client/core 0.20.10 → 0.21.0

package/src/models/transformers/LegacyExportProcessor.ts

@@ -1,248 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-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-expect-error This library will likely go away
-      if (item.legacyProject) {
-        if (item.projects) {
-          // @ts-expect-error This library will likely go away
-          request.projects[item.projects.length] = item.legacyProject
-        } else {
-          // @ts-expect-error This library will likely go away
-          request.projects = [request.legacyProject]
-        }
-        // @ts-expect-error This library will likely go away
-        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-expect-error This library will likely go away
-      delete project._rev
-      // @ts-expect-error This library will likely go away
-      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
-      delete request._rev
-      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
-      delete history._rev
-      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
-      delete history._rev
-      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
-      delete value._rev
-      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
-      delete value._rev
-      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
-        delete value._rev
-        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
-      delete value._rev
-      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
-      delete value._rev
-      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

@@ -1,303 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-import { PostmanTransformer, dataValue, paramValue } from './PostmanTransformer.js'
-import { HttpProject, IHttpProject, Kind as HttpProjectKind } 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'
-import { Thing } from '../Thing.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: HttpProjectKind,
-      definitions: {},
-      info: Thing.fromName(name).toJSON(),
-      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
-
-    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

@@ -1,54 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { PostmanBackupTransformer } from './PostmanBackupTransformer.js'
-
-import { PostmanV2Transformer } from './PostmanV2Transformer.js'
-import { PostmanV21Transformer } from './PostmanV21Transformer.js'
-import { PostmanTransformer } from './PostmanTransformer.js'
-import type { 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

@@ -1,113 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-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[]>
-}