@johntalton/http-util 6.1.0 → 7.0.2

package/src/response/5xx/not-implemented.js

@@ -1,7 +1,6 @@
 import http2 from 'node:http2'
 
-import { CONTENT_TYPE_TEXT } from '../../headers/content-type.js'
-import { send } from '../send-util.js'
+import { send_error } from '../send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from '../../defs.js' */
@@ -14,5 +13,5 @@ const { HTTP_STATUS_NOT_IMPLEMENTED } = http2.constants
  * @param {Metadata} meta
  */
 export function sendNotImplemented(stream, message, meta) {
-	send(stream, HTTP_STATUS_NOT_IMPLEMENTED, {}, [], CONTENT_TYPE_TEXT, message, meta)
+	send_error(stream, HTTP_STATUS_NOT_IMPLEMENTED, message, undefined, meta)
 }

package/src/response/5xx/unavailable.js

@@ -1,37 +1,20 @@
 import http2 from 'node:http2'
 
-import { CONTENT_TYPE_TEXT } from '../../headers/content-type.js'
-import { send } from '../send-util.js'
+import { send_error } from '../send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { SendInfo, Metadata } from '../../defs.js' */
 
-const {
-	HTTP2_HEADER_RETRY_AFTER
-} = http2.constants
-
 const { HTTP_STATUS_SERVICE_UNAVAILABLE } = http2.constants
 
-/**
- * @param {ServerHttp2Stream} stream
- * @param {string|undefined} message
- * @param {number|undefined} retryAfter
- * @param {Metadata} meta
- */
-export function sendUnavailable(stream, message, retryAfter, meta) {
-	_sendUnavailable(stream, message, { retryAfter }, meta)
-}
-
 /**
  * @param {ServerHttp2Stream} stream
  * @param {string|undefined} message
  * @param {Pick<SendInfo, 'retryAfter'>} info
  * @param {Metadata} meta
  */
