@api-client/core 0.6.30 → 0.7.1

package/src/runtime/http-engine/CoreEngine.ts

@@ -762,7 +762,7 @@ export class CoreEngine extends HttpEngine {
     if (buffer) {
       raw = buffer.toString();
     }
-    this.currentResponse!.headers = raw;
+    (this.currentResponse as Response).headers = raw;
     this.logger.info('Received headers list', raw);
     const headers = new Headers(raw);
     this.currentHeaders = headers;
@@ -974,13 +974,14 @@ export class CoreEngine extends HttpEngine {
     };
     if (proxyIsSsl) {
       connectOptions.rejectUnauthorized = false;
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
       connectOptions.requestOCSP = false;
     }
     const auth = this._proxyAuthHeader();
     if (auth) {
       this.logger.debug(`Adding proxy authorization.`);
-      connectOptions.headers!['proxy-authorization'] = auth;
+      (connectOptions.headers as http.OutgoingHttpHeaders)['proxy-authorization'] = auth;
     }
     const lib = proxyIsSsl ? https : http;
     return new Promise((resolve, reject) => {

package/src/runtime/http-engine/HttpEngine.ts

@@ -25,9 +25,18 @@ import { DefaultLogger } from '../../lib/logging/DefaultLogger.js';
 import { ILogger, Logger } from '../../lib/logging/Logger.js';
 import { Headers } from '../../lib/headers/Headers.js';
 import * as RequestUtils from './RequestUtils.js';
-import { Cookies } from '../../lib/cookies/Cookies.js';
+// import { Cookies } from '../../lib/cookies/Cookies.js';
 import { HttpErrorCodes } from './HttpErrorCodes.js';
+import { CookieParser } from '../../cookies/CookieParser.js';
 
+/**
+ * A note on cookies and redirects.
+ * The architecture here assumes running requests is a test environment.
+ * This means cookies are not processed by this class. This includes processing cookies during a redirect.
+ * The class does parse response cookies before a redirect and sets new cookies in the redirected request only
+ * if they match the domain + path. However, this class doesn't know anything about other cookies 
+ * that the application may have for the domain after redirection.
+ */
 export interface HttpEngineOptions extends IRequestBaseConfig {
   /**
    * The authorization configuration to apply to the request.
@@ -473,11 +482,8 @@ export abstract class HttpEngine extends EventEmitter {
       this._publishResponse();
       return;
     }
-    let responseCookies;
-    if (this.currentHeaders.has('set-cookie')) {
-      responseCookies = this.currentHeaders.get('set-cookie');
-    }
     try {
+      const responseCookies = this.currentHeaders.get('set-cookie');
       const response = await this._createRedirectResponse(location);
       this.redirects.push(response);
       this._cleanUpRedirect();
@@ -712,35 +718,47 @@ Check your request parameters.`);
    * @param location Redirect destination
    */
   _processRedirectCookies(responseCookies: string, location: string): void {
-    let newParser = new Cookies(responseCookies, location);
-    newParser.filter();
-    const expired = newParser.clearExpired();
+    const received = CookieParser.parse(this.request.url, responseCookies);
+    const forwardCookies = CookieParser.filterCookies(received, location);
     const headers = new Headers(this.request.headers);
-    const hasCookie = headers.has('cookie');
-    if (hasCookie) {
-      const oldCookies = headers.get('cookie');
-      const oldParser = new Cookies(oldCookies, location);
-      oldParser.filter();
-      oldParser.clearExpired();
-      oldParser.merge(newParser);
-      newParser = oldParser;
-      // remove expired from the new response.
-      newParser.cookies = newParser.cookies.filter((c) => {
-        for (let i = 0, len = expired.length; i < len; i++) {
-          if (expired[i].name === c.name) {
-            return false;
-          }
-        }
-        return true;
+    headers.delete('cookie');
+    if (forwardCookies.length) {
+      const parts: string[] = [];
+      forwardCookies.forEach((cookie) => {
+        parts.push(cookie.toString());
       });
-    }
-    const str = newParser.toString(true);
-    if (str) {
-      headers.set('cookie', str);
-    } else if (hasCookie) {
-      headers.delete('cookie');
+      headers.set('cookie', parts.join('; '));
     }
     this.request.headers = headers.toString();
+
+    // let newParser = new Cookies(responseCookies, location);
+    // newParser.filter();
+    // const expired = newParser.clearExpired();
+    // const hasCookie = headers.has('cookie');
+    // if (hasCookie) {
+    //   const oldCookies = headers.get('cookie');
+    //   const oldParser = new Cookies(oldCookies, location);
+    //   oldParser.filter();
+    //   oldParser.clearExpired();
+    //   oldParser.merge(newParser);
+    //   newParser = oldParser;
+    //   // remove expired from the new response.
+    //   newParser.cookies = newParser.cookies.filter((c) => {
+    //     for (let i = 0, len = expired.length; i < len; i++) {
+    //       if (expired[i].name === c.name) {
+    //         return false;
+    //       }
+    //     }
+    //     return true;
+    //   });
+    // }
+    // const str = newParser.toString(true);
+    // if (str) {
+    //   headers.set('cookie', str);
+    // } else if (hasCookie) {
+    //   headers.delete('cookie');
+    // }
+    // this.request.headers = headers.toString();
   }
 
   /**

package/src/runtime/{actions/ConditionRunner.ts → http-runner/ConditionCheck.ts}

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { OperatorEnum } from '../../models/actions/Enums.js';
+import { ActionOperatorEnum } from '../../models/http-actions/HttpActions.js';
 
 /**
  * Checks if values equal.
@@ -8,7 +8,7 @@ import { OperatorEnum } from '../../models/actions/Enums.js';
  * @returns True if objects matches.
  */
 export function isEqual(value: any, condition: any): boolean {
-  if (value === condition) {
+  if (value === condition || String(value) === String(condition)) {
     return true;
   }
   let valueTyped = value;
@@ -170,7 +170,7 @@ export function isRegex(value: any, condition: any): boolean {
  * @param condition Value to compare.
  * @returns True if the condition is satisfied and false otherwise.
  */
-export function checkCondition(value: any, operator: OperatorEnum, condition: string | number): boolean {
+export function checkCondition(value: any, operator: ActionOperatorEnum, condition: string | undefined): boolean {
   switch (operator) {
     case 'equal':
       return isEqual(value, condition);

package/src/runtime/http-runner/HttpFlowRunner.ts

@@ -0,0 +1,232 @@
+import { CookieJar } from "../../cookies/CookieJar.js";
+import { IHttpRequest } from "../../models/HttpRequest.js";
+import { ISentRequest } from "../../models/SentRequest.js";
+import { IResponse } from "../../models/Response.js";
+import { IErrorResponse } from "../../models/ErrorResponse.js";
+import { HttpCookie } from "../../models/HttpCookie.js";
+import { ActionSourceEnum, DeleteCookieStepKind, IActionStep, IDeleteCookieStep, IHttpAction, IHttpActionFlow, IHttpCondition, IReadDataStep, ISetCookieStep, ISetDataStep, ISetVariableStep, ReadDataStepKind, SetCookieStepKind, SetDataStepKind, SetVariableStepKind } from '../../models/http-actions/HttpActions.js';
+import { RequestDataExtractor } from "../../data/RequestDataExtractor.js";
+import { checkCondition } from "./ConditionCheck.js";
+import { ApiSchemaValues } from "../../amf/ApiSchemaValues.js";
+import { SameSiteValue } from "../../cookies/CookieParser.js";
+
+type FlowValue = string | number | boolean | null | undefined;
+
+export class HttpFlowRunner {
+  /**
+   * The cumulative list of all variables to be applied to the request and other properties.
+   * The variables must be already processed for variables in values (evaluated).
+   * 
+   * These variables are passed by reference. Changes made anywhere to the variables will result 
+   * with updating this list.
+   */
+  variables?: Record<string, string>;
+
+  /**
+   * An instance of a cookie jar (store) to put/read cookies.
+   */
+  cookies?: CookieJar;
+
+  async request(request: IHttpRequest, flows?: IHttpActionFlow[]): Promise<void> {
+    if (!flows || !flows.length) {
+      return;
+    }
+    for (const flow of flows) {
+      for (const action of flow.actions) {
+        await this._runAction(action, request);
+      }
+    }
+  }
+
+  async response(request: IHttpRequest | ISentRequest, response: IResponse | IErrorResponse, flows?: IHttpActionFlow[]): Promise<void> {
+    if (!flows || !flows.length) {
+      return;
+    }
+    for (const flow of flows) {
+      for (const action of flow.actions) {
+        await this._runAction(action, request, response);
+      }
+    }
+  }
+
+  async _runAction(action: IHttpAction, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<void> {
+    const { steps, condition } = action;
+    if (!Array.isArray(steps) || !steps.length) {
+      return;
+    }
+    if (condition) {
+      const meet = await this._satisfied(condition, request, response);
+      if (!meet) {
+        return;
+      }
+    }
+
+    // this keeps a value from the last step to be passed to the next step.
+    let lastResult: FlowValue;
+    for (const step of steps) {
+      lastResult = await this._runStep(step, lastResult, request, response);
+    }
+  }
+
+  async _satisfied(condition: IHttpCondition, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<boolean> {
+    const { source, data, path, operator, value } = condition;
+    if (!source || !operator) {
+      return false;
+    }
+    const extractor = new RequestDataExtractor(request, response);
+    const readValue = await extractor.extract(source, data, path);
+    return checkCondition(readValue, operator, value);
+  }
+
+  async _runStep(step: IActionStep, input: FlowValue, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<FlowValue> {
+    switch (step.kind) {
+      case ReadDataStepKind: return this._runReadDataStep(step as IReadDataStep, request, response);
+      case SetDataStepKind: return this._runSetDataStep(step as ISetDataStep);
+      case SetVariableStepKind: return this._runSetVariableStep(step as ISetVariableStep, input);
+      case SetCookieStepKind: return this._runSetCookieStep(step as ISetCookieStep, input, request);
+      case DeleteCookieStepKind: return this._runDeleteCookieStep(step as IDeleteCookieStep, request);
+      default: return undefined;
+    }
+  }
+
+  /**
+   * A step that reads data from the request, response, or variables.
+   * 
+   * @param step The step configuration.
+   * @param request The HttpRequest or the SentRequest (for responses)
+   * @param response When available, the response data
+   * @returns The read value or undefined.
+   */
+  async _runReadDataStep(step: IReadDataStep, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<string | number | undefined> {
+    const { source, data, enabled, path } = step;
+    if (enabled === false) {
+      return undefined;
+    }
+    if (source === ActionSourceEnum.request) {
+      const extractor = new RequestDataExtractor(request);
+      return extractor.extract(source, data, path);
+    }
+
+    if (source === ActionSourceEnum.response) {
+      const extractor = new RequestDataExtractor(request, response);
+      return extractor.extract(source, data, path);
+    }
+
+    if (source === ActionSourceEnum.variable && path && this.variables) {
+      return this.variables[path];
+    }
+
+    return undefined;
+  }
+
+  /**
+   * A step that returns a pre-configured value.
+   * 
+   * @param step The step configuration.
+   * @returns The read value with applied data type.
+   */
+  _runSetDataStep(step: ISetDataStep): FlowValue {
+    const { value, dataType, enabled } = step;
+    if (enabled === false) {
+      return undefined;
+    }
+    if (value === null || value === undefined) {
+      return undefined;
+    }
+    return ApiSchemaValues.parseScalar(value, dataType);
+  }
+
+  /**
+   * A step that sets a variable in the current environment.
+   * 
+   * @param step The step configuration.
+   * @param value The value to set. A value that is `null` or `undefined` deletes the variable.
+   */
+  _runSetVariableStep(step: ISetVariableStep, value: FlowValue): FlowValue {
+    const { name, enabled } = step;
+    if (enabled === false || !name || !this.variables) {
+      return undefined;
+    }
+    if (value === null || typeof value === undefined) {
+      delete this.variables[name];
+    } else {
+      this.variables[name] = String(value);
+    }
+    return undefined;
+  }
+
+  /**
+   * A step that sets a cookie.
+   * 
+   * @param step The step configuration.
+   * @param value The value to sent on the cookie.
+   * @param request The request object.
+   */
+  async _runSetCookieStep(step: ISetCookieStep, value: FlowValue, request: IHttpRequest | ISentRequest): Promise<FlowValue> {
+    const { name, enabled, expires, hostOnly, httpOnly, sameSite, secure, session } = step;
+    const { cookies } = this;
+    if (enabled === false || !name || !cookies ) {
+      return undefined;
+    }
+    if (value === null || typeof value === undefined) {
+      return undefined;
+    }
+    const typedValue = String(value);
+    let url: string;
+    if (step.url) {
+      url = step.url;
+    } else {
+      url = request.url;
+    }
+    const cookie = new HttpCookie({
+      name: name,
+      value: typedValue,
+      sameSite: 'unspecified',
+    });
+    
+    if (sameSite) {
+      const typed = sameSite as SameSiteValue;
+      switch (typed.toLowerCase()) {
+        case 'lax': cookie.sameSite = 'lax'; break;
+        case 'strict': cookie.sameSite = 'strict'; break;
+        case 'none': cookie.sameSite = 'no_restriction'; break;
+      }
+    }
+    if (expires) {
+      cookie.expirationDate = expires;
+    }
+    if (typeof hostOnly === 'boolean') {
+      cookie.hostOnly = hostOnly;
+    }
+    if (typeof httpOnly === 'boolean') {
+      cookie.httpOnly = httpOnly;
+    }
+    if (typeof secure === 'boolean') {
+      cookie.secure = secure;
+    }
+    if (typeof session === 'boolean') {
+      cookie.session = session;
+    }
+    await cookies.setCookies(url, [cookie]);
+    return undefined;
+  }
+
+  /**
+   * A step to delete cookies from the cookie jar.
+   */
+  async _runDeleteCookieStep(step: IDeleteCookieStep, request: IHttpRequest | ISentRequest): Promise<FlowValue> {
+    const { name, enabled } = step;
+    const { cookies } = this;
+    if (enabled === false || !cookies ) {
+      return undefined;
+    }
+    let url: string;
+    if (step.url) {
+      url = step.url;
+    } else {
+      url = request.url;
+    }
+    await cookies.deleteCookies(url, name);
+    return undefined;
+  }
+}