@ragestudio/scylla-odm 0.22.2 → 0.22.3

package/driver/types/tuple.js

@@ -0,0 +1,103 @@
+/*
+ * 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.
+ */
+
+/** @module types */
+
+/**
+ * Creates a new sequence of immutable objects with the parameters provided.
+ * @class
+ * @classdesc A tuple is a sequence of immutable objects.
+ * Tuples are sequences, just like [Arrays]{@link Array}. The only difference is that tuples can't be changed.
+ * <p>
+ *   As tuples can be used as a Map keys, the {@link Tuple#toString toString()} method calls toString of each element,
+ *   to try to get a unique string key.
+ * </p>
+ * @param args The sequence elements as arguments.
+ * @constructor
+ */
+function Tuple(...args) {
+	/**
+	 * Immutable elements of Tuple object.
+	 * @type Array
+	 */
+	this.elements = args
+
+	if (this.elements.length === 0) {
+		throw new TypeError("Tuple must contain at least one value")
+	}
+
+	/**
+	 * Returns the number of the elements.
+	 * @type Number
+	 */
+	this.length = this.elements.length
+}
+
+/**
+ * Creates a new instance of a tuple based on the Array
+ * @param {Array} elements
+ * @returns {Tuple}
+ */
+Tuple.fromArray = function (elements) {
+	// Apply the elements Array as parameters
+	return new Tuple(...elements)
+}
+
+/**
+ * Returns the value located at the index.
+ * @param {Number} index Element index
+ */
+Tuple.prototype.get = function (index) {
+	return this.elements[index || 0]
+}
+
+/**
+ * Returns the string representation of the sequence surrounded by parenthesis, ie: (1, 2).
+ * <p>
+ *   The returned value attempts to be a unique string representation of its values.
+ * </p>
+ * @returns {string}
+ */
+Tuple.prototype.toString = function () {
+	return (
+		"(" +
+		this.elements.reduce(function (prev, x, i) {
+			return prev + (i > 0 ? "," : "") + x.toString()
+		}, "") +
+		")"
+	)
+}
+
+/**
+ * Returns the Array representation of the sequence.
+ * @returns {Array}
+ */
+Tuple.prototype.toJSON = function () {
+	return this.elements
+}
+
+/**
+ * Gets the elements as an array
+ * @returns {Array}
+ */
+Tuple.prototype.values = function () {
+	// Clone the elements
+	return this.elements.slice(0)
+}
+
+export default Tuple

package/driver/types/uuid.js

@@ -0,0 +1,160 @@
+/*
+ * 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 crypto from "crypto"
+import utils from "../utils.js"
+
+/** @module types */
+
+/**
+ * Creates a new instance of Uuid based on a Buffer
+ * @class
+ * @classdesc Represents an immutable universally unique identifier (UUID). A UUID represents a 128-bit value.
+ * @param {Buffer} buffer The 16-length buffer.
+ * @constructor
+ */
+function Uuid(buffer) {
+	if (!buffer || buffer.length !== 16) {
+		throw new Error("You must provide a buffer containing 16 bytes")
+	}
+	this.buffer = buffer
+}
+
+/**
+ * Parses a string representation of a Uuid
+ * @param {String} value
+ * @returns {Uuid}
+ */
+Uuid.fromString = function (value) {
+	//36 chars: 32 + 4 hyphens
+	if (typeof value !== "string" || value.length !== 36) {
+		throw new Error(
+			"Invalid string representation of Uuid, it should be in the 00000000-0000-0000-0000-000000000000",
+		)
+	}
+	return new Uuid(utils.allocBufferFromString(value.replace(/-/g, ""), "hex"))
+}
+
+/**
+ * Creates a new random (version 4) Uuid.
+ * @param {function} [callback] Optional callback to be invoked with the error as first parameter and the created Uuid as
+ * second parameter.
+ * @returns {Uuid}
+ */
+Uuid.random = function (callback) {
+	if (callback) {
+		getRandomBytes(function (err, buffer) {
+			if (err) {
+				return callback(err)
+			}
+			return callback(null, createUuidFromBuffer(buffer))
+		})
+	} else {
+		const buffer = getRandomBytes()
+		return createUuidFromBuffer(buffer)
+	}
+}
+
+/**
+ * Gets the bytes representation of a Uuid
+ * @returns {Buffer}
+ */
+Uuid.prototype.getBuffer = function () {
+	return this.buffer
+}
+/**
+ * Compares this object to the specified object.
+ * The result is true if and only if the argument is not null, is a UUID object, and contains the same value, bit for bit, as this UUID.
+ * @param {Uuid} other The other value to test for equality.
+ */
+Uuid.prototype.equals = function (other) {
+	return other instanceof Uuid && this.buffer.equals(other.buffer)
+}
+
+/**
+ * Returns a string representation of the value of this Uuid instance.
+ * 32 hex separated by hyphens, in the form of 00000000-0000-0000-0000-000000000000.
+ * @returns {String}
+ */
+Uuid.prototype.toString = function () {
+	//32 hex representation of the Buffer
+	const hexValue = getHex(this)
+	return (
+		hexValue.substr(0, 8) +
+		"-" +
+		hexValue.substr(8, 4) +
+		"-" +
+		hexValue.substr(12, 4) +
+		"-" +
+		hexValue.substr(16, 4) +
+		"-" +
+		hexValue.substr(20, 12)
+	)
+}
+
+/**
+ * Provide the name of the constructor and the string representation
+ * @returns {string}
+ */
+Uuid.prototype.inspect = function () {
+	return this.constructor.name + ": " + this.toString()
+}
+
+/**
+ * Returns the string representation.
+ * Method used by the native JSON.stringify() to serialize this instance.
+ */
+Uuid.prototype.toJSON = function () {
+	return this.toString()
+}
+
+/**
+ * Returns new Uuid
+ * @private
+ * @returns {Uuid}
+ */
+function createUuidFromBuffer(buffer) {
+	//clear the version
+	buffer[6] &= 0x0f
+	//set the version 4
+	buffer[6] |= 0x40
+	//clear the variant
+	buffer[8] &= 0x3f
+	//set the IETF variant
+	buffer[8] |= 0x80
+	return new Uuid(buffer)
+}
+
+/**
+ * @private
+ * @returns {String} 32 hex representation of the instance, without separators
+ */
+function getHex(uuid) {
+	return uuid.buffer.toString("hex")
+}
+
+/**
+ * Gets a crypto generated 16 bytes
+ * @private
+ * @returns {Buffer}
+ */
+function getRandomBytes(cb) {
+	return crypto.randomBytes(16, cb)
+}
+
+export default Uuid

