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

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,96 +272,156 @@ export class HttpHandler {
      * @param responseValue
      * @protected
      */
-    async _sendResponse(context, responseValue) {
+    async sendResponse(context, responseValue) {
+        if (context.errors.length)
+            return this._sendErrorResponse(context);
         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);
+        try {
+            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,
+                            onFail: issue => `Response body validation failed: ` + issue.message,
+                        });
+                        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);
+                        }
                     }
-                }
-                /** Encode body */
-                if (operationResponse.type.extendsFrom(operationResultType)) {
-                    if (body instanceof OperationResult)
-                        body = encode(body);
                     else {
-                        body.payload = encode(body.payload);
-                        body = operationResultEncoder(body);
+                        if (body instanceof OperationResult &&
+                            contentType &&
+                            typeIs.is(contentType, [MimeTypes.opra_response_json])) {
+                            body.payload = encode(body.payload);
+                            body = operationResultEncoder(body);
+                        }
+                        else {
+                            body = encode(body);
+                        }
                     }
-                }
-                else {
                     if (body instanceof OperationResult &&
-                        contentType &&
-                        typeIs.is(contentType, [MimeTypes.opra_response_json])) {
-                        body.payload = encode(body.payload);
-                        body = operationResultEncoder(body);
+                        operationResponse.type &&
+                        operationResponse.type !== document.node.getDataType(OperationResult)) {
+                        body.type = operationResponse.type.name ? operationResponse.type.name : '#embedded';
                     }
-                    else
-                        body = encode(body);
-                }
-                if (body instanceof OperationResult &&
-                    operationResponse.type &&
-                    operationResponse.type !== document.node.getDataType(OperationResult)) {
-                    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 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);
+                }
             }
-            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);
         }
-        /** Set content-type header value if not set */
-        if (contentType && contentType !== responseArgs.contentType)
-            response.setHeader('content-type', contentType);
-        response.status(statusCode);
-        if (body == null) {
+        catch (error) {
+            context.errors.push(error);
+            return this._sendErrorResponse(context);
+        }
+    }
+    async _sendErrorResponse(context) {
+        const { response, errors } = context;
+        if (response.headersSent) {
             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);
+        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();
     }
     /**
      *
@@ -421,6 +480,8 @@ export class HttpHandler {
                                     : operationResponse.contentType);
                                 if (typeof ct === 'string')
                                     responseArgs.contentType = contentType = ct;
+                                else if (operationResponse.type)
+                                    responseArgs.contentType = MimeTypes.opra_response_json;
                             }
                         }
                     }
@@ -498,11 +559,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 +574,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();
-    }
 }

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

@@ -1,55 +1,146 @@
+import { randomFillSync } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import nodePath from 'node:path';
+import typeIs from '@browsery/type-is';
+import { BadRequestError } from '@opra/common';
+import busboy from 'busboy';
 import { EventEmitter } from 'events';
-import formidable from 'formidable';
-import fs from 'fs/promises';
+import fsPromise from 'fs/promises';
+import { isNotNullish } from 'valgen';
 export class MultipartReader extends 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 = formidable({
-            ...options,
-            filter: (part) => !this._cancelled && (!options?.filter || options.filter(part)),
-        }));
-        form.once('error', () => {
+        this.tempDirectory = options?.tempDirectory || os.tmpdir();
+        const { request } = context;
+        const form = busboy({ 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 = nodePath.join(this.tempDirectory, `opra-${generateFileName()}`);
+            file.pipe(fs.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 BadRequestError(`Unknown multipart field (${item.field})`);
+            if (item.kind === 'field') {
+                const decode = field.generateCodec('decode');
+                item.value = decode(item.value, {
+                    onFail: issue => `Multipart field (${item.field}) validation failed: ` + issue.message,
+                });
+            }
+            else if (item.kind === 'file') {
+                if (field.contentType) {
+                    const arr = Array.isArray(field.contentType) ? field.contentType : [field.contentType];
+                    if (!(item.mimeType && arr.find(ct => typeIs.is(item.mimeType, [ct])))) {
+                        throw new BadRequestError(`Multipart field (${item.field}) do not accept this content type`);
+                    }
+                }
+            }
+        }
+        /** if all items received we check for required items */
+        if (this._finished && 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 {
+                    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();
@@ -66,29 +157,26 @@ export class MultipartReader extends 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;
-            promises.push(new Promise(resolve => {
-                if (file._writeStream.closed)
-                    return resolve();
-                file._writeStream.once('close', resolve);
-            })
-                .then(() => fs.unlink(file.filepath))
-                .then(() => 0));
+            promises.push(fsPromise.unlink(item.storedPath));
         });
         return Promise.allSettled(promises);
     }
 }
+function generateFileName() {
+    const buf = Buffer.alloc(10);
+    return new Date().toISOString().substring(0, 10).replaceAll('-', '') + randomFillSync(buf).toString('hex');
+}

package/esm/index.js

@@ -6,11 +6,11 @@ import * as HttpOutgoingHost_ from './http/impl/http-outgoing.host.js';
 import * as NodeIncomingMessageHost_ from './http/impl/node-incoming-message.host.js';
 import * as NodeOutgoingMessageHost_ from './http/impl/node-outgoing-message.host.js';
 export * from './execution-context.js';
-export * from './helpers/logger.js';
 export * from './helpers/service-base.js';
 export * from './http/express-adapter.js';
 export * from './http/http-adapter.js';
 export * from './http/http-context.js';
+export * from './http/http-handler.js';
 export * from './http/impl/multipart-reader.js';
 export * from './http/interfaces/http-incoming.interface.js';
 export * from './http/interfaces/http-outgoing.interface.js';

package/esm/platform-adapter.js

@@ -2,7 +2,6 @@ import './augmentation/18n.augmentation.js';
 import { I18n } from '@opra/common';
 import { AsyncEventEmitter } from 'strict-typed-events';
 import { kAssetCache } from './constants.js';
-import { Logger } from './helpers/logger.js';
 import { AssetCache } from './http/impl/asset-cache.js';
 /**
  * @class PlatformAdapter
@@ -12,8 +11,6 @@ export class PlatformAdapter extends AsyncEventEmitter {
         super();
         this[kAssetCache] = new AssetCache();
         this.document = document;
-        this.logger =
-            options?.logger && options.logger instanceof Logger ? options.logger : new Logger({ instance: options?.logger });
         this.i18n = options?.i18n || I18n.defaultInstance;
     }
 }