@api-client/core 0.7.8 → 0.7.11

package/src/proxy/ProxyService.ts

@@ -0,0 +1,48 @@
+import { IProjectExecutionLog } from "../runtime/reporters/Reporter.js";
+import { IRequestLog } from "../models/RequestLog.js";
+import AppProjectProxy, { IAppProjectProxyInit } from "./AppProjectProxy.js";
+import HttpProjectProxy, { IHttpProjectProxyInit } from "./HttpProjectProxy.js";
+import { IProxyResult } from "./Proxy.js";
+import RequestProxy, { IRequestProxyInit } from "./RequestProxy.js";
+
+export default class ProxyService {
+  /**
+   * Executes a single HTTP request.
+   * 
+   * @param init The request to execute with additional configuration.
+   * @returns The execution log for the request.
+   */
+  async proxyRequest(init: IRequestProxyInit): Promise<IProxyResult<IRequestLog>> {
+    const proxy = new RequestProxy();
+    await proxy.configure(init);
+    return proxy.execute();
+  }
+
+  /**
+   * Executes an HttpProject.
+   * 
+   * @param token The user access token to read data from the store.
+   * @param storeUri The store's base URI.
+   * @param init The project run configuration.
+   * @returns The key under which the proxy is cached.
+   */
+  async proxyHttpProject(token: string, storeUri: string, init: IHttpProjectProxyInit): Promise<IProxyResult<IProjectExecutionLog>> {
+    const proxy = new HttpProjectProxy();
+    await proxy.configure(init, token, storeUri);
+    return proxy.execute();
+  }
+
+  /**
+   * Executes an AppProject.
+   * 
+   * @param token The user access token to read data from the store.
+   * @param storeUri The store's base URI.
+   * @param init The project run configuration.
+   * @returns The key under which the proxy is cached.
+   */
+  async proxyAppProject(token: string, storeUri: string, init: IAppProjectProxyInit): Promise<IProxyResult<IProjectExecutionLog>> {
+    const proxy = new AppProjectProxy();
+    await proxy.configure(init, token, storeUri);
+    return proxy.execute() as Promise<IProxyResult<IProjectExecutionLog>>;
+  }
+}

package/src/proxy/RequestProxy.ts

@@ -0,0 +1,89 @@
+import { IHttpRequest, Kind as HttpRequestKind } from '../models/HttpRequest.js';
+import { IRequestAuthorization } from '../models/RequestAuthorization.js';
+import { IRequestConfig } from '../models/RequestConfig.js';
+import Proxy, { IProxyResult } from "./Proxy.js";
+import { HttpCertificate } from '../models/ClientCertificate.js';
+import { IHttpActionFlow } from '../models/http-actions/HttpActions.js';
+import { ApiError } from '../runtime/store/Errors.js';
+import { DummyLogger } from '../lib/logging/DummyLogger.js';
+import { HttpRequestRunner } from '../runtime/http-runner/HttpRequestRunner.js';
+import { IRequestLog } from "../models/RequestLog.js";
+
+export interface IRequestProxyInit {
+  kind: typeof HttpRequestKind;
+  /**
+   * The request to execute.
+   */
+  request: IHttpRequest;
+  /**
+   * The authorization data to apply.
+   */
+  authorization?: IRequestAuthorization[];
+  /**
+   * The request configuration.
+   */
+  config?: IRequestConfig;
+  /**
+   * The list of execution variables to use with the request.
+   */
+  variables?: Record<string, string>;
+  /**
+   * The certificate data to use with the request.
+   */
+  certificate?: HttpCertificate;
+  /**
+   * The request flows to execute with the request.
+   */
+  flows?: IHttpActionFlow[];
+}
+
+/**
+ * Proxies a single HTTP request
+ */
+export default class RequestProxy extends Proxy {
+  init?: IRequestProxyInit;
+
+  async configure(init: IRequestProxyInit): Promise<void> {
+    const { request } = init;
+    if (!request) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The "request" parameter is required.',
+        code: 400,
+      });
+    }
+    if (!request.url) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The "request.url" parameter is required.',
+        code: 400,
+      });
+    }
+    this.init = init;
+  }
+
+  async execute(): Promise<IProxyResult<IRequestLog>> {
+    const data = this.init as IRequestProxyInit;
+    const { request, authorization, certificate, config={}, variables={}, flows } = data;
+    const factory = new HttpRequestRunner();
+    factory.variables = variables;
+    factory.logger = new DummyLogger();
+    factory.config = { ...config, enabled: true } as IRequestConfig;
+    if (Array.isArray(authorization) && authorization.length) {
+      factory.authorization = authorization;
+    }
+    if (Array.isArray(flows) && flows.length) {
+      factory.flows = flows;
+    }
+    if (certificate) {
+      factory.certificates = [certificate];
+    }
+    const result = await factory.run(request);
+    return {
+      result: result,
+      variables,
+    };
+  }
+}

