File Explorer

1'use strict';2 3class NumberValue {4    value;5    constructor(value) {6        if (typeof value === "object" && "N" in value) {7            this.value = String(value.N);8        }9        else {10            this.value = String(value);11        }12        const valueOf = typeof value.valueOf() === "number" ? value.valueOf() : 0;13        const imprecise = valueOf > Number.MAX_SAFE_INTEGER ||14            valueOf < Number.MIN_SAFE_INTEGER ||15            Math.abs(valueOf) === Infinity ||16            Number.isNaN(valueOf);17        if (imprecise) {18            throw new Error(`NumberValue should not be initialized with an imprecise number=${valueOf}. Use a string instead.`);19        }20    }21    static from(value) {22        return new NumberValue(value);23    }24    toAttributeValue() {25        return {26            N: this.toString(),27        };28    }29    toBigInt() {30        const stringValue = this.toString();31        return BigInt(stringValue);32    }33    toString() {34        return String(this.value);35    }36    valueOf() {37        return this.toString();38    }39}40 41const convertToAttr = (data, options) => {42    if (data === undefined) {43        throw new Error(`Pass options.removeUndefinedValues=true to remove undefined values from map/array/set.`);44    }45    else if (data === null && typeof data === "object") {46        return convertToNullAttr();47    }48    else if (Array.isArray(data)) {49        return convertToListAttr(data, options);50    }51    else if (data?.constructor?.name === "Set") {52        return convertToSetAttr(data, options);53    }54    else if (data?.constructor?.name === "Map") {55        return convertToMapAttrFromIterable(data, options);56    }57    else if (data?.constructor?.name === "Object" ||58        (!data.constructor && typeof data === "object")) {59        return convertToMapAttrFromEnumerableProps(data, options);60    }61    else if (isBinary(data)) {62        if (data.length === 0 && options?.convertEmptyValues) {63            return convertToNullAttr();64        }65        return convertToBinaryAttr(data);66    }67    else if (typeof data === "boolean" || data?.constructor?.name === "Boolean") {68        return { BOOL: data.valueOf() };69    }70    else if (typeof data === "number" || data?.constructor?.name === "Number") {71        return convertToNumberAttr(data, options);72    }73    else if (data instanceof NumberValue) {74        return data.toAttributeValue();75    }76    else if (typeof data === "bigint") {77        return convertToBigIntAttr(data);78    }79    else if (typeof data === "string" || data?.constructor?.name === "String") {80        if (data.length === 0 && options?.convertEmptyValues) {81            return convertToNullAttr();82        }83        return convertToStringAttr(data);84    }85    else if (options?.convertClassInstanceToMap && typeof data === "object") {86        return convertToMapAttrFromEnumerableProps(data, options);87    }88    throw new Error(`Unsupported type passed: ${data}. Pass options.convertClassInstanceToMap=true to marshall typeof object as map attribute.`);89};90const convertToListAttr = (data, options) => ({91    L: data92        .filter((item) => typeof item !== "function" &&93        (!options?.removeUndefinedValues || (options?.removeUndefinedValues && item !== undefined)))94        .map((item) => convertToAttr(item, options)),95});96const convertToSetAttr = (set, options) => {97    const setToOperate = options?.removeUndefinedValues ? new Set([...set].filter((value) => value !== undefined)) : set;98    if (!options?.removeUndefinedValues && setToOperate.has(undefined)) {99        throw new Error(`Pass options.removeUndefinedValues=true to remove undefined values from map/array/set.`);100    }101    if (setToOperate.size === 0) {102        if (options?.convertEmptyValues) {103            return convertToNullAttr();104        }105        throw new Error(`Pass a non-empty set, or options.convertEmptyValues=true.`);106    }107    const item = setToOperate.values().next().value;108    if (item instanceof NumberValue) {109        return {110            NS: Array.from(setToOperate).map((_) => _.toString()),111        };112    }113    else if (typeof item === "number") {114        return {115            NS: Array.from(setToOperate)116                .map((num) => convertToNumberAttr(num, options))117                .map((item) => item.N),118        };119    }120    else if (typeof item === "bigint") {121        return {122            NS: Array.from(setToOperate)123                .map(convertToBigIntAttr)124                .map((item) => item.N),125        };126    }127    else if (typeof item === "string") {128        return {129            SS: Array.from(setToOperate)130                .map(convertToStringAttr)131                .map((item) => item.S),132        };133    }134    else if (isBinary(item)) {135        return {136            BS: Array.from(setToOperate)137                .map(convertToBinaryAttr)138                .map((item) => item.B),139        };140    }141    else {142        throw new Error(`Only Number Set (NS), Binary Set (BS) or String Set (SS) are allowed.`);143    }144};145const convertToMapAttrFromIterable = (data, options) => ({146    M: ((data) => {147        const map = {};148        for (const [key, value] of data) {149            if (typeof value !== "function" && (value !== undefined || !options?.removeUndefinedValues)) {150                map[key] = convertToAttr(value, options);151            }152        }153        return map;154    })(data),155});156const convertToMapAttrFromEnumerableProps = (data, options) => ({157    M: ((data) => {158        const map = {};159        for (const key in data) {160            const value = data[key];161            if (typeof value !== "function" && (value !== undefined || !options?.removeUndefinedValues)) {162                map[key] = convertToAttr(value, options);163            }164        }165        return map;166    })(data),167});168const convertToNullAttr = () => ({ NULL: true });169const convertToBinaryAttr = (data) => ({ B: data });170const convertToStringAttr = (data) => ({ S: data.toString() });171const convertToBigIntAttr = (data) => ({ N: data.toString() });172const validateBigIntAndThrow = (errorPrefix) => {173    throw new Error(`${errorPrefix} Use NumberValue from @aws-sdk/lib-dynamodb.`);174};175const convertToNumberAttr = (num, options) => {176    if ([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]177        .map((val) => val.toString())178        .includes(num.toString())) {179        throw new Error(`Special numeric value ${num.toString()} is not allowed`);180    }181    else if (!options?.allowImpreciseNumbers) {182        if (Number(num) > Number.MAX_SAFE_INTEGER) {183            validateBigIntAndThrow(`Number ${num.toString()} is greater than Number.MAX_SAFE_INTEGER.`);184        }185        else if (Number(num) < Number.MIN_SAFE_INTEGER) {186            validateBigIntAndThrow(`Number ${num.toString()} is lesser than Number.MIN_SAFE_INTEGER.`);187        }188    }189    return { N: num.toString() };190};191const isBinary = (data) => {192    const binaryTypes = [193        "ArrayBuffer",194        "Blob",195        "Buffer",196        "DataView",197        "File",198        "Int8Array",199        "Uint8Array",200        "Uint8ClampedArray",201        "Int16Array",202        "Uint16Array",203        "Int32Array",204        "Uint32Array",205        "Float32Array",206        "Float64Array",207        "BigInt64Array",208        "BigUint64Array",209    ];210    if (data?.constructor) {211        return binaryTypes.includes(data.constructor.name);212    }213    return false;214};215 216const convertToNative = (data, options) => {217    for (const [key, value] of Object.entries(data)) {218        if (value !== undefined) {219            switch (key) {220                case "NULL":221                    return null;222                case "BOOL":223                    return Boolean(value);224                case "N":225                    return convertNumber(value, options);226                case "B":227                    return convertBinary(value);228                case "S":229                    return convertString(value);230                case "L":231                    return convertList(value, options);232                case "M":233                    return convertMap(value, options);234                case "NS":235                    return new Set(value.map((item) => convertNumber(item, options)));236                case "BS":237                    return new Set(value.map(convertBinary));238                case "SS":239                    return new Set(value.map(convertString));240                default:241                    throw new Error(`Unsupported type passed: ${key}`);242            }243        }244    }245    throw new Error(`No value defined: ${JSON.stringify(data)}`);246};247const convertNumber = (numString, options) => {248    if (typeof options?.wrapNumbers === "function") {249        return options?.wrapNumbers(numString);250    }251    if (options?.wrapNumbers) {252        return NumberValue.from(numString);253    }254    const num = Number(numString);255    const infinityValues = [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];256    const isLargeFiniteNumber = (num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) && !infinityValues.includes(num);257    if (isLargeFiniteNumber) {258        if (typeof BigInt === "function") {259            try {260                return BigInt(numString);261            }262            catch (error) {263                throw new Error(`${numString} can't be converted to BigInt. Set options.wrapNumbers to get string value.`);264            }265        }266        else {267            throw new Error(`${numString} is outside SAFE_INTEGER bounds. Set options.wrapNumbers to get string value.`);268        }269    }270    return num;271};272const convertString = (stringValue) => stringValue;273const convertBinary = (binaryValue) => binaryValue;274const convertList = (list, options) => list.map((item) => convertToNative(item, options));275const convertMap = (map, options) => Object.entries(map).reduce((acc, [key, value]) => ((acc[key] = convertToNative(value, options)), acc), {});276 277function marshall(data, options) {278    const attributeValue = convertToAttr(data, options);279    const [key, value] = Object.entries(attributeValue)[0];280    switch (key) {281        case "M":282        case "L":283            return options?.convertTopLevelContainer ? attributeValue : value;284        case "SS":285        case "NS":286        case "BS":287        case "S":288        case "N":289        case "B":290        case "NULL":291        case "BOOL":292        case "$unknown":293        default:294            return attributeValue;295    }296}297 298const unmarshall = (data, options) => {299    if (options?.convertWithoutMapWrapper) {300        return convertToNative(data, options);301    }302    return convertToNative({ M: data }, options);303};304 305exports.NumberValueImpl = NumberValue;306exports.convertToAttr = convertToAttr;307exports.convertToNative = convertToNative;308exports.marshall = marshall;309exports.unmarshall = unmarshall;310