@api-client/core 0.6.29 → 0.7.0

package/src/models/AppRequest.ts

@@ -0,0 +1,176 @@
+import { IRequest, Request } from "./Request.js";
+import { HttpRequest, IHttpRequest } from "./HttpRequest.js";
+import { Thing } from "./Thing.js";
+
+export const Kind = 'Core#AppRequest';
+
+export interface IAppRequest extends IRequest {
+  kind: typeof Kind;
+  key: string;
+  /**
+   * The application id that created this request.
+   */
+  app: string;
+  /**
+   * May be used internally by the application that generated this entry 
+   * to distinguish between different types of requests.
+   */
+  type?: string;
+}
+
+/**
+ * An App request is an HTTP request that has been generated by an application that is 
+ * not related to a concept of project.
+ * You can think of it as a stand-alone request definition in an application.
+ * In HttpClient this represents a history entry. Another application can use it to stor a request data
+ * without any additional structure.
+ */
+export class AppRequest extends Request {
+  kind = Kind;
+
+  /**
+   * The identifier of the request.
+   * The key is related to the `created` property. It should be the `new Date(created).toJSON()` value.
+   */
+  key = '';
+
+  /**
+   * The application id that created this request.
+   */
+  app = '';
+
+  /**
+   * May be used internally by the application that generated this entry 
+   * to distinguish between different types of requests.
+   */
+  type?: string;
+
+  /**
+   * Creates a project request from an URL.
+   * 
+   * @param url The Request URL. This is required.
+   * @param app The application id that generated this request. This is a required argument, even though, typings marks it as optional.
+   */
+  static fromUrl(url: string, app?: string): AppRequest {
+    if (!app) {
+      throw new Error(`The app argument is required.`);
+    }
+    const d = new Date();
+    const now: number = d.getTime();
+    const request = new AppRequest({
+      key: d.toJSON(),
+      kind: Kind,
+      created: now,
+      updated: now,
+      expects: HttpRequest.fromBaseValues({ url, method: 'GET' }).toJSON(),
+      info: Thing.fromName(url).toJSON(),
+      app,
+    });
+    return request;
+  }
+
+  /**
+   * Creates a project request from a name.
+   * 
+   * @param name The Request name.
+   * @param app The application id that generated this request. This is a required argument, even though, typings marks it as optional.
+   */
+  static fromName(name: string, app?: string): AppRequest {
+    if (!app) {
+      throw new Error(`The app argument is required.`);
+    }
+    const d = new Date();
+    const now: number = d.getTime();
+    const request = new AppRequest({
+      key: d.toJSON(),
+      kind: Kind,
+      created: now,
+      updated: now,
+      expects: new HttpRequest().toJSON(),
+      info: Thing.fromName(name).toJSON(),
+      app,
+    });
+    return request;
+  }
+
+  /**
+   * Creates a request from an HttpRequest definition.
+   * 
+   * @param info The request data.
+   * @param app The application id that generated this request. This is a required argument, even though, typings marks it as optional.
+   */
+  static fromHttpRequest(info: IHttpRequest, app?: string): AppRequest {
+    if (!app) {
+      throw new Error(`The app argument is required.`);
+    }
+    const d = new Date();
+    const now: number = d.getTime();
+    const request = new AppRequest({
+      key: d.toJSON(),
+      kind: Kind,
+      created: now,
+      updated: now,
+      expects: HttpRequest.fromBaseValues({ method: info.method, url: info.url, headers: info.headers, payload: info.payload }).toJSON(),
+      info: Thing.fromName(info.url).toJSON(),
+      app,
+    });
+    return request;
+  }
+
+  /**
+   * Creates a request for a schema of a Request.
+   * @param app The application id that generated this request.
+   */
+  static fromRequest(request: IRequest, app: string): AppRequest {
+    const d = new Date(request.created || Date.now());
+    const now: number = d.getTime();
+    const init: IAppRequest = {
+      ...request,
+      key: d.toJSON(),
+      kind: Kind,
+      created: now,
+      app,
+    };
+    const result = new AppRequest(init);
+    return result;
+  }
+
+  constructor(input?: string | IAppRequest) {
+    super(input);
+
+    let init: IAppRequest | undefined;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    }
+    if (init) {
+      this.key = init.key;
+      this.app = init.app;
+    }
+    if (!this.key) {
+      this.key = new Date(this.created || Date.now()).toJSON();
+    }
+    this.kind = Kind;
+  }
+
+  new(init: IAppRequest): void {
+    super.new(init);
+
+    const { key, app } = init;
+    this.key = key || new Date(init.created || Date.now()).toJSON();
+    this.kind = Kind;
+    this.app = app;
+  }
+
+  toJSON(): IAppRequest {
+    const request = super.toJSON();
+    const result: IAppRequest = {
+      ...request,
+      key: this.key,
+      kind: Kind,
+      app: this.app,
+    };
+    return result;
+  }
+}

