Source: search-service-client.js

  1. /**
  2.  * @file Provides the (http) client/connection to the search backend service.
  3.  * @version {@link https://github.com/JohT/search-menu-ui/releases/latest latest version}
  4.  * @author JohT
  5.  * @version ${project.version}
  6.  */
  8. "use strict";
  10. var module = datarestructorInternalCreateIfNotExists(module); // Fallback for vanilla js without modules
  12. function datarestructorInternalCreateIfNotExists(objectToCheck) {
  13.   return objectToCheck || {};
  14. }
  16. /**
  17.  * Search-Menu Service-Client.
  18.  * It provides the (http) client/connection to the search backend service.
  19.  * @module searchMenuServiceClient
  20.  */
  21. var searchMenuServiceClient = (module.exports = {}); // Export module for npm...
  22. searchMenuServiceClient.internalCreateIfNotExists = datarestructorInternalCreateIfNotExists;
  24. var xmlHttpRequest = xmlHttpRequest || require("../../src/js/ponyfills/xmlHttpRequestPonyfill"); // supports vanilla js & npm
  26.  searchMenuServiceClient.HttpSearchConfig = (function () {
  27.   /**
  28.    * Configures and builds the {@link module:searchMenuServiceClient.HttpClient}.
  29.    * DescribedDataField is the main element of the restructured data and therefore considered "public".
  30.    * @constructs HttpSearchConfig
  31.    * @alias module:searchMenuServiceClient.HttpSearchConfig
  32.    */
  33.   function HttpSearchConfig() {
  34.     /**
  35.      * HTTP Search Configuration.
  36.      * @property {string} searchUrlTemplate URL that is called for every search request. It may include variables in double curly brackets like `{{searchtext}}`.
  37.      * @property {string} [searchMethod="POST"] HTTP Method, that is used for every search request.
  38.      * @property {string} [searchContentType="application/json"] HTTP MIME-Type of the body, that is used for every search request.
  39.      * @property {string} searchBodyTemplate HTTP body template, that is used for every search request. It may include variables in double curly brackets like `{{jsonSearchParameters}}`.
  40.      * @property {XMLHttpRequest} [httpRequest=new XMLHttpRequest()] Contains the XMLHttpRequest that is used to handle HTTP requests and responses. Defaults to XMLHttpRequest.
  41.      * @property {boolean} [debugMode=false] Adds detailed logging for development and debugging.
  42.      */
  43.     this.config = {
  44.       searchUrlTemplate: "",
  45.       searchMethod: "POST",
  46.       searchContentType: "application/json",
  47.       searchBodyTemplate: null,
  48.       /**
  49.        * Resolves variables in the search url template based on the given search parameters object.
  50.        * The variable {{jsonSearchParameters}} will be replaced by the JSON of all search parameters.
  51.        * @param {Object} searchParameters object properties will be used to replace the variables of the searchUrlTemplate
  52.        */
  53.       resolveSearchUrl: function (searchParameters) {
  54.         return resolveTemplate(this.searchUrlTemplate, searchParameters, this.debugMode);
  55.       },
  56.       /**
  57.        * Resolves variables in the search body template based on the given search parameters object.
  58.        * The variable {{jsonSearchParameters}} will be replaced by the JSON of all search parameters.
  59.        * @param {Object} searchParameters object properties will be used to replace the variables of the searchBodyTemplate
  60.        */
  61.       resolveSearchBody: function (searchParameters) {
  62.         return resolveTemplate(this.searchBodyTemplate, searchParameters, this.debugMode);
  63.       },
  64.       httpRequest: null,
  65.       debugMode: false
  66.     };
  67.     /**
  68.      * Sets the url for the HTTP request for the search.
  69.      * It may include variables in double curly brackets like {{searchtext}}.
  70.      * @param {String} value
  71.      * @return {module:searchMenuServiceClient.HttpSearchConfig}
  72.      */
  73.     this.searchUrlTemplate = function (value) {
  74.       this.config.searchUrlTemplate = value;
  75.       return this;
  76.     };
  77.     /**
  78.      * Sets the HTTP method for the search. Defaults to "POST".
  79.      * @param {String} value
  80.      * @return {module:searchMenuServiceClient.HttpSearchConfig}
  81.      */
  82.     this.searchMethod = function (value) {
  83.       this.config.searchMethod = value;
  84.       return this;
  85.     };
  86.     /**
  87.      * Sets the HTTP content type of the request body. Defaults to "application/json".
  88.      * @param {String} value
  89.      * @return {module:searchMenuServiceClient.HttpSearchConfig}
  90.      */
  91.     this.searchContentType = function (value) {
  92.       this.config.searchContentType = value;
  93.       return this;
  94.     };
  95.     /**
  96.      * Sets the HTTP request body template that may contain variables (e.g. {{searchParameters}}) in double curly brackets, or null if there is none.
  97.      * @param {String} value
  98.      * @return {module:searchMenuServiceClient.HttpSearchConfig}
  99.      */
  100.     this.searchBodyTemplate = function (value) {
  101.       this.config.searchBodyTemplate = value;
  102.       return this;
  103.     };
  104.     /**
  105.      * Sets the HTTP-Request-Object. Defaults to XMLHttpRequest if not set.
  106.      * @param {String} value
  107.      * @return {module:searchMenuServiceClient.HttpSearchConfig}
  108.      */
  109.     this.httpRequest = function (value) {
  110.       this.config.httpRequest = value;
  111.       return this;
  112.     };
  113.     /**
  114.      * Sets the debug mode, that prints some more info to the console.
  115.      * @param {boolean} value
  116.      * @return {module:searchMenuServiceClient.HttpSearchConfig}
  117.      */
  118.     this.debugMode = function (value) {
  119.       this.config.debugMode = value === true;
  120.       return this;
  121.     };
  122.     /**
  123.      * Uses the configuration to build the http client that provides the function "search" (parameters: searchParameters, onSuccess callback).
  124.      * @returns {module:searchMenuServiceClient.HttpClient}
  125.      */
  126.     this.build = function () {
  127.       if (!this.config.httpRequest) {
  128.         this.config.httpRequest = xmlHttpRequest.getXMLHttpRequest();
  129.       }
  130.       return new searchMenuServiceClient.HttpClient(this.config);
  131.     };
  132.   }
  134.   /**
  135.    * Resolves variables in the template based on the given search parameters object.
  136.    * The variable {{jsonSearchParameters}} will be replaced by the JSON of all search parameters.
  137.    * @param {String} template contains variables in double curly brackets that should be replaced by the values of the parameterSourceObject.
  138.    * @param {Object} parameterSourceObject object properties will be used to replace the variables of the template
  139.    * @param {boolean} debugMode enables/disables extended logging for debugging
  140.    * @memberof module:searchMenuServiceClient.HttpSearchConfig
  141.    * @protected
  142.    */
  143.   function resolveTemplate(template, parameterSourceObject, debugMode) {
  144.     if (template == null) {
  145.       return null;
  146.     }
  147.     var jsonSearchParameters = JSON.stringify(parameterSourceObject);
  148.     var resolvedBody = template;
  149.     resolvedBody = resolveVariableInTemplate(resolvedBody, "jsonSearchParameters", jsonSearchParameters);
  150.     resolvedBody = resolveVariablesInTemplate(resolvedBody, parameterSourceObject);
  151.     if (debugMode) {
  152.       console.log("template=" + template);
  153.       console.log("{{jsonSearchParameters}}=" + jsonSearchParameters);
  154.       console.log("resolved template=" + resolvedBody);
  155.     }
  156.     return resolvedBody;
  157.   }
  159.   function resolveVariablesInTemplate(templateString, sourceDataObject) {
  160.     var resolvedString = templateString;
  161.     forEachFieldsIn(sourceDataObject, function (fieldName, fieldValue) {
  162.       resolvedString = resolveVariableInTemplate(resolvedString, fieldName, fieldValue);
  163.     });
  164.     return resolvedString;
  165.   }
  167.   function resolveVariableInTemplate(templateString, fieldName, fieldValue) {
  168.     //TODO could there be a better compatible solution to replace ALL occurrences instead of creating regular expressions?
  169.     var variableReplaceRegExp = new RegExp("\\{\\{" + escapeCharsForRegEx(fieldName) + "\\}\\}", "gm");
  170.     return templateString.replace(variableReplaceRegExp, fieldValue);
  171.   }
  173.   function escapeCharsForRegEx(characters) {
  174.     var nonWordCharactersRegEx = new RegExp("([^-\\w])", "gi");
  175.     return characters.replace(nonWordCharactersRegEx, "\\$1");
  176.   }
  178.   function forEachFieldsIn(object, fieldNameAndValueConsumer) {
  179.     var fieldNames = Object.keys(object);
  180.     var index, fieldName, fieldValue;
  181.     for (index = 0; index < fieldNames.length; index += 1) {
  182.       fieldName = fieldNames[index];
  183.       fieldValue = object[fieldName];
  184.       fieldNameAndValueConsumer(fieldName, fieldValue);
  185.     }
  186.   }
  188.   return HttpSearchConfig;
  189. }());
  191. /**
  192.  * This function will be called, when search results are available.
  193.  * @callback module:searchMenuServiceClient.HttpClient.SearchServiceResultAvailable
  194.  * @param {Object} searchResultData already parsed data object containing the result of the search
  195.  */
  197. searchMenuServiceClient.HttpClient = (function () {
  198.   /**
  199.    * HttpClient.
  200.    *
  201.    * Contains the "backend-connection" of the search bar. It submits the search query,
  202.    * parses the results and informs the callback as soon as these results are available.
  203.    * @example new searchMenuServiceClient.HttpSearchConfig()....build();
  204.    * @param {module:searchMenuServiceClient.HttpSearchConfig} config 
  205.    * @constructs HttpClient
  206.    * @alias module:searchMenuServiceClient.HttpClient
  207.    */
  208.   var instance = function (config) {
  209.     /**
  210.      * Configuration for the search HTTP requests.
  211.      * @type {module:searchMenuServiceClient.HttpSearchConfig}
  212.      */
  213.     this.config = config;
  214.     /**
  215.      * This function will be called to trigger search (calling the search backend).
  216.      * @function
  217.      * @param {Object} searchParameters object that contains all parameters as properties. It will be converted to JSON.
  218.      * @param {module:searchMenuServiceClient.HttpClient.SearchServiceResultAvailable} onSearchResultsAvailable will be called when search results are available.
  219.      */
  220.     this.search = createSearchFunction(this.config, this.config.httpRequest);
  221.   };
  223.   /**
  224.    * Creates the search service function that can be bound to the search menu.
  225.    * @param {module:searchMenuServiceClient.HttpSearchConfig} config Configuration for the search HTTP requests.
  226.    * @param {XMLHttpRequest} httpRequest Takes the HTTP-Request-Object.
  227.    * @returns {module:searchMenuServiceClient.SearchService}
  228.    * @memberof module:searchMenuServiceClient.HttpClient
  229.    * @private
  230.    */
  231.   function createSearchFunction(config, httpRequest) {
  232.     return function (searchParameters, onJsonResultReceived) {
  233.       var onFailure = function (resultText, httpStatus) {
  234.         console.error("search failed with status code " + httpStatus + ": " + resultText);
  235.       };
  236.       var searchUrl = config.resolveSearchUrl(searchParameters);
  237.       var searchBody = config.resolveSearchBody(searchParameters);
  238.       var request = { url: searchUrl, method: config.searchMethod, contentType: config.searchContentType, body: searchBody };
  239.       if (config.debugMode) {
  240.         onJsonResultReceived = loggedSuccess(onJsonResultReceived);
  241.       }
  242.       httpRequestJson(request, httpRequest, onJsonResultReceived, onFailure);
  243.     };
  244.   }
  246.   function loggedSuccess(onSuccess) {
  247.     return function (jsonResult, status) {
  248.       console.log("successful search response with code " + status + ": " + JSON.stringify(jsonResult, null, 2));
  249.       onSuccess(jsonResult, status);
  250.     };
  251.   }
  253.   /**
  254.    * This function will be called when a already parsed response of the HTTP request is available.
  255.    * @callback module:searchMenuServiceClient.HttpClient.ParsedHttpResponseAvailable
  256.    * @param {Object} resultData already parsed data object containing the results of the HTTP request
  257.    * @param {number} httpStatus HTTP response status
  258.    */
  259.   /**
  260.    * This function will be called when a response of the HTTP request is available as text.
  261.    * @callback module:searchMenuServiceClient.HttpClient.TextHttpResponseAvailable
  262.    * @param {Object} resultText response body as text
  263.    * @param {number} httpStatus HTTP response status
  264.    */
  265.   /**
  266.    * Executes an HTTP "AJAX" request.
  267.    *
  268.    * @param {Object} request - flattened json from search query result
  269.    * @param {string} request.url - name of the property in hierarchical order separated by points
  270.    * @param {string} request.method - value of the property as string
  271.    * @param {string} request.contentType - value of the property as string
  272.    * @param {string} request.body - value of the property as string
  273.    * @param {Object} httpRequest - Browser provided object to use for the HTTP request.
  274.    * @param {module:searchMenuServiceClient.HttpClient.ParsedHttpResponseAvailable} onSuccess - will be called when the request was successful.
  275.    * @param {module:searchMenuServiceClient.HttpClient.TextHttpResponseAvailable} onFailure - will be called with the error message as text
  276.    * @memberof module:searchMenuServiceClient.HttpClient
  277.    * @private
  278.    */
  279.   function httpRequestJson(request, httpRequest, onSuccess, onFailure) {
  280.     httpRequest.onreadystatechange = function () {
  281.       if (httpRequest.readyState === 4) {
  282.         if (httpRequest.status >= 200 && httpRequest.status <= 299) {
  283.           var jsonResult = JSON.parse(httpRequest.responseText);
  284.           onSuccess(jsonResult, httpRequest.status);
  285.         } else {
  286.           onFailure(httpRequest.responseText, httpRequest.status);
  287.         }
  288.       }
  289.     };
  290.     httpRequest.open(request.method, request.url, true);
  291.     httpRequest.setRequestHeader("Content-Type", request.contentType);
  292.     httpRequest.send(request.body);
  293.   }
  295.   return instance;
  296. }());