package/src/proxy/readme.md

@@ -0,0 +1,9 @@
+# HTTP Proxy
+
+The libraries to create an HTTP/Socket proxy for API things (projects, requests).
+
+## Libraries
+
+- `AppProjectProxy` - a class that runs request from an `AppProject`
+- `HttpProjectProxy` - a class that runs request from an `HttpProject`
+- `RequestProxy` - a class that runs a single request as `HttpRequest`

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

@@ -166,6 +166,7 @@ export class HttpRequestRunner {
     const { variables, variablesProcessor } = this;
     let copy: IHttpRequest = { ...request };
     if (variables) {
+      copy.url = this.prepareRequestUrl(copy.url, variables);
       copy = await variablesProcessor.evaluateVariablesWithContext(copy, variables);
     }
     return copy;
@@ -350,4 +351,22 @@ export class HttpRequestRunner {
     }
     return !config.ignoreSessionCookies;
   }
+
+  /**
+   * When defined it applies the serve's base URI to relative URLs.
+   * @param currentUrl The URL to process.
+   */
+  prepareRequestUrl(currentUrl: string, variables: Record<string, string>): string {
+    const { baseUri } = variables;
+    if (!baseUri) {
+      return currentUrl;
+    }
+    if (currentUrl.startsWith('http:') || currentUrl.startsWith('https:')) {
+      return currentUrl;
+    }
+    if (currentUrl.startsWith('/')) {
+      return `${baseUri}${currentUrl}`;
+    }
+    return `${baseUri}/${currentUrl}`;
+  }
 }

package/src/runtime/node/InteropInterfaces.ts

@@ -4,6 +4,7 @@ import { Environment } from '../../models/Environment.js';
 import { Logger } from '../../lib/logging/Logger.js';
 import { IRequestLog } from '../../models/RequestLog.js';
 import { CookieJar } from '../../cookies/CookieJar.js';
