@api-client/core 0.7.9 → 0.7.10

package/src/proxy/HttpProjectProxy.ts

@@ -0,0 +1,113 @@
+import { IProjectRunnerOptions } from "../runtime/node/InteropInterfaces.js";
+import { Kind as HttpProjectKind, HttpProject, IHttpProject } from "../models/HttpProject.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 IHttpProjectProxyInit {
+  kind: typeof HttpProjectKind;
+  /**
+   * Project key
+   */
+  pid: string; 
+  /**
+   * Runner options.
+   */
+  options: IProjectRunnerOptions;
+}
+
+/**
+ * Runs requests from an HTTP project read from the store.
+ */
+export default class HttpProjectProxy extends Proxy {
+  project?: HttpProject;
+  options?: IProjectRunnerOptions;
+
+  async configure(init: IHttpProjectProxyInit, token: string, baseUri: string): Promise<void> {
+    const { pid, options } = init;
+    if (!pid) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The "pid" 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: IHttpProject;
+    try {
+      project = await sdk.file.read(pid, true) as IHttpProject;
+    } 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 HttpProject(project);
+  }
+  
+  async execute(): Promise<IProxyResult> {
+    const project = this.project as HttpProject;
+    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,
+    };
+  }
+}

package/src/proxy/Proxy.ts

@@ -0,0 +1,30 @@
+import { IRequestLog } from "../models/RequestLog.js";
+import { IProjectExecutionLog } from "../runtime/reporters/Reporter.js";
+
+export interface IProxyResult<T = IProjectExecutionLog | IRequestLog> {
+  /**
+   * The result of the proxy execution. It can be project execution log or a request log.
+   */
+  result: T;
+  /**
+   * Optional variables updated during the execution.
+   */
+  variables?: Record<string, string>;
+}
+
+export default abstract class Proxy {
+  /**
+   * The time when this class was initialized.
+   */
+  time = Date.now();
+
+  /**
+   * Configures the proxy before running it.
+   */
+  abstract configure(...args: unknown[]): Promise<unknown>;
+
+  /**
+   * Executes the proxy.
+   */
+  abstract execute(body?: Buffer): Promise<IProxyResult>;
+}

package/src/proxy/ProxyService.ts

@@ -0,0 +1,73 @@
+import { ApiError } from "../runtime/store/Errors.js";
+import v4 from "../lib/uuid.js";
+import AppProjectProxy, { IAppProjectProxyInit } from "./AppProjectProxy.js";
+import HttpProjectProxy, { IHttpProjectProxyInit } from "./HttpProjectProxy.js";
+import { IProxyResult } from "./Proxy.js";
+import RequestProxy, { IRequestProxyInit } from "./RequestProxy.js";
+
+type Proxy = RequestProxy | HttpProjectProxy | AppProjectProxy;
+
+export default class ProxyService {
+  state = new Map<string, Proxy>();
+
+  /**
+   * Executes a single HTTP request.
+   * @param init The request to execute with additional configuration.
+   * @returns The key under which the proxy is cached.
+   */
+  async addRequestProxy(init: IRequestProxyInit): Promise<string> {
+    const proxy = new RequestProxy();
+    await proxy.configure(init);
+    const id = v4();
+    this.state.set(id, proxy);
+    return id;
+  }
+
+  /**
+   * 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 addHttpProjectProxy(token: string, storeUri: string, init: IHttpProjectProxyInit): Promise<string> {
+    const proxy = new HttpProjectProxy();
+    await proxy.configure(init, token, storeUri);
+    const id = v4();
+    this.state.set(id, proxy);
+    return id;
+  }
+
+  /**
+   * 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 addAppProjectProxy(token: string, storeUri: string, init: IAppProjectProxyInit): Promise<string> {
+    const proxy = new AppProjectProxy();
+    await proxy.configure(init, token, storeUri);
+    const id = v4();
+    this.state.set(id, proxy);
+    return id;
+  }
+
+  /**
+   * Executes previously configured proxy.
+   * 
+   * @param key The key returned by the add proxy function.
+   * @param body Optional body to send with the `HttpRequest` proxy.
+   * @returns The execution log depending on the proxy type.
+   */
+  async proxy(key: string, body?: Buffer): Promise<IProxyResult> {
+    const proxy = this.state.get(key);
+    if (!proxy) {
+      throw new ApiError(`Unknown key: ${key}. The request may have been already executed.`, 400);
+    }
+    this.state.delete(key);
+    return proxy.execute(body);
+  }
+}

package/src/proxy/RequestProxy.ts

@@ -0,0 +1,94 @@
+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';
+
+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(body?: Buffer): Promise<IProxyResult> {
+    const data = this.init as IRequestProxyInit;
+    const { request, authorization, certificate, config={}, variables={}, flows } = data;
+    if (body) {
+      request.payload = {
+        type: 'buffer',
+        data: [...body],
+      };
+    }
+    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,14 @@
+# 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`
+
+## Architecture
+
+The proxy is a 2-step process. In the first step the client sets-up a session (in a server that implements the proxy), processes the configuration, and validates the data.
+In the second step the request is actually being executed. This 2nd step is very important when proxying `HttpRequest` as the `payload` read from the second server call is passed to the outgoing request (if any).

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/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}`;
-  }
 }