@opra/core 1.0.0-alpha.3 → 1.0.0-alpha.31

package/esm/http/{impl/http-handler.js → http-handler.js}

@@ -1,12 +1,12 @@
+import * as process from 'node:process';
+import typeIs from '@browsery/type-is';
+import { BadRequestError, HttpHeaderCodes, HttpStatusCode, InternalServerError, isBlob, isReadableStream, IssueSeverity, MethodNotAllowedError, MimeTypes, OperationResult, OpraException, OpraSchema, } from '@opra/common';
 import { parse as parseContentType } from 'content-type';
 import { splitString } from 'fast-tokenizer';
-import * as process from 'node:process';
 import { asMutable } from 'ts-gems';
 import { toArray, ValidationError, vg } from 'valgen';
-import typeIs from '@browsery/type-is';
-import { BadRequestError, HttpHeaderCodes, HttpStatusCode, InternalServerError, isBlob, isReadableStream, IssueSeverity, MethodNotAllowedError, MimeTypes, OperationResult, OpraException, OpraSchema, translate, } from '@opra/common';
-import { kAssetCache } from '../../constants.js';
-import { wrapException } from '../utils/wrap-exception.js';
+import { kAssetCache } from '../constants';
+import { wrapException } from './utils/wrap-exception';
 /**
  * @class HttpHandler
  */