package/src/models/ClientCertificate.ts

@@ -37,11 +37,11 @@ export interface ICertificate {
    */
   key: string;
   /**
-   * Custom name of the certificate.
+   * The custom name of the certificate.
    */
   name: string;
   /**
-   * Timestamp when the certificate was inserted into the data store.
+   * The timestamp when the certificate was inserted into the data store.
    * Required when returning a result. Auto-generated when inserting, if missing.
    */
   created?: number;

package/src/models/Environment.ts

@@ -4,6 +4,8 @@ import { IThing, Thing, Kind as ThingKind } from './Thing.js';
 import v4 from '../lib/uuid.js';
 import { ARCVariable } from './legacy/models/Variable.js';
 
+export const Kind = 'Core#Environment';
+
 export interface IEnvironmentCloneOptions {
   /**
    * By default it revalidates (re-creates) keys in the environment.
@@ -47,8 +49,6 @@ export interface IEnvironment {
   security?: unknown;
 }
 
-export const Kind = 'Core#Environment';
-
 /**
  * An environment is applied to a project or a folder.
  * It consists of a list of variables and a server configuration.
@@ -277,4 +277,26 @@ export class Environment {
     }
     return copy;
   }
+
+  /**
+   * Creates a map of variables from this environment.
+   * 
+   * @param readStrategy The read strategy. When `lastWins` (default) then a variable with the same name overwrites the previously set variable. The `firstWins` stops overwriting values once a variable is set.
+   * @returns An object containing variables defined in this environment
+   */
+  variablesMap(readStrategy: 'lastWins' | 'firstWins' = 'lastWins'): Record<string, string> {
+    const result: Record<string, string> = {};
+    const { variables=[] } = this
+    variables.forEach((item) => {
+      const { enabled, name, value } = item;
+      if (!enabled || !name || value === undefined) {
+        return;
+      }
+      if (readStrategy === 'firstWins' && name in result) {
+        return;
+      }
+      result[name] = value as string;
+    });
+    return result;
+  }
 }

package/src/models/HostRule.ts

@@ -17,11 +17,11 @@ export interface IHostRule {
    */
   from: string;
   /**
-   * replacement value
+   * The replacement value
    */
   to: string;
   /**
-   * if false the rule is ignored
+   * When false the rule is ignored
    */
   enabled?: boolean;
   /**

package/src/models/HttpCookie.ts

@@ -1,8 +1,31 @@
 import { ARCCookie as LegacyARCCookie } from './legacy/models/Cookies.js';
-import { Cookie as ParserCookie } from '../lib/cookies/Cookie.js';
 
 export type CookieSameSiteType = 'unspecified' | 'no_restriction' | 'lax' | 'strict';
 export type CookieChangeReason = 'explicit' | 'overwrite' | 'expired' | 'evicted' | 'expired-overwrite';
+// eslint-disable-next-line no-control-regex
+const fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+
+export interface IElectronCookie {
+  name: string;
+  value: string;
+  /**
+   * The domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains.
+   */
+  domain?: string;
+  /**
+   * Whether the cookie is a host-only cookie; this will only be true if no domain was passed.
+   */
+  hostOnly?: boolean;
+  /**
+   * The path of the cookie.
+   */
+  path?: string;
+  secure?: boolean;
+  httpOnly?: boolean;
+  session?: boolean;
+  expirationDate?: number;
+  sameSite?: CookieSameSiteType;
+}
 
 export interface IHttpCookieChangeRecord {
   /**
@@ -70,7 +93,7 @@ export interface IHttpCookie {
    * The Same Site policy applied to this cookie. Can be `unspecified`, `no_restriction`, `lax` or `strict`.
    * @default unspecified
    */
-  sameSite: CookieSameSiteType;
+  sameSite?: CookieSameSiteType;
 }
 
 export class HttpCookie {
@@ -82,11 +105,6 @@ export class HttpCookie {
    * The value of the cookie.
    */
   value = '';
-  /**
-   * The domain of the cookie; this will be normalized with a preceding dot so that
-   * it's also valid for subdomains.
-   */
-  domain?: string;
   /**
    * Whether the cookie is a host-only cookie; this will only be `true` if no domain
    * was passed.
@@ -108,17 +126,110 @@ export class HttpCookie {
    * Whether the cookie is a session cookie or a persistent cookie with an expiration
    * date.
    */
-  session?: boolean;
+  session?: boolean = true;
+  /**
+   * The Same Site policy applied to this cookie. Can be `unspecified`, `no_restriction`, `lax` or `strict`.
+   * @default unspecified
+   */
+  sameSite: CookieSameSiteType = 'unspecified';
+
+  protected _domain?: string;
+  protected _maxAge?: number;
+  protected _expirationDate?: number | undefined;
+
+  /**
+   * @param max The max age value
+   */
+  set maxAge(max: number | undefined) {
+    const typedMax = Number(max);
+    if (Number.isNaN(typedMax)) {
+      return;
+    }
+    
+    this._maxAge = typedMax;
+    if (typedMax <= 0) {
+      // see http://stackoverflow.com/a/11526569/1127848
+      // and https://tools.ietf.org/html/rfc6265#section-5.2.2
+      this._expirationDate = -8640000000000000;
+    } else {
+      let now = Date.now();
+      now += typedMax * 1000;
+      this._expirationDate = now;
+    }
+    this.session = false;
+  }
+
+  /**
+   * @return Returns a value of maxAge property
+   */
+  get maxAge(): number | undefined {
+    return this._maxAge;
+  }
+
   /**
    * The expiration date of the cookie as the number of seconds since the UNIX epoch.
    * Not provided for session cookies.
    */
-  expirationDate?: number;
+  set expirationDate(expires: number | Date | string | undefined) {
+    this.setExpirationTime(expires);
+  }
+
+  get expirationDate(): number | undefined {
+    return this._expirationDate;
+  }
+
   /**
-   * The Same Site policy applied to this cookie. Can be `unspecified`, `no_restriction`, `lax` or `strict`.
-   * @default unspecified
+   * The domain of the cookie; this will be normalized with a preceding dot so that
+   * it's also valid for subdomains.
    */
-  sameSite: CookieSameSiteType = 'unspecified';
+  set domain(domain: string | undefined) {
+    this._domain = domain;
+    if (!domain) {
+      this.hostOnly = false;
+    } else {
+      this.hostOnly = true;
+    }
+  }
+  
+  get domain(): string | undefined {
+    return this._domain;
+  }
+
+  // get samesite(): CookieSameSiteType | undefined {
+  //   return this.sameSite;
+  // }
+
+  set samesite(value: CookieSameSiteType | undefined) {
+    this.sameSite = value || 'unspecified';
+  }
+
+  // get httponly(): boolean | undefined {
+  //   return this.httpOnly;
+  // }
+
+  set httponly(value: boolean | undefined) {
+    this.httpOnly = value;
+  }
+
+  // get hostonly(): boolean | undefined {
+  //   return this.hostOnly;
+  // }
+
+  set hostonly(value: boolean | undefined) {
+    this.hostOnly = value;
+  }
+
+  // get ['max-age'](): number | undefined {
+  //   return this.maxAge;
+  // }
+
+  set ['max-age'](value: number | undefined) {
+    this.maxAge = value;
+  }
+
+  set expires(value: string | number | Date | undefined) {
+    this.expirationDate = value;
+  }
 
   static fromLegacy(old: LegacyARCCookie): HttpCookie {
     const init: IHttpCookie = {
@@ -150,7 +261,7 @@ export class HttpCookie {
     return new HttpCookie(init);
   }
 
-  static fromValue(name: string, value: string = ''): HttpCookie {
+  static fromValue(name: string, value = ''): HttpCookie {
     const init: IHttpCookie = {
       name,
       value,
@@ -159,37 +270,6 @@ export class HttpCookie {
     return new HttpCookie(init);
   }
 
-  static fromCookieParser(cookie: ParserCookie): HttpCookie {
-    const { name, value, sameSite='unspecified' } = cookie;
-    const init: IHttpCookie = {
-      name,
-      value,
-      sameSite,
-    };
-    if (typeof cookie.domain === 'string') {
-      init.domain = cookie.domain;
-    }
-    if (typeof cookie.path === 'string') {
-      init.path = cookie.path;
-    }
-    if (typeof cookie.expires === 'number') {
-      init.expirationDate = cookie.expires;
-    }
-    if (typeof cookie.hostOnly === 'boolean') {
-      init.hostOnly = cookie.hostOnly;
-    }
-    if (typeof cookie.httpOnly === 'boolean') {
-      init.httpOnly = cookie.httpOnly;
-    }
-    if (typeof cookie.secure === 'boolean') {
-      init.secure = cookie.secure;
-    }
-    if (typeof cookie.persistent === 'boolean') {
-      init.session = !cookie.persistent;
-    }
-    return new HttpCookie(init);
-  }
-
   constructor(input?: string|IHttpCookie) {
     let init: IHttpCookie;
     if (typeof input === 'string') {
@@ -213,10 +293,27 @@ export class HttpCookie {
       sameSite = 'unspecified',
       domain, expirationDate, hostOnly, httpOnly, path, secure, session
     } = init;
+    if (name && !fieldContentRegExp.test(name)) {
+      throw new TypeError('Argument `name` is invalid');
+    }
+    if (value && !fieldContentRegExp.test(value)) {
+      throw new TypeError('Argument `value` is invalid');
+    }
     this.name = name;
     this.value = value;
     this.sameSite = sameSite;
+    if (typeof path === 'string') {
+      if (!fieldContentRegExp.test(path)) {
+        throw new TypeError('Option `path` is invalid');
+      }
+      this.path = path;
+    } else {
+      this.path = undefined;
+    }
     if (domain) {
+      if (!fieldContentRegExp.test(domain)) {
+        throw new TypeError('Option `domain` is invalid');
+      }
       this.domain = domain;
     } else {
       this.domain = undefined;
@@ -244,13 +341,41 @@ export class HttpCookie {
     if (typeof session === 'boolean') {
       this.session = session;
     } else {
-      this.session = undefined;
+      this.session = !this.expirationDate;
     }
-    if (typeof path === 'string') {
-      this.path = path;
+  }
+
+  /**
+   * Sets value for `expirationDate` property.
+   * @param expires The value as string, date, or a number
+   */
+  setExpirationTime(expires: Date | string | number | undefined): void {
+    let value: number | undefined;
+    const typedNumber = Number(expires);
+    if (!Number.isNaN(typedNumber)) {
+      value = typedNumber;
+    } else if (expires instanceof Date) {
+      value = expires.getTime();
+    } else if (typeof expires === 'string') {
+      const tmp = new Date(expires);
+      if (tmp.toString() === 'Invalid Date') {
+        value = 0;
+      } else {
+        value = tmp.getTime();
+      }
     } else {
-      this.path = undefined;
+      value = undefined;
     }
+    this._expirationDate = value;
+    this.session = !value;
+  }
+
+  /**
+   * @return Cookie's `name=value` string.
+   */
+  toString(): string {
+    const { name, value } = this;
+    return `${name}=${value}`;
   }
 
   toJSON(): IHttpCookie {
@@ -282,4 +407,41 @@ export class HttpCookie {
     }
     return result;
   }
+
+  /**
+   * Returns a Cookie as a HTTP header string.
+   * @return Cookie string as a HTTP header value
+   */
+  toHeader(): string {
+    let header = this.toString();
+    let expires;
+    if (this._expirationDate) {
+      expires = new Date(this._expirationDate);
+      if (expires.toString() === 'Invalid Date') {
+        expires = new Date(0);
+      }
+    }
+    if (expires) {
+      header += `; expires=${expires.toUTCString()}`;
+    }
+    const { path, domain, httpOnly, sameSite, secure } = this;
+    if (path) {
+      header += `; path=${path}`;
+    }
+    if (domain) {
+      header += `; domain=${domain}`;
+    }
+    if (httpOnly) {
+      header += `; httpOnly=${httpOnly}`;
+    }
+    switch (sameSite) {
+      case 'lax': header += `; SameSite=Lax`; break;
+      case 'no_restriction': header += `; SameSite=None`; break;
+      case 'strict': header += `; SameSite=Strict`; break;
+    }
+    if (secure || sameSite === 'strict') {
+      header += `; Secure`;
+    }
+    return header;
+  }
 }

package/src/models/HttpHistory.ts

@@ -11,6 +11,8 @@ export interface IHttpHistory {
    * In majority of cases this value is set. It is not set when generating the history object before sending it to the store.
    * 
    * Note for data store implementations. This must be a URL-safe value so the id should be encoded if needed.
+   * 
+   * @readonly
    */
   key?: string;
   /**
@@ -27,9 +29,12 @@ export interface IHttpHistory {
   app?: string;
   /**
    * The user id that made that request.
-   * Note, the default API Client's store automatically adds the user information to the record overriding any pre-set user id.
+   * Note, the default API Client's store automatically adds the user information to the record overriding any pre-set user id, making it a read-only
+   * value.
+   * 
+   * @readonly
    */
-  user: string;
+  user?: string;
   /**
    * The optional request id in the project that generated this log.
    */
@@ -80,13 +85,15 @@ export interface IHttpHistoryBulkAdd {
 
 /**
  * An HTTP history is an object containing an information of a request and response
- * made with the application.
+ * made by an application.
  * 
  * Note, history object are not mutable. Can only be created or deleted.
  */
 export class HttpHistory {
-  [createdSymbol]: number;
-  [midnightSymbol]: number;
+  [createdSymbol] = 0;
+
+  [midnightSymbol] = 0;
+  
   kind = Kind;
   /**
    * The data store key. Only present when the object was already inserted into the data store.