-export function _sendUnavailable(stream, message, info, meta) {
+export function sendUnavailable(stream, message, info, meta) {
 	const { retryAfter } = info
 
-	send(stream, HTTP_STATUS_SERVICE_UNAVAILABLE, {
-		[HTTP2_HEADER_RETRY_AFTER]: Number.isInteger(retryAfter) ? `${retryAfter}` : undefined
-	}, [ HTTP2_HEADER_RETRY_AFTER ], CONTENT_TYPE_TEXT, message, meta)
+	send_error(stream, HTTP_STATUS_SERVICE_UNAVAILABLE, message, retryAfter, meta)
 }

package/src/response/header-util.js

@@ -1,5 +1,7 @@
 import http2 from 'node:http2'
 
+import { COMMON_LIST_VALUE_JOINER_COMMA } from '../defs.js'
+
 import {
 	HTTP_HEADER_SERVER_TIMING,
 	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
@@ -15,8 +17,8 @@ const {
 	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
 	HTTP2_HEADER_CONTENT_TYPE,
 	HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS,
-
-	HTTP2_HEADER_ETAG
+	HTTP2_HEADER_ETAG,
+	// HTTP2_HEADER_STRICT_TRANSPORT_SECURITY
 } = http2.constants
 
 /**
@@ -27,11 +29,12 @@ const {
  * @returns {OutgoingHttpHeaders}
  */
 export function coreHeaders(status, contentType, exposedHeaders, meta) {
-	const exposed = [ HTTP2_HEADER_ETAG, HTTP2_HEADER_SERVER, ...exposedHeaders ]
+	const exposed = [ HTTP2_HEADER_ETAG, HTTP2_HEADER_SERVER, ...exposedHeaders ] // todo include lastModified
 
 	return {
+		// todo [HTTP2_HEADER_STRICT_TRANSPORT_SECURITY]: StrictTransportSecurity.encode(meta.hsts)
 		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS]: exposed.join(','),
+		[HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS]: exposed.join(COMMON_LIST_VALUE_JOINER_COMMA),
 		// Access-Control-Allow-Credentials // for non-preflight
 		[HTTP2_HEADER_STATUS]: status,
 		[HTTP2_HEADER_CONTENT_TYPE]: contentType,
@@ -55,6 +58,7 @@ export function performanceHeaders(meta) {
  * @returns {OutgoingHttpHeaders}
  */
 export function customHeaders(meta) {
-	const m = new Map(meta.customHeaders?.filter(h => h[0].startsWith('X-')))
+	const CUSTOM_HEADER_PREFIX = 'X-'
+	const m = new Map(meta.customHeaders?.filter(h => h[0].startsWith(CUSTOM_HEADER_PREFIX)))
 	return Object.fromEntries(m)
 }

package/src/response/response.js

@@ -1,7 +1,7 @@
 import { sendAccepted } from './2xx/accepted.js'
 import { sendBytes } from './2xx/bytes.js'
 import { sendCreated } from './2xx/created.js'
-import { sendJSON_Encoded } from './2xx/json.js'
+import { sendJSON } from './2xx/json.js'
 import { sendNoContent } from './2xx/no-content.js'
 import { sendPartialContent } from './2xx/partial-content.js'
 import { sendPreflight } from './2xx/preflight.js'
@@ -49,7 +49,7 @@ export const Response = {
 	gone: sendGone,
 	imATeapot: sendImATeapot,
 	insufficientStorage: sendInsufficientStorage,
-	json: sendJSON_Encoded,
+	json: sendJSON,
 	movedPermanently: sendMovedPermanently,
 	multipleChoices: sendMultipleChoices,
 	noContent: sendNoContent,

package/src/response/send-util.js

@@ -1,18 +1,13 @@
 import http2 from 'node:http2'
-import { pipeline, Readable } from 'node:stream'
+import { compose, pipeline, Readable } from 'node:stream'
 import { ReadableStream } from 'node:stream/web'
-import {
-	brotliCompressSync,
-	deflateSync,
-	gzipSync,
-	zstdCompressSync
-} from 'node:zlib'
+import zlib from 'node:zlib'
 
-import { HTTP_HEADER_ACCEPT_QUERY } from '../defs.js'
+import { COMMON_LIST_VALUE_JOINER_COMMA, HTTP_HEADER_ACCEPT_QUERY } from '../defs.js'
 import { CacheControl } from '../headers/cache-control.js'
 import { Conditional } from '../headers/conditional.js'
 import { ContentRange } from '../headers/content-range.js'
-import { CHARSET_UTF8 } from '../headers/content-type.js'
+import { CHARSET_UTF8, CONTENT_TYPE_JSON } from '../headers/content-type.js'
 import {
 	coreHeaders,
 	customHeaders,
@@ -21,7 +16,7 @@ import {
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { OutgoingHttpHeaders } from 'node:http2' */
-/** @import { InputType } from 'node:zlib' */
+/** @import { InputType, BrotliOptions, ZlibOptions, ZstdOptions } from 'node:zlib' */
 /** @import { AcceptRangeUnits, Metadata, SendBody } from '../defs.js' */
 /** @import { EtagItem, IMFFixDateInput } from '../headers/conditional.js' */
 /** @import { CacheControlOptions } from '../headers/cache-control.js' */
@@ -45,19 +40,95 @@ const {
 	HTTP2_HEADER_CONTENT_LENGTH,
 	HTTP2_HEADER_ACCEPT,
 	HTTP2_HEADER_ACCEPT_ENCODING,
-	HTTP2_HEADER_RANGE
+	HTTP2_HEADER_RANGE,
+	HTTP2_HEADER_RETRY_AFTER
 } = http2.constants
 
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {number} status
+ * @param {OutgoingHttpHeaders} headers
+ * @param {Array<string>} exposedHeaders
+ * @param {Metadata} meta
+ */
+export function send_no_body(stream, status, headers, exposedHeaders, meta) {
+	send(stream, status, headers, exposedHeaders, undefined, undefined, meta)
+}
+
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {number} status
+ * @param {string|undefined} message
+ * @param {number|undefined} retryAfter
+ * @param {Metadata} meta
+ */
+export function send_error(stream, status, message, retryAfter, meta) {
+	const obj = JSON.stringify({
+		message: message ?? 'Error'
+	})
+
+	const exposedHeaders = Number.isInteger(retryAfter) ? [ HTTP2_HEADER_RETRY_AFTER ] : []
+
+	send(stream, status, {
+		[HTTP2_HEADER_RETRY_AFTER]: Number.isInteger(retryAfter) ? `${retryAfter}` : undefined
+	}, exposedHeaders, CONTENT_TYPE_JSON, obj, meta) // todo should this be plain text
+}
+
 /** @typedef { (data: InputType) => Buffer<ArrayBuffer> } EncoderFun */
 
 /** @type {Map<string, EncoderFun>} */
 export const ENCODER_MAP = new Map([
-	[ 'br', data => brotliCompressSync(data) ],
-	[ 'gzip', data => gzipSync(data) ],
-	[ 'deflate', data => deflateSync(data) ],
-	[ 'zstd', data => zstdCompressSync(data) ]
+	[ 'br', data => zlib.brotliCompressSync(data) ],
+	[ 'gzip', data => zlib.gzipSync(data) ],
+	[ 'deflate', data => zlib.deflateSync(data) ],
+	[ 'zstd', data => zlib.zstdCompressSync(data) ]
 ])
 
+/** @type {BrotliOptions} */
+export const ENCODER_STREAM_BR_OPTIONS = { }
+
+/** @type {ZlibOptions} */
+export const ENCODER_STREAM_GZIP_OPTIONS = {}
+
+/** @type {ZlibOptions} */
+export const ENCODER_STREAM_DEFLATE_OPTIONS = {}
+
+/** @type {ZstdOptions} */
+export const ENCODER_STREAM_ZSTD_OPTIONS = {}
+
+/** @typedef {(stream: Readable) => Readable} EncoderStreamFn */
+
+/** @type {Map<string, EncoderStreamFn>} */
+export const ENCODER_STREAM_MAP = new Map([
+	[ 'br', stream => compose(stream, zlib.createBrotliCompress(ENCODER_STREAM_BR_OPTIONS)) ],
+	[ 'gzip', stream => compose(stream, zlib.createGzip(ENCODER_STREAM_GZIP_OPTIONS)) ],
+	[ 'deflate', stream => compose(stream, zlib.createDeflate(ENCODER_STREAM_DEFLATE_OPTIONS)) ],
+	[ 'zstd', stream => compose(stream, zlib.createZstdCompress(ENCODER_STREAM_ZSTD_OPTIONS)) ]
+])
+
+
+/**
+ * @template T
+ * @param {string|undefined|'identity'} encoding
+ * @param {Map<string, T>} listing
+ * @returns {{ encoderFn: T | undefined, encoding: string | undefined }}
+ */
+export function lookupEncoder(encoding, listing) {
+	const encoderFn = listing.get(encoding ?? 'identity')
+	if(encoderFn === undefined) {
+		return {
+			encoderFn: undefined,
+			encoding: encoding === 'identity' ? encoding : undefined
+		}
+	}
+
+	return {
+		encoderFn,
+		encoding
+	}
+}
+
 /**
  * @param {ServerHttp2Stream} stream
  * @param {number} status
@@ -75,13 +146,16 @@ export const ENCODER_MAP = new Map([
 export function send_encoded(stream, status, contentType, body, encoding, etag, lastModified, age, cacheControl, acceptRanges, supportedQueryTypes, meta) {
 	const obj = (typeof body === 'string') ? Buffer.from(body, CHARSET_UTF8) : body
 
-	const useIdentity = encoding === 'identity'
-	const encoder = encoding === undefined ? undefined : ENCODER_MAP.get(encoding)
-	const hasEncoder = encoder !== undefined
-	const actualEncoding = hasEncoder ? encoding : undefined
+	if((obj instanceof ReadableStream) || (obj instanceof Readable)) {
+		const { encoderFn, encoding: actualEncoding } = lookupEncoder(encoding,	 ENCODER_STREAM_MAP)
+		const encodedStream = (encoderFn === undefined) ? obj : encoderFn((obj instanceof ReadableStream) ? Readable.fromWeb(obj) : obj)
+		send_bytes(stream, status, contentType, encodedStream, undefined, undefined, actualEncoding, etag, lastModified, age, cacheControl, acceptRanges, supportedQueryTypes, meta )
+		return
+	}
 
+	const { encoderFn, encoding: actualEncoding } = lookupEncoder(encoding, ENCODER_MAP)
 	const encodeStart = performance.now()
-	const encodedData = (hasEncoder && !useIdentity) ? encoder(obj) : obj
+	const encodedData = (encoderFn === undefined) ? obj : encoderFn(obj)
 	const encodeEnd = performance.now()
 
 	meta.performance.push(
@@ -91,7 +165,6 @@ export function send_encoded(stream, status, contentType, body, encoding, etag,
 	send_bytes(stream, status, contentType, encodedData, undefined, undefined, actualEncoding, etag, lastModified, age, cacheControl, acceptRanges, supportedQueryTypes, meta )
 }
 
-
 /**
  * @param {ServerHttp2Stream} stream
  * @param {number} status
@@ -123,15 +196,15 @@ export function send_bytes(stream, status, contentType, obj, range, contentLengt
 
 	send(stream, status, {
 			[HTTP2_HEADER_CONTENT_ENCODING]: encoding,
-			[HTTP2_HEADER_VARY]: varyHeaders.join(','),
+			[HTTP2_HEADER_VARY]: varyHeaders.join(COMMON_LIST_VALUE_JOINER_COMMA),
 			[HTTP2_HEADER_CACHE_CONTROL]: CacheControl.encode(cacheControl),
 			[HTTP2_HEADER_ETAG]: Conditional.encodeEtag(etag),
 			[HTTP2_HEADER_LAST_MODIFIED]: Conditional.encodeFixDate(lastModified),
-			[HTTP2_HEADER_AGE]: age === undefined ? undefined : `${age}`,
+			[HTTP2_HEADER_AGE]: Number.isInteger(age) ? `${age}` : undefined,
 			[HTTP2_HEADER_CONTENT_LENGTH]: contentLen,
 			[HTTP2_HEADER_CONTENT_RANGE]: ContentRange.encode(range),
 			[HTTP2_HEADER_ACCEPT_RANGES]: acceptRanges,
-			[HTTP_HEADER_ACCEPT_QUERY]: supportedQueryTypes?.join(',')
+			[HTTP_HEADER_ACCEPT_QUERY]: supportedQueryTypes?.join(COMMON_LIST_VALUE_JOINER_COMMA)
 		}, exposedHeaders, contentType, obj, meta)
 }
 
@@ -167,14 +240,13 @@ export function send(stream, status, headers, exposedHeaders, contentType, body,
 	}
 
 	if(stream.writable && body !== undefined) {
-		if(body instanceof ReadableStream) {
-			const signal = undefined // AbortSignal.timeout(1000)
+		if(body instanceof ReadableStream || body instanceof Readable) {
 			pipeline(
-				Readable.fromWeb(body, { signal }),
+				body,
 				stream,
 				err => {
-					if(err !== null) {
-						console.warn('pipeline error')
+					if(err !== null && err !== undefined) {
+						console.warn('pipeline error', err)
 					}
 				})
 
@@ -187,4 +259,4 @@ export function send(stream, status, headers, exposedHeaders, contentType, body,
 
 	stream.end()
 	// if(!stream.closed) { stream.close() }
-}
+}