package/driver/types/vector.js

@@ -0,0 +1,130 @@
+/*
+ * 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.
+ */
+/** @module types */
+
+import util from "node:util"
+
+class Vector {
+	/**
+	 *
+	 * @param {Float32Array | Array<any>} elements
+	 * @param {string} [subtype]
+	 */
+	constructor(elements, subtype) {
+		if (elements instanceof Float32Array) {
+			this.elements = Array.from(elements)
+		} else if (Array.isArray(elements)) {
+			this.elements = elements
+		} else {
+			throw new TypeError(
+				"Vector must be constructed with a Float32Array or an Array",
+			)
+		}
+		if (this.elements.length === 0) {
+			throw new TypeError("Vector must contain at least one value")
+		}
+		/**
+		 * Returns the number of the elements.
+		 * @type Number
+		 */
+		this.length = this.elements.length
+		this.subtype = subtype
+		return new Proxy(this, {
+			get: function (obj, key) {
+				if (key === "IDENTITY") {
+					return "Vector"
+				} else if (
+					typeof key === "string" &&
+					Number.isInteger(Number(key))
+				) // key is an index
+				{
+					return obj.elements[key]
+				}
+				return obj[key]
+			},
+			set: function (obj, key, value) {
+				if (
+					typeof key === "string" &&
+					Number.isInteger(Number(key))
+				) // key is an index
+				{
+					return (obj.elements[key] = value)
+				}
+				return (obj[key] = value)
+			},
+			ownKeys: function (obj) {
+				return Reflect.ownKeys(elements)
+			},
+			getOwnPropertyDescriptor(target, key) {
+				if (typeof key === "string" && Number.isInteger(Number(key))) {
+					// array index
+					return { enumerable: true, configurable: true }
+				}
+				return Reflect.getOwnPropertyDescriptor(target, key)
+			},
+		})
+	}
+	/**
+	 * Returns the string representation of the vector.
+	 * @returns {string}
+	 */
+	toString() {
+		return "[".concat(this.elements.toString(), "]")
+	}
+	/**
+	 *
+	 * @param {number} index
+	 */
+	at(index) {
+		return this.elements[index]
+	}
+
+	/**
+	 *
+	 * @returns {IterableIterator<any>} an iterator over the elements of the vector
+	 */
+	[Symbol.iterator]() {
+		return this.elements[Symbol.iterator]()
+	}
+
+	static get [Symbol.species]() {
+		return Vector
+	}
+
+	forEach(callback) {
+		return this.elements.forEach(callback)
+	}
+
+	/**
+	 * @returns {string | undefined} get the subtype string, e.g., "float", but it's optional so it can return undefined
+	 */
+	getSubtype() {
+		return this.subtype
+	}
+}
+
+Object.defineProperty(Vector, Symbol.hasInstance, {
+	value: function (i) {
+		return (
+			(util.types.isProxy(i) && i.IDENTITY === "Vector") ||
+			i instanceof Float32Array
+		)
+	},
+})
+
+export default Vector

