@opra/core 0.22.0 → 0.23.1

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

@@ -0,0 +1,148 @@
+"use strict";
+/*
+  This file contains code blocks from open source NodeJs project
+  https://github.com/nodejs/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpIncomingMessageHost = exports.kTrailersDistinct = exports.kTrailers = exports.kHeadersDistinct = exports.kHeaders = exports.CRLF = void 0;
+const stream_1 = require("stream");
+const http_parser_1 = require("@browsery/http-parser");
+const common_1 = require("@opra/common");
+const concat_readable_js_1 = require("../helpers/concat-readable.js");
+const convert_to_headers_js_1 = require("../helpers/convert-to-headers.js");
+const convert_to_raw_headers_js_1 = require("../helpers/convert-to-raw-headers.js");
+exports.CRLF = Buffer.from('\r\n');
+exports.kHeaders = Symbol.for('kHeaders');
+exports.kHeadersDistinct = Symbol.for('kHeadersDistinct');
+exports.kTrailers = Symbol.for('kTrailers');
+exports.kTrailersDistinct = Symbol.for('kTrailersDistinct');
+/**
+ *
+ * @class HttpIncomingMessageHost
+ */
+class HttpIncomingMessageHost extends stream_1.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 : (0, convert_to_raw_headers_js_1.convertToRawHeaders)(init.headers);
+            if (init.trailers)
+                this.rawTrailers = Array.isArray(init.trailers) ? init.trailers : (0, convert_to_raw_headers_js_1.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[exports.kHeaders])
+            this[exports.kHeaders] = (0, convert_to_headers_js_1.convertToHeaders)(this.rawHeaders, {}, this.joinDuplicateHeaders);
+        return this[exports.kHeaders];
+    }
+    set headers(headers) {
+        this[exports.kHeaders] = headers;
+    }
+    get headersDistinct() {
+        if (!this[exports.kHeadersDistinct])
+            this[exports.kHeadersDistinct] = (0, convert_to_headers_js_1.convertToHeadersDistinct)(this.rawHeaders, {});
+        return this[exports.kHeadersDistinct];
+    }
+    get trailers() {
+        if (!this[exports.kTrailers])
+            this[exports.kTrailers] = (0, convert_to_headers_js_1.convertToHeaders)(this.rawTrailers, {}, this.joinDuplicateHeaders);
+        return this[exports.kTrailers];
+    }
+    set trailers(trailers) {
+        this[exports.kTrailers] = trailers;
+    }
+    get trailersDistinct() {
+        if (!this[exports.kTrailersDistinct])
+            this[exports.kTrailersDistinct] = (0, convert_to_headers_js_1.convertToHeadersDistinct)(this.rawTrailers, {});
+        return this[exports.kTrailersDistinct];
+    }
+    _read(size) {
+        if (!this.body) {
+            this.push(null);
+            return;
+        }
+        if (!this._readStream) {
+            if ((0, common_1.isIterable)(this.body) || (0, common_1.isAsyncIterable)(this.body))
+                this._readStream = stream_1.Readable.from(this.body);
+            else if (typeof this.body === 'string') {
+                this._readStream = stream_1.Readable.from(Buffer.from(this.body, 'utf-8'));
+            }
+            else
+                this._readStream = stream_1.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' && !((0, common_1.isIterable)(iterable) || (0, common_1.isAsyncIterable)(iterable)))
+            return new HttpIncomingMessageHost(iterable);
+        const msg = new HttpIncomingMessageHost();
+        const parser = msg._httpParser = new http_parser_1.HTTPParser(http_parser_1.HTTPParser.REQUEST);
+        let bodyChunks;
+        parser[http_parser_1.HTTPParser.kOnHeadersComplete] = (info) => {
+            msg.httpVersionMajor = info.versionMajor;
+            msg.httpVersionMinor = info.versionMinor;
+            msg.rawHeaders = info.headers;
+            msg.method = http_parser_1.HTTPParser.methods[info.method];
+            msg.url = info.url;
+        };
+        parser[http_parser_1.HTTPParser.kOnHeaders] = (trailers) => {
+            msg.rawTrailers = trailers;
+        };
+        parser[http_parser_1.HTTPParser.kOnBody] = (chunk, offset, length) => {
+            bodyChunks = bodyChunks || [];
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        parser[http_parser_1.HTTPParser.kOnMessageComplete] = () => {
+            msg.complete = true;
+            if (bodyChunks)
+                msg.body = Buffer.concat(bodyChunks);
+        };
+        const readable = (0, concat_readable_js_1.concatReadable)(stream_1.Readable.from(iterable), stream_1.Readable.from(exports.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));
+        });
+    }
+}
+exports.HttpIncomingMessageHost = HttpIncomingMessageHost;

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

