duenamodb
Version:
Simple, strongly-typed helpers around the AWS SDK DynamoDB client.
207 lines • 8.44 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.BEGINS_WITH = exports.IS_BETWEEN = exports.IS_GREATER_OR_EQUAL_THAN = exports.IS_LESS_OR_EQUAL_THAN = exports.IS_GREATER_THAN = exports.IS_LESS_THAN = exports.createConditionExpression = exports.AND = exports.IN = exports.NOT = exports.conditionExpression = exports.expressionAttributeValues = exports.expressionAttributeNames = exports.expressionAttributeValueKey = exports.expressionAttributeNameKey = void 0;
const expressionAttributeNameKey = (key) => `#${String(key)}`;
exports.expressionAttributeNameKey = expressionAttributeNameKey;
const expressionAttributeValueKey = (key) => `:${String(key)}`;
exports.expressionAttributeValueKey = expressionAttributeValueKey;
const expressionAttributeNames = (names) => {
if (names.length === 0) {
return;
}
return names.reduce((acc, key) => {
acc[(0, exports.expressionAttributeNameKey)(key)] = key;
return acc;
}, {});
};
exports.expressionAttributeNames = expressionAttributeNames;
const expressionAttributeValueInKey = (key, index) => (0, exports.expressionAttributeValueKey)(`${key}_in${index}`);
const expressionAttributeValueNotKey = (key) => (0, exports.expressionAttributeValueKey)(`not_${key}`);
const andKey = (key, index) => `${key}_and${index}`;
const expressionAttributeValueLessThanKey = (key) => (0, exports.expressionAttributeValueKey)(`less_than_${key}`);
const expressionAttributeValueGreaterThanKey = (key) => (0, exports.expressionAttributeValueKey)(`greater_than_${key}`);
const expressionAttributeValueLessOrEqualKey = (key) => (0, exports.expressionAttributeValueKey)(`less_or_equal_${key}`);
const expressionAttributeValueGreaterOrEqualKey = (key) => (0, exports.expressionAttributeValueKey)(`greater_or_equal_${key}`);
const expressionAttributeValueBetweenKey = (key, index) => (0, exports.expressionAttributeValueKey)(`between_${key}_${index}`);
const expressionAttributeValueBeginsWithKey = (key) => (0, exports.expressionAttributeValueKey)(`begins_with_${key}`);
const transformExpressionAttributeEntry = (key, value) => {
if (!isDuenamoExpression(value)) {
return { [(0, exports.expressionAttributeValueKey)(key)]: value };
}
if (value.duenamoType === "not") {
return { [expressionAttributeValueNotKey(key)]: value.value };
}
if (value.duenamoType === "in") {
const result = {};
for (let i = 0; i < value.value.length; i++) {
const arrayValue = value.value[i];
result[expressionAttributeValueInKey(key, i)] = arrayValue;
}
return result;
}
if (value.duenamoType === "and") {
let result = {};
for (let i = 0; i < value.value.length; i++) {
const arrayValue = value.value[i];
result = {
...result,
...transformExpressionAttributeEntry(andKey(key, i), arrayValue),
};
}
return result;
}
if (value.duenamoType === "is_less_than") {
return { [expressionAttributeValueLessThanKey(key)]: value.value };
}
if (value.duenamoType === "is_greater_than") {
return { [expressionAttributeValueGreaterThanKey(key)]: value.value };
}
if (value.duenamoType === "is_less_or_equal") {
return { [expressionAttributeValueLessOrEqualKey(key)]: value.value };
}
if (value.duenamoType === "is_greater_or_equal") {
return { [expressionAttributeValueGreaterOrEqualKey(key)]: value.value };
}
if (value.duenamoType === "is_between") {
return {
[expressionAttributeValueBetweenKey(key, 0)]: value.value1,
[expressionAttributeValueBetweenKey(key, 1)]: value.value2,
};
}
if (value.duenamoType === "begins_with") {
return { [expressionAttributeValueBeginsWithKey(key)]: value.value };
}
return {};
};
const expressionAttributeValues = (options) => {
const keys = Object.keys(options);
if (keys.length === 0) {
return;
}
let result = {};
for (const key of keys) {
const value = options[key];
result = {
...result,
...transformExpressionAttributeEntry(key, value),
};
}
return result;
};
exports.expressionAttributeValues = expressionAttributeValues;
const transformConditionExpressionEntry = (key, value, nameKey) => {
if (!isDuenamoExpression(value)) {
const valueKey = (0, exports.expressionAttributeValueKey)(key);
return `(${nameKey} = ${valueKey})`;
}
if (value.duenamoType === "not") {
const valueKey = expressionAttributeValueNotKey(key);
return `(${nameKey} <> ${valueKey})`;
}
if (value.duenamoType === "in") {
const result = [];
for (let i = 0; i < value.value.length; i++) {
result.push(expressionAttributeValueInKey(key, i));
}
return `(${nameKey} IN (${result.join(", ")}))`;
}
if (value.duenamoType === "and") {
const result = [];
for (let i = 0; i < value.value.length; i++) {
const arrayValue = value.value[i];
result.push(transformConditionExpressionEntry(andKey(key, i), arrayValue, nameKey));
}
return `(${result.join(" AND ")})`;
}
if (value.duenamoType === "is_less_than") {
return `(${nameKey} < ${expressionAttributeValueLessThanKey(key)})`;
}
if (value.duenamoType === "is_greater_than") {
return `(${nameKey} > ${expressionAttributeValueGreaterThanKey(key)})`;
}
if (value.duenamoType === "is_less_or_equal") {
return `(${nameKey} <= ${expressionAttributeValueLessOrEqualKey(key)})`;
}
if (value.duenamoType === "is_greater_or_equal") {
return `(${nameKey} >= ${expressionAttributeValueGreaterOrEqualKey(key)})`;
}
if (value.duenamoType === "is_between") {
return `(${nameKey} BETWEEN ${expressionAttributeValueBetweenKey(key, 0)} AND ${expressionAttributeValueBetweenKey(key, 1)})`;
}
if (value.duenamoType === "begins_with") {
return `begins_with(${nameKey}, ${expressionAttributeValueBeginsWithKey(key)})`;
}
return "";
};
const conditionExpression = (options) => {
const keys = Object.keys(options);
if (keys.length === 0) {
return;
}
const array = [];
for (const key of keys) {
const value = options[key];
const nameKey = (0, exports.expressionAttributeNameKey)(key);
array.push(transformConditionExpressionEntry(key, value, nameKey));
}
return array.join(" and ");
};
exports.conditionExpression = conditionExpression;
const isDuenamoExpression = (object) => {
return Boolean(typeof object === "object" && object && "duenamoType" in object);
};
const NOT = (value) => {
return { duenamoType: "not", value };
};
exports.NOT = NOT;
const IN = (...value) => {
return {
duenamoType: "in",
value,
};
};
exports.IN = IN;
const AND = (...value) => {
return {
duenamoType: "and",
value,
};
};
exports.AND = AND;
const createConditionExpression = (object) => {
const keys = Object.keys(object);
const attributeValues = (0, exports.expressionAttributeValues)(object);
const attributeNames = (0, exports.expressionAttributeNames)(keys);
const expression = (0, exports.conditionExpression)(object);
return {
attributeNames,
attributeValues,
expression,
};
};
exports.createConditionExpression = createConditionExpression;
const IS_LESS_THAN = (value) => {
return { duenamoType: "is_less_than", value };
};
exports.IS_LESS_THAN = IS_LESS_THAN;
const IS_GREATER_THAN = (value) => {
return { duenamoType: "is_greater_than", value };
};
exports.IS_GREATER_THAN = IS_GREATER_THAN;
const IS_LESS_OR_EQUAL_THAN = (value) => {
return { duenamoType: "is_less_or_equal", value };
};
exports.IS_LESS_OR_EQUAL_THAN = IS_LESS_OR_EQUAL_THAN;
const IS_GREATER_OR_EQUAL_THAN = (value) => {
return { duenamoType: "is_greater_or_equal", value };
};
exports.IS_GREATER_OR_EQUAL_THAN = IS_GREATER_OR_EQUAL_THAN;
const IS_BETWEEN = (value1, value2) => {
return { duenamoType: "is_between", value1, value2 };
};
exports.IS_BETWEEN = IS_BETWEEN;
const BEGINS_WITH = (value) => {
return { duenamoType: "begins_with", value };
};
exports.BEGINS_WITH = BEGINS_WITH;
//# sourceMappingURL=expression.js.map