@ragestudio/scylla-odm 0.22.2 → 0.22.3

package/driver/mapping/q.js

@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import errors from "../errors.js"
+
+/**
+ * Represents a CQL query operator, like >=, IN, <, ...
+ * @ignore
+ */
+class QueryOperator {
+	/**
+	 * Creates a new instance of <code>QueryOperator</code>.
+	 * @param {String} key
+	 * @param value
+	 * @param [hasChildValues]
+	 * @param [isInOperator]
+	 */
+	constructor(key, value, hasChildValues, isInOperator) {
+		/**
+		 * The CQL key representing the operator
+		 * @type {string}
+		 */
+		this.key = key
+
+		/**
+		 * The value to be used as parameter.
+		 */
+		this.value = value
+
+		/**
+		 * Determines whether a query operator can have child values or operators (AND, OR)
+		 */
+		this.hasChildValues = hasChildValues
+
+		/**
+		 * Determines whether this instance represents CQL "IN" operator.
+		 */
+		this.isInOperator = isInOperator
+	}
+}
+
+/**
+ * Represents a CQL assignment operation, like col = col + x.
+ * @ignore
+ */
+class QueryAssignment {
+	constructor(sign, value, inverted) {
+		/**
+		 * Gets the sign of the assignment operation.
+		 */
+		this.sign = sign
+
+		/**
+		 * Gets the value to be assigned.
+		 */
+		this.value = value
+
+		/**
+		 * Determines whether the assignment should be inverted (prepends), e.g: col = x + col
+		 * @type {boolean}
+		 */
+		this.inverted = !!inverted
+	}
+}
+
+/**
+ * Contains functions that represents operators in a query.
+ * @alias module:mapping~q
+ * @type {Object}
+ * @property {function} in_ Represents the CQL operator "IN".
+ * @property {function} gt Represents the CQL operator greater than ">".
+ * @property {function} gte Represents the CQL operator greater than or equals to ">=" .
+ * @property {function} lt Represents the CQL operator less than "<" .
+ * @property {function} lte Represents the CQL operator less than or equals to "<=" .
+ * @property {function} notEq Represents the CQL operator not equals to "!=" .
+ * @property {function} and When applied to a property, it represents two CQL conditions on the same column separated
+ * by the logical AND operator, e.g: "col1 >= x col < y"
+ * @property {function} incr Represents the CQL increment assignment used for counters, e.g: "col = col + x"
+ * @property {function} decr Represents the CQL decrement assignment used for counters, e.g: "col = col - x"
+ * @property {function} append Represents the CQL append assignment used for collections, e.g: "col = col + x"
+ * @property {function} prepend Represents the CQL prepend assignment used for lists, e.g: "col = x + col"
+ * @property {function} remove Represents the CQL remove assignment used for collections, e.g: "col = col - x"
+ */
+const q = {
+	in_: function in_(arr) {
+		if (!Array.isArray(arr)) {
+			throw new errors.ArgumentError(
+				"IN operator supports only Array values",
+			)
+		}
+		return new QueryOperator("IN", arr, false, true)
+	},
+
+	gt: function gt(value) {
+		return new QueryOperator(">", value)
+	},
+
+	gte: function gte(value) {
+		return new QueryOperator(">=", value)
+	},
+
+	lt: function lt(value) {
+		return new QueryOperator("<", value)
+	},
+
+	lte: function lte(value) {
+		return new QueryOperator("<=", value)
+	},
+
+	notEq: function notEq(value) {
+		return new QueryOperator("!=", value)
+	},
+
+	and: function (condition1, condition2) {
+		return new QueryOperator("AND", [condition1, condition2], true)
+	},
+
+	incr: function incr(value) {
+		return new QueryAssignment("+", value)
+	},
+
+	decr: function decr(value) {
+		return new QueryAssignment("-", value)
+	},
+
+	append: function append(value) {
+		return new QueryAssignment("+", value)
+	},
+
+	prepend: function prepend(value) {
+		return new QueryAssignment("+", value, true)
+	},
+
+	remove: function remove(value) {
+		return new QueryAssignment("-", value)
+	},
+}
+
+export { q, QueryAssignment, QueryOperator }
+
+export default { q, QueryAssignment, QueryOperator }

package/driver/mapping/query-generator.js

