@api-client/core 0.20.10 → 0.21.1

package/src/mocking/legacy/Urls.ts

@@ -1,46 +0,0 @@
-import { Time } from '@pawel-up/data-mock/Time.js'
-import { Types } from '@pawel-up/data-mock/Types.js'
-import { Internet } from '@pawel-up/data-mock/Internet.js'
-import { ArcDataMockInit } from '../LegacyInterfaces.js'
-import { ARCUrlHistory } from '../../models/legacy/models/UrlHistory.js'
-
-export class Urls {
-  types: Types
-  internet: Internet
-  time: Time
-
-  constructor(init: ArcDataMockInit = {}) {
-    this.types = new Types(init.seed)
-    this.internet = new Internet(init)
-    this.time = new Time(init)
-  }
-
-  /**
-   * Generates a single ARC URL model item.
-   */
-  url(): ARCUrlHistory {
-    const url = this.internet.uri()
-    const time = this.types.datetime().getTime()
-    const result: ARCUrlHistory = {
-      time,
-      cnt: this.types.number({ min: 100, max: 1000 }),
-      _id: url,
-      url,
-      midnight: this.time.midnight(time),
-    }
-    return result
-  }
-
-  /**
-   * Generates list of ARC URL models.
-   *
-   * @returns List of datastore entries.
-   */
-  urls(size = 25): ARCUrlHistory[] {
-    const result = []
-    for (let i = 0; i < size; i++) {
-      result.push(this.url())
-    }
-    return result
-  }
-}

package/src/mocking/legacy/Variables.ts

@@ -1,54 +0,0 @@
-import { Lorem } from '@pawel-up/data-mock/Lorem.js'
-import { Types } from '@pawel-up/data-mock/Types.js'
-import { ArcDataMockInit, VariableInit } from '../LegacyInterfaces.js'
-import { ARCVariable } from '../../models/legacy/models/Variable.js'
-
-export class Variables {
-  types: Types
-  lorem: Lorem
-
-  constructor(init: ArcDataMockInit = {}) {
-    this.types = new Types(init.seed)
-    this.lorem = new Lorem(init)
-  }
-
-  /**
-   * Generates a random variable
-   */
-  variable(init: VariableInit = {}): ARCVariable {
-    let isDefault
-    if (init.defaultEnv) {
-      isDefault = true
-    } else if (init.randomEnv) {
-      isDefault = false
-    } else {
-      isDefault = this.types.boolean()
-    }
-
-    const result = /** @type ARCVariable */ {
-      enabled: this.types.boolean({ likelihood: 85 }),
-      value: this.lorem.sentence({ words: 2 }),
-      name: this.lorem.word(),
-      _id: this.types.uuid(),
-      environment: '',
-    }
-    if (isDefault) {
-      result.environment = 'default'
-    } else {
-      result.environment = this.lorem.sentence({ words: 2 })
-    }
-    return result
-  }
-
-  /**
-   * Generates a number of variables.
-   * @param size The number of variables to generate.
-   */
-  listVariables(size = 25, init: VariableInit = {}): ARCVariable[] {
-    const result = []
-    for (let i = 0; i < size; i++) {
-      result.push(this.variable(init))
-    }
-    return result
-  }
-}

package/src/mocking/lib/Certificates.ts

