@opra/core 0.22.0 → 0.23.1

package/esm/adapter/http/http-adapter-base.js

@@ -0,0 +1,123 @@
+import { BadRequestError, HttpHeaderCodes, HttpStatusCodes, InternalServerError, IssueSeverity, OpraException, OpraSchema, wrapException } from '@opra/common';
+import { ExecutionContextHost } from '../execution-context.host.js';
+import { PlatformAdapterHost } from '../platform-adapter.host.js';
+import { EntityRequestHandler } from './request-handlers/entity-request-handler.js';
+import { StorageRequestHandler } from './request-handlers/storage-request-handler.js';
+/**
+ *
+ * @class HttpAdapterBase
+ */
+export class HttpAdapterBase extends PlatformAdapterHost {
+    constructor() {
+        super(...arguments);
+        this._protocol = 'http';
+        this._requestHandlers = [
+            new EntityRequestHandler(this),
+            new StorageRequestHandler(this)
+        ];
+    }
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    async handleIncoming(incoming, outgoing) {
+        const context = new ExecutionContextHost(this.api, this.platform, { http: { incoming, outgoing } });
+        try {
+            /* istanbul ignore next */
+            if (!this._initialized)
+                throw new InternalServerError(`${Object.getPrototypeOf(this).constructor.name} has not been initialized yet`);
+            outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+            // Expose headers if cors enabled
+            if (outgoing.getHeader(HttpHeaderCodes.Access_Control_Allow_Origin)) {
+                // Expose X-Opra-* headers
+                outgoing.appendHeader(HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(HttpHeaderCodes)
+                    .filter(k => k.toLowerCase().startsWith('x-opra-')));
+            }
+            await this.processRequest(context);
+        }
+        catch (error) {
+            context.errors.push(wrapException(error));
+        }
+        // If no response returned to the client we send an error
+        if (!outgoing.writableEnded) {
+            if (!context.errors.length)
+                context.errors.push(new BadRequestError(`Server can not process this request`));
+            await this.handleError(context);
+        }
+    }
+    async processRequest(context) {
+        try {
+            const { incoming, outgoing } = context.switchToHttp();
+            if (incoming.method === 'GET' &&
+                incoming.parsedUrl.path.length &&
+                incoming.parsedUrl.path[0].resource === '$metadata') {
+                outgoing.setHeader('content-type', 'application/json');
+                outgoing.end(JSON.stringify(this.api.exportSchema({ webSafe: true })));
+                return;
+            }
+            const { parsedUrl } = incoming;
+            if (!parsedUrl.path.length) {
+                // Batch
+                if (incoming.headers['content-type'] === 'multipart/mixed') {
+                    // todo
+                }
+                throw new BadRequestError();
+            }
+            // Iterate through request handlers until one of them sends response (end outgoing stream)
+            for (const requestHandler of this._requestHandlers) {
+                await requestHandler.processRequest(context);
+                if (outgoing.writableEnded)
+                    return;
+                if (context.errors.length) {
+                    await this.handleError(context);
+                    return;
+                }
+            }
+        }
+        finally {
+            await context.emitAsync('finish');
+        }
+    }
+    async handleError(context) {
+        const { errors } = context;
+        const { outgoing } = context.switchToHttp();
+        if (outgoing.headersSent) {
+            outgoing.end();
+            return;
+        }
+        errors.forEach(x => {
+            // todo. implement a better log mechanism
+            if (x instanceof OpraException)
+                this._logger.fatal(x);
+            else
+                this._logger.error(x);
+        });
+        const wrappedErrors = errors.map(wrapException);
+        // Sort errors from fatal to info
+        wrappedErrors.sort((a, b) => {
+            const i = IssueSeverity.Keys.indexOf(a.severity) - IssueSeverity.Keys.indexOf(b.severity);
+            if (i === 0)
+                return b.status - a.status;
+            return i;
+        });
+        let status = outgoing.statusCode || 0;
+        if (!status || status < Number(HttpStatusCodes.BAD_REQUEST)) {
+            status = wrappedErrors[0].status;
+            if (status < Number(HttpStatusCodes.BAD_REQUEST))
+                status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
+        }
+        outgoing.statusCode = status;
+        const body = {
+            errors: wrappedErrors.map(x => this._i18n.deep(x.toJSON()))
+        };
+        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
+        outgoing.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
+        outgoing.setHeader(HttpHeaderCodes.Expires, '-1');
+        outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+        outgoing.send(JSON.stringify(body));
+        outgoing.end();
+    }
+}

