dynamodb-turbine/dist/expressions.js

Entity mapping and query library for DynamoDB

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateUpdateExpression = exports.generateFilterExpression = exports.generateQueryExpression = exports.buildValue = exports.generateAttributeNames = exports.generateAttributeValues = void 0;
var generateAttributeValues = function (patch, prefix) {
    return Object.entries(patch)
        .filter(function (_a) {
        var value = _a[1];
        return value !== undefined && value !== null;
    })
        .reduce(function (patch, _a) {
        var _b;
        var key = _a[0], value = _a[1];
        return (__assign(__assign({}, patch), (_b = {}, _b[":".concat(prefix || "").concat(key)] = value, _b)));
    }, {});
};
exports.generateAttributeValues = generateAttributeValues;
var generateAttributeNames = function (patch, prefix) {
    return Object.entries(patch)
        .filter(function (_a) {
        var value = _a[1];
        return value !== undefined;
    })
        .reduce(function (patch, _a) {
        var _b;
        var key = _a[0];
        return (__assign(__assign({}, patch), (_b = {}, _b["#".concat(prefix || "").concat(key)] = key, _b)));
    }, {});
};
exports.generateAttributeNames = generateAttributeNames;
var buildValue = function (value) {
    if (Array.isArray(value)) {
        value = value.join("#");
    }
    return value;
};
exports.buildValue = buildValue;
var generateQueryExpression = function (key, filters) {
    var keyCondition = (0, exports.generateFilterExpression)(key, "key");
    var filter = (0, exports.generateFilterExpression)(filters);
    return {
        KeyConditionExpression: keyCondition.FilterExpression,
        FilterExpression: filter.FilterExpression,
        ExpressionAttributeNames: __assign(__assign({}, keyCondition.ExpressionAttributeNames), filter.ExpressionAttributeNames),
        ExpressionAttributeValues: __assign(__assign({}, keyCondition.ExpressionAttributeValues), filter.ExpressionAttributeValues),
    };
};
exports.generateQueryExpression = generateQueryExpression;
var generateFilterExpression = function (filters, prefix) {
    if (prefix === void 0) { prefix = "filter"; }
    if (!filters || filters.length === 0) {
        return {};
    }
    var ExpressionAttributeNames = {};
    var ExpressionAttributeValues = {};
    var filterExpressions = Object.entries(filters).map(function (_a) {
        var attr = _a[0], expression = _a[1];
        var attributeName = "#".concat(prefix, "_").concat(attr.toString());
        var attributeValue = ":".concat(prefix, "_").concat(attr.toString());
        ExpressionAttributeNames[attributeName] = attr.toString();
        if (typeof expression === "object" && expression !== null) {
            if ("equals" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.equals);
                return "".concat(attributeName, " = ").concat(attributeValue);
            }
            if ("notEquals" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.notEquals);
                return "".concat(attributeName, " <> ").concat(attributeValue);
            }
            if ("greaterThan" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.greaterThan);
                return "".concat(attributeName, " > ").concat(attributeValue);
            }
            if ("lessThan" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.lessThan);
                return "".concat(attributeName, " < ").concat(attributeValue);
            }
            if ("greaterThanOrEquals" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.greaterThanOrEquals);
                return "".concat(attributeName, " >= ").concat(attributeValue);
            }
            if ("lessThanOrEquals" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.lessThanOrEquals);
                return "".concat(attributeName, " <= ").concat(attributeValue);
            }
            if ("between" in expression) {
                var _b = expression.between, start = _b[0], end = _b[1];
                ExpressionAttributeValues[attributeValue + "1"] = (0, exports.buildValue)(start);
                ExpressionAttributeValues[attributeValue + "2"] = (0, exports.buildValue)(end);
                return "".concat(attributeName, " BETWEEN ").concat(attributeValue + "1", " AND ").concat(attributeValue + "2");
            }
            if ("contains" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.contains);
                return "contains(".concat(attributeName, ", ").concat(attributeValue, ")");
            }
            if ("notContains" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.notContains);
                return "not contains(".concat(attributeName, ", ").concat(attributeValue, ")");
            }
            if ("beginsWith" in expression) {
                ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression.beginsWith);
                return "begins_with(".concat(attributeName, ", ").concat(attributeValue, ")");
            }
            if ("exists" in expression) {
                return "attribute_exists(".concat(attributeName, ")");
            }
            if ("notExists" in expression) {
                return "attribute_not_exists(".concat(attributeName, ")");
            }
        }
        // Default: equals
        ExpressionAttributeValues[attributeValue] = (0, exports.buildValue)(expression);
        return "".concat(attributeName, " = ").concat(attributeValue);
    });
    return {
        FilterExpression: filterExpressions.join(" AND "),
        ExpressionAttributeNames: ExpressionAttributeNames,
        ExpressionAttributeValues: ExpressionAttributeValues,
    };
};
exports.generateFilterExpression = generateFilterExpression;
var generateUpdateExpression = function (patch, doNotOverwrite) {
    if (doNotOverwrite === void 0) { doNotOverwrite = []; }
    var setExpression = Object.entries(patch)
        .filter(function (_a) {
        var value = _a[1];
        return value !== undefined && value !== null;
    })
        .map(function (_a) {
        var key = _a[0];
        var value = ":".concat(key);
        if (doNotOverwrite.includes(key)) {
            value = "if_not_exists(#".concat(key, ", ").concat(value, ")");
        }
        return "#".concat(key, " = ").concat(value);
    });
    var removeExpression = Object.entries(patch)
        .filter(function (_a) {
        var value = _a[1];
        return value === null;
    })
        .map(function (_a) {
        var key = _a[0];
        return "#".concat(key);
    });
    var expressionComponents = [
        setExpression.length && "SET ".concat(setExpression.join(", ")),
        removeExpression.length && "REMOVE ".concat(removeExpression.join(", ")),
    ];
    return {
        UpdateExpression: expressionComponents.filter(Boolean).join(" "),
        ExpressionAttributeNames: (0, exports.generateAttributeNames)(patch),
        ExpressionAttributeValues: (0, exports.generateAttributeValues)(patch),
    };
};
exports.generateUpdateExpression = generateUpdateExpression;