package/driver/types/version-number.js

@@ -0,0 +1,153 @@
+/*
+ * 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 _versionPattern =
+	/(\d+)\.(\d+)(?:\.(\d+))?(?:\.(\d+)?)?(?:[-~]([\w+]*(?:-\w[.\w]*)*))?(?:\+([.\w]+))?/
+
+/**
+ * Represents a version number in the form of X.Y.Z with optional pre-release and build metadata.
+ *
+ * Version numbers compare the usual way, the major version number (X) is compared first, then
+ * the minor one (Y) and then the patch level one (Z).  If pre-release or other build metadata
+ * is present for a version, that version is considered less than an otherwise equivalent version
+ * that doesn't have these labels, otherwise they are considered equal.
+ *
+ * As of initial implementation versions are only compared against those with at most patch versions
+ * more refined comparisons are not needed.
+ *
+ * @property {Number} major The major version, X of X.Y.Z.
+ * @property {Number} minor The minor version, Y of X.Y.Z.
+ * @property {Number} patch The patch version, Z of X.Y.Z.
+ * @property {Number} dsePatch The dsePatch version, A of X.Y.Z.A or undefined if not present.
+ * @property {String[]} preReleases Prerelease indicators if present, i.e. SNAPSHOT of X.Y.Z-SNAPSHOT.
+ * @property {String} build Build string if present, i.e. build1 of X.Y.Z+build1.
+ *
+ * @ignore
+ */
+class VersionNumber {
+	constructor(major, minor, patch, dsePatch, preReleases, build) {
+		this.major = major
+		this.minor = minor
+		this.patch = patch
+		this.dsePatch = dsePatch
+		this.preReleases = preReleases
+		this.build = build
+	}
+
+	/**
+	 * @return {String} String representation of this version.
+	 */
+	toString() {
+		let str = this.major + "." + this.minor
+		if (this.patch !== undefined) {
+			str += "." + this.patch
+		}
+		if (this.dsePatch !== undefined) {
+			str += "." + this.dsePatch
+		}
+		if (this.preReleases !== undefined) {
+			this.preReleases.forEach((preRelease) => {
+				str += "-" + preRelease
+			})
+		}
+		if (this.build) {
+			str += "+" + this.build
+		}
+		return str
+	}
+
+	/**
+	 * Compares this version with the provided version.
+	 * @param {VersionNumber} other
+	 * @return {Number} -1 if less than other, 0 if equal, 1 if greater than.
+	 */
+	compare(other) {
+		if (this.major < other.major) {
+			return -1
+		} else if (this.major > other.major) {
+			return 1
+		} else if (this.minor < other.minor) {
+			return -1
+		} else if (this.minor > other.minor) {
+			return 1
+		}
+
+		// sanitize patch by setting to 0 if undefined.
+		const thisPatch = this.patch || 0
+		const otherPatch = other.patch || 0
+		if (thisPatch < otherPatch) {
+			return -1
+		} else if (thisPatch > otherPatch) {
+			return 1
+		}
+
+		// if dsePatch is set in one case, but not other, consider the one where it is set as greater.
+		if (this.dsePatch === undefined) {
+			if (other.dsePatch !== undefined) {
+				return -1
+			}
+		} else if (other.dsePatch === undefined) {
+			return 1
+		} else {
+			if (this.dsePatch < other.dsePatch) {
+				return -1
+			} else if (this.dsePatch > other.dsePatch) {
+				return 1
+			}
+		}
+
+		// If prereleases are present, consider less than those that don't have any.
+		if (this.preReleases === undefined) {
+			if (other.preReleases !== undefined) {
+				return 1
+			}
+		} else if (other.preReleases === undefined) {
+			return -1
+		}
+
+		// Don't consider build.
+		return 0
+	}
+
+	static parse(version) {
+		if (!version) {
+			return null
+		}
+
+		const match = version.match(_versionPattern)
+		if (match) {
+			const major = parseInt(match[1], 10)
+			const minor = parseInt(match[2], 10)
+			const patch = match[3] ? parseInt(match[3], 10) : undefined
+			const dsePatch = match[4] ? parseInt(match[4], 10) : undefined
+			const preReleases = match[5] ? match[5].split("-") : undefined
+			const build = match[6]
+			return new VersionNumber(
+				major,
+				minor,
+				patch,
+				dsePatch,
+				preReleases,
+				build,
+			)
+		}
+		throw new TypeError("Could not extract version from '" + version + "'")
+	}
+}
+
+export default VersionNumber