@api-client/core 0.3.3 → 0.3.6

package/src/models/Environment.ts

@@ -0,0 +1,279 @@
+import { Property, IProperty } from './Property.js';
+import { Server, IServer } from './Server.js';
+import { IThing, Thing, Kind as ThingKind } from './Thing.js';
+import v4 from '../lib/uuid.js';
+import { ARCVariable } from './legacy/models/Variable.js';
+
+export interface IEnvironmentCloneOptions {
+  /**
+   * By default it revalidates (re-creates) keys in the environment.
+   * Set this to true to not make any changes to the keys.
+   */
+  withoutRevalidate?: boolean;
+}
+
+/**
+ * A project environment definition.
+ */
+export interface IEnvironment {
+  kind: 'ARC#Environment';
+  /**
+   * The identifier of the environment.
+   */
+  key: string;
+  /**
+   * The environment's meta info.
+   */
+  info: IThing;
+  /**
+   * The server's definition for the environment.
+   * When a server is defined for the environment then all request that have no 
+   * absolute URL will inherit this server configuration.
+   */
+  server?: IServer;
+  /**
+   * The variables added to this project.
+   * It overrides application defined variables.
+   */
+  variables: IProperty[];
+  /**
+   * When set this configuration does not allow to be extended by the parent object's environment configuration.
+   * By default an environment can be extended by the parent object's values.
+   */
+  encapsulated?: boolean;
+  /**
+   * The security to be applied to all requests that are going to this environment.
+   */
+  security?: unknown;
+}
+
+export const Kind = 'ARC#Environment';
+
+/**
+ * An environment is applied to a project or a folder.
+ * It consists of a list of variables and a server configuration.
+ * This allows to apply the runtime configuration just by changing the environment.
+ */
+export class Environment {
+  kind = Kind;
+  key = '';
+  /**
+   * The name of the environment.
+   */
+  info: Thing = new Thing({ kind: ThingKind });
+  /**
+   * The variables added to this project.
+   * It overrides application defined variables.
+   */
+  variables: Property[] = [];
+  /**
+   * The server's definition for the environment.
+   * When a server is defined for the environment then all request that have no 
+   * absolute URL will inherit this server configuration.
+   */
+  server?: Server;
+  /**
+   * When set this configuration does not allow to be extended by the parent object's environment configuration.
+   * By default an environment can be extended by the parent object's values.
+   * 
+   * When encapsulation is disabled you can, for example, skip server definition and only overwrite variables. 
+   */
+  encapsulated = false;
+  /**
+   * The security to be applied to all requests that are going to this server.
+   */
+  security?: unknown;
+  
+  /**
+   * Creates a new Environment object from a name.
+   * 
+   * @param name The name to set.
+   */
+  static fromName(name: string): Environment {
+    const key = v4();
+    const info = new Thing({ kind: ThingKind, name });
+    const definition = new Environment({
+      key,
+      kind: Kind,
+      info: info.toJSON(),
+      variables: [],
+    });
+    return definition;
+  }
+
+  static fromLegacyVariables(name: string, variables: ARCVariable[]): Environment {
+    const key = v4();
+    const info = new Thing({ kind: ThingKind, name });
+    const definition = new Environment({
+      key,
+      kind: Kind,
+      info: info.toJSON(),
+      variables: [],
+    });
+    variables.forEach((i) => {
+      const name = i.variable || i.name;
+      const property = Property.fromApiType(i);
+      property.name = name;
+      definition.variables.push(property);
+    });
+    return definition;
+  }
+
+  /**
+   * @param input The environment definition used to restore the state.
+   */
+  constructor(input?: string|IEnvironment) {
+    let init: IEnvironment;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        key: v4(),
+        info: {
+          kind: ThingKind,
+          name: '',
+        },
+        variables: [],
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new environment clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the environment is not an ARC environment. 
+   */
+  new(init: IEnvironment): void {
+    if (!Environment.isEnvironment(init)) {
+      throw new Error(`Not an ARC environment.`);
+    }
+    const { key=v4(), variables, info, server, encapsulated=false, security } = init;
+    this.kind = Kind;
+    this.key = key;
+    this.encapsulated = encapsulated;
+    this.security = security;
+    if (Array.isArray(variables)) {
+      this.variables = variables.map(i => new Property(i))
+    } else {
+      this.variables = [];
+    }
+    if (server) {
+      this.server = new Server(server);
+    } else {
+      this.server = undefined;
+    }
+    if (info) {
+      this.info = new Thing(info);
+    } else {
+      this.info = new Thing({ kind: ThingKind, name: '' });
+    }
+  }
+
+  /**
+   * Checks whether the input is a definition of a environment.
+   */
+  static isEnvironment(input: unknown): boolean {
+    const typed = input as IEnvironment;
+    if (!input || typed.kind !== Kind) {
+      return false;
+    }
+    return true;
+  }
+
+  toJSON(): IEnvironment {
+    const { variables=[], encapsulated=false, server } = this;
+    const result: IEnvironment = {
+      kind: Kind,
+      key: this.key,
+      info: this.info.toJSON(),
+      variables: variables.map((v) => v.toJSON()),
+      encapsulated,
+    };
+    if (server) {
+      result.server = server.toJSON();
+    }
+    if (this.security) {
+      result.security = this.security;
+    }
+    return result;
+  }
+
+  addVariable(name: string, value: unknown): Property;
+  addVariable(variable: IProperty): Property;
+
+  /**
+   * Adds a new variable to the list of variables.
+   * It makes sure the variables property is initialized.
+   */
+  addVariable(variableOrName: IProperty|string, value?: unknown): Property {
+    if (!Array.isArray(this.variables)) {
+      this.variables = [];
+    }
+    let prop: Property;
+    if (typeof variableOrName === 'string') {
+      prop = Property.fromType(variableOrName, value);
+    } else {
+      prop = new Property(variableOrName);
+    }
+    this.variables.push(prop);
+    return prop;
+  }
+
+  /**
+   * Reads the server configuration.
+   * @param force When set then it creates a server instance when missing.
+   */
+  getServer(force?: boolean): Server|undefined {
+    if (!this.server && !force) {
+      return undefined;
+    }
+    
+    if (!this.server) {
+      this.server = new Server();
+    }
+    return this.server;
+  }
+
+  /**
+   * Adds a new server definition.
+   * @param uri The base URI to create the server from
+   */
+  addServer(uri: string): Server;
+
+  /**
+   * Adds a new server definition.
+   * @param info The server definition.
+   */
+  addServer(info: IServer): Server;
+
+  /**
+   * Adds a new server definition.
+   * @param uriOrInfo Either URI to create the server from or the definition of the server.
+   */
+  addServer(uriOrInfo: string | IServer): Server {
+    let srv: Server;
+    if (typeof uriOrInfo === 'string') {
+      srv = Server.fromUri(uriOrInfo);
+    } else {
+      srv = new Server(uriOrInfo);
+    }
+    this.server = srv;
+    return srv;
+  }
+
+  /**
+   * Makes a copy of this environment
+   * @param opts Cloning options.
+   */
+  clone(opts: IEnvironmentCloneOptions = {}): Environment {
+    const copy = new Environment(this.toJSON());
+    if (!opts.withoutRevalidate) {
+      copy.key = v4();
+    }
+    return copy;
+  }
+}

package/src/models/ErrorResponse.ts

@@ -0,0 +1,113 @@
+import { IHttpResponse, HttpResponse, Kind } from './HttpResponse.js';
+import { ErrorResponse as LegacyErrorResponse } from './legacy/request/ArcResponse.js';
+import { PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
+import { Normalizer } from './legacy/Normalizer.js';
+import { SerializableError, ISerializedError } from './SerializableError.js';
+
+export interface IErrorResponse extends IHttpResponse {
+  /**
+   * An error associated with the response
+   */
+  error: string | ISerializedError;
+}
+
+export class ErrorResponse extends HttpResponse {
+  /**
+   * An error associated with the response
+   */
+  error = new SerializableError('Unknown error');
+
+  /**
+   * @returns The same Error or new Error instance when passed string.
+   */
+  static ensureError(error: string | Error | SerializableError): SerializableError {
+    if (typeof error === 'string') {
+      return new SerializableError(error);
+    }
+    if (error.name === 'SerializableError') {
+      return error as SerializableError;
+    }
+    return new SerializableError(error);
+  }
+
+  /**
+   * @param error The error message or Error object to use.
+   */
+  static fromError(error: Error | SerializableError | string): ErrorResponse {
+    const err = ErrorResponse.ensureError(error);
+    return new ErrorResponse({
+      kind: Kind,
+      status: 0,
+      error: err,
+    });
+  }
+
+  static async fromLegacy(input: LegacyErrorResponse): Promise<ErrorResponse> {
+    const init: IErrorResponse = {
+      kind: Kind,
+      status: input.status || 0,
+      error: input.error ? ErrorResponse.ensureError(input.error) : new SerializableError('Unknown error'),
+    };
+    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);
+      }
+    }
+    return new ErrorResponse(init);
+  }
+
+  /**
+   * @param input The request definition used to restore the state.
+   */
+  constructor(input?: string|IErrorResponse) {
+    super(input);
+    let init: IErrorResponse;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        status: 0,
+        error: new SerializableError('Unknown error'),
+      };
+    }
+    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: IErrorResponse): void {
+    super.new(init);
+    if (init.error) {
+      if (typeof init.error === 'string') {
+        this.error = new SerializableError(init.error);
+      } else {
+        this.error = new SerializableError();
+        this.error.new(init.error);
+      }
+    }
+  }
+
+  toJSON(): IErrorResponse {
+    const response = super.toJSON() as IErrorResponse;
+    response.error = this.error;
+    return response;
+  }
+
+  static isErrorResponse(input: unknown): boolean {
+    const typed = input as IErrorResponse;
+    return !!typed.error;
+  }
+}