@@ -1,64 +0,0 @@
-import { Lorem } from '@pawel-up/data-mock/Lorem.js'
-import { Random } from '@pawel-up/data-mock/Random.js'
-import { Types } from '@pawel-up/data-mock/Types.js'
-import type { IDataMockInit } from '@pawel-up/data-mock/types.js'
-import { strToBuffer } from '@pawel-up/data-mock/Utils.js'
-import { HttpCertificate, Certificate, ICertificateData } from '../../models/ClientCertificate.js'
-
-export declare interface CertificateCreateInit {
-  binary?: boolean
-  noPassphrase?: boolean
-  type?: 'p12' | 'pem'
-}
-
-export class Certificates {
-  lorem: Lorem
-  types: Types
-  random: Random
-
-  constructor(init: IDataMockInit = {}) {
-    this.lorem = new Lorem(init)
-    this.types = new Types(init.seed)
-    this.random = new Random(init.seed)
-  }
-
-  /**
-   * Creates a certificate definition.
-   */
-  certificate(opts: CertificateCreateInit = {}): HttpCertificate {
-    const type = opts.type ? opts.type : this.random.pickOne(['p12', 'pem'])
-    const data = this.lorem.paragraph()
-    const cert = opts.binary ? strToBuffer(data) : data
-    let instance: Certificate
-    if (type === 'p12') {
-      instance = Certificate.fromP12(cert, this.lorem.word())
-    } else if (type === 'pem') {
-      instance = Certificate.fromPem(cert, cert, this.lorem.word())
-    } else {
-      throw new Error(`Invalid certificate type.`)
-    }
-    if (!opts.noPassphrase) {
-      instance.cert.passphrase = this.lorem.word()
-      if (type === 'pem') {
-        const key = instance.certKey as ICertificateData
-        key.passphrase = this.lorem.word()
-      }
-    }
-
-    return instance.toJSON()
-  }
-
-  /**
-   * Creates a list of ClientCertificate objects that are used to create a new certificates.
-   *
-   * @param size The number of certificates to generate.
-   * @param opts Create options
-   */
-  certificates(size = 15, opts: CertificateCreateInit = {}): HttpCertificate[] {
-    const result: HttpCertificate[] = []
-    for (let i = 0; i < size; i++) {
-      result[result.length] = this.certificate(opts)
-    }
-    return result
-  }
-}

package/src/mocking/lib/History.ts

@@ -1,187 +0,0 @@
-import type { IDataMockInit, ITypeDateTimeInit } from '@pawel-up/data-mock/types.js'
-import { Random } from '@pawel-up/data-mock/Random.js'
-import { Types } from '@pawel-up/data-mock/Types.js'
-import { Internet } from '@pawel-up/data-mock/Internet.js'
-import { Person } from '@pawel-up/data-mock/Person.js'
-// import { randomValue } from '@pawel-up/data-mock/src/lib/Http.js';
-import { IHttpHistory, Kind as HttpHistoryKind } from '../../models/HttpHistory.js'
-import { Request, IRequestLogInit } from './Request.js'
-
-export interface IHttpHistoryInit {
-  /**
-   * Either organization id, list of organizations to pick one or whether to generate a organization.
-   */
-  organization?: boolean | string | string[]
-  /**
-   * User is always generated per store requirements.
-   */
-  user?: string | string[]
-  /**
-   * Either project id, list of projects to pick one or whether to generate a project.
-   */
-  project?: boolean | string | string[]
-  /**
-   * Either request id, list of requests to pick one or whether to generate a request.
-   */
-  request?: boolean | string | string[]
-  /**
-   * Either app id, list of apps to pick one or whether to generate an app.
-   */
-  app?: boolean | string | string[]
-  /**
-   * The log init options
-   */
-  log?: IRequestLogInit
-  /**
-   * The created time init options.
-   */
-  created?: ITypeDateTimeInit
-}
-
-export interface IHttpHistoryListInit extends IHttpHistoryInit {
-  /**
-   * When set it generates as many user IDs.
-   * Ignored when the `user` is set.
-   */
-  usersSize?: number
-  /**
-   * When set it generates as many organization ids.
-   * Ignored when the `organization` is set.
-   */
-  organizationSize?: number
-  /**
-   * When set it generates as many project ids.
-   * Ignored when the `project` is set.
-   */
-  projectsSize?: number
-  /**
-   * When set it generates as many request ids.
-   * Ignored when the `request` is set.
-   */
-  requestsSize?: number
-  /**
-   * When set it generates as many app ids.
-   * Ignored when the `app` is set.
-   */
-  appsSize?: number
-}
-
-export class History {
-  person: Person
-  types: Types
-  internet: Internet
-  random: Random
-  request: Request
-
-  constructor(init: IDataMockInit = {}) {
-    this.person = new Person(init)
-    this.types = new Types(init.seed)
-    this.internet = new Internet(init)
-    this.random = new Random(init.seed)
-    this.request = new Request(init)
-  }
-
-  async httpHistory(init: IHttpHistoryInit = {}): Promise<IHttpHistory> {
-    const date = this.types.datetime(init.created)
-    const result: IHttpHistory = {
-      kind: HttpHistoryKind,
-      created: date.getTime(),
-      log: await this.request.log(init.log),
-      user: '',
-      app: '',
-      key: '',
-      project: '',
-      request: '',
-      organization: '',
-    }
-    date.setHours(0, 0, 0, 0)
-    result.midnight = date.getTime()
-
-    if (typeof init.organization === 'string') {
-      result.organization = init.organization
-    } else if (Array.isArray(init.organization)) {
-      result.organization = this.random.pickOne(init.organization)
-    } else if (init.organization) {
-      result.organization = this.types.string(10)
-    }
-
-    if (typeof init.user === 'string') {
-      result.user = init.user
-    } else if (Array.isArray(init.user)) {
-      result.user = this.random.pickOne(init.user)
-    } else {
-      result.user = this.types.string(21)
-    }
-
-    if (typeof init.project === 'string') {
-      result.project = init.project
-    } else if (Array.isArray(init.project)) {
-      result.project = this.random.pickOne(init.project)
-    } else if (init.project) {
-      result.project = this.types.string(21)
-    }
-
-    if (typeof init.request === 'string') {
-      result.request = init.request
-    } else if (Array.isArray(init.request)) {
-      result.request = this.random.pickOne(init.request)
-    } else if (init.request) {
-      result.request = this.types.string(21)
-    }
-
-    if (typeof init.app === 'string') {
-      result.app = init.app
-    } else if (Array.isArray(init.app)) {
-      result.app = this.random.pickOne(init.app)
-    } else if (init.app) {
-      result.app = this.types.string(21)
-    }
-    return result
-  }
-
-  async httpHistoryList(size = 25, init: IHttpHistoryListInit = {}): Promise<IHttpHistory[]> {
-    const { usersSize, organizationSize, projectsSize, requestsSize, appsSize } = init
-    const copy = { ...init }
-    if (usersSize && typeof init.user === 'undefined') {
-      const users: string[] = []
-      for (let i = 0; i < usersSize; i++) {
-        users.push(this.types.string(21))
-      }
-      copy.user = users
-    }
-    if (organizationSize && typeof init.organization === 'undefined') {
-      const organization: string[] = []
-      for (let i = 0; i < organizationSize; i++) {
-        organization.push(this.types.string(10))
-      }
-      copy.organization = organization
-    }
-    if (projectsSize && typeof init.project === 'undefined') {
-      const project: string[] = []
-      for (let i = 0; i < projectsSize; i++) {
-        project.push(this.types.string(21))
-      }
-      copy.project = project
-    }
-    if (requestsSize && typeof init.request === 'undefined') {
-      const requests: string[] = []
-      for (let i = 0; i < requestsSize; i++) {
-        requests.push(this.types.string(21))
-      }
-      copy.request = requests
-    }
-    if (appsSize && typeof init.app === 'undefined') {
-      const apps: string[] = []
-      for (let i = 0; i < appsSize; i++) {
-        apps.push(this.types.string(21))
-      }
-      copy.app = apps
-    }
-
-    const result: IHttpHistory[] = []
-    for (let i = 0; i < size; i++) {
-      result.push(await this.httpHistory(copy))
-    }
-    return result
-  }
-}