package/esm/adapter/http/http-adapter.host.js

@@ -0,0 +1,52 @@
+import http from 'http';
+import { HttpStatusCodes, HttpStatusMessages, OpraURL, OpraURLPath, } from '@opra/common';
+import { HttpAdapterBase } from './http-adapter-base.js';
+import { HttpServerRequest } from './http-server-request.js';
+import { HttpServerResponse } from './http-server-response.js';
+/**
+ * @class HttpAdapterHost
+ */
+export class HttpAdapterHost extends HttpAdapterBase {
+    constructor(api, options) {
+        super(api, options);
+        this._platform = 'http';
+        this._basePath = new OpraURLPath(options?.basePath);
+        this._server = http.createServer((incomingMessage, serverResponse) => this._serverListener(incomingMessage, serverResponse));
+    }
+    get basePath() {
+        return this._basePath;
+    }
+    get server() {
+        return this._server;
+    }
+    _serverListener(incomingMessage, serverResponse) {
+        const originalUrl = incomingMessage.url;
+        const parsedUrl = new OpraURL(originalUrl);
+        const relativePath = OpraURLPath.relative(parsedUrl.path, this.basePath);
+        if (!relativePath) {
+            serverResponse.statusCode = HttpStatusCodes.NOT_FOUND;
+            serverResponse.statusMessage = HttpStatusMessages[HttpStatusCodes.NOT_FOUND];
+            serverResponse.end();
+            return;
+        }
+        parsedUrl.path = relativePath;
+        incomingMessage.originalUrl = originalUrl;
+        incomingMessage.baseUrl = this.basePath.toString();
+        incomingMessage.parsedUrl = parsedUrl;
+        const req = HttpServerRequest.from(incomingMessage);
+        const res = HttpServerResponse.from(serverResponse);
+        this.handleIncoming(req, res)
+            .catch((e) => this._logger.fatal(e));
+    }
+    async close() {
+        await super.close();
+        if (this.server.listening)
+            await new Promise((resolve, reject) => {
+                this.server.close((err) => {
+                    if (err)
+                        return reject(err);
+                    resolve();
+                });
+            });
+    }
+}

package/esm/adapter/http/http-adapter.js

@@ -1,134 +1,13 @@
-import { Task } from 'power-tasks';
-import { BadRequestError, Collection, HttpHeaderCodes, HttpStatusCodes, InternalServerError, isReadable, IssueSeverity, OpraException, OpraSchema, wrapException } from '@opra/common';
-import { OpraAdapter } from '../adapter.js';
-import { RequestContextHost } from '../request-context.host.js';
-import { ResponseHost } from '../response.host.js';
-import { parseRequest } from './request-parsers/parse-request.js';
+import { HttpAdapterHost } from './http-adapter.host.js';
 /**
- *
- * @class OpraHttpAdapter
+ * @namespace HttpAdapter
  */
