@opra/core 1.0.0-alpha.23 → 1.0.0-alpha.24

package/cjs/constants.js

@@ -1,5 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.kAssetCache = exports.kHandler = void 0;
-exports.kHandler = Symbol.for('kHandler');
+exports.kAssetCache = void 0;
 exports.kAssetCache = Symbol.for('kAssetCache');

package/cjs/execution-context.js

@@ -8,6 +8,7 @@ const strict_typed_events_1 = require("strict-typed-events");
 class ExecutionContext extends strict_typed_events_1.AsyncEventEmitter {
     constructor(init) {
         super();
+        this.errors = [];
         this.document = init.document;
         this.protocol = init.protocol;
         this.platform = init.platform;

package/cjs/http/express-adapter.js

@@ -5,11 +5,11 @@ const tslib_1 = require("tslib");
 const common_1 = require("@opra/common");
 const express_1 = require("express");
 const nodePath = tslib_1.__importStar(require("path"));
-const constants_js_1 = require("../constants.js");
 const http_adapter_js_1 = require("./http-adapter.js");
 const http_context_js_1 = require("./http-context.js");
 const http_incoming_interface_js_1 = require("./interfaces/http-incoming.interface.js");
 const http_outgoing_interface_js_1 = require("./interfaces/http-outgoing.interface.js");
+const wrap_exception_1 = require("./utils/wrap-exception");
 class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
     constructor(app, document, options) {
         super(document, options);
@@ -40,7 +40,8 @@ class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
                         await resource.onShutdown.call(instance, resource);
                     }
                     catch (e) {
-                        this.logger.error(e);
+                        if (this.listenerCount('error'))
+                            this.emit('error', (0, wrap_exception_1.wrapException)(e));
                     }
                 }
             }
@@ -80,7 +81,7 @@ class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
         /** Add an endpoint that returns document schema */
         router.get('/\\$schema', (_req, _res, next) => {
             const context = createContext(_req, _res);
-            this[constants_js_1.kHandler].sendDocumentSchema(context).catch(next);
+            this.handler.sendDocumentSchema(context).catch(next);
         });
         /** Add operation endpoints */
         if (this.api.controllers.size) {
@@ -100,13 +101,13 @@ class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
                             operation,
                             operationHandler,
                         });
-                        this[constants_js_1.kHandler]
+                        this.handler
                             .handleRequest(context)
                             .then(() => {
                             if (!_res.headersSent)
                                 _next();
                         })