package/src/mocking/lib/HostRules.ts

@@ -1,45 +0,0 @@
-import type { IDataMockInit } from '@pawel-up/data-mock/types.js'
-import { Types } from '@pawel-up/data-mock/Types.js'
-import { Internet } from '@pawel-up/data-mock/Internet.js'
-import { Lorem } from '@pawel-up/data-mock/Lorem.js'
-import { IHostRule } from '../../models/HostRule.js'
-
-export class HostRules {
-  types: Types
-  lorem: Lorem
-  internet: Internet
-
-  constructor(init: IDataMockInit = {}) {
-    this.types = new Types(init.seed)
-    this.lorem = new Lorem(init)
-    this.internet = new Internet(init)
-  }
-
-  /**
-   * Generates random host rule data object.
-   */
-  rule(): IHostRule {
-    const result: IHostRule = {
-      key: this.types.string(21),
-      from: this.internet.uri(),
-      to: this.internet.uri(),
-      enabled: this.types.boolean(),
-      comment: this.lorem.paragraph(),
-    }
-    return result
-  }
-
-  /**
-   * Generates a list of host rules.
-   *
-   * @param size Number of items to generate. Default to 25.
-   * @return List of datastore entries.
-   */
-  rules(size = 25): IHostRule[] {
-    const result = []
-    for (let i = 0; i < size; i++) {
-      result.push(this.rule())
-    }
-    return result
-  }
-}

package/src/mocking/lib/Request.ts

