@api-client/core 0.20.10 → 0.21.1

package/src/sdk/HistorySdk.ts

@@ -1,272 +0,0 @@
-import {
-  SdkBase,
-  E_RESPONSE_STATUS,
-  E_RESPONSE_NO_VALUE,
-  E_INVALID_JSON,
-  E_RESPONSE_UNKNOWN,
-  SdkOptions,
-} from './SdkBase.js'
-import { RouteBuilder } from './RouteBuilder.js'
-import { IHttpHistory, IHttpHistoryBulkAdd, Kind as HttpHistoryKind } from '../models/HttpHistory.js'
-import {
-  ContextChangeRecord,
-  ContextDeleteRecord,
-  ContextListResult,
-  HistoryListOptions,
-  IBulkOperationResult,
-  IHistoryRequestListOptions,
-} from '../events/BaseEvents.js'
-import { Exception } from '../exceptions/exception.js'
-
-export class HistorySdk extends SdkBase {
-  /**
-   * Creates a history object.
-   * A history object can be created per app (type = app) or a store's organization/[project/[request]].
-   *
-   * The user can always read their own history. If the history is created for a organization/project then
-   * history records are shared as any other object in the organization.
-   *
-   * Note, history objects cannot be updated. They can only be created or deleted.
-   *
-   * @param history The history to create
-   * @param request Optional request options.
-   * @returns The key of the created history.
-   */
-  async add(history: IHttpHistory, request: SdkOptions = {}): Promise<ContextChangeRecord<IHttpHistory>> {
-    const { token } = request
-    const url = this.sdk.getUrl(RouteBuilder.history())
-    const body = JSON.stringify(history)
-    const result = await this.sdk.http.post(url.toString(), { token, body })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to create a history. '
-    if (result.status !== 200) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-    if (!result.body) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`, { code: 'E_RESPONSE_NO_VALUE', status: result.status })
-    }
-    let data: ContextChangeRecord<IHttpHistory>
-    try {
-      data = JSON.parse(result.body).data
-    } catch {
-      throw new Exception(`${E_PREFIX}${E_INVALID_JSON}`, { code: 'E_INVALID_JSON', status: result.status })
-    }
-    if (!data.key) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`, { code: 'E_RESPONSE_UNKNOWN', status: result.status })
-    }
-    return data
-  }
-
-  /**
-   * Creates a multiple history objects in a batch operation.
-   *
-   * @param info The bulk create info object.
-   * @param request Optional request options.
-   */
-  async createBulk(
-    info: IHttpHistoryBulkAdd,
-    request: SdkOptions = {}
-  ): Promise<IBulkOperationResult<ContextChangeRecord<IHttpHistory>>> {
-    const { token } = request
-    const url = this.sdk.getUrl(RouteBuilder.historyBatchCreate())
-    const body = JSON.stringify(info)
-    const result = await this.sdk.http.post(url.toString(), { token, body })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to create a bulk history. '
-    if (result.status !== 200) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-    if (!result.body) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`, { code: 'E_RESPONSE_NO_VALUE', status: result.status })
-    }
-    let data: IBulkOperationResult<ContextChangeRecord<IHttpHistory>>
-    try {
-      data = JSON.parse(result.body)
-    } catch {
-      throw new Exception(`${E_PREFIX}${E_INVALID_JSON}`, { code: 'E_INVALID_JSON', status: result.status })
-    }
-    if (!data.data) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`, { code: 'E_RESPONSE_UNKNOWN', status: result.status })
-    }
-    return data
-  }
-
-  /**
-   * Lists the history.
-   *
-   * @param options Optional query options.
-   * @param request Optional request options.
-   */
-  async list(options: HistoryListOptions, request: SdkOptions = {}): Promise<ContextListResult<IHttpHistory>> {
-    const { token } = request
-    const url = this.sdk.getUrl(RouteBuilder.history())
-    this.appendHistoryListParameters(url, options)
-    const result = await this.sdk.http.get(url.toString(), { token })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to list history. '
-    if (result.status !== 200) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-    if (!result.body) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`, { code: 'E_RESPONSE_NO_VALUE', status: result.status })
-    }
-    let data: ContextListResult<IHttpHistory>
-    try {
-      data = JSON.parse(result.body)
-    } catch {
-      throw new Exception(`${E_PREFIX}${E_INVALID_JSON}`, { code: 'E_INVALID_JSON', status: result.status })
-    }
-    if (!Array.isArray(data.data)) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`, { code: 'E_RESPONSE_UNKNOWN', status: result.status })
-    }
-    return data
-  }
-
-  appendHistoryListParameters(url: URL, options: HistoryListOptions): void {
-    this.sdk.appendListOptions(url, options)
-    const { searchParams } = url
-    searchParams.set('organization', options.organization)
-    if (options.type) {
-      searchParams.set('type', options.type)
-    }
-    const projectOptions = options as IHistoryRequestListOptions
-    if (projectOptions.id) {
-      searchParams.set('id', projectOptions.id)
-    }
-    if (projectOptions.user) {
-      searchParams.set('user', 'true')
-    }
-    if (projectOptions.project) {
-      searchParams.set('project', projectOptions.project)
-    }
-  }
-
-  /**
-   * Deletes a history object form the store.
-   *
-   * @param key The key returned by the store when created the history. Also available via the
-   *   `key` property on the history object.
-   * @param request Optional request options.
-   */
-  async delete(key: string, request: SdkOptions = {}): Promise<void> {
-    const { token } = request
-    const path = RouteBuilder.historyItem(key)
-    const url = this.sdk.getUrl(path)
-
-    const result = await this.sdk.http.delete(url.toString(), { token })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to delete history. '
-    if (result.status !== 204) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-  }
-
-  /**
-   * Deletes history in a bulk operation.
-   * @param keys The list of keys of history objects to delete.
-   * @param request Optional request options.
-   * @returns The list of delete records.
-   */
-  async deleteBulk(keys: string[], request: SdkOptions = {}): Promise<IBulkOperationResult<ContextDeleteRecord>> {
-    const { token } = request
-    const path = RouteBuilder.historyBatchDelete()
-    const url = this.sdk.getUrl(path)
-    const result = await this.sdk.http.post(url.toString(), { token, body: JSON.stringify(keys) })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to delete history. '
-    if (result.status !== 200) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-    if (!result.body) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`, { code: 'E_RESPONSE_NO_VALUE', status: result.status })
-    }
-
-    let data: IBulkOperationResult<ContextDeleteRecord>
-    try {
-      data = JSON.parse(result.body)
-    } catch {
-      throw new Exception(`${E_PREFIX}${E_INVALID_JSON}`, { code: 'E_INVALID_JSON', status: result.status })
-    }
-    if (!Array.isArray(data.data)) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`, { code: 'E_RESPONSE_UNKNOWN', status: result.status })
-    }
-    return data
-  }
-
-  /**
-   * Reads a history definition from the store.
-   * @param key The history key
-   * @param request Optional request options.
-   * @returns The history object
-   */
-  async read(key: string, request: SdkOptions = {}): Promise<IHttpHistory> {
-    const { token } = request
-    const url = this.sdk.getUrl(RouteBuilder.historyItem(key))
-    const result = await this.sdk.http.get(url.toString(), { token })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to read a history. '
-    if (result.status !== 200) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-    if (!result.body) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`, { code: 'E_RESPONSE_NO_VALUE', status: result.status })
-    }
-    let data: IHttpHistory
-    try {
-      data = JSON.parse(result.body).data
-    } catch {
-      throw new Exception(`${E_PREFIX}${E_INVALID_JSON}`, { code: 'E_INVALID_JSON', status: result.status })
-    }
-    if (data.kind !== HttpHistoryKind) {
-      throw new Exception(`${E_PREFIX}${E_RESPONSE_UNKNOWN}`, { code: 'E_RESPONSE_UNKNOWN', status: result.status })
-    }
-    return data
-  }
-
-  async clearOrganization(organizationKey: string, request: SdkOptions = {}): Promise<void> {
-    const { token } = request
-    const url = this.sdk.getUrl(RouteBuilder.historyClear('organization', organizationKey))
-    const result = await this.sdk.http.delete(url.toString(), { token })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to clear history for the organization. '
-    if (result.status !== 204) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-  }
-
-  async clearProject(organizationKey: string, projectKey: string, request: SdkOptions = {}): Promise<void> {
-    const { token } = request
-    const url = this.sdk.getUrl(RouteBuilder.historyClear('project', organizationKey, projectKey))
-    const result = await this.sdk.http.delete(url.toString(), { token })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to clear history for the project. '
-    if (result.status !== 204) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-  }
-
-  async clearRequest(
-    organizationKey: string,
-    projectKey: string,
-    requestKey: string,
-    request: SdkOptions = {}
-  ): Promise<void> {
-    const { token } = request
-    const url = this.sdk.getUrl(RouteBuilder.historyClear('request', organizationKey, projectKey, requestKey))
-    const result = await this.sdk.http.delete(url.toString(), { token })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to clear history for the request. '
-    if (result.status !== 204) {
-      this.logInvalidResponse(result)
-      throw this.createApiError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.body)
-    }
-  }
-}

package/src/sdk/ProjectExecutionsSdk.ts

@@ -1,135 +0,0 @@
-import { SdkBase, E_RESPONSE_UNKNOWN, SdkOptions, ResourceResponse } from './SdkBase.js'
-import { RouteBuilder } from './RouteBuilder.js'
-import {
-  ContextChangeRecord,
-  ContextDeleteRecord,
-  ContextListResult,
-  IBulkOperationResult,
-  IProjectExecutionListOptions,
-} from '../events/BaseEvents.js'
-import { IProjectExecution, Kind as ProjectExecutionKind } from '../models/ProjectExecution.js'
-
-export class ProjectExecutionSdk extends SdkBase {
-  /**
-   * Adds an execution logs object to the store.
-   *
-   * @param history The history object
-   * @param organization The parent organization key
-   */
-  async add(
-    organization: string,
-    value: IProjectExecution,
-    request: SdkOptions = {}
-  ): Promise<ContextChangeRecord<IProjectExecution>> {
-    const url = this.sdk.getUrl(RouteBuilder.projectExecutions())
-    url.searchParams.set('organization', organization)
-    const { token } = request
-    const result = await this.sdk.http.post(url.toString(), { token, body: JSON.stringify(value) })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to create a project execution entity. '
-    const data = this.readResponseJSON(result, E_PREFIX) as ResourceResponse<ContextChangeRecord<IProjectExecution>>
-    if (!data.data.key) {
-      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
-    }
-    return data.data
-  }
-
-  /**
-   * Reads an execution logs item.
-   *
-   * @param key The key of the history object to read.
-   */
-  async read(key: string, request: SdkOptions = {}): Promise<IProjectExecution> {
-    const url = this.sdk.getUrl(RouteBuilder.projectExecution(key))
-    const { token } = request
-    const result = await this.sdk.http.get(url.toString(), { token })
-    this.inspectCommonStatusCodes(result)
-    const E_PREFIX = 'Unable to read a project execution entity. '
-    const data = this.readResponseJSON(result, E_PREFIX) as ResourceResponse<IProjectExecution>
-    if (data.data.kind !== ProjectExecutionKind) {
-      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`)
-    }
-    return data.data
-  }
-
-  /**
-   * Lists the execution logs data.
-   *
-   * @param key The id of the file to lists revisions for.
-   * @param options The list query options
-   */
-  async list(
-    options: IProjectExecutionListOptions,
-    request: SdkOptions = {}
-  ): Promise<ContextListResult<IProjectExecution>> {
-    const url = this.sdk.getUrl(RouteBuilder.projectExecutions())
-    if (options.project) {
-      url.searchParams.set('project', options.project)
-    }
-    if (options.app) {
-      url.searchParams.set('app', options.app)
-    }
-    if (options.user) {
-      url.searchParams.set('user', options.user)
-    }
-    // the rest query params is set through the generic function.
-    const result = (await this.genericList(url, options, request)) as ContextListResult<IProjectExecution>
-    return result
-  }
-
-  /**
-   * Marks the data as deleted.
-   *
-   * @param key The key of the object to delete.
-   */
-  async delete(key: string, request: SdkOptions = {}): Promise<void> {
-    const url = this.sdk.getUrl(RouteBuilder.projectExecution(key))
-    return this.genericDelete(url, request)
-  }
-
-  /**
-   * Deletes a history in a bulk operation.
-   *
-   * @param keys The list of history keys to delete.
-   */
-  async deleteBulk(keys: string[], request: SdkOptions = {}): Promise<IBulkOperationResult<ContextDeleteRecord>> {
-    const url = this.sdk.getUrl(RouteBuilder.projectExecutionBulkDelete())
-    return this.genericBatchDelete(url, keys, request)
-  }
-
-  /**
-   * Clears the datastore from history for a organization.
-   *
-   * @param organization The parent organization key
-   */
-  async clearOrganization(organization: string, request: SdkOptions = {}): Promise<void> {
-    const url = this.sdk.getUrl(RouteBuilder.projectExecutionClear('organization'))
-    url.searchParams.set('organization', organization)
-    await this.genericDelete(url, request)
-  }
-
-  /**
-   * Clears all history from a project
-   *
-   * @param project The parent project key
-   */
-  async clearProject(organization: string, project: string, request: SdkOptions = {}): Promise<void> {
-    const url = this.sdk.getUrl(RouteBuilder.projectExecutionClear('project'))
-    url.searchParams.set('organization', organization)
-    url.searchParams.set('project', project)
-    await this.genericDelete(url, request)
-  }
-
-  /**
-   * Clears all history from a folder
-   *
-   * @param project The parent project key
-   */
-  async clearParent(organization: string, project: string, folder: string, request: SdkOptions = {}): Promise<void> {
-    const url = this.sdk.getUrl(RouteBuilder.projectExecutionClear('folder'))
-    url.searchParams.set('organization', organization)
-    url.searchParams.set('project', project)
-    url.searchParams.set('folder', folder)
-    await this.genericDelete(url, request)
-  }
-}

