@team-internet/apiconnector 10.0.0

package/src/responsetemplatemanager.ts

@@ -0,0 +1,136 @@
+import { ResponseParser } from "./responseparser.js";
+import { Response } from "./response.js";
+
+/**
+ * ResponseTemplateManager Singleton Class
+ */
+export class ResponseTemplateManager {
+  /**
+   * Get ResponseTemplateManager Instance
+   * @returns ResponseTemplateManager Instance
+   */
+  public static getInstance(): ResponseTemplateManager {
+    if (!ResponseTemplateManager.instance) {
+      ResponseTemplateManager.instance = new ResponseTemplateManager();
+    }
+    return ResponseTemplateManager.instance;
+  }
+  /**
+   * ResponseTemplateManager Instance
+   */
+  private static instance: ResponseTemplateManager;
+  /**
+   * template container
+   */
+  public templates: any;
+
+  private constructor() {
+    this.templates = {
+      404: this.generateTemplate("421", "Page not found"),
+      500: this.generateTemplate("500", "Internal server error"),
+      empty: this.generateTemplate(
+        "423",
+        "Empty API response. Probably unreachable API end point {CONNECTION_URL}",
+      ),
+      error: this.generateTemplate(
+        "421",
+        "Command failed due to server error. Client should try again",
+      ),
+      expired: this.generateTemplate("530", "SESSIONID NOT FOUND"),
+      httperror: this.generateTemplate(
+        "421",
+        "Command failed due to HTTP communication error",
+      ),
+      invalid: this.generateTemplate(
+        "423",
+        "Invalid API response. Contact Support",
+      ),
+      nocurl: this.generateTemplate(
+        "423",
+        "API access error: curl_init failed",
+      ),
+      notfound: this.generateTemplate("500", "Response Template not found"),
+      unauthorized: this.generateTemplate("500", "Unauthorized"),
+    };
+  }
+
+  /**
+   * Generate API response template string for given code and description
+   * @param code API response code
+   * @param description API response description
+   * @returns generate response template string
+   */
+  public generateTemplate(code: string, description: string): string {
+    return `[RESPONSE]\r\nCODE=${code}\r\nDESCRIPTION=${description}\r\nEOF\r\n`;
+  }
+
+  /**
+   * Add response template to template container
+   * @param id template id
+   * @param plain API plain response
+   * @returns ResponseTemplateManager instance for method chaining
+   */
+  public addTemplate(id: string, plain: string): ResponseTemplateManager {
+    this.templates[id] = plain;
+    return ResponseTemplateManager.instance;
+  }
+
+  /**
+   * Get response template instance from template container
+   * @param id template id
+   * @returns template instance
+   */
+  public getTemplate(id: string): Response {
+    if (this.hasTemplate(id)) {
+      return new Response(id);
+    }
+    console.log("template id " + id);
+    return new Response("notfound");
+  }
+
+  /**
+   * Return all available response templates
+   * @returns all available response template instances
+   */
+  public getTemplates(): any {
+    const tpls: any = {};
+    Object.keys(this.templates).forEach((key) => {
+      tpls[key] = new Response(key);
+    });
+    return tpls;
+  }
+
+  /**
+   * Check if given template exists in template container
+   * @param id template id
+   * @returns boolean result
+   */
+  public hasTemplate(id: string): boolean {
+    return Object.prototype.hasOwnProperty.call(this.templates, id);
+  }
+
+  /**
+   * Check if given API response hash matches a given template by code and description
+   * @param tpl2 api response hash
+   * @param id template id
+   * @returns boolean result
+   */
+  public isTemplateMatchHash(tpl2: any, id: string): boolean {
+    const h = this.getTemplate(id).getHash();
+    return h.CODE === tpl2.CODE && h.DESCRIPTION === tpl2.DESCRIPTION;
+  }
+
+  /**
+   * Check if given API plain response matches a given template by code and description
+   * @param plain API plain response
+   * @param id template id
+   * @returns boolean result
+   */
+  public isTemplateMatchPlain(plain: string, id: string): boolean {
+    const h = this.getTemplate(id).getHash();
+    const tpl2 = ResponseParser.parse(plain);
+    return h.CODE === tpl2.CODE && h.DESCRIPTION === tpl2.DESCRIPTION;
+  }
+}
+
+ResponseTemplateManager.getInstance();

package/src/responsetranslator.ts

