postgres-interval 1.1.1 → 2.1.0

package/index.d.ts

@@ -0,0 +1,21 @@
+declare namespace PostgresInterval {
+  export interface IPostgresInterval {
+    years: number;
+    months: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+
+    toPostgres(): string;
+
+    toISO(): string;
+    toISOString(): string;
+    toISOStringShort(): string;
+  }
+}
+
+declare function PostgresInterval(raw: string): PostgresInterval.IPostgresInterval;
+
+export = PostgresInterval;

package/index.js

@@ -1,18 +1,21 @@
 '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))
+
+  for (const key in positions) {
+    this[key] = 0
+  }
+
+  Object.assign(this, parse(raw))
 }
-var properties = ['seconds', 'minutes', 'hours', 'days', 'months', 'years']
+const properties = ['seconds', 'minutes', 'hours', 'days', 'months', 'years']
 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) {
@@ -22,12 +25,12 @@ PostgresInterval.prototype.toPostgres = function () {
   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.
       if (property === 'seconds' && this.milliseconds) {
-        value = (value + this.milliseconds / 1000).toFixed(6).replace(/0+$/, '')
+        value = (value + this.milliseconds / 1000).toFixed(6).replace(/\.?0+$/, '')
       }
 
       return value + ' ' + property
@@ -35,7 +38,7 @@ PostgresInterval.prototype.toPostgres = function () {
     .join(' ')
 }
 
-var propertiesISOEquivalent = {
+const propertiesISOEquivalent = {
   years: 'Y',
   months: 'M',
   days: 'D',
@@ -43,22 +46,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.toISO = function () {
-  var datePart = dateProperties
+PostgresInterval.prototype.toISOString = PostgresInterval.prototype.toISO = function () {
+  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,23 +81,24 @@ PostgresInterval.prototype.toISO = function () {
       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) {
+const NUMBER = '([+-]?\\d+)'
+const YEAR = NUMBER + '\\s+years?'
+const MONTH = NUMBER + '\\s+mons?'
+const DAY = NUMBER + '\\s+days?'
+const TIME = '([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?'
+const INTERVAL = new RegExp([YEAR, MONTH, DAY, TIME].map(function (regexString) {
   return '(' + regexString + ')?'
 })
-.join('\\s*'))
+  .join('\\s*'))
 
 // Positions of values in regex match
-var positions = {
+const positions = {
   years: 2,
   months: 4,
   days: 6,
@@ -92,22 +108,22 @@ var positions = {
   milliseconds: 12
 }
 // We can use negative time
-var negatives = ['hours', 'minutes', 'seconds', 'milliseconds']
+const negatives = ['hours', 'minutes', 'seconds', 'milliseconds']
 
 function parseMilliseconds (fraction) {
   // add omitted zeroes
-  var microseconds = fraction + '000000'.slice(fraction.length)
+  const 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] === '-'
+  const matches = INTERVAL.exec(interval)
+  const isNegative = matches[8] === '-'
   return Object.keys(positions)
     .reduce(function (parsed, property) {
-      var position = positions[property]
-      var value = matches[position]
+      const position = positions[property]
+      let value = matches[position]
       // no empty string
       if (!value) return parsed
       // milliseconds are actually microseconds (up to 6 digits)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "postgres-interval",
   "main": "index.js",
-  "version": "1.1.1",
+  "version": "2.1.0",
   "description": "Parse Postgres interval columns",
   "license": "MIT",
   "repository": "bendrucker/postgres-interval",
@@ -11,7 +11,7 @@
     "url": "bendrucker.me"
   },
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=8"
   },
   "scripts": {
     "test": "standard && tape test.js"
@@ -21,15 +21,14 @@
     "interval",
     "parser"
   ],
-  "dependencies": {
-    "xtend": "^4.0.0"
-  },
+  "dependencies": {},
   "devDependencies": {
-    "tape": "^4.0.0",
-    "standard": "^4.0.0"
+    "standard": "^14.0.0",
+    "tape": "^5.0.0"
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "readme.md"
   ]
 }

package/readme.md

@@ -5,8 +5,8 @@
 
 ## Install
 
-```
-$ npm install --save postgres-interval
+```sh
+npm install --save postgres-interval
 ```
 
 
@@ -18,10 +18,16 @@ var interval = parse('01:02:03')
 //=> {hours: 1, minutes: 2, seconds: 3}
 interval.toPostgres()
 // 3 seconds 2 minutes 1 hours
-interval.toISO()
+interval.toISOString()
 // P0Y0M0DT1H2M3S
 ```
 
+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
 
 #### `parse(pgInterval)` -> `interval`
@@ -37,9 +43,15 @@ A Postgres interval string.
 
 Returns an interval string. This allows the interval object to be passed into prepared statements.
 
-#### `interval.toISO()` -> `string`
+#### `interval.toISOString()` -> `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.
+Returns an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) compliant string shortened to minimum length, for example `PT9M`.
 
 ## License