package/src/sdk/WsClient.ts

@@ -1,28 +0,0 @@
-import WebSocketNode from 'ws'
-import { SdkBase } from './SdkBase.js'
-
-export abstract class WsClient extends SdkBase {
-  /**
-   * Creates a WS client with optional token
-   * @param addr The ws:// address
-   * @param token Optional token to add.
-   */
-  abstract getClient(addr: string, token?: string): WebSocket | WebSocketNode
-
-  /**
-   * Connect to the WS server
-   *
-   * @param client The client to wait for connection.
-   */
-  abstract connect(client: WebSocket | WebSocketNode): Promise<void>
-
-  /**
-   * Disconnects from the WS server.
-   */
-  abstract disconnect(client: WebSocket | WebSocketNode): Promise<void>
-
-  /**
-   * The combination of `getClient()` and `connect()`.
-   */
-  abstract createAndConnect(addr: string, token?: string): Promise<WebSocket | WebSocketNode>
-}

package/src/sdk/WsClientNode.ts

@@ -1,68 +0,0 @@
-import WebSocket from 'ws'
-import { WsClient } from './WsClient.js'
-
-export class WsClientNode extends WsClient {
-  /**
-   * Creates a WS client with optional token
-   * @param addr The ws:// address
-   * @param token Optional token to add.
-   */
-  getClient(addr: string, token?: string): WebSocket {
-    let url = addr
-    if (token) {
-      url += url.includes('?') ? '&' : '?'
-      url += 'token='
-      url += token
-    }
-    if (url.startsWith('http:')) {
-      url = `ws:${url.substring(5)}`
-    } else if (url.startsWith('https:')) {
-      url = `wss:${url.substring(6)}`
-    }
-    return new WebSocket(url)
-  }
-
-  /**
-   * Connect to the WS server
-   *
-   * @param client The client to wait for connection.
-   */
-  connect(client: WebSocket): Promise<void> {
-    return new Promise((resolve, reject) => {
-      client.once('open', () => {
-        client.removeAllListeners('error')
-        resolve()
-      })
-      client.once('error', (err) => {
-        client.removeAllListeners('open')
-        reject(err)
-      })
-    })
-  }
-
-  /**
-   * Disconnects from the WS server.
-   */
-  disconnect(client: WebSocket): Promise<void> {
-    return new Promise((resolve, reject) => {
-      client.once('close', () => {
-        client.removeAllListeners('error')
-        resolve()
-      })
-      client.once('error', (err) => {
-        client.removeAllListeners('close')
-        reject(err)
-      })
-      client.close()
-    })
-  }
-
-  /**
-   * The combination of `getClient()` and `connect()`.
-   */
-  async createAndConnect(addr: string, token?: string): Promise<WebSocket> {
-    const client = this.getClient(addr, token)
-    await this.connect(client)
-    return client
-  }
-}

