@opra/core 0.20.3 → 0.22.0

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

@@ -1,9 +1,9 @@
 import { Task } from 'power-tasks';
-import { BadRequestError, Collection, HttpHeaderCodes, HttpStatusCodes, InternalServerError, isReadable, IssueSeverity, MethodNotAllowedError, OpraException, OpraSchema, OpraURL, Singleton, wrapException } from '@opra/common';
+import { BadRequestError, Collection, HttpHeaderCodes, HttpStatusCodes, InternalServerError, isReadable, IssueSeverity, OpraException, OpraSchema, wrapException } from '@opra/common';
 import { OpraAdapter } from '../adapter.js';
-import { HttpRequestHost } from './http-request.host.js';
-import { HttpRequestContextHost } from './http-request-context.host.js';
-import { HttpResponseHost } from './http-response.host.js';
+import { RequestContextHost } from '../request-context.host.js';
+import { ResponseHost } from '../response.host.js';
+import { parseRequest } from './request-parsers/parse-request.js';
 /**
  *
  * @class OpraHttpAdapter
@@ -17,43 +17,83 @@ export class OpraHttpAdapter extends OpraAdapter {
      */
     async handler(incoming, outgoing) {
         try {
-            // Batch
-            if (incoming.is('multipart/mixed')) {
-                throw new BadRequestError({ message: 'Not implemented yet' });
+            try {
+                const request = await parseRequest(this._apiRoot, incoming);
+                const task = this.createRequestTask(request, outgoing);
+                await task.toPromise();
             }
-            if (!(incoming.method === 'POST' || incoming.method === 'PATCH') || incoming.is('json')) {
-                const request = await this.parseRequest(incoming);
-                const response = new HttpResponseHost({}, outgoing);
-                const context = new HttpRequestContextHost(this.platform, this.api, request, response);
-                const task = new Task(async () => {
-                    try {
-                        await this.executeRequest(context);
-                        if (request.operation === 'findMany' && request.args.count && response.count != null) {
-                            response.switchToHttp().header(HttpHeaderCodes.X_Opra_Total_Matches, String(response.count));
-                        }
-                    }
-                    catch (error) {
-                        return this.errorHandler(incoming, outgoing, [error]);
-                    }
-                    await this.sendResponse(context);
-                }, {
-                    id: incoming.get('content-id'),
-                    exclusive: request.crud !== 'read'
-                });
-                await task.toPromise().catch(e => {
-                    this.logger?.error?.(e);
-                    outgoing.sendStatus(500);
-                });
-                await this.emitAsync('request-finish', context);
-                return;
+            catch (e) {
+                if (e instanceof OpraException)
+                    throw e;
+                throw new BadRequestError(e);
             }
-            throw new BadRequestError({ message: 'Unsupported Content-Type' });
         }
         catch (error) {
-            await this.errorHandler(incoming, outgoing, [error]);
+            await this.handleError(incoming, outgoing, [error]);
         }
     }
-    async errorHandler(incoming, outgoing, errors) {
+    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
         });
@@ -66,20 +106,20 @@ export class OpraHttpAdapter extends OpraAdapter {
                 return b.status - a.status;
             return i;
         });
