@opra/core 0.33.13 → 1.0.0-alpha.10

package/esm/http/impl/http-handler.js

@@ -0,0 +1,579 @@
+import * as process from 'node:process';
+import typeIs from '@browsery/type-is';
+import { BadRequestError, HttpHeaderCodes, HttpStatusCode, InternalServerError, isBlob, isReadableStream, IssueSeverity, MethodNotAllowedError, MimeTypes, OperationResult, OpraException, OpraSchema, translate, } from '@opra/common';
+import { parse as parseContentType } from 'content-type';
+import { splitString } from 'fast-tokenizer';
+import { asMutable } from 'ts-gems';
+import { toArray, ValidationError, vg } from 'valgen';
+import { kAssetCache } from '../../constants.js';
+import { wrapException } from '../utils/wrap-exception.js';
+/**
+ * @class HttpHandler
+ */
+export class HttpHandler {
+    constructor(adapter) {
+        this.adapter = adapter;
+        this[kAssetCache] = adapter[kAssetCache];
+    }
+    /**
+     * Main http request handler
+     * @param context
+     * @protected
+     */
+    async handleRequest(context) {
+        const { response } = context;
+        try {
+            response.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+            // Expose headers if cors enabled
+            if (response.getHeader(HttpHeaderCodes.Access_Control_Allow_Origin)) {
+                // Expose X-Opra-* headers
+                response.appendHeader(HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(HttpHeaderCodes).filter(k => k.toLowerCase().startsWith('x-opra-')));
+            }
+            // Parse request
+            try {
+                await this.parseRequest(context);
+            }
+            catch (e) {
+                if (e instanceof OpraException)
+                    throw e;
+                if (e instanceof ValidationError) {
+                    throw new BadRequestError({
+                        message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                        code: 'RESPONSE_VALIDATION',
+                        details: e.issues,
+                    }, e);
+                }
+                throw new BadRequestError(e);
+            }
+            await this.adapter.emitAsync('request', context);
+            // Call interceptors than execute request
+            if (this.adapter.interceptors) {
+                let i = 0;
+                const next = async () => {
+                    const interceptor = this.adapter.interceptors[i++];
+                    if (interceptor)
+                        await interceptor(context, next);
+                    await this._executeRequest(context);
+                };
+                await next();
+            }
+            else
+                await this._executeRequest(context);
+        }
+        catch (error) {
+            let e = error;
+            if (e instanceof ValidationError) {
+                e = new InternalServerError({
+                    message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                    code: 'RESPONSE_VALIDATION',
+                    details: e.issues,
+                }, e);
+            }
+            else
+                e = wrapException(e);
+            response.status(e.statusCode || e.status || HttpStatusCode.INTERNAL_SERVER_ERROR);
+            response.contentType(MimeTypes.opra_response_json);
+            await this._sendResponse(context, new OperationResult({ errors: [e.toJSON()] })).finally(() => {
+                if (!response.finished)
+                    response.end();
+            });
+        }
+        finally {
+            await context.emitAsync('finish');
+        }
+    }
+    /**
+     *
+     * @param context
+     */
+    async parseRequest(context) {
+        await this._parseParameters(context);
+        await this._parseContentType(context);
+        if (context.operation.requestBody?.immediateFetch)
+            await context.getBody();
+        /** Set default status code as the first status code between 200 and 299 */
+        if (context.operation) {
+            for (const r of context.operation.responses) {
+                const st = r.statusCode.find(sc => sc.start <= 299 && sc.end >= 200);
+                if (st) {
+                    context.response.status(st.start);
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    async _parseParameters(context) {
+        const { operation, request } = context;
+        let key = '';
+        try {
+            const onFail = (issue) => {
+                issue.location = key;
+                return issue;
+            };
+            /** prepare decoders */
+            const getDecoder = (prm) => {
+                let decode = this[kAssetCache].get(prm, 'decode');
+                if (!decode) {
+                    decode = prm.type?.generateCodec('decode', { ignoreReadonlyFields: true }) || vg.isAny();
+                    this[kAssetCache].set(prm, 'decode', decode);
+                }
+                return decode;
+            };
+            const paramsLeft = new Set([...operation.parameters, ...operation.owner.parameters]);
+            /** parse cookie parameters */
+            if (request.cookies) {
+                for (key of Object.keys(request.cookies)) {
+                    const oprPrm = operation.findParameter(key, 'cookie');
+                    const cntPrm = operation.owner.findParameter(key, 'cookie');
+                    const prm = oprPrm || cntPrm;
+                    if (!prm)
+                        continue;
+                    if (oprPrm)
+                        paramsLeft.delete(oprPrm);
+                    if (cntPrm)
+                        paramsLeft.delete(cntPrm);
+                    const decode = getDecoder(prm);
+                    const v = decode(request.cookies[key], { coerce: true, label: key, onFail });
+                    const prmName = typeof prm.name === 'string' ? prm.name : key;
+                    if (v !== undefined)
+                        context.cookies[prmName] = v;
+                }
+            }
+            /** parse headers */
+            if (request.headers) {
+                for (key of Object.keys(request.headers)) {
+                    const oprPrm = operation.findParameter(key, 'header');
+                    const cntPrm = operation.owner.findParameter(key, 'header');
+                    const prm = oprPrm || cntPrm;
+                    if (!prm)
+                        continue;
+                    if (oprPrm)
+                        paramsLeft.delete(oprPrm);
+                    if (cntPrm)
+                        paramsLeft.delete(cntPrm);
+                    const decode = getDecoder(prm);
+                    const v = decode(request.headers[key], { coerce: true, label: key, onFail });
+                    const prmName = typeof prm.name === 'string' ? prm.name : key;
+                    if (v !== undefined)
+                        context.headers[prmName] = v;
+                }
+            }
+            /** parse path parameters */
+            if (request.params) {
+                for (key of Object.keys(request.params)) {
+                    const oprPrm = operation.findParameter(key, 'path');
+                    const cntPrm = operation.owner.findParameter(key, 'path');
+                    const prm = oprPrm || cntPrm;
+                    if (!prm)
+                        continue;
+                    if (oprPrm)
+                        paramsLeft.delete(oprPrm);
+                    if (cntPrm)
+                        paramsLeft.delete(cntPrm);
+                    const decode = getDecoder(prm);
+                    const v = decode(request.params[key], { coerce: true, label: key, onFail });
+                    if (v !== undefined)
+                        context.pathParams[key] = v;
+                }
+            }
+            /** parse query parameters */
+            const url = new URL(request.originalUrl || request.url || '/', 'http://tempuri.org');
+            const { searchParams } = url;
+            for (key of searchParams.keys()) {
+                const oprPrm = operation.findParameter(key, 'query');
+                const cntPrm = operation.owner.findParameter(key, 'query');
+                const prm = oprPrm || cntPrm;
+                if (!prm)
+                    continue;
+                if (oprPrm)
+                    paramsLeft.delete(oprPrm);
+                if (cntPrm)
+                    paramsLeft.delete(cntPrm);
+                const decode = getDecoder(prm);
+                let values = searchParams?.getAll(key);
+                const prmName = typeof prm.name === 'string' ? prm.name : key;
+                if (values?.length && prm.isArray) {
+                    values = values.map(v => splitString(v, { delimiters: prm.arraySeparator, quotes: true })).flat();
+                    values = values.map(v => decode(v, { coerce: true, label: key, onFail }));
+                    if (values.length)
+                        context.queryParams[prmName] = values;
+                }
+                else {
+                    const v = decode(values[0], { coerce: true, label: key, onFail });
+                    if (values.length)
+                        context.queryParams[prmName] = v;
+                }
+            }
+            for (const prm of paramsLeft) {
+                // Throw error for required parameters
+                if (prm.required) {
+                    const decode = getDecoder(prm);
+                    decode(undefined, { coerce: true, label: String(prm.name), onFail });
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                throw new BadRequestError({
+                    message: `Invalid parameter (${key}) value. ` + e.message,
+                    code: 'REQUEST_VALIDATION',
+                    details: e.issues,
+                }, e);
+            }
+            throw e;
+        }
+    }
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    async _parseContentType(context) {
+        const { request, operation } = context;
+        if (operation.requestBody?.content.length) {
+            let mediaType;
+            let contentType = request.header('content-type');
+            if (contentType) {
+                contentType = parseContentType(contentType).type;
+                mediaType = operation.requestBody.content.find(mc => mc.contentType &&
+                    typeIs.is(contentType, Array.isArray(mc.contentType) ? mc.contentType : [mc.contentType]));
+            }
+            if (!mediaType) {
+                const contentTypes = operation.requestBody.content.map(mc => mc.contentType).flat();
+                throw new BadRequestError(`Request body should be one of required content types (${contentTypes.join(', ')})`);
+            }
+            asMutable(context).mediaType = mediaType;
+        }
+    }
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    async _executeRequest(context) {
+        if (!context.operationHandler)
+            throw new MethodNotAllowedError();
+        const responseValue = await context.operationHandler.call(context.controllerInstance, context);
+        const { response } = context;
+        if (!response.writableEnded) {
+            await this._sendResponse(context, responseValue).finally(() => {
+                if (!response.writableEnded)
+                    response.end();
+            });
+        }
+    }
+    /**
+     *
+     * @param context
+     * @param responseValue
+     * @protected
+     */
+    async _sendResponse(context, responseValue) {
+        const { response } = context;
+        const { document } = this.adapter;
+        const responseArgs = this._determineResponseArgs(context, responseValue);
+        const { operationResponse, statusCode } = responseArgs;
+        let { contentType, body } = responseArgs;
+        const operationResultType = document.node.getDataType(OperationResult);
+        let operationResultEncoder = this[kAssetCache].get(operationResultType, 'encode');
+        if (!operationResultEncoder) {
+            operationResultEncoder = operationResultType.generateCodec('encode', { ignoreWriteonlyFields: true });
+            this[kAssetCache].set(operationResultType, 'encode', operationResultEncoder);
+        }
+        /** Validate response */
+        if (operationResponse?.type) {
+            if (!(body == null && statusCode === HttpStatusCode.NO_CONTENT)) {
+                /** Generate encoder */
+                let encode = this[kAssetCache].get(operationResponse, 'encode');
+                if (!encode) {
+                    encode = operationResponse.type.generateCodec('encode', {
+                        partial: operationResponse.partial,
+                        projection: '*',
+                        ignoreWriteonlyFields: true,
+                    });
+                    if (operationResponse) {
+                        if (operationResponse.isArray)
+                            encode = vg.isArray(encode);
+                        this[kAssetCache].set(operationResponse, 'encode', encode);
+                    }
+                }
+                /** Encode body */
+                if (operationResponse.type.extendsFrom(operationResultType)) {
+                    if (body instanceof OperationResult)
+                        body = encode(body);
+                    else {
+                        body.payload = encode(body.payload);
+                        body = operationResultEncoder(body);
+                    }
+                }
+                else {
+                    if (body instanceof OperationResult &&
+                        contentType &&
+                        typeIs.is(contentType, [MimeTypes.opra_response_json])) {
+                        body.payload = encode(body.payload);
+                        body = operationResultEncoder(body);
+                    }
+                    else
+                        body = encode(body);
+                }
+                if (body instanceof OperationResult && operationResponse.type) {
+                    body.type = operationResponse.type.name ? operationResponse.type.name : '#embedded';
+                }
+            }
+        }
+        else if (body != null) {
+            if (body instanceof OperationResult) {
+                body = operationResultEncoder(body);
+                contentType = MimeTypes.opra_response_json;
+            }
+            else if (Buffer.isBuffer(body))
+                contentType = MimeTypes.binary;
+            else if (typeof body === 'object') {
+                contentType = contentType || MimeTypes.json;
+                if (typeof body.toJSON === 'function')
+                    body = body.toJSON();
+            }
+            else {
+                contentType = contentType || MimeTypes.text;
+                body = String(body);
+            }
+        }
+        /** Set content-type header value if not set */
+        if (contentType && contentType !== responseArgs.contentType)
+            response.setHeader('content-type', contentType);
+        response.status(statusCode);
+        if (body == null) {
+            response.end();
+            return;
+        }
+        let x;
+        if (Buffer.isBuffer(body) || isReadableStream(body))
+            x = body;
+        else if (isBlob(body))
+            x = body.stream();
+        else if (typeof body === 'object')
+            x = JSON.stringify(body);
+        else
+            x = String(body);
+        response.end(x);
+    }
+    /**
+     *
+     * @param context
+     * @param body
+     * @protected
+     */
+    _determineResponseArgs(context, body) {
+        const { response, operation } = context;
+        const hasBody = body != null;
+        const statusCode = !hasBody && response.statusCode === HttpStatusCode.OK ? HttpStatusCode.NO_CONTENT : response.statusCode;
+        /** Parse content-type header */
+        const parsedContentType = hasBody && response.hasHeader('content-type') ? parseContentType(response) : undefined;
+        let contentType = parsedContentType?.type;
+        /** Estimate content type if not defined */
+        if (hasBody && !contentType) {
+            if (body instanceof OperationResult)
+                contentType = MimeTypes.opra_response_json;
+            else if (Buffer.isBuffer(body))
+                contentType = MimeTypes.binary;
+        }
+        let operationResponse;
+        const cacheKey = `HttpOperationResponse:${statusCode}${contentType ? ':' + contentType : ''}`;
+        let responseArgs = this[kAssetCache].get(response, cacheKey);
+        if (!responseArgs) {
+            responseArgs = { statusCode, contentType };
+            if (operation.responses.length) {
+                /** Filter available HttpOperationResponse instances according to status code. */
+                const filteredResponses = operation.responses.filter(r => r.statusCode.find(sc => sc.start <= statusCode && sc.end >= statusCode));
+                /** Throw InternalServerError if controller returns non-configured status code */
+                if (!filteredResponses.length && statusCode < 400) {
+                    throw new InternalServerError(`No responses defined for status code ${statusCode} in operation "${operation.name}"`);
+                }
+                /** We search for content-type in filtered HttpOperationResponse array */
+                if (filteredResponses.length) {
+                    /** If no response returned, and content-type has not been set (No response wants to be returned by operation) */
+                    if (!hasBody) {
+                        /** Find HttpOperationResponse with no content-type */
+                        operationResponse = filteredResponses.find(r => !r.contentType);
+                    }
+                    if (!operationResponse) {
+                        /** Find HttpOperationResponse according to content-type */
+                        if (contentType) {
+                            // Find HttpEndpointResponse instance according to content-type header
+                            operationResponse = filteredResponses.find(r => typeIs.is(contentType, toArray(r.contentType)));
+                            if (!operationResponse) {
+                                throw new InternalServerError(`Operation didn't configured to return "${contentType}" content`);
+                            }
+                        }
+                        else {
+                            /** Select first HttpOperationResponse if content-type header has not been set */
+                            operationResponse = filteredResponses[0];
+                            if (operationResponse.contentType) {
+                                const ct = typeIs.normalize(Array.isArray(operationResponse.contentType)
+                                    ? operationResponse.contentType[0]
+                                    : operationResponse.contentType);
+                                if (typeof ct === 'string')
+                                    responseArgs.contentType = contentType = ct;
+                            }
+                        }
+                    }
+                    responseArgs.operationResponse = operationResponse;
+                    if (!operationResponse.statusCode.find(sc => sc.start <= statusCode && sc.end >= statusCode)) {
+                        responseArgs.statusCode = operationResponse.statusCode[0].start;
+                    }
+                }
+            }
+            if (!hasBody)
+                delete responseArgs.contentType;
+            this[kAssetCache].set(response, cacheKey, { ...responseArgs });
+        }
+        /** Fix response value according to composition */
+        const composition = operationResponse?.owner.composition;
+        if (composition && body != null) {
+            switch (composition) {
+                case 'Entity.Create':
+                case 'Entity.Get':
+                case 'Entity.FindMany':
+                case 'Entity.Update': {
+                    if (!(body instanceof OperationResult)) {
+                        body = new OperationResult({
+                            payload: body,
+                        });
+                    }
+                    if ((composition === 'Entity.Create' || composition === 'Entity.Update') &&
+                        composition &&
+                        body.affected == null) {
+                        body.affected = 1;
+                    }
+                    break;
+                }
+                case 'Entity.Delete':
+                case 'Entity.DeleteMany':
+                case 'Entity.UpdateMany': {
+                    if (!(body instanceof OperationResult)) {
+                        body = new OperationResult({
+                            affected: body,
+                        });
+                    }
+                    body.affected =
+                        typeof body.affected === 'number'
+                            ? body.affected
+                            : typeof body.affected === 'boolean'
+                                ? body.affected
+                                    ? 1
+                                    : 0
+                                : undefined;
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        if (responseArgs.contentType && responseArgs.contentType !== parsedContentType?.type) {
+            response.setHeader('content-type', responseArgs.contentType);
+        }
+        if (responseArgs.contentType &&
+            body != null &&
+            !(body instanceof OperationResult) &&
+            typeIs.is(responseArgs.contentType, [MimeTypes.opra_response_json])) {
+            body = new OperationResult({ payload: body });
+        }
+        if (hasBody)
+            responseArgs.body = body;
+        return responseArgs;
+    }
+    async sendDocumentSchema(context) {
+        const { request, response } = context;
+        const { document } = this.adapter;
+        response.setHeader('content-type', MimeTypes.json);
+        const url = new URL(request.originalUrl || request.url || '/', 'http://tempuri.org');
+        const { searchParams } = url;
+        const documentId = searchParams.get('id');
+        const doc = documentId ? document.findDocument(documentId) : document;
+        if (!doc) {
+            return this.sendErrorResponse(response, [
+                new BadRequestError({
+                    message: `Document with given id [${documentId}] does not exists`,
+                }),
+            ]);
+        }
+        /** Check if response cache exists */
+        let responseBody = this[kAssetCache].get(doc, `$schema`);
+        /** Create response if response cache does not exists */
+        if (!responseBody) {
+            const schema = doc.export();
+            responseBody = JSON.stringify(schema);
+            this[kAssetCache].set(doc, `$schema`, responseBody);
+        }
+        response.end(responseBody);
+    }
+    async sendErrorResponse(response, errors) {
+        if (response.headersSent) {
+            response.end();
+            return;
+        }
+        if (!errors.length)
+            errors.push(wrapException({ status: response.statusCode || 500 }));
+        const { logger } = this.adapter;
+        errors.forEach(x => {
+            if (x instanceof OpraException) {
+                switch (x.severity) {
+                    case 'fatal':
+                        logger.fatal(x);
+                        break;
+                    case 'warning':
+                        logger.warn(x);
+                        break;
+                    default:
+                        logger.error(x);
+                }
+            }
+            else
+                logger.fatal(x);
+        });
+        const wrappedErrors = errors.map(wrapException);
+        // 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 = response.statusCode || 0;
+        if (!status || status < Number(HttpStatusCode.BAD_REQUEST)) {
+            status = wrappedErrors[0].status;
+            if (status < Number(HttpStatusCode.BAD_REQUEST))
+                status = HttpStatusCode.INTERNAL_SERVER_ERROR;
+        }
+        response.statusCode = status;
+        const { document } = this.adapter;
+        const dt = document.node.getComplexType('OperationResult');
+        let encode = this[kAssetCache].get(dt, 'encode');
+        if (!encode) {
+            encode = dt.generateCodec('encode', { ignoreWriteonlyFields: true });
+            this[kAssetCache].set(dt, 'encode', encode);
+        }
+        const { i18n } = this.adapter;
+        const bodyObject = new OperationResult({
+            errors: wrappedErrors.map(x => {
+                const o = x.toJSON();
+                if (!(process.env.NODE_ENV === 'dev' || process.env.NODE_ENV === 'development'))
+                    delete o.stack;
+                return i18n.deep(o);
+            }),
+        });
+        const body = encode(bodyObject);
+        response.setHeader(HttpHeaderCodes.Content_Type, MimeTypes.opra_response_json + '; charset=utf-8');
+        response.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
+        response.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
+        response.setHeader(HttpHeaderCodes.Expires, '-1');
+        response.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+        response.send(JSON.stringify(body));
+        response.end();
+    }
+}

package/esm/http/{http-server-request.js → impl/http-incoming.host.js}

@@ -2,44 +2,16 @@
   Some parts of this file contains codes from open source express library
   https://github.com/expressjs
  */
+import typeIs from '@browsery/type-is';
 import accepts from 'accepts';
 import fresh from 'fresh';
 import parseRange from 'range-parser';
-import typeIs from '@browsery/type-is';
-import { isReadable, mergePrototype, OpraURL } from '@opra/common';
-import { HttpIncomingMessageHost } from './impl/http-incoming-message.host.js';
-function isHttpIncomingMessage(v) {
-    return v && Array.isArray(v.rawHeaders) && isReadable(v);
-}
-export var HttpServerRequest;
-(function (HttpServerRequest) {
-    function from(instance) {
-        if (!isHttpIncomingMessage(instance))
-            instance = HttpIncomingMessageHost.from(instance);
-        mergePrototype(instance, HttpServerRequestHost.prototype);
-        const req = instance;
-        req.baseUrl = req.baseUrl || '';
-        req.parsedUrl = req.parsedUrl || new OpraURL(req.url);
-        if (!req.searchParams)
-            Object.defineProperty(req, 'searchParams', {
-                get() {
-                    return req.parsedUrl.searchParams;
-                }
-            });
-        return req;
-    }
-    HttpServerRequest.from = from;
-})(HttpServerRequest || (HttpServerRequest = {}));
-class HttpServerRequestHost {
-    constructor() {
-        this.basePath = '/';
-    }
+import { BodyReader } from '../utils/body-reader.js';
+export class HttpIncomingHost {
     get protocol() {
         const proto = this.header('X-Forwarded-Proto') || 'http';
         const index = proto.indexOf(',');
-        return index !== -1
-            ? proto.substring(0, index).trim()
-            : proto.trim();
+        return index !== -1 ? proto.substring(0, index).trim() : proto.trim();
     }
     get secure() {
         return this.protocol === 'https';
@@ -54,28 +26,25 @@ class HttpServerRequestHost {
             //       single value, but this is to be safe.
             host = host.substring(0, host.indexOf(',')).trim();
         }
-        if (!host)
-            return;
-        // IPv6 literal support
-        const offset = host[0] === '['
-            ? host.indexOf(']') + 1
-            : 0;
-        const index = host.indexOf(':', offset);
-        return index !== -1
-            ? host.substring(0, index)
-            : host;
+        if (host) {
+            // IPv6 literal support
+            const offset = host[0] === '[' ? host.indexOf(']') + 1 : 0;
+            const index = host.indexOf(':', offset);
+            return index !== -1 ? host.substring(0, index) : host;
+        }
+        return '';
     }
     get fresh() {
         const method = this.method;
         // GET or HEAD for weak freshness validation only
-        if ('GET' !== method && 'HEAD' !== method)
+        if (method !== 'GET' && method !== 'HEAD')
             return false;
         const status = this.res?.statusCode;
         // 2xx or 304 as per rfc2616 14.26
-        if ((status >= 200 && status < 300) || 304 === status) {
+        if ((status >= 200 && status < 300) || status === 304) {
             return fresh(this.headers, {
-                'etag': this.res.getHeader('ETag'),
-                'last-modified': this.res.getHeader('Last-Modified')
+                etag: this.res.getHeader('ETag'),
+                'last-modified': this.res.getHeader('Last-Modified'),
             });
         }
         return false;
@@ -130,4 +99,9 @@ class HttpServerRequestHost {
             return;
         return parseRange(size, range, options);
     }
+    async readBody(options) {
+        if (!this.complete)
+            this.body = await BodyReader.read(this, options);
+        return this.body;
+    }
 }