-                            .catch((e) => this.logger.fatal(e));
+                            .catch((e) => this.emit('error', e));
                     });
                 }
                 if (controller.controllers.size) {
@@ -119,19 +120,15 @@ class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
         }
         /** Add an endpoint that returns 404 error at last */
         router.use('*', (_req, _res, next) => {
-            const res = http_outgoing_interface_js_1.HttpOutgoing.from(_res);
-            // const url = new URL(_req.originalUrl, '')
-            this[constants_js_1.kHandler]
-                .sendErrorResponse(res, [
-                new common_1.NotFoundError({
-                    message: `No endpoint found for [${_req.method}]${_req.baseUrl}`,
-                    details: {
-                        path: _req.baseUrl,
-                        method: _req.method,
-                    },
-                }),
-            ])
-                .catch(next);
+            const context = createContext(_req, _res);
+            context.errors.push(new common_1.NotFoundError({
+                message: `No endpoint found at [${_req.method}]${_req.baseUrl}`,
+                details: {
+                    path: _req.baseUrl,
+                    method: _req.method,
+                },
+            }));
+            this.handler.sendResponse(context).catch(next);
         });
     }
     _createControllers(controller) {

package/cjs/http/http-adapter.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpAdapter = void 0;
 const common_1 = require("@opra/common");
-const constants_js_1 = require("../constants.js");
 const platform_adapter_js_1 = require("../platform-adapter.js");
-const http_handler_js_1 = require("./impl/http-handler.js");
+const http_handler_js_1 = require("./http-handler.js");
 /**
  *
  * @class HttpAdapter
@@ -15,10 +14,8 @@ class HttpAdapter extends platform_adapter_js_1.PlatformAdapter {
         this.protocol = 'http';
         if (!(document.api instanceof common_1.HttpApi))
             throw new TypeError(`The document does not expose an HTTP Api`);
-        this[constants_js_1.kHandler] = new http_handler_js_1.HttpHandler(this);
+        this.handler = new http_handler_js_1.HttpHandler(this);
         this.interceptors = [...(options?.interceptors || [])];
-        if (options?.onRequest)
-            this.on('request', options.onRequest);
     }
     get api() {
         return this.document.api;

package/cjs/http/http-context.js

@@ -29,6 +29,10 @@ class HttpContext extends execution_context_js_1.ExecutionContext {
         this.pathParams = init.pathParams || {};
         this.queryParams = init.queryParams || {};
         this._body = init.body;
+        this.on('finish', () => {
+            if (this._multipartReader)
+                this._multipartReader.purge().catch(() => undefined);
+        });
     }
     get isMultipart() {
         return !!this.request.is('multipart');
@@ -38,21 +42,21 @@ class HttpContext extends execution_context_js_1.ExecutionContext {
             throw new common_1.InternalServerError('Request content is not a multipart content');
         if (this._multipartReader)
             return this._multipartReader;
-        const { request, mediaType } = this;
+        const { mediaType } = this;
         if (mediaType?.contentType) {
             const arr = Array.isArray(mediaType.contentType) ? mediaType.contentType : [mediaType.contentType];
             const contentType = arr.find(ct => type_is_1.default.is(ct, ['multipart']));
             if (!contentType)
                 throw new common_1.NotAcceptableError('This endpoint does not accept multipart requests');
         }
-        const reader = new multipart_reader_js_1.MultipartReader(request, {
-            maxFields: mediaType?.maxFields,
-            maxFieldsSize: mediaType?.maxFieldsSize,
-            maxFiles: mediaType?.maxFiles,
-            maxFileSize: mediaType?.maxFileSize,
-            maxTotalFileSize: mediaType?.maxTotalFileSize,
-            minFileSize: mediaType?.minFileSize,
-        });
+        const reader = new multipart_reader_js_1.MultipartReader(this, {
+            limits: {
+                fields: mediaType?.maxFields,
+                fieldSize: mediaType?.maxFieldsSize,
+                files: mediaType?.maxFiles,
+                fileSize: mediaType?.maxFileSize,
+            },
+        }, mediaType);
         this._multipartReader = reader;
         return reader;
     }
@@ -70,7 +74,7 @@ class HttpContext extends execution_context_js_1.ExecutionContext {
             if (mediaType && multipartFields?.length) {
                 const fieldsFound = new Map();
                 for (const item of parts) {
-                    const field = mediaType.findMultipartField(item.fieldName, item.type);
+                    const field = mediaType.findMultipartField(item.field, item.kind);
                     if (field) {
                         fieldsFound.set(field, true);
                         this._body.push(item);

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

@@ -9,15 +9,15 @@ const content_type_1 = require("content-type");
 const fast_tokenizer_1 = require("fast-tokenizer");
 const ts_gems_1 = require("ts-gems");
 const valgen_1 = require("valgen");
-const constants_js_1 = require("../../constants.js");
-const wrap_exception_js_1 = require("../utils/wrap-exception.js");
+const constants_1 = require("../constants");
+const wrap_exception_1 = require("./utils/wrap-exception");
 /**
  * @class HttpHandler
  */
 class HttpHandler {
     constructor(adapter) {
         this.adapter = adapter;
-        this[constants_js_1.kAssetCache] = adapter[constants_js_1.kAssetCache];
+        this[constants_1.kAssetCache] = adapter[constants_1.kAssetCache];
     }
     /**
      * Main http request handler
@@ -42,7 +42,7 @@ class HttpHandler {
                     throw e;
                 if (e instanceof valgen_1.ValidationError) {
                     throw new common_1.BadRequestError({
-                        message: (0, common_1.translate)('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                        message: 'Response validation failed',
                         code: 'RESPONSE_VALIDATION',
                         details: e.issues,
                     }, e);
@@ -68,19 +68,17 @@ class HttpHandler {
             let e = error;
             if (e instanceof valgen_1.ValidationError) {
                 e = new common_1.InternalServerError({
-                    message: (0, common_1.translate)('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                    message: 'Response validation failed',
                     code: 'RESPONSE_VALIDATION',
                     details: e.issues,
                 }, e);
             }
             else
-                e = (0, wrap_exception_js_1.wrapException)(e);
-            response.status(e.statusCode || e.status || common_1.HttpStatusCode.INTERNAL_SERVER_ERROR);
-            response.contentType(common_1.MimeTypes.opra_response_json);
-            await this._sendResponse(context, new common_1.OperationResult({ errors: [e.toJSON()] })).finally(() => {
-                if (!response.finished)
-                    response.end();
-            });
+                e = (0, wrap_exception_1.wrapException)(e);
+            if (this.onError)
+                await this.onError(context, error);
+            context.errors.push(e);
+            await this.sendResponse(context);
         }
         finally {
             await context.emitAsync('finish');
@@ -121,10 +119,10 @@ class HttpHandler {
             };
             /** prepare decoders */
             const getDecoder = (prm) => {
-                let decode = this[constants_js_1.kAssetCache].get(prm, 'decode');
+                let decode = this[constants_1.kAssetCache].get(prm, 'decode');
                 if (!decode) {
                     decode = prm.type?.generateCodec('decode', { ignoreReadonlyFields: true }) || valgen_1.vg.isAny();
-                    this[constants_js_1.kAssetCache].set(prm, 'decode', decode);
+                    this[constants_1.kAssetCache].set(prm, 'decode', decode);
                 }
                 return decode;
             };
@@ -214,6 +212,7 @@ class HttpHandler {
                 }
             }
             for (const prm of paramsLeft) {
+                key = String(prm.name);
                 // Throw error for required parameters
                 if (prm.required) {
                     const decode = getDecoder(prm);
@@ -265,7 +264,7 @@ class HttpHandler {
         const responseValue = await context.operationHandler.call(context.controllerInstance, context);
         const { response } = context;
         if (!response.writableEnded) {
-            await this._sendResponse(context, responseValue).finally(() => {
+            await this.sendResponse(context, responseValue).finally(() => {
                 if (!response.writableEnded)
                     response.end();
             });
@@ -277,23 +276,25 @@ class HttpHandler {
      * @param responseValue
      * @protected
      */
-    async _sendResponse(context, responseValue) {
+    async sendResponse(context, responseValue) {
+        if (context.errors.length)
+            return this.sendErrorResponse(context, context.errors);
         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(common_1.OperationResult);
-        let operationResultEncoder = this[constants_js_1.kAssetCache].get(operationResultType, 'encode');
+        let operationResultEncoder = this[constants_1.kAssetCache].get(operationResultType, 'encode');
         if (!operationResultEncoder) {
             operationResultEncoder = operationResultType.generateCodec('encode', { ignoreWriteonlyFields: true });
-            this[constants_js_1.kAssetCache].set(operationResultType, 'encode', operationResultEncoder);
+            this[constants_1.kAssetCache].set(operationResultType, 'encode', operationResultEncoder);
         }
         /** Validate response */
         if (operationResponse?.type) {
             if (!(body == null && statusCode === common_1.HttpStatusCode.NO_CONTENT)) {
                 /** Generate encoder */
-                let encode = this[constants_js_1.kAssetCache].get(operationResponse, 'encode');
+                let encode = this[constants_1.kAssetCache].get(operationResponse, 'encode');
                 if (!encode) {
                     encode = operationResponse.type.generateCodec('encode', {
                         partial: operationResponse.partial,
@@ -303,7 +304,7 @@ class HttpHandler {
                     if (operationResponse) {
                         if (operationResponse.isArray)
                             encode = valgen_1.vg.isArray(encode);
-                        this[constants_js_1.kAssetCache].set(operationResponse, 'encode', encode);
+                        this[constants_1.kAssetCache].set(operationResponse, 'encode', encode);
                     }
                 }
                 /** Encode body */
@@ -368,6 +369,57 @@ class HttpHandler {
             x = String(body);
         response.end(x);
     }
+    async sendErrorResponse(context, errors) {
+        const { response } = context;
+        if (response.headersSent) {
+            response.end();
+            return;
+        }
+        errors = errors || context.errors;
+        const wrappedErrors = errors.map(wrap_exception_1.wrapException);
+        if (!wrappedErrors.length)
+            wrappedErrors.push(new common_1.InternalServerError());
+        // Sort errors from fatal to info
+        wrappedErrors.sort((a, b) => {
+            const i = common_1.IssueSeverity.Keys.indexOf(a.severity) - common_1.IssueSeverity.Keys.indexOf(b.severity);
+            if (i === 0)
+                return b.status - a.status;
+            return i;
+        });
+        context.errors = wrappedErrors;
+        let status = response.statusCode || 0;
+        if (!status || status < Number(common_1.HttpStatusCode.BAD_REQUEST)) {
+            status = wrappedErrors[0].status;
+            if (status < Number(common_1.HttpStatusCode.BAD_REQUEST))
+                status = common_1.HttpStatusCode.INTERNAL_SERVER_ERROR;
+        }
+        response.statusCode = status;
+        this.adapter.emitAsync('error', wrappedErrors[0], context).catch(() => undefined);
+        const { document } = this.adapter;
+        const dt = document.node.getComplexType('OperationResult');
+        let encode = this[constants_1.kAssetCache].get(dt, 'encode');
+        if (!encode) {
+            encode = dt.generateCodec('encode', { ignoreWriteonlyFields: true });
+            this[constants_1.kAssetCache].set(dt, 'encode', encode);
+        }
+        const { i18n } = this.adapter;
+        const bodyObject = new common_1.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(common_1.HttpHeaderCodes.Content_Type, common_1.MimeTypes.opra_response_json + '; charset=utf-8');
+        response.setHeader(common_1.HttpHeaderCodes.Cache_Control, 'no-cache');
+        response.setHeader(common_1.HttpHeaderCodes.Pragma, 'no-cache');
+        response.setHeader(common_1.HttpHeaderCodes.Expires, '-1');
+        response.setHeader(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
+        response.send(JSON.stringify(body));
+        response.end();
+    }
     /**
      *
      * @param context
@@ -390,7 +442,7 @@ class HttpHandler {
         }
         let operationResponse;
         const cacheKey = `HttpOperationResponse:${statusCode}${contentType ? ':' + contentType : ''}`;
-        let responseArgs = this[constants_js_1.kAssetCache].get(response, cacheKey);
+        let responseArgs = this[constants_1.kAssetCache].get(response, cacheKey);
         if (!responseArgs) {
             responseArgs = { statusCode, contentType };
             if (operation.responses.length) {
@@ -436,7 +488,7 @@ class HttpHandler {
             }
             if (!hasBody)
                 delete responseArgs.contentType;
-            this[constants_js_1.kAssetCache].set(response, cacheKey, { ...responseArgs });
+            this[constants_1.kAssetCache].set(response, cacheKey, { ...responseArgs });
         }
         /** Fix response value according to composition */
         const composition = operationResponse?.owner.composition;
@@ -502,85 +554,20 @@ class HttpHandler {
         const documentId = searchParams.get('id');
         const doc = documentId ? document.findDocument(documentId) : document;
         if (!doc) {
-            return this.sendErrorResponse(response, [
-                new common_1.BadRequestError({
-                    message: `Document with given id [${documentId}] does not exists`,
-                }),
-            ]);
+            context.errors.push(new common_1.BadRequestError({
+                message: `Document with given id [${documentId}] does not exists`,
+            }));
+            return this.sendResponse(context);
         }
         /** Check if response cache exists */
-        let responseBody = this[constants_js_1.kAssetCache].get(doc, `$schema`);
+        let responseBody = this[constants_1.kAssetCache].get(doc, `$schema`);
         /** Create response if response cache does not exists */
         if (!responseBody) {
             const schema = doc.export();
             responseBody = JSON.stringify(schema);
-            this[constants_js_1.kAssetCache].set(doc, `$schema`, responseBody);
+            this[constants_1.kAssetCache].set(doc, `$schema`, responseBody);
         }
         response.end(responseBody);
     }
-    async sendErrorResponse(response, errors) {
-        if (response.headersSent) {
-            response.end();
-            return;
-        }
-        if (!errors.length)
-            errors.push((0, wrap_exception_js_1.wrapException)({ status: response.statusCode || 500 }));
-        const { logger } = this.adapter;
-        errors.forEach(x => {
-            if (x instanceof common_1.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(wrap_exception_js_1.wrapException);
-        // Sort errors from fatal to info
-        wrappedErrors.sort((a, b) => {
-            const i = common_1.IssueSeverity.Keys.indexOf(a.severity) - common_1.IssueSeverity.Keys.indexOf(b.severity);
-            if (i === 0)
-                return b.status - a.status;
-            return i;
-        });
-        let status = response.statusCode || 0;
-        if (!status || status < Number(common_1.HttpStatusCode.BAD_REQUEST)) {
-            status = wrappedErrors[0].status;
-            if (status < Number(common_1.HttpStatusCode.BAD_REQUEST))
-                status = common_1.HttpStatusCode.INTERNAL_SERVER_ERROR;
-        }
-        response.statusCode = status;
-        const { document } = this.adapter;
-        const dt = document.node.getComplexType('OperationResult');
-        let encode = this[constants_js_1.kAssetCache].get(dt, 'encode');
-        if (!encode) {
-            encode = dt.generateCodec('encode', { ignoreWriteonlyFields: true });
-            this[constants_js_1.kAssetCache].set(dt, 'encode', encode);
-        }
-        const { i18n } = this.adapter;
-        const bodyObject = new common_1.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(common_1.HttpHeaderCodes.Content_Type, common_1.MimeTypes.opra_response_json + '; charset=utf-8');
-        response.setHeader(common_1.HttpHeaderCodes.Cache_Control, 'no-cache');
-        response.setHeader(common_1.HttpHeaderCodes.Pragma, 'no-cache');
-        response.setHeader(common_1.HttpHeaderCodes.Expires, '-1');
-        response.setHeader(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
-        response.send(JSON.stringify(body));
-        response.end();
-    }
 }
 exports.HttpHandler = HttpHandler;