@ragestudio/scylla-odm 0.22.2 → 0.22.4

package/driver/mapping/model-mapping-info.js

@@ -0,0 +1,225 @@
+/*
+ * 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 { TableMappings, DefaultTableMappings } from "./table-mappings.js"
+
+/**
+ * Represents the parsed user information of the table mappings of a model.
+ * @ignore
+ */
+class ModelMappingInfo {
+	/**
+	 * @param {String} keyspace
+	 * @param {Array<{name, isView}>} tables
+	 * @param {TableMappings} mappings
+	 * @param {Map<String,ModelColumnInfo>} columns
+	 */
+	constructor(keyspace, tables, mappings, columns) {
+		this.keyspace = keyspace
+		this.tables = tables
+		this._mappings = mappings
+		this._columns = columns
+
+		// Define a map of column information per property name
+		/** @type {Map<String, ModelColumnInfo>} */
+		this._documentProperties = new Map()
+		for (const modelColumnInfo of columns.values()) {
+			this._documentProperties.set(
+				modelColumnInfo.propertyName,
+				modelColumnInfo,
+			)
+		}
+	}
+
+	getColumnName(propName) {
+		const modelColumnInfo = this._documentProperties.get(propName)
+		if (modelColumnInfo !== undefined) {
+			// There is an specific name transformation between the column name and the property name
+			return modelColumnInfo.columnName
+		}
+		// Rely on the TableMappings (i.e. maybe there is a convention defined for this property)
+		return this._mappings.getColumnName(propName)
+	}
+
+	getPropertyName(columnName) {
+		const modelColumnInfo = this._columns.get(columnName)
+		if (modelColumnInfo !== undefined) {
+			// There is an specific name transformation between the column name and the property name
+			return modelColumnInfo.propertyName
+		}
+		// Rely on the TableMappings (i.e. maybe there is a convention defined for this column)
+		return this._mappings.getPropertyName(columnName)
+	}
+
+	getFromModelFn(propName) {
+		const modelColumnInfo = this._documentProperties.get(propName)
+		return modelColumnInfo !== undefined ? modelColumnInfo.fromModel : null
+	}
+
+	getToModelFn(columnName) {
+		const modelColumnInfo = this._columns.get(columnName)
+		return modelColumnInfo !== undefined ? modelColumnInfo.toModel : null
+	}
+
+	newInstance() {
+		return this._mappings.newObjectInstance()
+	}
+
+	/**
+	 * Parses the user options into a map of model names and ModelMappingInfo.
+	 * @param {MappingOptions} options
+	 * @param {String} currentKeyspace
+	 * @returns {Map<String, ModelMappingInfo>}
+	 */
+	static parse(options, currentKeyspace) {
+		const result = new Map()
+		if (!options || !options.models) {
+			return result
+		}
+
+		Object.keys(options.models).forEach((modelName) => {
+			const modelOptions = options.models[modelName]
+			result.set(
+				modelName,
+				ModelMappingInfo._create(
+					modelName,
+					currentKeyspace,
+					modelOptions,
+				),
+			)
+		})
+
+		return result
+	}
+
+	static _create(modelName, currentKeyspace, modelOptions) {
+		if (!currentKeyspace && (!modelOptions || !modelOptions.keyspace)) {
+			throw new Error(
+				"You should specify the keyspace of the model in the MappingOptions when the Client is not using a keyspace",
+			)
+		}
+
+		if (!modelOptions) {
+			return ModelMappingInfo.createDefault(modelName, currentKeyspace)
+		}
+
+		let tables
+
+		if (modelOptions.tables && modelOptions.tables.length > 0) {
+			tables = modelOptions.tables.map((item) => {
+				const table = { name: null, isView: false }
+				if (typeof item === "string") {
+					table.name = item
+				} else if (item) {
+					table.name = item.name
+					table.isView = !!item.isView
+				}
+
+				if (!table.name) {
+					throw new Error(
+						`Table name not specified for model '${modelName}'`,
+					)
+				}
+
+				return table
+			})
+		} else {
+			tables = [{ name: modelName, isView: false }]
+		}
+
+		if (
+			modelOptions.mappings &&
+			!(modelOptions.mappings instanceof TableMappings)
+		) {
+			throw new Error("mappings should be an instance of TableMappings")
+		}
+
+		const columns = new Map()
+		if (
+			modelOptions.columns !== null &&
+			typeof modelOptions.columns === "object"
+		) {
+			Object.keys(modelOptions.columns).forEach((columnName) => {
+				columns.set(
+					columnName,
+					ModelColumnInfo.parse(
+						columnName,
+						modelOptions.columns[columnName],
+					),
+				)
+			})
+		}
+
+		return new ModelMappingInfo(
+			modelOptions.keyspace || currentKeyspace,
+			tables,
+			modelOptions.mappings || new DefaultTableMappings(),
+			columns,
+		)
+	}
+
+	static createDefault(modelName, currentKeyspace) {
+		return new ModelMappingInfo(
+			currentKeyspace,
+			[{ name: modelName, isView: false }],
+			new DefaultTableMappings(),
+			new Map(),
+		)
+	}
+}
+
+class ModelColumnInfo {
+	constructor(columnName, propertyName, toModel, fromModel) {
+		this.columnName = columnName
+		this.propertyName = propertyName
+
+		if (toModel && typeof toModel !== "function") {
+			throw new TypeError(
+				`toModel type for property '${propertyName}' should be a function (obtained ${typeof toModel})`,
+			)
+		}
+
+		if (fromModel && typeof fromModel !== "function") {
+			throw new TypeError(
+				`fromModel type for property '${propertyName}' should be a function (obtained ${typeof fromModel})`,
+			)
+		}
+
+		this.toModel = toModel
+		this.fromModel = fromModel
+	}
+
+	static parse(columnName, value) {
+		if (!value) {
+			return new ModelColumnInfo(columnName, columnName)
+		}
+
+		if (typeof value === "string") {
+			return new ModelColumnInfo(columnName, value)
+		}
+
+		return new ModelColumnInfo(
+			columnName,
+			value.name || columnName,
+			value.toModel,
+			value.fromModel,
+		)
+	}
+}
+
+export default ModelMappingInfo

