@johntalton/http-util 4.1.1 → 5.0.1

package/src/response/see-other.js

@@ -0,0 +1,23 @@
+import http2 from 'node:http2'
+
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const {
+  HTTP2_HEADER_LOCATION
+} = http2.constants
+
+const { HTTP_STATUS_SEE_OTHER } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {URL} location
+ * @param {Metadata} meta
+ */
+export function sendSeeOther(stream, location, meta) {
+  send(stream, HTTP_STATUS_SEE_OTHER, {
+    [HTTP2_HEADER_LOCATION]: location.href
+  }, [ HTTP2_HEADER_LOCATION ], undefined, undefined, meta)
+}

package/src/response/send-util.js

@@ -1,3 +1,18 @@
+import http2 from 'node:http2'
+import { Readable } from 'node:stream'
+import { ReadableStream } from 'node:stream/web'
+import {
+	brotliCompressSync,
+	deflateSync,
+	gzipSync,
+	zstdCompressSync
+} from 'node:zlib'
+
+import { CacheControl } from '../cache-control.js'
+import { Conditional } from '../conditional.js'
+import { ContentRange } from '../content-range.js'
+import { CHARSET_UTF8 } from '../content-type.js'
+import { HTTP_HEADER_ACCEPT_QUERY } from './defs.js'
 import {
 	coreHeaders,
 	customHeaders,
@@ -6,7 +21,117 @@ import {
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { IncomingHttpHeaders } from 'node:http2' */
+/** @import { InputType } from 'node:zlib' */
 /** @import { Metadata } from './defs.js' */
+/** @import { EtagItem } from '../conditional.js' */
+/** @import { CacheControlOptions } from '../cache-control.js' */
+/** @import { ContentRangeDirective } from '../content-range.js' */
+
+/** @typedef {ArrayBufferLike|ArrayBufferView|ReadableStream|string} SendBody */
+
+const {
+	HTTP_STATUS_INTERNAL_SERVER_ERROR,
+	HTTP_STATUS_NOT_FOUND,
+	HTTP_STATUS_UNAUTHORIZED
+} = http2.constants
+
+const {
+	HTTP2_HEADER_CONTENT_ENCODING,
+	HTTP2_HEADER_VARY,
+	HTTP2_HEADER_CACHE_CONTROL,
+	HTTP2_HEADER_ETAG,
+	HTTP2_HEADER_AGE,
+	HTTP2_HEADER_ACCEPT_RANGES,
+	HTTP2_HEADER_CONTENT_RANGE,
+	HTTP2_HEADER_CONTENT_LENGTH,
+	HTTP2_HEADER_ACCEPT,
+	HTTP2_HEADER_ACCEPT_ENCODING,
+	HTTP2_HEADER_RANGE
+} = http2.constants
+
+/** @typedef { (data: InputType) => Buffer } 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) ]
+])
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {number} status
+ * @param {string|undefined} contentType
+ * @param {SendBody} body
+ * @param {string|undefined} encoding
+ * @param {EtagItem|undefined} etag
+ * @param {number|undefined} age
+ * @param {CacheControlOptions|undefined} cacheControl
+ * @param {'bytes'|'none'|undefined} acceptRanges
+ * @param {Array<string>|undefined} supportedQueryTypes
+ * @param {Metadata} meta
+ */
+export function send_encoded(stream, status, contentType, body, encoding, etag, age, cacheControl, acceptRanges, supportedQueryTypes, meta) {
+	const obj = (typeof body === 'string') ? Buffer.from(body, CHARSET_UTF8) : body
+
+	const useIdentity = encoding === 'identity'
+	const encoder = encoding !== undefined ? ENCODER_MAP.get(encoding) : undefined
+	const hasEncoder = encoder !== undefined
+	const actualEncoding = hasEncoder ? encoding : undefined
+
+	const encodeStart = performance.now()
+	const encodedData = (hasEncoder && !useIdentity) ? encoder(obj) : obj
+	const encodeEnd = performance.now()
+
+	meta.performance.push(
+		{ name: 'encode', duration: encodeEnd - encodeStart }
+	)
+
+	send_bytes(stream, status, contentType, encodedData, undefined, undefined, actualEncoding, etag, age, cacheControl, acceptRanges, supportedQueryTypes, meta )
+}
+
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {number} status
+ * @param {string|undefined} contentType
+ * @param {SendBody|undefined} obj
+ * @param {ContentRangeDirective|undefined} range
+ * @param {number|undefined} contentLength
+ * @param {string|undefined} encoding
+ * @param {EtagItem|undefined} etag
+ * @param {number|undefined} age
+ * @param {CacheControlOptions|undefined} cacheControl
+ * @param {'bytes'|'none'|undefined} acceptRanges
+ * @param {Array<string>|undefined} supportedQueryTypes
+ * @param {Metadata} meta
+ */
+export function send_bytes(stream, status, contentType, obj, range, contentLength, encoding, etag, age, cacheControl, acceptRanges, supportedQueryTypes, meta) {
+	const contentLen = Number.isInteger(contentLength) ? `${contentLength}` : undefined
+	const supportsQuery = supportedQueryTypes !== undefined && supportedQueryTypes.length > 0
+
+	const exposedHeaders = [ ]
+	if(age !== undefined) { exposedHeaders.push(HTTP2_HEADER_AGE) }
+	if(acceptRanges !== undefined) { exposedHeaders.push(HTTP2_HEADER_ACCEPT_RANGES) }
+	if(range !== undefined) { exposedHeaders.push(HTTP2_HEADER_CONTENT_RANGE) }
+	if(supportsQuery) { exposedHeaders.push(HTTP_HEADER_ACCEPT_QUERY) }
+
+	const varyHeaders = [ HTTP2_HEADER_ACCEPT, HTTP2_HEADER_ACCEPT_ENCODING ]
+	if(range !== undefined) { varyHeaders.push(HTTP2_HEADER_RANGE) } // todo: very on range is true even if not returning a content range (multipart/byteranges)
+
+	send(stream, status, {
+			[HTTP2_HEADER_CONTENT_ENCODING]: encoding,
+			[HTTP2_HEADER_VARY]: varyHeaders.join(','),
+			[HTTP2_HEADER_CACHE_CONTROL]: CacheControl.encode(cacheControl),
+			[HTTP2_HEADER_ETAG]: Conditional.encodeEtag(etag),
+			[HTTP2_HEADER_AGE]: age !== undefined ? `${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(',')
+		}, exposedHeaders, contentType, obj, meta)
+}
 
 /**
  * @param {ServerHttp2Stream} stream
@@ -14,17 +139,18 @@ import {
  * @param {IncomingHttpHeaders} headers
  * @param {Array<string>} exposedHeaders
  * @param {string|undefined} contentType
- * @param {ArrayBufferLike|ArrayBufferView|string|undefined} body
+ * @param {SendBody|undefined} body
  * @param {Metadata} meta
  */
 export function send(stream, status, headers, exposedHeaders, contentType, body, meta) {
 	// if(status >= 400) { console.warn(status, body) }
-	if(status === 401) { console.warn(status, body) }
-	if(status === 404) { console.warn(status, body) }
-	if(status >= 500) { console.warn(status, body) }
+	if(status === HTTP_STATUS_UNAUTHORIZED) { console.warn(status, body) }
+	if(status === HTTP_STATUS_NOT_FOUND) { console.warn(status, body) }
+	if(status >= HTTP_STATUS_INTERNAL_SERVER_ERROR) { console.warn(status, body) }
+	// console.log('SEND', status, body?.byteLength)
 
-	if(stream === undefined) { return }
-	if(stream.closed) { return }
+	if(stream === undefined) { console.log('send - end stream undef'); return }
+	if(stream.closed) { console.log('send - end closed'); return }
 
 	if(!stream.headersSent) {
 		const custom = customHeaders(meta)
@@ -39,6 +165,11 @@ export function send(stream, status, headers, exposedHeaders, contentType, body,
 	}
 
 	if(stream.writable && body !== undefined) {
+		if(body instanceof ReadableStream) {
+			Readable.fromWeb(body).pipe(stream)
+			return
+		}
+
 		stream.end(body)
 		return
 	}

package/src/response/sse.js

@@ -1,9 +1,10 @@
 import http2 from 'node:http2'
+
 import {
-	SSE_MIME,
-	SSE_INACTIVE_STATUS_CODE,
-	SSE_BOM,
 	ENDING,
+	SSE_BOM,
+	SSE_INACTIVE_STATUS_CODE,
+	SSE_MIME,
 } from '@johntalton/sse-util'
 import { coreHeaders, performanceHeaders } from './header-util.js'
 

package/src/response/temporary-redirect.js

@@ -0,0 +1,23 @@
+import http2 from 'node:http2'
+
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const {
+	HTTP2_HEADER_LOCATION
+} = http2.constants
+
+const { HTTP_STATUS_TEMPORARY_REDIRECT } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {URL} location
+ * @param {Metadata} meta
+ */
+export function sendTemporaryRedirect(stream, location, meta) {
+	send(stream, HTTP_STATUS_TEMPORARY_REDIRECT, {
+		[HTTP2_HEADER_LOCATION]: location.href
+	}, [ HTTP2_HEADER_LOCATION ], undefined, undefined, meta)
+}

package/src/response/timeout.js

@@ -1,4 +1,5 @@
 import http2 from 'node:http2'
+
 import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */

package/src/response/too-many-requests.js

@@ -1,4 +1,5 @@
 import http2 from 'node:http2'
+
 import { CONTENT_TYPE_TEXT } from '../content-type.js'
 import {
 	HTTP_HEADER_RATE_LIMIT,

package/src/response/trace.js

@@ -1,4 +1,5 @@
 import http2 from 'node:http2'
+
 import { CONTENT_TYPE_MESSAGE_HTTP } from '../content-type.js'
 import { send } from './send-util.js'
 
@@ -8,6 +9,9 @@ import { send } from './send-util.js'
 
 const { HTTP_STATUS_OK } = http2.constants
 
+const LINE_ENDING = '\n'
+const PSEUDO_HEADER_PREFIX = ':'
+
 /**
  * @param {ServerHttp2Stream} stream
  * @param {string} method
@@ -27,13 +31,13 @@ export function sendTrace(stream, method, url, headers, meta) {
 	const reconstructed = [
 		`${method} ${url.pathname}${url.search} ${version}`,
 		Object.entries(headers)
-			.filter(([ key ]) => !key.startsWith(':'))
+			.filter(([ key ]) => !key.startsWith(PSEUDO_HEADER_PREFIX))
 			.filter(([ key ]) => !FILTER_KEYS.includes(key))
 			.map(([ key, value ]) => `${key}: ${value}`)
-			.join('\n'),
-		'\n'
+			.join(LINE_ENDING),
+		LINE_ENDING
 		]
-		.join('\n')
+		.join(LINE_ENDING)
 
 	send(stream, HTTP_STATUS_OK, {}, [], CONTENT_TYPE_MESSAGE_HTTP, reconstructed, meta)
 }

package/src/response/unauthorized.js

@@ -1,4 +1,5 @@
 import http2 from 'node:http2'
+
 import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */

package/src/response/unavailable.js

@@ -1,4 +1,5 @@
 import http2 from 'node:http2'
+
 import { CONTENT_TYPE_TEXT } from '../content-type.js'
 import { send } from './send-util.js'
 

package/src/response/unprocessable.js

@@ -1,4 +1,5 @@
 import http2 from 'node:http2'
+
 import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */

package/src/response/unsupported-media.js

@@ -1,21 +1,32 @@
 import http2 from 'node:http2'
-import { HTTP_HEADER_ACCEPT_POST } from './defs.js'
+
+import { HTTP_HEADER_ACCEPT_PATCH, HTTP_HEADER_ACCEPT_POST, HTTP_HEADER_ACCEPT_QUERY } from './defs.js'
 import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
+const { HTTP2_METHOD_POST, HTTP2_METHOD_PATCH } = http2.constants
+
 const { HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Array<string>|string} acceptableMediaType
+ * @param {Array<string>|undefined} supportedQueryTypes
  * @param {Metadata} meta
  */
-export function sendUnsupportedMediaType(stream, acceptableMediaType, meta) {
+export function sendUnsupportedMediaType(stream, acceptableMediaType, supportedQueryTypes, meta) {
+	const supportsQuery = supportedQueryTypes !== undefined && supportedQueryTypes.length > 0
+	const exposedHeaders = supportsQuery ? [ HTTP_HEADER_ACCEPT_QUERY, HTTP_HEADER_ACCEPT_POST ] : [ HTTP_HEADER_ACCEPT_POST ]
+
+	const method = HTTP2_METHOD_POST // todo pass in as parameter or split acceptable to post and patch types
 	const acceptable = Array.isArray(acceptableMediaType) ? acceptableMediaType : [ acceptableMediaType ]
+	const acceptHeader = (method === HTTP2_METHOD_POST) ? HTTP_HEADER_ACCEPT_POST : HTTP_HEADER_ACCEPT_PATCH
+	const acceptValue = ((method === HTTP2_METHOD_POST) || (method === HTTP2_METHOD_PATCH)) ? acceptable.join(',') : undefined
 
 	send(stream, HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE, {
-			[HTTP_HEADER_ACCEPT_POST]: acceptable.join(',')
-		}, [ HTTP_HEADER_ACCEPT_POST ], undefined, undefined, meta)
+			[acceptHeader]: acceptValue,
+			[HTTP_HEADER_ACCEPT_QUERY]: supportedQueryTypes?.join(',')
+		}, exposedHeaders, undefined, undefined, meta)
 }