@ragestudio/scylla-odm 0.22.2 → 0.22.3

package/driver/types/local-date.js

@@ -0,0 +1,280 @@
+/*
+ * 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 util from "util"
+
+import utils from "../utils.js"
+/** @module types */
+
+/**
+ * @private
+ * @const
+ */
+const millisecondsPerDay = 86400000
+/**
+ * @private
+ */
+const dateCenter = Math.pow(2, 31)
+/**
+ *
+ * Creates a new instance of LocalDate.
+ * @class
+ * @classdesc A date without a time-zone in the ISO-8601 calendar system, such as 2010-08-05.
+ * <p>
+ *   LocalDate is an immutable object that represents a date, often viewed as year-month-day. For example, the value "1st October 2014" can be stored in a LocalDate.
+ * </p>
+ * <p>
+ *   This class does not store or represent a time or time-zone. Instead, it is a description of the date, as used for birthdays. It cannot represent an instant on the time-line without additional information such as an offset or time-zone.
+ * </p>
+ * <p>
+ *   Note that this type can represent dates in the range [-5877641-06-23; 5881580-07-17] while the ES5 date type can only represent values in the range of [-271821-04-20; 275760-09-13].
+ *   In the event that year, month, day parameters do not fall within the ES5 date range an Error will be thrown.  If you wish to represent a date outside of this range, pass a single
+ *   parameter indicating the days since epoch.  For example, -1 represents 1969-12-31.
+ * </p>
+ * @param {Number} year The year or days since epoch.  If days since epoch, month and day should not be provided.
+ * @param {Number} month Between 1 and 12 inclusive.
+ * @param {Number} day Between 1 and the number of days in the given month of the given year.
+ *
+ * @property {Date} date The date representation if falls within a range of an ES5 data type, otherwise an invalid date.
+ *
+ * @constructor
+ */
+function LocalDate(year, month, day) {
+	//implementation detail: internally uses a UTC based date
+	if (
+		typeof year === "number" &&
+		typeof month === "number" &&
+		typeof day === "number"
+	) {
+		// Use setUTCFullYear as if there is a 2 digit year, Date.UTC() assumes
+		// that is the 20th century.
+		this.date = new Date()
+		this.date.setUTCHours(0, 0, 0, 0)
+		this.date.setUTCFullYear(year, month - 1, day)
+		if (isNaN(this.date.getTime())) {
+			throw new Error(
+				util.format(
+					"%d-%d-%d does not form a valid ES5 date!",
+					year,
+					month,
+					day,
+				),
+			)
+		}
+	} else if (typeof month === "undefined" && typeof day === "undefined") {
+		if (typeof year === "number") {
+			//in days since epoch.
+			if (year < -2147483648 || year > 2147483647) {
+				throw new Error(
+					"You must provide a valid value for days since epoch (-2147483648 <= value <= 2147483647).",
+				)
+			}
+			this.date = new Date(year * millisecondsPerDay)
+		}
+	}
+
+	if (typeof this.date === "undefined") {
+		throw new Error("You must provide a valid year, month and day")
+	}
+
+	/**
+	 * If date cannot be represented yet given a valid days since epoch, track
+	 * it internally.
+	 */
+	this._value = isNaN(this.date.getTime()) ? year : null
+
+	/**
+	 * A number representing the year.  May return NaN if cannot be represented as
+	 * a Date.
+	 * @type Number
+	 */
+	this.year = this.date.getUTCFullYear()
+	/**
+	 * A number between 1 and 12 inclusive representing the month.  May return
+	 * NaN if cannot be represented as a Date.
+	 * @type Number
+	 */
+	this.month = this.date.getUTCMonth() + 1
+	/**
+	 * A number between 1 and the number of days in the given month of the given year (28, 29, 30, 31).
+	 * May return NaN if cannot be represented as a Date.
+	 * @type Number
+	 */
+	this.day = this.date.getUTCDate()
+}
+
+/**
+ * Creates a new instance of LocalDate using the current year, month and day from the system clock in the default time-zone.
+ */
+LocalDate.now = function () {
+	return LocalDate.fromDate(new Date())
+}
+
+/**
+ * Creates a new instance of LocalDate using the current date from the system clock at UTC.
+ */
+LocalDate.utcNow = function () {
+	return new LocalDate(Date.now())
+}
+
+/**
+ * Creates a new instance of LocalDate using the year, month and day from the provided local date time.
+ * @param {Date} date
+ */
+LocalDate.fromDate = function (date) {
+	if (isNaN(date.getTime())) {
+		throw new TypeError("Invalid date: " + date)
+	}
+	return new LocalDate(
+		date.getFullYear(),
+		date.getMonth() + 1,
+		date.getDate(),
+	)
+}
+
+/**
+ * Creates a new instance of LocalDate using the year, month and day provided in the form: yyyy-mm-dd or
+ * days since epoch (i.e. -1 for Dec 31, 1969).
+ * @param {String} value
+ */
+LocalDate.fromString = function (value) {
+	const dashCount = (value.match(/-/g) || []).length
+	if (dashCount >= 2) {
+		let multiplier = 1
+		if (value[0] === "-") {
+			value = value.substring(1)
+			multiplier = -1
+		}
+		const parts = value.split("-")
+		return new LocalDate(
+			multiplier * parseInt(parts[0], 10),
+			parseInt(parts[1], 10),
+			parseInt(parts[2], 10),
+		)
+	}
+	if (value.match(/^-?\d+$/)) {
+		// Parse as days since epoch.
+		return new LocalDate(parseInt(value, 10))
+	}
+	throw new Error("Invalid input '" + value + "'.")
+}
+
+/**
+ * Creates a new instance of LocalDate using the bytes representation.
+ * @param {Buffer} buffer
+ */
+LocalDate.fromBuffer = function (buffer) {
+	//move to unix epoch: 0.
+	return new LocalDate(buffer.readUInt32BE(0) - dateCenter)
+}
+
+/**
+ * Compares this LocalDate with the given one.
+ * @param {LocalDate} other date to compare against.
+ * @return {number} 0 if they are the same, 1 if the this is greater, and -1
+ * if the given one is greater.
+ */
+LocalDate.prototype.compare = function (other) {
+	const thisValue = isNaN(this.date.getTime())
+		? this._value * millisecondsPerDay
+		: this.date.getTime()
+	const otherValue = isNaN(other.date.getTime())
+		? other._value * millisecondsPerDay
+		: other.date.getTime()
+	const diff = thisValue - otherValue
+	if (diff < 0) {
+		return -1
+	}
+	if (diff > 0) {
+		return 1
+	}
+	return 0
+}
+
+/**
+ * Returns true if the value of the LocalDate instance and other are the same
+ * @param {LocalDate} other
+ * @returns {Boolean}
+ */
+LocalDate.prototype.equals = function (other) {
+	return other instanceof LocalDate && this.compare(other) === 0
+}
+
+LocalDate.prototype.inspect = function () {
+	return this.constructor.name + ": " + this.toString()
+}
+
+/**
+ * Gets the bytes representation of the instance.
+ * @returns {Buffer}
+ */
+LocalDate.prototype.toBuffer = function () {
+	//days since unix epoch
+	const daysSinceEpoch = isNaN(this.date.getTime())
+		? this._value
+		: Math.floor(this.date.getTime() / millisecondsPerDay)
+	const value = daysSinceEpoch + dateCenter
+	const buf = utils.allocBufferUnsafe(4)
+	buf.writeUInt32BE(value, 0)
+	return buf
+}
+
+/**
+ * Gets the string representation of the instance in the form: yyyy-mm-dd if
+ * the value can be parsed as a Date, otherwise days since epoch.
+ * @returns {String}
+ */
+LocalDate.prototype.toString = function () {
+	let result
+	//if cannot be parsed as date, return days since epoch representation.
+	if (isNaN(this.date.getTime())) {
+		return this._value.toString()
+	}
+	if (this.year < 0) {
+		result = "-" + fillZeros((this.year * -1).toString(), 4)
+	} else {
+		result = fillZeros(this.year.toString(), 4)
+	}
+	result +=
+		"-" +
+		fillZeros(this.month.toString(), 2) +
+		"-" +
+		fillZeros(this.day.toString(), 2)
+	return result
+}
+
+/**
+ * Gets the string representation of the instance in the form: yyyy-mm-dd, valid for JSON.
+ * @returns {String}
+ */
+LocalDate.prototype.toJSON = function () {
+	return this.toString()
+}
+
+/**
+ * @param {String} value
+ * @param {Number} amount
+ * @private
+ */
+function fillZeros(value, amount) {
+	if (value.length >= amount) {
+		return value
+	}
+	return utils.stringRepeat("0", amount - value.length) + value
+}
+
+export default LocalDate

