Fixed endpoints for index configuration (#22)

- Added some model classes
- Tested new features
- Increased all functional tests

Author: mmoreram

dist/apisearch.js

@@ -1,11 +1,54 @@
+import { Synonym } from "./Synonym";
 /**
  * Result class
  */
 export declare class Config {
+    private language;
+    private storeSearchableMetadata;
+    private synonyms;
     /**
-     * To array
+     * Constructor
      *
-     * @returns {any}
+     * @param language
+     * @param storeSearchableMetadata
      */
-    toArray(): any;
+    constructor(language?: string, storeSearchableMetadata?: boolean);
+    /**
+     * Get language
+     *
+     * @return {string}
+     */
+    getLanguage(): string;
+    /**
+     * Should searchable metadata be stored
+     *
+     * @return {boolean}
+     */
+    shouldSearchableMetadataBeStored(): boolean;
+    /**
+     * Add synonym
+     *
+     * @param synonym
+     */
+    addSynonym(synonym: Synonym): void;
+    /**
+     * Get synonyms
+     *
+     * @return {Synonym[]}
+     */
+    getSynonyms(): Synonym[];
+    /**
+     * to array
+     */
+    toArray(): {
+        language: string;
+        store_searchable_metadata: boolean;
+        synonyms: {
+            words: string[];
+        }[];
+    };
+    /**
+     * Create from array
+     */
+    static createFromArray(array: any): Config;
 }

dist/apisearch.js.map

@@ -1,18 +1,77 @@
 "use strict";
 exports.__esModule = true;
+var Synonym_1 = require("./Synonym");
 /**
  * Result class
  */
 var Config = /** @class */ (function () {
-    function Config() {
+    /**
+     * Constructor
+     *
+     * @param language
+     * @param storeSearchableMetadata
+     */
+    function Config(language, storeSearchableMetadata) {
+        if (language === void 0) { language = null; }
+        if (storeSearchableMetadata === void 0) { storeSearchableMetadata = true; }
+        this.synonyms = [];
+        this.language = language;
+        this.storeSearchableMetadata = storeSearchableMetadata;
     }
     /**
-     * To array
+     * Get language
+     *
+     * @return {string}
+     */
+    Config.prototype.getLanguage = function () {
+        return this.language;
+    };
+    /**
+     * Should searchable metadata be stored
+     *
+     * @return {boolean}
+     */
+    Config.prototype.shouldSearchableMetadataBeStored = function () {
+        return this.storeSearchableMetadata;
+    };
+    /**
+     * Add synonym
      *
-     * @returns {any}
+     * @param synonym
+     */
+    Config.prototype.addSynonym = function (synonym) {
+        this.synonyms.push(synonym);
+    };
+    /**
+     * Get synonyms
+     *
+     * @return {Synonym[]}
+     */
+    Config.prototype.getSynonyms = function () {
+        return this.synonyms;
+    };
+    /**
+     * to array
      */
     Config.prototype.toArray = function () {
-        return {};
+        return {
+            language: this.language,
+            store_searchable_metadata: this.storeSearchableMetadata,
+            synonyms: this.synonyms.map(function (synonym) { return synonym.toArray(); })
+        };
+    };
+    /**
+     * Create from array
+     */
+    Config.createFromArray = function (array) {
+        var immutableConfig = new Config(array.language ? array.language : null, typeof array.store_searchable_metadata == "boolean"
+            ? array.store_searchable_metadata
+            : true);
+        if (array.synonyms instanceof Array &&
+            array.synonyms.length > 0) {
+            immutableConfig.synonyms = array.synonyms.map(function (synonym) { return Synonym_1.Synonym.createFromArray(synonym); });
+        }
+        return immutableConfig;
     };
     return Config;
 }());

dist/apisearch.min.js

@@ -57,6 +57,24 @@ export declare class InvalidFormatError extends ErrorWithMessage {
      * @return {InvalidFormatError}
      */
     static tokenFormatNotValid(): InvalidFormatError;
+    /**
+     * Index format not valid.
+     *
+     * @return {InvalidFormatError}
+     */
+    static indexFormatNotValid(): InvalidFormatError;
+    /**
+     * IndexUUI format not valid.
+     *
+     * @return {InvalidFormatError}
+     */
+    static indexUUIDFormatNotValid(): InvalidFormatError;
+    /**
+     * App format not valid.
+     *
+     * @return {InvalidFormatError}
+     */
+    static appUUIDFormatNotValid(): InvalidFormatError;
     /**
      * Campaign representation not valid
      *

dist/apisearch.min.js.map

@@ -82,6 +82,30 @@ var InvalidFormatError = /** @class */ (function (_super) {
     InvalidFormatError.tokenFormatNotValid = function () {
         return new InvalidFormatError("Token Format not valid. Expecting a Token serialized but found malformed data");
     };
+    /**
+     * Index format not valid.
+     *
+     * @return {InvalidFormatError}
+     */
+    InvalidFormatError.indexFormatNotValid = function () {
+        return new InvalidFormatError('Index Format not valid. Expecting an Index serialized but found malformed data');
+    };
+    /**
+     * IndexUUI format not valid.
+     *
+     * @return {InvalidFormatError}
+     */
+    InvalidFormatError.indexUUIDFormatNotValid = function () {
+        return new InvalidFormatError('IndexUUID Format not valid. Expecting an IndexUUID serialized but found malformed data');
+    };
+    /**
+     * App format not valid.
+     *
+     * @return {InvalidFormatError}
+     */
+    InvalidFormatError.appUUIDFormatNotValid = function () {
+        return new InvalidFormatError('AppUUID Format not valid. Expecting an AppUUID serialized but found malformed data');
+    };
     /**
      * Campaign representation not valid
      *

lib/Config/Config.d.ts

@@ -38,6 +38,14 @@ export declare class AxiosClient extends Client implements HttpClient {
     /**
      * Abort current request
      * And regenerate the cancellation token
+     *
+     * @param url
+     */
+    abort(url: string): void;
+    /**
+     * Generate a new cancellation token for a query
+     *
+     * @param url
      */
-    abort(): void;
+    generateCancelToken(url: string): void;
 }

lib/Config/Config.js

@@ -25,7 +25,7 @@ var AxiosClient = /** @class */ (function (_super) {
         _this.timeout = timeout;
         _this.cache = cache;
         _this.overrideQueries = overrideQueries;
-        _this.cancelToken = axios_1["default"].CancelToken.source();
+        _this.cancelToken = {};
         return _this;
     }
     /**
@@ -52,7 +52,7 @@ var AxiosClient = /** @class */ (function (_super) {
                 method = method.toLowerCase();
                 if ("get" === method &&
                     this.overrideQueries) {
-                    this.abort();
+                    this.abort(url);
                 }
                 return [2 /*return*/, new Promise(function (resolve, reject) {
                         var headers = "get" == method
@@ -61,33 +61,50 @@ var AxiosClient = /** @class */ (function (_super) {
                                 "Content-Encoding": "gzip",
                                 "Content-Type": "application/json"
                             };
-                        //noinspection TypeScriptValidateTypes
-                        axios_1["default"]
-                            .request({
+                        var axiosRequestConfig = {
                             url: url + "?" + Client_1.Client.objectToUrlParameters(tslib_1.__assign({}, credentials, parameters)),
                             data: data,
                             headers: headers,
                             method: method,
                             baseURL: that.host.replace(/\/*$/g, ""),
                             timeout: that.timeout,
-                            cancelToken: _this.cancelToken.token,
                             transformRequest: [function (data) { return JSON.stringify(data); }]
-                        })
+                        };
+                        if (typeof _this.cancelToken[url] != 'undefined') {
+                            axiosRequestConfig.cancelToken = _this.cancelToken[url].token;
+                        }
+                        axios_1["default"]
+                            .request(axiosRequestConfig)
                             .then(function (axiosResponse) {
                             var response = new Response_1.Response(axiosResponse.status, axiosResponse.data);
                             return resolve(response);
-                        })["catch"](function (thrown) { return reject(thrown); });
+                        })["catch"](function (error) {
+                            var response = new Response_1.Response(error.response.status, error.response.data);
+                            return reject(response);
+                        });
                     })];
             });
         });
     };
     /**
      * Abort current request
      * And regenerate the cancellation token
+     *
+     * @param url
+     */
+    AxiosClient.prototype.abort = function (url) {
+        if (typeof this.cancelToken[url] != 'undefined') {
+            this.cancelToken[url].cancel();
+        }
+        this.generateCancelToken(url);
+    };
+    /**
+     * Generate a new cancellation token for a query
+     *
+     * @param url
      */
-    AxiosClient.prototype.abort = function () {
-        this.cancelToken.cancel();
-        this.cancelToken = axios_1["default"].CancelToken.source();
+    AxiosClient.prototype.generateCancelToken = function (url) {
+        this.cancelToken[url] = axios_1["default"].CancelToken.source();
     };
     return AxiosClient;
 }(Client_1.Client));