@api-client/core 0.20.10 → 0.21.0

package/src/events/transport/TransportEvents.ts

@@ -1,105 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { IHttpRequest } from '../../models/HttpRequest.js'
-import { IRequestLog } from '../../models/RequestLog.js'
-import { IProjectExecutionLog } from '../../models/ProjectExecution.js'
-import { ContextEvent } from '../BaseEvents.js'
-import { TransportEventTypes } from './TransportEventTypes.js'
-import { IRequestProxyInit } from '../../proxy/RequestProxy.js'
-import { IHttpProjectProxyInit, IHttpProjectStoreProxyInit } from '../../proxy/HttpProjectProxy.js'
-import { IProxyResult } from '../../proxy/Proxy.js'
-
-export interface IHttpRequestDetail {
-  request: IHttpRequest
-  init?: RequestInit
-}
-
-export const TransportEvent = Object.freeze({
-  /**
-   * Transport via the CoreEngine.
-   */
-  Core: Object.freeze({
-    /**
-     * Sends a single request without a context of a project.
-     *
-     * @param target The events target.
-     * @param init The request execution configuration
-     * @returns The execution log with the variables evaluated during the run or
-     *          `undefined` when the event was not handled.
-     */
-    request: async (
-      init: IRequestProxyInit,
-      target: EventTarget = window
-    ): Promise<IProxyResult<IRequestLog> | undefined> => {
-      const e = new ContextEvent<IRequestProxyInit, IProxyResult<IRequestLog>>(TransportEventTypes.Core.request, init)
-      target.dispatchEvent(e)
-      return e.detail.result
-    },
-
-    /**
-     * For both the project or a folder (since it's all single configuration.)
-     *
-     * @param target The events target
-     * @param init The project execution configuration
-     */
-    httpProject: async (
-      init: IHttpProjectProxyInit | IHttpProjectStoreProxyInit,
-      target: EventTarget = window
-    ): Promise<IProxyResult<IProjectExecutionLog> | undefined> => {
-      const e = new ContextEvent<
-        IHttpProjectProxyInit | IHttpProjectStoreProxyInit,
-        IProxyResult<IProjectExecutionLog>
-      >(TransportEventTypes.Core.httpProject, init)
-      target.dispatchEvent(e)
-      return e.detail.result
-    },
-  }),
-  /**
-   * Transport via the native platform's bindings.
-   */
-  Http: Object.freeze({
-    /**
-     * Sends the request outside the Core engine, most probably using Fetch API.
-     * Note, CORS may apply to the request.
-     *
-     * @param target The events target
-     * @param request The base request definition.
-     * @param init Optional request init options compatible with the Fetch API.
-     * @returns Compatible with the Fetch API Response object or `undefined` when the event was not handled.
-     */
-    send: async (
-      request: IHttpRequest,
-      init?: RequestInit,
-      target: EventTarget = window
-    ): Promise<Response | undefined> => {
-      const e = new ContextEvent<IHttpRequestDetail, Response>(TransportEventTypes.Http.send, {
-        request,
-        init,
-      })
-      target.dispatchEvent(e)
-      return e.detail.result
-    },
-  }),
-
-  // web sockets.
-  Ws: Object.freeze({
-    /**
-     * Informs to make a connection. Used by web sockets.
-     */
-    connect: async (target: EventTarget): Promise<any> => {
-      throw new Error(`Not yet implemented`)
-    },
-    /**
-     * Informs to close the current connection. Used by web sockets.
-     */
-    disconnect: async (target: EventTarget): Promise<any> => {
-      throw new Error(`Not yet implemented`)
-    },
-    /**
-     * Informs to send a data on the current connection. Used by web sockets.
-     */
-    send: async (target: EventTarget): Promise<any> => {
-      throw new Error(`Not yet implemented`)
-    },
-  }),
-})

package/src/lib/Buffer.ts