package/src/sdk/WsClientWeb.ts

@@ -1,75 +0,0 @@
-import { WsClient } from './WsClient.js'
-
-export class WsClientWeb extends WsClient {
-  /**
-   * Creates a WS client with optional token
-   * @param addr The ws:// address
-   * @param token Optional token to add.
-   */
-  getClient(addr: string, token?: string): WebSocket {
-    let url = addr
-    if (token) {
-      url += url.includes('?') ? '&' : '?'
-      url += 'token='
-      url += token
-    }
-    if (url.startsWith('http:')) {
-      url = `ws:${url.substring(5)}`
-    } else if (url.startsWith('https:')) {
-      url = `wss:${url.substring(6)}`
-    }
-    return new WebSocket(url)
-  }
-
-  /**
-   * Connect to the WS server
-   *
-   * @param client The client to wait for connection.
-   */
-  connect(client: WebSocket): Promise<void> {
-    return new Promise((resolve, reject) => {
-      function opened(): void {
-        client.removeEventListener('open', opened)
-        client.removeEventListener('error', errored)
-        resolve()
-      }
-      function errored(): void {
-        client.removeEventListener('open', opened)
-        client.removeEventListener('error', errored)
-        reject(new Error(`Unable to connect to: ${client.url}`))
-      }
-      client.addEventListener('open', opened)
-      client.addEventListener('error', errored)
-    })
-  }
-
-  /**
-   * Disconnects from the WS server.
-   */
-  disconnect(client: WebSocket): Promise<void> {
-    return new Promise((resolve, reject) => {
-      function closed(): void {
-        client.removeEventListener('close', closed)
-        client.removeEventListener('error', errored)
-        resolve()
-      }
-      function errored(): void {
-        client.removeEventListener('close', closed)
-        client.removeEventListener('error', errored)
-        reject(new Error(`Unable to connect to: ${client.url}`))
-      }
-      client.addEventListener('close', closed)
-      client.addEventListener('error', errored)
-      client.close()
-    })
-  }
-
-  /**
-   * The combination of `getClient()` and `connect()`.
-   */
-  async createAndConnect(addr: string, token?: string): Promise<WebSocket> {
-    const client = this.getClient(addr, token)
-    await this.connect(client)
-    return client
-  }
-}

