Merge pull request #7 from flickr/esm

Move codebase to esm

Author: jeremyruppel

.eslintrc.js renamed to .eslintrc.cjs

@@ -8,6 +8,7 @@ module.exports = {
   },
 
   parserOptions: {
+    sourceType: 'module',
     ecmaVersion: 8
   },
 

README.md

@@ -13,14 +13,14 @@ $ npm install incoming-message-hash --save
 This example demonstrates how the hashing function returns a different hash based on the IncomingMessage's method, path, query string, headers and body.
 
 ``` js
-var hash = require('incoming-message-hash');
-var http = require('http');
+import hash from 'incoming-message-hash'
+import { createServer } from 'http'
 
-http.createServer(function (req, res) {
-  req.pipe(hash()).pipe(res);
-}).listen(4567, function () {
+createServer((req, res) => {
+  req.pipe(hash()).pipe(res)
+}).listen(4567, () => {
   console.log('Server is listening on port 4567');
-});
+})
 ```
 
 ``` bash
@@ -50,16 +50,48 @@ var hash = require('incoming-message-hash');
 
 Returns a new [crypto.Hash][] stream using the specified algorithm and encoding (defaults to "md5" and "hex"). You can pipe your [http.IncomingMessage][] in and get a hash back.
 
+```js
+import hash from 'incoming-message-hash'
+import { createServer } from 'http'
+
+createServer((req, res) => {
+  req.pipe(hash()).pipe(res)
+})
+```
 
 ### hash.sync(req, body[, algorithm='md5'[, encoding='hex']])
 
 Synchronous version of `hash()` that accepts an [http.IncomingMessage][] and its body and returns the hash. You must buffer up the request body yourself if you wish to use this method.
 
+```js
+import { promise } from 'incoming-message-hash'
+import { createServer } from 'http'
+
+createServer(async function (req, res) {
+  let body = ''
+
+  req.on('data', chunk => body += String(chunk))
+
+  req.on('end', () => {
+    res.end(sync(req, body))
+  })
+})
+```
+
 ### hash.promise(req[, algorithm='md5'[, encoding='hex]])
 
 Asynchronous version of `hash()` that accepts an [http.IncomingMessage][] and
 buffers the body up for you.
 
+```js
+import { promise } from 'incoming-message-hash'
+import { createServer } from 'http'
+
+createServer(async (req, res) => {
+  res.end(await promise(req))
+})
+```
+
 ## license
 
 This software is free to use under the MIT license. See the [LICENSE][] file for license text and copyright information.

hook.sh

@@ -4,5 +4,3 @@ set -ex
 
 npm run lint
 npm run test
-
-node package.json

index.js

@@ -1,35 +1,116 @@
 // Copyright 2021 SmugMug, Inc.
 // Licensed under the terms of the MIT license. Please see LICENSE file in the project root for terms.
 
-var crypto = require('crypto');
-var url = require('url');
-
-module.exports = createStream;
-
-function createStream(algorithm, encoding) {
-  var hash = createHash(algorithm);
+import { createHash } from 'crypto';
+import { parse } from 'url';
+
+
+/**
+ * The default digest algorithm to use
+ * @see https://nodejs.org/dist/latest-v16.x/docs/api/crypto.html#cryptocreatehashalgorithm-options
+ */
+
+const DEFAULT_ALGORITHM = 'md5';
+
+/**
+ * The default digest encoding to return
+ * @type {BufferEncoding}
+ */
+
+const DEFAULT_ENCODING = 'hex';
+
+/**
+ * Returns a new `crypto.Hash` stream using the specified algorithm and encoding
+ * (defaults to "md5" and "hex"). You can pipe your `http.IncomingMessage` in
+ * and get a hash back.
+ *
+ * @param {string} algorithm
+ * @param {BufferEncoding} encoding
+ * @returns {import('crypto').Hash}
+ * @example
+ *
+ * import hash from 'incoming-message-hash'
+ * import { createServer } from 'http'
+ *
+ * createServer((req, res) => {
+ *   req.pipe(hash()).pipe(res)
+ * })
+ */
+
+export default function createStream(algorithm = DEFAULT_ALGORITHM, encoding = DEFAULT_ENCODING) {
+  const hash = createHash(algorithm);
 
   hash.on('pipe', function (req) {
     updateHash(hash, req);
   });
 
-  hash.setEncoding(encoding || 'hex');
+  hash.setEncoding(encoding);
 
   return hash;
 }
 
-createStream.sync = function (req, body, algorithm, encoding) {
-  var hash = createHash(algorithm);
+// backwards-compatibility
+createStream.sync = sync;
+createStream.promise = promise;
+
+/**
+ * Synchronous version of `hash()` that accepts an http.IncomingMessage and its
+ * body and returns the hash. You must buffer up the request body yourself
+ * if you wish to use this method.
+
+ * @param {import('http').IncomingMessage} req
+ * @param {string|Buffer} body
+ * @param {string} algorithm
+ * @param {BufferEncoding} encoding
+ * @async
+ * @returns {string}
+ * @example
+ *
+ * import { promise } from 'incoming-message-hash'
+ * import { createServer } from 'http'
+ *
+ * createServer(async function (req, res) {
+ *   let body = ''
+ *
+ *   req.on('data', chunk => body += String(chunk))
+ *
+ *   req.on('end', () => {
+ *     res.end(sync(req, body))
+ *   })
+ * })
+ */
+
+export function sync(req, body, algorithm = DEFAULT_ALGORITHM, encoding = DEFAULT_ENCODING) {
+  const hash = createHash(algorithm);
 
   updateHash(hash, req);
 
   hash.write(body);
 
-  return hash.digest(encoding || 'hex');
-};
+  return hash.digest(encoding);
+}
 
-createStream.promise = function (req, algorithm, encoding) {
-  var hash = createHash(algorithm);
+/**
+ * Asynchronous version of `hash()` that accepts an `http.IncomingMessage` and
+ * buffers the request body up for you.
+ *
+ * @param {import('http').IncomingMessage} req
+ * @param {string} algorithm
+ * @param {BufferEncoding} encoding
+ * @async
+ * @returns {Promise<string>}
+ * @example
+ *
+ * import { promise } from 'incoming-message-hash'
+ * import { createServer } from 'http'
+ *
+ * createServer(async (req, res) => {
+ *   res.end(await promise(req))
+ * })
+ */
+
+export function promise(req, algorithm = DEFAULT_ALGORITHM, encoding = DEFAULT_ENCODING) {
+  const hash = createHash(algorithm);
 
   updateHash(hash, req);
 
@@ -43,17 +124,13 @@ createStream.promise = function (req, algorithm, encoding) {
     });
 
     req.on('end', function () {
-      resolve(hash.digest(encoding || 'hex'));
+      resolve(hash.digest(encoding));
     });
   });
-};
-
-function createHash(algorithm) {
-  return crypto.createHash(algorithm || 'md5');
 }
 
 function updateHash(hash, req) {
-  var parts = url.parse(req.url, true);
+  const parts = parse(req.url, true);
 
   hash.update(req.httpVersion);
   hash.update(req.method);

package.json

@@ -3,6 +3,7 @@
   "version": "4.1.0",
   "description": "Generate a one-way hash from an http.IncomingMessage",
   "main": "index.js",
+  "type": "module",
   "engines": {
     "node": ">=12"
   },

test/fixture.js

@@ -3,87 +3,86 @@
 
 /* eslint-env mocha */
 
-var request = require('supertest');
-var fixture = require('./fixture');
+import request from 'supertest';
 
 /**
  * Shared expectations for each version of the hash API.
  */
 
-module.exports = function (app) {
+export default function (app) {
 
-  it('hashes an http.IncomingMessage', function (done) {
-    request(app())
+  it('hashes an http.IncomingMessage', function () {
+    return request(app())
     .get('/')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
-    .expect(fixture[this.test.title], done);
+    .expect('09a3df93c944461cee09969f2a4bb848');
   });
 
-  it('produces a different hash for a different path', function (done) {
-    request(app())
+  it('produces a different hash for a different path', function () {
+    return request(app())
     .get('/quux')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
-    .expect(fixture[this.test.title], done);
+    .expect('85713c266b81f0be1d61b281405bafc0');
   });
 
-  it('produces a different hash for a different query string', function (done) {
-    request(app())
+  it('produces a different hash for a different query string', function () {
+    return request(app())
     .get('/?foo=1&bar=2')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
-    .expect(fixture[this.test.title], done);
+    .expect('2f8a8a2c8b6f286e65848160ba8c6ab1');
   });
 
-  it('produces the same hash for different ordered query params', function (done) {
-    request(app())
+  it('produces the same hash for different ordered query params', function () {
+    return request(app())
     .get('/?bar=2&foo=1')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
-    .expect(fixture[this.test.title], done);
+    .expect('2f8a8a2c8b6f286e65848160ba8c6ab1');
   });
 
-  it('produces a different hash for a different method', function (done) {
-    request(app())
+  it('produces a different hash for a different method', function () {
+    return request(app())
     .post('/')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
-    .expect(fixture[this.test.title], done);
+    .expect('6db371c210f891e15229c3a9470da6a6');
   });
 
-  it('produces a different hash for different headers', function (done) {
-    request(app())
+  it('produces a different hash for different headers', function () {
+    return request(app())
     .get('/')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
     .set('x-foo', 'bar')
-    .expect(fixture[this.test.title], done);
+    .expect('46e486ddb60f2236f77c8bbe29d6c760');
   });
 
-  it('produces a different hash for a different post body', function (done) {
-    request(app())
+  it('produces a different hash for a different post body', function () {
+    return request(app())
     .post('/')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
     .send('yay')
-    .expect(fixture[this.test.title], done);
+    .expect('e84cf2827fbc172a5957e3b29a1f47d5');
   });
 
-  it('can use a different hash algorithm', function (done) {
-    request(app('sha1'))
+  it('can use a different hash algorithm', function () {
+    return request(app('sha1'))
     .get('/')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
-    .expect(fixture[this.test.title], done);
+    .expect("d8b3b0f8af8babb29291719b3bbbaa45b1aaaa85");
   });
 
-  it('can use a different encoding', function (done) {
-    request(app('md5', 'base64'))
+  it('can use a different encoding', function () {
+    return request(app('md5', 'base64'))
     .get('/')
     .set('host', 'localhost:4567')
     .set('user-agent', 'node-superagent/1.3.0')
-    .expect(fixture[this.test.title], done);
+    .expect('CaPfk8lERhzuCZafKku4SA==');
   });
 
-};
+}