@@ -3,36 +3,42 @@
   This file contains code blocks from open source NodeJs project
   https://github.com/nodejs/
  */
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpOutgoingMessageHost = exports.kErrored = exports.kOutTrailers = exports.kOutHeaders = void 0;
-const tslib_1 = require("tslib");
-const stream = tslib_1.__importStar(require("stream"));
+exports.HttpOutgoingMessageHost = exports.kOutTrailers = exports.kOutHeaders = void 0;
+const stream_1 = require("stream");
 const common_js_1 = require("../helpers/common.js");
-exports.kOutHeaders = Symbol('kOutHeaders');
-exports.kOutTrailers = Symbol('kOutTrailers');
-exports.kErrored = Symbol('kErrored');
+exports.kOutHeaders = Symbol.for('kOutHeaders');
+exports.kOutTrailers = Symbol.for('kOutTrailers');
 // noinspection JSUnusedLocalSymbols
 /**
  *
  * @class HttpOutgoingMessageHost
  */
-class HttpOutgoingMessageHost {
-    constructor() {
+class HttpOutgoingMessageHost extends stream_1.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[exports.kErrored];
+    get headersSent() {
+        return this._headersSent;
     }
     appendHeader(name, value) {
         if (this.headersSent)
@@ -185,26 +191,8 @@ 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);
     }
 }
 exports.HttpOutgoingMessageHost = HttpOutgoingMessageHost;
