@api-client/core 0.3.3 → 0.3.6

package/src/mocking/lib/Response.ts

@@ -0,0 +1,101 @@
+import { Http, Har, Types, Lorem, Time, DataMockInit, HttpResponseInit, HarTimingInit, Internet } from '@pawel-up/data-mock';
+import { IHttpResponse, Kind as HttpResponseKind } from '../../models/HttpResponse.js';
+import { IArcResponse, Kind as ArcResponseKind } from '../../models/ArcResponse.js';
+import { IRequestsSize } from '../../models/RequestsSize.js';
+import { IResponseRedirect, Kind as ResponseRedirectKind  } from '../../models/ResponseRedirect.js';
+
+export interface IArcResponseInit extends HttpResponseInit, HarTimingInit {
+  /**
+   * When set it does not generate a response payload.
+   */
+  noBody?: boolean;
+  /**
+   * 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: DataMockInit={}) {
+    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);
+  }
+
+  response(init: IArcResponseInit = {}): IHttpResponse {
+    const ct = init.noBody ? undefined : this.http.headers.contentType();
+    const body = init.noBody ? undefined : this.http.payload.payload(ct);
+    const headers = this.http.headers.headers('response', { mime: ct });
+    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,
+    };
+    if (!init.noBody) {
+      result.payload = body;
+    }
+    return result;
+  }
+
+  arcResponse(init: IArcResponseInit={}): IArcResponse {
+    const base = this.response(init);
+    const length = this.types.number({ min: 10, max: 4000 });
+    const result: IArcResponse = {
+      ...base,
+      kind: ArcResponseKind,
+      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;
+  }
+
+  redirect(init?: IArcResponseInit): 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: this.response({ ...init, statusGroup: 3}),
+    };
+    return info;
+  }
+
+  redirects(size=1, init?: IArcResponseInit): IResponseRedirect[] {
+    const result: IResponseRedirect[] = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.redirect(init));
+    }
+    return result;
+  }
+}

package/src/models/ArcResponse.ts

@@ -0,0 +1,166 @@
+import { IHttpResponse, HttpResponse, Kind } from './HttpResponse.js';
+import { IRequestTime, RequestTime } from './RequestTime.js';
+import { IResponseAuthorization, ResponseAuthorization } from './ResponseAuthorization.js';
+import { IErrorResponse } from './ErrorResponse.js';
+import { Response as LegacyResponse } from './legacy/request/ArcResponse.js';
+import { PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
+import { Normalizer } from './legacy/Normalizer.js';
+
+export { Kind };
+
+/**
+ * An HTTP response object.
+ */
+export interface IArcResponse extends IHttpResponse {
+  /**
+   * The request timings. 
+   * Some HTTP clients may not give this information.
+   */
+  timings?: IRequestTime;
+  /**
+   * The total loading time (from sending the request to receive the last byte)
+   */
+  loadingTime: number;
+  /**
+   * The authentication request from the server.
+   */
+  auth?: IResponseAuthorization;
+}
+
+export class ArcResponse extends HttpResponse {
+  /**
+   * The request timings. 
+   * Some HTTP clients may not give this information.
+   */
+  timings?: RequestTime;
+  /**
+   * The total loading time (from sending the request to receive the last byte)
+   */
+  loadingTime = 0;
+  /**
+   * The authentication request from the server.
+   */
+  auth?: ResponseAuthorization;
+
+  static fromValues(status: number, statusText?: string, headers?: string): ArcResponse {
+    return new ArcResponse({
+      kind: Kind,
+      status,
+      statusText,
+      headers,
+      loadingTime: 0,
+    });
+  }
+
+  static async fromLegacy(input: LegacyResponse): Promise<ArcResponse> {
+    const init: IArcResponse = {
+      kind: Kind,
+      status: input.status || 0,
+      loadingTime: input.loadingTime || 0,
+    };
+    if (input.headers) {
+      init.headers = input.headers;
+    }
+    if (input.statusText) {
+      init.statusText = input.statusText;
+    }
+    if (input.payload) {
+      const orig = Normalizer.restoreTransformedPayload(input.payload);
+      if (orig) {
+        init.payload = await PayloadSerializer.serialize(orig);
+      }
+    } else if (input.blob) {
+      init.payload = {
+        type: 'blob',
+        data: input.blob,
+      };
+    } else if (input.multipart) {
+      init.payload = {
+        type: 'formdata',
+        data: input.multipart,
+      };
+    }
+    if (input.timings) {
+      init.timings = new RequestTime(input.timings).toJSON();
+    }
+    return new ArcResponse(init);
+  }
+
+  /**
+   * @param input The response definition used to restore the state.
+   */
+  constructor(input?: string|IArcResponse) {
+    super();
+    let init: IArcResponse;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        status: 0,
+        loadingTime: 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: IArcResponse): void {
+    super.new(init);
+    const { loadingTime=0, timings, auth } = init;
+    this.loadingTime = loadingTime;
+    if (timings) {
+      this.timings = new RequestTime(timings);
+    } else {
+      this.timings = undefined;
+    }
+    if (auth) {
+      this.auth = new ResponseAuthorization(auth);
+    } else {
+      this.auth = undefined;
+    }
+  }
+
+  toJSON(): IArcResponse {
+    const response = super.toJSON() as IArcResponse;
+    response.loadingTime = this.loadingTime;
+    if (this.timings) {
+      response.timings = this.timings.toJSON();
+    }
+    if (this.auth) {
+      response.auth = this.auth.toJSON();
+    }
+    return response;
+  }
+
+  /**
+   * Checks whether the object (JSON Object) is an Error response.
+   */
+  static isErrorResponse(input: unknown): boolean {
+    const typed = input as IErrorResponse;
+    if (typed.error) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Creates the RequestTime object from the passed object.
+   */
+  setTimings(timings: IRequestTime): void {
+    this.timings = new RequestTime(timings);
+  }
+
+  /**
+   * Sets the authorization data on the response.
+   */
+  setAuth(auth: IResponseAuthorization): void {
+    this.auth = new ResponseAuthorization(auth);
+  }
+}