@aws-sdk/util-dynamodb 3.183.0 → 3.186.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06)
+
+**Note:** Version bump only for package @aws-sdk/util-dynamodb
+
+
+
+
+
+# [3.185.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.184.0...v3.185.0) (2022-10-05)
+
+**Note:** Version bump only for package @aws-sdk/util-dynamodb
+
+
+
+
+
 # [3.183.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.182.0...v3.183.0) (2022-10-03)
 
 **Note:** Version bump only for package @aws-sdk/util-dynamodb

package/dist-es/convertToAttr.js

@@ -1,6 +1,8 @@
-export const convertToAttr = (data, options) => {
+import { __read, __spreadArray, __values } from "tslib";
+export var convertToAttr = function (data, options) {
+    var _a, _b, _c, _d, _e, _f;
     if (data === undefined) {
-        throw new Error(`Pass options.removeUndefinedValues=true to remove undefined values from map/array/set.`);
+        throw new Error("Pass options.removeUndefinedValues=true to remove undefined values from map/array/set.");
     }
     else if (data === null && typeof data === "object") {
         return convertToNullAttr();
@@ -8,137 +10,148 @@ export const convertToAttr = (data, options) => {
     else if (Array.isArray(data)) {
         return convertToListAttr(data, options);
     }
-    else if (data?.constructor?.name === "Set") {
+    else if (((_a = data === null || data === void 0 ? void 0 : data.constructor) === null || _a === void 0 ? void 0 : _a.name) === "Set") {
         return convertToSetAttr(data, options);
     }
-    else if (data?.constructor?.name === "Map") {
+    else if (((_b = data === null || data === void 0 ? void 0 : data.constructor) === null || _b === void 0 ? void 0 : _b.name) === "Map") {
         return convertToMapAttrFromIterable(data, options);
     }
-    else if (data?.constructor?.name === "Object" ||
+    else if (((_c = data === null || data === void 0 ? void 0 : data.constructor) === null || _c === void 0 ? void 0 : _c.name) === "Object" ||
         (!data.constructor && typeof data === "object")) {
         return convertToMapAttrFromEnumerableProps(data, options);
     }
     else if (isBinary(data)) {
-        if (data.length === 0 && options?.convertEmptyValues) {
+        if (data.length === 0 && (options === null || options === void 0 ? void 0 : options.convertEmptyValues)) {
             return convertToNullAttr();
         }
         return convertToBinaryAttr(data);
     }
-    else if (typeof data === "boolean" || data?.constructor?.name === "Boolean") {
+    else if (typeof data === "boolean" || ((_d = data === null || data === void 0 ? void 0 : data.constructor) === null || _d === void 0 ? void 0 : _d.name) === "Boolean") {
         return { BOOL: data.valueOf() };
     }
-    else if (typeof data === "number" || data?.constructor?.name === "Number") {
+    else if (typeof data === "number" || ((_e = data === null || data === void 0 ? void 0 : data.constructor) === null || _e === void 0 ? void 0 : _e.name) === "Number") {
         return convertToNumberAttr(data);
     }
     else if (typeof data === "bigint") {
         return convertToBigIntAttr(data);
     }
-    else if (typeof data === "string" || data?.constructor?.name === "String") {
-        if (data.length === 0 && options?.convertEmptyValues) {
+    else if (typeof data === "string" || ((_f = data === null || data === void 0 ? void 0 : data.constructor) === null || _f === void 0 ? void 0 : _f.name) === "String") {
+        if (data.length === 0 && (options === null || options === void 0 ? void 0 : options.convertEmptyValues)) {
             return convertToNullAttr();
         }
         return convertToStringAttr(data);
     }
-    else if (options?.convertClassInstanceToMap && typeof data === "object") {
+    else if ((options === null || options === void 0 ? void 0 : options.convertClassInstanceToMap) && typeof data === "object") {
         return convertToMapAttrFromEnumerableProps(data, options);
     }
-    throw new Error(`Unsupported type passed: ${data}. Pass options.convertClassInstanceToMap=true to marshall typeof object as map attribute.`);
+    throw new Error("Unsupported type passed: ".concat(data, ". Pass options.convertClassInstanceToMap=true to marshall typeof object as map attribute."));
 };
-const convertToListAttr = (data, options) => ({
+var convertToListAttr = function (data, options) { return ({
     L: data
-        .filter((item) => !options?.removeUndefinedValues || (options?.removeUndefinedValues && item !== undefined))
-        .map((item) => convertToAttr(item, options)),
-});
-const convertToSetAttr = (set, options) => {
-    const setToOperate = options?.removeUndefinedValues ? new Set([...set].filter((value) => value !== undefined)) : set;
-    if (!options?.removeUndefinedValues && setToOperate.has(undefined)) {
-        throw new Error(`Pass options.removeUndefinedValues=true to remove undefined values from map/array/set.`);
+        .filter(function (item) { return !(options === null || options === void 0 ? void 0 : options.removeUndefinedValues) || ((options === null || options === void 0 ? void 0 : options.removeUndefinedValues) && item !== undefined); })
+        .map(function (item) { return convertToAttr(item, options); }),
+}); };
+var convertToSetAttr = function (set, options) {
+    var setToOperate = (options === null || options === void 0 ? void 0 : options.removeUndefinedValues) ? new Set(__spreadArray([], __read(set), false).filter(function (value) { return value !== undefined; })) : set;
+    if (!(options === null || options === void 0 ? void 0 : options.removeUndefinedValues) && setToOperate.has(undefined)) {
+        throw new Error("Pass options.removeUndefinedValues=true to remove undefined values from map/array/set.");
     }
     if (setToOperate.size === 0) {
-        if (options?.convertEmptyValues) {
+        if (options === null || options === void 0 ? void 0 : options.convertEmptyValues) {
             return convertToNullAttr();
         }
-        throw new Error(`Pass a non-empty set, or options.convertEmptyValues=true.`);
+        throw new Error("Pass a non-empty set, or options.convertEmptyValues=true.");
     }
-    const item = setToOperate.values().next().value;
+    var item = setToOperate.values().next().value;
     if (typeof item === "number") {
         return {
             NS: Array.from(setToOperate)
                 .map(convertToNumberAttr)
-                .map((item) => item.N),
+                .map(function (item) { return item.N; }),
         };
     }
     else if (typeof item === "bigint") {
         return {
             NS: Array.from(setToOperate)
                 .map(convertToBigIntAttr)
-                .map((item) => item.N),
+                .map(function (item) { return item.N; }),
         };
     }
     else if (typeof item === "string") {
         return {
             SS: Array.from(setToOperate)
                 .map(convertToStringAttr)
-                .map((item) => item.S),
+                .map(function (item) { return item.S; }),
         };
     }
     else if (isBinary(item)) {
         return {
             BS: Array.from(setToOperate)
                 .map(convertToBinaryAttr)
-                .map((item) => item.B),
+                .map(function (item) { return item.B; }),
         };
     }
     else {
-        throw new Error(`Only Number Set (NS), Binary Set (BS) or String Set (SS) are allowed.`);
+        throw new Error("Only Number Set (NS), Binary Set (BS) or String Set (SS) are allowed.");
     }
 };
-const convertToMapAttrFromIterable = (data, options) => ({
-    M: ((data) => {
-        const map = {};
-        for (const [key, value] of data) {
-            if (typeof value !== "function" && (value !== undefined || !options?.removeUndefinedValues)) {
-                map[key] = convertToAttr(value, options);
+var convertToMapAttrFromIterable = function (data, options) { return ({
+    M: (function (data) {
+        var e_1, _a;
+        var map = {};
+        try {
+            for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
+                var _b = __read(data_1_1.value, 2), key = _b[0], value = _b[1];
+                if (typeof value !== "function" && (value !== undefined || !(options === null || options === void 0 ? void 0 : options.removeUndefinedValues))) {
+                    map[key] = convertToAttr(value, options);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
             }
+            finally { if (e_1) throw e_1.error; }
         }
         return map;
     })(data),
-});
-const convertToMapAttrFromEnumerableProps = (data, options) => ({
-    M: ((data) => {
-        const map = {};
-        for (const key in data) {
-            const value = data[key];
-            if (typeof value !== "function" && (value !== undefined || !options?.removeUndefinedValues)) {
+}); };
+var convertToMapAttrFromEnumerableProps = function (data, options) { return ({
+    M: (function (data) {
+        var map = {};
+        for (var key in data) {
+            var value = data[key];
+            if (typeof value !== "function" && (value !== undefined || !(options === null || options === void 0 ? void 0 : options.removeUndefinedValues))) {
                 map[key] = convertToAttr(value, options);
             }
         }
         return map;
     })(data),
-});
-const convertToNullAttr = () => ({ NULL: true });
-const convertToBinaryAttr = (data) => ({ B: data });
-const convertToStringAttr = (data) => ({ S: data.toString() });
-const convertToBigIntAttr = (data) => ({ N: data.toString() });
-const validateBigIntAndThrow = (errorPrefix) => {
-    throw new Error(`${errorPrefix} ${typeof BigInt === "function" ? "Use BigInt." : "Pass string value instead."} `);
+}); };
+var convertToNullAttr = function () { return ({ NULL: true }); };
+var convertToBinaryAttr = function (data) { return ({ B: data }); };
+var convertToStringAttr = function (data) { return ({ S: data.toString() }); };
+var convertToBigIntAttr = function (data) { return ({ N: data.toString() }); };
+var validateBigIntAndThrow = function (errorPrefix) {
+    throw new Error("".concat(errorPrefix, " ").concat(typeof BigInt === "function" ? "Use BigInt." : "Pass string value instead.", " "));
 };
-const convertToNumberAttr = (num) => {
+var convertToNumberAttr = function (num) {
     if ([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]
-        .map((val) => val.toString())
+        .map(function (val) { return val.toString(); })
         .includes(num.toString())) {
-        throw new Error(`Special numeric value ${num.toString()} is not allowed`);
+        throw new Error("Special numeric value ".concat(num.toString(), " is not allowed"));
     }
     else if (num > Number.MAX_SAFE_INTEGER) {
-        validateBigIntAndThrow(`Number ${num.toString()} is greater than Number.MAX_SAFE_INTEGER.`);
+        validateBigIntAndThrow("Number ".concat(num.toString(), " is greater than Number.MAX_SAFE_INTEGER."));
     }
     else if (num < Number.MIN_SAFE_INTEGER) {
-        validateBigIntAndThrow(`Number ${num.toString()} is lesser than Number.MIN_SAFE_INTEGER.`);
+        validateBigIntAndThrow("Number ".concat(num.toString(), " is lesser than Number.MIN_SAFE_INTEGER."));
     }
     return { N: num.toString() };
 };
-const isBinary = (data) => {
-    const binaryTypes = [
+var isBinary = function (data) {
+    var binaryTypes = [
         "ArrayBuffer",
         "Blob",
         "Buffer",
@@ -156,7 +169,7 @@ const isBinary = (data) => {
         "BigInt64Array",
         "BigUint64Array",
     ];
-    if (data?.constructor) {
+    if (data === null || data === void 0 ? void 0 : data.constructor) {
         return binaryTypes.includes(data.constructor.name);
     }
     return false;

package/dist-es/convertToNative.js

@@ -1,59 +1,76 @@
-export const convertToNative = (data, options) => {
-    for (const [key, value] of Object.entries(data)) {
-        if (value !== undefined) {
-            switch (key) {
-                case "NULL":
-                    return null;
-                case "BOOL":
-                    return Boolean(value);
-                case "N":
-                    return convertNumber(value, options);
-                case "B":
-                    return convertBinary(value);
-                case "S":
-                    return convertString(value);
-                case "L":
-                    return convertList(value, options);
-                case "M":
-                    return convertMap(value, options);
-                case "NS":
-                    return new Set(value.map((item) => convertNumber(item, options)));
-                case "BS":
-                    return new Set(value.map(convertBinary));
-                case "SS":
-                    return new Set(value.map(convertString));
-                default:
-                    throw new Error(`Unsupported type passed: ${key}`);
+import { __assign, __read, __values } from "tslib";
+export var convertToNative = function (data, options) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(Object.entries(data)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
+            if (value !== undefined) {
+                switch (key) {
+                    case "NULL":
+                        return null;
+                    case "BOOL":
+                        return Boolean(value);
+                    case "N":
+                        return convertNumber(value, options);
+                    case "B":
+                        return convertBinary(value);
+                    case "S":
+                        return convertString(value);
+                    case "L":
+                        return convertList(value, options);
+                    case "M":
+                        return convertMap(value, options);
+                    case "NS":
+                        return new Set(value.map(function (item) { return convertNumber(item, options); }));
+                    case "BS":
+                        return new Set(value.map(convertBinary));
+                    case "SS":
+                        return new Set(value.map(convertString));
+                    default:
+                        throw new Error("Unsupported type passed: ".concat(key));
+                }
             }
         }
     }
-    throw new Error(`No value defined: ${JSON.stringify(data)}`);
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    throw new Error("No value defined: ".concat(JSON.stringify(data)));
 };
-const convertNumber = (numString, options) => {
-    if (options?.wrapNumbers) {
+var convertNumber = function (numString, options) {
+    if (options === null || options === void 0 ? void 0 : options.wrapNumbers) {
         return { value: numString };
     }
-    const num = Number(numString);
-    const infinityValues = [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];
+    var num = Number(numString);
+    var infinityValues = [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];
     if ((num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) && !infinityValues.includes(num)) {
         if (typeof BigInt === "function") {
             try {
                 return BigInt(numString);
             }
             catch (error) {
-                throw new Error(`${numString} can't be converted to BigInt. Set options.wrapNumbers to get string value.`);
+                throw new Error("".concat(numString, " can't be converted to BigInt. Set options.wrapNumbers to get string value."));
             }
         }
         else {
-            throw new Error(`${numString} is outside SAFE_INTEGER bounds. Set options.wrapNumbers to get string value.`);
+            throw new Error("".concat(numString, " is outside SAFE_INTEGER bounds. Set options.wrapNumbers to get string value."));
         }
     }
     return num;
 };
-const convertString = (stringValue) => stringValue;
-const convertBinary = (binaryValue) => binaryValue;
-const convertList = (list, options) => list.map((item) => convertToNative(item, options));
-const convertMap = (map, options) => Object.entries(map).reduce((acc, [key, value]) => ({
-    ...acc,
-    [key]: convertToNative(value, options),
-}), {});
+var convertString = function (stringValue) { return stringValue; };
+var convertBinary = function (binaryValue) { return binaryValue; };
+var convertList = function (list, options) {
+    return list.map(function (item) { return convertToNative(item, options); });
+};
+var convertMap = function (map, options) {
+    return Object.entries(map).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
+        return (__assign(__assign({}, acc), (_b = {}, _b[key] = convertToNative(value, options), _b)));
+    }, {});
+};

package/dist-es/marshall.js

@@ -1,7 +1,8 @@
+import { __read } from "tslib";
 import { convertToAttr } from "./convertToAttr";
 export function marshall(data, options) {
-    const attributeValue = convertToAttr(data, options);
-    const [key, value] = Object.entries(attributeValue)[0];
+    var attributeValue = convertToAttr(data, options);
+    var _a = __read(Object.entries(attributeValue)[0], 2), key = _a[0], value = _a[1];
     switch (key) {
         case "M":
         case "L":

package/dist-es/unmarshall.js

@@ -1,2 +1,4 @@
 import { convertToNative } from "./convertToNative";
-export const unmarshall = (data, options) => convertToNative({ M: data }, options);
+export var unmarshall = function (data, options) {
+    return convertToNative({ M: data }, options);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/util-dynamodb",
-  "version": "3.183.0",
+  "version": "3.186.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -23,7 +23,7 @@
     "tslib": "^2.3.1"
   },
   "devDependencies": {
-    "@aws-sdk/client-dynamodb": "3.183.0",
+    "@aws-sdk/client-dynamodb": "3.186.0",
     "@tsconfig/recommended": "1.0.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",