package/driver/types/local-time.js

@@ -0,0 +1,299 @@
+/*
+ * 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 Long from "long"
+import util from "util"
+import utils from "../utils.js"
+/** @module types */
+
+/**
+ * @const
+ * @private
+ * */
+const maxNanos = Long.fromString("86399999999999")
+/**
+ * Nanoseconds in a second
+ * @const
+ * @private
+ * */
+const nanoSecInSec = Long.fromNumber(1000000000)
+/**
+ * Nanoseconds in a millisecond
+ * @const
+ * @private
+ * */
+const nanoSecInMillis = Long.fromNumber(1000000)
+/**
+ * Milliseconds in day
+ * @const
+ * @private
+ * */
+const millisInDay = 86400000
+/**
+ *
+ * Creates a new instance of LocalTime.
+ * @class
+ * @classdesc A time without a time-zone in the ISO-8601 calendar system, such as 10:30:05.
+ * <p>
+ *   LocalTime is an immutable date-time object that represents a time, often viewed as hour-minute-second. Time is represented to nanosecond precision. For example, the value "13:45.30.123456789" can be stored in a LocalTime.
+ * </p>
+ * @param {Long} totalNanoseconds Total nanoseconds since midnight.
+ * @constructor
+ */
+function LocalTime(totalNanoseconds) {
+	if (!(totalNanoseconds instanceof Long)) {
+		throw new Error("You must specify a Long value as totalNanoseconds")
+	}
+	if (
+		totalNanoseconds.lessThan(Long.ZERO) ||
+		totalNanoseconds.greaterThan(maxNanos)
+	) {
+		throw new Error("Total nanoseconds out of range")
+	}
+	this.value = totalNanoseconds
+
+	/**
+	 * Gets the hour component of the time represented by the current instance, a number from 0 to 23.
+	 * @type Number
+	 */
+	this.hour = this._getParts()[0]
+	/**
+	 * Gets the minute component of the time represented by the current instance, a number from 0 to 59.
+	 * @type Number
+	 */
+	this.minute = this._getParts()[1]
+	/**
+	 * Gets the second component of the time represented by the current instance, a number from 0 to 59.
+	 * @type Number
+	 */
+	this.second = this._getParts()[2]
+	/**
+	 * Gets the nanoseconds component of the time represented by the current instance, a number from 0 to 999999999.
+	 * @type Number
+	 */
+	this.nanosecond = this._getParts()[3]
+}
+
+/**
+ * Parses an string representation and returns a new LocalDate.
+ * @param {String} value
+ * @returns {LocalTime}
+ */
+LocalTime.fromString = function (value) {
+	if (typeof value !== "string") {
+		throw new Error("Argument type invalid: " + util.inspect(value))
+	}
+	const parts = value.split(":")
+	let millis =
+		parseInt(parts[0], 10) * 3600000 + parseInt(parts[1], 10) * 60000
+	let nanos
+	if (parts.length === 3) {
+		const secParts = parts[2].split(".")
+		millis += parseInt(secParts[0], 10) * 1000
+		if (secParts.length === 2) {
+			nanos = secParts[1]
+			//add zeros at the end
+			nanos = nanos + utils.stringRepeat("0", 9 - nanos.length)
+		}
+	}
+	return LocalTime.fromMilliseconds(millis, parseInt(nanos, 10) || 0)
+}
+
+/**
+ * Uses the current local time (in milliseconds) and the nanoseconds to create a new instance of LocalTime
+ * @param {Number} [nanoseconds] A Number from 0 to 999,999, representing the time nanosecond portion.
+ * @returns {LocalTime}
+ */
+LocalTime.now = function (nanoseconds) {
+	return LocalTime.fromDate(new Date(), nanoseconds)
+}
+
+/**
+ * Uses the provided local time (in milliseconds) and the nanoseconds to create a new instance of LocalTime
+ * @param {Date} date Local date portion to extract the time passed since midnight.
+ * @param {Number} [nanoseconds] A Number from 0 to 999,999, representing the nanosecond time portion.
+ * @returns {LocalTime}
+ */
+LocalTime.fromDate = function (date, nanoseconds) {
+	if (!(date instanceof Date)) {
+		throw new Error("Not a valid date")
+	}
+	//Use the local representation, only the milliseconds portion
+	const millis =
+		(date.getTime() + date.getTimezoneOffset() * -60000) % millisInDay
+	return LocalTime.fromMilliseconds(millis, nanoseconds)
+}
+
+/**
+ * Uses the provided local time (in milliseconds) and the nanoseconds to create a new instance of LocalTime
+ * @param {Number} milliseconds A Number from 0 to 86,399,999.
+ * @param {Number} [nanoseconds] A Number from 0 to 999,999, representing the time nanosecond portion.
+ * @returns {LocalTime}
+ */
+LocalTime.fromMilliseconds = function (milliseconds, nanoseconds) {
+	if (typeof nanoseconds !== "number") {
+		nanoseconds = 0
+	}
+	return new LocalTime(
+		Long.fromNumber(milliseconds)
+			.multiply(nanoSecInMillis)
+			.add(Long.fromNumber(nanoseconds)),
+	)
+}
+
+/**
+ * Creates a new instance of LocalTime from the bytes representation.
+ * @param {Buffer} value
+ * @returns {LocalTime}
+ */
+LocalTime.fromBuffer = function (value) {
+	if (!(value instanceof Buffer)) {
+		throw new TypeError("Expected Buffer, obtained " + util.inspect(value))
+	}
+	return new LocalTime(new Long(value.readInt32BE(4), value.readInt32BE(0)))
+}
+
+/**
+ * Compares this LocalTime with the given one.
+ * @param {LocalTime} other time to compare against.
+ * @return {number} 0 if they are the same, 1 if the this is greater, and -1
+ * if the given one is greater.
+ */
+LocalTime.prototype.compare = function (other) {
+	return this.value.compare(other.value)
+}
+
+/**
+ * Returns true if the value of the LocalTime instance and other are the same
+ * @param {LocalTime} other
+ * @returns {Boolean}
+ */
+LocalTime.prototype.equals = function (other) {
+	return other instanceof LocalTime && this.compare(other) === 0
+}
+
+/**
+ * Gets the total amount of nanoseconds since midnight for this instance.
+ * @returns {Long}
+ */
+LocalTime.prototype.getTotalNanoseconds = function () {
+	return this.value
+}
+
+LocalTime.prototype.inspect = function () {
+	return this.constructor.name + ": " + this.toString()
+}
+
+/**
+ * Returns a big-endian bytes representation of the instance
+ * @returns {Buffer}
+ */
+LocalTime.prototype.toBuffer = function () {
+	const buffer = utils.allocBufferUnsafe(8)
+	buffer.writeUInt32BE(this.value.getHighBitsUnsigned(), 0)
+	buffer.writeUInt32BE(this.value.getLowBitsUnsigned(), 4)
+	return buffer
+}
+
+/**
+ * Returns the string representation of the instance in the form of hh:MM:ss.ns
+ * @returns {String}
+ */
+LocalTime.prototype.toString = function () {
+	return formatTime(this._getParts())
+}
+
+/**
+ * Gets the string representation of the instance in the form: hh:MM:ss.ns
+ * @returns {String}
+ */
+LocalTime.prototype.toJSON = function () {
+	return this.toString()
+}
+
+/**
+ * @returns {Array.<Number>}
+ * @ignore
+ */
+LocalTime.prototype._getParts = function () {
+	if (!this._partsCache) {
+		//hours, minutes, seconds and nanos
+		const parts = [0, 0, 0, 0]
+		const secs = this.value.div(nanoSecInSec)
+		//faster modulo
+		//total nanos
+		parts[3] = this.value.subtract(secs.multiply(nanoSecInSec)).toNumber()
+		//seconds
+		parts[2] = secs.toNumber()
+		if (parts[2] >= 60) {
+			//minutes
+			parts[1] = Math.floor(parts[2] / 60)
+			parts[2] = parts[2] % 60
+		}
+		if (parts[1] >= 60) {
+			//hours
+			parts[0] = Math.floor(parts[1] / 60)
+			parts[1] = parts[1] % 60
+		}
+		this._partsCache = parts
+	}
+	return this._partsCache
+}
+
+/**
+ * @param {Array.<Number>} values
+ * @private
+ */
+function formatTime(values) {
+	let result
+	if (values[0] < 10) {
+		result = "0" + values[0] + ":"
+	} else {
+		result = values[0] + ":"
+	}
+	if (values[1] < 10) {
+		result += "0" + values[1] + ":"
+	} else {
+		result += values[1] + ":"
+	}
+	if (values[2] < 10) {
+		result += "0" + values[2]
+	} else {
+		result += values[2]
+	}
+	if (values[3] > 0) {
+		let nanos = values[3].toString()
+		//nine digits
+		if (nanos.length < 9) {
+			nanos = utils.stringRepeat("0", 9 - nanos.length) + nanos
+		}
+		let lastPosition
+		for (let i = nanos.length - 1; i > 0; i--) {
+			if (nanos[i] !== "0") {
+				break
+			}
+			lastPosition = i
+		}
+		if (lastPosition) {
+			nanos = nanos.substring(0, lastPosition)
+		}
+		result += "." + nanos
+	}
+	return result
+}
+
+export default LocalTime