@@ -1,100 +0,0 @@
-import type { IDataMockInit, IHttpRequestInit } from '@pawel-up/data-mock/types.js'
-import { Types } from '@pawel-up/data-mock/Types.js'
-import { Time } from '@pawel-up/data-mock/Time.js'
-import { Lorem } from '@pawel-up/data-mock/Lorem.js'
-import Http from '@pawel-up/data-mock/Http.js'
-// import { randomValue } from '@pawel-up/data-mock/src/lib/Http.js';
-import { IHttpRequest, Kind as HttpRequestKind } from '../../models/HttpRequest.js'
-import { IRequest, Kind as RequestKind, Request as RequestModel } from '../../models/Request.js'
-import { ISentRequest } from '../../models/SentRequest.js'
-import { IRequestLog, Kind as RequestLogKind } from '../../models/RequestLog.js'
-import { IResponseInit, Response } from './Response.js'
-
-export interface IRequestLogInit {
-  request?: IHttpRequestInit
-  response?: IResponseInit
-  /**
-   * When set it ignores size information
-   */
-  noSize?: boolean
-  /**
-   * Adds redirects to the request
-   */
-  redirects?: boolean
-  noResponse?: boolean
-  noRequest?: boolean
-}
-
-export interface IRequestInit extends IResponseInit {
-  /**
-   * The content type to generate the body for.
-   * Has no effect when `noBody` is set.
-   */
-  contentType?: string
-}
-
-export class Request {
-  types: Types
-  lorem: Lorem
-  time: Time
-  http: Http
-  response: Response
-
-  constructor(init: IDataMockInit = {}) {
-    this.types = new Types(init.seed)
-    this.lorem = new Lorem(init)
-    this.time = new Time(init)
-    this.http = new Http(init)
-    this.response = new Response(init)
-  }
-
-  request(init?: IHttpRequestInit): IRequest {
-    const schema = {
-      kind: RequestKind,
-      expects: this.httpRequest(init),
-      info: {
-        name: this.lorem.words(2),
-        description: this.lorem.paragraph(),
-      },
-      created: this.time.timestamp(),
-    }
-    const instance = new RequestModel(schema)
-    return instance.toJSON()
-  }
-
-  httpRequest(init?: IHttpRequestInit): IHttpRequest {
-    const request = this.http.request.request(init)
-    return {
-      kind: HttpRequestKind,
-      ...request,
-    }
-  }
-
-  sentRequest(init?: IHttpRequestInit): ISentRequest {
-    const start = this.time.timestamp()
-    return {
-      startTime: start,
-      endTime: this.time.timestamp({ min: start + 1 }),
-      ...this.httpRequest(init),
-    }
-  }
-
-  async log(init: IRequestLogInit = {}): Promise<IRequestLog> {
-    const result: IRequestLog = {
-      kind: RequestLogKind,
-    }
-    if (!init.noRequest) {
-      result.request = this.sentRequest(init.request)
-    }
-    if (!init.noResponse) {
-      result.response = await this.response.response(init.response)
-    }
-    if (init.redirects) {
-      result.redirects = await this.response.redirects(undefined, init.response)
-    }
-    if (!init.noSize) {
-      result.size = this.response.size()
-    }
-    return result
-  }
-}

package/src/mocking/lib/Response.ts