package/src/models/HistoryIndex.ts

@@ -0,0 +1,76 @@
+/**
+ * An object that is stored in ARCs internal store to build history navigation.
+ * It does not contain all the history data. Just the ones that are presented in the UI.
+ */
+export interface IHistoryIndex {
+  /**
+   * Timestamp when the request was last updated.
+   */
+  updated: number;
+  /**
+   * A timestamp of the midnight when the request object was updated
+   */
+  midnight: number;
+  /**
+   * The request URL
+   */
+  url: string;
+  /**
+   * HTTP method name
+   */
+  method: string;
+}
+
+export class HistoryIndex {
+  /**
+   * Timestamp when the request was last updated.
+   */
+  updated = 0;
+  /**
+   * A timestamp of the midnight when the request object was updated
+   */
+  midnight = 0;
+  /**
+   * The request URL
+   */
+  url = '';
+  /**
+   * HTTP method name
+   */
+  method = 'GET';
+
+  constructor(input?: string|IHistoryIndex) {
+    let init: IHistoryIndex;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        updated: 0,
+        midnight: 0,
+        url: '',
+        method: 'GET',
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: IHistoryIndex): void {
+    const { updated=0, midnight=0, url='', method='GET' } = init;
+    this.updated = updated;
+    this.midnight = midnight;
+    this.url = url;
+    this.method = method;
+  }
+
+  toJSON(): IHistoryIndex {
+    const result: IHistoryIndex = {
+      updated: this.updated,
+      midnight: this.midnight,
+      url: this.url,
+      method: this.method,
+    };
+    return result;
+  }
+}

