@johntalton/http-util 4.1.0 → 5.0.0

package/src/response/response.js

@@ -1,17 +1,30 @@
 import { sendAccepted } from './accepted.js'
+import { sendBytes } from './bytes.js'
 import { sendConflict } from './conflict.js'
+import { sendContentTooLarge } from './content-too-large.js'
 import { sendCreated } from './created.js'
 import { sendError } from './error.js'
+import { sendForbidden } from './forbidden.js'
+import { sendGone } from './gone.js'
+import { sendImATeapot } from './im-a-teapot.js'
+import { sendInsufficientStorage } from './insufficient-storage.js'
 import { sendJSON_Encoded } from './json.js'
+import { sendMovedPermanently } from './moved-permanently.js'
+import { sendMultipleChoices } from './multiple-choices.js'
 import { sendNoContent } from './no-content.js'
 import { sendNotAcceptable } from './not-acceptable.js'
 import { sendNotAllowed } from './not-allowed.js'
 import { sendNotFound } from './not-found.js'
 import { sendNotImplemented } from './not-implemented.js'
 import { sendNotModified } from './not-modified.js'
+import { sendPartialContent } from './partial-content.js'
+import { sendPermanentRedirect } from './permanent-redirect.js'
 import { sendPreconditionFailed } from './precondition-failed.js'
 import { sendPreflight } from './preflight.js'
+import { sendRangeNotSatisfiable } from './range-not-satisfiable.js'
+import { sendSeeOther } from './see-other.js'
 import { sendSSE } from './sse.js'
+import { sendTemporaryRedirect } from './temporary-redirect.js'
 import { sendTimeout } from './timeout.js'
 import { sendTooManyRequests } from './too-many-requests.js'
 import { sendTrace } from './trace.js'
@@ -22,19 +35,32 @@ import { sendUnsupportedMediaType } from './unsupported-media.js'
 
 export const Response = {
 	accepted: sendAccepted,
+	bytes: sendBytes,
 	conflict: sendConflict,
+	contentTooLarge: sendContentTooLarge,
 	created: sendCreated,
 	error: sendError,
+	forbidden: sendForbidden,
+	gone: sendGone,
+	imATeapot: sendImATeapot,
+	insufficientStorage: sendInsufficientStorage,
 	json: sendJSON_Encoded,
+	movedPermanently: sendMovedPermanently,
+	multipleChoices: sendMultipleChoices,
 	noContent: sendNoContent,
 	notAcceptable: sendNotAcceptable,
 	notAllowed: sendNotAllowed,
 	notFound: sendNotFound,
 	notImplemented: sendNotImplemented,
 	notModified: sendNotModified,
+	partialContent: sendPartialContent,
+	permanentRedirect: sendPermanentRedirect,
 	preconditionFailed: sendPreconditionFailed,
 	preflight: sendPreflight,
+	rangeNotSatisfiable: sendRangeNotSatisfiable,
+	seeOther: sendSeeOther,
 	sse: sendSSE,
+	temporaryRedirect: sendTemporaryRedirect,
 	timeout: sendTimeout,
 	tooManyRequests: sendTooManyRequests,
 	trace: sendTrace,

package/src/response/see-other.js

@@ -0,0 +1,22 @@
+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,12 +1,131 @@
+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 {
 	coreHeaders,
 	customHeaders,
 	performanceHeaders
 } from './header-util.js'
+import { ContentRange } from '../content-range.js'
+import { CacheControl } from '../cache-control.js'
+import { Conditional } from '../conditional.js'
+import { HTTP_HEADER_ACCEPT_QUERY } from './defs.js'
+import { CHARSET_UTF8 } from '../content-type.js'
 
 /** @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 {
+	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,7 +133,7 @@ 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) {
@@ -22,9 +141,10 @@ export function send(stream, status, headers, exposedHeaders, contentType, body,
 	if(status === 401) { console.warn(status, body) }
 	if(status === 404) { console.warn(status, body) }
 	if(status >= 500) { 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 +159,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/temporary-redirect.js

@@ -0,0 +1,22 @@
+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/unsupported-media.js

@@ -1,5 +1,5 @@
 import http2 from 'node:http2'
-import { HTTP_HEADER_ACCEPT_POST } from './defs.js'
+import { HTTP_HEADER_ACCEPT_POST, HTTP_HEADER_ACCEPT_QUERY } from './defs.js'
 import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
@@ -10,12 +10,17 @@ 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 acceptable = Array.isArray(acceptableMediaType) ? acceptableMediaType : [ acceptableMediaType ]
 
+	const supportsQuery = supportedQueryTypes !== undefined && supportedQueryTypes.length > 0
+	const exposedHeaders = supportsQuery ? [ HTTP_HEADER_ACCEPT_QUERY, HTTP_HEADER_ACCEPT_POST ] : [ HTTP_HEADER_ACCEPT_POST ]
+
 	send(stream, HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE, {
-			[HTTP_HEADER_ACCEPT_POST]: acceptable.join(',')
-		}, [ HTTP_HEADER_ACCEPT_POST ], undefined, undefined, meta)
+			[HTTP_HEADER_ACCEPT_POST]: acceptable.join(','),
+			[HTTP_HEADER_ACCEPT_QUERY]: supportedQueryTypes?.join(',')
+		}, exposedHeaders, undefined, undefined, meta)
 }