-        if (!status || status < HttpStatusCodes.BAD_REQUEST) {
+        if (!status || status < Number(HttpStatusCodes.BAD_REQUEST)) {
             status = errors[0].status;
-            if (status < HttpStatusCodes.BAD_REQUEST)
+            if (status < Number(HttpStatusCodes.BAD_REQUEST))
                 status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
         }
         const body = this.i18n.deep({
             errors: errors.map(e => e.issue)
         });
-        outgoing.set(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
-        outgoing.set(HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.set(HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.set(HttpHeaderCodes.Expires, '-1');
-        outgoing.set(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-        outgoing.status(status);
+        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();
     }
@@ -91,402 +131,4 @@ export class OpraHttpAdapter extends OpraAdapter {
             return;
         logFn.apply(this.logger, [String(message), ...optionalParams]);
     }
-    async executeRequest(context) {
-        await super.executeRequest(context);
-        const { request } = context;
-        const response = context.response;
-        const { crud } = request;
-        const httpResponse = response.switchToHttp();
-        if (request.resource instanceof Singleton || request.resource instanceof Collection) {
-            httpResponse.set(HttpHeaderCodes.X_Opra_Data_Type, request.resource.type.name);
-            httpResponse.set(HttpHeaderCodes.X_Opra_Operation, request.operation);
-        }
-        if (crud === 'create') {
-            if (!response.value)
-                throw new InternalServerError();
-            // todo validate
-            httpResponse.status(201);
-        }
-    }
-    /**
-     *
-     * @param incoming
-     * @protected
-     */
-    async parseRequest(incoming) {
-        try {
-            const url = new OpraURL();
-            url.searchParams.define({
-                '$search': { codec: 'string' },
-                '$pick': { codec: 'string', array: 'strict' },
-                '$omit': { codec: 'string', array: 'strict' },
-                '$include': { codec: 'string', array: 'strict' },
-                '$sort': { codec: 'string', array: 'strict' },
-                '$filter': { codec: 'filter' },
-                '$limit': { codec: 'number' },
-                '$skip': { codec: 'number' },
-                '$distinct': { codec: 'boolean' },
-                '$count': { codec: 'boolean' },
-            });
-            url.parse(incoming.url);
-            // const {context, url, method, headers, body, contentId} = args;
-            if (!url.path.size)
-                throw new BadRequestError();
-            const method = incoming.method;
-            if (method !== 'GET' && url.path.size > 1)
-                throw new BadRequestError();
-            // const pathLen = url.path.size;
-            // let pathIndex = 0;
-            const params = url.searchParams;
-            const p = url.path.get(0);
-            const resource = this._internalDoc.getResource(p.resource);
-            // let container: IResourceContainer | undefined;
-            // while (resource && resource instanceof ContainerResourceInfo) {
-            //   container = resource;
-            //   p = url.path.get(++pathIndex);
-            //   resource = container.getResource(p.resource);
-            // }
-            // const headers = incoming.headers;
-            /*
-             * Collection
-             */
-            if (resource instanceof Collection) {
-                switch (method) {
-                    case 'POST': {
-                        if (!p.key) {
-                            const pick = params.get('$pick');
-                            const omit = params.get('$omit');
-                            const include = params.get('$include');
-                            return new HttpRequestHost({
-                                kind: 'CollectionCreateRequest',
-                                resource,
-                                operation: 'create',
-                                crud: 'create',
-                                many: false,
-                                args: {
-                                    data: incoming.body,
-                                    pick: pick && resource.normalizeFieldPath(pick),
-                                    omit: omit && resource.normalizeFieldPath(omit),
-                                    include: include && resource.normalizeFieldPath(include)
-                                }
-                            }, incoming);
-                        }
-                        break;
-                    }
-                    case 'DELETE': {
-                        if (p.key) {
-                            return new HttpRequestHost({
-                                kind: 'CollectionDeleteRequest',
-                                resource,
-                                operation: 'delete',
-                                crud: 'delete',
-                                many: false,
-                                args: {
-                                    key: resource.parseKeyValue(p.key)
-                                }
-                            }, incoming);
-                        }
-                        const filter = resource.normalizeFilter(params.get('$filter'));
-                        return new HttpRequestHost({
-                            kind: 'CollectionDeleteManyRequest',
-                            resource,
-                            operation: 'deleteMany',
-                            crud: 'delete',
-                            many: true,
-                            args: {
-                                filter
-                            }
-                        }, incoming);
-                    }
-                    case 'GET': {
-                        const pick = params.get('$pick');
-                        const omit = params.get('$omit');
-                        const include = params.get('$include');
-                        if (p.key) {
-                            return new HttpRequestHost({
-                                kind: 'CollectionGetRequest',
-                                resource,
-                                operation: 'get',
-                                crud: 'read',
-                                many: false,
-                                args: {
-                                    key: resource.parseKeyValue(p.key),
-                                    pick: pick && resource.normalizeFieldPath(pick),
-                                    omit: omit && resource.normalizeFieldPath(omit),
-                                    include: include && resource.normalizeFieldPath(include)
-                                }
-                            }, incoming);
-                        }
-                        const filter = resource.normalizeFilter(params.get('$filter'));
-                        const sort = params.get('$sort');
-                        return new HttpRequestHost({
-                            kind: 'CollectionFindManyRequest',
-                            resource,
-                            operation: 'findMany',
-                            crud: 'read',
-                            many: true,
-                            args: {
-                                pick: pick && resource.normalizeFieldPath(pick),
-                                omit: omit && resource.normalizeFieldPath(omit),
-                                include: include && resource.normalizeFieldPath(include),
-                                sort: sort && resource.normalizeSortFields(sort),
-                                filter,
-                                limit: params.get('$limit'),
-                                skip: params.get('$skip'),
-                                distinct: params.get('$distinct'),
-                                count: params.get('$count'),
-                            }
-                        }, incoming);
-                    }
-                    case 'PATCH': {
-                        if (p.key) {
-                            const pick = params.get('$pick');
-                            const omit = params.get('$omit');
-                            const include = params.get('$include');
-                            return new HttpRequestHost({
-                                kind: 'CollectionUpdateRequest',
-                                resource,
-                                operation: 'update',
-                                crud: 'update',
-                                many: false,
-                                args: {
-                                    key: resource.parseKeyValue(p.key),
-                                    data: incoming.body,
-                                    pick: pick && resource.normalizeFieldPath(pick),
-                                    omit: omit && resource.normalizeFieldPath(omit),
-                                    include: include && resource.normalizeFieldPath(include),
-                                }
-                            }, incoming);
-                        }
-                        const filter = resource.normalizeFilter(params.get('$filter'));
-                        return new HttpRequestHost({
-                            kind: 'CollectionUpdateManyRequest',
-                            resource,
-                            operation: 'updateMany',
-                            crud: 'update',
-                            many: true,
-                            args: {
-                                data: incoming.body,
-                                filter,
-                            }
-                        }, incoming);
-                    }
-                    default:
-                        throw new BadRequestError();
-                }
-            }
-            else 
-            /*
-             * Singleton
-             */
-            if (resource instanceof Singleton) {
-                if (p.key)
-                    throw new BadRequestError();
-                switch (method) {
-                    case 'POST': {
-                        const pick = params.get('$pick');
-                        const omit = params.get('$omit');
-                        const include = params.get('$include');
-                        return new HttpRequestHost({
-                            kind: 'SingletonCreateRequest',
-                            resource,
-                            operation: 'create',
-                            crud: 'create',
-                            many: false,
-                            args: {
-                                data: incoming.body,
-                                pick: pick && resource.normalizeFieldPath(pick),
-                                omit: omit && resource.normalizeFieldPath(omit),
-                                include: include && resource.normalizeFieldPath(include),
-                            }
-                        }, incoming);
-                    }
-                    case 'DELETE': {
-                        return new HttpRequestHost({
-                            kind: 'SingletonDeleteRequest',
-                            resource,
-                            operation: 'delete',
-                            crud: 'delete',
-                            many: false,
-                            args: {}
-                        }, incoming);
-                    }
-                    case 'GET': {
-                        const pick = params.get('$pick');
-                        const omit = params.get('$omit');
-                        const include = params.get('$include');
-                        return new HttpRequestHost({
-                            kind: 'SingletonGetRequest',
-                            resource,
-                            operation: 'get',
-                            crud: 'read',
-                            many: false,
-                            args: {
-                                pick: pick && resource.normalizeFieldPath(pick),
-                                omit: omit && resource.normalizeFieldPath(omit),
-                                include: include && resource.normalizeFieldPath(include),
-                            }
-                        }, incoming);
-                    }
-                    case 'PATCH': {
-                        const pick = params.get('$pick');
-                        const omit = params.get('$omit');
-                        const include = params.get('$include');
-                        return new HttpRequestHost({
-                            kind: 'SingletonUpdateRequest',
-                            resource,
-                            operation: 'update',
-                            crud: 'update',
-                            many: false,
-                            args: {
-                                data: incoming.body,
-                                pick: pick && resource.normalizeFieldPath(pick),
-                                omit: omit && resource.normalizeFieldPath(omit),
-                                include: include && resource.normalizeFieldPath(include),
-                            }
-                        }, incoming);
-                    }
-                    default:
-                        throw new BadRequestError();
-                }
-            }
-            else
-                throw new InternalServerError();
-            // if (query instanceof SingletonGetQuery || query instanceof CollectionGetQuery || query instanceof ElementReadQuery) {
-            //   // Move through properties
-            //   let parentType: DataType;
-            //   const curPath: string[] = [];
-            //   let parent: SingletonGetQuery | CollectionGetQuery | ElementReadQuery = query;
-            //   while (++pathIndex < pathLen) {
-            //     p = url.path.get(pathIndex);
-            //     parentType = parent.type;
-            //     if (parent.type instanceof UnionType) {
-            //       if (parent.type.name === 'any')
-            //         parentType = this.document.getComplexType('object');
-            //       else
-            //         throw new TypeError(`"${resource.name}.${curPath.join()}" is a UnionType and needs type casting.`);
-            //     }
-            //     if (!(parentType instanceof ComplexType))
-            //       throw new TypeError(`"${resource.name}.${curPath.join()}" is not a ComplexType and has no fields.`);
-            //     curPath.push(p.resource);
-            //     parent.child = new ElementReadQuery(parent, p.resource, {castingType: parentType});
-            //     parent = parent.child;
-            //   }
-            // }
-            throw new MethodNotAllowedError({
-                message: `Method "${method}" is not allowed by target endpoint`
-            });
-        }
-        catch (e) {
-            if (e instanceof OpraException)
-                throw e;
-            throw new BadRequestError(e);
-        }
-    }
-    // async parseMultiPart(
-    //     context: TExecutionContext,
-    //     url: OpraURL,
-    //     headers: IncomingHttpHeaders,
-    //     input: Readable,
-    //     boundary: string
-    // ): Promise<BatchRequestContext> {
-    //   return await new Promise((resolve, reject) => {
-    //     let _resolved = false;
-    //     const dicer = new Dicer({boundary});
-    //     const doReject = (e) => {
-    //       if (_resolved) return;
-    //       _resolved = true;
-    //       reject(e);
-    //       taskQueue.clearQueue();
-    //       dicer.destroy();
-    //     }
-    //     const taskQueue = new TaskQueue({concurrency: 1});
-    //     taskQueue.on('error', doReject);
-    //
-    //     const queries: SingleRequestContext[] = [];
-    //     let partCounter = 0;
-    //     dicer.on('error', doReject);
-    //     dicer.on('part', part => {
-    //       const partIndex = partCounter++;
-    //       let header: any;
-    //       const chunks: Buffer[] = [];
-    //       part.on('error', doReject);
-    //       part.on('header', (_header) => header = normalizeHeaders(_header));
-    //       part.on('data', (chunk: Buffer) => chunks.push(chunk));
-    //       part.on('end', () => {
-    //         if (_resolved || !(header || chunks.length))
-    //           return;
-    //         const ct = header['content-type'];
-    //         if (ct === 'application/http') {
-    //           taskQueue.enqueue(async () => {
-    //             const data = Buffer.concat(chunks);
-    //             if (!(data && data.length))
-    //               return;
-    //             const r = HttpRequest.parse(data);
-    //             await callMiddlewares(r, [jsonBodyParser]);
-    //             const subUrl = new OpraURL(r.url);
-    //             const contentId = header && header['content-id'];
-    //             queries.push(this.parseSingleQuery({
-    //               context,
-    //               url: subUrl,
-    //               method: r.method,
-    //               headers: r.headers,
-    //               body: r.body,
-    //               contentId
-    //             }));
-    //           });
-    //         } else doReject(new BadRequestError({
-    //           message: 'Unaccepted "content-type" header in multipart data',
-    //           details: {
-    //             position: `${boundary}[${partIndex}]`
-    //           }
-    //         }))
-    //       });
-    //     });
-    //     dicer.on('finish', () => {
-    //       taskQueue.enqueue(() => {
-    //         if (_resolved) return;
-    //         _resolved = true;
-    //         const batch = new BatchRequestContext({
-    //           service: this.document,
-    //           context,
-    //           headers,
-    //           queries,
-    //           params: url.searchParams,
-    //           continueOnError: false
-    //         });
-    //         resolve(batch);
-    //       });
-    //     });
-    //     input.pipe(dicer);
-    //   });
-    // }
-    async sendResponse(context) {
-        const { request, response } = context;
-        const outgoing = response.switchToHttp();
-        const errors = response.errors?.map(e => wrapException(e));
-        if (errors && errors.length) {
-            await this.errorHandler(request.switchToHttp(), outgoing, errors);
-            return;
-        }
-        outgoing.set(HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.set(HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.set(HttpHeaderCodes.Expires, '-1');
-        outgoing.set(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-        outgoing.status(outgoing.statusCode || HttpStatusCodes.OK);
-        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.set(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
-                    outgoing.send(JSON.stringify(body));
-                }
-            }
-            else
-                outgoing.send(JSON.stringify(response.value));
-        }
-        outgoing.end();
-    }
 }

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

@@ -0,0 +1,122 @@
+/*
+  This file contains code blocks from open source NodeJs project
+  https://github.com/nodejs/
+ */
+import * as stream from 'stream';
+import { HTTPParser } from '@browsery/http-parser';
+import { isReadable } from '@opra/common';
+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('kHeaders');
+export const kHeadersDistinct = Symbol('kHeadersDistinct');
+export const kTrailers = Symbol('kTrailers');
+export const kTrailersDistinct = Symbol('kTrailersDistinct');
+/**
+ *
+ * @class HttpIncomingMessageHost
+ */
+export class HttpIncomingMessageHost {
+    constructor() {
+        this.rawHeaders = [];
+        this.rawTrailers = [];
+        this.complete = false;
+        this.joinDuplicateHeaders = false;
+        stream.Readable.apply(this);
+    }
+    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];
+    }
+    _readConfig(init) {
+        this.complete = true;
+        this.httpVersionMajor = init?.httpVersionMajor || 1;
+        this.httpVersionMinor = init?.httpVersionMinor || 0;
+        this.method = (init.method || 'GET').toUpperCase();
+        this.url = init.url || '';
+        this.body = init.body;
+        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] : []);
+    }
+    _readBuffer(buf) {
+        const parser = new HTTPParser(HTTPParser.REQUEST);
+        let bodyChunks;
+        parser[HTTPParser.kOnHeadersComplete] = (info) => {
+            this.httpVersionMajor = info.versionMajor;
+            this.httpVersionMinor = info.versionMinor;
+            this.rawHeaders = info.headers;
+            this.method = HTTPParser.methods[info.method];
+            this.url = info.url;
+        };
+        parser[HTTPParser.kOnHeaders] = (trailers) => {
+            this.rawTrailers = trailers;
+        };
+        parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
+            bodyChunks = bodyChunks || [];
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        parser[HTTPParser.kOnMessageComplete] = () => {
+            this.complete = true;
+            if (bodyChunks)
+                this.body = Buffer.concat(bodyChunks);
+        };
+        const buffer = Buffer.from(buf);
+        let x = parser.execute(buffer, 0, buffer.length);
+        if (typeof x === 'object')
+            throw x;
+        if (!this.complete) {
+            x = parser.execute(CRLF);
+            if (typeof x === 'object')
+                throw x;
+        }
+        parser.finish();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _readStream(readable) {
+        throw new Error('_readStream is not implemented yet');
+    }
+    static create(init) {
+        const msg = new HttpIncomingMessageHost();
+        if (Buffer.isBuffer(init))
+            msg._readBuffer(init);
+        else if (isReadable(init)) {
+            throw new Error('fromStream is not implemented yet');
+        }
+        else if (init)
+            msg._readConfig(init);
+        return msg;
+    }
+}
+// Apply mixins
+Object.assign(HttpIncomingMessageHost.prototype, stream.Readable.prototype);