@opra/core 0.33.11 → 1.0.0-alpha.1

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

@@ -1,710 +0,0 @@
-import fs from 'fs/promises';
-import os from 'os';
-import { ValidationError } from 'valgen';
-import { BadRequestError, Collection, Container, HttpHeaderCodes, HttpStatusCode, InternalServerError, isReadable, IssueSeverity, MethodNotAllowedError, OperationResult, OpraException, OpraSchema, OpraURL, ResourceNotAvailableError, 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';
-import { RequestContext } from '../request-context.js';
-import { ResponseHost } from '../response.host.js';
-import { jsonBodyLoader } from './helpers/json-body-loader.js';
-import { MultipartIterator } from './helpers/multipart-helper.js';
-/**
- *
- * @class HttpAdapterHost
- */
-export class HttpAdapterHost extends PlatformAdapterHost {
-    constructor() {
-        super(...arguments);
-        this._protocol = 'http';
-        this._tempDir = os.tmpdir();
-    }
-    /**
-     * Main http request handler
-     * @param incoming
-     * @param outgoing
-     * @protected
-     */
-    async handleHttp(incoming, outgoing) {
-        const context = new ExecutionContextHost(this.api, this.platform, { http: { incoming, outgoing } });
-        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-')));
-            }
-            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();
-            }
-            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');
-        }
-    }
-    async handleExecution(executionContext) {
-        // Parse incoming message and create Request object
-        let request;
-        try {
-            request = await this.parseRequest(executionContext);
-        }
-        catch (e) {
-            if (e instanceof OpraException)
-                throw e;
-            const errors = e.issues.map(issue => new BadRequestError({
-                message: issue.message,
-                code: 'REQUEST_VALIDATION',
-                details: {
-                    ...issue,
-                    message: undefined
-                }
-            }));
-            return this.sendErrorResponse(executionContext, errors);
-        }
-        try {
-            const { outgoing } = executionContext.switchToHttp();
-            const response = new ResponseHost({ http: outgoing });
-            const context = RequestContext.from(executionContext, this.api, request, response);
-            await this.executeRequest(context);
-            await this.sendResponse(context);
-        }
-        catch (e) {
-            if (e instanceof OpraException)
-                throw e;
-            if (e instanceof ValidationError) {
-                throw new InternalServerError({
-                    message: translate('error:RESPONSE_VALIDATION,'),
-                    code: 'RESPONSE_VALIDATION',
-                    details: e.issues
-                }, e);
-            }
-            throw new InternalServerError(e);
-        }
-    }
-    async parseRequest(executionContext) {
-        const { incoming } = executionContext.switchToHttp();
-        const parsedUrl = new OpraURL(incoming.url);
-        let i = 0;
-        let p;
-        let resource = this.api.root;
-        let request;
-        // Walk through container
-        while (resource instanceof Container && i < parsedUrl.path.length) {
-            p = parsedUrl.path[i];
-            const r = resource.resources.get(p.resource);
-            if (r) {
-                resource = r;
-                if (resource instanceof Container) {
-                    i++;
-                }
-                else
-                    break;
-            }
-            else
-                break;
-        }
-        const urlPath = i > 0 ? parsedUrl.path.slice(i) : parsedUrl.path;
-        const searchParams = parsedUrl.searchParams;
-        // If there is one more element in the path it may be an action
-        if (resource instanceof Container) {
-            if (urlPath.length === 1 && resource.actions.has(urlPath[0].resource)) {
-                request = await this._parseRequestAction(executionContext, resource, urlPath, searchParams);
-                if (request)
-                    return request;
-            }
-        }
-        else if (urlPath.length === 2 && resource.actions.has(urlPath[1].resource)) {
-            request = await this._parseRequestAction(executionContext, resource, urlPath.slice(1), searchParams);
-            if (request)
-                return request;
-        }
-        if (resource instanceof Storage)
-            request = await this._parseRequestStorage(executionContext, resource, urlPath.slice(1), 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);
-            else if (resource instanceof Singleton)
-                request = await this._parseRequestSingleton(executionContext, resource, urlPath, searchParams);
-        }
-        if (request)
-            return request;
-        const path = parsedUrl.path.toString();
-        throw new BadRequestError({
-            message: 'No resource or endpoint found at ' + path,
-            details: { path }
-        });
-    }
-    async _parseRequestAction(executionContext, resource, urlPath, searchParams) {
-        const p = urlPath[0];
-        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, searchParams);
-        return new RequestHost({
-            endpoint,
-            controller,
-            handler,
-            http: incoming,
-            contentId,
-            params
-        });
-    }
-    async _parseRequestCollection(executionContext, resource, urlPath, searchParams) {
-        const { incoming } = executionContext.switchToHttp();
-        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': {
-                if (p.key == null) {
-                    const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'create');
-                    const jsonReader = jsonBodyLoader({
-                        limit: endpoint.options.inputMaxContentSize
-                    }, endpoint);
-                    let data = await jsonReader(incoming);
-                    data = endpoint.decodeInput(data, { coerce: true });
-                    const params = this.parseParameters(endpoint.parameters, searchParams);
-                    return new RequestHost({
-                        endpoint,
-                        controller,
-                        handler,
-                        http: incoming,
-                        contentId,
-                        data,
-                        params: {
-                            ...params,
-                            pick: params.pick && resource.normalizeFieldNames(params.pick),
-                            omit: params.omit && resource.normalizeFieldNames(params.omit),
-                            include: params.include && resource.normalizeFieldNames(params.include)
-                        }
-                    });
-                }
-                break;
-            }
-            case 'DELETE': {
-                if (p.key != null) {
-                    const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'delete');
-                    const params = this.parseParameters(endpoint.parameters, searchParams);
-                    return new RequestHost({
-                        endpoint,
-                        controller,
-                        handler,
-                        http: incoming,
-                        contentId,
-                        key: resource.parseKeyValue(p.key),
-                        params
-                    });
-                }
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'deleteMany');
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    params: {
-                        ...params,
-                        filter: params.filter && resource.normalizeFilter(params.filter)
-                    }
-                });
-            }
-            case 'GET': {
-                if (p.key != null) {
-                    const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'get');
-                    const params = this.parseParameters(endpoint.parameters, searchParams);
-                    return new RequestHost({
-                        endpoint,
-                        controller,
-                        handler,
-                        http: incoming,
-                        contentId,
-                        key: resource.parseKeyValue(p.key),
-                        params: {
-                            ...params,
-                            pick: params.pick && resource.normalizeFieldNames(params.pick),
-                            omit: params.omit && resource.normalizeFieldNames(params.omit),
-                            include: params.include && resource.normalizeFieldNames(params.include)
-                        }
-                    });
-                }
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'findMany');
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    params: {
-                        ...params,
-                        pick: params.pick && resource.normalizeFieldNames(params.pick),
-                        omit: params.omit && resource.normalizeFieldNames(params.omit),
-                        include: params.include && resource.normalizeFieldNames(params.include),
-                        sort: params.sort && resource.normalizeSortFields(params.sort),
-                        filter: params.filter && resource.normalizeFilter(params.filter)
-                    }
-                });
-            }
-            case 'PATCH': {
-                if (p.key != null) {
-                    const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'update');
-                    const jsonReader = jsonBodyLoader({
-                        limit: endpoint.options.inputMaxContentSize
-                    }, endpoint);
-                    let data = await jsonReader(incoming);
-                    data = endpoint.decodeInput(data, { coerce: true, partial: true });
-                    const params = this.parseParameters(endpoint.parameters, searchParams);
-                    return new RequestHost({
-                        endpoint,
-                        controller,
-                        handler,
-                        http: incoming,
-                        contentId,
-                        key: resource.parseKeyValue(p.key),
-                        data,
-                        params: {
-                            ...params,
-                            pick: params.pick && resource.normalizeFieldNames(params.pick),
-                            omit: params.omit && resource.normalizeFieldNames(params.omit),
-                            include: params.include && resource.normalizeFieldNames(params.include),
-                        }
-                    });
-                }
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'updateMany');
-                const jsonReader = jsonBodyLoader({
-                    limit: endpoint.options.inputMaxContentSize
-                }, endpoint);
-                let data = await jsonReader(incoming);
-                data = endpoint.decodeInput(data, { coerce: true, partial: true });
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    data,
-                    params: {
-                        ...params,
-                        filter: params.filter && resource.normalizeFilter(params.filter)
-                    }
-                });
-            }
-        }
-        throw new MethodNotAllowedError({
-            message: `Collection resource doesn't accept http "${incoming.method}" method`
-        });
-    }
-    async _parseRequestSingleton(executionContext, resource, urlPath, searchParams) {
-        const { incoming } = executionContext.switchToHttp();
-        if ((incoming.method === 'POST' || incoming.method === 'PATCH') && !incoming.is('json'))
-            throw new BadRequestError({ message: 'Unsupported Content-Type' });
-        const contentId = incoming.headers['content-id'];
-        switch (incoming.method) {
-            case 'POST': {
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'create');
-                const jsonReader = jsonBodyLoader({
-                    limit: endpoint.options.inputMaxContentSize
-                }, endpoint);
-                let data = await jsonReader(incoming);
-                data = endpoint.decodeInput(data, { coerce: true });
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    data,
-                    params: {
-                        ...params,
-                        pick: params.pick && resource.normalizeFieldNames(params.pick),
-                        omit: params.omit && resource.normalizeFieldNames(params.omit),
-                        include: params.include && resource.normalizeFieldNames(params.include)
-                    }
-                });
-            }
-            case 'DELETE': {
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'delete');
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    params
-                });
-            }
-            case 'GET': {
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'get');
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    params: {
-                        ...params,
-                        pick: params.pick && resource.normalizeFieldNames(params.pick),
-                        omit: params.omit && resource.normalizeFieldNames(params.omit),
-                        include: params.include && resource.normalizeFieldNames(params.include)
-                    }
-                });
-            }
-            case 'PATCH': {
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'update');
-                const jsonReader = jsonBodyLoader({
-                    limit: endpoint.options.inputMaxContentSize
-                }, endpoint);
-                let data = await jsonReader(incoming);
-                data = endpoint.decodeInput(data, { coerce: true, partial: true });
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    data,
-                    params: {
-                        ...params,
-                        pick: params.pick && resource.normalizeFieldNames(params.pick),
-                        omit: params.omit && resource.normalizeFieldNames(params.omit),
-                        include: params.include && resource.normalizeFieldNames(params.include),
-                    }
-                });
-            }
-        }
-        throw new MethodNotAllowedError({
-            message: `Singleton resource doesn't accept http "${incoming.method}" method`
-        });
-    }
-    async _parseRequestStorage(executionContext, resource, urlPath, searchParams) {
-        const { incoming } = executionContext.switchToHttp();
-        const contentId = incoming.headers['content-id'];
-        switch (incoming.method) {
-            case 'GET': {
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'get');
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    path: urlPath.toString().substring(1),
-                    params
-                });
-            }
-            case 'DELETE': {
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'delete');
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    path: urlPath.toString().substring(1),
-                    params
-                });
-            }
-            case 'POST': {
-                const { controller, endpoint, handler } = await this.getOperationHandler(resource, 'post');
-                const params = this.parseParameters(endpoint.parameters, searchParams);
-                await fs.mkdir(this._tempDir, { recursive: true });
-                const multipartIterator = await MultipartIterator.create(incoming, {
-                    ...endpoint.options,
-                    filename: () => this.serviceName + '_p' + process.pid +
-                        't' + String(Date.now()).substring(8) + 'r' + uid(12)
-                });
-                multipartIterator.pause();
-                // Add an hook to clean up files after request finished
-                executionContext.on('finish', async () => {
-                    multipartIterator.cancel();
-                    await multipartIterator.deleteFiles().catch(() => void 0);
-                });
-                return new RequestHost({
-                    endpoint,
-                    controller,
-                    handler,
-                    http: incoming,
-                    contentId,
-                    parts: multipartIterator,
-                    path: urlPath.toString().substring(1),
-                    params
-                });
-            }
-        }
-        throw new MethodNotAllowedError({
-            message: `Storage resource doesn't accept http "${incoming.method}" method`
-        });
-    }
-    parseParameters(paramDefs, searchParams) {
-        const out = {};
-        const onFail = (issue) => {
-            issue.message = `Parameter parse error. ` + issue.message;
-            issue.location = '@parameters';
-            return issue;
-        };
-        // 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, label: k, onFail });
-                }
-                else {
-                    v = v.map(x => decode(x, { coerce: true, label: k })).flat();
-                    if (!v.length)
-                        v = undefined;
-                }
-                if (v !== undefined)
-                    out[k] = v;
-            }
-            catch (e) {
-                e.message = `Error parsing parameter ${k}. ` + e.message;
-                throw e;
-            }
-        }
-        // Add unknown parameters
-        if (searchParams) {
-            for (const k of searchParams.keys()) {
-                let v = searchParams.getAll(k);
-                if (v.length < 2)
-                    v = v[0];
-                if (!paramDefs.has(k))
-                    out[k] = v;
-            }
-        }
-        return out;
-    }
-    async executeRequest(context) {
-        const { request } = context;
-        const { response } = context;
-        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;
-            // Normalize response value
-            if (endpoint.kind === 'operation') {
-                if (resource instanceof Collection || resource instanceof Singleton || resource instanceof Storage) {
-                    const operationName = endpoint.name;
-                    if (operationName === 'delete' || operationName === 'deleteMany' || operationName === 'updateMany') {
-                        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 Collection || resource instanceof Singleton) {
-                        // "get" and "update" endpoints must return the entity instance, otherwise it means resource not found
-                        if (value == null && (operationName === 'get' || operationName === 'update'))
-                            throw new ResourceNotAvailableError(resource.name, request.key);
-                        // "findMany" endpoint should return array of entity instances
-                        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, partial: true });
-                    response.value = value;
-                    return;
-                }
-            }
-            if (response.value)
-                response.value = endpoint.encodeReturning(response.value, { coerce: true, partial: true });
-        }
-        catch (error) {
-            response.errors.push(error);
-        }
-    }
-    async sendResponse(context) {
-        const { request, response } = context;
-        const { endpoint, resource } = request;
-        const outgoing = response.switchToHttp();
-        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') || '');
-        let returnType = endpoint.returnType;
-        if (endpoint.kind === 'action' && !contentType && endpoint.returnMime && response.value) {
-            contentType = endpoint.returnMime;
-            outgoing.setHeader('Content-Type', contentType);
-        }
-        // OperationResult response
-        if ((returnType || endpoint.kind === 'operation') &&
-            !(resource instanceof Storage && endpoint.name === 'get')) {
-            const incoming = context.switchToHttp().incoming;
-            const apiUrl = new OpraURL(incoming.baseUrl, incoming.protocol + '://' + incoming.get('host')).toString();
-            const body = new OperationResult({
-                context: '',
-                contextUrl: ''
-            });
-            const operationName = endpoint.kind === 'operation' ? endpoint.name : '';
-            if (operationName === 'delete' || operationName === 'deleteMany' || operationName === 'updateMany') {
-                body.affected = response.value;
-                returnType = undefined;
-            }
-            else {
-                outgoing.statusCode = outgoing.statusCode || HttpStatusCode.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;
-                }
-            }
-            if (returnType) {
-                if (response.value == null)
-                    throw new InternalServerError(`"${request.endpoint.name}" endpoint should return value`);
-                if (!returnType.isEmbedded) {
-                    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';
-                if (response.value instanceof OperationResult) {
-                    Object.assign(body, response.value);
-                }
-                else
-                    body.payload = response.value;
-                body.payload = this.i18n.deep(body.payload);
-            }
-            body.context = endpoint.getFullPath(false);
-            body.contextUrl = apiUrl + '/#' + endpoint.getFullPath(true);
-            outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/opra+json; charset=utf-8');
-            outgoing.send(JSON.stringify(body));
-            outgoing.end();
-            return;
-        }
-        outgoing.statusCode = outgoing.statusCode || HttpStatusCode.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 {
-                outgoing.setHeader('content-type', 'application/json; charset=utf-8');
-                outgoing.send(JSON.stringify(response.value));
-            }
-        }
-        outgoing.end();
-    }
-    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) {
-                    case "fatal":
-                        this._logger.fatal(x);
-                        break;
-                    case "warning":
-                        this._logger.warn(x);
-                        break;
-                    default:
-                        this._logger.error(x);
-                }
-            }
-            else
-                this._logger.fatal(x);
-        });
-        const wrappedErrors = errors.map(wrapException);
-        // Sort errors from fatal to info
-        wrappedErrors.sort((a, b) => {
-            const i = IssueSeverity.Keys.indexOf(a.severity) - IssueSeverity.Keys.indexOf(b.severity);
-            if (i === 0)
-                return b.status - a.status;
-            return i;
-        });
-        let status = outgoing.statusCode || 0;
-        if (!status || status < Number(HttpStatusCode.BAD_REQUEST)) {
-            status = wrappedErrors[0].status;
-            if (status < Number(HttpStatusCode.BAD_REQUEST))
-                status = HttpStatusCode.INTERNAL_SERVER_ERROR;
-        }
-        outgoing.statusCode = status;
-        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');
-        outgoing.setHeader(HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-        outgoing.send(JSON.stringify(body));
-        outgoing.end();
-    }
-}