@api-client/core 0.3.3 → 0.3.6

package/src/data/Json2Xml.ts

@@ -0,0 +1,190 @@
+/**
+ * Normalizes given name to a value that can be accepted by `createElement`
+ * function on a document object.
+ * @param name A name to process
+ * @returns Normalized name
+ */
+export const normalizeXmlTagName = (name: string): string => name.replace(/[^a-zA-Z0-9-_.]/g, '');
+
+/**
+ * Converts a JSON value to an XML.
+ * 
+ * To convert a JSON to XML call the `convert()` function. This creates the `doc` property with the XML document.
+ * To transform the document into an XML string, use the `serialize()` function.
+ * 
+ * This library work in both browser and NodeJS (via the `@xmldom/xmldom` library.)
+ */
+export class Json2Xml {
+  /**
+   * Whether it uses native or synthetic API.
+   */
+  syntheticApi: boolean;
+  /**
+   * Created document
+   */
+  doc?: XMLDocument;
+  /**
+   * The current node that is being processed.
+   */
+  currentNode?: Element;
+
+  constructor() {
+    this.syntheticApi = typeof DOMParser === 'undefined';
+  }
+
+  /**
+   * Converts a JavaScript object to an XML document.
+   * This creates the `doc` property with the JSON translated to the XML document.
+   * Use the `serialize()` to convert it to string.
+   * 
+   * @param data A JavaScript object to convert
+   * @param root The name of the root node. Defaults to "root"
+   */
+  async convert(data: any, root='root'): Promise<void> {
+    const doc = await this.getDocument();
+    this.doc = doc;
+    const rootNode = doc.createElement(root);
+    doc.appendChild(rootNode);
+    this.currentNode = rootNode;
+
+    if (Array.isArray(data)) {
+      this.processArray(data);
+    } else if (typeof data === 'object') {
+      this.processObject(data);
+    } else {
+      throw new Error('Invalid object. Unable to process non-object property.');
+    }
+  }
+
+  /**
+   * Converts the current document to a string.
+   * @returns The converted document.
+   */
+  async serialize(): Promise<string> {
+    const { doc } = this;
+    if (!doc) {
+      throw new Error(`No document created.`);
+    }
+    const serializer = await this.getSerializer();
+    return serializer.serializeToString(doc);
+  }
+
+  /**
+   * A helper function to convert and serialize a JSON to XML.
+   * 
+   * @param data The JSON data to serialize
+   * @param root The name of the root node. Defaults to "root"
+   * @returns The serialized to XML value.
+   */
+  async serializeJson(data: any, root='root'): Promise<string> {
+    await this.convert(data, root);
+    return this.serialize();
+  }
+
+  /**
+   * Depending on the environment it creates the XML document implementation.
+   * 
+   * @returns The XML document to use
+   */
+  async getDocument(): Promise<XMLDocument> {
+    let doc: XMLDocument;
+    if (this.syntheticApi) {
+      const { DOMImplementation } = await import('@xmldom/xmldom');
+      doc = new DOMImplementation().createDocument(null, null, null);
+    } else {
+      doc = document.implementation.createDocument(null, null, null);
+    }
+    return doc;
+  }
+
+  /**
+   * Depending on the environment it creates the XML serializer implementation.
+   * 
+   * @returns The XML serializer to use
+   */
+  async getSerializer(): Promise<XMLSerializer> {
+    if (this.syntheticApi) {
+      const { XMLSerializer } = await import('@xmldom/xmldom');
+      return new XMLSerializer;
+    }
+    return new XMLSerializer();
+  }
+
+  /**
+   * Processes a property which type is not yet detected
+   * @param input The input to process.
+   */
+  processAny(input: any): void {
+    const type = typeof input;
+    if (Array.isArray(input)) {
+      this.processArray(input);
+    } else if (type === 'object' && input !== null) {
+      this.processObject(input);
+    } else {
+      this.processScalar(input);
+    }
+  }
+
+  /**
+   * Processes an array.
+   * @param input The array to process.
+   */
+  processArray(input: any[]): void {
+    if (!Array.isArray(input)) {
+      throw new Error(`Expected array. ${typeof input} given.`);
+    }
+    input.forEach((item) => this.processAny(item));
+  }
+
+  /**
+   * Appends object properties to the current node.
+   * @param input The object to process.
+   */
+  processObject(input: any): void {
+    const { currentNode, doc } = this;
+    if (!currentNode || !doc) {
+      throw new Error(`Library not initialized. Call the convert() function.`);
+    }
+    Object.keys(input).forEach((key) => {
+      const val = input[key];
+      const elementName = normalizeXmlTagName(key);
+      const element = doc.createElement(elementName);
+      currentNode.appendChild(element);
+      this.currentNode = element;
+      this.processAny(val);
+    });
+    this.currentNode = currentNode;
+  }
+
+  /**
+   * Adds the value to the current node.
+   * @param input the scalar to add
+   */
+  processScalar(input: any): void {
+    const { currentNode, doc } = this;
+    if (!currentNode || !doc) {
+      throw new Error(`Library not initialized. Call the convert() function.`);
+    }
+    if (input === undefined || input === null) {
+      // nothing to add. silently quit.
+      return;
+    }
+    let value: any = '';
+    let valid = false;
+    if (!valid && ['boolean', 'string', 'number', 'bigint'].includes(typeof input)) {
+      valid = true;
+      value = input;
+    }
+    if (!valid) {
+      throw new Error(`Invalid scalar type: ${typeof input}.`);
+    }
+    const typedValue = String(value);
+    if (typedValue.includes('<') || typedValue.includes('>')) {
+      const cdata = doc.createCDATASection(typedValue);
+      currentNode.appendChild(cdata);
+    } else {
+      const node = doc.createTextNode(typedValue);
+      currentNode.appendChild(node);
+    }
+  }
+}