@@ -38,7 +38,7 @@ export class HttpHandler {
                     throw e;
                 if (e instanceof ValidationError) {
                     throw new BadRequestError({
-                        message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                        message: 'Response validation failed',
                         code: 'RESPONSE_VALIDATION',
                         details: e.issues,
                     }, e);
@@ -48,11 +48,14 @@ export class HttpHandler {
             await this.adapter.emitAsync('request', context);
             // Call interceptors than execute request
             if (this.adapter.interceptors) {
+                const interceptors = this.adapter.interceptors;
                 let i = 0;
                 const next = async () => {
-                    const interceptor = this.adapter.interceptors[i++];
-                    if (interceptor)
+                    const interceptor = interceptors[i++];
+                    if (typeof interceptor === 'function')
                         await interceptor(context, next);
+                    else if (typeof interceptor?.intercept === 'function')
+                        await interceptor.intercept(context, next);
                     await this._executeRequest(context);
                 };
                 await next();
@@ -60,23 +63,21 @@ export class HttpHandler {
             else
                 await this._executeRequest(context);
         }
-        catch (e) {
+        catch (error) {
+            let e = error;
             if (e instanceof ValidationError) {
                 e = new InternalServerError({
-                    message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                    message: 'Response validation failed',
                     code: 'RESPONSE_VALIDATION',
                     details: e.issues,
                 }, e);
             }
             else
                 e = wrapException(e);
-            response.status(e.statusCode || e.status || HttpStatusCode.INTERNAL_SERVER_ERROR);
-            response.contentType(MimeTypes.opra_response_json);
-            await this._sendResponse(context, new OperationResult({ errors: [e] })).finally(() => {
-                if (!response.finished)
-                    response.end();
-            });
-            // if (!outgoing.writableEnded) await this._sendErrorResponse(context.response, [error]);
+            if (this.onError)
+                await this.onError(context, error);
+            context.errors.push(e);
+            await this.sendResponse(context);
         }
         finally {
             await context.emitAsync('finish');
@@ -89,7 +90,7 @@ export class HttpHandler {
     async parseRequest(context) {
         await this._parseParameters(context);
         await this._parseContentType(context);
-        if (context.operation.requestBody?.immediateFetch)
+        if (context.operation?.requestBody?.immediateFetch)
             await context.getBody();
         /** Set default status code as the first status code between 200 and 299 */
         if (context.operation) {
@@ -109,17 +110,19 @@ export class HttpHandler {
      */
     async _parseParameters(context) {
         const { operation, request } = context;
-        let prmName = '';
+        if (!operation)
+            return;
+        let key = '';
         try {
             const onFail = (issue) => {
-                issue.location = prmName;
+                issue.location = key;
                 return issue;
             };
             /** prepare decoders */
             const getDecoder = (prm) => {
                 let decode = this[kAssetCache].get(prm, 'decode');
                 if (!decode) {
-                    decode = prm.type?.generateCodec('decode') || vg.isAny();
+                    decode = prm.type?.generateCodec('decode', { ignoreReadonlyFields: true }) || vg.isAny();
                     this[kAssetCache].set(prm, 'decode', decode);
                 }
                 return decode;
@@ -127,9 +130,9 @@ export class HttpHandler {
             const paramsLeft = new Set([...operation.parameters, ...operation.owner.parameters]);
             /** parse cookie parameters */
             if (request.cookies) {
-                for (prmName of Object.keys(request.cookies)) {
-                    const oprPrm = operation.findParameter(prmName, 'cookie');
-                    const cntPrm = operation.owner.findParameter(prmName, 'cookie');
+                for (key of Object.keys(request.cookies)) {
+                    const oprPrm = operation.findParameter(key, 'cookie');
+                    const cntPrm = operation.owner.findParameter(key, 'cookie');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -138,16 +141,17 @@ export class HttpHandler {
                     if (cntPrm)
                         paramsLeft.delete(cntPrm);
                     const decode = getDecoder(prm);
-                    const v = decode(request.cookies[prmName], { coerce: true, label: prmName, onFail });
+                    const v = decode(request.cookies[key], { coerce: true, label: key, onFail });
+                    const prmName = typeof prm.name === 'string' ? prm.name : key;
                     if (v !== undefined)
                         context.cookies[prmName] = v;
                 }
             }
             /** parse headers */
             if (request.headers) {
-                for (prmName of Object.keys(request.headers)) {
-                    const oprPrm = operation.findParameter(prmName, 'header');
-                    const cntPrm = operation.owner.findParameter(prmName, 'header');
+                for (key of Object.keys(request.headers)) {
+                    const oprPrm = operation.findParameter(key, 'header');
+                    const cntPrm = operation.owner.findParameter(key, 'header');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -156,16 +160,17 @@ export class HttpHandler {
                     if (cntPrm)
                         paramsLeft.delete(cntPrm);
                     const decode = getDecoder(prm);
-                    const v = decode(request.headers[prmName], { coerce: true, label: prmName, onFail });
+                    const v = decode(request.headers[key], { coerce: true, label: key, onFail });
+                    const prmName = typeof prm.name === 'string' ? prm.name : key;
                     if (v !== undefined)
                         context.headers[prmName] = v;
                 }
             }
             /** parse path parameters */
             if (request.params) {
-                for (prmName of Object.keys(request.params)) {
-                    const oprPrm = operation.findParameter(prmName, 'path');
-                    const cntPrm = operation.owner.findParameter(prmName, 'path');
+                for (key of Object.keys(request.params)) {
+                    const oprPrm = operation.findParameter(key, 'path');
+                    const cntPrm = operation.owner.findParameter(key, 'path');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -174,17 +179,17 @@ export class HttpHandler {
                     if (cntPrm)
                         paramsLeft.delete(cntPrm);
                     const decode = getDecoder(prm);
-                    const v = decode(request.params[prmName], { coerce: true, label: prmName, onFail });
+                    const v = decode(request.params[key], { coerce: true, label: key, onFail });
                     if (v !== undefined)
-                        context.pathParams[prmName] = v;
+                        context.pathParams[key] = v;
                 }
             }
             /** parse query parameters */
             const url = new URL(request.originalUrl || request.url || '/', 'http://tempuri.org');
             const { searchParams } = url;
-            for (prmName of searchParams.keys()) {
-                const oprPrm = operation.findParameter(prmName, 'query');
-                const cntPrm = operation.owner.findParameter(prmName, 'query');
+            for (key of searchParams.keys()) {
+                const oprPrm = operation.findParameter(key, 'query');
+                const cntPrm = operation.owner.findParameter(key, 'query');
                 const prm = oprPrm || cntPrm;
                 if (!prm)
                     continue;
@@ -193,20 +198,22 @@ export class HttpHandler {
                 if (cntPrm)
                     paramsLeft.delete(cntPrm);
                 const decode = getDecoder(prm);
-                let values = searchParams?.getAll(prmName);
+                let values = searchParams?.getAll(key);
+                const prmName = typeof prm.name === 'string' ? prm.name : key;
                 if (values?.length && prm.isArray) {
                     values = values.map(v => splitString(v, { delimiters: prm.arraySeparator, quotes: true })).flat();
-                    values = values.map(v => decode(v, { coerce: true, label: prmName, onFail }));
+                    values = values.map(v => decode(v, { coerce: true, label: key, onFail }));
                     if (values.length)
                         context.queryParams[prmName] = values;
                 }
                 else {
-                    const v = decode(values[0], { coerce: true, label: prmName, onFail });
+                    const v = decode(values[0], { coerce: true, label: key, onFail });
                     if (values.length)
                         context.queryParams[prmName] = v;
                 }
             }
             for (const prm of paramsLeft) {
+                key = String(prm.name);
                 // Throw error for required parameters
                 if (prm.required) {
                     const decode = getDecoder(prm);
@@ -216,8 +223,8 @@ export class HttpHandler {
         }
         catch (e) {
             if (e instanceof ValidationError) {
-                e = new BadRequestError({
-                    message: `Invalid parameter (${prmName}) value. ` + e.message,
+                throw new BadRequestError({
+                    message: `Invalid parameter (${key}) value. ` + e.message,
                     code: 'REQUEST_VALIDATION',
                     details: e.issues,
                 }, e);
@@ -232,14 +239,15 @@ export class HttpHandler {
      */
     async _parseContentType(context) {
         const { request, operation } = context;
+        if (!operation)
+            return;
         if (operation.requestBody?.content.length) {
             let mediaType;
             let contentType = request.header('content-type');
             if (contentType) {
                 contentType = parseContentType(contentType).type;
-                mediaType = operation.requestBody.content.find(mc => {
-                    return (mc.contentType && typeIs.is(contentType, Array.isArray(mc.contentType) ? mc.contentType : [mc.contentType]));
-                });
+                mediaType = operation.requestBody.content.find(mc => mc.contentType &&
+                    typeIs.is(contentType, Array.isArray(mc.contentType) ? mc.contentType : [mc.contentType]));
             }
             if (!mediaType) {
                 const contentTypes = operation.requestBody.content.map(mc => mc.contentType).flat();
@@ -258,11 +266,12 @@ export class HttpHandler {
             throw new MethodNotAllowedError();
         const responseValue = await context.operationHandler.call(context.controllerInstance, context);
         const { response } = context;
-        if (!response.writableEnded)
-            await this._sendResponse(context, responseValue).finally(() => {
+        if (!response.writableEnded) {
+            await this.sendResponse(context, responseValue).finally(() => {
                 if (!response.writableEnded)
                     response.end();
             });
+        }
     }
     /**
      *
@@ -270,93 +279,180 @@ export class HttpHandler {
      * @param responseValue
      * @protected
      */
-    async _sendResponse(context, responseValue) {
+    async sendResponse(context, responseValue) {
+        if (context.errors.length)
+            return this._sendErrorResponse(context);
         const { response } = context;
         const { document } = this.adapter;
-        const responseArgs = this._determineResponseArgs(context, responseValue);
-        const { operationResponse, statusCode } = responseArgs;
-        let { contentType, body } = responseArgs;
-        const operationResultType = document.node.getDataType(OperationResult);
-        let operationResultEncoder = this[kAssetCache].get(operationResultType, 'encode');
-        if (!operationResultEncoder) {
-            operationResultEncoder = operationResultType.generateCodec('encode');
-            this[kAssetCache].set(operationResultType, 'encode', operationResultEncoder);
-        }
-        /** Validate response */
-        if (operationResponse?.type) {
-            if (!(body == null && statusCode === HttpStatusCode.NO_CONTENT)) {
-                /** Generate encoder */
-                let encode = this[kAssetCache].get(operationResponse, 'encode');
-                if (!encode) {
-                    encode = operationResponse.type.generateCodec('encode', {
-                        partial: operationResponse.partial,
-                        projection: '*',
-                    });
-                    if (operationResponse) {
-                        if (operationResponse.isArray)
-                            encode = vg.isArray(encode);
-                        this[kAssetCache].set(operationResponse, 'encode', encode);
+        try {
+            const responseArgs = this._determineResponseArgs(context, responseValue);
+            const { operationResponse, statusCode } = responseArgs;
+            let { contentType, body } = responseArgs;
+            const operationResultType = document.node.getDataType(OperationResult);
+            let operationResultEncoder = this[kAssetCache].get(operationResultType, 'encode');
+            if (!operationResultEncoder) {
+                operationResultEncoder = operationResultType.generateCodec('encode', {
+                    ignoreWriteonlyFields: true,
+                    ignoreHiddenFields: true,
+                });
+                this[kAssetCache].set(operationResultType, 'encode', operationResultEncoder);
+            }
+            /** Validate response */
+            if (operationResponse?.type) {
+                if (!(body == null && statusCode === HttpStatusCode.NO_CONTENT)) {
+                    /** Generate encoder */
+                    let encode = this[kAssetCache].get(operationResponse, 'encode');
+                    if (!encode) {
+                        encode = operationResponse.type.generateCodec('encode', {
+                            partial: operationResponse.partial,
+                            projection: responseArgs.projection || '*',
+                            ignoreWriteonlyFields: true,
+                            ignoreHiddenFields: true,
+                            onFail: issue => `Response body validation failed: ` + issue.message,
+                        });
+                        if (operationResponse) {
+                            if (operationResponse.isArray)
+                                encode = vg.isArray(encode);
+                            this[kAssetCache].set(operationResponse, 'encode', encode);
+                        }
+                    }
+                    /** Encode body */
+                    if (operationResponse.type.extendsFrom(operationResultType)) {
+                        if (body instanceof OperationResult)
+                            body = encode(body);
+                        else {
+                            body.payload = encode(body.payload);
+                            body = operationResultEncoder(body);
+                        }
                     }
-                }
-                /** Encode body */
-                if (operationResponse.type.extendsFrom(operationResultType)) {
-                    if (body instanceof OperationResult)
-                        body = encode(body);
                     else {
-                        body.payload = encode(body.payload);
-                        body = operationResultEncoder(body);
+                        if (body instanceof OperationResult &&
+                            contentType &&
+                            typeIs.is(contentType, [MimeTypes.opra_response_json])) {
+                            body.payload = encode(body.payload);
+                            body = operationResultEncoder(body);
+                        }
+                        else {
+                            body = encode(body);
+                        }
                     }
-                }
-                else {
                     if (body instanceof OperationResult &&
-                        contentType &&
-                        typeIs.is(contentType, [MimeTypes.opra_response_json])) {
-                        body.payload = encode(body.payload);
-                        body = operationResultEncoder(body);
+                        operationResponse.type &&
+                        operationResponse.type !== document.node.getDataType(OperationResult)) {
+                        body.type = operationResponse.type.name ? operationResponse.type.name : '#embedded';
                     }
-                    else
-                        body = encode(body);
-                }
-                if (body instanceof OperationResult && operationResponse.type) {
-                    body.type = operationResponse.type.name ? operationResponse.type.name : '#embedded';
                 }
             }
-        }
-        else if (body != null) {
-            if (body instanceof OperationResult) {
-                body = operationResultEncoder(body);
-                contentType = MimeTypes.opra_response_json;
-            }
-            else if (Buffer.isBuffer(body))
-                contentType = MimeTypes.binary;
-            else if (typeof body === 'object') {
-                contentType = contentType || MimeTypes.json;
-                if (typeof body.toJSON === 'function')
-                    body = body.toJSON();
+            else if (body != null) {
+                if (body instanceof OperationResult) {
+                    body = operationResultEncoder(body);
+                    contentType = MimeTypes.opra_response_json;
+                }
+                else if (Buffer.isBuffer(body))
+                    contentType = MimeTypes.binary;
+                else if (typeof body === 'object') {
+                    contentType = contentType || MimeTypes.json;
+                    if (typeof body.toJSON === 'function')
+                        body = body.toJSON();
+                }
+                else {
+                    contentType = contentType || MimeTypes.text;
+                    body = String(body);
+                }
             }
-            else {
-                contentType = contentType || MimeTypes.text;
-                body = String(body);
+            /** Set content-type header value if not set */
+            if (contentType && contentType !== responseArgs.contentType)
+                response.setHeader('content-type', contentType);
+            response.status(statusCode);
+            if (body == null) {
+                response.end();
+                return;
             }
+            let x;
+            if (Buffer.isBuffer(body) || isReadableStream(body))
+                x = body;
+            else if (isBlob(body))
+                x = body.stream();
+            else if (typeof body === 'object')
+                x = JSON.stringify(body);
+            else
+                x = String(body);
+            response.end(x);
         }
-        /** Set content-type header value if not set */
-        if (contentType && contentType !== responseArgs.contentType)
-            response.setHeader('content-type', contentType);
-        response.status(statusCode);
-        if (body == null) {
+        catch (error) {
+            context.errors.push(error);
+            return this._sendErrorResponse(context);
+        }
+    }
+    async _sendErrorResponse(context) {
+        context.errors = this._wrapExceptions(context.errors);
+        try {
+            await this.adapter.emitAsync('error', context);
+            context.errors = this._wrapExceptions(context.errors);
+        }
+        catch (e) {
+            context.errors = this._wrapExceptions([e, ...context.errors]);
+        }
+        const { response, errors } = context;
+        if (response.headersSent) {
             response.end();
             return;
         }
-        let x;
-        if (Buffer.isBuffer(body) || isReadableStream(body))
-            x = body;
-        else if (isBlob(body))
-            x = body.stream();
-        else if (typeof body === 'object')
-            x = JSON.stringify(body);
-        else
-            x = String(body);
-        response.end(x);
+        let status = response.statusCode || 0;
+        if (!status || status < Number(HttpStatusCode.BAD_REQUEST)) {
+            status = errors[0].status;
+            if (status < Number(HttpStatusCode.BAD_REQUEST))
+                status = HttpStatusCode.INTERNAL_SERVER_ERROR;
+        }
+        response.statusCode = status;
+        const { document } = this.adapter;
+        const dt = document.node.getComplexType('OperationResult');
+        let encode = this[kAssetCache].get(dt, 'encode');
+        if (!encode) {
+            encode = dt.generateCodec('encode', { ignoreWriteonlyFields: true });
+            this[kAssetCache].set(dt, 'encode', encode);
+        }
+        const { i18n } = this.adapter;
+        const bodyObject = new OperationResult({
+            errors: errors.map(x => {
+                const o = x.toJSON();
+                if (!(process.env.NODE_ENV === 'dev' || process.env.NODE_ENV === 'development'))
+                    delete o.stack;
+                return i18n.deep(o);
+            }),
+        });
+        const body = encode(bodyObject);
+        response.setHeader(HttpHeaderCodes.Content_Type, MimeTypes.opra_response_json + '; charset=utf-8');
+        response.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
+        response.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
+        response.setHeader(HttpHeaderCodes.Expires, '-1');
+        response.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+        response.send(JSON.stringify(body));
+        response.end();
+    }
+    async sendDocumentSchema(context) {
+        const { request, response } = context;
+        const { document } = this.adapter;
+        response.setHeader('content-type', MimeTypes.json);
+        const url = new URL(request.originalUrl || request.url || '/', 'http://tempuri.org');
+        const { searchParams } = url;
+        const documentId = searchParams.get('id');
+        const doc = documentId ? document.findDocument(documentId) : document;
+        if (!doc) {
+            context.errors.push(new BadRequestError({
+                message: `Document with given id [${documentId}] does not exists`,
+            }));
+            return this.sendResponse(context);
+        }
+        /** Check if response cache exists */
+        let responseBody = this[kAssetCache].get(doc, `$schema`);
+        /** Create response if response cache does not exists */
+        if (!responseBody) {
+            const schema = doc.export();
+            responseBody = JSON.stringify(schema);
+            this[kAssetCache].set(doc, `$schema`, responseBody);
+        }
+        response.end(responseBody);
     }
     /**
      *
@@ -383,12 +479,13 @@ export class HttpHandler {
         let responseArgs = this[kAssetCache].get(response, cacheKey);
         if (!responseArgs) {
             responseArgs = { statusCode, contentType };
-            if (operation.responses.length) {
+            if (operation?.responses.length) {
                 /** Filter available HttpOperationResponse instances according to status code. */
                 const filteredResponses = operation.responses.filter(r => r.statusCode.find(sc => sc.start <= statusCode && sc.end >= statusCode));
                 /** Throw InternalServerError if controller returns non-configured status code */
-                if (!filteredResponses.length && statusCode < 400)
+                if (!filteredResponses.length && statusCode < 400) {
                     throw new InternalServerError(`No responses defined for status code ${statusCode} in operation "${operation.name}"`);
+                }
                 /** We search for content-type in filtered HttpOperationResponse array */
                 if (filteredResponses.length) {
                     /** If no response returned, and content-type has not been set (No response wants to be returned by operation) */
@@ -401,8 +498,9 @@ export class HttpHandler {
                         if (contentType) {
                             // Find HttpEndpointResponse instance according to content-type header
                             operationResponse = filteredResponses.find(r => typeIs.is(contentType, toArray(r.contentType)));
-                            if (!operationResponse)
+                            if (!operationResponse) {
                                 throw new InternalServerError(`Operation didn't configured to return "${contentType}" content`);
+                            }
                         }
                         else {
                             /** Select first HttpOperationResponse if content-type header has not been set */
@@ -413,6 +511,8 @@ export class HttpHandler {
                                     : operationResponse.contentType);
                                 if (typeof ct === 'string')
                                     responseArgs.contentType = contentType = ct;
+                                else if (operationResponse.type)
+                                    responseArgs.contentType = MimeTypes.opra_response_json;
                             }
                         }
                     }
@@ -424,6 +524,10 @@ export class HttpHandler {
             }
             if (!hasBody)
                 delete responseArgs.contentType;
+            if (operation?.composition?.startsWith('Entity.')) {
+                if (context.queryParams.projection)
+                    responseArgs.projection = context.queryParams.projection;
+            }
             this[kAssetCache].set(response, cacheKey, { ...responseArgs });
         }
         /** Fix response value according to composition */
@@ -434,23 +538,26 @@ export class HttpHandler {
                 case 'Entity.Get':
                 case 'Entity.FindMany':
                 case 'Entity.Update': {
-                    if (!(body instanceof OperationResult))
+                    if (!(body instanceof OperationResult)) {
                         body = new OperationResult({
                             payload: body,
                         });
+                    }
                     if ((composition === 'Entity.Create' || composition === 'Entity.Update') &&
                         composition &&
-                        body.affected == null)
+                        body.affected == null) {
                         body.affected = 1;
+                    }
                     break;
                 }
                 case 'Entity.Delete':
                 case 'Entity.DeleteMany':
                 case 'Entity.UpdateMany': {
-                    if (!(body instanceof OperationResult))
+                    if (!(body instanceof OperationResult)) {
                         body = new OperationResult({
                             affected: body,
                         });
+                    }
                     body.affected =
                         typeof body.affected === 'number'
                             ? body.affected
@@ -461,68 +568,27 @@ export class HttpHandler {
                                 : undefined;
                     break;
                 }
+                default:
+                    break;
             }
         }
-        if (responseArgs.contentType && responseArgs.contentType !== parsedContentType?.type)
+        if (responseArgs.contentType && responseArgs.contentType !== parsedContentType?.type) {
             response.setHeader('content-type', responseArgs.contentType);
+        }
         if (responseArgs.contentType &&
             body != null &&
             !(body instanceof OperationResult) &&
-            typeIs.is(responseArgs.contentType, [MimeTypes.opra_response_json]))
+            typeIs.is(responseArgs.contentType, [MimeTypes.opra_response_json])) {
             body = new OperationResult({ payload: body });
+        }
         if (hasBody)
             responseArgs.body = body;
         return responseArgs;
     }
-    async sendDocumentSchema(context) {
-        const { request, response } = context;
-        const { document } = this.adapter;
-        response.setHeader('content-type', MimeTypes.json);
-        const url = new URL(request.originalUrl || request.url || '/', 'http://tempuri.org');
-        const { searchParams } = url;
-        const documentId = searchParams.get('id');
-        const doc = documentId ? document.findDocument(documentId) : document;
-        if (!doc)
-            return this.sendErrorResponse(response, [
-                new BadRequestError({
-                    message: `Document with given id [${documentId}] does not exists`,
-                }),
-            ]);
-        /** Check if response cache exists */
-        let responseBody = this[kAssetCache].get(doc, `$schema`);
-        /** Create response if response cache does not exists */
-        if (!responseBody) {
-            const schema = doc.export();
-            responseBody = JSON.stringify(schema);
-            this[kAssetCache].set(doc, `$schema`, responseBody);
-        }
-        response.end(responseBody);
-    }
-    async sendErrorResponse(response, errors) {
-        if (response.headersSent) {
-            response.end();
-            return;
-        }
-        if (!errors.length)
-            errors.push(wrapException({ status: response.statusCode || 500 }));
-        const { logger } = this.adapter;
-        errors.forEach(x => {
-            if (x instanceof OpraException) {
-                switch (x.severity) {
-                    case 'fatal':
-                        logger.fatal(x);
-                        break;
-                    case 'warning':
-                        logger.warn(x);
-                        break;
-                    default:
-                        logger.error(x);
-                }
-            }
-            else
-                logger.fatal(x);
-        });
-        const wrappedErrors = errors.map(wrapException);
+    _wrapExceptions(exceptions) {
+        const wrappedErrors = exceptions.map(wrapException);
+        if (!wrappedErrors.length)
+            wrappedErrors.push(new InternalServerError());
         // Sort errors from fatal to info
         wrappedErrors.sort((a, b) => {
             const i = IssueSeverity.Keys.indexOf(a.severity) - IssueSeverity.Keys.indexOf(b.severity);
@@ -530,36 +596,6 @@ export class HttpHandler {
                 return b.status - a.status;
             return i;
         });
-        let status = response.statusCode || 0;
-        if (!status || status < Number(HttpStatusCode.BAD_REQUEST)) {
-            status = wrappedErrors[0].status;
-            if (status < Number(HttpStatusCode.BAD_REQUEST))
-                status = HttpStatusCode.INTERNAL_SERVER_ERROR;
-        }
-        response.statusCode = status;
-        const { document } = this.adapter;
-        const dt = document.node.getComplexType('OperationResult');
-        let encode = this[kAssetCache].get(dt, 'encode');
-        if (!encode) {
-            encode = dt.generateCodec('encode');
-            this[kAssetCache].set(dt, 'encode', encode);
-        }
-        const { i18n } = this.adapter;
-        const bodyObject = new OperationResult({
-            errors: wrappedErrors.map(x => {
-                const o = x.toJSON();
-                if (!(process.env.NODE_ENV === 'dev' || process.env.NODE_ENV === 'development'))
-                    delete o.stack;
-                return i18n.deep(o);
-            }),
-        });
-        const body = encode(bodyObject);
-        response.setHeader(HttpHeaderCodes.Content_Type, MimeTypes.opra_response_json + '; charset=utf-8');
-        response.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
-        response.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
-        response.setHeader(HttpHeaderCodes.Expires, '-1');
-        response.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-        response.send(JSON.stringify(body));
-        response.end();
+        return wrappedErrors;
     }
 }