@api-client/core 0.9.4 → 0.9.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "license": "Apache-2.0",
   "main": "build/index.js",
   "module": "build/index.js",
@@ -81,7 +81,8 @@
     "lint": "tsc --noEmit && eslint \"**/*.{js,ts}\" --quiet --fix",
     "prepare": "husky install && npm run build-ts && npm run build:api-models",
     "tsc:watch": "tsc --watch",
-    "test:browser": "wtr --playwright --browsers chromium firefox webkit --coverage",
+    "test:browser": "wtr --playwright --browsers chromium --coverage",
+    "test:all": "wtr --playwright --browsers chromium firefox webkit --coverage",
     "test:browser:watch": "wtr --watch --playwright --browsers chromium",
     "test:node": "npm run build-ts && mocha",
     "test": "npm run test:node && npm run test:browser",

package/src/data/{JmesparthReader.ts → JmespathReader.ts}

@@ -9,13 +9,13 @@ import { DataReader } from './DataReader.js';
  * request data. Instead, we use `JsonReader` that converts the JSON to XML so the same 
  * XPath can be used for both JSON and XML.
  */
-export class JmesparthReader extends DataReader {
+export class JmespathReader extends DataReader {
   async getValue(path: string): Promise<unknown> {
     const body = await this.readPayloadAsString();
     if (!body) {
       return undefined;
     }
-    let obj: any;
+    let obj;
     try {
       obj = JSON.parse(body);
     } catch (e) {

package/src/data/RequestDataExtractor.ts

@@ -3,7 +3,7 @@ import { IHttpRequest, HttpRequest } from '../models/HttpRequest.js';
 import { ISentRequest, SentRequest } from '../models/SentRequest.js';
 import { IHttpResponse, HttpResponse } from '../models/HttpResponse.js';
 import { IErrorResponse, ErrorResponse } from '../models/ErrorResponse.js';
-import { ActionRequestDataEnum, ActionResponseDataEnum, ActionSourceEnum } from '../models/http-actions/HttpActions.js';
+import { FlowRequestDataEnum, FlowResponseDataEnum, FlowSourceEnum } from '../models/http-actions/HttpFlows.js';
 import { Headers } from '../lib/headers/Headers.js';
 import { JsonReader } from './JsonReader.js';
 import { XmlReader } from './XmlReader.js';
@@ -43,7 +43,7 @@ export class RequestDataExtractor {
    * @param path The path to the data.
    * @return Data to be processed
    */
-  async extract(source: ActionSourceEnum, data?: ActionRequestDataEnum | ActionResponseDataEnum, path?: string): Promise<string | number | undefined> {
+  async extract(source: FlowSourceEnum, data?: FlowRequestDataEnum | FlowResponseDataEnum, path?: string): Promise<string | number | undefined> {
     const args = path ? path.split('.') : [];
     switch (data) {
       case 'url':
@@ -73,14 +73,14 @@ export class RequestDataExtractor {
    * @param source The source name 
    * @returns The headers from the request / response
    */
-  getHeaders(source?: ActionSourceEnum): string {
+  getHeaders(source?: FlowSourceEnum): string {
     if (source === 'request') {
       return this.request.headers || '';
     }
     return this.response && this.response.headers || '';
   }
 
-  async processBody(path?: string, source?: ActionSourceEnum): Promise<string | undefined> {
+  async processBody(path?: string, source?: FlowSourceEnum): Promise<string | undefined> {
     const value = await this.getBody(source);
     if (!value) {
       return undefined;
@@ -104,7 +104,7 @@ export class RequestDataExtractor {
    * @param source The source name 
    * @returns The headers from the request / response
    */
-  async getBody(source?: ActionSourceEnum): Promise<string | undefined> {
+  async getBody(source?: FlowSourceEnum): Promise<string | undefined> {
     if (source === 'request') {
       return this.request.readPayloadAsString();
     }

package/src/data/XmlReader.ts

@@ -38,7 +38,7 @@ export class XmlReader extends DataReader {
   }
 
   processNodeResult(result: XPathResult): unknown {
-    const results: any[] = [];
+    const results: unknown[] = [];
     let next = result.iterateNext();
     while (next) {
       const value = next.textContent;
@@ -50,7 +50,21 @@ export class XmlReader extends DataReader {
     if (!results.length) {
       return undefined;
     }
-    return results.length === 1 ? results[0] : results;
+    
+    const mapped = results.map((item) => {
+      if (item === 'true') {
+        return true;
+      }
+      if (item === 'true') {
+        return false;
+      }
+      const typedNumber = Number(item);
+      if (!Number.isNaN(typedNumber)) {
+        return typedNumber;
+      }
+      return item;
+    });
+    return mapped.length === 1 ? mapped[0] : mapped;
   }
 
   async getDocument(): Promise<Document|undefined> {

package/src/events/BaseEvents.ts

@@ -495,6 +495,36 @@ export interface IHistoryRequestListOptions extends ContextListOptions {
  */
 export type HistoryListOptions = IHistoryRequestListOptions;
 
+export interface IProjectExecutionListOptions extends ContextListOptions {
+  /**
+   * The key of the parent space.
+   */
+  space: string;
+
+  /**
+   * The id of the parent project
+   */
+  project: string;
+  
+  /**
+   * The key of the application that made the records.
+   * This is optional and will returns results for the project made in all apps.
+   */
+  app?: string;
+
+  /**
+   * The key of the parent folder, if any.
+   * Note, when this is not provided the endpoint only returns list of logs
+   * created for the project.
+   */
+  parent?: string;
+
+  /**
+   * The user id that made that project run. Optional.
+   */
+  user?: string;
+}
+
 
 export interface IPatchBase {
   /**

package/src/events/transport/TransportEvents.ts

@@ -2,9 +2,9 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { IHttpRequest } from "../../models/HttpRequest.js";
 import { IRequestLog } from '../../models/RequestLog.js';
+import { IProjectExecutionLog } from "../../models/ProjectExecution.js";
 import { ContextEvent } from "../BaseEvents.js";
 import { TransportEventTypes } from "./TransportEventTypes.js";
-import { IProjectExecutionLog } from "../../runtime/reporters/Reporter.js";
 import { IRequestProxyInit } from "../../proxy/RequestProxy.js";
 import { IHttpProjectProxyInit, IHttpProjectStoreProxyInit } from "../../proxy/HttpProjectProxy.js";
 import { IProxyResult } from "../../proxy/Proxy.js";

package/src/models/ClientCertificate.ts

@@ -73,6 +73,9 @@ export interface IPemCertificate extends ICertificate {
 
 export type HttpCertificate = IP12Certificate | IPemCertificate | ICertificate;
 
+/**
+ * @deprecated Do not use this type anymore. Create a cert instance instead.
+ */
 export interface IPemCreateOptions {
   type: 'p12';
   /**
@@ -93,6 +96,9 @@ export interface IPemCreateOptions {
   passphrase?: string;
 }
 
+/**
+ * @deprecated Do not use this type anymore. Create a cert instance instead.
+ */
 export interface IP12CreateOptions {
   type: 'pem';
   /**
@@ -109,6 +115,9 @@ export interface IP12CreateOptions {
   passphrase?: string;
 }
 
+/**
+ * @deprecated Do not use this type anymore. Create a cert instance instead.
+ */
 export type ICertificateCreateOptions = IPemCreateOptions | IP12CreateOptions;
 
 /**

package/src/models/Environment.ts

@@ -3,6 +3,7 @@ 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';
+import { IRequestAuthorization, RequestAuthorization } from './RequestAuthorization.js';
 
 export const Kind = 'Core#Environment';
 
@@ -46,7 +47,7 @@ export interface IEnvironment {
   /**
    * The security to be applied to all requests that are going to this environment.
    */
-  security?: unknown;
+  authorization?: IRequestAuthorization[];
 }
 
 /**
@@ -82,7 +83,7 @@ export class Environment {
   /**
    * The security to be applied to all requests that are going to this server.
    */
-  security?: unknown;
+  authorization?: RequestAuthorization[];
 
   /**
    * Creates a new Environment object from a name.
@@ -151,11 +152,15 @@ export class Environment {
     if (!Environment.isEnvironment(init)) {
       throw new Error(`Not an environment.`);
     }
-    const { key = v4(), variables, info, server, encapsulated = false, security } = init;
+    const { key = v4(), variables, info, server, encapsulated = false, authorization } = init;
     this.kind = Kind;
     this.key = key;
     this.encapsulated = encapsulated;
-    this.security = security;
+    if (Array.isArray(authorization)) {
+      this.authorization = authorization.map(i => new RequestAuthorization(i));
+    } else {
+      this.authorization = undefined;
+    }
     if (Array.isArray(variables)) {
       this.variables = variables.map(i => new Property(i))
     } else {
@@ -196,9 +201,8 @@ export class Environment {
     if (server) {
       result.server = server.toJSON();
     }
-    if (this.security) {
-      // TODO: When this is defined then call toJSON().
-      result.security = this.security;
+    if (Array.isArray(this.authorization)) {
+      result.authorization = this.authorization.map(i => i.toJSON());
     }
     return result;
   }

package/src/models/ErrorResponse.ts

@@ -66,7 +66,7 @@ export class ErrorResponse extends HttpResponse {
   /**
    * @param input The request definition used to restore the state.
    */
-  constructor(input?: string|IErrorResponse) {
+  constructor(input?: string | IErrorResponse) {
     super(input);
     let init: IErrorResponse;
     if (typeof input === 'string') {

package/src/models/HttpRequest.ts

@@ -1,11 +1,10 @@
-import { SerializablePayload, SerializablePayloadOptions } from './SerializablePayload.js';
-import { Payload } from '../lib/transformers/PayloadSerializer.js';
+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 {
+export interface IBaseHttpRequest extends ISerializablePayload {
   /**
    * The request URL
    */
@@ -19,10 +18,6 @@ export interface IBaseHttpRequest {
    * HTTP headers string
    */
   headers?: string;
-  /**
-   * The request payload.
-   */
-  payload?: Payload;
 }
 
 /**
@@ -136,8 +131,9 @@ export class HttpRequest extends SerializablePayload {
     return true;
   }
 
-  toJSON(): IHttpRequest {
+  override toJSON(): IHttpRequest {
     const result: IHttpRequest = {
+      ...super.toJSON(),
       kind: this.kind,
       url: this.url,
       method: this.method,
@@ -145,15 +141,9 @@ export class HttpRequest extends SerializablePayload {
     if (this.headers) {
       result.headers = this.headers;
     }
-    if (this.payload) {
-      result.payload = this.payload;
-    }
     if (this.headersModel) {
       result.headersModel = this.headersModel.toJSON();
     }
-    if (this.payloadOptions) {
-      result.payloadOptions = { ...this.payloadOptions };
-    }
     return result;
   }
 

package/src/models/HttpResponse.ts

@@ -1,11 +1,11 @@
-import { SerializablePayload } from './SerializablePayload.js';
-import { Payload, PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
+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';
 
 export const Kind = 'Core#HttpResponse';
 
-export interface IHttpResponse {
+export interface IHttpResponse extends ISerializablePayload {
   kind?: string;
   /**
    * The response status code
@@ -19,10 +19,6 @@ export interface IHttpResponse {
    * The response headers
    */
   headers?: string;
-  /**
-   * The response message
-   */
-  payload?: Payload;
 }
 
 export class HttpResponse extends SerializablePayload {
@@ -116,8 +112,9 @@ export class HttpResponse extends SerializablePayload {
     return true;
   }
 
-  toJSON(): IHttpResponse {
+  override toJSON(): IHttpResponse {
     const result: IHttpResponse = {
+      ...super.toJSON(),
       kind: this.kind,
       status: this.status,
     };
@@ -127,9 +124,6 @@ export class HttpResponse extends SerializablePayload {
     if (this.headers) {
       result.headers = this.headers;
     }
-    if (this.payload) {
-      result.payload = this.payload;
-    }
     return result;
   }
 

package/src/models/ProjectExecution.ts

@@ -0,0 +1,227 @@
+import { Core as JsonCore } from '@api-client/json'
+import { IRequestLog } from "./RequestLog.js";
+
+export const Kind = 'Core#ProjectExecution';
+
+export interface IProjectExecutionIteration {
+  /**
+   * The index of the iteration.
+   */
+  index: number;
+  /**
+   * The list of requests executed in the iteration.
+   */
+  executed: IRequestLog[];
+  /**
+   * The variables evaluated during the run. 
+   * These variables have values set by requests' HTTP flows.
+   */
+  variables: Record<string, string>;
+  /**
+   * Optional general error message.
+   */
+  error?: string;
+}
+
+export interface IProjectExecutionLog {
+  /**
+   * The timestamp when the execution started
+   */
+  started: number;
+  /**
+   * The timestamp when the execution ended
+   */
+  ended: number;
+  /**
+   * The execution logs for each iteration.
+   */
+  iterations: IProjectExecutionIteration[];
+}
+
+export interface IProjectExecution extends IProjectExecutionLog {
+  kind: typeof Kind;
+  /**
+   * The key of the execution entry. This is generated by the store. Client value is ignored.
+   */
+  key: string;
+  
+  /**
+   * The key of the parent project.
+   */
+  project: string;
+
+  /**
+   * The key of the parent folder, if any.
+   */
+  parent?: string;
+
+  /**
+   * The application id that generated the entry.
+   */
+  app: string;
+
+  /**
+   * The user id that made that request.
+   * This is only available when the store support multi-user environment.
+   */
+  user?: string;
+
+  /**
+   * A timestamp of the midnight when the object was created.
+   */
+  midnight: number;
+}
+
+export class ProjectExecution implements IProjectExecution {
+  kind: typeof Kind = Kind;
+
+  /**
+   * The key of the execution entry. This is generated by the store. Client value is ignored.
+   */
+  key = '';
+
+  /**
+   * The key of the parent project.
+   */
+  project = '';
+
+  /**
+   * The key of the parent folder, if any.
+   */
+  parent?: string;
+
+  /**
+   * The application id that generated the entry.
+   */
+  app = '';
+
+  /**
+   * The user id that made that request.
+   * This is only available when the store support multi-user environment.
+   */
+  user?: string;
+
+  /**
+   * @param value The timestamp of the midnight when the request object was updated
+   */
+  set midnight(value: number | undefined) {
+    if (!value) {
+      this.midnightInternal = this.defaultMidnight();
+    } else {
+      this.midnightInternal = value;
+    }
+  }
+
+  /**
+   * @returns The timestamp of the midnight when the request object was updated
+   */
+  get midnight(): number {
+    if (this.midnightInternal) {
+      return this.midnightInternal;
+    }
+    return this.defaultMidnight();
+  }
+
+  private midnightInternal = 0;
+
+  /**
+   * The timestamp when the execution started
+   */
+  started = 0;
+
+  /**
+   * The timestamp when the execution ended
+   */
+  ended = 0;
+
+  /**
+   * The execution logs for each iteration.
+   */
+  iterations: IProjectExecutionIteration[] = [];
+
+
+  constructor(input?: string | IProjectExecution) {
+    let init: IProjectExecution;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      const now = Date.now();
+      init = {
+        kind: Kind,
+        user: '',
+        app: '',
+        key: '',
+        project: '',
+        ended: 0,
+        iterations: [],
+        midnight: 0,
+        started: now,
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: IProjectExecution): void {
+    const { started = Date.now(), midnight, project, user, key, app, ended = started, iterations,  parent } = init;
+    this.started = started;
+    this.ended = ended;
+    this.iterations = iterations.map(i => JsonCore.clone(i));
+    if (key) {
+      this.key = key;
+    } else {
+      this.key = '';
+    }
+    if (app) {
+      this.app = app;
+    } else {
+      this.app = '';
+    }
+    if (midnight) {
+      this.midnight = midnight;
+    }
+    if (project) {
+      this.project = project;
+    } else {
+      this.project = '';
+    }
+    if (parent) {
+      this.parent = parent;
+    } else {
+      this.parent = '';
+    }
+    if (user) {
+      this.user = user;
+    } else {
+      this.user = '';
+    }
+  }
+
+  toJSON(): IProjectExecution {
+    const result: IProjectExecution = {
+      kind: Kind,
+      midnight: this.midnight,
+      user: this.user,
+      key: this.key,
+      project: this.project,
+      app: this.app,
+      ended: this.ended,
+      iterations: this.iterations.map(i => JsonCore.clone(i)),
+      started: this.started,
+    };
+    if (this.parent) {
+      result.parent = this.parent;
+    }
+    return result;
+  }
+
+  /**
+   * @returns The default value for the midnight when the request was last updated.
+   */
+  defaultMidnight(): number {
+    const d = new Date(this.started);
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+  }
+}

package/src/models/ProjectRequest.ts

@@ -9,6 +9,7 @@ import { Environment } from './Environment.js';
 import { Property } from './Property.js';
 import { Server } from './Server.js';
 import { UriTemplate } from '../lib/parsers/UriTemplate.js';
+import { RequestAuthorization } from './RequestAuthorization.js';
 
 export const Kind = 'Core#ProjectRequest';
 
@@ -485,4 +486,57 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
     }
     return result;
   }
+
+  /**
+   * Reads the authorization that should be applied to the request.
+   * 
+   * 1) First it returns the locally (on the request) defined authorization.
+   * 2) Then it returns authorization defined on the selected environment.
+   * 3) If has defined environment but no authorization on it, then it returns empty array.
+   * 4) Only if the request has no selected environment then it reads first environment
+   * that has authorization (from the request up to the project's root).
+   */
+  readAuthorization(): RequestAuthorization[] {
+    if (Array.isArray(this.authorization) && this.authorization.length) {
+      return this.authorization;
+    }
+    const envAuth = this.readEnvironmentAuthorization();
+    if (envAuth) {
+      return envAuth;
+    }
+    if (this.environment) {
+      return [];
+    }
+    const inherited = this.readEnvironmentsAuthorization();
+    if (inherited) {
+      return inherited;
+    }
+    return [];
+  }
+
+  /**
+   * @returns Authorization defined on the selected environment or undefined.
+   */
+  protected readEnvironmentAuthorization(): RequestAuthorization[] | undefined {
+    const selfEnv = this.getEnvironment();
+    if (!selfEnv) {
+      return undefined;
+    }
+    if (Array.isArray(selfEnv.authorization) && selfEnv.authorization.length) {
+      return selfEnv.authorization;
+    }
+    return undefined;
+  }
+
+  /**
+   * @returns Authorization defined on any inherited environment or undefined.
+   */
+  protected readEnvironmentsAuthorization(): RequestAuthorization[] | undefined {
+    const envs = this.readEnvironments();
+    const authEnv = envs.find(i => Array.isArray(i.authorization) && !!i.authorization.length);
+    if (authEnv) {
+      return authEnv.authorization as RequestAuthorization[];
+    }
+    return undefined;
+  }
 }