@@ -0,0 +1,556 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import vm from "vm"
+import { QueryOperator, QueryAssignment } from "./q.js"
+import types from "../types/index.js"
+const dataTypes = types.dataTypes
+
+const vmFileName = "gen-param-getter"
+
+/**
+ * Provides methods to generate a query and parameter handlers.
+ * @ignore
+ */
+class QueryGenerator {
+	/**
+	 * Gets the SELECT query given the doc.
+	 * @param {String} tableName
+	 * @param {String} keyspace
+	 * @param {Array} propertiesInfo
+	 * @param {Array} fieldsInfo
+	 * @param {Array} orderByColumns
+	 * @param {Number|undefined} limit
+	 * @return {string}
+	 */
+	static getSelect(
+		tableName,
+		keyspace,
+		propertiesInfo,
+		fieldsInfo,
+		orderByColumns,
+		limit,
+	) {
+		let query = "SELECT "
+		query +=
+			fieldsInfo.length > 0
+				? fieldsInfo.map((p) => `"${p.columnName}"`).join(", ")
+				: "*"
+		query += ` FROM ${keyspace}.${tableName}`
+
+		if (propertiesInfo.length > 0) {
+			query += " WHERE "
+			query += QueryGenerator._getConditionWithOperators(propertiesInfo)
+		}
+
+		if (orderByColumns.length > 0) {
+			query += " ORDER BY "
+			query += orderByColumns
+				.map((order) => `"${order[0]}" ${order[1]}`)
+				.join(", ")
+		}
+
+		if (typeof limit === "number") {
+			query += " LIMIT ?"
+		}
+
+		return query
+	}
+
+	static selectParamsGetter(propertiesInfo, limit) {
+		let scriptText =
+			"(function getParametersSelect(doc, docInfo, mappingInfo) {\n"
+		scriptText += "  return ["
+
+		scriptText += QueryGenerator._valueGetterExpression(propertiesInfo)
+
+		if (typeof limit === "number") {
+			if (propertiesInfo.length > 0) {
+				scriptText += ", "
+			}
+			scriptText += `docInfo['limit']`
+		}
+
+		// Finish return statement
+		scriptText += "];\n})"
+
+		const script = new vm.Script(scriptText, { filename: vmFileName })
+		return script.runInThisContext()
+	}
+
+	/**
+	 * Gets the INSERT query and function to obtain the parameters, given the doc.
+	 * @param {TableMetadata} table
+	 * @param {String} keyspace
+	 * @param {Array} propertiesInfo
+	 * @param {Object} docInfo
+	 * @param {Boolean|undefined} ifNotExists
+	 * @return {{query: String, paramsGetter: Function, isIdempotent: Boolean}}
+	 */
+	static getInsert(table, keyspace, propertiesInfo, docInfo, ifNotExists) {
+		const ttl = docInfo && docInfo.ttl
+
+		// Not all columns are contained in the table
+		const filteredPropertiesInfo = propertiesInfo.filter(
+			(pInfo) => table.columnsByName[pInfo.columnName] !== undefined,
+		)
+
+		return {
+			query: QueryGenerator._getInsertQuery(
+				table.name,
+				keyspace,
+				filteredPropertiesInfo,
+				ifNotExists,
+				ttl,
+			),
+			paramsGetter: QueryGenerator._insertParamsGetter(
+				filteredPropertiesInfo,
+				docInfo,
+			),
+			isIdempotent: !ifNotExists,
+		}
+	}
+
+	/**
+	 * Gets the query for an insert statement.
+	 * @param {String} tableName
+	 * @param {String} keyspace
+	 * @param {Array} propertiesInfo
+	 * @param {Boolean} ifNotExists
+	 * @param {Number|undefined} ttl
+	 * @return {String}
+	 */
+	static _getInsertQuery(
+		tableName,
+		keyspace,
+		propertiesInfo,
+		ifNotExists,
+		ttl,
+	) {
+		let query = `INSERT INTO ${keyspace}.${tableName} (`
+		query += propertiesInfo
+			.map((pInfo) => `"${pInfo.columnName}"`)
+			.join(", ")
+		query += ") VALUES ("
+		query += propertiesInfo.map(() => "?").join(", ")
+		query += ")"
+
+		if (ifNotExists === true) {
+			query += " IF NOT EXISTS"
+		}
+
+		if (typeof ttl === "number") {
+			query += " USING TTL ?"
+		}
+		return query
+	}
+
+	static _insertParamsGetter(propertiesInfo, docInfo) {
+		let scriptText =
+			"(function getParametersInsert(doc, docInfo, mappingInfo) {\n"
+		scriptText += "  return ["
+
+		scriptText += QueryGenerator._valueGetterExpression(propertiesInfo)
+
+		if (docInfo && typeof docInfo.ttl === "number") {
+			scriptText += `, docInfo['ttl']`
+		}
+
+		// Finish return statement
+		scriptText += "];\n})"
+
+		const script = new vm.Script(scriptText, { filename: vmFileName })
+		return script.runInThisContext()
+	}
+
+	/**
+	 * Gets the UPDATE query and function to obtain the parameters, given the doc.
+	 * @param {TableMetadata} table
+	 * @param {String} keyspace
+	 * @param {Array} propertiesInfo
+	 * @param {Object} docInfo
+	 * @param {Array} when
+	 * @param {Boolean|undefined} ifExists
+	 * @return {{query: String, paramsGetter: Function, isIdempotent: Boolean, isCounter}}
+	 */
+	static getUpdate(table, keyspace, propertiesInfo, docInfo, when, ifExists) {
+		const ttl = docInfo && docInfo.ttl
+		const primaryKeys = new Set(
+			table.partitionKeys.concat(table.clusteringKeys).map((c) => c.name),
+		)
+		let isIdempotent = true
+		let isCounter = false
+
+		// Not all columns are contained in the table
+		const filteredPropertiesInfo = propertiesInfo.filter((pInfo) => {
+			const column = table.columnsByName[pInfo.columnName]
+			if (column === undefined) {
+				return false
+			}
+
+			if (
+				column.type.code === dataTypes.list &&
+				pInfo.value instanceof QueryAssignment
+			) {
+				// Its not idempotent when list append/prepend
+				isIdempotent = false
+			} else if (column.type.code === dataTypes.counter) {
+				// Any update on a counter table is not idempotent
+				isIdempotent = false
+				isCounter = true
+			}
+
+			return true
+		})
+
+		return {
+			query: QueryGenerator._getUpdateQuery(
+				table.name,
+				keyspace,
+				primaryKeys,
+				filteredPropertiesInfo,
+				when,
+				ifExists,
+				ttl,
+			),
+			isIdempotent: isIdempotent && when.length === 0 && !ifExists,
+			paramsGetter: QueryGenerator._updateParamsGetter(
+				primaryKeys,
+				filteredPropertiesInfo,
+				when,
+				ttl,
+			),
+			isCounter,
+		}
+	}
+
+	/**
+	 * Gets the query for an UPDATE statement.
+	 * @param {String} tableName
+	 * @param {String} keyspace
+	 * @param {Set} primaryKeys
+	 * @param {Array} propertiesInfo
+	 * @param {Object} when
+	 * @param {Boolean} ifExists
+	 * @param {Number|undefined} ttl
+	 */
+	static _getUpdateQuery(
+		tableName,
+		keyspace,
+		primaryKeys,
+		propertiesInfo,
+		when,
+		ifExists,
+		ttl,
+	) {
+		let query = `UPDATE ${keyspace}.${tableName} `
+
+		if (typeof ttl === "number") {
+			query += "USING TTL ? "
+		}
+
+		query += "SET "
+
+		query += propertiesInfo
+			.filter((p) => !primaryKeys.has(p.columnName))
+			.map((p) => {
+				if (p.value instanceof QueryAssignment) {
+					if (p.value.inverted) {
+						// e.g: prepend "col1 = ? + col1"
+						return `"${p.columnName}" = ? ${p.value.sign} "${p.columnName}"`
+					}
+					// e.g: increment "col1 = col1 + ?"
+					return `"${p.columnName}" = "${p.columnName}" ${p.value.sign} ?`
+				}
+
+				return `"${p.columnName}" = ?`
+			})
+			.join(", ")
+
+		query += " WHERE "
+		query += propertiesInfo
+			.filter((p) => primaryKeys.has(p.columnName))
+			.map((p) => `"${p.columnName}" = ?`)
+			.join(" AND ")
+
+		if (ifExists === true) {
+			query += " IF EXISTS"
+		} else if (when.length > 0) {
+			query += " IF " + QueryGenerator._getConditionWithOperators(when)
+		}
+
+		return query
+	}
+
+	/**
+	 * Returns a function to obtain the parameter values from a doc for an UPDATE statement.
+	 * @param {Set} primaryKeys
+	 * @param {Array} propertiesInfo
+	 * @param {Array} when
+	 * @param {Number|undefined} ttl
+	 * @returns {Function}
+	 */
+	static _updateParamsGetter(primaryKeys, propertiesInfo, when, ttl) {
+		let scriptText =
+			"(function getParametersUpdate(doc, docInfo, mappingInfo) {\n"
+		scriptText += "  return ["
+
+		if (typeof ttl === "number") {
+			scriptText += `docInfo['ttl'], `
+		}
+
+		// Assignment clause
+		scriptText += QueryGenerator._assignmentGetterExpression(
+			propertiesInfo.filter((p) => !primaryKeys.has(p.columnName)),
+		)
+		scriptText += ", "
+
+		// Where clause
+		scriptText += QueryGenerator._valueGetterExpression(
+			propertiesInfo.filter((p) => primaryKeys.has(p.columnName)),
+		)
+
+		// Condition clause
+		if (when.length > 0) {
+			scriptText +=
+				", " +
+				QueryGenerator._valueGetterExpression(when, "docInfo.when")
+		}
+
+		// Finish return statement
+		scriptText += "];\n})"
+
+		const script = new vm.Script(scriptText, { filename: vmFileName })
+		return script.runInThisContext()
+	}
+
+	/**
+	 * Gets the DELETE query and function to obtain the parameters, given the doc.
+	 * @param {TableMetadata} table
+	 * @param {String} keyspace
+	 * @param {Array} propertiesInfo
+	 * @param {Object} docInfo
+	 * @param {Array} when
+	 * @param {Boolean|undefined} ifExists
+	 * @return {{query: String, paramsGetter: Function, isIdempotent}}
+	 */
+	static getDelete(table, keyspace, propertiesInfo, docInfo, when, ifExists) {
+		const deleteOnlyColumns = docInfo && docInfo.deleteOnlyColumns
+		const primaryKeys = new Set(
+			table.partitionKeys.concat(table.clusteringKeys).map((c) => c.name),
+		)
+
+		const filteredPropertiesInfo = propertiesInfo.filter(
+			(pInfo) => table.columnsByName[pInfo.columnName] !== undefined,
+		)
+
+		return {
+			query: QueryGenerator._getDeleteQuery(
+				table.name,
+				keyspace,
+				primaryKeys,
+				filteredPropertiesInfo,
+				when,
+				ifExists,
+				deleteOnlyColumns,
+			),
+			paramsGetter: QueryGenerator._deleteParamsGetter(
+				primaryKeys,
+				filteredPropertiesInfo,
+				when,
+			),
+			isIdempotent: when.length === 0 && !ifExists,
+		}
+	}
+
+	/**
+	 * Gets the query for an UPDATE statement.
+	 * @param {String} tableName
+	 * @param {String} keyspace
+	 * @param {Set} primaryKeys
+	 * @param {Array} propertiesInfo
+	 * @param {Array} when
+	 * @param {Boolean} ifExists
+	 * @param {Boolean} deleteOnlyColumns
+	 * @private
+	 * @return {String}
+	 */
+	static _getDeleteQuery(
+		tableName,
+		keyspace,
+		primaryKeys,
+		propertiesInfo,
+		when,
+		ifExists,
+		deleteOnlyColumns,
+	) {
+		let query = "DELETE"
+
+		if (deleteOnlyColumns) {
+			const columnsToDelete = propertiesInfo
+				.filter((p) => !primaryKeys.has(p.columnName))
+				.map((p) => `"${p.columnName}"`)
+				.join(", ")
+
+			if (columnsToDelete !== "") {
+				query += " " + columnsToDelete
+			}
+		}
+
+		query += ` FROM ${keyspace}.${tableName} WHERE `
+		query += propertiesInfo
+			.filter((p) => primaryKeys.has(p.columnName))
+			.map((p) => `"${p.columnName}" = ?`)
+			.join(" AND ")
+
+		if (ifExists === true) {
+			query += " IF EXISTS"
+		} else if (when.length > 0) {
+			query += " IF " + QueryGenerator._getConditionWithOperators(when)
+		}
+
+		return query
+	}
+	/**
+	 * Returns a function to obtain the parameter values from a doc for an UPDATE statement.
+	 * @param {Set} primaryKeys
+	 * @param {Array} propertiesInfo
+	 * @param {Array} when
+	 * @returns {Function}
+	 */
+	static _deleteParamsGetter(primaryKeys, propertiesInfo, when) {
+		let scriptText =
+			"(function getParametersDelete(doc, docInfo, mappingInfo) {\n"
+		scriptText += "  return ["
+
+		// Where clause
+		scriptText += QueryGenerator._valueGetterExpression(
+			propertiesInfo.filter((p) => primaryKeys.has(p.columnName)),
+		)
+
+		// Condition clause
+		if (when.length > 0) {
+			scriptText +=
+				", " +
+				QueryGenerator._valueGetterExpression(when, "docInfo.when")
+		}
+
+		// Finish return statement
+		scriptText += "];\n})"
+
+		const script = new vm.Script(scriptText, { filename: vmFileName })
+		return script.runInThisContext()
+	}
+
+	/**
+	 * Gets a string containing the doc properties to get.
+	 * @param {Array} propertiesInfo
+	 * @param {String} [objectName='doc']
+	 * @return {string}
+	 * @private
+	 */
+	static _valueGetterExpression(propertiesInfo, objectName) {
+		objectName = objectName || "doc"
+
+		return propertiesInfo
+			.map((p) =>
+				QueryGenerator._valueGetterSingle(
+					`${objectName}['${p.propertyName}']`,
+					p.propertyName,
+					p.value,
+					p.fromModel,
+				),
+			)
+			.join(", ")
+	}
+
+	static _valueGetterSingle(prefix, propName, value, fromModelFn) {
+		let valueGetter = prefix
+
+		if (value instanceof QueryOperator) {
+			if (value.hasChildValues) {
+				return (
+					`${QueryGenerator._valueGetterSingle(`${prefix}.value[0]`, propName, value.value[0], fromModelFn)}` +
+					`, ${QueryGenerator._valueGetterSingle(`${prefix}.value[1]`, propName, value.value[1], fromModelFn)}`
+				)
+			}
+
+			valueGetter = `${prefix}.value`
+
+			if (value.isInOperator && fromModelFn) {
+				// Transform each individual value
+				return `${valueGetter}.map(v => ${QueryGenerator._getMappingFunctionCall(propName, "v")})`
+			}
+		}
+
+		return !fromModelFn
+			? valueGetter
+			: QueryGenerator._getMappingFunctionCall(propName, valueGetter)
+	}
+
+	/**
+	 * Gets a string containing the doc properties to SET, considering QueryAssignment instances.
+	 * @param {Array} propertiesInfo
+	 * @param {String} [prefix='doc']
+	 * @return {string}
+	 * @private
+	 */
+	static _assignmentGetterExpression(propertiesInfo, prefix) {
+		prefix = prefix || "doc"
+
+		return propertiesInfo
+			.map((p) => {
+				const valueGetter = `${prefix}['${p.propertyName}']${p.value instanceof QueryAssignment ? ".value" : ""}`
+				if (p.fromModel) {
+					return QueryGenerator._getMappingFunctionCall(
+						p.propertyName,
+						valueGetter,
+					)
+				}
+				return valueGetter
+			})
+			.join(", ")
+	}
+
+	static _getConditionWithOperators(propertiesInfo) {
+		return propertiesInfo
+			.map((p) =>
+				QueryGenerator._getSingleCondition(p.columnName, p.value),
+			)
+			.join(" AND ")
+	}
+
+	static _getMappingFunctionCall(propName, valueGetter) {
+		return `mappingInfo.getFromModelFn('${propName}')(${valueGetter})`
+	}
+
+	static _getSingleCondition(columnName, value) {
+		if (value instanceof QueryOperator) {
+			if (value.hasChildValues) {
+				return (
+					`${QueryGenerator._getSingleCondition(columnName, value.value[0])}` +
+					` ${value.key} ${QueryGenerator._getSingleCondition(columnName, value.value[1])}`
+				)
+			}
+			return `"${columnName}" ${value.key} ?`
+		}
+		return `"${columnName}" = ?`
+	}
+}
+
+export default QueryGenerator