package/driver/mapping/object-selector.js

@@ -0,0 +1,417 @@
+/*
+ * 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.
+ */
+
+const keyMatches = {
+	all: 1,
+	none: 0,
+	some: -1,
+}
+
+/**
+ * Provides utility methods to choose the correct tables and views that should be included in a statement.
+ * @ignore
+ */
+class ObjectSelector {
+	/**
+	 * Gets the table/view that should be used to execute the SELECT query.
+	 * @param {Client} client
+	 * @param {ModelMappingInfo} info
+	 * @param {Boolean} allPKsDefined
+	 * @param {Array} propertiesInfo
+	 * @param {Array} fieldsInfo
+	 * @param {Array<Array<String>>} orderByColumns
+	 * @return {Promise<String>} A promise that resolves to a table names.
+	 */
+	static getForSelect(
+		client,
+		info,
+		allPKsDefined,
+		propertiesInfo,
+		fieldsInfo,
+		orderByColumns,
+	) {
+		return Promise.all(
+			info.tables.map((t) => {
+				if (t.isView) {
+					return client.metadata.getMaterializedView(
+						info.keyspace,
+						t.name,
+					)
+				}
+				return client.metadata.getTable(info.keyspace, t.name)
+			}),
+		).then((tables) => {
+			for (let i = 0; i < tables.length; i++) {
+				const table = tables[i]
+				if (table === null) {
+					throw new Error(
+						`Table "${info.tables[i].name}" could not be retrieved`,
+					)
+				}
+
+				if (
+					keysAreIncluded(table.partitionKeys, propertiesInfo) !==
+					keyMatches.all
+				) {
+					// Not all the partition keys are covered
+					continue
+				}
+
+				if (allPKsDefined) {
+					if (
+						keysAreIncluded(
+							table.clusteringKeys,
+							propertiesInfo,
+						) !== keyMatches.all
+					) {
+						// All clustering keys should be included as allPKsDefined flag is set
+						continue
+					}
+				}
+
+				if (propertiesInfo.length > table.partitionKeys.length) {
+					// Check that the Where clause is composed by partition and clustering keys
+					const allPropertiesArePrimaryKeys = propertiesInfo.reduce(
+						(acc, p) =>
+							acc &&
+							(contains(
+								table.partitionKeys,
+								(c) => c.name === p.columnName,
+							) ||
+								contains(
+									table.clusteringKeys,
+									(c) => c.name === p.columnName,
+								)),
+						true,
+					)
+
+					if (!allPropertiesArePrimaryKeys) {
+						continue
+					}
+				}
+
+				// All fields must be contained
+				const containsAllFields = fieldsInfo.reduce(
+					(acc, p) =>
+						acc && table.columnsByName[p.columnName] !== undefined,
+					true,
+				)
+
+				if (!containsAllFields) {
+					continue
+				}
+
+				// CQL:
+				// - "ORDER BY" is currently only supported on the clustered columns of the PRIMARY KEY
+				// - "ORDER BY" currently only support the ordering of columns following their declared order in
+				//   the PRIMARY KEY
+				//
+				// In the mapper, we validate that the ORDER BY columns appear in the same order as in the clustering keys
+				const containsAllOrderByColumns = orderByColumns.reduce(
+					(acc, order, index) => {
+						if (!acc) {
+							return false
+						}
+
+						const ck = table.clusteringKeys[index]
+
+						return ck && ck.name === order[0]
+					},
+					true,
+				)
+
+				if (!containsAllOrderByColumns) {
+					continue
+				}
+
+				return table.name
+			}
+
+			let message = `No table matches the filter (${allPKsDefined ? "all PKs have to be specified" : "PKs"}): [${propertiesInfo.map(
+				(p) => p.columnName,
+			)}]`
+
+			if (fieldsInfo.length > 0) {
+				message += `; fields: [${fieldsInfo.map((p) => p.columnName)}]`
+			}
+			if (orderByColumns.length > 0) {
+				message += `; orderBy: [${orderByColumns.map((item) => item[0])}]`
+			}
+
+			throw new Error(message)
+		})
+	}
+
+	/** Returns the name of the first table */
+	static getForSelectAll(info) {
+		return info.tables[0].name
+	}
+
+	/**
+	 * Gets the tables that should be used to execute the INSERT query.
+	 * @param {Client} client
+	 * @param {ModelMappingInfo} info
+	 * @param {Array} propertiesInfo
+	 * @return {Promise<Array<TableMetadata>>} A promise that resolves to an Array of tables.
+	 */
+	static getForInsert(client, info, propertiesInfo) {
+		return Promise.all(
+			info.tables
+				.filter((t) => !t.isView)
+				.map((t) => client.metadata.getTable(info.keyspace, t.name)),
+		).then((tables) => {
+			const filteredTables = tables.filter((table, i) => {
+				if (table === null) {
+					throw new Error(
+						`Table "${info.tables[i].name}" could not be retrieved`,
+					)
+				}
+
+				if (
+					keysAreIncluded(table.partitionKeys, propertiesInfo) !==
+					keyMatches.all
+				) {
+					// Not all the partition keys are covered
+					return false
+				}
+
+				const clusteringKeyMatches = keysAreIncluded(
+					table.clusteringKeys,
+					propertiesInfo,
+				)
+
+				// All clustering keys should be included or it can be inserting a static column value
+				if (clusteringKeyMatches === keyMatches.all) {
+					return true
+				}
+
+				if (clusteringKeyMatches === keyMatches.some) {
+					return false
+				}
+
+				const staticColumns = staticColumnCount(table)
+				return (
+					propertiesInfo.length ===
+						table.partitionKeys.length + staticColumns &&
+					staticColumns > 0
+				)
+			})
+
+			if (filteredTables.length === 0) {
+				throw new Error(
+					`No table matches (all PKs have to be specified) fields: [${propertiesInfo.map(
+						(p) => p.columnName,
+					)}]`,
+				)
+			}
+
+			return filteredTables
+		})
+	}
+
+	/**
+	 * Gets the tables that should be used to execute the UPDATE query.
+	 * @param {Client} client
+	 * @param {ModelMappingInfo} info
+	 * @param {Array} propertiesInfo
+	 * @param {Array} when
+	 * @return {Promise<Array<TableMetadata>>} A promise that resolves to an Array of tables.
+	 */
+	static getForUpdate(client, info, propertiesInfo, when) {
+		return Promise.all(
+			info.tables
+				.filter((t) => !t.isView)
+				.map((t) => client.metadata.getTable(info.keyspace, t.name)),
+		).then((tables) => {
+			const filteredTables = tables.filter((table, i) => {
+				if (table === null) {
+					throw new Error(
+						`Table "${info.tables[i].name}" could not be retrieved`,
+					)
+				}
+
+				if (
+					keysAreIncluded(table.partitionKeys, propertiesInfo) !==
+					keyMatches.all
+				) {
+					// Not all the partition keys are covered
+					return false
+				}
+
+				const clusteringKeyMatches = keysAreIncluded(
+					table.clusteringKeys,
+					propertiesInfo,
+				)
+
+				// All clustering keys should be included or it can be updating a static column value
+				if (clusteringKeyMatches === keyMatches.some) {
+					return false
+				}
+
+				if (
+					clusteringKeyMatches === keyMatches.none &&
+					!hasStaticColumn(table)
+				) {
+					return false
+				}
+
+				const applicableColumns = propertiesInfo.reduce(
+					(acc, p) =>
+						acc +
+						(table.columnsByName[p.columnName] !== undefined
+							? 1
+							: 0),
+					0,
+				)
+
+				if (
+					applicableColumns <=
+					table.partitionKeys.length + table.clusteringKeys.length
+				) {
+					if (
+						!hasStaticColumn(table) ||
+						applicableColumns <= table.partitionKeys.length
+					) {
+						// UPDATE statement does not contain columns to SET
+						return false
+					}
+				}
+
+				// "when" conditions should be contained in the table
+				return when.reduce(
+					(acc, p) =>
+						acc && table.columnsByName[p.columnName] !== undefined,
+					true,
+				)
+			})
+
+			if (filteredTables.length === 0) {
+				let message = `No table matches (all PKs and columns to set have to be specified) fields: [${propertiesInfo.map(
+					(p) => p.columnName,
+				)}]`
+
+				if (when.length > 0) {
+					message += `; condition: [${when.map((p) => p.columnName)}]`
+				}
+
+				throw new Error(message)
+			}
+
+			return filteredTables
+		})
+	}
+
+	/**
+	 * Gets the tables that should be used to execute the DELETE query.
+	 * @param {Client} client
+	 * @param {ModelMappingInfo} info
+	 * @param {Array} propertiesInfo
+	 * @param {Array} when
+	 * @return {Promise<Array<TableMetadata>>} A promise that resolves to an Array of tables.
+	 */
+	static getForDelete(client, info, propertiesInfo, when) {
+		return Promise.all(
+			info.tables
+				.filter((t) => !t.isView)
+				.map((t) => client.metadata.getTable(info.keyspace, t.name)),
+		).then((tables) => {
+			const filteredTables = tables.filter((table, i) => {
+				if (table === null) {
+					throw new Error(
+						`Table "${info.tables[i].name}" could not be retrieved`,
+					)
+				}
+
+				// All partition and clustering keys from the table should be included in the document
+				const keyNames = table.partitionKeys
+					.concat(table.clusteringKeys)
+					.map((k) => k.name)
+				const columns = propertiesInfo.map((p) => p.columnName)
+
+				for (let i = 0; i < keyNames.length; i++) {
+					if (columns.indexOf(keyNames[i]) === -1) {
+						return false
+					}
+				}
+
+				// "when" conditions should be contained in the table
+				return when.reduce(
+					(acc, p) =>
+						acc && table.columnsByName[p.columnName] !== undefined,
+					true,
+				)
+			})
+
+			if (filteredTables.length === 0) {
+				let message = `No table matches (all PKs have to be specified) fields: [${propertiesInfo.map(
+					(p) => p.columnName,
+				)}]`
+
+				if (when.length > 0) {
+					message += `; condition: [${when.map((p) => p.columnName)}]`
+				}
+
+				throw new Error(message)
+			}
+
+			return filteredTables
+		})
+	}
+}
+
+function contains(arr, fn) {
+	return arr.filter(fn).length > 0
+}
+
+/**
+ * Returns the amount of matches for a given key
+ * @private
+ * @param {Array} keys
+ * @param {Array} propertiesInfo
+ */
+function keysAreIncluded(keys, propertiesInfo) {
+	if (keys.length === 0) {
+		return keyMatches.all
+	}
+
+	// Filtering by name might look slow / ineffective to using hash maps
+	// but we expect `keys` and `propertiesInfo` to contain only few items
+	const matches = propertiesInfo.reduce(
+		(acc, p) =>
+			acc + (contains(keys, (k) => p.columnName === k.name) ? 1 : 0),
+		0,
+	)
+	if (matches === 0) {
+		return keyMatches.none
+	}
+
+	return matches === keys.length ? keyMatches.all : keyMatches.some
+}
+
+function hasStaticColumn(table) {
+	return staticColumnCount(table) > 0
+}
+
+function staticColumnCount(table) {
+	return table.columns.reduce(
+		(acc, column) => acc + (column.isStatic ? 1 : 0),
+		0,
+	)
+}
+
+export default ObjectSelector