package/src/data/JsonReader.ts

@@ -0,0 +1,41 @@
+import { Json2Xml } from './Json2Xml.js';
+import { XmlReader } from './XmlReader.js';
+
+/**
+ * A class that converts the passed JSON value to XML and then it performs
+ * search through the XPath implementation.
+ */
+export class JsonReader extends XmlReader {
+  async getValue(path: string): Promise<unknown> {
+    const body = await this.readPayloadAsString();
+    if (!body) {
+      return undefined;
+    }
+    let obj: any;
+    try {
+      obj = JSON.parse(body);
+    } catch (e) {
+      return undefined;
+    }
+    const factory = new Json2Xml();
+    const str = await factory.serializeJson(obj);
+    const doc = await this.getDocumentWithBody(str);
+    if (!doc) {
+      return undefined;
+    }
+
+    // the below works well in a browser but in Node it won't process the document created from
+    // a synthetic API.
+    // await factory.convert(obj);
+    // const doc = factory.doc as XMLDocument;
+
+    let finalPath = path;
+    if (finalPath.startsWith('/') && !finalPath.startsWith('//')) {
+      finalPath = `/root${finalPath}`;
+    } else if (!finalPath.startsWith('/')) {
+      finalPath = `/root/${finalPath}`;
+    }
+    
+    return this.queryDocument(finalPath, doc);
+  }
+}

package/src/data/PayloadPointer.ts

@@ -0,0 +1,48 @@
+import { Payload } from '../lib/transformers/PayloadSerializer.js';
+import { JsonReader } from './JsonReader.js'
+import { XmlReader } from './XmlReader.js'
+import { UrlEncodedReader } from './UrlEncodedReader.js'
+import { DataReader } from './DataReader.js'
+
+/**
+ * A class that creates a pointer to a value in a Payload.
+ */
+export class PayloadPointer {
+  payload?: Payload;
+  mime?: string;
+  path: string;
+
+  /**
+   * @param path The path to the data.
+   * @param payload The Payload value. Note, without the payload the `getValue()` always returns `undefined`. This is optional for convenience.
+   * @param mime The content type of the body message. Note, without the payload's mime the `getValue()` always returns `undefined`. This is optional for convenience.
+   */
+  constructor(path: string, payload?: Payload, mime?: string) {
+    this.path = path;
+    this.payload = payload;
+    this.mime = mime;
+  }
+
+  /**
+   * @returns the value for the `path`.
+   */
+  async getValue(): Promise<unknown> {
+    const { path, payload, mime } = this;
+    if (!mime || !path || !payload) {
+      return undefined;
+    }
+    let reader: DataReader | undefined;
+    if (mime.includes('json')) {
+      reader = new JsonReader();
+    } else if (mime.includes('xml')) {
+      reader = new XmlReader();
+    } else if (mime.includes('x-www-form-urlencoded')) {
+      reader = new UrlEncodedReader();
+    }
+    if (!reader) {
+      return undefined;
+    }
+    reader.payload = payload;
+    return reader.getValue(path);
+  }
+}

