@ama-sdk/core 12.3.0-prerelease.72 → 12.3.0-prerelease.73

package/cjs/fwk/param-deserialization.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    deserializePathParams: function() {
+        return deserializePathParams;
+    },
+    deserializeQueryParams: function() {
+        return deserializeQueryParams;
+    }
+});
+var _paramserialization = require("./param-serialization");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * Split parameter elements by delimiter based on the serialization style (with removal of the prefix)
+ * @param serializedParamValue serialized parameter value
+ * @param paramSerialization parameter serialization
+ */ function splitParamElements(serializedParamValue, paramSerialization) {
+    switch(paramSerialization.style){
+        case 'simple':
+            {
+                return serializedParamValue.split(',').map(function(value) {
+                    return decodeURIComponent(value);
+                });
+            }
+        case 'label':
+            {
+                // NOTE: Path parameters of style label are prefixed with a '.'
+                return serializedParamValue.substring(1).split(paramSerialization.explode ? '.' : ',').map(function(value) {
+                    return decodeURIComponent(value);
+                });
+            }
+        case 'matrix':
+            {
+                // NOTE: Path parameters of style matrix and exploded true are written like this: ';paramName=value1;paramName=value2'
+                // NOTE: Path parameters of style matrix and exploded false are prefixed with a ';paramName=' and the values are separated by a ','
+                return paramSerialization.explode ? serializedParamValue.substring(1).split(';').map(function(value) {
+                    return decodeURIComponent(value.split('=')[1]);
+                }) : serializedParamValue.split('=')[1].split(',').map(function(value) {
+                    return decodeURIComponent(value);
+                });
+            }
+        case 'form':
+            {
+                // NOTE: Query parameters of style form and explode true are written like this: 'paramName=value1&paramName=value2&paramName=value3'
+                // NOTE: Query parameters of style form and explode false are prefixed with the parameter name and delimited by a ','
+                return paramSerialization.explode ? serializedParamValue.split('&').map(function(value) {
+                    return decodeURIComponent(value.split('=')[1]);
+                }) : serializedParamValue.split('=')[1].split(',').map(function(value) {
+                    return decodeURIComponent(value);
+                });
+            }
+        case 'spaceDelimited':
+            {
+                // NOTE: Query parameters of style spaceDelimited and explode false are prefixed with the parameter name and delimited by the encoded space character
+                // Here is an example of the format: 'paramName=value1%20value2%20value3'
+                return paramSerialization.explode ? undefined : serializedParamValue.split('=')[1].split(_paramserialization.SPACE_URL_CODE).map(function(value) {
+                    return decodeURIComponent(value);
+                });
+            }
+        case 'pipeDelimited':
+            {
+                // NOTE: Query parameters of style spaceDelimited and explode false are prefixed with the parameter name and delimited by the encoded pipe character
+                // Here is an example of the format: 'paramName=value1%7Cvalue2%7Cvalue3'
+                return paramSerialization.explode ? undefined : serializedParamValue.split('=')[1].split(_paramserialization.PIPE_URL_CODE).map(function(value) {
+                    return decodeURIComponent(value);
+                });
+            }
+    }
+}
+/**
+ * Create object from pairwise array - every other item of the array is a key and the following item is the corresponding value
+ * @param splitObject
+ */ function objectFromPairwiseArray(splitObject) {
+    return splitObject.reduce(function(obj, currentValue, index, array) {
+        // NOTE: Every other item of the array is a key and the following item is the corresponding value
+        if (index % 2 === 0) {
+            obj[decodeURIComponent(currentValue)] = decodeURIComponent(array[index + 1]);
+        }
+        return obj;
+    }, {});
+}
+/**
+ * Deserialize query parameters of type array
+ * OpenAPI Parameter Serialization {@link https://swagger.io/specification | documentation}
+ * @param serializedParamValue serialized query parameter value
+ * @param paramSerialization parameter serialization
+ */ function deserializeArrayQueryParams(serializedParamValue, paramSerialization) {
+    return splitParamElements(serializedParamValue, paramSerialization);
+}
+/**
+ * Deserialize query parameters of type object
+ * OpenAPI Parameter Serialization {@link https://swagger.io/specification | documentation}
+ * @param serializedParamValue serialized query parameter value
+ * @param paramSerialization parameter serialization
+ */ function deserializeObjectQueryParams(serializedParamValue, paramSerialization) {
+    // NOTE: Applies to the exploded styles 'form' and 'deepObject'
+    if (paramSerialization.explode && (paramSerialization.style === 'form' || paramSerialization.style === 'deepObject')) {
+        return serializedParamValue.split('&').reduce(function(obj, serializedProperty) {
+            var _serializedProperty_split = _sliced_to_array(serializedProperty.split('='), 2), key = _serializedProperty_split[0], value = _serializedProperty_split[1];
+            // NOTE: The key of an object in deepObject style is surrounded by opening and closing square brackets
+            var objKey = paramSerialization.style === 'deepObject' ? key.split(_paramserialization.OPENING_SQUARE_BRACKET_URL_CODE)[1].split(_paramserialization.CLOSING_SQUARE_BRACKET_URL_CODE)[0] : key;
+            obj[decodeURIComponent(objKey)] = decodeURIComponent(value);
+            return obj;
+        }, {});
+    }
+    // NOTE: Applies to the non-exploded styles 'form', 'spaceDelimited', and 'pipeDelimited'
+    if (paramSerialization.style !== 'deepObject' && !paramSerialization.explode) {
+        // NOTE: The splitParamElements function is called since object query parameters can be split by delimiters based on the serialization style
+        // NOTE: The deserialized value will exist since these exploded styles are supported
+        var splitObject = splitParamElements(serializedParamValue, paramSerialization);
+        return objectFromPairwiseArray(splitObject);
+    }
+}
+function deserializeQueryParams(serializedQueryParams, queryParamSerialization) {
+    return Object.entries(serializedQueryParams).reduce(function(acc, param) {
+        var _param = _sliced_to_array(param, 2), queryParamName = _param[0], serializedParamValue = _param[1];
+        var paramSerialization = queryParamSerialization[queryParamName];
+        var deserializedValue;
+        if (paramSerialization.paramType === 'array') {
+            deserializedValue = deserializeArrayQueryParams(serializedParamValue, paramSerialization);
+        } else if (paramSerialization.paramType === 'object') {
+            deserializedValue = deserializeObjectQueryParams(serializedParamValue, paramSerialization);
+        } else {
+            // NOTE: Query parameters of type primitive are prefixed with the parameter name like this: 'paramName=value'
+            deserializedValue = decodeURIComponent(serializedParamValue.split('=')[1]);
+        }
+        if (deserializedValue) {
+            acc[queryParamName] = deserializedValue;
+        } else {
+            throw new Error("Unable to deserialize query parameter ".concat(queryParamName, " since the combination explode=").concat(paramSerialization.explode, " and style='").concat(paramSerialization.style, "' is not supported."));
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Deserialize path parameters of type primitive
+ * OpenAPI Parameter Serialization {@link https://swagger.io/specification | documentation}
+ * @param serializedParamValue serialized path parameter value
+ * @param paramSerialization parameter serialization
+ */ function deserializePrimitivePathParams(serializedParamValue, paramSerialization) {
+    switch(paramSerialization.style){
+        case 'simple':
+            {
+                return decodeURIComponent(serializedParamValue);
+            }
+        case 'label':
+            {
+                // NOTE: Path parameters of style label are prefixed with a '.'
+                return decodeURIComponent(serializedParamValue.substring(1));
+            }
+        case 'matrix':
+            {
+                return decodeURIComponent(serializedParamValue.substring(1).split('=')[1]);
+            }
+    }
+}
+/**
+ * Deserialize path parameters of type array
+ * OpenAPI Parameter Serialization {@link https://swagger.io/specification | documentation}
+ * @param serializedParamValue serialized path parameter value
+ * @param paramSerialization parameter serialization
+ */ function deserializeArrayPathParams(serializedParamValue, paramSerialization) {
+    return splitParamElements(serializedParamValue, paramSerialization);
+}
+/**
+ * Deserialize path parameters of type object
+ * OpenAPI Parameter Serialization {@link https://swagger.io/specification | documentation}
+ * @param serializedParamValue serialized path parameter value
+ * @param paramSerialization parameter serialization
+ */ function deserializeObjectPathParams(serializedParamValue, paramSerialization) {
+    // NOTE: The splitParamElements function is called since object path parameters can be split by delimiters based on the serialization style
+    // NOTE: There is an exception for path parameters of exploded style 'matrix' which is not serialized like its corresponding array
+    // This exception is serialized like this (prefixed by a ';'): ';prop1=value1;prop2=value2'
+    var splitObject = paramSerialization.style === 'matrix' && paramSerialization.explode ? serializedParamValue.substring(1).split(';').map(function(value) {
+        return decodeURIComponent(value);
+    }) : splitParamElements(serializedParamValue, paramSerialization);
+    // NOTE: Object path parameters that are exploded are serialized as 'prop=value'
+    if (paramSerialization.explode) {
+        return splitObject.reduce(function(obj, serializedProperty) {
+            var _serializedProperty_split_map = _sliced_to_array(serializedProperty.split('=').map(function(v) {
+                return decodeURIComponent(v);
+            }), 2), key = _serializedProperty_split_map[0], value = _serializedProperty_split_map[1];
+            obj[key] = value;
+            return obj;
+        }, {});
+    }
+    return objectFromPairwiseArray(splitObject);
+}
+function deserializePathParams(serializedPathParams, pathParamSerialization) {
+    return Object.entries(serializedPathParams).reduce(function(acc, param) {
+        var _param = _sliced_to_array(param, 2), pathParamName = _param[0], serializedParamValue = _param[1];
+        var paramSerialization = pathParamSerialization[pathParamName];
+        var deserializedValue;
+        if (paramSerialization.paramType === 'array') {
+            deserializedValue = deserializeArrayPathParams(serializedParamValue, paramSerialization);
+        } else if (paramSerialization.paramType === 'object') {
+            deserializedValue = deserializeObjectPathParams(serializedParamValue, paramSerialization);
+        } else {
+            deserializedValue = deserializePrimitivePathParams(serializedParamValue, paramSerialization);
+        }
+        if (deserializedValue) {
+            acc[pathParamName] = deserializedValue;
+        } else {
+            throw new Error("Unable to deserialize path parameter ".concat(pathParamName, " since the combination explode=").concat(paramSerialization.explode, " and style='").concat(paramSerialization.style, "' is not supported."));
+        }
+        return acc;
+    }, {});
+}