@@ -1,62 +0,0 @@
-import { hasBuffer } from '../Platform.js'
-
-/**
- * Converts base64 string to Uint8Array.
- *
- * @returns The restored array view.
- */
-export function base64ToBuffer(str: string): Uint8Array | Buffer {
-  if (hasBuffer) {
-    return Buffer.from(str, 'base64')
-  }
-  const asciiString = atob(str)
-  return new Uint8Array([...asciiString].map((char) => char.charCodeAt(0)))
-}
-
-function uint8ArrayToBase64(view: Uint8Array): string {
-  if (hasBuffer) {
-    const buffer = Buffer.from(view)
-    return buffer.toString('base64')
-  }
-  return btoa(String.fromCharCode(...view))
-}
-
-function arrayBufferToBase64(buffer: ArrayBuffer): string {
-  if (hasBuffer) {
-    const nodeBuffer = Buffer.from(buffer)
-    return nodeBuffer.toString('base64')
-  }
-  return btoa(String.fromCharCode(...new Uint8Array(buffer)))
-}
-
-/**
- * Converts incoming data to base64 string.
- *
- * @returns Safe to store string.
- */
-export function bufferToBase64(view: Buffer | ArrayBuffer | Uint8Array): string {
-  const name = view[Symbol.toStringTag]
-  if (name === 'Uint8Array') {
-    return uint8ArrayToBase64(view as Uint8Array)
-  }
-  if (name === 'ArrayBuffer') {
-    return arrayBufferToBase64(view as ArrayBuffer)
-  }
-  const buffer = view as Buffer
-  return buffer.toString('base64')
-}
-
-/**
- * Reads file as ArrayBuffer
- */
-export async function fileToBuffer(blob: Blob): Promise<Uint8Array> {
-  const ab = await blob.arrayBuffer()
-  return new Uint8Array(ab)
-}
-
-/**
- * Reads file as string
- */
-export async function fileToString(blob: Blob): Promise<string> {
-  return blob.text()
-}

package/src/lib/definitions/HttpDefinitions.ts

@@ -1,68 +0,0 @@
-import {
-  requestHeaders,
-  responseHeaders,
-  statusCodes,
-  IHeaderDefinition,
-  IStatusCodeDefinition,
-} from '../headers/HeadersData.js'
-
-/**
- * Queries for headers containing a `query`. If query is not set
- * (value is falsy) then it returns all headers definitions array.
- *
- * @param query A query to search for in the `key` field of the headers array.
- * @param type If this equals `request` then it will look in the request headers array.
- *  Is the response headers list otherwise.
- * @returns Array of the headers of selected `type` matched a `query` in a header's `key` field.
- */
-export function queryHeaders(type: 'request' | 'response', query?: string): IHeaderDefinition[] {
-  const headers = type === 'request' ? requestHeaders : responseHeaders
-  if (!query) {
-    return headers
-  }
-  const lowerQuery = query.trim().toLowerCase()
-  return headers.filter((item) => item.key.toLowerCase().indexOf(lowerQuery) !== -1)
-}
-
-/**
- * Queries for request headers that contains a `query`. If query is
- * not set (value is falsy) then it returns all headers definitions array.
- *
- * @param name A header name to look for. It will match a header where the header name contains the `name` param.
- * @returns Array of the request headers matched `name` in the header's `key` field.
- */
-export function queryRequestHeaders(name?: string): IHeaderDefinition[] {
-  return queryHeaders('request', name)
-}
-
-/**
- * Queries for response headers that contains a `query`. If query is
- * not set (value is falsy) then it returns all headers definitions array.
- *
- * @param name A header name to look for. It will match a header where the header name contains the `name` param.
- * @returns Array of the response headers matched `name` in the header's `key` field.
- */
-export function queryResponseHeaders(name?: string): IHeaderDefinition[] {
-  return queryHeaders('response', name)
-}
-
-/**
- * Convenient function to look for a status code in the array.
- *
- * @param codeArg The status code to look for.
- * @returns Status code definition or null if not found.
- */
-export function getStatusCode(codeArg: number): IStatusCodeDefinition | IStatusCodeDefinition[] | null {
-  if (!codeArg) {
-    return statusCodes
-  }
-  const code = Number(codeArg)
-  if (Number.isNaN(code)) {
-    return null
-  }
-  const res = statusCodes.filter((item) => item.key === code)
-  if (!res.length) {
-    return null
-  }
-  return res[0]
-}

