Skip to content
Permalink
9bfb9ba527
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
 
 
Cannot retrieve contributors at this time
789 lines (789 sloc) 34.2 KB
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
import * as base64 from "./util/base64";
import * as utils from "./util/utils";
var Serializer = /** @class */ (function () {
function Serializer(modelMappers, isXML) {
if (modelMappers === void 0) { modelMappers = {}; }
this.modelMappers = modelMappers;
this.isXML = isXML;
}
Serializer.prototype.validateConstraints = function (mapper, value, objectName) {
var failValidation = function (constraintName, constraintValue) {
throw new Error("\"" + objectName + "\" with value \"" + value + "\" should satisfy the constraint \"" + constraintName + "\": " + constraintValue + ".");
};
if (mapper.constraints && value != undefined) {
var _a = mapper.constraints, ExclusiveMaximum = _a.ExclusiveMaximum, ExclusiveMinimum = _a.ExclusiveMinimum, InclusiveMaximum = _a.InclusiveMaximum, InclusiveMinimum = _a.InclusiveMinimum, MaxItems = _a.MaxItems, MaxLength = _a.MaxLength, MinItems = _a.MinItems, MinLength = _a.MinLength, MultipleOf = _a.MultipleOf, Pattern = _a.Pattern, UniqueItems = _a.UniqueItems;
if (ExclusiveMaximum != undefined && value >= ExclusiveMaximum) {
failValidation("ExclusiveMaximum", ExclusiveMaximum);
}
if (ExclusiveMinimum != undefined && value <= ExclusiveMinimum) {
failValidation("ExclusiveMinimum", ExclusiveMinimum);
}
if (InclusiveMaximum != undefined && value > InclusiveMaximum) {
failValidation("InclusiveMaximum", InclusiveMaximum);
}
if (InclusiveMinimum != undefined && value < InclusiveMinimum) {
failValidation("InclusiveMinimum", InclusiveMinimum);
}
if (MaxItems != undefined && value.length > MaxItems) {
failValidation("MaxItems", MaxItems);
}
if (MaxLength != undefined && value.length > MaxLength) {
failValidation("MaxLength", MaxLength);
}
if (MinItems != undefined && value.length < MinItems) {
failValidation("MinItems", MinItems);
}
if (MinLength != undefined && value.length < MinLength) {
failValidation("MinLength", MinLength);
}
if (MultipleOf != undefined && value % MultipleOf !== 0) {
failValidation("MultipleOf", MultipleOf);
}
if (Pattern) {
var pattern = typeof Pattern === "string" ? new RegExp(Pattern) : Pattern;
if (typeof value !== "string" || value.match(pattern) === null) {
failValidation("Pattern", Pattern);
}
}
if (UniqueItems &&
value.some(function (item, i, ar) { return ar.indexOf(item) !== i; })) {
failValidation("UniqueItems", UniqueItems);
}
}
};
/**
* Serialize the given object based on its metadata defined in the mapper
*
* @param {Mapper} mapper The mapper which defines the metadata of the serializable object
*
* @param {object|string|Array|number|boolean|Date|stream} object A valid Javascript object to be serialized
*
* @param {string} objectName Name of the serialized object
*
* @returns {object|string|Array|number|boolean|Date|stream} A valid serialized Javascript object
*/
Serializer.prototype.serialize = function (mapper, object, objectName) {
var payload = {};
var mapperType = mapper.type.name;
if (!objectName) {
objectName = mapper.serializedName;
}
if (mapperType.match(/^Sequence$/gi) !== null) {
payload = [];
}
if (mapper.isConstant) {
object = mapper.defaultValue;
}
// This table of allowed values should help explain
// the mapper.required and mapper.nullable properties.
// X means "neither undefined or null are allowed".
// || required
// || true | false
// nullable || ==========================
// true || null | undefined/null
// false || X | undefined
// undefined || X | undefined/null
var required = mapper.required, nullable = mapper.nullable;
if (required && nullable && object === undefined) {
throw new Error(objectName + " cannot be undefined.");
}
if (required && !nullable && object == undefined) {
throw new Error(objectName + " cannot be null or undefined.");
}
if (!required && nullable === false && object === null) {
throw new Error(objectName + " cannot be null.");
}
if (object == undefined) {
payload = object;
}
else {
// Validate Constraints if any
this.validateConstraints(mapper, object, objectName);
if (mapperType.match(/^any$/gi) !== null) {
payload = object;
}
else if (mapperType.match(/^(Number|String|Boolean|Object|Stream|Uuid)$/gi) !== null) {
payload = serializeBasicTypes(mapperType, objectName, object);
}
else if (mapperType.match(/^Enum$/gi) !== null) {
var enumMapper = mapper;
payload = serializeEnumType(objectName, enumMapper.type.allowedValues, object);
}
else if (mapperType.match(/^(Date|DateTime|TimeSpan|DateTimeRfc1123|UnixTime)$/gi) !== null) {
payload = serializeDateTypes(mapperType, object, objectName);
}
else if (mapperType.match(/^ByteArray$/gi) !== null) {
payload = serializeByteArrayType(objectName, object);
}
else if (mapperType.match(/^Base64Url$/gi) !== null) {
payload = serializeBase64UrlType(objectName, object);
}
else if (mapperType.match(/^Sequence$/gi) !== null) {
payload = serializeSequenceType(this, mapper, object, objectName);
}
else if (mapperType.match(/^Dictionary$/gi) !== null) {
payload = serializeDictionaryType(this, mapper, object, objectName);
}
else if (mapperType.match(/^Composite$/gi) !== null) {
payload = serializeCompositeType(this, mapper, object, objectName);
}
}
return payload;
};
/**
* Deserialize the given object based on its metadata defined in the mapper
*
* @param {object} mapper The mapper which defines the metadata of the serializable object
*
* @param {object|string|Array|number|boolean|Date|stream} responseBody A valid Javascript entity to be deserialized
*
* @param {string} objectName Name of the deserialized object
*
* @returns {object|string|Array|number|boolean|Date|stream} A valid deserialized Javascript object
*/
Serializer.prototype.deserialize = function (mapper, responseBody, objectName) {
if (responseBody == undefined) {
if (this.isXML && mapper.type.name === "Sequence" && !mapper.xmlIsWrapped) {
// Edge case for empty XML non-wrapped lists. xml2js can't distinguish
// between the list being empty versus being missing,
// so let's do the more user-friendly thing and return an empty list.
responseBody = [];
}
// specifically check for undefined as default value can be a falsey value `0, "", false, null`
if (mapper.defaultValue !== undefined) {
responseBody = mapper.defaultValue;
}
return responseBody;
}
var payload;
var mapperType = mapper.type.name;
if (!objectName) {
objectName = mapper.serializedName;
}
if (mapperType.match(/^Composite$/gi) !== null) {
payload = deserializeCompositeType(this, mapper, responseBody, objectName);
}
else {
if (this.isXML) {
/**
* If the mapper specifies this as a non-composite type value but the responseBody contains
* both header ("$") and body ("_") properties, then just reduce the responseBody value to
* the body ("_") property.
*/
if (responseBody["$"] != undefined && responseBody["_"] != undefined) {
responseBody = responseBody["_"];
}
}
if (mapperType.match(/^Number$/gi) !== null) {
payload = parseFloat(responseBody);
if (isNaN(payload)) {
payload = responseBody;
}
}
else if (mapperType.match(/^Boolean$/gi) !== null) {
if (responseBody === "true") {
payload = true;
}
else if (responseBody === "false") {
payload = false;
}
else {
payload = responseBody;
}
}
else if (mapperType.match(/^(String|Enum|Object|Stream|Uuid|TimeSpan|any)$/gi) !== null) {
payload = responseBody;
}
else if (mapperType.match(/^(Date|DateTime|DateTimeRfc1123)$/gi) !== null) {
payload = new Date(responseBody);
}
else if (mapperType.match(/^UnixTime$/gi) !== null) {
payload = unixTimeToDate(responseBody);
}
else if (mapperType.match(/^ByteArray$/gi) !== null) {
payload = base64.decodeString(responseBody);
}
else if (mapperType.match(/^Base64Url$/gi) !== null) {
payload = base64UrlToByteArray(responseBody);
}
else if (mapperType.match(/^Sequence$/gi) !== null) {
payload = deserializeSequenceType(this, mapper, responseBody, objectName);
}
else if (mapperType.match(/^Dictionary$/gi) !== null) {
payload = deserializeDictionaryType(this, mapper, responseBody, objectName);
}
}
if (mapper.isConstant) {
payload = mapper.defaultValue;
}
return payload;
};
return Serializer;
}());
export { Serializer };
function trimEnd(str, ch) {
var len = str.length;
while (len - 1 >= 0 && str[len - 1] === ch) {
--len;
}
return str.substr(0, len);
}
function bufferToBase64Url(buffer) {
if (!buffer) {
return undefined;
}
if (!(buffer instanceof Uint8Array)) {
throw new Error("Please provide an input of type Uint8Array for converting to Base64Url.");
}
// Uint8Array to Base64.
var str = base64.encodeByteArray(buffer);
// Base64 to Base64Url.
return trimEnd(str, "=").replace(/\+/g, "-").replace(/\//g, "_");
}
function base64UrlToByteArray(str) {
if (!str) {
return undefined;
}
if (str && typeof str.valueOf() !== "string") {
throw new Error("Please provide an input of type string for converting to Uint8Array");
}
// Base64Url to Base64.
str = str.replace(/\-/g, "+").replace(/\_/g, "/");
// Base64 to Uint8Array.
return base64.decodeString(str);
}
function splitSerializeName(prop) {
var classes = [];
var partialclass = "";
if (prop) {
var subwords = prop.split(".");
for (var _i = 0, subwords_1 = subwords; _i < subwords_1.length; _i++) {
var item = subwords_1[_i];
if (item.charAt(item.length - 1) === "\\") {
partialclass += item.substr(0, item.length - 1) + ".";
}
else {
partialclass += item;
classes.push(partialclass);
partialclass = "";
}
}
}
return classes;
}
function dateToUnixTime(d) {
if (!d) {
return undefined;
}
if (typeof d.valueOf() === "string") {
d = new Date(d);
}
return Math.floor(d.getTime() / 1000);
}
function unixTimeToDate(n) {
if (!n) {
return undefined;
}
return new Date(n * 1000);
}
function serializeBasicTypes(typeName, objectName, value) {
if (value !== null && value !== undefined) {
if (typeName.match(/^Number$/gi) !== null) {
if (typeof value !== "number") {
throw new Error(objectName + " with value " + value + " must be of type number.");
}
}
else if (typeName.match(/^String$/gi) !== null) {
if (typeof value.valueOf() !== "string") {
throw new Error(objectName + " with value \"" + value + "\" must be of type string.");
}
}
else if (typeName.match(/^Uuid$/gi) !== null) {
if (!(typeof value.valueOf() === "string" && utils.isValidUuid(value))) {
throw new Error(objectName + " with value \"" + value + "\" must be of type string and a valid uuid.");
}
}
else if (typeName.match(/^Boolean$/gi) !== null) {
if (typeof value !== "boolean") {
throw new Error(objectName + " with value " + value + " must be of type boolean.");
}
}
else if (typeName.match(/^Stream$/gi) !== null) {
var objectType = typeof value;
if (objectType !== "string" &&
objectType !== "function" &&
!(value instanceof ArrayBuffer) &&
!ArrayBuffer.isView(value) &&
!(typeof Blob === "function" && value instanceof Blob)) {
throw new Error(objectName + " must be a string, Blob, ArrayBuffer, ArrayBufferView, or a function returning NodeJS.ReadableStream.");
}
}
}
return value;
}
function serializeEnumType(objectName, allowedValues, value) {
if (!allowedValues) {
throw new Error("Please provide a set of allowedValues to validate " + objectName + " as an Enum Type.");
}
var isPresent = allowedValues.some(function (item) {
if (typeof item.valueOf() === "string") {
return item.toLowerCase() === value.toLowerCase();
}
return item === value;
});
if (!isPresent) {
throw new Error(value + " is not a valid value for " + objectName + ". The valid values are: " + JSON.stringify(allowedValues) + ".");
}
return value;
}
function serializeByteArrayType(objectName, value) {
if (value != undefined) {
if (!(value instanceof Uint8Array)) {
throw new Error(objectName + " must be of type Uint8Array.");
}
value = base64.encodeByteArray(value);
}
return value;
}
function serializeBase64UrlType(objectName, value) {
if (value != undefined) {
if (!(value instanceof Uint8Array)) {
throw new Error(objectName + " must be of type Uint8Array.");
}
value = bufferToBase64Url(value);
}
return value;
}
function serializeDateTypes(typeName, value, objectName) {
if (value != undefined) {
if (typeName.match(/^Date$/gi) !== null) {
if (!(value instanceof Date ||
(typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
throw new Error(objectName + " must be an instanceof Date or a string in ISO8601 format.");
}
value =
value instanceof Date
? value.toISOString().substring(0, 10)
: new Date(value).toISOString().substring(0, 10);
}
else if (typeName.match(/^DateTime$/gi) !== null) {
if (!(value instanceof Date ||
(typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
throw new Error(objectName + " must be an instanceof Date or a string in ISO8601 format.");
}
value = value instanceof Date ? value.toISOString() : new Date(value).toISOString();
}
else if (typeName.match(/^DateTimeRfc1123$/gi) !== null) {
if (!(value instanceof Date ||
(typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
throw new Error(objectName + " must be an instanceof Date or a string in RFC-1123 format.");
}
value = value instanceof Date ? value.toUTCString() : new Date(value).toUTCString();
}
else if (typeName.match(/^UnixTime$/gi) !== null) {
if (!(value instanceof Date ||
(typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
throw new Error(objectName + " must be an instanceof Date or a string in RFC-1123/ISO8601 format " +
"for it to be serialized in UnixTime/Epoch format.");
}
value = dateToUnixTime(value);
}
else if (typeName.match(/^TimeSpan$/gi) !== null) {
if (!utils.isDuration(value)) {
throw new Error(objectName + " must be a string in ISO 8601 format. Instead was \"" + value + "\".");
}
value = value;
}
}
return value;
}
function serializeSequenceType(serializer, mapper, object, objectName) {
if (!Array.isArray(object)) {
throw new Error(objectName + " must be of type Array.");
}
var elementType = mapper.type.element;
if (!elementType || typeof elementType !== "object") {
throw new Error("element\" metadata for an Array must be defined in the " +
("mapper and it must of type \"object\" in " + objectName + "."));
}
var tempArray = [];
for (var i = 0; i < object.length; i++) {
tempArray[i] = serializer.serialize(elementType, object[i], objectName);
}
return tempArray;
}
function serializeDictionaryType(serializer, mapper, object, objectName) {
if (typeof object !== "object") {
throw new Error(objectName + " must be of type object.");
}
var valueType = mapper.type.value;
if (!valueType || typeof valueType !== "object") {
throw new Error("\"value\" metadata for a Dictionary must be defined in the " +
("mapper and it must of type \"object\" in " + objectName + "."));
}
var tempDictionary = {};
for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {
var key = _a[_i];
tempDictionary[key] = serializer.serialize(valueType, object[key], objectName + "." + key);
}
return tempDictionary;
}
/**
* Resolves a composite mapper's modelProperties.
* @param serializer the serializer containing the entire set of mappers
* @param mapper the composite mapper to resolve
*/
function resolveModelProperties(serializer, mapper, objectName) {
var modelProps = mapper.type.modelProperties;
if (!modelProps) {
var className = mapper.type.className;
if (!className) {
throw new Error("Class name for model \"" + objectName + "\" is not provided in the mapper \"" + JSON.stringify(mapper, undefined, 2) + "\".");
}
var modelMapper = serializer.modelMappers[className];
if (!modelMapper) {
throw new Error("mapper() cannot be null or undefined for model \"" + className + "\".");
}
modelProps = modelMapper.type.modelProperties;
if (!modelProps) {
throw new Error("modelProperties cannot be null or undefined in the " +
("mapper \"" + JSON.stringify(modelMapper) + "\" of type \"" + className + "\" for object \"" + objectName + "\"."));
}
}
return modelProps;
}
function serializeCompositeType(serializer, mapper, object, objectName) {
var _a;
if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) {
mapper = getPolymorphicMapper(serializer, mapper, object, "clientName");
}
if (object != undefined) {
var payload = {};
var modelProps = resolveModelProperties(serializer, mapper, objectName);
for (var _i = 0, _b = Object.keys(modelProps); _i < _b.length; _i++) {
var key = _b[_i];
var propertyMapper = modelProps[key];
if (propertyMapper.readOnly) {
continue;
}
var propName = void 0;
var parentObject = payload;
if (serializer.isXML) {
if (propertyMapper.xmlIsWrapped) {
propName = propertyMapper.xmlName;
}
else {
propName = propertyMapper.xmlElementName || propertyMapper.xmlName;
}
}
else {
var paths = splitSerializeName(propertyMapper.serializedName);
propName = paths.pop();
for (var _c = 0, paths_1 = paths; _c < paths_1.length; _c++) {
var pathName = paths_1[_c];
var childObject = parentObject[pathName];
if (childObject == undefined && object[key] != undefined) {
parentObject[pathName] = {};
}
parentObject = parentObject[pathName];
}
}
if (parentObject != undefined) {
var propertyObjectName = propertyMapper.serializedName !== ""
? objectName + "." + propertyMapper.serializedName
: objectName;
var toSerialize = object[key];
var polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
if (polymorphicDiscriminator &&
polymorphicDiscriminator.clientName === key &&
toSerialize == undefined) {
toSerialize = mapper.serializedName;
}
var serializedValue = serializer.serialize(propertyMapper, toSerialize, propertyObjectName);
if (serializedValue !== undefined && propName != undefined) {
if (propertyMapper.xmlIsAttribute) {
// $ is the key attributes are kept under in xml2js.
// This keeps things simple while preventing name collision
// with names in user documents.
parentObject.$ = parentObject.$ || {};
parentObject.$[propName] = serializedValue;
}
else if (propertyMapper.xmlIsWrapped) {
parentObject[propName] = (_a = {}, _a[propertyMapper.xmlElementName] = serializedValue, _a);
}
else {
parentObject[propName] = serializedValue;
}
}
}
}
var additionalPropertiesMapper = mapper.type.additionalProperties;
if (additionalPropertiesMapper) {
var propNames = Object.keys(modelProps);
var _loop_1 = function (clientPropName) {
var isAdditionalProperty = propNames.every(function (pn) { return pn !== clientPropName; });
if (isAdditionalProperty) {
payload[clientPropName] = serializer.serialize(additionalPropertiesMapper, object[clientPropName], objectName + '["' + clientPropName + '"]');
}
};
for (var clientPropName in object) {
_loop_1(clientPropName);
}
}
return payload;
}
return object;
}
function isSpecialXmlProperty(propertyName) {
return ["$", "_"].includes(propertyName);
}
function deserializeCompositeType(serializer, mapper, responseBody, objectName) {
if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) {
mapper = getPolymorphicMapper(serializer, mapper, responseBody, "serializedName");
}
var modelProps = resolveModelProperties(serializer, mapper, objectName);
var instance = {};
var handledPropertyNames = [];
for (var _i = 0, _a = Object.keys(modelProps); _i < _a.length; _i++) {
var key = _a[_i];
var propertyMapper = modelProps[key];
var paths = splitSerializeName(modelProps[key].serializedName);
handledPropertyNames.push(paths[0]);
var serializedName = propertyMapper.serializedName, xmlName = propertyMapper.xmlName, xmlElementName = propertyMapper.xmlElementName;
var propertyObjectName = objectName;
if (serializedName !== "" && serializedName !== undefined) {
propertyObjectName = objectName + "." + serializedName;
}
var headerCollectionPrefix = propertyMapper.headerCollectionPrefix;
if (headerCollectionPrefix) {
var dictionary = {};
for (var _b = 0, _c = Object.keys(responseBody); _b < _c.length; _b++) {
var headerKey = _c[_b];
if (headerKey.startsWith(headerCollectionPrefix)) {
dictionary[headerKey.substring(headerCollectionPrefix.length)] = serializer.deserialize(propertyMapper.type.value, responseBody[headerKey], propertyObjectName);
}
handledPropertyNames.push(headerKey);
}
instance[key] = dictionary;
}
else if (serializer.isXML) {
if (propertyMapper.xmlIsAttribute && responseBody.$) {
instance[key] = serializer.deserialize(propertyMapper, responseBody.$[xmlName], propertyObjectName);
}
else {
var propertyName = xmlElementName || xmlName || serializedName;
var unwrappedProperty = responseBody[propertyName];
if (propertyMapper.xmlIsWrapped) {
unwrappedProperty = responseBody[xmlName];
unwrappedProperty = unwrappedProperty && unwrappedProperty[xmlElementName];
var isEmptyWrappedList = unwrappedProperty === undefined;
if (isEmptyWrappedList) {
unwrappedProperty = [];
}
}
instance[key] = serializer.deserialize(propertyMapper, unwrappedProperty, propertyObjectName);
}
}
else {
// deserialize the property if it is present in the provided responseBody instance
var propertyInstance = void 0;
var res = responseBody;
// traversing the object step by step.
for (var _d = 0, paths_2 = paths; _d < paths_2.length; _d++) {
var item = paths_2[_d];
if (!res)
break;
res = res[item];
}
propertyInstance = res;
var polymorphicDiscriminator = mapper.type.polymorphicDiscriminator;
// checking that the model property name (key)(ex: "fishtype") and the
// clientName of the polymorphicDiscriminator {metadata} (ex: "fishtype")
// instead of the serializedName of the polymorphicDiscriminator (ex: "fish.type")
// is a better approach. The generator is not consistent with escaping '\.' in the
// serializedName of the property (ex: "fish\.type") that is marked as polymorphic discriminator
// and the serializedName of the metadata polymorphicDiscriminator (ex: "fish.type"). However,
// the clientName transformation of the polymorphicDiscriminator (ex: "fishtype") and
// the transformation of model property name (ex: "fishtype") is done consistently.
// Hence, it is a safer bet to rely on the clientName of the polymorphicDiscriminator.
if (polymorphicDiscriminator &&
key === polymorphicDiscriminator.clientName &&
propertyInstance == undefined) {
propertyInstance = mapper.serializedName;
}
var serializedValue = void 0;
// paging
if (Array.isArray(responseBody[key]) && modelProps[key].serializedName === "") {
propertyInstance = responseBody[key];
var arrayInstance = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName);
// Copy over any properties that have already been added into the instance, where they do
// not exist on the newly de-serialized array
for (var _e = 0, _f = Object.entries(instance); _e < _f.length; _e++) {
var _g = _f[_e], key_1 = _g[0], value = _g[1];
if (!arrayInstance.hasOwnProperty(key_1)) {
arrayInstance[key_1] = value;
}
}
instance = arrayInstance;
}
else if (propertyInstance !== undefined || propertyMapper.defaultValue !== undefined) {
serializedValue = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName);
instance[key] = serializedValue;
}
}
}
var additionalPropertiesMapper = mapper.type.additionalProperties;
if (additionalPropertiesMapper) {
var isAdditionalProperty = function (responsePropName) {
for (var clientPropName in modelProps) {
var paths = splitSerializeName(modelProps[clientPropName].serializedName);
if (paths[0] === responsePropName) {
return false;
}
}
return true;
};
for (var responsePropName in responseBody) {
if (isAdditionalProperty(responsePropName)) {
instance[responsePropName] = serializer.deserialize(additionalPropertiesMapper, responseBody[responsePropName], objectName + '["' + responsePropName + '"]');
}
}
}
else if (responseBody) {
for (var _h = 0, _j = Object.keys(responseBody); _h < _j.length; _h++) {
var key = _j[_h];
if (instance[key] === undefined &&
!handledPropertyNames.includes(key) &&
!isSpecialXmlProperty(key)) {
instance[key] = responseBody[key];
}
}
}
return instance;
}
function deserializeDictionaryType(serializer, mapper, responseBody, objectName) {
/*jshint validthis: true */
var value = mapper.type.value;
if (!value || typeof value !== "object") {
throw new Error("\"value\" metadata for a Dictionary must be defined in the " +
("mapper and it must of type \"object\" in " + objectName));
}
if (responseBody) {
var tempDictionary = {};
for (var _i = 0, _a = Object.keys(responseBody); _i < _a.length; _i++) {
var key = _a[_i];
tempDictionary[key] = serializer.deserialize(value, responseBody[key], objectName);
}
return tempDictionary;
}
return responseBody;
}
function deserializeSequenceType(serializer, mapper, responseBody, objectName) {
/*jshint validthis: true */
var element = mapper.type.element;
if (!element || typeof element !== "object") {
throw new Error("element\" metadata for an Array must be defined in the " +
("mapper and it must of type \"object\" in " + objectName));
}
if (responseBody) {
if (!Array.isArray(responseBody)) {
// xml2js will interpret a single element array as just the element, so force it to be an array
responseBody = [responseBody];
}
var tempArray = [];
for (var i = 0; i < responseBody.length; i++) {
tempArray[i] = serializer.deserialize(element, responseBody[i], objectName + "[" + i + "]");
}
return tempArray;
}
return responseBody;
}
function getPolymorphicMapper(serializer, mapper, object, polymorphicPropertyName) {
var polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
if (polymorphicDiscriminator) {
var discriminatorName = polymorphicDiscriminator[polymorphicPropertyName];
if (discriminatorName != undefined) {
var discriminatorValue = object[discriminatorName];
if (discriminatorValue != undefined) {
var typeName = mapper.type.uberParent || mapper.type.className;
var indexDiscriminator = discriminatorValue === typeName
? discriminatorValue
: typeName + "." + discriminatorValue;
var polymorphicMapper = serializer.modelMappers.discriminators[indexDiscriminator];
if (polymorphicMapper) {
mapper = polymorphicMapper;
}
}
}
}
return mapper;
}
function getPolymorphicDiscriminatorRecursively(serializer, mapper) {
return (mapper.type.polymorphicDiscriminator ||
getPolymorphicDiscriminatorSafely(serializer, mapper.type.uberParent) ||
getPolymorphicDiscriminatorSafely(serializer, mapper.type.className));
}
function getPolymorphicDiscriminatorSafely(serializer, typeName) {
return (typeName &&
serializer.modelMappers[typeName] &&
serializer.modelMappers[typeName].type.polymorphicDiscriminator);
}
// TODO: why is this here?
export function serializeObject(toSerialize) {
if (toSerialize == undefined)
return undefined;
if (toSerialize instanceof Uint8Array) {
toSerialize = base64.encodeByteArray(toSerialize);
return toSerialize;
}
else if (toSerialize instanceof Date) {
return toSerialize.toISOString();
}
else if (Array.isArray(toSerialize)) {
var array = [];
for (var i = 0; i < toSerialize.length; i++) {
array.push(serializeObject(toSerialize[i]));
}
return array;
}
else if (typeof toSerialize === "object") {
var dictionary = {};
for (var property in toSerialize) {
dictionary[property] = serializeObject(toSerialize[property]);
}
return dictionary;
}
return toSerialize;
}
/**
* Utility function to create a K:V from a list of strings
*/
function strEnum(o) {
var result = {};
for (var _i = 0, o_1 = o; _i < o_1.length; _i++) {
var key = o_1[_i];
result[key] = key;
}
return result;
}
export var MapperType = strEnum([
"Base64Url",
"Boolean",
"ByteArray",
"Composite",
"Date",
"DateTime",
"DateTimeRfc1123",
"Dictionary",
"Enum",
"Number",
"Object",
"Sequence",
"String",
"Stream",
"TimeSpan",
"UnixTime",
]);
//# sourceMappingURL=serializer.js.map