package/src/data/RequestDataExtractor.ts

@@ -0,0 +1,133 @@
+import * as DataUtils from './DataUtils.js';
+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 { IDataSource } from '../models/actions/Condition.js';
+import { ActionTypeEnum } from '../models/actions/Enums.js';
+import { Headers } from '../lib/headers/Headers.js';
+import { JsonReader } from './JsonReader.js';
+import { XmlReader } from './XmlReader.js';
+import { UrlEncodedReader } from './UrlEncodedReader.js';
+import { DataReader } from './DataReader.js';
+
+/**
+ * A class to extract data from the request or the response.
+ */
+export class RequestDataExtractor {
+  /**
+   * The request that has been sent to the server.
+   */
+  request: HttpRequest | SentRequest;
+  /**
+   * The response object
+   */
+  response?: HttpResponse | ErrorResponse;
+  constructor(request: IHttpRequest | ISentRequest, response?: IHttpResponse | IErrorResponse) {
+    this.request = new HttpRequest(request);
+    if (response) {
+      if (ErrorResponse.isErrorResponse(response)) {
+        this.response = new ErrorResponse(response as IErrorResponse);
+      } else {
+        this.response = new HttpResponse(response);
+      }
+    }
+  }
+
+  /**
+   * Reads the data from the selected path.
+   * 
+   * @param config The configuration of the data source
+   * @return Data to be processed
+   */
+  async extract(config: IDataSource): Promise<string | number | undefined> {
+    const { type, source, path, value } = config;
+    if (source === 'value') {
+      return value;
+    }
+    const args = path ? path.split('.') : [];
+    switch (source) {
+      case 'url':
+        return DataUtils.getDataUrl(this.getUrl(), args);
+      case 'headers':
+        return DataUtils.getDataHeaders(this.getHeaders(type), args);
+      case 'status':
+        return this.response && this.response.status;
+      case 'method':
+        return this.request.method;
+      case 'body':
+        return this.processBody(path, type);
+      default:
+        throw new Error(`Unknown source ${source} for ${type} data`);
+    }
+  }
+
+  /**
+   * @param source The source name 
+   * @returns The URL of the request
+   */
+  getUrl(): string {
+    return this.request.url;
+  }
+
+  /**
+   * @param source The source name 
+   * @returns The headers from the request / response
+   */
+  getHeaders(source?: ActionTypeEnum): string {
+    if (source === 'request') {
+      return this.request.headers || '';
+    }
+    return this.response && this.response.headers || '';
+  }
+
+  async processBody(path?: string, source?: ActionTypeEnum): Promise<string | undefined> {
+    const value = await this.getBody(source);
+    if (!value) {
+      return undefined;
+    }
+    if (!path) {
+      return value;
+    }
+    const headersValue = this.getHeaders(source);
+    if (!headersValue) {
+      return undefined;
+    }
+    const headers = new Headers(headersValue);
+    const mime = headers.get('content-type');
+    if (!mime) {
+      return undefined;
+    }
+    return this.extractBody(value, mime, path);
+  }
+
+  /**
+   * @param source The source name 
+   * @returns The headers from the request / response
+   */
+  async getBody(source?: ActionTypeEnum): Promise<string | undefined> {
+    if (source === 'request') {
+      return this.request.readPayloadAsString();
+    }
+    if (this.response) {
+      return this.response.readPayloadAsString();
+    }
+    return undefined;
+  }
+
+  async extractBody(value: string, mime: string, path: string): Promise<string | undefined> {
+    let reader: DataReader | undefined;
+    if (mime.includes('json')) {
+      reader = new JsonReader();
+    } else if (mime.includes('xml')) {
+      reader = new XmlReader();
+    } else if (mime.includes('x-www-form-urlencoded')) {
+      reader = new UrlEncodedReader();
+    }
+    if (!reader) {
+      return undefined;
+    }
+    await reader.writePayload(value);
+    return reader.getValue(path) as Promise<string>;
+  }
+}

