@opra/core 0.26.4 → 0.27.0

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

@@ -1,7 +1,8 @@
 import fs from 'fs/promises';
 import os from 'os';
-import * as valgen from 'valgen';
-import { BadRequestError, Collection, Container, HttpHeaderCodes, HttpStatusCodes, InternalServerError, isReadable, IssueSeverity, MethodNotAllowedError, OpraException, OpraSchema, OpraURL, ResourceNotFoundError, Singleton, Storage, translate, uid, wrapException } from '@opra/common';
+import typeIs from 'type-is';
+import * as vg from 'valgen';
+import { BadRequestError, Collection, Container, HttpHeaderCodes, HttpStatusCodes, InternalServerError, isReadable, IssueSeverity, MethodNotAllowedError, OperationResult, OpraException, OpraSchema, OpraURL, ResourceNotFoundError, Singleton, Storage, translate, uid, wrapException } from '@opra/common';
 import { ExecutionContextHost } from '../execution-context.host.js';
 import { PlatformAdapterHost } from '../platform-adapter.host.js';
 import { RequestHost } from '../request.host.js';
@@ -28,54 +29,47 @@ export class HttpAdapterHost extends PlatformAdapterHost {
     async handleHttp(incoming, outgoing) {
         const context = new ExecutionContextHost(this.api, this.platform, { http: { incoming, outgoing } });
         try {
-            try {
-                /* istanbul ignore next */
-                if (!this._api)
-                    throw new InternalServerError(`${Object.getPrototypeOf(this).constructor.name} has not been initialized yet`);
-                outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-                // Expose headers if cors enabled
-                if (outgoing.getHeader(HttpHeaderCodes.Access_Control_Allow_Origin)) {
-                    // Expose X-Opra-* headers
-                    outgoing.appendHeader(HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(HttpHeaderCodes)
-                        .filter(k => k.toLowerCase().startsWith('x-opra-')));
+            /* istanbul ignore next */
+            if (!this._api)
+                throw new InternalServerError(`${Object.getPrototypeOf(this).constructor.name} has not been initialized yet`);
+            outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+            // Expose headers if cors enabled
+            if (outgoing.getHeader(HttpHeaderCodes.Access_Control_Allow_Origin)) {
+                // Expose X-Opra-* headers
+                outgoing.appendHeader(HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(HttpHeaderCodes)
+                    .filter(k => k.toLowerCase().startsWith('x-opra-')));
+            }
+            const { parsedUrl } = incoming;
+            if (!parsedUrl.path.length) {
+                if (incoming.method === 'GET') {
+                    outgoing.setHeader('content-type', 'application/json');
+                    outgoing.end(JSON.stringify(this.api.exportSchema({ webSafe: true })));
+                    return;
                 }
-                const { parsedUrl } = incoming;
-                if (!parsedUrl.path.length) {
-                    if (incoming.method === 'GET') {
-                        outgoing.setHeader('content-type', 'application/json');
-                        outgoing.end(JSON.stringify(this.api.exportSchema({ webSafe: true })));
-                        return;
-                    }
-                    // Process Batch
-                    if (incoming.method === 'POST' && incoming.headers['content-type'] === 'multipart/mixed') {
-                        // todo Process Batch
-                    }
-                    throw new BadRequestError();
+                // Process Batch
+                if (incoming.method === 'POST' && incoming.headers['content-type'] === 'multipart/mixed') {
+                    // todo Process Batch
                 }
-                let i = 0;
-                let requestProcessed = false;
-                const next = async () => {
-                    const interceptor = this._interceptors[i++];
-                    if (interceptor) {
-                        await interceptor(context, next);
-                        await next();
-                    }
-                    else if (!requestProcessed) {
-                        requestProcessed = true;
-                        await this.handleExecution(context);
-                    }
-                };
-                await next();
-            }
-            catch (error) {
-                context.errors.push(wrapException(error));
-            }
-            // If no response returned to the client we send an error
-            if (!outgoing.writableEnded) {
-                if (!context.errors.length)
-                    context.errors.push(new BadRequestError(`Server can not process this request`));
-                await this.handleError(context);
+                throw new BadRequestError();
             }
+            let i = 0;
+            let requestProcessed = false;
+            const next = async () => {
+                const interceptor = this._interceptors[i++];
+                if (interceptor) {
+                    await interceptor(context, next);
+                    await next();
+                }
+                else if (!requestProcessed) {
+                    requestProcessed = true;
+                    await this.handleExecution(context);
+                }
+            };
+            await next();
+        }
+        catch (error) {
+            if (!outgoing.writableEnded)
+                await this.sendErrorResponse(context, [error]);
         }
         finally {
             await context.emitAsync('finish');
@@ -83,22 +77,33 @@ export class HttpAdapterHost extends PlatformAdapterHost {
     }
     async handleExecution(executionContext) {
         // Parse incoming message and create Request object
-        const request = await this.parseRequest(executionContext);
-        const { outgoing } = executionContext.switchToHttp();
-        const response = new ResponseHost({ http: outgoing });
-        const context = RequestContext.from(executionContext, request, response);
-        await this.executeRequest(context);
-        if (response.errors.length) {
-            context.errors.push(...response.errors);
-            return;
+        let request;
+        try {
+            request = await this.parseRequest(executionContext);
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            if (e instanceof vg.ValidationError) {
+                throw new BadRequestError({
+                    message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                    code: 'RESPONSE_VALIDATION',
+                    details: e.issues
+                }, e);
+            }
+            throw new BadRequestError(e);
         }
         try {
+            const { outgoing } = executionContext.switchToHttp();
+            const response = new ResponseHost({ http: outgoing });
+            const context = RequestContext.from(executionContext, request, response);
+            await this.executeRequest(context);
             await this.sendResponse(context);
         }
         catch (e) {
             if (e instanceof OpraException)
                 throw e;
-            if (e instanceof valgen.ValidationError) {
+            if (e instanceof vg.ValidationError) {
                 throw new InternalServerError({
                     message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
                     code: 'RESPONSE_VALIDATION',
@@ -146,7 +151,7 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                 return request;
         }
         if (resource instanceof Storage)
-            request = await this._parseRequestStorage(executionContext, resource, urlPath.slice(1), searchParams);
+            request = await this._parseRequestStorage(executionContext, resource, searchParams);
         else if (urlPath.length === 1) { // Collection and Singleton resources should be last element in path
             if (resource instanceof Collection)
                 request = await this._parseRequestCollection(executionContext, resource, urlPath, searchParams);
@@ -163,14 +168,12 @@ export class HttpAdapterHost extends PlatformAdapterHost {
     }
     async _parseRequestAction(executionContext, resource, urlPath, searchParams) {
         const p = urlPath[0];
-        const { controller, endpoint, handler } = await this.getOperationHandler(resource, p.resource);
+        const { controller, endpoint, handler } = await this.getActionHandler(resource, p.resource);
         const { incoming } = executionContext.switchToHttp();
         const contentId = incoming.headers['content-id'];
-        const params = this.parseParameters(endpoint.parameters, p, searchParams);
+        const params = this.parseParameters(endpoint.parameters, searchParams);
         return new RequestHost({
             endpoint,
-            operation: 'action',
-            action: endpoint.name,
             controller,
             handler,
             http: incoming,
@@ -190,11 +193,10 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                     const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'create');
                     const jsonReader = jsonBodyLoader({ limit: endpoint.inputMaxContentSize }, endpoint);
                     let data = await jsonReader(incoming);
-                    data = endpoint.decode(data, { coerce: true });
-                    const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                    data = endpoint.decodeInput(data, { coerce: true });
+                    const params = this.parseParameters(endpoint.parameters, searchParams);
                     return new RequestHost({
                         endpoint,
-                        operation: 'create',
                         controller,
                         handler,
                         http: incoming,
@@ -213,10 +215,9 @@ export class HttpAdapterHost extends PlatformAdapterHost {
             case 'DELETE': {
                 if (p.key != null) {
                     const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'delete');
-                    const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                    const params = this.parseParameters(endpoint.parameters, searchParams);
                     return new RequestHost({
                         endpoint,
-                        operation: 'delete',
                         controller,
                         handler,
                         http: incoming,
@@ -226,10 +227,9 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                     });
                 }
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'deleteMany');
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'deleteMany',
                     controller,
                     handler,
                     http: incoming,
@@ -243,10 +243,9 @@ export class HttpAdapterHost extends PlatformAdapterHost {
             case 'GET': {
                 if (p.key != null) {
                     const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'get');
-                    const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                    const params = this.parseParameters(endpoint.parameters, searchParams);
                     return new RequestHost({
                         endpoint,
-                        operation: 'get',
                         controller,
                         handler,
                         http: incoming,
@@ -261,10 +260,9 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                     });
                 }
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'findMany');
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'findMany',
                     controller,
                     handler,
                     http: incoming,
@@ -284,11 +282,10 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                     const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'update');
                     const jsonReader = jsonBodyLoader({ limit: endpoint.inputMaxContentSize }, endpoint);
                     let data = await jsonReader(incoming);
-                    data = endpoint.decode(data, { coerce: true });
-                    const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                    data = endpoint.decodeInput(data, { coerce: true });
+                    const params = this.parseParameters(endpoint.parameters, searchParams);
                     return new RequestHost({
                         endpoint,
-                        operation: 'update',
                         controller,
                         handler,
                         http: incoming,
@@ -306,11 +303,10 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'updateMany');
                 const jsonReader = jsonBodyLoader({ limit: endpoint.inputMaxContentSize }, endpoint);
                 let data = await jsonReader(incoming);
-                data = endpoint.decode(data, { coerce: true });
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                data = endpoint.decodeInput(data, { coerce: true });
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'updateMany',
                     controller,
                     handler,
                     http: incoming,
@@ -332,17 +328,15 @@ export class HttpAdapterHost extends PlatformAdapterHost {
         if ((incoming.method === 'POST' || incoming.method === 'PATCH') && !incoming.is('json'))
             throw new BadRequestError({ message: 'Unsupported Content-Type' });
         const contentId = incoming.headers['content-id'];
-        const p = urlPath[0];
         switch (incoming.method) {
             case 'POST': {
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'create');
                 const jsonReader = jsonBodyLoader({ limit: endpoint.inputMaxContentSize }, endpoint);
                 let data = await jsonReader(incoming);
-                data = endpoint.decode(data, { coerce: true });
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                data = endpoint.decodeInput(data, { coerce: true });
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'create',
                     controller,
                     handler,
                     http: incoming,
@@ -358,10 +352,9 @@ export class HttpAdapterHost extends PlatformAdapterHost {
             }
             case 'DELETE': {
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'delete');
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'delete',
                     controller,
                     handler,
                     http: incoming,
@@ -371,10 +364,9 @@ export class HttpAdapterHost extends PlatformAdapterHost {
             }
             case 'GET': {
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'get');
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'get',
                     controller,
                     handler,
                     http: incoming,
@@ -391,11 +383,10 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'update');
                 const jsonReader = jsonBodyLoader({ limit: endpoint.inputMaxContentSize }, endpoint);
                 let data = await jsonReader(incoming);
-                data = endpoint.decode(data, { coerce: true });
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                data = endpoint.decodeInput(data, { coerce: true });
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'update',
                     controller,
                     handler,
                     http: incoming,
@@ -414,17 +405,15 @@ export class HttpAdapterHost extends PlatformAdapterHost {
             message: `Singleton resource doesn't accept http "${incoming.method}" method`
         });
     }
-    async _parseRequestStorage(executionContext, resource, urlPath, searchParams) {
+    async _parseRequestStorage(executionContext, resource, searchParams) {
         const { incoming } = executionContext.switchToHttp();
         const contentId = incoming.headers['content-id'];
-        const p = urlPath[0];
         switch (incoming.method) {
             case 'GET': {
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'get');
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'get',
                     controller,
                     handler,
                     http: incoming,
@@ -435,10 +424,9 @@ export class HttpAdapterHost extends PlatformAdapterHost {
             }
             case 'DELETE': {
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'delete');
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 return new RequestHost({
                     endpoint,
-                    operation: 'delete',
                     controller,
                     handler,
                     http: incoming,
@@ -449,7 +437,7 @@ export class HttpAdapterHost extends PlatformAdapterHost {
             }
             case 'POST': {
                 const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'post');
-                const params = this.parseParameters(endpoint.parameters, p, searchParams);
+                const params = this.parseParameters(endpoint.parameters, searchParams);
                 await fs.mkdir(this._tempDir, { recursive: true });
                 const multipartIterator = new MultipartIterator(incoming, {
                     ...endpoint.options,
@@ -464,7 +452,6 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                 });
                 return new RequestHost({
                     endpoint,
-                    operation: 'post',
                     controller,
                     handler,
                     http: incoming,
@@ -479,13 +466,15 @@ export class HttpAdapterHost extends PlatformAdapterHost {
             message: `Storage resource doesn't accept http "${incoming.method}" method`
         });
     }
-    parseParameters(paramDefs, pathComponent, searchParams) {
+    parseParameters(paramDefs, searchParams) {
         const out = {};
         // Parse known parameters
         for (const [k, prm] of paramDefs.entries()) {
             const decode = prm.getDecoder();
             let v = searchParams?.getAll(k);
             try {
+                if (!v.length && prm.default != null)
+                    v = [prm.default];
                 if (!prm.isArray) {
                     v = v[0];
                     v = decode(v, { coerce: true });
@@ -518,38 +507,51 @@ export class HttpAdapterHost extends PlatformAdapterHost {
     async executeRequest(context) {
         const { request } = context;
         const { response } = context;
-        const { resource, handler } = request;
+        const { endpoint, resource, handler } = request;
         // Call endpoint handler method
         let value;
         try {
             value = await handler.call(request.controller, context);
             if (response.value == null)
                 response.value = value;
-            if (request.resource instanceof Collection || request.resource instanceof Singleton) {
-                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;
+            // Normalize response value
+            if (endpoint.kind === 'operation') {
+                if (resource instanceof Storage && endpoint.name === 'post') {
+                    // Count file parts
+                    value = context.request.parts.items.reduce((n, item) => item.file ? n + 1 : n, 0);
                 }
-                else {
+                if (resource instanceof Collection || resource instanceof Singleton || resource instanceof Storage) {
+                    const operationName = endpoint.name;
+                    if (operationName === 'delete' || operationName === 'deleteMany' ||
+                        operationName === 'updateMany' || operationName === 'post') {
+                        let affected = 0;
+                        if (typeof value === 'number')
+                            affected = value;
+                        else if (typeof value === 'boolean')
+                            affected = value ? 1 : 0;
+                        else if (typeof value === 'object')
+                            affected = value.affected || value.affectedRows ||
+                                (operationName === 'updateMany' ? value.updated : value.deleted);
+                        response.value = affected;
+                        return;
+                    }
+                    if (resource instanceof Storage)
+                        return;
                     // "get" and "update" endpoints must return the entity instance, otherwise it means resource not found
-                    if (value == null && (request.operation === 'get' || request.operation === 'update'))
+                    if (value == null && (operationName === 'get' || operationName === 'update'))
                         throw new ResourceNotFoundError(resource.name, request.key);
                     // "findMany" endpoint should return array of entity instances
-                    if (request.operation === 'findMany')
-                        value = value == null ? [] : Array.isArray(value) ? value : [value];
+                    if (operationName === 'findMany')
+                        value = (value == null ? [] : Array.isArray(value) ? value : [value]);
                     else
                         value = value == null ? {} : Array.isArray(value) ? value[0] : value;
+                    value = endpoint.encodeReturning(value, { coerce: true });
                     response.value = value;
+                    return;
                 }
             }
+            if (response.value)
+                response.value = endpoint.encodeReturning(response.value, { coerce: true });
         }
         catch (error) {
             response.errors.push(error);
@@ -557,77 +559,96 @@ export class HttpAdapterHost extends PlatformAdapterHost {
     }
     async sendResponse(context) {
         const { request, response } = context;
+        const { endpoint, resource } = request;
         const outgoing = response.switchToHttp();
-        if (request.resource instanceof Storage) {
-            outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
-            if (response.value != null) {
-                if (typeof response.value === 'string') {
-                    if (!outgoing.hasHeader('content-type'))
-                        outgoing.setHeader('content-type', 'text/plain');
-                    outgoing.send(response.value);
-                }
-                else if (Buffer.isBuffer(response.value) || isReadable(response.value)) {
-                    if (!outgoing.hasHeader('content-type'))
-                        outgoing.setHeader('content-type', 'application/octet-stream');
-                    outgoing.send(response.value);
+        if (response.errors?.length || (outgoing.statusCode >= 400 && outgoing.statusCode <= 599))
+            return this.sendErrorResponse(context, response.errors || []);
+        // if response redirected we do not send any response
+        if (outgoing.statusCode >= 300 && outgoing.statusCode < 400) {
+            outgoing.end();
+            return;
+        }
+        let contentType = String(outgoing.getHeader('content-type') || '');
+        const returnType = endpoint.returnType;
+        if (endpoint.kind === 'action' && !contentType && endpoint.returnMime && response.value) {
+            contentType = endpoint.returnMime;
+            outgoing.setHeader('Content-Type', contentType);
+        }
+        // OperationResult response
+        if ((endpoint.kind === 'operation' &&
+            (resource instanceof Collection || resource instanceof Singleton ||
+                (resource instanceof Storage && endpoint.name !== 'get'))) ||
+            (endpoint.kind === 'action' &&
+                (!contentType || typeIs.is(contentType, ['application/opra+json'])))) {
+            const incoming = context.switchToHttp().incoming;
+            const apiUrl = new OpraURL(incoming.baseUrl, incoming.protocol + '://' + incoming.get('host')).toString();
+            const body = new OperationResult({
+                context: endpoint.getFullPath(false),
+                contextUrl: apiUrl + '/#' + endpoint.getFullPath(true)
+            });
+            const operationName = endpoint.kind === 'operation' ? endpoint.name : '';
+            if (operationName === 'delete' || operationName === 'deleteMany' ||
+                operationName === 'updateMany' || operationName === 'post')
+                body.affected = response.value;
+            else {
+                outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
+                if (operationName === 'create')
+                    outgoing.statusCode = 201;
+                if (operationName === 'update' || operationName === 'create')
+                    body.affected = response.value ? 1 : 0;
+                if (operationName === 'findMany') {
+                    body.count = response.value.length;
+                    body.totalMatches = response.totalMatches;
                 }
-                else {
-                    outgoing.setHeader('content-type', 'application/json; charset=utf-8');
-                    outgoing.send(JSON.stringify(response.value));
+                if (returnType) {
+                    if (response.value == null)
+                        throw new InternalServerError(`"${request.endpoint.name}" endpoint should return value`);
+                    if (returnType.name) {
+                        const ns = this.api.getDataTypeNs(returnType);
+                        // const isOpraSpec = returnType.document.url?.startsWith('https://oprajs.com/spec/v1.0')
+                        body.type = (ns ? ns + ':' : '') + returnType.name;
+                        body.typeUrl =
+                            (ns
+                                ? new OpraURL('/#/types/' + returnType.name, returnType.document.url || 'http://tempuri.org').toString()
+                                : apiUrl + '/#/types/' + returnType.name);
+                    }
+                    else
+                        body.typeUrl = body.contextUrl + '/type';
+                    body.payload = this.i18n.deep(response.value);
                 }
             }
+            outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/opra+json; charset=utf-8');
+            outgoing.send(JSON.stringify(body));
             outgoing.end();
             return;
         }
-        const responseObject = {
-            context: request.resource.getFullPath()
-        };
-        if (request.operation === 'action')
-            responseObject.action = request.action;
-        else
-            responseObject.operation = request.operation;
-        const returnType = request.endpoint.returnType;
-        let responseValue = response.value;
-        if (returnType) {
-            responseObject.type = returnType.name || '#anonymous';
-            if (response.value != null)
-                responseValue = responseObject.data = request.endpoint.encode(response.value, { coerce: true });
-        }
-        if (request.operation === 'action') {
-            if (responseValue != null)
-                responseObject.data = responseValue;
-        }
-        else if (request.resource instanceof Collection || request.resource instanceof Singleton) {
-            if (request.operation === 'delete' || request.operation === 'deleteMany' ||
-                request.operation === 'updateMany') {
-                responseObject.affected = responseValue || 0;
+        outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
+        if (response.value != null) {
+            if (typeof response.value === 'string') {
+                if (!contentType)
+                    outgoing.setHeader('content-type', 'text/plain');
+                outgoing.send(response.value);
+            }
+            else if (Buffer.isBuffer(response.value) || isReadable(response.value)) {
+                if (!contentType)
+                    outgoing.setHeader('content-type', 'application/octet-stream');
+                outgoing.send(response.value);
             }
             else {
-                if (!responseValue)
-                    throw new InternalServerError(`"${request.operation}" endpoint should return value`);
-                if (request.operation === 'create')
-                    outgoing.statusCode = 201;
-                if (request.operation === 'create' || request.operation === 'update')
-                    responseObject.affected = 1;
-                else if (request.operation === 'get' || request.operation === 'update')
-                    responseObject.key = request.key;
-                if (request.operation === 'findMany' && response.count != null && response.count >= 0)
-                    responseObject.totalCount = response.count;
+                outgoing.setHeader('content-type', 'application/json; charset=utf-8');
+                outgoing.send(JSON.stringify(response.value));
             }
-            outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
         }
-        const body = this.i18n.deep(responseObject);
-        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/opra+json; charset=utf-8');
-        outgoing.send(JSON.stringify(body));
         outgoing.end();
     }
-    async handleError(context) {
-        const { errors } = context;
+    async sendErrorResponse(context, errors) {
         const { outgoing } = context.switchToHttp();
         if (outgoing.headersSent) {
             outgoing.end();
             return;
         }
+        if (!errors.length)
+            errors.push(wrapException({ status: outgoing.statusCode || 500 }));
         errors.forEach(x => {
             if (x instanceof OpraException) {
                 switch (x.severity) {
@@ -659,9 +680,9 @@ export class HttpAdapterHost extends PlatformAdapterHost {
                 status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
         }
         outgoing.statusCode = status;
-        const body = {
+        const body = new OperationResult({
             errors: wrappedErrors.map(x => this._i18n.deep(x.toJSON()))
-        };
+        });
         outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/opra+json; charset=utf-8');
         outgoing.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
         outgoing.setHeader(HttpHeaderCodes.Pragma, 'no-cache');