@opra/core 0.21.0 → 0.23.0

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) {
@@ -43,28 +43,28 @@ class HttpServerResponseHost {
     }
     setHeader(field, val) {
         const setHeader = Object.getPrototypeOf(this).setHeader;
-        if (typeof field === 'string') {
-            let value = Array.isArray(val)
-                ? val.map(String)
-                : (val ? String(val) : '');
-            // add charset to content-type
-            if (field.toLowerCase() === 'content-type') {
-                if (Array.isArray(value)) {
-                    throw new TypeError('Content-Type cannot be set to an Array');
-                }
-                if (!charsetRegExp.test(value)) {
-                    const charset = mime.charsets.lookup(value.split(';')[0]);
-                    if (charset)
-                        value += '; charset=' + charset.toLowerCase();
-                }
-            }
-            setHeader.call(this, field, value);
-        }
-        else {
+        if (typeof field === 'object') {
             for (const [k, v] of Object.entries(field)) {
                 this.setHeader(k, v);
             }
+            return this;
+        }
+        const fieldLower = field.toLowerCase();
+        let value = Array.isArray(val)
+            ? val.map(String)
+            : (val ? String(val) : '');
+        // add charset to content-type
+        if (fieldLower === 'content-type') {
+            if (Array.isArray(value)) {
+                throw new TypeError('Content-Type cannot be set to an Array');
+            }
+            if (!charsetRegExp.test(value)) {
+                const charset = mime.charsets.lookup(value.split(';')[0]);
+                if (charset)
+                    value += '; charset=' + charset.toLowerCase();
+            }
         }
+        setHeader.call(this, field, value);
         return this;
     }
     clearCookie(name, options) {

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);

package/esm/adapter/http/request-handlers/entity-request-handler.js

@@ -0,0 +1,373 @@
+import bodyParser from 'body-parser';
+import { toBoolean, toInt } from 'putil-varhelpers';
+import { BadRequestError, Collection, HttpHeaderCodes, HttpStatusCodes, InternalServerError, MethodNotAllowedError, OpraException, ResourceNotFoundError, Singleton, } from '@opra/common';
+import { OperationContext } from '../../operation-context.js';
+import { RequestHost } from '../../request.host.js';
+import { ResponseHost } from '../../response.host.js';
+import { parseArrayParam } from '../helpers/query-parsers.js';
+import { RequestHandlerBase } from './request-handler-base.js';
+/**
+ * @class EntityRequestHandler
+ */
+export class EntityRequestHandler extends RequestHandlerBase {
+    constructor(adapter) {
+        super(adapter);
+        this.adapter = adapter;
+        this.bodyLoaders = new WeakMap();
+    }
+    async processRequest(executionContext) {
+        const { incoming, outgoing } = executionContext.switchToHttp();
+        // Parse incoming message and create Request object
+        const request = await this.parseRequest(incoming);
+        if (!request)
+            return;
+        const response = new ResponseHost({ http: outgoing });
+        const context = OperationContext.from(executionContext, request, response);
+        // Execute operation
+        await this.executeOperation(context);
+        if (response.errors.length) {
+            context.errors.push(...response.errors);
+            return;
+        }
+        await this.sendResponse(context);
+    }
+    async parseRequest(incoming) {
+        const p = incoming.parsedUrl.path[0];
+        const resource = this.adapter.api.getResource(p.resource);
+        try {
+            if (resource instanceof Collection)
+                return await this.parseCollectionRequest(resource, incoming);
+            if (resource instanceof Singleton)
+                return await this.parseSingletonRequest(resource, incoming);
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            throw new BadRequestError(e);
+        }
+    }
+    async executeOperation(context) {
+        const request = context.request;
+        const { response } = context;
+        const resource = request.resource;
+        // Call operation handler method
+        let value;
+        try {
+            value = await request.controller[request.operation].call(request.controller, context);
+            if (value == null)
+                value = response.value;
+            const { operation } = request;
+            if (operation === 'delete' || operation === 'deleteMany' || operation === 'updateMany') {
+                let affected = 0;
+                if (typeof value === 'number')
+                    affected = value;
+                if (typeof value === 'boolean')
+                    affected = value ? 1 : 0;
+                if (typeof value === 'object')
+                    affected = value.affected || value.affectedRows ||
+                        (operation === 'updateMany' ? value.updated : value.deleted);
+                response.value = affected;
+            }
+            else {
+                // "get" and "update" operations must return the entity instance, otherwise it means resource not found
+                if (value == null && (request.operation === 'get' || request.operation === 'update'))
+                    throw new ResourceNotFoundError(resource.name, request.key);
+                // "findMany" operation should return array of entity instances
+                if (request.operation === 'findMany')
+                    value = value == null ? [] : Array.isArray(value) ? value : [value];
+                else
+                    value = value == null ? {} : Array.isArray(value) ? value[0] : value;
+                response.value = value;
+            }
+        }
+        catch (error) {
+            response.errors.push(error);
+        }
+    }
+    async sendResponse(context) {
+        const { request, response } = context;
+        const resource = request.resource;
+        const outgoing = response.switchToHttp();
+        let responseObject;
+        if (request.operation === 'delete' || request.operation === 'deleteMany' || request.operation === 'updateMany') {
+            responseObject = {
+                resource: resource.name,
+                operation: request.operation,
+                affected: response.value
+            };
+        }
+        else {
+            if (!response.value)
+                throw new InternalServerError(`"${request.operation}" operation should return value`);
+            const encode = resource.getEncoder(request.operation);
+            const data = encode(response.value, { coerce: true });
+            if (request.operation === 'create')
+                outgoing.statusCode = 201;
+            responseObject = {
+                resource: resource.name,
+                operation: request.operation,
+                data
+            };
+            if (request.operation === 'create' || request.operation === 'update')
+                responseObject.affected = 1;
+            if (request.operation === 'findMany' && response.count != null && response.count >= 0)
+                responseObject.totalCount = response.count;
+        }
+        outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
+        const body = this.adapter._i18n.deep(responseObject);
+        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.send(JSON.stringify(body));
+        outgoing.end();
+    }
+    async parseCollectionRequest(resource, incoming) {
+        if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+            incoming.headers['content-type'] !== 'application/json')
+            throw new BadRequestError({ message: 'Unsupported Content-Type' });
+        const contentId = incoming.headers['content-id'];
+        const p = incoming.parsedUrl.path[0];
+        const params = incoming.parsedUrl.searchParams;
+        switch (incoming.method) {
+            case 'POST': {
+                if (p.key == null) {
+                    const operationMeta = await this.assertOperation(resource, 'create');
+                    const jsonReader = this.getBodyLoader(operationMeta);
+                    const decode = resource.getDecoder('create');
+                    const data = decode(await jsonReader(incoming), { coerce: true });
+                    const pick = parseArrayParam(params.get('$pick'));
+                    const omit = parseArrayParam(params.get('$omit'));
+                    const include = parseArrayParam(params.get('$include'));
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'create',
+                        data,
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include)
+                        }
+                    });
+                }
+                break;
+            }
+            case 'DELETE': {
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'delete',
+                        key: resource.parseKeyValue(p.key)
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'deleteMany');
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'deleteMany',
+                    params: {
+                        filter
+                    }
+                });
+            }
+            case 'GET': {
+                const pick = parseArrayParam(params.get('$pick'));
+                const omit = parseArrayParam(params.get('$omit'));
+                const include = parseArrayParam(params.get('$include'));
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'get');
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'get',
+                        key: resource.parseKeyValue(p.key),
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include)
+                        }
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'findMany');
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                const sort = parseArrayParam(params.get('$sort'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'findMany',
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include),
+                        sort: sort && resource.normalizeSortFields(sort),
+                        filter,
+                        limit: toInt(params.get('$limit')),
+                        skip: toInt(params.get('$skip')),
+                        distinct: toBoolean(params.get('$distinct')),
+                        count: toBoolean(params.get('$count')),
+                    }
+                });
+            }
+            case 'PATCH': {
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'update');
+                    const jsonReader = this.getBodyLoader(operationMeta);
+                    const decode = resource.getDecoder('update');
+                    const data = decode(await jsonReader(incoming), { coerce: true });
+                    const pick = parseArrayParam(params.get('$pick'));
+                    const omit = parseArrayParam(params.get('$omit'));
+                    const include = parseArrayParam(params.get('$include'));
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'update',
+                        key: resource.parseKeyValue(p.key),
+                        data,
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include),
+                        }
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'updateMany');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('updateMany');
+                const data = decode(await jsonReader(incoming), { coerce: true });
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'updateMany',
+                    data,
+                    params: {
+                        filter,
+                    }
+                });
+            }
+        }
+        throw new MethodNotAllowedError({
+            message: `Collection resources do not accept http "${incoming.method}" method`
+        });
+    }
+    async parseSingletonRequest(resource, incoming) {
+        if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+            incoming.headers['content-type'] !== 'application/json')
+            throw new BadRequestError({ message: 'Unsupported Content-Type' });
+        const contentId = incoming.headers['content-id'];
+        const params = incoming.parsedUrl.searchParams;
+        switch (incoming.method) {
+            case 'POST': {
+                const operationMeta = await this.assertOperation(resource, 'create');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('create');
+                const data = decode(await jsonReader(incoming), { coerce: true });
+                const pick = parseArrayParam(params.get('$pick'));
+                const omit = parseArrayParam(params.get('$omit'));
+                const include = parseArrayParam(params.get('$include'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'create',
+                    data,
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include)
+                    }
+                });
+            }
+            case 'DELETE': {
+                const operationMeta = await this.assertOperation(resource, 'delete');
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'delete',
+                });
+            }
+            case 'GET': {
+                const operationMeta = await this.assertOperation(resource, 'get');
+                const pick = parseArrayParam(params.get('$pick'));
+                const omit = parseArrayParam(params.get('$omit'));
+                const include = parseArrayParam(params.get('$include'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'get',
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include)
+                    }
+                });
+            }
+            case 'PATCH': {
+                const operationMeta = await this.assertOperation(resource, 'update');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('update');
+                const data = decode(await jsonReader(incoming), { coerce: true });
+                const pick = parseArrayParam(params.get('$pick'));
+                const omit = parseArrayParam(params.get('$omit'));
+                const include = parseArrayParam(params.get('$include'));
+                return new RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'update',
+                    data,
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include),
+                    }
+                });
+            }
+        }
+        throw new MethodNotAllowedError({
+            message: `Singleton resources do not accept http "${incoming.method}" method`
+        });
+    }
+    getBodyLoader(operation) {
+        let bodyLoader = this.bodyLoaders.get(operation);
+        if (!bodyLoader) {
+            const parser = bodyParser.json({
+                limit: operation.input?.maxContentSize,
+                type: 'json'
+            });
+            bodyLoader = (incoming) => {
+                return new Promise((resolve, reject) => {
+                    const next = (error) => {
+                        if (error)
+                            return reject(error);
+                        resolve(incoming.body);
+                    };
+                    parser(incoming, {}, next);
+                });
+            };
+            this.bodyLoaders.set(operation, bodyLoader);
+        }
+        return bodyLoader;
+    }
+}