@api-client/core 0.3.1 → 0.3.4

package/src/models/HttpProjectListItem.ts

@@ -0,0 +1,23 @@
+export const Kind = 'ARC#HttpProjectListItem';
+/**
+ * The HTTP Project definition to be used in lists.
+ */
+export interface IHttpProjectListItem {
+  /**
+   * The data store key of the project.
+   */
+  key: string;
+  /**
+   * Project's name
+   */
+  name: string;
+  /**
+   * Whether the project is one of the favourites.
+   * May be used by an UI to add projects to favourites.
+   */
+  favourite?: boolean;
+  /**
+   * The timestamp when the project was last updated.
+   */
+  updated: number;
+}

package/src/models/HttpRequest.ts

@@ -0,0 +1,124 @@
+import { SerializablePayload } from './SerializablePayload.js';
+import { Payload } from '../lib/transformers/PayloadSerializer.js';
+
+export const Kind = 'ARC#HttpRequest';
+
+export interface IBaseHttpRequest {
+  /**
+   * The request URL
+   */
+  url: string;
+  /**
+   * HTTP method name
+   * Defaults to "GET".
+   */
+  method?: string;
+  /**
+   * HTTP headers string
+   */
+  headers?: string;
+  /**
+   * The request payload.
+   */
+  payload?: Payload;
+}
+
+/**
+ * The most basic HTTP request.
+ */
+export interface IHttpRequest extends IBaseHttpRequest {
+  kind?: string;
+}
+
+/**
+ * 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;
+
+  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 an ARC request.
+   */
+  new(init: IHttpRequest): void {
+    const { url, method='GET', headers, payload, kind = Kind } = init;
+    this.kind = kind;
+    this.url = url;
+    this.method = method;
+    this.headers = headers;
+    this.payload = payload;
+  }
+
+  /**
+   * 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;
+  }
+
+  toJSON(): IHttpRequest {
+    const result: IHttpRequest = {
+      kind: this.kind,
+      url: this.url,
+      method: this.method,
+    };
+    if (this.headers) {
+      result.headers = this.headers;
+    }
+    if (this.payload) {
+      result.payload = this.payload;
+    }
+    return result;
+  }
+}

package/src/models/HttpResponse.ts

@@ -0,0 +1,143 @@
+import { SerializablePayload } from './SerializablePayload.js';
+import { Payload, PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
+import { HTTPResponse as LegacyHttpResponse } from './legacy/request/ArcResponse.js';
+import { Normalizer } from './legacy/Normalizer.js';
+
+export const Kind = 'ARC#HttpResponse';
+
+export interface IHttpResponse {
+  kind?: string;
+  /**
+   * The response status code
+   */
+  status: number;
+  /**
+   * The reason part of the status message
+   */
+  statusText?: string;
+  /**
+   * The response headers
+   */
+  headers?: string;
+  /**
+   * The response message
+   */
+  payload?: Payload;
+}
+
+export class HttpResponse extends SerializablePayload {
+  kind = Kind;
+  /**
+   * 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: Kind,
+      status,
+      statusText,
+      headers,
+    });
+  }
+
+  static async fromLegacy(response: LegacyHttpResponse): Promise<HttpResponse> {
+    const init: IHttpResponse = {
+      kind: Kind,
+      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: Kind,
+        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 an ARC response.
+   */
+  new(init: IHttpResponse): void {
+    if (!HttpResponse.isHttpResponse(init)) {
+      throw new Error(`Not an ARC response.`);
+    }
+    const { status, statusText, headers, payload, kind=Kind } = 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;
+  }
+
+  toJSON(): IHttpResponse {
+    const result: IHttpResponse = {
+      kind: this.kind,
+      status: this.status,
+    };
+    if (this.statusText) {
+      result.statusText = this.statusText;
+    }
+    if (this.headers) {
+      result.headers = this.headers;
+    }
+    if (this.payload) {
+      result.payload = this.payload;
+    }
+    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

@@ -0,0 +1,113 @@
+export const Kind = 'ARC#License';
+
+export interface ILicense {
+  kind: 'ARC#License'
+  /**
+   * 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 an ARC license object.
+   */
+  new(init: ILicense): void {
+    if (!License.isLicense(init)) {
+      throw new Error(`Not an ARC 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/ProjectDefinitionProperty.ts

@@ -0,0 +1,40 @@
+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;
+}