@@ -0,0 +1,191 @@
+import { ResponseTemplateManager as RTM } from "./responsetemplatemanager.js";
+
+function preg_quote(str: string, delimiter: string = "") {
+  // MIT, from: https://locutus.io/php/preg_quote/
+  return (str + "").replace(
+    new RegExp("[.\\\\+*?\\[\\^\\]$(){}=!<>|:\\" + delimiter + "-]", "g"),
+    "\\$&",
+  );
+}
+
+/**
+ * ResponseTranslator class
+ */
+export class ResponseTranslator {
+  /**
+   * Regular Expression Mapping for API DESCRIPTION Property translation
+   */
+  private static descriptionRegexMap: Object = {
+    // HX
+    "Authorization failed; Operation forbidden by ACL":
+      "Authorization failed; Used Command `{COMMAND}` not white-listed by your Access Control List",
+    "Request is not available; DOMAIN TRANSFER IS PROHIBITED BY STATUS (clientTransferProhibited)/WRONG AUTH":
+      "This Domain is locked and the given Authorization Code is wrong. Initiating a Transfer is therefore impossible.",
+    "Request is not available; DOMAIN TRANSFER IS PROHIBITED BY STATUS (clientTransferProhibited)":
+      "This Domain is locked. Initiating a Transfer is therefore impossible.",
+    "Request is not available; DOMAIN TRANSFER IS PROHIBITED BY STATUS (requested)":
+      "Registration of this Domain Name has not yet completed. Initiating a Transfer is therefore impossible.",
+    "Request is not available; DOMAIN TRANSFER IS PROHIBITED BY STATUS (requestedcreate)":
+      "Registration of this Domain Name has not yet completed. Initiating a Transfer is therefore impossible.",
+    "Request is not available; DOMAIN TRANSFER IS PROHIBITED BY STATUS (requesteddelete)":
+      "Deletion of this Domain Name has been requested. Initiating a Transfer is therefore impossible.",
+    "Request is not available; DOMAIN TRANSFER IS PROHIBITED BY STATUS (pendingdelete)":
+      "Deletion of this Domain Name is pending. Initiating a Transfer is therefore impossible.",
+    "Request is not available; DOMAIN TRANSFER IS PROHIBITED BY WRONG AUTH":
+      "The given Authorization Code is wrong. Initiating a Transfer is therefore impossible.",
+    "Request is not available; DOMAIN TRANSFER IS PROHIBITED BY AGE OF THE DOMAIN":
+      "This Domain Name is within 60 days of initial registration. Initiating a Transfer is therefore impossible.",
+    "Attribute value is not unique; DOMAIN is already assigned to your account":
+      "You cannot transfer a domain that is already on your account at the registrar's system.",
+    // CNR
+    "Missing required attribute; premium domain name. please provide required parameters":
+      "Confirm the Premium pricing by providing the necessary premium domain price data.",
+    SkipPregQuote: {
+      // HX
+      "Invalid attribute value syntax; resource record [(.+)]":
+        "Invalid Syntax for DNSZone Resource Record: $1",
+      "Missing required attribute; CLASS(?:=| [MUST BE )PREMIUM_([w+]+)[s]]":
+        "Confirm the Premium pricing by providing the parameter CLASS with the value PREMIUM_$1.",
+      "Syntax error in Parameter DOMAIN ((.+))":
+        "The Domain Name $1 is invalid.",
+    },
+  };
+
+  /**
+   * translate a raw api response
+   * @param raw API raw response
+   * @param cmd requested API command
+   * @param ph list of place holder vars
+   * @returns new translated raw response
+   */
+  public static translate(raw: string, cmd: any, ph: any = {}): string {
+    let httperror = "";
+    let newraw = raw || "empty";
+    // Hint: Empty API Response (replace {CONNECTION_URL} later)
+
+    // curl error handling
+    const isHTTPError = newraw.substring(0, 10) === "httperror|";
+    if (isHTTPError) {
+      [newraw, httperror] = newraw.split("|");
+    }
+
+    // Explicit call for a static template
+    if (RTM.getInstance().hasTemplate(newraw)) {
+      // don't use getTemplate as it leads to endless loop as of again
+      // creating a response instance
+      newraw = RTM.getInstance().templates[newraw];
+      if (isHTTPError && httperror.length) {
+        newraw = newraw.replace(/\{HTTPERROR\}/, " (" + httperror + ")");
+      }
+    }
+
+    // Missing CODE or DESCRIPTION in API Response
+    if (
+      (!/description[\s]*=/i.test(newraw) || // missing description
+        /description[\s]*=\r\n/i.test(newraw) || // empty description
+        !/code[\s]*=/i.test(newraw)) && // missing code
+      RTM.getInstance().hasTemplate("invalid")
+    ) {
+      newraw = RTM.getInstance().templates.invalid;
+    }
+
+    // Iterate through the description-to-regex mapping
+    // generic API response description rewrite
+    let data: string = "";
+    for (const [regex, val] of Object.entries(
+      ResponseTranslator.descriptionRegexMap,
+    )) {
+      // Check if regex should be treated as multiple patterns
+      if (regex === "SkipPregQuote") {
+        // Iterate through each temporary pattern in val
+        for (const [tmpregex, tmpval] of Object.entries(val)) {
+          // Attempt to find a match using the temporary pattern
+          data = ResponseTranslator.findMatch(
+            tmpregex,
+            newraw,
+            "" + tmpval,
+            cmd,
+            ph,
+          );
+
+          // If a match is found, exit the inner loop
+          if (data) {
+            newraw = data;
+            break;
+          }
+        }
+      } else {
+        // Escape the pattern and attempt to find a match for it
+        const escapedregex = preg_quote(regex);
+        console.log(newraw);
+        data = ResponseTranslator.findMatch(escapedregex, newraw, val, cmd, ph);
+        console.log(newraw);
+      }
+
+      // If a match is found, exit the outer loop
+      if (data) {
+        newraw = data;
+        break;
+      }
+    }
+
+    const cregex = /\{.+\}/;
+    if (cregex.test(newraw)) {
+      newraw = newraw.replace(cregex, "");
+    }
+
+    return newraw;
+  }
+
+  /**
+   * Finds a match in the given text and performs replacements based on patterns and placeholders.
+   *
+   * This function searches for a specified regular expression pattern in the provided text and
+   * performs replacements based on the matched pattern, command data, and placeholder values.
+   *
+   * @param regex The regular expression pattern to search for.
+   * @param newraw The input text where the match will be searched for.
+   * @param val The value to be used in replacement if a match is found.
+   * @param cmd The command data containing replacements, if applicable.
+   * @param ph An array of placeholder values for further replacements.
+   *
+   * @return Returns non-empty string if replacements were performed, empty string otherwise.
+   */
+  protected static findMatch(
+    regex: string,
+    newraw: string,
+    val: string,
+    cmd: any = {},
+    ph: any = {},
+  ): string {
+    // match the response for given description
+    // NOTE: we match if the description starts with the given description
+    // it would also match if it is followed by additional text
+    const qregex = new RegExp("/descriptions*=s*" + regex + "([^\\r\\n]+)?/i");
+    let ret = "";
+
+    if (qregex.test(newraw)) {
+      // If "COMMAND" exists in cmd, replace "{COMMAND}" in val
+      if (Object.prototype.hasOwnProperty.call(cmd, "COMMAND")) {
+        val = val.replace("{COMMAND}", cmd.COMMAND);
+      }
+
+      // If $newraw matches $qregex, replace with "description=" . $val
+      let tmp = newraw.replace(qregex, "description=" + val);
+      if (newraw !== tmp) {
+        ret = tmp;
+      }
+    }
+
+    // Generic replacing of placeholder vars
+    const vregex = /\{[^}]+\}/;
+    if (vregex.test(newraw)) {
+      for (const [tkey, tval] of Object.entries(ph)) {
+        newraw = newraw.replace("{" + tkey + "}", "" + tval);
+      }
+      newraw = newraw.replace(vregex, "");
+      ret = newraw;
+    }
+    return ret;
+  }
+}