package/src/data/UrlEncodedReader.ts

@@ -0,0 +1,20 @@
+import { DataReader } from './DataReader.js';
+
+/**
+ * Reads a value for a property in an `application/x-www-form-urlencoded` body.
+ */
+export class UrlEncodedReader extends DataReader {
+  /**
+   * @param path Since the `application/x-www-form-urlencoded` is a key-value pair this can be just a simple name of the property to read.
+   * @returns The value of the property or undefined.
+   */
+  async getValue(path: string): Promise<unknown> {
+    const body = await this.readPayloadAsString();
+    const parsed = new URLSearchParams(body);
+    const result = parsed.get(path);
+    if (result === null) {
+      return undefined;
+    }
+    return result;
+  }
+}

package/src/data/XmlReader.ts

@@ -0,0 +1,103 @@
+import { DataReader } from './DataReader.js';
+
+let xResult: typeof XPathResult | undefined = typeof XPathResult !== 'undefined' ? XPathResult : undefined;
+
+/**
+ * Reads the data from an XML using the xpath.
+ * See https://www.w3schools.com/xml/xpath_syntax.asp.
+ */
+export class XmlReader extends DataReader {
+  async getValue(path: string): Promise<unknown> {
+    const doc = await this.getDocument();
+    if (!doc) {
+      return undefined;
+    }
+    return this.queryDocument(path, doc);
+  }
+
+  queryDocument(path: string, doc: Document): unknown {
+    try {
+      const result = doc.evaluate(path, doc);
+      switch (result.resultType) {
+        case xResult!.NUMBER_TYPE: return result.numberValue;
+        case xResult!.STRING_TYPE: return result.stringValue;
+        case xResult!.BOOLEAN_TYPE: return result.booleanValue;
+        case xResult!.UNORDERED_NODE_ITERATOR_TYPE: 
+        case xResult!.ORDERED_NODE_ITERATOR_TYPE: 
+          return this.processNodeResult(result);
+        default:
+          console.error(`Unsupported xpath result type: [${result.resultType}]`);
+          return undefined;
+      }
+    } catch (e) {
+      console.error(e);
+      return undefined;
+    }
+  }
+
+  processNodeResult(result: XPathResult): unknown {
+    const results: any[] = [];
+    let next = result.iterateNext();
+    while (next) {
+      const value = next.textContent;
+      if (value) {
+        results.push(value.trim());
+      }
+      next = result.iterateNext();
+    }
+    if (!results.length) {
+      return undefined;
+    }
+    return results.length === 1 ? results[0] : results;
+  }
+
+  async getDocument(): Promise<Document|undefined> {
+    const body = await this.readPayloadAsString();
+    if (!body) {
+      return undefined;
+    }
+    return this.getDocumentWithBody(body);
+  }
+
+  async getDocumentWithBody(body: string): Promise<Document|undefined> {
+    if (typeof DOMParser === 'undefined') {
+      return this.getNodeDocument(body);
+    }
+    return this.getWebDocument(body);
+  }
+
+  async getWebDocument(data: string): Promise<Document|undefined> {
+    const parser = new DOMParser();
+    const dom = parser.parseFromString(data, 'text/xml');
+    if (dom.querySelector('parsererror')) {
+      return undefined;
+    }
+    return dom;
+  }
+
+  async getNodeDocument(data: string): Promise<Document|undefined> {
+    const { DOMParser } = await import('@xmldom/xmldom');
+    const xpath = await import('xpath');
+    // @ts-ignore
+    xResult = xpath.default.XPathResult;
+    let errored = false;
+    const parser = new DOMParser({
+      errorHandler: {
+        error: (): void => { 
+          errored = true;
+        },
+        fatalError: (): void => { 
+          errored = true;
+        }
+      }
+    });
+    const dom = parser.parseFromString(data, 'text/xml');
+    if (errored) {
+      return undefined;
+    }
+    dom.evaluate = (expression: string, contextNode: Node): XPathResult => {
+      return xpath.default.evaluate(expression, contextNode, null, 0, null);
+    }
+    return dom;
+  }
+}