-export class OpraHttpAdapter extends OpraAdapter {
-    /**
-     * Main http request handler
-     * @param incoming
-     * @param outgoing
-     * @protected
-     */
-    async handler(incoming, outgoing) {
-        try {
-            try {
-                const request = await parseRequest(this._apiRoot, incoming);
-                const task = this.createRequestTask(request, outgoing);
-                await task.toPromise();
-            }
-            catch (e) {
-                if (e instanceof OpraException)
-                    throw e;
-                throw new BadRequestError(e);
-            }
-        }
-        catch (error) {
-            await this.handleError(incoming, outgoing, [error]);
-        }
-    }
-    createRequestTask(request, outgoing) {
-        return new Task(async () => {
-            const response = new ResponseHost({ http: outgoing });
-            const context = new RequestContextHost('http', this.platform, this.api, request, response);
-            return this.executeRequest(context);
-        }, {
-            id: request.contentId,
-            exclusive: request.crud !== 'read'
-        });
-    }
-    async executeRequest(context) {
-        const { request, response } = context;
-        await super.executeRequest(context)
-            .catch(e => {
-            response.errors = response.errors || [];
-            response.errors.push(e);
-        });
-        const outgoing = response.switchToHttp();
-        if (response.errors?.length) {
-            const errors = response.errors.map(e => wrapException(e));
-            await this.handleError(request.switchToHttp(), outgoing, errors);
-            return;
-        }
-        if (request.crud === 'create') {
-            if (!response.value)
-                throw new InternalServerError();
-            // todo validate
-            outgoing.statusCode = 201;
-        }
-        if (request.resource instanceof Collection &&
-            request.crud === 'read' && request.many && request.args.count >= 0) {
-            outgoing.setHeader(HttpHeaderCodes.X_Total_Count, String(response.count));
-        }
-        outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
-        outgoing.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-        // Expose headers if cors enabled
-        if (outgoing.getHeader(HttpHeaderCodes.Access_Control_Allow_Origin)) {
-            // Expose X-Total-Count header
-            outgoing.appendHeader(HttpHeaderCodes.Access_Control_Expose_Headers, [HttpHeaderCodes.X_Total_Count]);
-            // Expose X-Opra-* headers
-            outgoing.appendHeader(HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(HttpHeaderCodes)
-                .filter(k => k.toLowerCase().startsWith('x-opra-')));
-        }
-        if (response.value) {
-            if (typeof response.value === 'object') {
-                if (isReadable(response.value) || Buffer.isBuffer(response.value))
-                    outgoing.send(response.value);
-                else {
-                    const body = this.i18n.deep(response.value);
-                    outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
-                    outgoing.send(JSON.stringify(body));
-                }
-            }
-            else
-                outgoing.send(JSON.stringify(response.value));
-        }
-        outgoing.end();
-    }
-    async handleError(incoming, outgoing, errors) {
-        errors.forEach(e => {
-            this.log((e instanceof OpraException) ? 'error' : 'fatal', incoming, e); // todo. implement a better logger
-        });
-        errors = errors.map(wrapException);
-        let status = outgoing.statusCode || 0;
-        // Sort errors from fatal to info
-        errors.sort((a, b) => {
-            const i = IssueSeverity.Keys.indexOf(a.issue.severity) - IssueSeverity.Keys.indexOf(b.issue.severity);
-            if (i === 0)
-                return b.status - a.status;
-            return i;
-        });
-        if (!status || status < Number(HttpStatusCodes.BAD_REQUEST)) {
-            status = errors[0].status;
-            if (status < Number(HttpStatusCodes.BAD_REQUEST))
-                status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
-        }
-        const body = this.i18n.deep({
-            errors: errors.map(e => e.issue)
-        });
-        outgoing.statusCode = status;
-        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
-        outgoing.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-        outgoing.send(JSON.stringify(body));
-        outgoing.end();
-    }
-    log(logType, incoming, message, ...optionalParams) {
-        const logFn = logType === 'fatal'
-            ? this.logger?.fatal || this.logger?.error
-            : this.logger?.[logType];
-        if (!logFn)
-            return;
-        logFn.apply(this.logger, [String(message), ...optionalParams]);
-    }
-}
+export var HttpAdapter;
+(function (HttpAdapter) {
+    async function create(api, options) {
+        const adapter = new HttpAdapterHost(api, options);
+        await adapter.init();
+        return adapter;
+    }
+    HttpAdapter.create = create;
+})(HttpAdapter || (HttpAdapter = {}));