-_a = exports.kErrored;
-// Apply mixins
-Object.assign(HttpOutgoingMessageHost.prototype, stream.Stream.prototype);

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

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityRequestHandler = void 0;
+const tslib_1 = require("tslib");
+const body_parser_1 = tslib_1.__importDefault(require("body-parser"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const valgen = tslib_1.__importStar(require("valgen"));
+const common_1 = require("@opra/common");
+const operation_context_js_1 = require("../../operation-context.js");
+const request_host_js_1 = require("../../request.host.js");
+const response_host_js_1 = require("../../response.host.js");
+const query_parsers_js_1 = require("../helpers/query-parsers.js");
+const request_handler_base_js_1 = require("./request-handler-base.js");
+/**
+ * @class EntityRequestHandler
+ */
+class EntityRequestHandler extends request_handler_base_js_1.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 response_host_js_1.ResponseHost({ http: outgoing });
+        const context = operation_context_js_1.OperationContext.from(executionContext, request, response);
+        // Execute operation
+        await this.executeOperation(context);
+        if (response.errors.length) {
+            context.errors.push(...response.errors);
+            return;
+        }
+        try {
+            await this.sendResponse(context);
+        }
+        catch (e) {
+            if (e instanceof common_1.OpraException)
+                throw e;
+            if (e instanceof valgen.ValidationError) {
+                throw new common_1.InternalServerError({
+                    message: (0, common_1.translate)('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                    code: 'RESPONSE_VALIDATION',
+                    details: e.issues
+                }, e);
+            }
+            throw new common_1.InternalServerError(e);
+        }
+    }
+    async parseRequest(incoming) {
+        const p = incoming.parsedUrl.path[0];
+        const resource = this.adapter.api.getResource(p.resource);
+        try {
+            if (resource instanceof common_1.Collection)
+                return await this.parseCollectionRequest(resource, incoming);
+            if (resource instanceof common_1.Singleton)
+                return await this.parseSingletonRequest(resource, incoming);
+        }
+        catch (e) {
+            if (e instanceof common_1.OpraException)
+                throw e;
+            if (e instanceof valgen.ValidationError) {
+                throw new common_1.BadRequestError({
+                    message: (0, common_1.translate)('error:REQUEST_VALIDATION,', 'Request validation failed'),
+                    code: 'REQUEST_VALIDATION',
+                    details: e.issues
+                }, e);
+            }
+            throw new common_1.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 common_1.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 common_1.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 || common_1.HttpStatusCodes.OK;
+        const body = this.adapter._i18n.deep(responseObject);
+        outgoing.setHeader(common_1.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 common_1.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');
+                    let data = await jsonReader(incoming);
+                    data = decode(data, { coerce: true });
+                    const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                    const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                    const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                    return new request_host_js_1.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 request_host_js_1.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 request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'deleteMany',
+                    params: {
+                        filter
+                    }
+                });
+            }
+            case 'GET': {
+                const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'get');
+                    return new request_host_js_1.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 = (0, query_parsers_js_1.parseArrayParam)(params.get('$sort'));
+                return new request_host_js_1.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: (0, putil_varhelpers_1.toInt)(params.get('$limit')),
+                        skip: (0, putil_varhelpers_1.toInt)(params.get('$skip')),
+                        distinct: (0, putil_varhelpers_1.toBoolean)(params.get('$distinct')),
+                        count: (0, putil_varhelpers_1.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');
+                    let data = await jsonReader(incoming);
+                    data = decode(data, { coerce: true });
+                    const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                    const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                    const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                    return new request_host_js_1.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');
+                let data = await jsonReader(incoming);
+                data = decode(data, { coerce: true });
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                return new request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'updateMany',
+                    data,
+                    params: {
+                        filter,
+                    }
+                });
+            }
+        }
+        throw new common_1.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 common_1.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');
+                let data = await jsonReader(incoming);
+                data = decode(data, { coerce: true });
+                const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                return new request_host_js_1.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 request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'delete',
+                });
+            }
+            case 'GET': {
+                const operationMeta = await this.assertOperation(resource, 'get');
+                const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                return new request_host_js_1.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');
+                let data = await jsonReader(incoming);
+                data = decode(data, { coerce: true });
+                const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                return new request_host_js_1.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 common_1.MethodNotAllowedError({
+            message: `Singleton resources do not accept http "${incoming.method}" method`
+        });
+    }
+    getBodyLoader(operation) {
+        let bodyLoader = this.bodyLoaders.get(operation);
+        if (!bodyLoader) {
+            const parser = body_parser_1.default.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;
+    }
+}
+exports.EntityRequestHandler = EntityRequestHandler;

package/cjs/adapter/http/request-handlers/request-handler-base.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHandlerBase = void 0;
+const common_1 = require("@opra/common");
+/**
+ * @class RequestHandlerBase
+ */
+class RequestHandlerBase {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    async assertOperation(resource, operation) {
+        const controller = await this.adapter.getController(resource);
+        const operationMeta = (typeof controller?.[operation] === 'function') && resource.operations[operation];
+        if (operationMeta)
+            return {
+                ...operationMeta,
+                controller
+            };
+        throw new common_1.ForbiddenError({
+            message: (0, common_1.translate)('RESOLVER_FORBIDDEN', { resource: resource.name, operation }, `'{{resource}}' endpoint does not accept '{{operation}}' operations`),
+            severity: 'error',
+            code: 'RESOLVER_FORBIDDEN'
+        });
+    }
+}
+exports.RequestHandlerBase = RequestHandlerBase;