package/src/models/HistoryRequest.ts

@@ -0,0 +1,28 @@
+import { IRequest, Request } from './Request.js';
+
+export const Kind = 'ARC#HistoryRequest';
+
+/**
+ * A class that specializes in processing ARC history request object.
+ */
+export class HistoryRequest extends Request {
+  kind = Kind;
+
+  /**
+   * Generates an id for a history object
+   */
+  generateId(): string {
+    const { method='', url='' } = this.expects;
+    const d = new Date();
+    d.setHours(0, 0, 0, 0);
+    const time = d.getTime();
+    const encUrl = encodeURIComponent(url);
+    return `${time}/${encUrl}/${method}`;
+  }
+
+  toJSON(): IRequest {
+    const result = super.toJSON();
+    result.kind = Kind;
+    return result;
+  }
+}

package/src/models/HostRule.ts

@@ -0,0 +1,163 @@
+export const Kind = 'ARC#HostRule';
+
+/**
+ * ARC host rule definition.
+ */
+export interface IHostRule {
+  kind?: typeof Kind;
+  /**
+   * The from rule (may contain asterisks)
+   */
+  from: string;
+  /**
+   * replacement value
+   */
+  to: string;
+  /**
+   * if false the rule is ignored
+   */
+  enabled?: boolean;
+  /**
+   * optional rule description
+   */
+  comment?: string;
+}
+
+export class HostRule {
+  kind = Kind;
+  /**
+   * The from rule (may contain asterisks)
+   */
+  from = '';
+  /**
+   * replacement value
+   */
+  to = '';
+  /**
+   * if false the rule is ignored
+   */
+  enabled?: boolean;
+  /**
+   * optional rule description
+   */
+  comment?: string;
+
+  static fromValues(from: string, to: string ): HostRule {
+    const result = new HostRule({
+      kind: Kind,
+      from,
+      to,
+      enabled: true,
+    });
+    return result;
+  }
+
+  /**
+   * @param input The thing definition used to restore the state.
+   */
+  constructor(input?: string | IHostRule) {
+    let init: IHostRule;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        from: '',
+        to: '',
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new thing clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the server is not an ARC thing.
+   */
+  new(init: IHostRule): void {
+    if (!HostRule.isHostRule(init)) {
+      throw new Error(`Not an ARC HostRule.`);
+    }
+    const { from='', to='', enabled, comment } = init;
+    this.kind = Kind;
+    this.from = from;
+    this.to = to;
+    this.enabled = enabled;
+    this.comment = comment;
+  }
+
+  /**
+   * Checks whether the input is a definition of a host rule.
+   */
+  static isHostRule(input: unknown): boolean {
+    const typed = input as IHostRule;
+    if (input && typed.kind && typed.kind === Kind) {
+      return true;
+    }
+    return false;
+  }
+
+  toJSON(): IHostRule {
+    const result: IHostRule = {
+      kind: Kind,
+      from : this.from,
+      to : this.to,
+    };
+    if (typeof this.enabled === 'boolean') {
+      result.enabled = this.enabled;
+    }
+    if (this.comment) {
+      result.comment = this.comment;
+    }
+    return result;
+  }
+
+  /**
+   * Applies `hosts` rules to the URL.
+   *
+   * @param value An URL to apply the rules to
+   * @param rules List of host rules. It is a list of objects containing `from` and `to` properties.
+   * @return Evaluated URL with hosts rules.
+   */
+  static applyHosts(value: string, rules: HostRule[]): string {
+    if (!rules || !rules.length) {
+      return value;
+    }
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+      const result = HostRule.evaluateRule(value, rule);
+      if (result) {
+        value = result;
+      }
+    }
+    return value;
+  }
+
+  /**
+   * Evaluates hosts rule and applies it to the `url`.
+   * @param {string} url The URL to evaluate
+   * @param {HostRule} rule ARC rule definition
+   * @return {string} Processed url.
+   */
+  static evaluateRule(url: string, rule: HostRule): string | undefined {
+    if (!rule || !rule.from || !rule.to) {
+      return;
+    }
+    const re = HostRule.createRuleRe(rule.from);
+    if (!re.test(url)) {
+      return;
+    }
+    return url.replace(re, rule.to);
+  }
+
+  /**
+   * @param input Rule body
+   * @return Regular expression for the rule.
+   */
+  static createRuleRe(input: string): RegExp {
+    input = input.replace(/\*/g, '(.*)');
+    return new RegExp(input, 'gi');
+  }
+}