postgres-interval 1.2.0 → 4.0.0

package/index.d.ts

@@ -1,20 +1,86 @@
 declare namespace PostgresInterval {
   export interface IPostgresInterval {
-    years?: number;
-    months?: number;
-    days?: number;
-    hours?: number;
-    minutes?: number;
-    seconds?: number;
-    milliseconds?: number;
+    years: number;
+    months: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
 
+    /**
+     * Returns an interval string. This allows the interval object to be passed into prepared statements.
+     *
+     * ```js
+     * var parse = require('postgres-interval')
+     * var interval = parse('01:02:03')
+     * // => { hours: 1, minutes: 2, seconds: 3 }
+     * interval.toPostgres()
+     * // 1 hour 2 minutes 3 seconds
+     * ```
+     */
     toPostgres(): string;
 
+    /**
+     * Returns an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) compliant string, for example P0Y0M0DT0H9M0S.
+     *
+     * Also available as {@link toISOString toISOString}.
+     *
+     * ```js
+     * var parse = require('postgres-interval')
+     * var interval = parse('01:02:03')
+     * // => { hours: 1, minutes: 2, seconds: 3 }
+     * interval.toISO()
+     * // P0Y0M0DT1H2M3S
+     * ```
+     */
     toISO(): string;
+    /**
+     * Returns an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) compliant string, for example P0Y0M0DT0H9M0S.
+     *
+     * Also available as {@link toISO toISO} for backwards compatibility.
+     *
+     * ```js
+     * var parse = require('postgres-interval')
+     * var interval = parse('01:02:03')
+     * // => { hours: 1, minutes: 2, seconds: 3 }
+     * interval.toISOString()
+     * // P0Y0M0DT1H2M3S
+     * ```
+     */
     toISOString(): string;
+    /**
+     * Returns an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) compliant string shortened to minimum length, for example `PT9M`.
+     *
+     * ```js
+     * var parse = require('postgres-interval')
+     * var interval = parse('01:02:03')
+     * // => { hours: 1, minutes: 2, seconds: 3 }
+     * interval.toISOStringShort()
+     * // PT1H2M3S
+     * ```
+     */
+    toISOStringShort(): string;
   }
 }
 
+/**
+ * Parse Postgres interval columns.
+ *
+ * ```js
+ * var parse = require('postgres-interval')
+ * var interval = parse('01:02:03')
+ * // => { hours: 1, minutes: 2, seconds: 3 }
+ * interval.toPostgres()
+ * // 1 hour 2 minutes 3 seconds
+ * interval.toISOString()
+ * // P0Y0M0DT1H2M3S
+ * interval.toISOStringShort()
+ * // PT1H2M3S
+ * ```
+ *
+ * @param raw A Postgres interval string.
+ */
 declare function PostgresInterval(raw: string): PostgresInterval.IPostgresInterval;
 
 export = PostgresInterval;

package/index.js

@@ -1,28 +1,27 @@
 'use strict'
 
-var extend = require('xtend/mutable')
-
 module.exports = PostgresInterval
 
 function PostgresInterval (raw) {
   if (!(this instanceof PostgresInterval)) {
     return new PostgresInterval(raw)
   }
-  extend(this, parse(raw))
+
+  Object.assign(this, parse(raw))
 }
