pax_global_header00006660000000000000000000000064134336671640014527gustar00rootroot0000000000000052 comment=c05140cde9bbce2127926752433271c6f3fe8787 on-headers-1.0.2/000077500000000000000000000000001343366716400135545ustar00rootroot00000000000000on-headers-1.0.2/.eslintignore000066400000000000000000000000261343366716400162550ustar00rootroot00000000000000coverage node_modules on-headers-1.0.2/.eslintrc.yml000066400000000000000000000000771343366716400162040ustar00rootroot00000000000000root: true extends: standard rules: no-param-reassign: error on-headers-1.0.2/.gitignore000066400000000000000000000000441343366716400155420ustar00rootroot00000000000000coverage node_modules npm-debug.log on-headers-1.0.2/.travis.yml000066400000000000000000000054031343366716400156670ustar00rootroot00000000000000language: node_js node_js: - "0.8" - "0.10" - "0.12" - "1.8" - "2.5" - "3.3" - "4.9" - "5.12" - "6.16" - "7.10" - "8.15" - "9.11" - "10.15" - "11.10" sudo: false cache: directories: - node_modules before_install: - | # Setup utility functions function node_version_lt () { [[ "$(v "$TRAVIS_NODE_VERSION")" -lt "$(v "${1}")" ]] } function npm_module_installed () { npm -lsp ls | grep -Fq "$(pwd)/node_modules/${1}:${1}@" } function npm_remove_module_re () { node -e ' fs = require("fs"); p = JSON.parse(fs.readFileSync("package.json", "utf8")); r = RegExp(process.argv[1]); for (k in p.devDependencies) { if (r.test(k)) delete p.devDependencies[k]; } fs.writeFileSync("package.json", JSON.stringify(p, null, 2) + "\n"); ' "$@" } function npm_use_module () { node -e ' fs = require("fs"); p = JSON.parse(fs.readFileSync("package.json", "utf8")); p.devDependencies[process.argv[1]] = process.argv[2]; fs.writeFileSync("package.json", JSON.stringify(p, null, 2) + "\n"); ' "$@" } function v () { tr '.' '\n' <<< "${1}" \ | awk '{ printf "%03d", $0 }' \ | sed 's/^0*//' } # Configure npm - | # Skip updating shrinkwrap / lock npm config set shrinkwrap false # Setup Node.js version-specific dependencies - | # Configure mocha for testing if node_version_lt '0.10'; then npm_use_module 'mocha' '2.5.3' elif node_version_lt '4.0' ; then npm_use_module 'mocha' '3.5.3' elif node_version_lt '6.0' ; then npm_use_module 'mocha' '5.2.0' fi - | # Configure istanbul for coverage if node_version_lt '0.10'; then npm_remove_module_re '^istanbul$' fi - | # Configure supertest for http calls if node_version_lt '0.10'; then npm_use_module 'supertest' '1.1.0' elif node_version_lt '4.0' ; then npm_use_module 'supertest' '2.0.0' fi - | # Configure eslint for linting if node_version_lt '6.0'; then npm_remove_module_re '^eslint(-|$)' fi # Update Node.js modules - | # Prune & rebuild node_modules if [[ -d node_modules ]]; then npm prune npm rebuild fi before_scrpt: - | # Contents of node_modules npm -s ls ||: script: - | # Run test script, depending on istanbul install if npm_module_installed 'istanbul'; then npm run-script test-travis else npm test fi - | # Run linting, if eslint exists if npm_module_installed 'eslint'; then npm run-script lint fi after_script: - | # Upload coverage to coveralls if exists if [[ -e ./coverage/lcov.info ]]; then npm install --save-dev coveralls@2 coveralls < ./coverage/lcov.info fi on-headers-1.0.2/HISTORY.md000066400000000000000000000006031343366716400152360ustar00rootroot000000000000001.0.2 / 2019-02-21 ================== * Fix `res.writeHead` patch missing return value 1.0.1 / 2015-09-29 ================== * perf: enable strict mode 1.0.0 / 2014-08-10 ================== * Honor `res.statusCode` change in `listener` * Move to `jshttp` organization * Prevent `arguments`-related de-opt 0.0.0 / 2014-05-13 ================== * Initial implementation on-headers-1.0.2/LICENSE000066400000000000000000000021011343366716400145530ustar00rootroot00000000000000(The MIT License) Copyright (c) 2014 Douglas Christopher Wilson Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. on-headers-1.0.2/README.md000066400000000000000000000041531343366716400150360ustar00rootroot00000000000000# on-headers [![NPM Version][npm-version-image]][npm-url] [![NPM Downloads][npm-downloads-image]][npm-url] [![Node.js Version][node-version-image]][node-version-url] [![Build Status][travis-image]][travis-url] [![Test Coverage][coveralls-image]][coveralls-url] Execute a listener when a response is about to write headers. ## Installation This is a [Node.js](https://nodejs.org/en/) module available through the [npm registry](https://www.npmjs.com/). Installation is done using the [`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): ```sh $ npm install on-headers ``` ## API ```js var onHeaders = require('on-headers') ``` ### onHeaders(res, listener) This will add the listener `listener` to fire when headers are emitted for `res`. The listener is passed the `response` object as it's context (`this`). Headers are considered to be emitted only once, right before they are sent to the client. When this is called multiple times on the same `res`, the `listener`s are fired in the reverse order they were added. ## Examples ```js var http = require('http') var onHeaders = require('on-headers') http .createServer(onRequest) .listen(3000) function addPoweredBy () { // set if not set by end of request if (!this.getHeader('X-Powered-By')) { this.setHeader('X-Powered-By', 'Node.js') } } function onRequest (req, res) { onHeaders(res, addPoweredBy) res.setHeader('Content-Type', 'text/plain') res.end('hello!') } ``` ## Testing ```sh $ npm test ``` ## License [MIT](LICENSE) [coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/on-headers/master [coveralls-url]: https://coveralls.io/r/jshttp/on-headers?branch=master [node-version-image]: https://badgen.net/npm/node/on-headers [node-version-url]: https://nodejs.org/en/download [npm-downloads-image]: https://badgen.net/npm/dm/on-headers [npm-url]: https://npmjs.org/package/on-headers [npm-version-image]: https://badgen.net/npm/v/on-headers [travis-image]: https://badgen.net/travis/jshttp/on-headers/master [travis-url]: https://travis-ci.org/jshttp/on-headers on-headers-1.0.2/index.js000066400000000000000000000051501343366716400152220ustar00rootroot00000000000000/*! * on-headers * Copyright(c) 2014 Douglas Christopher Wilson * MIT Licensed */ 'use strict' /** * Module exports. * @public */ module.exports = onHeaders /** * Create a replacement writeHead method. * * @param {function} prevWriteHead * @param {function} listener * @private */ function createWriteHead (prevWriteHead, listener) { var fired = false // return function with core name and argument list return function writeHead (statusCode) { // set headers from arguments var args = setWriteHeadHeaders.apply(this, arguments) // fire listener if (!fired) { fired = true listener.call(this) // pass-along an updated status code if (typeof args[0] === 'number' && this.statusCode !== args[0]) { args[0] = this.statusCode args.length = 1 } } return prevWriteHead.apply(this, args) } } /** * Execute a listener when a response is about to write headers. * * @param {object} res * @return {function} listener * @public */ function onHeaders (res, listener) { if (!res) { throw new TypeError('argument res is required') } if (typeof listener !== 'function') { throw new TypeError('argument listener must be a function') } res.writeHead = createWriteHead(res.writeHead, listener) } /** * Set headers contained in array on the response object. * * @param {object} res * @param {array} headers * @private */ function setHeadersFromArray (res, headers) { for (var i = 0; i < headers.length; i++) { res.setHeader(headers[i][0], headers[i][1]) } } /** * Set headers contained in object on the response object. * * @param {object} res * @param {object} headers * @private */ function setHeadersFromObject (res, headers) { var keys = Object.keys(headers) for (var i = 0; i < keys.length; i++) { var k = keys[i] if (k) res.setHeader(k, headers[k]) } } /** * Set headers and other properties on the response object. * * @param {number} statusCode * @private */ function setWriteHeadHeaders (statusCode) { var length = arguments.length var headerIndex = length > 1 && typeof arguments[1] === 'string' ? 2 : 1 var headers = length >= headerIndex + 1 ? arguments[headerIndex] : undefined this.statusCode = statusCode if (Array.isArray(headers)) { // handle array case setHeadersFromArray(this, headers) } else if (headers) { // handle object case setHeadersFromObject(this, headers) } // copy leading arguments var args = new Array(Math.min(length, headerIndex)) for (var i = 0; i < args.length; i++) { args[i] = arguments[i] } return args } on-headers-1.0.2/package.json000066400000000000000000000023331343366716400160430ustar00rootroot00000000000000{ "name": "on-headers", "description": "Execute a listener when a response is about to write headers", "version": "1.0.2", "author": "Douglas Christopher Wilson ", "license": "MIT", "keywords": [ "event", "headers", "http", "onheaders" ], "repository": "jshttp/on-headers", "devDependencies": { "eslint": "5.14.1", "eslint-config-standard": "12.0.0", "eslint-plugin-import": "2.16.0", "eslint-plugin-markdown": "1.0.0", "eslint-plugin-node": "8.0.1", "eslint-plugin-promise": "4.0.1", "eslint-plugin-standard": "4.0.0", "istanbul": "0.4.5", "mocha": "6.0.1", "supertest": "3.4.2" }, "files": [ "LICENSE", "HISTORY.md", "README.md", "index.js" ], "engines": { "node": ">= 0.8" }, "scripts": { "lint": "eslint --plugin markdown --ext js,md .", "test": "mocha --reporter spec --bail --check-leaks test/", "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot --check-leaks test/", "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec --check-leaks test/", "version": "node scripts/version-history.js && git add HISTORY.md" } } on-headers-1.0.2/scripts/000077500000000000000000000000001343366716400152435ustar00rootroot00000000000000on-headers-1.0.2/scripts/version-history.js000066400000000000000000000027771343366716400210020ustar00rootroot00000000000000'use strict' var fs = require('fs') var path = require('path') var HISTORY_FILE_PATH = path.join(__dirname, '..', 'HISTORY.md') var MD_HEADER_REGEXP = /^====*$/ var VERSION = process.env.npm_package_version var VERSION_PLACEHOLDER_REGEXP = /^(?:unreleased|(\d+\.)+x)$/ var historyFileLines = fs.readFileSync(HISTORY_FILE_PATH, 'utf-8').split('\n') if (!MD_HEADER_REGEXP.test(historyFileLines[1])) { console.error('Missing header in HISTORY.md') process.exit(1) } if (!VERSION_PLACEHOLDER_REGEXP.test(historyFileLines[0])) { console.error('Missing placegolder version in HISTORY.md') process.exit(1) } if (historyFileLines[0].indexOf('x') !== -1) { var versionCheckRegExp = new RegExp('^' + historyFileLines[0].replace('x', '.+') + '$') if (!versionCheckRegExp.test(VERSION)) { console.error('Version %s does not match placeholder %s', VERSION, historyFileLines[0]) process.exit(1) } } historyFileLines[0] = VERSION + ' / ' + getLocaleDate() historyFileLines[1] = repeat('=', historyFileLines[0].length) fs.writeFileSync(HISTORY_FILE_PATH, historyFileLines.join('\n')) function getLocaleDate () { var now = new Date() return zeroPad(now.getFullYear(), 4) + '-' + zeroPad(now.getMonth() + 1, 2) + '-' + zeroPad(now.getDate(), 2) } function repeat (str, length) { var out = '' for (var i = 0; i < length; i++) { out += str } return out } function zeroPad (number, length) { var num = number.toString() while (num.length < length) { num = '0' + num } return num } on-headers-1.0.2/test/000077500000000000000000000000001343366716400145335ustar00rootroot00000000000000on-headers-1.0.2/test/.eslintrc.yml000066400000000000000000000000231343366716400171520ustar00rootroot00000000000000env: mocha: true on-headers-1.0.2/test/test.js000066400000000000000000000170031343366716400160510ustar00rootroot00000000000000 var assert = require('assert') var http = require('http') var onHeaders = require('..') var request = require('supertest') describe('onHeaders(res, listener)', function () { it('should fire after setHeader', function (done) { var server = createServer(echoListener) request(server) .get('/') .expect('X-Outgoing-Echo', 'test') .expect(200, done) }) it('should fire before write', function (done) { var server = createServer(echoListener, handler) function handler (req, res) { res.setHeader('X-Outgoing', 'test') res.write('1') } request(server) .get('/') .expect('X-Outgoing-Echo', 'test') .expect(200, '1', done) }) it('should fire with no headers', function (done) { var server = createServer(listener, handler) function handler (req, res) {} function listener (req, res) { this.setHeader('X-Headers', Object.keys(this._headers || {}).join(',')) } request(server) .get('/') .expect('X-Headers', '') .expect(200, done) }) it('should fire only once', function (done) { var count = 0 var server = createServer(listener, handler) function handler (req, res) { res.writeHead(200) try { res.writeHead(200) } catch (e) {} } function listener (req, res) { count++ } request(server) .get('/') .expect(200, function (err) { if (err) return done(err) assert.strictEqual(count, 1) done() }) }) it('should fire in reverse order', function (done) { var server = createServer(echoListener, handler) function handler (req, res) { onHeaders(res, appendHeader(1)) onHeaders(res, appendHeader(2)) onHeaders(res, appendHeader(3)) res.setHeader('X-Outgoing', 'test') } request(server) .get('/') .expect('X-Outgoing-Echo', 'test,3,2,1') .expect(200, done) }) describe('arguments', function () { describe('res', function () { it('should be required', function () { assert.throws(onHeaders.bind(), /res.*required/) }) }) describe('listener', function () { it('should be required', function (done) { var server = createServer() request(server) .get('/') .expect(500, /listener.*function/, done) }) it('should only accept function', function (done) { var server = createServer(42) request(server) .get('/') .expect(500, /listener.*function/, done) }) }) }) describe('setHeader', function () { it('should be available in listener', function (done) { var server = createServer(echoListener) request(server) .get('/') .expect('X-Outgoing-Echo', 'test') .expect(200, done) }) }) describe('writeHead(status)', function () { it('should make status available in listener', function (done) { var server = createServer(listener, handler) function handler (req, res) { res.writeHead(201) } function listener (req, res) { this.setHeader('X-Status', this.statusCode) } request(server) .get('/') .expect('X-Status', '201') .expect(201, done) }) it('should allow manipulation of status in listener', function (done) { var server = createServer(listener, handler) function handler (req, res) { res.writeHead(201) } function listener (req, res) { this.setHeader('X-Status', this.statusCode) this.statusCode = 202 } request(server) .get('/') .expect('X-Status', '201') .expect(202, done) }) it('should pass-through core error', function (done) { var server = createServer(appendHeader(1), handler) function handler (req, res) { res.writeHead() // error } request(server) .get('/') .expect(500, done) }) it('should retain return value', function (done) { var server = http.createServer(function (req, res) { if (req.url === '/attach') { onHeaders(res, appendHeader(1)) } res.end(typeof res.writeHead(200)) }) request(server) .get('/') .expect(200, function (err, res) { if (err) return done(err) request(server) .get('/attach') .expect(200, res.text, done) }) }) }) describe('writeHead(status, reason)', function () { it('should be available in listener', function (done) { var server = createServer(echoListener, handler) function handler (req, res) { res.setHeader('X-Outgoing', 'test') res.writeHead(200, 'OK') } request(server) .get('/') .expect('X-Outgoing-Echo', 'test') .expect(200, done) }) }) describe('writeHead(status, reason, obj)', function () { it('should be available in listener', function (done) { var server = createServer(echoListener, handler) function handler (req, res) { res.writeHead(200, 'OK', { 'X-Outgoing': 'test' }) } request(server) .get('/') .expect('X-Outgoing-Echo', 'test') .expect(200, done) }) }) describe('writeHead(status, obj)', function () { it('should be available in listener', function (done) { var server = createServer(listener, handler) function handler (req, res) { res.writeHead(201, { 'X-Outgoing': 'test' }) } function listener (req, res) { this.setHeader('X-Status', this.statusCode) this.setHeader('X-Outgoing-Echo', this.getHeader('X-Outgoing')) } request(server) .get('/') .expect('X-Status', '201') .expect('X-Outgoing-Echo', 'test') .expect(201, done) }) it('should handle falsy keys', function (done) { var server = createServer(listener, handler) function handler (req, res) { res.writeHead(201, { 'X-Outgoing': 'test', '': 'test' }) } function listener (req, res) { this.setHeader('X-Status', this.statusCode) this.setHeader('X-Outgoing-Echo', this.getHeader('X-Outgoing')) } request(server) .get('/') .expect('X-Status', '201') .expect('X-Outgoing-Echo', 'test') .expect(201, done) }) }) describe('writeHead(status, arr)', function () { it('should be available in listener', function (done) { var server = createServer(listener, handler) function handler (req, res) { res.writeHead(201, [['X-Outgoing', 'test']]) } function listener (req, res) { this.setHeader('X-Status', this.statusCode) this.setHeader('X-Outgoing-Echo', this.getHeader('X-Outgoing')) } request(server) .get('/') .expect('X-Status', '201') .expect('X-Outgoing-Echo', 'test') .expect(201, done) }) }) }) function createServer (listener, handler) { var fn = handler || echoHandler return http.createServer(function (req, res) { try { onHeaders(res, listener) fn(req, res) res.statusCode = 200 } catch (err) { res.statusCode = 500 res.write(err.message) } finally { res.end() } }) } function appendHeader (num) { return function onHeaders () { this.setHeader('X-Outgoing', this.getHeader('X-Outgoing') + ',' + num) } } function echoHandler (req, res) { res.setHeader('X-Outgoing', 'test') } function echoListener () { this.setHeader('X-Outgoing-Echo', this.getHeader('X-Outgoing')) }