@api-client/core 0.7.7 → 0.7.10

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.7.7",
+  "version": "0.7.10",
   "license": "Apache-2.0",
   "main": "build/index.js",
   "module": "build/index.js",
@@ -28,6 +28,7 @@
     "@esm-bundle/chai": "^4.3.4-fix.0",
     "@types/chai": "^4.2.22",
     "@types/chai-as-promised": "^7.1.5",
+    "@types/chai-uuid": "^1.0.2",
     "@types/cors": "^2.8.12",
     "@types/express-ntlm": "^2.3.3",
     "@types/fs-extra": "^9.0.13",
@@ -42,6 +43,7 @@
     "amf-client-js": "^5.0.8-0",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
+    "chai-uuid": "^1.0.6",
     "cors": "^2.8.5",
     "eslint": "^8.9.0",
     "eslint-config-prettier": "^8.3.0",
@@ -55,6 +57,7 @@
     "husky": "^8.0.1",
     "lint-staged": "^13.0.1",
     "mocha": "^10.0.0",
+    "nock": "^13.2.7",
     "oauth2-mock-server": "^4.3.1",
     "sinon": "^14.0.0",
     "source-map-support": "^0.5.21",

package/src/cookies/CookieParser.ts

@@ -71,19 +71,20 @@ export class CookieParser {
 
   /**
    * Parses the `set-cookie` header value and creates a list of cookies.
-   * The cookie configuration must match the `url`. This means that if the cookie has a `host` property
-   * this must match the request URL (browsers do not allow setting cookies from one domain for another).
    * 
-   * When `host` or `path` part is missing from the cookie, the URL values are used.
+   * Notes:
+   * - This does not check whether the cookie should be stored in the Cookie Jar based on the request URL, use `parse()` instead
+   * - This will fill up cookies' `domain` and `path` when `requestUrl` is provided. Otherwise it will leave these fields empty which makes the cookie invalid. Use `parse()` instead
    * 
-   * @param requestUrl The HTTP request URL. Cookies must match this URL or will be ignored.
    * @param setCookie The value of the `set-cookie` string.
+   * @param requestUrl The HTTP request URL.
    */
-  static parse(requestUrl: string, setCookie?: string): HttpCookie[] {
+  static parseRelaxed(setCookie?: string, requestUrl?: string): HttpCookie[] {
     const result: HttpCookie[] = [];
     if (!setCookie || typeof setCookie !== 'string') {
       return result;
     }
+
     const blocks = setCookie.split(';').map(i => i.trim());
     blocks.forEach((part, index) => {
       // Consider the following set-cookie string:
@@ -153,28 +154,41 @@ export class CookieParser {
       }
     });
 
-    // At this point we have all cookies set by the server. Now we need to filter out cookies 
-    // set for a different domains.
-
-    // first lets set cookie domain and path.
-    const url = new URL(requestUrl);
-    const domain = this.canonicalDomain(url.host);
-    const path = this.getPath(url);
+    if (requestUrl) {
+      const url = new URL(requestUrl);
+      const domain = this.canonicalDomain(url.host);
+      const path = this.getPath(url);
+  
+      result.forEach((cookie) => {
+        if (!cookie.path) {
+          cookie.path = path;
+        }
+        if (!cookie.domain) {
+          // point 6. of https://tools.ietf.org/html/rfc6265#section-5.3
+          cookie.domain = domain;
+          cookie.hostOnly = true;
+        } else if (cookie.domain[0] !== '.') {
+          // https://stackoverflow.com/a/1063760/1127848
+          cookie.domain = `.${cookie.domain}`;
+        }
+      });
+    }
+    return result;
+  }
 
-    result.forEach((cookie) => {
-      if (!cookie.path) {
-        cookie.path = path;
-      }
-      if (!cookie.domain) {
-        // point 6. of https://tools.ietf.org/html/rfc6265#section-5.3
-        cookie.domain = domain;
-        cookie.hostOnly = true;
-      } else if (cookie.domain[0] !== '.') {
-        // https://stackoverflow.com/a/1063760/1127848
-        cookie.domain = `.${cookie.domain}`;
-      }
-    });
-    return this.filterCookies(result, requestUrl);
+  /**
+   * Parses the `set-cookie` header value and creates a list of cookies.
+   * The cookie configuration must match the `url`. This means that if the cookie has a `host` property
+   * this must match the request URL (browsers do not allow setting cookies from one domain for another).
+   * 
+   * When `host` or `path` part is missing from the cookie, the URL values are used.
+   * 
+   * @param requestUrl The HTTP request URL. Cookies must match this URL or will be ignored.
+   * @param setCookie The value of the `set-cookie` string.
+   */
+  static parse(requestUrl: string, setCookie?: string): HttpCookie[] {
+    const cookies = this.parseRelaxed(setCookie, requestUrl);
+    return this.filterCookies(cookies, requestUrl);
   }
 
   /**

package/src/events/transport/TransportEventTypes.ts

@@ -3,9 +3,11 @@ export const TransportEventTypes = Object.freeze({
    * Transport via the CoreEngine.
    */
   Core: Object.freeze({
-    // sends a request
-    send: 'coretransportsend',
+    request: 'transportcorerequest',
+    httpProject: 'transportcorehttpproject',
+    appProject: 'transportcoreappproject',
   }),
+  
   /** 
    * Transport via the native platform's bindings.
    */
@@ -13,12 +15,6 @@ export const TransportEventTypes = Object.freeze({
     send: 'httptransportsend',
   }),
 
-  // project runner
-  Project: Object.freeze({
-    // for both a request or a folder (since it's all single configuration.)
-    send: 'transportprojectsend',
-  }),
-
   // web sockets.
   Ws: Object.freeze({
     /** 

package/src/events/transport/TransportEvents.ts

@@ -1,31 +1,20 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { IRequestAuthorization } from "../../models/RequestAuthorization.js";
 import { IHttpRequest } from "../../models/HttpRequest.js";
-import { IRequestBaseConfig } from "../../models/RequestConfig.js";
 import { IRequestLog } from '../../models/RequestLog.js';
-import { HttpProject } from "../../models/HttpProject.js";
 import { ContextEvent } from "../BaseEvents.js";
 import { TransportEventTypes } from "./TransportEventTypes.js";
-import { IProjectRunnerOptions } from "../../runtime/node/InteropInterfaces.js";
 import { IProjectExecutionLog } from "../../runtime/reporters/Reporter.js";
-
-export interface ICoreRequestDetail {
-  request: IHttpRequest; 
-  authorization?: IRequestAuthorization[]; 
-  config?: IRequestBaseConfig;
-}
+import { IRequestProxyInit } from "../../proxy/RequestProxy.js";
+import { IHttpProjectProxyInit } from "../../proxy/HttpProjectProxy.js";
+import { IAppProjectProxyInit } from "../../proxy/AppProjectProxy.js";
+import { IProxyResult } from "../../proxy/Proxy.js";
 
 export interface IHttpRequestDetail {
   request: IHttpRequest; 
   init?: RequestInit;
 }
 
-export interface IProjectRequestDetail {
-  project: HttpProject | string; 
-  opts: IProjectRunnerOptions;
-}
-
 /* eslint-disable no-unused-vars */
 export const TransportEvent = Object.freeze({
   /** 
@@ -36,17 +25,35 @@ export const TransportEvent = Object.freeze({
      * Sends a single request without a context of a project.
      * 
      * @param target The events target.
-     * @param request The request definition
-     * @param authorization When known, a list of authorization configuration to apply to the request.
-     * @param config Optional request configuration.
-     * @returns The execution log or `undefined` when the event was not handled.
+     * @param init The request execution configuration
+     * @returns The execution log with the variables evaluated during the run or `undefined` when the event was not handled.
      */
-    send: async (request: IHttpRequest, authorization?: IRequestAuthorization[], config?: IRequestBaseConfig, target: EventTarget = window): Promise<IRequestLog | undefined> => {
-      const e = new ContextEvent<ICoreRequestDetail, IRequestLog>(TransportEventTypes.Core.send, {
-        request,
-        authorization,
-        config
-      });
+    request: async (init: IRequestProxyInit, target: EventTarget = window): Promise<IProxyResult<IRequestLog> | undefined> => {
+      const e = new ContextEvent<IRequestProxyInit, IProxyResult<IRequestLog>>(TransportEventTypes.Core.request, init);
+      target.dispatchEvent(e);
+      return e.detail.result;
+    },
+
+    /**
+     * For both the project or a folder (since it's all single configuration.)
+     * 
+     * @param target The events target
+     * @param init The project execution configuration
+     */
+    httpProject: async (init: IHttpProjectProxyInit, target: EventTarget = window): Promise<IProxyResult<IProjectExecutionLog> | undefined> => {
+      const e = new ContextEvent<IHttpProjectProxyInit, IProxyResult<IProjectExecutionLog>>(TransportEventTypes.Core.httpProject, init);
+      target.dispatchEvent(e);
+      return e.detail.result;
+    },
+
+    /**
+     * For both the project or a folder (since it's all single configuration.)
+     * 
+     * @param target The events target
+     * @param init The project execution configuration
+     */
+    appProject: async (init: IAppProjectProxyInit, target: EventTarget = window): Promise<IProxyResult<IProjectExecutionLog> | undefined> => {
+      const e = new ContextEvent<IAppProjectProxyInit, IProxyResult<IProjectExecutionLog>>(TransportEventTypes.Core.appProject, init);
       target.dispatchEvent(e);
       return e.detail.result;
     },
@@ -74,26 +81,6 @@ export const TransportEvent = Object.freeze({
     },
   }),
 
-  // project runner
-  Project: Object.freeze({
-    /**
-     * For both a request or a folder (since it's all single configuration.)
-     * 
-     * @param target The events target
-     * @param project The instance of a project or an id of the project to execute. The current user has to be already authenticated.
-     * @param opts The project execution options.
-     * @returns 
-     */
-    send: async (project: HttpProject | string, opts: IProjectRunnerOptions, target: EventTarget = window): Promise<IProjectExecutionLog | undefined> => {
-      const e = new ContextEvent<IProjectRequestDetail, IProjectExecutionLog>(TransportEventTypes.Project.send, {
-        project,
-        opts,
-      });
-      target.dispatchEvent(e);
-      return e.detail.result;
-    },
-  }),
-
   // web sockets.
   Ws: Object.freeze({
     /** 

package/src/lib/transformers/PayloadSerializer.ts

@@ -154,6 +154,7 @@ export class PayloadSerializer {
         const result = await PayloadSerializer.stringifyFormData(payload);
         return result;
       } catch (e: unknown) {
+        // eslint-disable-next-line no-console
         console.warn(`Unable to transform FormData: ${(e as Error).message}`);
       }
     }

package/src/models/AppProject.ts

@@ -983,6 +983,13 @@ export class AppProjectFolder extends AppProjectParent {
   listEnvironments(): Environment[] {
     return this.project.listEnvironments({ parent: this.key });
   }
+
+  /**
+   * @returns The list of environments defined in this folder
+   */
+  getEnvironments(): Environment[] {
+    return this.project.getEnvironments({ parent: this.key });
+  }
 }
 
 /**
@@ -1879,6 +1886,15 @@ export class AppProject extends AppProjectParent {
     return env;
   }
 
+  /**
+   * This method is a link to `listEnvironments()` to be compatible with the HttpProject.
+   * 
+   * @returns The list of environments defined in this folder
+   */
+  getEnvironments(opts?: IAppProjectItemOptions): Environment[] {
+    return this.listEnvironments(opts);
+  }
+
   /**
    * This is a link to the `getEnvironments()`. The difference is that on the 
    * project level it won't return environments defined with the class initialization.

package/src/models/HttpResponse.ts

@@ -72,7 +72,7 @@ export class HttpResponse extends SerializablePayload {
   /**
    * @param input The response definition used to restore the state.
    */
-  constructor(input?: string|IHttpResponse) {
+  constructor(input?: string | IHttpResponse) {
     super();
     let init: IHttpResponse;
     if (typeof input === 'string') {
@@ -97,7 +97,7 @@ export class HttpResponse extends SerializablePayload {
     if (!HttpResponse.isHttpResponse(init)) {
       throw new Error(`Not a response.`);
     }
-    const { status, statusText, headers, payload, kind=Kind } = init;
+    const { status, statusText, headers, payload, kind = Kind } = init;
     this.kind = kind;
     this.status = status;
     this.statusText = statusText;

package/src/models/ProjectRequest.ts

@@ -70,7 +70,7 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
     if (!project) {
       throw new Error(`The project is required.`);
     }
-    const now:number = Date.now();
+    const now: number = Date.now();
     const request = new ProjectRequest(project, {
       key: v4(),
       kind: Kind,
@@ -100,7 +100,7 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
     if (!project) {
       throw new Error(`The project is required.`);
     }
-    const now:number = Date.now();
+    const now: number = Date.now();
     const request = new ProjectRequest(project, {
       key: v4(),
       kind: Kind,
@@ -130,7 +130,7 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
     if (!project) {
       throw new Error(`The project is required.`);
     }
-    const now:number = Date.now();
+    const now: number = Date.now();
     const request = new ProjectRequest(project, {
       key: v4(),
       kind: Kind,
@@ -160,8 +160,8 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
     const result = new ProjectRequest(project, init);
     return result;
   }
-  
-  constructor(project: HttpProject, input?: string|IProjectRequest | IAppProjectRequest) {
+
+  constructor(project: HttpProject, input?: string | IProjectRequest | IAppProjectRequest) {
     super(input);
     this.project = project;
     let init: IProjectRequest | IAppProjectRequest;
@@ -170,7 +170,7 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
     } else if (typeof input === 'object') {
       init = input;
     } else {
-      const now:number = Date.now();
+      const now: number = Date.now();
       init = {
         key: v4(),
         kind: Kind,
@@ -192,7 +192,7 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
 
   new(init: IProjectRequest | IAppProjectRequest): void {
     super.new(init);
-    
+
     const { key } = init;
     this.key = key || v4();
   }
@@ -224,7 +224,7 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
   /**
    * @returns The instance of the HttpProject or a ProjectFolder that is a closes parent of this instance.
    */
-  getParent(): ProjectFolder|HttpProject|undefined {
+  getParent(): ProjectFolder | HttpProject | undefined {
     const { project, key } = this;
     return project.findParent(key);
   }

package/src/models/Request.ts

@@ -117,7 +117,7 @@ export class Request {
    * @param url The Request URL.
    */
   static fromUrl(url: string): Request {
-    const now:number = Date.now();
+    const now: number = Date.now();
     const request = new Request({
       kind: Kind,
       created: now,
@@ -141,7 +141,7 @@ export class Request {
    * @param name The Request name.
    */
   static fromName(name: string): Request {
-    const now:number = Date.now();
+    const now: number = Date.now();
     const request = new Request({
       kind: Kind,
       created: now,
@@ -165,7 +165,7 @@ export class Request {
    * @param info The request data.
    */
   static fromHttpRequest(info: IHttpRequest): Request {
-    const now:number = Date.now();
+    const now: number = Date.now();
     const request = new Request({
       kind: Kind,
       created: now,
@@ -185,12 +185,12 @@ export class Request {
     return request;
   }
 
-  static async fromLegacy(request: ARCSavedRequest|ARCHistoryRequest): Promise<Request> {
+  static async fromLegacy(request: ARCSavedRequest | ARCHistoryRequest): Promise<Request> {
     const normalized = Normalizer.normalizeRequest(request) as ARCSavedRequest;
     if (!normalized) {
       throw new Error(`Unknown object.`);
     }
-    const init:IRequest = {
+    const init: IRequest = {
       kind: Kind,
       expects: {
         kind: HttpRequestKind,
@@ -312,14 +312,14 @@ export class Request {
     return this.defaultMidnight();
   }
 
-  constructor(input?: string|IRequest) {
+  constructor(input?: string | IRequest) {
     let init: IRequest;
     if (typeof input === 'string') {
       init = JSON.parse(input);
     } else if (typeof input === 'object') {
       init = input;
     } else {
-      const now:number = Date.now();
+      const now: number = Date.now();
       init = {
         kind: Kind,
         created: now,

package/src/models/legacy/Normalizer.ts

@@ -82,7 +82,7 @@ export class Normalizer {
   }
 
   /**
-   * Transforms the `TransformedPayload` object to its original data type.
+   * Transforms the legacy `TransformedPayload` object to its original data type.
    */
   static restoreTransformedPayload(body: string | ArrayBuffer | Buffer | LegacyTransformedPayload): string | Buffer | ArrayBuffer | undefined {
     if (!body) {

package/src/proxy/AppProjectProxy.ts

@@ -0,0 +1,125 @@
+import { IProjectRunnerOptions } from "../runtime/node/InteropInterfaces.js";
+import { AppProject, AppProjectKind, IAppProject } from "../models/AppProject.js";
+import { ApiError } from "../runtime/store/Errors.js";
+import { StoreSdk } from "../runtime/store/StoreSdkNode.js";
+import { ProjectSerialRunner } from "../runtime/node/ProjectSerialRunner.js";
+import { ProjectParallelRunner } from "../runtime/node/ProjectParallelRunner.js";
+import Proxy, { IProxyResult } from "./Proxy.js";
+
+export interface IAppProjectProxyInit {
+  kind: typeof AppProjectKind;
+  /**
+   * Project key
+   */
+  pid: string;
+  /**
+   * Application that created the project id.
+   */
+  appId: string;
+  /**
+   * Runner options.
+   */
+  options: IProjectRunnerOptions;
+}
+
+/**
+ * Runs requests from an AppProject read from the store.
+ */
+export default class AppProjectProxy extends Proxy {
+  project?: AppProject;
+  options?: IProjectRunnerOptions;
+
+  async configure(init: IAppProjectProxyInit, token: string, baseUri: string): Promise<void> {
+    const { pid, appId, options } = init;
+    if (!pid) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The "pid" parameter is required.',
+        code: 400,
+      });
+    }
+    if (!appId) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The "appId" parameter is required.',
+        code: 400,
+      });
+    }
+    if (!options) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The "options" parameter is required.',
+        code: 400,
+      });
+    }
+    if (!token) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'Set the authentication credentials.',
+        code: 400,
+      });
+    }
+    if (!baseUri) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The store uri is missing.',
+        code: 400,
+      });
+    }
+    if (!baseUri.startsWith('http')) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The store uri is invalid.',
+        code: 400,
+      });
+    }
+    const sdk = new StoreSdk(baseUri);
+    sdk.token = token;
+    let project: IAppProject;
+    try {
+      project = await sdk.app.projects.read(pid, appId);
+    } catch (cause) {
+      const e = cause as Error;
+      throw new ApiError(e.message, 400);
+    }
+    if (project.key !== pid) {
+      throw new ApiError(`Unable to read the project.`, 500);
+    }
+    this.options = options;
+    this.project = new AppProject(project);
+  }
+
+  async execute(): Promise<IProxyResult> {
+    const project = this.project as AppProject;
+    const opts = this.options as IProjectRunnerOptions;
+    let factory: ProjectParallelRunner | ProjectSerialRunner;
+    if (opts.parallel) {
+      factory = new ProjectParallelRunner(project, opts);
+    } else {
+      factory = new ProjectSerialRunner();
+      factory.configure(project, opts);
+    }
+
+    // eslint-disable-next-line no-inner-declarations
+    function unhandledRejection(): void { 
+      // 
+    }
+    // the executing library handles all related errors it need.
+    // However, when executing a request to an unknown host Node process may 
+    // throw unhandled error event when the error is properly reported by the 
+    // application. This suppresses these errors.
+    // Note, uncomment this line for debug.
+    process.on('unhandledRejection', unhandledRejection);
+    const report = await factory.execute();
+    process.off('unhandledRejection', unhandledRejection);
+    return {
+      result: report,
+    };
+  }
+}