mirror of
https://github.com/oven-sh/setup-bun.git
synced 2025-02-24 03:00:39 +08:00
789 lines
34 KiB
JavaScript
789 lines
34 KiB
JavaScript
|
// 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
|