package/src/testing/TestCliHelper.ts

@@ -1,93 +0,0 @@
-/* eslint-disable no-restricted-globals */
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable no-console */
-export interface ITestRunCommandOptions {
-  includeError?: boolean
-  noCleaning?: boolean
-}
-
-export class TestCliHelper {
-  /**
-   * The globally set test timeout.
-   * @default 2000 The mocha default test timeout.
-   */
-  static testTimeout = 2000
-
-  static cleanTerminalOutput(s: string): string {
-    let result = s.trim()
-    result = result.replace(/[^\x20-\x7E\n]/gm, '')
-    // result = result.replace(/\[\d+m/gm, '');
-    result = result.replace(/\[\d+[a-zA-Z]/gm, '')
-    result = result
-      .split('\n')
-      .filter((i) => !!i.trim())
-      .join('\n')
-    return result
-  }
-
-  static splitLines(table: string): string[] {
-    const result: string[] = []
-    table.split('\n').forEach((line) => {
-      const value = line.trim()
-      if (!value) {
-        return
-      }
-      result.push(value)
-    })
-    return result
-  }
-
-  /**
-   * Executes a passed asynchronous function and captures stdout.
-   * When the function fails, it cleans up output listeners and throws the error.
-   *
-   * ```javascript
-   * const out = grabOutput(async () => {
-   *  // ...
-   * });
-   * console.log(out); // combined stdout and stderr.
-   * ```
-   *
-   * @param fn The function to execute.
-   * @param timeout The test timeout. After this time the output is reset.
-   * @returns The terminal output.
-   */
-  static async grabOutput(fn: () => Promise<void>, timeout = TestCliHelper.testTimeout): Promise<string> {
-    const messages: string[] = []
-    function noop(): void {
-      //
-    }
-    const origOut = process.stdout.write
-    const origErr = process.stderr.write
-    const origClear = console.clear
-    function messageHandler(buffer: string | Buffer): boolean {
-      if (typeof buffer === 'string') {
-        messages.push(buffer)
-      } else {
-        messages.push(buffer.toString('utf8'))
-      }
-      return true
-    }
-    function stop(): void {
-      process.stdout.write = origOut
-      process.stderr.write = origErr
-      console.clear = origClear
-    }
-    process.stdout.write = messageHandler
-    process.stderr.write = messageHandler
-    console.clear = noop
-
-    const handle = setTimeout(() => stop(), timeout)
-
-    try {
-      await fn()
-      stop()
-      clearTimeout(handle)
-    } catch (e) {
-      stop()
-      clearTimeout(handle)
-      throw e
-    }
-    return messages.join('')
-  }
-}