package/src/socketconfig.ts

@@ -0,0 +1,116 @@
+export const fixedURLEnc = (str: string): string => {
+  return encodeURIComponent(str).replace(/[!'()*]/g, (c) => {
+    return `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+  });
+};
+
+/**
+ * SocketConfig Class
+ */
+export class SocketConfig {
+  /**
+   * account name
+   */
+  private login: string;
+  /**
+   * persistent for session request
+   */
+  private persistent: string;
+  /**
+   * account password
+   */
+  private pw: string;
+  /**
+   * API session id
+   */
+  private sessionid: string;
+
+  public constructor() {
+    this.login = "";
+    this.persistent = "";
+    this.pw = "";
+    this.sessionid = "";
+  }
+
+  /**
+   * Create POST data string out of connection data
+   * @returns POST data string
+   */
+  public getPOSTData(): string {
+    let data = "";
+    if (this.login !== "") {
+      data += `${fixedURLEnc("s_login")}=${fixedURLEnc(this.login)}&`;
+    }
+    if (this.persistent !== "") {
+      data += `${fixedURLEnc("persistent")}=${fixedURLEnc(this.persistent)}&`;
+    }
+    if (this.pw !== "") {
+      data += `${fixedURLEnc("s_pw")}=${fixedURLEnc(this.pw)}&`;
+    }
+    if (this.sessionid !== "") {
+      data += `${fixedURLEnc("s_sessionid")}=${fixedURLEnc(this.sessionid)}&`;
+    }
+    return data;
+  }
+
+  /**
+   * Get API Session ID in use
+   * @returns API Session ID
+   */
+  public getSession(): string {
+    return this.sessionid;
+  }
+
+  /**
+   * Set account login to use
+   * @param value account login
+   * @returns Current SocketConfig instance for method chaining
+   */
+  public setLogin(value: string): SocketConfig {
+    this.sessionid = "";
+    this.login = value;
+    return this;
+  }
+
+  /**
+   * Get account login to use
+   * @returns Current login
+   */
+  public getLogin(): string {
+    return this.login;
+  }
+
+  /**
+   * Set persistent to request session id
+   * @param value one time password
+   * @returns Current SocketConfig instance for method chaining
+   */
+  public setPersistent(): SocketConfig {
+    this.sessionid = "";
+    this.persistent = "1";
+    return this;
+  }
+
+  /**
+   * Set account password to use
+   * @param value account password
+   * @returns Current SocketConfig instance for method chaining
+   */
+  public setPassword(value: string): SocketConfig {
+    this.sessionid = "";
+    this.pw = value;
+    return this;
+  }
+
+  /**
+   * Set API Session ID to use
+   * @param value API Session ID
+   * @returns Current SocketConfig instance for method chaining
+   */
+  public setSession(value: string): SocketConfig {
+    this.sessionid = value;
+    this.pw = "";
+    this.persistent = "";
+    return this;
+  }
+}