package/src/lib/fs/Fs.ts

@@ -1,258 +0,0 @@
-import { writeFile, mkdir, rm, readdir, stat, access, readFile, copyFile as fsCopyFile } from 'fs/promises'
-import { constants } from 'fs'
-import { join, dirname } from 'path'
-
-export interface JsonReadOptions {
-  /**
-   * Whether it should throw an error when a reading error occurs.
-   */
-  throws?: boolean
-}
-
-// function statPromise(filePath: string): Promise<fsSync.Stats> {
-//   return new Promise((resolve, reject) => {
-//     fsSync.stat(filePath, (err, stats) => {
-//       if (err) {
-//         reject(err);
-//       } else {
-//         resolve(stats);
-//       }
-//     });
-//   });
-// }
-
-/**
- * Checks whether a file exists in the location.
- */
-export async function pathExists(filePath: string): Promise<boolean> {
-  // return new Promise((resolve) => {
-  //   fsSync.stat(filePath, (err, stats) => {
-  //     if (err) {
-  //       resolve(false);
-  //     } else {
-  //       resolve(true);
-  //     }
-  //   });
-  // });
-  try {
-    await stat(filePath)
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Tests a user's permissions for the file or directory specified by filePath.
- * @param filePath The path to test
- * @returns True when the path can be read by the current user.
- */
-export async function canRead(filePath: string): Promise<boolean> {
-  const exists = await pathExists(filePath)
-  if (!exists) {
-    return false
-  }
-
-  // return new Promise((resolve) => {
-  //   fsSync.access(filePath, constants.R_OK, (err) => {
-  //     if (err) {
-  //       resolve(false);
-  //     } else {
-  //       resolve(true);
-  //     }
-  //   });
-  // });
-  try {
-    await access(filePath, constants.R_OK)
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Tests a user's permissions for the file or directory specified by filePath.
- * @param filePath The path to test
- * @returns True when the path can be written to by the current user.
- */
-export async function canWrite(filePath: string): Promise<boolean> {
-  const exists = await pathExists(filePath)
-  if (!exists) {
-    return false
-  }
-  // return new Promise((resolve) => {
-  //   fsSync.access(filePath, constants.W_OK, (err) => {
-  //     if (err) {
-  //       resolve(false);
-  //     } else {
-  //       resolve(true);
-  //     }
-  //   });
-  // });
-  try {
-    await access(filePath, constants.W_OK)
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Reads the contents of a JSON file.
- *
- * @param filePath The path to the JSON file to read.
- * @returns The contents of the file. When `throws` options is not set and error occurs then it returns an empty file.
- */
-export async function readJson(filePath: string, opts: JsonReadOptions = {}): Promise<unknown> {
-  const readable = await canRead(filePath)
-  if (!readable) {
-    if (opts.throws) {
-      throw new Error(`Unable to read file: ${filePath}. Access is denied.`)
-    }
-    return {}
-  }
-  // return new Promise((resolve, reject) => {
-  //   fsSync.readFile(filePath, 'utf8', (err, contents) => {
-  //     if (err) {
-  //       reject(err);
-  //     } else {
-  //       let data = {};
-  //       try {
-  //         data = JSON.parse(contents);
-  //       } catch (e) {
-  //         if (opts.throws) {
-  //           const err = new Error(`Invalid JSON contents for file: ${filePath}.`);
-  //           reject(err);
-  //           return;
-  //         }
-  //       }
-  //       resolve(data);
-  //     }
-  //   });
-  // });
-  const contents = await readFile(filePath, 'utf8')
-  let data = {}
-  try {
-    data = JSON.parse(contents)
-  } catch {
-    if (opts.throws) {
-      throw new Error(`Invalid JSON contents for file: ${filePath}.`)
-    }
-  }
-  return data
-}
-
-/**
- * Writes the contents to the file.
- *
- * @param filePath The file to write to. It replaces the contents.
- * @param contents The contents to write.
- */
-export async function writeJson(filePath: string, contents: string | unknown): Promise<void> {
-  const destParent = dirname(filePath)
-  await ensureDir(destParent)
-  const parentWritable = await canWrite(destParent)
-  if (!parentWritable) {
-    throw new Error(`Unable to write to location: ${parentWritable}. Access is denied.`)
-  }
-  const data = typeof contents === 'string' ? contents : JSON.stringify(contents)
-  await writeFile(filePath, data)
-}
-
-/**
- * Ensures the directory exists.
- */
-export async function ensureDir(dirPath: string): Promise<void> {
-  const readable = await canRead(dirPath)
-  if (readable) {
-    return
-  }
-  await mkdir(dirPath, { recursive: true })
-}
-
-/**
- * Removes contents of the directory, leaving the directory in the filesystem.
- */
-export async function emptyDir(dirPath: string): Promise<void> {
-  const exists = await pathExists(dirPath)
-  if (!exists) {
-    return
-  }
-  const writeable = await canWrite(dirPath)
-  if (!writeable) {
-    throw new Error(`Unable to clear directory: ${dirPath}. Access is denied.`)
-  }
-  const items = await readdir(dirPath, 'utf8')
-  for (const item of items) {
-    const file = join(dirPath, item)
-    await rm(file, { recursive: true })
-  }
-}
-
-/**
- * Copies a file
- */
-async function copyFile(source: string, dest: string): Promise<void> {
-  const destParent = dirname(dest)
-  await ensureDir(destParent)
-  await fsCopyFile(source, dest)
-}
-
-// /**
-//  * Copies a file
-//  * @param {string} source
-//  * @param {string} dest
-//  * @returns {Promise<void>}
-//  */
-// async function copyFile(source, dest) {
-//   const destParent = dirname(dest);
-//   await ensureDir(destParent);
-//   return new Promise((resolve, reject) => {
-//     fsSync.copyFile(source, dest, (err) => {
-//       if (err) {
-//         reject(err);
-//       } else {
-//         resolve();
-//       }
-//     });
-//   });
-// }
-
-/**
- * Copies a directory and its contents.
- */
-async function copyDirectory(source: string, dest: string): Promise<void> {
-  await ensureDir(dest)
-  // const entries = fsSync.readdirSync(source, { withFileTypes: true, encoding: 'utf8' });
-  const entries = await readdir(source, { withFileTypes: true, encoding: 'utf8' })
-  for (const entry of entries) {
-    const srcFile = join(source, entry.name)
-    const destFile = join(dest, entry.name)
-    const srcStat = await stat(srcFile)
-    if (srcStat.isDirectory()) {
-      await copyDirectory(srcFile, destFile)
-    } else {
-      await copyFile(srcFile, destFile)
-    }
-  }
-}
-
-/**
- * Copies a file or a directory to the destination location.
- * It creates the destination folder when missing.
- *
- * @param source The source file or folder.
- * @param dest The destination file or folder.
- */
-export async function copy(source: string, dest: string): Promise<void> {
-  const existing = await pathExists(source)
-  if (!existing) {
-    throw new Error(`Specified path does not exist: ${source}`)
-  }
-  const srcStat = await stat(source)
-  if (srcStat.isDirectory()) {
-    await copyDirectory(source, dest)
-  } else {
-    await copyFile(source, dest)
-  }
-}