-var properties = ['seconds', 'minutes', 'hours', 'days', 'months', 'years']
+const properties = ['years', 'months', 'days', 'hours', 'minutes', 'seconds']
 PostgresInterval.prototype.toPostgres = function () {
-  var filtered = properties.filter(this.hasOwnProperty, this)
+  const filtered = properties.filter(key => Object.prototype.hasOwnProperty.call(this, key) && this[key] !== 0)
 
   // In addition to `properties`, we need to account for fractions of seconds.
-  if (this.milliseconds && filtered.indexOf('seconds') < 0) {
+  if (this.milliseconds && !filtered.includes('seconds')) {
     filtered.push('seconds')
   }
 
   if (filtered.length === 0) return '0'
   return filtered
     .map(function (property) {
-      var value = this[property] || 0
+      let value = this[property] || 0
 
       // Account for fractional part of seconds,
       // remove trailing zeroes.
@@ -30,12 +29,15 @@ PostgresInterval.prototype.toPostgres = function () {
         value = (value + this.milliseconds / 1000).toFixed(6).replace(/\.?0+$/, '')
       }
 
-      return value + ' ' + property
+      // fractional seconds will be a String, all others are Number
+      const isSingular = String(value) === '1'
+      // Remove plural 's' when the value is singular
+      return value + ' ' + (isSingular ? property.replace(/s$/, '') : property)
     }, this)
     .join(' ')
 }
 
-var propertiesISOEquivalent = {
+const propertiesISOEquivalent = {
   years: 'Y',
   months: 'M',
   days: 'D',
@@ -43,22 +45,34 @@ var propertiesISOEquivalent = {
   minutes: 'M',
   seconds: 'S'
 }
-var dateProperties = ['years', 'months', 'days']
-var timeProperties = ['hours', 'minutes', 'seconds']
+const dateProperties = ['years', 'months', 'days']
+const timeProperties = ['hours', 'minutes', 'seconds']
 // according to ISO 8601
 PostgresInterval.prototype.toISOString = PostgresInterval.prototype.toISO = function () {
-  var datePart = dateProperties
+  return toISOString.call(this, { short: false })
+}
+
+PostgresInterval.prototype.toISOStringShort = function () {
+  return toISOString.call(this, { short: true })
+}
+
+function toISOString ({ short = false }) {
+  const datePart = dateProperties
     .map(buildProperty, this)
     .join('')
 
-  var timePart = timeProperties
+  const timePart = timeProperties
     .map(buildProperty, this)
     .join('')
 
-  return 'P' + datePart + 'T' + timePart
+  if (!timePart.length && !datePart.length) return 'PT0S'
+
+  if (!timePart.length) return `P${datePart}`
+
+  return `P${datePart}T${timePart}`
 
   function buildProperty (property) {
-    var value = this[property] || 0
+    let value = this[property] || 0
 
     // Account for fractional part of seconds,
     // remove trailing zeroes.
@@ -66,60 +80,80 @@ PostgresInterval.prototype.toISOString = PostgresInterval.prototype.toISO = func
       value = (value + this.milliseconds / 1000).toFixed(6).replace(/0+$/, '')
     }
 
+    if (short && !value) return ''
+
     return value + propertiesISOEquivalent[property]
   }
 }
 
-var NUMBER = '([+-]?\\d+)'
-var YEAR = NUMBER + '\\s+years?'
-var MONTH = NUMBER + '\\s+mons?'
-var DAY = NUMBER + '\\s+days?'
-var TIME = '([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?'
-var INTERVAL = new RegExp([YEAR, MONTH, DAY, TIME].map(function (regexString) {
-  return '(' + regexString + ')?'
+const NUMBER = '([+-]?\\d+)'
+const YEAR = `${NUMBER}\\s+years?`
+const MONTH = `${NUMBER}\\s+mons?`
+const DAY = `${NUMBER}\\s+days?`
+// NOTE: PostgreSQL automatically overflows seconds into minutes and minutes
+// into hours, so we can rely on minutes and seconds always being 2 digits
+// (plus decimal for seconds). The overflow stops at hours - hours do not
+// overflow into days, so could be arbitrarily long.
+const TIME = '([+-])?(\\d+):(\\d\\d):(\\d\\d(?:\\.\\d{1,6})?)'
+const INTERVAL = new RegExp(
+  '^\\s*' +
+    // All parts of an interval are optional
+    [YEAR, MONTH, DAY, TIME].map((str) => '(?:' + str + ')?').join('\\s*') +
+    '\\s*$'
+)
+
+// All intervals will have exactly these properties:
+const ZERO_INTERVAL = Object.freeze({
+  years: 0,
+  months: 0,
+  days: 0,
+  hours: 0,
+  minutes: 0,
+  seconds: 0,
+  milliseconds: 0.0
 })
-  .join('\\s*'))
-
-// Positions of values in regex match
-var positions = {
-  years: 2,
-  months: 4,
-  days: 6,
-  hours: 9,
-  minutes: 10,
-  seconds: 11,
-  milliseconds: 12
-}
-// We can use negative time
-var negatives = ['hours', 'minutes', 'seconds', 'milliseconds']
-
-function parseMilliseconds (fraction) {
-  // add omitted zeroes
-  var microseconds = fraction + '000000'.slice(fraction.length)
-  return parseInt(microseconds, 10) / 1000
-}
 
 function parse (interval) {
-  if (!interval) return {}
-  var matches = INTERVAL.exec(interval)
-  var isNegative = matches[8] === '-'
-  return Object.keys(positions)
-    .reduce(function (parsed, property) {
-      var position = positions[property]
-      var value = matches[position]
-      // no empty string
-      if (!value) return parsed
-      // milliseconds are actually microseconds (up to 6 digits)
-      // with omitted trailing zeroes.
-      value = property === 'milliseconds'
-        ? parseMilliseconds(value)
-        : parseInt(value, 10)
-      // no zeros
-      if (!value) return parsed
-      if (isNegative && ~negatives.indexOf(property)) {
-        value *= -1
-      }
-      parsed[property] = value
-      return parsed
-    }, {})
+  if (!interval) {
+    return ZERO_INTERVAL
+  }
+
+  const matches = INTERVAL.exec(interval) || []
+
+  const [
+    ,
+    yearsString,
+    monthsString,
+    daysString,
+    plusMinusTime,
+    hoursString,
+    minutesString,
+    secondsString
+  ] = matches
+
+  const timeMultiplier = plusMinusTime === '-' ? -1 : 1
+
+  const years = yearsString ? parseInt(yearsString, 10) : 0
+  const months = monthsString ? parseInt(monthsString, 10) : 0
+  const days = daysString ? parseInt(daysString, 10) : 0
+  const hours = hoursString ? timeMultiplier * parseInt(hoursString, 10) : 0
+  const minutes = minutesString
+    ? timeMultiplier * parseInt(minutesString, 10)
+    : 0
+  const secondsFloat = parseFloat(secondsString) || 0
+  // secondsFloat is guaranteed to be >= 0, so floor is safe
+  const absSeconds = Math.floor(secondsFloat)
+  const seconds = timeMultiplier * absSeconds
+  // Without the rounding, we end up with decimals like 455.99999999999994 instead of 456
+  const milliseconds = Math.round(timeMultiplier * (secondsFloat - absSeconds) * 1000000) / 1000
+  return {
+    years,
+    months,
+    days,
+    hours,
+    minutes,
+    seconds,
+    milliseconds
+  }
 }
+PostgresInterval.parse = parse

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "postgres-interval",
   "main": "index.js",
-  "version": "1.2.0",
+  "version": "4.0.0",
   "description": "Parse Postgres interval columns",
   "license": "MIT",
   "repository": "bendrucker/postgres-interval",
   "author": {
     "name": "Ben Drucker",
     "email": "bvdrucker@gmail.com",
-    "url": "bendrucker.me"
+    "url": "https://www.bendrucker.me"
   },
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=12"
   },
   "scripts": {
     "test": "standard && tape test.js"
@@ -21,12 +21,10 @@
     "interval",
     "parser"
   ],
-  "dependencies": {
-    "xtend": "^4.0.0"
-  },
+  "dependencies": {},
   "devDependencies": {
-    "tape": "^4.0.0",
-    "standard": "^12.0.1"
+    "standard": "^16.0.0",
+    "tape": "^5.0.0"
   },
   "files": [
     "index.js",

package/readme.md

@@ -1,12 +1,12 @@
-# postgres-interval [![Build Status](https://travis-ci.org/bendrucker/postgres-interval.svg?branch=master)](https://travis-ci.org/bendrucker/postgres-interval) [![Greenkeeper badge](https://badges.greenkeeper.io/bendrucker/postgres-interval.svg)](https://greenkeeper.io/)
+# postgres-interval [![tests](https://github.com/bendrucker/postgres-interval/workflows/tests/badge.svg)](https://github.com/bendrucker/postgres-interval/actions?query=workflow%3Atests)
 
 > Parse Postgres interval columns
 
 
 ## Install
 
-```
-$ npm install --save postgres-interval
+```sh
+npm install --save postgres-interval
 ```
 
 
@@ -15,11 +15,19 @@ $ npm install --save postgres-interval
 ```js
 var parse = require('postgres-interval')
 var interval = parse('01:02:03')
-//=> {hours: 1, minutes: 2, seconds: 3}
+// => { hours: 1, minutes: 2, seconds: 3 }
 interval.toPostgres()
-// 3 seconds 2 minutes 1 hours
-interval.toISO()
+// 1 hour 2 minutes 3 seconds
+interval.toISOString()
 // P0Y0M0DT1H2M3S
+interval.toISOStringShort()
+// PT1H2M3S
+```
+
+This package parses the default Postgres interval style. If you have changed [`intervalstyle`](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-INTERVALSTYLE), you will need to set it back to the default:
+
+```sql
+set intervalstyle to default;
 ```
 
 ## API
@@ -39,10 +47,14 @@ Returns an interval string. This allows the interval object to be passed into pr
 
 #### `interval.toISOString()` -> `string`
 
-Returns an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) compliant string.
+Returns an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) compliant string, for example `P0Y0M0DT0H9M0S`.
 
 Also available as `interval.toISO()` for backwards compatibility.
 
+#### `interval.toISOStringShort()` -> `string`
+
+Returns an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) compliant string shortened to minimum length, for example `PT9M`.
+
 ## License
 
 MIT © [Ben Drucker](http://bendrucker.me)