@@ -1,121 +0,0 @@
-import type { IDataMockInit, IHttpResponseInit, IHarTimingInit, IHttpPayloadInit } from '@pawel-up/data-mock/types.js'
-import { Types } from '@pawel-up/data-mock/Types.js'
-import { Time } from '@pawel-up/data-mock/Time.js'
-import { Lorem } from '@pawel-up/data-mock/Lorem.js'
-import { Internet } from '@pawel-up/data-mock/Internet.js'
-import { Har } from '@pawel-up/data-mock/Har.js'
-import Http from '@pawel-up/data-mock/Http.js'
-import { IHttpResponse, HttpResponse } from '../../models/HttpResponse.js'
-import { IResponse } from '../../models/Response.js'
-import { IRequestsSize } from '../../models/RequestsSize.js'
-import { IResponseRedirect, Kind as ResponseRedirectKind } from '../../models/ResponseRedirect.js'
-import { DeserializedPayload } from '../../lib/transformers/PayloadSerializer.js'
-import { HttpResponseKind, ResponseKind } from '../../models/kinds.js'
-
-export interface IResponseInit extends IHttpResponseInit, IHarTimingInit {
-  /**
-   * The first number of the status group. Other 2 are auto generated
-   */
-  statusGroup?: number
-  /**
-   * Whether to generate timings object
-   */
-  timings?: boolean
-}
-
-export class Response {
-  types: Types
-  lorem: Lorem
-  time: Time
-  http: Http
-  har: Har
-  internet: Internet
-
-  constructor(init: IDataMockInit = {}) {
-    this.types = new Types(init.seed)
-    this.lorem = new Lorem(init)
-    this.time = new Time(init)
-    this.http = new Http(init)
-    this.har = new Har(init)
-    this.internet = new Internet(init)
-  }
-
-  protected _getPayload(mime?: string): DeserializedPayload {
-    if (!mime) {
-      return undefined
-    }
-    switch (mime) {
-      case 'multipart/form-data':
-        return this.http.formData.form()
-      default:
-        return this.http.payload.payload(mime as string)
-    }
-  }
-
-  async httpResponse(init: IResponseInit = {}): Promise<IHttpResponse> {
-    const mime = this.http.headers.contentType(init.payload as IHttpPayloadInit)
-    const body = this._getPayload(mime)
-    const headers = this.http.headers.headers('response', { mime: mime })
-    const statusGroup = init.statusGroup ? init.statusGroup : this.types.number({ min: 2, max: 5 })
-    const sCode = this.types.number({ min: 0, max: 99 }).toString()
-    const code = Number(`${statusGroup}${sCode.padStart(2, '0')}`)
-    const status = this.lorem.word()
-    const result: IHttpResponse = {
-      kind: HttpResponseKind,
-      status: code,
-      statusText: status,
-      headers,
-    }
-    const response = new HttpResponse(result)
-    if (body) {
-      await response.writePayload(body)
-    }
-    return response.toJSON()
-  }
-
-  async response(init: IResponseInit = {}): Promise<IResponse> {
-    const base = await this.httpResponse(init)
-    const length = this.types.number({ min: 10, max: 4000 })
-    const result: IResponse = {
-      ...base,
-      kind: ResponseKind,
-      loadingTime: length,
-    }
-    if (init.timings) {
-      result.timings = this.har.timing(init)
-    }
-    return result
-  }
-
-  size(): IRequestsSize {
-    const result: IRequestsSize = {
-      request: this.types.number({ min: 10 }),
-      response: this.types.number({ min: 10 }),
-    }
-    return result
-  }
-
-  async redirect(init: IResponseInit = {}): Promise<IResponseRedirect> {
-    const start = this.time.timestamp()
-    const end = this.time.timestamp({ min: start + 1 })
-    const info: IResponseRedirect = {
-      kind: ResponseRedirectKind,
-      startTime: start,
-      endTime: end,
-      url: this.internet.uri(),
-      response: await this.httpResponse({ ...init, statusGroup: 3 }),
-    }
-    if (init.timings) {
-      info.timings = this.har.timing(init)
-    }
-    return info
-  }
-
-  async redirects(size = 1, init?: IResponseInit): Promise<IResponseRedirect[]> {
-    const result: Promise<IResponseRedirect>[] = []
-    for (let i = 0; i < size; i++) {
-      result.push(this.redirect(init))
-    }
-    return Promise.all(result)
-  }
-}

package/src/mocking/lib/Url.ts

@@ -1,45 +0,0 @@
-import type { IDataMockInit } from '@pawel-up/data-mock/types.js'
-import { Types } from '@pawel-up/data-mock/Types.js'
-import { Time } from '@pawel-up/data-mock/Time.js'
-import { Internet } from '@pawel-up/data-mock/Internet.js'
-import { IUrl } from '../../models/Url.js'
-
-export class Url {
-  types: Types
-  internet: Internet
-  time: Time
-
-  constructor(init: IDataMockInit = {}) {
-    this.types = new Types(init.seed)
-    this.internet = new Internet(init)
-    this.time = new Time(init)
-  }
-
-  /**
-   * Generates a single ARC URL model item.
-   */
-  url(): IUrl {
-    const url = this.internet.uri()
-    const time = this.types.datetime().getTime()
-    const result: IUrl = {
-      time,
-      cnt: this.types.number({ min: 100, max: 1000 }),
-      key: url,
-      midnight: this.time.midnight(time),
-    }
-    return result
-  }
-
-  /**
-   * Generates list of ARC URL models.
-   *
-   * @returns List of datastore entries.
-   */
-  urls(size = 25): IUrl[] {
-    const result: IUrl[] = []
-    for (let i = 0; i < size; i++) {
-      result.push(this.url())
-    }
-    return result
-  }
-}