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

package/cjs/http/impl/multipart-reader.js

@@ -2,58 +2,147 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultipartReader = void 0;
 const tslib_1 = require("tslib");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_os_1 = tslib_1.__importDefault(require("node:os"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
+const common_1 = require("@opra/common");
+const busboy_1 = tslib_1.__importDefault(require("busboy"));
 const events_1 = require("events");
-const formidable_1 = tslib_1.__importDefault(require("formidable"));
 const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const valgen_1 = require("valgen");
 class MultipartReader extends events_1.EventEmitter {
-    constructor(incoming, options) {
+    constructor(context, options, mediaType) {
         super();
+        this.context = context;
+        this.mediaType = mediaType;
         this._started = false;
+        this._finished = false;
         this._cancelled = false;
         this._items = [];
         this._stack = [];
         this.setMaxListeners(1000);
-        this._incoming = incoming;
-        const form = (this._form = (0, formidable_1.default)({
-            ...options,
-            filter: (part) => !this._cancelled && (!options?.filter || options.filter(part)),
-        }));
-        form.once('error', () => {
+        this.tempDirectory = options?.tempDirectory || node_os_1.default.tmpdir();
+        const { request } = context;
+        const form = (0, busboy_1.default)({ headers: request.headers });
+        this._form = form;
+        form.once('error', (e) => {
             this._cancelled = true;
+            this._finished = true;
             if (this.listenerCount('error') > 0)
-                this.emit('error');
+                this.emit('error', e);
         });
-        form.on('field', (fieldName, value) => {
-            const item = { fieldName, type: 'field', value };
+        form.on('close', () => {
+            this._finished = true;
+        });
+        form.on('field', (field, value, info) => {
+            const item = {
+                kind: 'field',
+                field,
+                value,
+                mimeType: info.mimeType,
+                encoding: info.encoding,
+            };
             this._items.push(item);
             this._stack.push(item);
             this.emit('field', item);
             this.emit('item', item);
         });
-        form.on('file', (fieldName, file) => {
-            const item = { fieldName, type: 'file', file };
-            this._items.push(item);
-            this._stack.push(item);
-            this.emit('file', item);
-            this.emit('item', item);
+        form.on('file', (field, file, info) => {
+            const saveTo = node_path_1.default.join(this.tempDirectory, `opra-${generateFileName()}`);
+            file.pipe(node_fs_1.default.createWriteStream(saveTo));
+            file.once('end', () => {
+                const item = {
+                    kind: 'file',
+                    field,
+                    storedPath: saveTo,
+                    filename: info.filename,
+                    mimeType: info.mimeType,
+                    encoding: info.encoding,
+                };
+                this._items.push(item);
+                this._stack.push(item);
+                this.emit('file', item);
+                this.emit('item', item);
+            });
         });
     }
     get items() {
         return this._items;
     }
-    getNext() {
-        if (!this._form.ended)
+    async getNext() {
+        let item = this._stack.shift();
+        if (!item && !this._finished) {
             this.resume();
-        return new Promise((resolve, reject) => {
-            if (this._stack.length)
-                return resolve(this._stack.shift());
-            if (this._form.ended)
-                return resolve(undefined);
-            this.once('item', () => resolve(this._stack.shift()));
-            this.once('error', e => reject(e));
-        });
+            item = await new Promise((resolve, reject) => {
+                if (this._stack.length)
+                    return resolve(this._stack.shift());
+                if (this._form.ended)
+                    return resolve(undefined);
+                this._form.once('close', () => {
+                    resolve(this._stack.shift());
+                });
+                this.once('item', () => {
+                    this.pause();
+                    resolve(this._stack.shift());
+                });
+                this.once('error', e => reject(e));
+            });
+        }
+        if (item && this.mediaType) {
+            const field = this.mediaType.findMultipartField(item.field);
+            if (!field)
+                throw new common_1.BadRequestError(`Unknown multipart field (${item.field})`);
+            if (item.kind === 'field') {
+                const codec = field.generateCodec('decode');
+                item.value = codec(item.value);
+            }
+            else if (item.kind === 'file') {
+                if (field.contentType) {
+                    const arr = Array.isArray(field.contentType) ? field.contentType : [field.contentType];
+                    if (!(item.mimeType && arr.find(ct => type_is_1.default.is(item.mimeType, [ct])))) {
+                        throw new common_1.BadRequestError(`Multipart field (${item.field}) do not accept this content type`);
+                    }
+                }
+            }
+        }
+        /** if all items received we check for required items */
+        if (!item && this.mediaType && this.mediaType.multipartFields?.length > 0) {
+            const fieldsLeft = new Set(this.mediaType.multipartFields);
+            for (const x of this._items) {
+                const field = this.mediaType.findMultipartField(x.field);
+                if (field)
+                    fieldsLeft.delete(field);
+            }
+            let issues;
+            for (const field of fieldsLeft) {
+                try {
+                    (0, valgen_1.isNotNullish)(null, { onFail: () => `Multi part field "${String(field.fieldName)}" is required` });
+                }
+                catch (e) {
+                    if (!issues) {
+                        issues = e.issues;
+                        this.context.errors.push(e);
+                    }
+                    else
+                        issues.push(...e.issues);
+                }
+            }
+            if (this.context.errors.length)
+                throw this.context.errors[0];
+        }
+        return item;
+    }
+    async getAll() {
+        const items = [];
+        let item;
+        while (!this._cancelled && (item = await this.getNext())) {
+            items.push(item);
+        }
+        return items;
     }
-    getAll() {
+    getAll_() {
         if (this._form.ended)
             return Promise.resolve([...this._items]);
         this.resume();
@@ -70,21 +159,21 @@ class MultipartReader extends events_1.EventEmitter {
             this.resume();
     }
     resume() {
-        if (!this._started)
-            this._form.parse(this._incoming, () => undefined);
-        if (this._form.req)
-            this._form.resume();
+        if (!this._started) {
+            this._started = true;
+            this.context.request.pipe(this._form);
+        }
+        this.context.request.resume();
     }
     pause() {
-        if (this._form.req)
-            this._form.pause();
+        this.context.request.pause();
     }
-    async deleteTempFiles() {
+    async purge() {
         const promises = [];
         this._items.forEach(item => {
-            if (!item.file)
+            if (item.kind !== 'file')
                 return;
-            const file = item.file;
+            const file = item.storedPath;
             promises.push(new Promise(resolve => {
                 if (file._writeStream.closed)
                     return resolve();
@@ -97,3 +186,7 @@ class MultipartReader extends events_1.EventEmitter {
     }
 }
 exports.MultipartReader = MultipartReader;
+function generateFileName() {
+    const buf = Buffer.alloc(10);
+    return new Date().toISOString().substring(0, 10).replaceAll('-', '') + (0, node_crypto_1.randomFillSync)(buf).toString('hex');
+}

package/cjs/index.js

@@ -10,11 +10,11 @@ const HttpOutgoingHost_ = tslib_1.__importStar(require("./http/impl/http-outgoin
 const NodeIncomingMessageHost_ = tslib_1.__importStar(require("./http/impl/node-incoming-message.host.js"));
 const NodeOutgoingMessageHost_ = tslib_1.__importStar(require("./http/impl/node-outgoing-message.host.js"));
 tslib_1.__exportStar(require("./execution-context.js"), exports);
-tslib_1.__exportStar(require("./helpers/logger.js"), exports);
 tslib_1.__exportStar(require("./helpers/service-base.js"), exports);
 tslib_1.__exportStar(require("./http/express-adapter.js"), exports);
 tslib_1.__exportStar(require("./http/http-adapter.js"), exports);
 tslib_1.__exportStar(require("./http/http-context.js"), exports);
+tslib_1.__exportStar(require("./http/http-handler.js"), exports);
 tslib_1.__exportStar(require("./http/impl/multipart-reader.js"), exports);
 tslib_1.__exportStar(require("./http/interfaces/http-incoming.interface.js"), exports);
 tslib_1.__exportStar(require("./http/interfaces/http-outgoing.interface.js"), exports);

package/cjs/platform-adapter.js

@@ -5,7 +5,6 @@ require("./augmentation/18n.augmentation.js");
 const common_1 = require("@opra/common");
 const strict_typed_events_1 = require("strict-typed-events");
 const constants_js_1 = require("./constants.js");
-const logger_js_1 = require("./helpers/logger.js");
 const asset_cache_js_1 = require("./http/impl/asset-cache.js");
 /**
  * @class PlatformAdapter
@@ -15,8 +14,6 @@ class PlatformAdapter extends strict_typed_events_1.AsyncEventEmitter {
         super();
         this[constants_js_1.kAssetCache] = new asset_cache_js_1.AssetCache();
         this.document = document;
-        this.logger =
-            options?.logger && options.logger instanceof logger_js_1.Logger ? options.logger : new logger_js_1.Logger({ instance: options?.logger });
         this.i18n = options?.i18n || common_1.I18n.defaultInstance;
     }
 }

package/esm/constants.js

@@ -1,2 +1 @@
-export const kHandler = Symbol.for('kHandler');
 export const kAssetCache = Symbol.for('kAssetCache');

package/esm/execution-context.js

@@ -5,6 +5,7 @@ import { AsyncEventEmitter } from 'strict-typed-events';
 export class ExecutionContext extends AsyncEventEmitter {
     constructor(init) {
         super();
+        this.errors = [];
         this.document = init.document;
         this.protocol = init.protocol;
         this.platform = init.platform;

package/esm/http/express-adapter.js

@@ -1,11 +1,11 @@
 import { HttpApi, NotFoundError } from '@opra/common';
 import { Router } from 'express';
 import * as nodePath from 'path';
-import { kHandler } from '../constants.js';
 import { HttpAdapter } from './http-adapter.js';
 import { HttpContext } from './http-context.js';
 import { HttpIncoming } from './interfaces/http-incoming.interface.js';
 import { HttpOutgoing } from './interfaces/http-outgoing.interface.js';
+import { wrapException } from './utils/wrap-exception';
 export class ExpressAdapter extends HttpAdapter {
     constructor(app, document, options) {
         super(document, options);
@@ -36,7 +36,8 @@ export class ExpressAdapter extends HttpAdapter {
                         await resource.onShutdown.call(instance, resource);
                     }
                     catch (e) {
-                        this.logger.error(e);
+                        if (this.listenerCount('error'))
+                            this.emit('error', wrapException(e));
                     }
                 }
             }
@@ -76,7 +77,7 @@ export class ExpressAdapter extends HttpAdapter {
         /** Add an endpoint that returns document schema */
         router.get('/\\$schema', (_req, _res, next) => {
             const context = createContext(_req, _res);
-            this[kHandler].sendDocumentSchema(context).catch(next);
+            this.handler.sendDocumentSchema(context).catch(next);
         });
         /** Add operation endpoints */
         if (this.api.controllers.size) {
@@ -96,13 +97,13 @@ export class ExpressAdapter extends HttpAdapter {
                             operation,
                             operationHandler,
                         });
-                        this[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) {
@@ -115,19 +116,15 @@ export class ExpressAdapter extends HttpAdapter {
         }
         /** Add an endpoint that returns 404 error at last */
         router.use('*', (_req, _res, next) => {
-            const res = HttpOutgoing.from(_res);
-            // const url = new URL(_req.originalUrl, '')
-            this[kHandler]
-                .sendErrorResponse(res, [
-                new 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 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/esm/http/http-adapter.js

@@ -1,7 +1,6 @@
 import { HttpApi } from '@opra/common';
-import { kHandler } from '../constants.js';
 import { PlatformAdapter } from '../platform-adapter.js';
-import { HttpHandler } from './impl/http-handler.js';
+import { HttpHandler } from './http-handler.js';
 /**
  *
  * @class HttpAdapter
@@ -12,10 +11,8 @@ export class HttpAdapter extends PlatformAdapter {
         this.protocol = 'http';
         if (!(document.api instanceof HttpApi))
             throw new TypeError(`The document does not expose an HTTP Api`);
-        this[kHandler] = new HttpHandler(this);
+        this.handler = new HttpHandler(this);
         this.interceptors = [...(options?.interceptors || [])];
-        if (options?.onRequest)
-            this.on('request', options.onRequest);
     }
     get api() {
         return this.document.api;

package/esm/http/http-context.js

@@ -25,6 +25,10 @@ export class HttpContext extends 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');
@@ -34,21 +38,21 @@ export class HttpContext extends ExecutionContext {
             throw new 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 => typeIs.is(ct, ['multipart']));
             if (!contentType)
                 throw new NotAcceptableError('This endpoint does not accept multipart requests');
         }
-        const reader = new MultipartReader(request, {
-            maxFields: mediaType?.maxFields,
-            maxFieldsSize: mediaType?.maxFieldsSize,
-            maxFiles: mediaType?.maxFiles,
-            maxFileSize: mediaType?.maxFileSize,
-            maxTotalFileSize: mediaType?.maxTotalFileSize,
-            minFileSize: mediaType?.minFileSize,
-        });
+        const reader = new MultipartReader(this, {
+            limits: {
+                fields: mediaType?.maxFields,
+                fieldSize: mediaType?.maxFieldsSize,
+                files: mediaType?.maxFiles,
+                fileSize: mediaType?.maxFileSize,
+            },
+        }, mediaType);
         this._multipartReader = reader;
         return reader;
     }
@@ -66,7 +70,7 @@ export class HttpContext extends 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/esm/http/{impl/http-handler.js → http-handler.js}

@@ -1,12 +1,12 @@
 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 { BadRequestError, HttpHeaderCodes, HttpStatusCode, InternalServerError, isBlob, isReadableStream, IssueSeverity, MethodNotAllowedError, MimeTypes, OperationResult, OpraException, OpraSchema, } 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';
+import { kAssetCache } from '../constants';
+import { wrapException } from './utils/wrap-exception';
 /**
  * @class HttpHandler
  */
@@ -38,7 +38,7 @@ export class HttpHandler {
                     throw e;
                 if (e instanceof ValidationError) {
                     throw new BadRequestError({
-                        message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                        message: 'Response validation failed',
                         code: 'RESPONSE_VALIDATION',
                         details: e.issues,
                     }, e);
@@ -64,19 +64,17 @@ export class HttpHandler {
             let e = error;
             if (e instanceof ValidationError) {
                 e = new InternalServerError({
-                    message: translate('error:RESPONSE_VALIDATION,', 'Response validation failed'),
+                    message: '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();
-            });
+            if (this.onError)
+                await this.onError(context, error);
+            context.errors.push(e);
+            await this.sendResponse(context);
         }
         finally {
             await context.emitAsync('finish');
@@ -210,6 +208,7 @@ export class HttpHandler {
                 }
             }
             for (const prm of paramsLeft) {
+                key = String(prm.name);
                 // Throw error for required parameters
                 if (prm.required) {
                     const decode = getDecoder(prm);
@@ -261,7 +260,7 @@ export 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();
             });
@@ -273,7 +272,9 @@ export 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);
@@ -364,6 +365,57 @@ export 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(wrapException);
+        if (!wrappedErrors.length)
+            wrappedErrors.push(new InternalServerError());
+        // 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;
+        });
+        context.errors = wrappedErrors;
+        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;
+        this.adapter.emitAsync('error', wrappedErrors[0], context).catch(() => undefined);
+        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();
+    }
     /**
      *
      * @param context
@@ -498,11 +550,10 @@ export class HttpHandler {
         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`,
-                }),
-            ]);
+            context.errors.push(new BadRequestError({
+                message: `Document with given id [${documentId}] does not exists`,
+            }));
+            return this.sendResponse(context);
         }
         /** Check if response cache exists */
         let responseBody = this[kAssetCache].get(doc, `$schema`);
@@ -514,68 +565,4 @@ export class HttpHandler {
         }
         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();
-    }
 }