+import { IAppProject } from 'browser.js';
 
 export interface IRequestRunnerOptions {
   /**
@@ -71,7 +72,7 @@ export interface IProjectParallelRunnerOptions extends IProjectRunnerOptions {
 }
 
 export interface IProjectParallelWorkerOptions extends IProjectRunnerOptions {
-  project: IHttpProject;
+  project: IHttpProject | IAppProject;
 }
 
 export interface IProjectRunnerOptions {

package/src/runtime/node/ProjectParallelRunner.ts

@@ -3,6 +3,7 @@ import { cpus } from 'os';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { HttpProject } from '../../models/HttpProject.js';
+import { AppProject } from '../../models/AppProject.js';
 import { IProjectExecutionLog, IProjectExecutionIteration } from '../reporters/Reporter.js';
 import { BaseRunner } from './BaseRunner.js';
 import { State } from './enums.js';
@@ -66,13 +67,13 @@ export interface ProjectParallelRunner {
  * change. This event can be user to refresh the UI to reflect the newest state.
  */
 export class ProjectParallelRunner extends BaseRunner {
-  project: HttpProject;
+  project: HttpProject | AppProject;
   options: IProjectParallelRunnerOptions;
   workers: WorkerInfoInternal[] = [];
   private mainResolver?: (report: IProjectExecutionLog) => void;
   private mainRejecter?: (err: Error) => void;
 
-  constructor(project: HttpProject, opts: IProjectParallelRunnerOptions = {}) {
+  constructor(project: HttpProject | AppProject, opts: IProjectParallelRunnerOptions = {}) {
     super();
     this.project = project;
     this.options = opts;

package/src/runtime/node/ProjectRequestRunner.ts

@@ -252,11 +252,11 @@ export class ProjectRequestRunner extends EventEmitter {
       key: request.key,
     };
     const requestData = request.expects.toJSON();
-    requestData.url = this.prepareRequestUrl(requestData.url, variables);
-
+    
     try {
       // Below replaces the single call to the `run()` function of the factory to 
       // report via the events a request object that has evaluated with the Jexl library.
+      requestData.url = factory.prepareRequestUrl(requestData.url, variables);
       const requestCopy = await factory.applyVariables(requestData);
       await factory.applyAuthorization(requestCopy);
       await factory.applyCookies(requestCopy);
@@ -333,22 +333,4 @@ export class ProjectRequestRunner extends EventEmitter {
     ctx.baseUri = baseUri || '';
     return this.variablesProcessor.buildContext(ctx);
   }
-
-  /**
-   * When defined it applies the serve's base URI to relative URLs.
-   * @param currentUrl The URL to process.
-   */
-  protected prepareRequestUrl(currentUrl: string, variables: Record<string, string>): string {
-    const { baseUri } = variables;
-    if (!baseUri) {
-      return currentUrl;
-    }
-    if (currentUrl.startsWith('http:') || currentUrl.startsWith('https:')) {
-      return currentUrl;
-    }
-    if (currentUrl.startsWith('/')) {
-      return `${baseUri}${currentUrl}`;
-    }
-    return `${baseUri}/${currentUrl}`;
-  }
 }

package/src/runtime/node/ProjectRunner.ts

@@ -11,9 +11,9 @@ import { pathExists, readJson } from '../../lib/fs/Fs.js';
 import { BaseRunner } from './BaseRunner.js';
 import { IProjectRunnerOptions, IRequestRunnerOptions } from './InteropInterfaces.js';
 import { State } from './enums.js';
-import { AppProject } from '../../models/AppProject.js';
+import { AppProject, AppProjectFolder } from '../../models/AppProject.js';
 
-type ProjectParent = HttpProject | ProjectFolder;
+type ProjectParent = HttpProject | ProjectFolder | AppProject | AppProjectFolder;
 
 export interface ProjectRunner {
   /**
@@ -173,7 +173,7 @@ export abstract class ProjectRunner extends BaseRunner {
    * A required step before running the project.
    * It configures the execution context. It may throw an error when configuration is not valid.
    */
-  async configure(project: HttpProject, opts: IProjectRunnerOptions = {}): Promise<void> {
+  async configure(project: HttpProject | AppProject, opts: IProjectRunnerOptions = {}): Promise<void> {
     this.project = project;
     this.options = opts || {};
     if (typeof this.options.iterations === 'number' && this.options.iterations >= 0) {

package/src/runtime/node/ProjectRunnerWorker.ts

@@ -2,7 +2,8 @@
 /* eslint-disable no-unused-vars */
 import process from 'process';
 import cluster from 'cluster';
-import { HttpProject } from '../../models/HttpProject.js';
+import { HttpProject, Kind as HttpProjectKind } from '../../models/HttpProject.js';
+import { AppProject, AppProjectKind } from '../../models/AppProject.js';
 import { IProjectExecutionLog } from '../reporters/Reporter.js';
 import { IWorkerMessage } from './ProjectParallelRunner.js';
 import { IProjectParallelWorkerOptions } from './InteropInterfaces.js';
@@ -16,7 +17,9 @@ class ProjectExeWorker extends ProjectRunner {
     if (cluster.isPrimary) {
       throw new Error(`This file should not be called directly.`);
     }
-    process.send!({ cmd: 'online' });
+    if (process.send) {
+      process.send({ cmd: 'online' });
+    }
     process.on('message', this.messageHandler.bind(this));
   }
 
@@ -29,11 +32,22 @@ class ProjectExeWorker extends ProjectRunner {
   async run(options: IProjectParallelWorkerOptions): Promise<void> {
     options.cookies = new InMemoryCookieJar();
     try {
-      await this.configure(new HttpProject(options.project), options);
+      const schema = options.project;
+      let project: HttpProject | AppProject;
+      if (schema.kind === HttpProjectKind) {
+        project = new HttpProject(schema);
+      } else if (schema.kind === AppProjectKind) {
+        project = new AppProject(schema);
+      } else {
+        throw new Error(`Unknown project kind: ${schema.kind}`);
+      }
+      await this.configure(project, options);
       await this.execute();
     } catch (e) {
       const cause = e as Error;
-      process.send!({ cmd: 'error', data: cause.message });
+      if (process.send) {
+        process.send({ cmd: 'error', data: cause.message });
+      }
     }
   }
 
@@ -58,7 +72,9 @@ class ProjectExeWorker extends ProjectRunner {
     this.endTime = Date.now();
 
     const log = await this.createReport();
-    process.send!({ cmd: 'result', data: log.iterations });
+    if (process.send) {
+      process.send({ cmd: 'result', data: log.iterations });
+    }
     this._state = State.Idle as State;
     return log;
   }