package/esm/adapter/http/{impl/http-server-request.js → http-server-request.js}

@@ -6,22 +6,28 @@ import accepts from 'accepts';
 import fresh from 'fresh';
 import parseRange from 'range-parser';
 import typeIs from 'type-is';
-import { isReadable, mergePrototype } from '@opra/common';
-import { HttpIncomingMessageHost } from './http-incoming-message-host.js';
+import { isReadable, mergePrototype, OpraURL } from '@opra/common';
+import { HttpIncomingMessageHost } from './impl/http-incoming-message.host.js';
 function isHttpIncomingMessage(v) {
     return v && Array.isArray(v.rawHeaders) && isReadable(v);
 }
 export var HttpServerRequest;
 (function (HttpServerRequest) {
-    function create(instance) {
+    function from(instance) {
         if (!isHttpIncomingMessage(instance))
-            instance = HttpIncomingMessageHost.create(instance);
+            instance = HttpIncomingMessageHost.from(instance);
         mergePrototype(instance, HttpServerRequestHost.prototype);
-        return instance;
+        const req = instance;
+        req.baseUrl = req.baseUrl || '';
+        req.parsedUrl = req.parsedUrl || new OpraURL(req.url);
+        return req;
     }
-    HttpServerRequest.create = create;
+    HttpServerRequest.from = from;
 })(HttpServerRequest || (HttpServerRequest = {}));
 class HttpServerRequestHost {
+    constructor() {
+        this.basePath = '/';
+    }
     get protocol() {
         const proto = this.header('X-Forwarded-Proto') || 'http';
         const index = proto.indexOf(',');

package/esm/adapter/http/{impl/http-server-response.js → http-server-response.js}

@@ -12,20 +12,20 @@ import path from 'path';
 import { toString } from 'putil-varhelpers';
 import vary from 'vary';
 import { HttpStatusCodes, isStream, mergePrototype } from '@opra/common';
-import { HttpOutgoingMessageHost } from './http-outgoing-message-host.js';
+import { HttpOutgoingMessageHost } from './impl/http-outgoing-message.host.js';
 const charsetRegExp = /;\s*charset\s*=/;
 function isHttpIncomingMessage(v) {
     return v && typeof v.getHeaders === 'function' && isStream(v);
 }
 export var HttpServerResponse;
 (function (HttpServerResponse) {
-    function create(instance) {
+    function from(instance) {
         if (!isHttpIncomingMessage(instance))
-            instance = HttpOutgoingMessageHost.create(instance);
+            instance = new HttpOutgoingMessageHost(instance);
         mergePrototype(instance, HttpServerResponseHost.prototype);
         return instance;
     }
-    HttpServerResponse.create = create;
+    HttpServerResponse.from = from;
 })(HttpServerResponse || (HttpServerResponse = {}));
 class HttpServerResponseHost {
     attachment(filename) {

package/esm/adapter/http/impl/http-incoming-message.host.js

@@ -0,0 +1,144 @@
+/*
+  This file contains code blocks from open source NodeJs project
+  https://github.com/nodejs/
+ */
+import { Duplex, Readable } from 'stream';
+import { HTTPParser } from '@browsery/http-parser';
+import { isAsyncIterable, isIterable } from '@opra/common';
+import { concatReadable } from '../helpers/concat-readable.js';
+import { convertToHeaders, convertToHeadersDistinct } from '../helpers/convert-to-headers.js';
+import { convertToRawHeaders } from '../helpers/convert-to-raw-headers.js';
+export const CRLF = Buffer.from('\r\n');
+export const kHeaders = Symbol.for('kHeaders');
+export const kHeadersDistinct = Symbol.for('kHeadersDistinct');
+export const kTrailers = Symbol.for('kTrailers');
+export const kTrailersDistinct = Symbol.for('kTrailersDistinct');
+/**
+ *
+ * @class HttpIncomingMessageHost
+ */
+export class HttpIncomingMessageHost extends Duplex {
+    constructor(init) {
+        super();
+        this.rawHeaders = [];
+        this.rawTrailers = [];
+        this.complete = false;
+        this.joinDuplicateHeaders = false;
+        if (init) {
+            this.complete = true;
+            this.httpVersionMajor = init.httpVersionMajor || 1;
+            this.httpVersionMinor = init.httpVersionMinor || 0;
+            this.method = (init.method || 'GET').toUpperCase();
+            this.url = init.url || '';
+            if (init.body != null) {
+                if (Buffer.isBuffer(init.body))
+                    this.body = init.body;
+                else if (typeof init.body === 'string')
+                    this.body = Buffer.from(init.body, 'utf-8');
+                else
+                    this.body = Buffer.from(JSON.stringify(init.body), 'utf-8');
+            }
+            if (init.headers)
+                this.rawHeaders = Array.isArray(init.headers) ? init.headers : convertToRawHeaders(init.headers);
+            if (init.trailers)
+                this.rawTrailers = Array.isArray(init.trailers) ? init.trailers : convertToRawHeaders(init.trailers);
+            this.ip = init.ip || '';
+            this.ips = init.ips || (this.ip ? [this.ip] : []);
+            if (this.body && !this.headers['content-length'])
+                this.headers['content-length'] = String(this.body.length);
+        }
+    }
+    get httpVersion() {
+        return this.httpVersionMajor
+            ? this.httpVersionMajor + '.' + this.httpVersionMinor
+            : '';
+    }
+    get headers() {
+        if (!this[kHeaders])
+            this[kHeaders] = convertToHeaders(this.rawHeaders, {}, this.joinDuplicateHeaders);
+        return this[kHeaders];
+    }
+    set headers(headers) {
+        this[kHeaders] = headers;
+    }
+    get headersDistinct() {
+        if (!this[kHeadersDistinct])
+            this[kHeadersDistinct] = convertToHeadersDistinct(this.rawHeaders, {});
+        return this[kHeadersDistinct];
+    }
+    get trailers() {
+        if (!this[kTrailers])
+            this[kTrailers] = convertToHeaders(this.rawTrailers, {}, this.joinDuplicateHeaders);
+        return this[kTrailers];
+    }
+    set trailers(trailers) {
+        this[kTrailers] = trailers;
+    }
+    get trailersDistinct() {
+        if (!this[kTrailersDistinct])
+            this[kTrailersDistinct] = convertToHeadersDistinct(this.rawTrailers, {});
+        return this[kTrailersDistinct];
+    }
+    _read(size) {
+        if (!this.body) {
+            this.push(null);
+            return;
+        }
+        if (!this._readStream) {
+            if (isIterable(this.body) || isAsyncIterable(this.body))
+                this._readStream = Readable.from(this.body);
+            else if (typeof this.body === 'string') {
+                this._readStream = Readable.from(Buffer.from(this.body, 'utf-8'));
+            }
+            else
+                this._readStream = Readable.from(Buffer.from(JSON.stringify(this.body), 'utf-8'));
+        }
+        const chunk = this._readStream.read(size);
+        this.push(chunk);
+        // this.push(null);s
+    }
+    _write(chunk, encoding, callback) {
+        const error = this._httpParser?.execute(chunk);
+        if (error && typeof error === 'object')
+            callback(error);
+        else
+            callback();
+    }
+    static from(iterable) {
+        if (typeof iterable === 'object' && !(isIterable(iterable) || isAsyncIterable(iterable)))
+            return new HttpIncomingMessageHost(iterable);
+        const msg = new HttpIncomingMessageHost();
+        const parser = msg._httpParser = new HTTPParser(HTTPParser.REQUEST);
+        let bodyChunks;
+        parser[HTTPParser.kOnHeadersComplete] = (info) => {
+            msg.httpVersionMajor = info.versionMajor;
+            msg.httpVersionMinor = info.versionMinor;
+            msg.rawHeaders = info.headers;
+            msg.method = HTTPParser.methods[info.method];
+            msg.url = info.url;
+        };
+        parser[HTTPParser.kOnHeaders] = (trailers) => {
+            msg.rawTrailers = trailers;
+        };
+        parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
+            bodyChunks = bodyChunks || [];
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        parser[HTTPParser.kOnMessageComplete] = () => {
+            msg.complete = true;
+            if (bodyChunks)
+                msg.body = Buffer.concat(bodyChunks);
+        };
+        const readable = concatReadable(Readable.from(iterable), Readable.from(CRLF));
+        msg.once('finish', () => parser.finish());
+        readable.pipe(msg);
+        return msg;
+    }
+    static async fromAsync(iterable) {
+        return new Promise((resolve, reject) => {
+            const msg = this.from(iterable);
+            msg.once('finish', () => resolve(msg));
+            msg.once('error', (error) => reject(error));
+        });
+    }
+}

package/esm/adapter/http/impl/{http-outgoing-message-host.js → http-outgoing-message.host.js}

@@ -2,33 +2,40 @@
   This file contains code blocks from open source NodeJs project
   https://github.com/nodejs/
  */
-var _a;
-import * as stream from 'stream';
+import { Duplex } from 'stream';
 import { validateHeaderName, validateHeaderValue, validateString } from '../helpers/common.js';
-export const kOutHeaders = Symbol('kOutHeaders');
-export const kOutTrailers = Symbol('kOutTrailers');
-export const kErrored = Symbol('kErrored');
+export const kOutHeaders = Symbol.for('kOutHeaders');
+export const kOutTrailers = Symbol.for('kOutTrailers');
 // noinspection JSUnusedLocalSymbols
 /**
  *
  * @class HttpOutgoingMessageHost
  */
-export class HttpOutgoingMessageHost {
-    constructor() {
+export class HttpOutgoingMessageHost extends Duplex {
+    constructor(init) {
+        super();
         this._headersSent = false;
-        this._closed = false;
-        this[_a] = null;
         this.finished = false;
-        stream.Stream.apply(this);
+        if (init) {
+            this.req = init.req;
+            this.statusCode = init?.statusCode || 0;
+            this.statusMessage = init?.statusMessage || '';
+            this.chunkedEncoding = !!init?.chunkedEncoding;
+            this.sendDate = !!init?.sendDate;
+            this.strictContentLength = !!init?.strictContentLength;
+            if (init.headers)
+                this.setHeaders(Array.isArray(init.headers) ? new Map([init.headers]) : init.headers);
+            this.body = init.body;
+        }
     }
-    get headersSent() {
-        return this._headersSent;
+    get httpVersionMajor() {
+        return this.req?.httpVersionMajor || this._httpVersionMajor;
     }
-    get closed() {
-        return this._closed;
+    get httpVersionMinor() {
+        return this.req?.httpVersionMinor || this._httpVersionMinor;
     }
-    get errored() {
-        return this[kErrored];
+    get headersSent() {
+        return this._headersSent;
     }
     appendHeader(name, value) {
         if (this.headersSent)
@@ -181,25 +188,7 @@ export class HttpOutgoingMessageHost {
         //
         return this;
     }
-    _readConfig(init) {
-        this.req = init.req;
-        this.statusCode = init?.statusCode || 0;
-        this.statusMessage = init?.statusMessage || '';
-        this.chunkedEncoding = !!init?.chunkedEncoding;
-        this.sendDate = !!init?.sendDate;
-        this.strictContentLength = !!init?.strictContentLength;
-        if (init.headers) {
-            this.setHeaders(Array.isArray(init.headers) ? new Map([init.headers]) : init.headers);
-        }
-        this.body = init.body;
-    }
-    static create(init) {
-        const msg = new HttpOutgoingMessageHost();
-        if (init)
-            msg._readConfig(init);
-        return msg;
+    static from(init) {
+        return new HttpOutgoingMessageHost(init);
     }
 }
-_a = kErrored;
-// Apply mixins
-Object.assign(HttpOutgoingMessageHost.prototype, stream.Stream.prototype);