@api-client/core 0.20.10 → 0.21.0

package/src/models/HttpRequest.ts

@@ -1,166 +0,0 @@
-import { ISerializablePayload, SerializablePayload, SerializablePayloadOptions } from './SerializablePayload.js'
-import { IProperty } from './Property.js'
-import { HeadersArray } from './HeadersArray.js'
-
-export const Kind = 'Core#HttpRequest'
-
-export interface IBaseHttpRequest extends ISerializablePayload {
-  /**
-   * The request URL
-   */
-  url: string
-  /**
-   * HTTP method name
-   * Defaults to "GET".
-   */
-  method?: string
-  /**
-   * HTTP headers string
-   */
-  headers?: string
-}
-
-/**
- * The most basic HTTP request.
- */
-export interface IHttpRequest extends IBaseHttpRequest {
-  kind?: string
-
-  /**
-   * Headers model, if any.
-   * When reading headers string, the value of `headers` is preferred over the model.
-   */
-  headersModel?: IProperty[]
-
-  /**
-   * Optional meta of the payload
-   */
-  payloadOptions?: SerializablePayloadOptions
-}
-
-/**
- * The base model of an HTTP request.
- *
- * **Note about the payload.**
- *
- * The payload is **always** stored in the request object in its serialized form.
- * Use the `readPayload()` to read the correct data type and the `writePayload()` to
- * safely store the payload.
- */
-export class HttpRequest extends SerializablePayload {
-  kind = Kind
-  /**
-   * The request URL
-   */
-  url = ''
-  /**
-   * HTTP method name.
-   * Defaults to "GET".
-   */
-  method = 'GET'
-  /**
-   * HTTP headers string
-   */
-  headers?: string
-
-  /**
-   * Headers model, if any.
-   * When reading headers string, the value of `headers` is preferred over the model.
-   */
-  headersModel?: HeadersArray
-
-  static fromBaseValues(values: IBaseHttpRequest): HttpRequest {
-    return new HttpRequest({
-      ...values,
-      kind: Kind,
-    })
-  }
-
-  /**
-   * @param input The request definition used to restore the state.
-   */
-  constructor(input?: string | IHttpRequest) {
-    super()
-    let init: IHttpRequest
-    if (typeof input === 'string') {
-      init = JSON.parse(input)
-    } else if (typeof input === 'object') {
-      init = input
-    } else {
-      init = {
-        kind: Kind,
-        url: '',
-        method: 'GET',
-      }
-    }
-    this.new(init)
-  }
-
-  /**
-   * Creates a new request clearing anything that is so far defined.
-   *
-   * Note, this throws an error when the object is not a request.
-   */
-  new(init: IHttpRequest): void {
-    const { url, method = 'GET', headers, payload, kind = Kind, headersModel, payloadOptions } = init
-    this.kind = kind
-    this.url = url
-    this.method = method
-    this.headers = headers
-    this.payload = payload
-    if (Array.isArray(headersModel)) {
-      this.headersModel = HeadersArray.from(headersModel)
-    } else {
-      this.headersModel = undefined
-    }
-    if (payloadOptions) {
-      this.payloadOptions = payloadOptions
-    } else {
-      this.payloadOptions = undefined
-    }
-  }
-
-  /**
-   * Checks whether the input is a definition of an HTTP request.
-   */
-  static isHttpRequest(input: unknown): boolean {
-    const typed = input as IHttpRequest
-    if (!input || typed.kind !== Kind) {
-      return false
-    }
-    return true
-  }
-
-  override toJSON(): IHttpRequest {
-    const result: IHttpRequest = {
-      ...super.toJSON(),
-      kind: this.kind,
-      url: this.url,
-      method: this.method,
-    }
-    if (this.headers) {
-      result.headers = this.headers
-    }
-    if (this.headersModel) {
-      result.headersModel = this.headersModel.toJSON()
-    }
-    return result
-  }
-
-  /**
-   * It reads headers from the request.
-   * It prefers `headers` string over `headersModel` so set only the model
-   * if the application should only use model.
-   * @returns The HTTP headers string from the current headers.
-   */
-  toHeadersString(): string {
-    const { headers, headersModel } = this
-    if (headers) {
-      return headers
-    }
-    if (headersModel) {
-      return headersModel.toString()
-    }
-    return ''
-  }
-}

package/src/models/HttpResponse.ts

