postgres-interval 1.0.1 → 1.1.2

package/index.d.ts

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

package/index.js

@@ -13,19 +13,69 @@ function PostgresInterval (raw) {
 var properties = ['seconds', 'minutes', 'hours', 'days', 'months', 'years']
 PostgresInterval.prototype.toPostgres = function () {
   var filtered = properties.filter(this.hasOwnProperty, this)
+
+  // In addition to `properties`, we need to account for fractions of seconds.
+  if (this.milliseconds && filtered.indexOf('seconds') < 0) {
+    filtered.push('seconds')
+  }
+
   if (filtered.length === 0) return '0'
   return filtered
     .map(function (property) {
-      return this[property] + ' ' + property
+      var 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+$/, '')
+      }
+
+      return value + ' ' + property
     }, this)
     .join(' ')
 }
 
+var propertiesISOEquivalent = {
+  years: 'Y',
+  months: 'M',
+  days: 'D',
+  hours: 'H',
+  minutes: 'M',
+  seconds: 'S'
+}
+var dateProperties = ['years', 'months', 'days']
+var timeProperties = ['hours', 'minutes', 'seconds']
+// according to ISO 8601
+PostgresInterval.prototype.toISO = function () {
+  var datePart = dateProperties
+    .map(buildProperty, this)
+    .join('')
+
+  var timePart = timeProperties
+    .map(buildProperty, this)
+    .join('')
+
+  return 'P' + datePart + 'T' + timePart
+
+  function buildProperty (property) {
+    var 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+$/, '')
+    }
+
+    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):?(\\d\\d\\d)?'
+var TIME = '([+-])?([\\d]*):(\\d\\d):(\\d\\d)\.?(\\d{1,6})?'
 var INTERVAL = new RegExp([YEAR, MONTH, DAY, TIME].map(function (regexString) {
   return '(' + regexString + ')?'
 })
@@ -42,7 +92,13 @@ var positions = {
   milliseconds: 12
 }
 // We can use negative time
-var negatives = ['hours', 'minutes', 'seconds']
+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 {}
@@ -54,7 +110,11 @@ function parse (interval) {
       var value = matches[position]
       // no empty string
       if (!value) return parsed
-      value = parseInt(value, 10)
+      // 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)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "postgres-interval",
   "main": "index.js",
-  "version": "1.0.1",
+  "version": "1.1.2",
   "description": "Parse Postgres interval columns",
   "license": "MIT",
   "repository": "bendrucker/postgres-interval",
@@ -30,6 +30,7 @@
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "readme.md"
   ]
 }

package/readme.md

@@ -18,6 +18,8 @@ var interval = parse('01:02:03')
 //=> {hours: 1, minutes: 2, seconds: 3}
 interval.toPostgres()
 // 3 seconds 2 minutes 1 hours
+interval.toISO()
+// P0Y0M0DT1H2M3S
 ```
 
 ## API
@@ -35,6 +37,10 @@ A Postgres interval string.
 
 Returns an interval string. This allows the interval object to be passed into prepared statements.
 
+#### `interval.toISO()` -> `string`
+
+Returns an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) compliant string.
+
 ## License
 
 MIT © [Ben Drucker](http://bendrucker.me)