@opra/core 0.20.3 → 0.21.0

package/esm/adapter/http/helpers/convert-to-headers.js

@@ -0,0 +1,60 @@
+import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD } from './match-known-fields.js';
+export function convertToHeaders(src, dst, joinDuplicateHeaders) {
+    for (let n = 0; n < src.length; n += 2) {
+        addHeaderLine(src[n], src[n + 1], dst, joinDuplicateHeaders);
+    }
+    return dst;
+}
+export function convertToHeadersDistinct(src, dst) {
+    const count = src.length % 2;
+    for (let n = 0; n < count; n += 2) {
+        addHeaderLineDistinct(src[n], src[n + 1], dst);
+    }
+    return dst;
+}
+function addHeaderLine(field, value, dest, joinDuplicateHeaders) {
+    if (value == null)
+        return;
+    field = field.toLowerCase();
+    const [, flag] = matchKnownFields(field);
+    // comma(0) or semicolon(2) delimited field
+    if (flag === COMMA_DELIMITED_FIELD || flag === SEMICOLON_DELIMITED_FIELD) {
+        // Make a delimited list
+        if (typeof dest[field] === 'string') {
+            dest[field] += (flag === COMMA_DELIMITED_FIELD ? ', ' : '; ') + value;
+        }
+        else {
+            dest[field] = value;
+        }
+    }
+    else if (flag === ARRAY_FIELD) {
+        // Array header -- only Set-Cookie at the moment
+        if (dest['set-cookie'] !== undefined) {
+            dest['set-cookie'].push(value);
+        }
+        else {
+            dest['set-cookie'] = [value];
+        }
+    }
+    else if (joinDuplicateHeaders) {
+        if (dest[field] === undefined) {
+            dest[field] = value;
+        }
+        else {
+            dest[field] += ', ' + value;
+        }
+    }
+    else if (dest[field] === undefined) {
+        // Drop duplicates
+        dest[field] = value;
+    }
+}
+function addHeaderLineDistinct(field, value, dest) {
+    field = field.toLowerCase();
+    if (!dest[field]) {
+        dest[field] = [value];
+    }
+    else {
+        dest[field].push(value);
+    }
+}

package/esm/adapter/http/helpers/convert-to-raw-headers.js

@@ -0,0 +1,21 @@
+import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD } from './match-known-fields.js';
+export function convertToRawHeaders(src) {
+    return Object.entries(src)
+        .reduce((a, [field, v]) => {
+        const [name, flag] = matchKnownFields(field);
+        if (flag === ARRAY_FIELD) {
+            if (Array.isArray(v))
+                v.forEach(x => a.push(name, String(x)));
+            else
+                a.push(name, String(v));
+            return a;
+        }
+        if (flag === COMMA_DELIMITED_FIELD || flag === SEMICOLON_DELIMITED_FIELD) {
+            v = Array.isArray(v) ? v.join(flag === COMMA_DELIMITED_FIELD ? ', ' : '; ') : String(v);
+        }
+        else
+            v = Array.isArray(v) ? String(v[0]) : String(v);
+        a.push(name, v);
+        return a;
+    }, []);
+}

package/esm/adapter/http/helpers/match-known-fields.js

@@ -0,0 +1,43 @@
+import { HttpHeaderCodes } from '@opra/common';
+export const NO_DUPLICATES_FIELD = 0;
+export const COMMA_DELIMITED_FIELD = 1;
+export const SEMICOLON_DELIMITED_FIELD = 2;
+export const ARRAY_FIELD = 3;
+const ARRAY_HEADERS = [
+    'set-cookie'
+];
+const NO_DUPLICATES_HEADERS = [
+    'age',
+    'from',
+    'etag',
+    'server',
+    'referer',
+    'referrer',
+    'expires',
+    'location',
+    'user-agent',
+    'retry-after',
+    'content-type',
+    'content-length',
+    'max-forwards',
+    'last-modified',
+    'authorization',
+    'proxy-authorization',
+    'if-modified-since',
+    'if-unmodified-since',
+];
+const SEMICOLON_DELIMITED_HEADERS = ['cookie'];
+const KNOWN_FIELDS = Object.values(HttpHeaderCodes)
+    .reduce((o, k) => {
+    const n = k.toLowerCase();
+    o[n] = [k,
+        (NO_DUPLICATES_HEADERS.includes(n) ? NO_DUPLICATES_FIELD :
+            (ARRAY_HEADERS.includes(n) ? ARRAY_FIELD :
+                (SEMICOLON_DELIMITED_HEADERS.includes(n) ? SEMICOLON_DELIMITED_FIELD : COMMA_DELIMITED_FIELD)))
+    ];
+    return o;
+}, {});
+export function matchKnownFields(field) {
+    const x = KNOWN_FIELDS[field.toLowerCase()];
+    return x ? x : [field, COMMA_DELIMITED_FIELD];
+}

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

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