@@ -1,136 +0,0 @@
-import { ISerializablePayload, SerializablePayload } from './SerializablePayload.js'
-import { PayloadSerializer } from '../lib/transformers/PayloadSerializer.js'
-import { HTTPResponse as LegacyHttpResponse } from './legacy/request/ArcResponse.js'
-import { Normalizer } from './legacy/Normalizer.js'
-import { HttpResponseKind } from './kinds.js'
-
-export interface IHttpResponse extends ISerializablePayload {
-  kind?: string
-  /**
-   * The response status code
-   */
-  status: number
-  /**
-   * The reason part of the status message
-   */
-  statusText?: string
-  /**
-   * The response headers
-   */
-  headers?: string
-}
-
-export class HttpResponse extends SerializablePayload {
-  kind = HttpResponseKind
-  /**
-   * The response status code
-   */
-  status = 0
-  /**
-   * The reason part of the status message
-   */
-  statusText?: string
-  /**
-   * The response headers
-   */
-  headers?: string
-
-  static fromValues(status: number, statusText?: string, headers?: string): HttpResponse {
-    return new HttpResponse({
-      kind: HttpResponseKind,
-      status,
-      statusText,
-      headers,
-    })
-  }
-
-  static async fromLegacy(response: LegacyHttpResponse): Promise<HttpResponse> {
-    const init: IHttpResponse = {
-      kind: HttpResponseKind,
-      status: response.status || 0,
-    }
-    if (response.statusText) {
-      init.statusText = response.statusText
-    }
-    if (response.headers) {
-      init.headers = response.headers
-    }
-    if (response.payload) {
-      const orig = Normalizer.restoreTransformedPayload(response.payload)
-      if (orig) {
-        init.payload = await PayloadSerializer.serialize(orig)
-      }
-    }
-    return new HttpResponse(init)
-  }
-
-  /**
-   * @param input The response definition used to restore the state.
-   */
-  constructor(input?: string | IHttpResponse) {
-    super()
-    let init: IHttpResponse
-    if (typeof input === 'string') {
-      init = JSON.parse(input)
-    } else if (typeof input === 'object') {
-      init = input
-    } else {
-      init = {
-        kind: HttpResponseKind,
-        status: 0,
-      }
-    }
-    this.new(init)
-  }
-
-  /**
-   * Creates a new response clearing anything that is so far defined.
-   *
-   * Note, this throws an error when the object is not a response.
-   */
-  new(init: IHttpResponse): void {
-    if (!HttpResponse.isHttpResponse(init)) {
-      throw new Error(`Not a response.`)
-    }
-    const { status, statusText, headers, payload, kind = HttpResponseKind } = init
-    this.kind = kind
-    this.status = status
-    this.statusText = statusText
-    this.headers = headers
-    this.payload = payload
-  }
-
-  /**
-   * Checks whether the input is a definition of an HTTP response.
-   */
-  static isHttpResponse(input: unknown): boolean {
-    const typed = input as IHttpResponse
-    if (!input || typeof typed.status !== 'number') {
-      return false
-    }
-    return true
-  }
-
-  override toJSON(): IHttpResponse {
-    const result: IHttpResponse = {
-      ...super.toJSON(),
-      kind: this.kind,
-      status: this.status,
-    }
-    if (this.statusText) {
-      result.statusText = this.statusText
-    }
-    if (this.headers) {
-      result.headers = this.headers
-    }
-    return result
-  }
-
-  /**
-   * A shortcut function to create an instance from a response object and to read the payload of it as string.
-   */
-  static readPayloadAsString(info: IHttpResponse): Promise<string | undefined> {
-    const request = new HttpResponse(info)
-    return request.readPayloadAsString()
-  }
-}

package/src/models/License.ts

@@ -1,113 +0,0 @@
-export const Kind = 'Core#License'
-
-export interface ILicense {
-  kind: typeof Kind
-  /**
-   * The URL to the license text.
-   * Only `url` or `content` can be used at a time.
-   */
-  url?: string
-  /**
-   * The name of the license.
-   */
-  name?: string
-  /**
-   * The content of the license.
-   * Only `url` or `content` can be used at a time.
-   */
-  content?: string
-}
-
-export class License {
-  kind = Kind
-  /**
-   * The URL to the license text.
-   * Only `url` or `content` can be used at a time.
-   */
-  url?: string
-  /**
-   * The name of the license.
-   */
-  name?: string
-  /**
-   * The content of the license.
-   * Only `url` or `content` can be used at a time.
-   */
-  content?: string
-
-  static fromUrl(url: string, name?: string): License {
-    return new License({
-      kind: Kind,
-      url,
-      name,
-    })
-  }
-
-  static fromContent(content: string, name?: string): License {
-    return new License({
-      kind: Kind,
-      content,
-      name,
-    })
-  }
-
-  /**
-   * @param input The license definition used to restore the state.
-   */
-  constructor(input?: string | ILicense) {
-    let init: ILicense
-    if (typeof input === 'string') {
-      init = JSON.parse(input)
-    } else if (typeof input === 'object') {
-      init = input
-    } else {
-      init = {
-        kind: Kind,
-      }
-    }
-    this.new(init)
-  }
-
-  /**
-   * Creates a new license clearing anything that is so far defined.
-   *
-   * Note, this throws an error when the license is not a license object.
-   */
-  new(init: ILicense): void {
-    if (!License.isLicense(init)) {
-      throw new Error(`Not a license.`)
-    }
-    const { url, content, name } = init
-    this.kind = Kind
-    this.name = name
-    this.content = content
-    this.url = url
-  }
-
-  /**
-   * Checks whether the input is a definition of a license.
-   */
-  static isLicense(input: unknown): boolean {
-    const typed = input as ILicense
-    if (typed && typed.kind === Kind) {
-      return true
-    }
-    return false
-  }
-
-  toJSON(): ILicense {
-    const result: ILicense = {
-      kind: Kind,
-    }
-    if (this.name) {
-      result.name = this.name
-    }
-    if (this.url) {
-      result.url = this.url
-    }
-    if (this.content) {
-      result.content = this.content
-    }
-    return result
-  }
-}

package/src/models/Project.ts

@@ -1,93 +0,0 @@
-import { nanoid } from '../nanoid.js'
-import { IFile, File } from './store/File.js'
-import { Thing } from './Thing.js'
-import { HttpProject, IHttpProject } from './HttpProject.js'
-import { ProjectKind } from './kinds.js'
-
-/**
- * This model represents a meta data for an HTTP project stored with the data store.
- * This does not include the HTTP project entity, though, it is referenced through the same key.
- */
-export interface IProject extends IFile {
-  kind: typeof ProjectKind
-}
-
-/**
- * This model represents a meta data for an HTTP project stored with the data store.
- * This does not include the HTTP project entity, though, it is referenced through the same key.
- */
-export class Project extends File {
-  override kind = ProjectKind
-
-  static fromProject(project: HttpProject | IHttpProject): Project {
-    let final: IHttpProject
-    if (typeof (project as HttpProject).toJSON === 'function') {
-      final = (project as HttpProject).toJSON()
-    } else {
-      final = project as IHttpProject
-    }
-    const init: IProject = {
-      kind: ProjectKind,
-      key: project.key,
-      info: { ...final.info },
-      lastModified: { user: '', time: 0, byMe: false },
-      parents: [],
-      permissionIds: [],
-      permissions: [],
-    }
-    return new Project(init)
-  }
-
-  /**
-   * @param name The name to set.
-   */
-  static override fromName(name: string): Project {
-    return super.fromName(name, ProjectKind) as Project
-  }
-
-  constructor(input?: string | IProject) {
-    super()
-    let init: IProject
-    if (typeof input === 'string') {
-      init = JSON.parse(input)
-    } else if (typeof input === 'object') {
-      init = input
-    } else {
-      init = {
-        kind: ProjectKind,
-        key: nanoid(),
-        info: Thing.fromName('').toJSON(),
-        parents: [],
-        permissionIds: [],
-        permissions: [],
-        lastModified: { user: '', time: 0, byMe: false },
-      }
-    }
-    this.new(init)
-  }
-
-  override new(init: IProject): this {
-    if (!Project.isProject(init)) {
-      throw new Error(`Not a project file.`)
-    }
-    super.new(init)
-    this.kind = ProjectKind
-    return this
-  }
-
-  static isProject(input: unknown): boolean {
-    const typed = input as IProject
-    if (!input || typed.kind !== ProjectKind) {
-      return false
-    }
-    return true
-  }
-
-  override toJSON(): IProject {
-    const result: IProject = {
-      ...super.toJSON(),
-      kind: ProjectKind,
-    }
-    return result
-  }
-}

package/src/models/ProjectDefinitionProperty.ts

@@ -1,40 +0,0 @@
-import { HttpProject } from './HttpProject.js'
-import { ProjectFolder } from './ProjectFolder.js'
-
-export interface IProjectDefinitionProperty {
-  kind: unknown
-  key: string
-}
-
-export interface ProjectDefinitionProperty {
-  kind: unknown
-  key: string
-
-  /**
-   * A reference to the top level project object. Not set in the `HttpProject`. Otherwise it is always set.
-   */
-  project?: HttpProject
-
-  /**
-   * The callback called when the object is attached to a parent.
-   * This is called when the object is created and inserted to a project or a folder
-   * and when the object is moved between folders.
-   */
-  attachedCallback(): void
-
-  /**
-   * The callback called when the object is detached from its parent.
-   * This callback is called when the item is deleted from a folder or a project,
-   * or when the item is about to be moved to another folder.
-   */
-  detachedCallback(): void
-
-  /**
-   * @returns The instance of the HttpProject or a ProjectFolder that is a closes parent of this instance.
-   */
-  getParent(): ProjectFolder | HttpProject | undefined
-  /**
-   * @returns A reference to the parent folder or the top-level HTTP project.
-   */
-  getProject(): HttpProject
-}