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

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

@@ -1,55 +1,144 @@
+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 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 => 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 (!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 {
+                    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 +155,33 @@ 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;
+            const file = item.storedPath;
             promises.push(new Promise(resolve => {
                 if (file._writeStream.closed)
                     return resolve();
                 file._writeStream.once('close', resolve);
             })
-                .then(() => fs.unlink(file.filepath))
+                .then(() => fsPromise.unlink(file.filepath))
                 .then(() => 0));
         });
         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;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "1.0.0-alpha.23",
+  "version": "1.0.0-alpha.24",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -33,10 +33,10 @@
   "dependencies": {
     "@browsery/http-parser": "^0.5.8",
     "@browsery/type-is": "^1.6.18-r2",
-    "@opra/common": "^1.0.0-alpha.23",
-    "@types/formidable": "^3.4.5",
+    "@opra/common": "^1.0.0-alpha.24",
     "accepts": "^1.3.8",
     "base64-stream": "^1.0.0",
+    "busboy": "^1.6.0",
     "bytes": "^3.1.2",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
@@ -44,7 +44,6 @@
     "cookie-signature": "^1.2.1",
     "cppzst": "^2.0.12",
     "encodeurl": "^2.0.0",
-    "formidable": "^3.5.1",
     "fresh": "^0.5.2",
     "iconv-lite": "^0.6.3",
     "mime-types": "^2.1.35",
@@ -55,7 +54,7 @@
     "range-parser": "^1.2.1",
     "raw-body": "^2.5.2",
     "reflect-metadata": "^0.2.2",
-    "strict-typed-events": "^2.3.3",
+    "strict-typed-events": "^2.4.0",
     "vary": "^1.1.2"
   },
   "optionalDependencies": {
@@ -66,6 +65,7 @@
     "@faker-js/faker": "^8.4.1",
     "@types/accepts": "^1.3.7",
     "@types/base64-stream": "^1.0.5",
+    "@types/busboy": "^1.5.4",
     "@types/bytes": "^3.1.4",
     "@types/content-disposition": "^0.5.8",
     "@types/content-type": "^1.1.8",

package/types/constants.d.ts

@@ -1,2 +1 @@
-export declare const kHandler: unique symbol;
 export declare const kAssetCache: unique symbol;

package/types/execution-context.d.ts

@@ -1,4 +1,4 @@
-import { ApiDocument, OpraSchema } from '@opra/common';
+import { ApiDocument, OpraException, OpraSchema } from '@opra/common';
 import { AsyncEventEmitter } from 'strict-typed-events';
 /**
  * @namespace ExecutionContext
@@ -18,6 +18,7 @@ export declare abstract class ExecutionContext extends AsyncEventEmitter {
     readonly document: ApiDocument;
     readonly protocol: OpraSchema.Protocol;
     readonly platform: string;
+    errors: OpraException[];
     protected constructor(init: ExecutionContext.Initiator);
     addListener(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
     removeListener(event: 'finish', listener: ExecutionContext.OnFinishListener): this;

package/types/http/http-adapter.d.ts

@@ -1,8 +1,7 @@
-import { ApiDocument, HttpApi, OpraSchema } from '@opra/common';
-import { kHandler } from '../constants.js';
+import { ApiDocument, HttpApi, OpraException, OpraSchema } from '@opra/common';
 import { PlatformAdapter } from '../platform-adapter.js';
 import { HttpContext } from './http-context.js';
-import { HttpHandler } from './impl/http-handler.js';
+import { HttpHandler } from './http-handler.js';
 export declare namespace HttpAdapter {
     /**
      * @type Interceptor
@@ -11,15 +10,34 @@ export declare namespace HttpAdapter {
     interface Options extends PlatformAdapter.Options {
         basePath?: string;
         interceptors?: HttpAdapter.Interceptor[];
-        onRequest?: (ctx: HttpContext) => void | Promise<void>;
     }
+    interface Events {
+        error: (error: OpraException, context: HttpContext) => void | Promise<void>;
+        request: (context: HttpContext) => void | Promise<void>;
+    }
+}
+export interface HttpAdapter {
+    addListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    on<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    once<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    off<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this;
+    prependListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    prependOnceListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
 }
 /**
  *
  * @class HttpAdapter
  */
 export declare abstract class HttpAdapter extends PlatformAdapter {
-    protected [kHandler]: HttpHandler;
+    readonly handler: HttpHandler;
     readonly protocol: OpraSchema.Protocol;
     interceptors: HttpAdapter.Interceptor[];
     protected constructor(document: ApiDocument, options?: HttpAdapter.Options);

package/types/http/{impl/http-handler.d.ts → http-handler.d.ts}

@@ -1,9 +1,8 @@
-import { HttpOperationResponse } from '@opra/common';
-import { kAssetCache } from '../../constants.js';
-import type { HttpAdapter } from '../http-adapter.js';
-import { HttpContext } from '../http-context.js';
-import { HttpOutgoing } from '../interfaces/http-outgoing.interface.js';
-import { AssetCache } from './asset-cache.js';
+import { HttpOperationResponse, OpraException } from '@opra/common';
+import { kAssetCache } from '../constants';
+import type { HttpAdapter } from './http-adapter';
+import { HttpContext } from './http-context';
+import { AssetCache } from './impl/asset-cache';
 /**
  * @namespace
  */
@@ -24,6 +23,7 @@ export declare namespace HttpHandler {
 export declare class HttpHandler {
     readonly adapter: HttpAdapter;
     protected [kAssetCache]: AssetCache;
+    onError?: (context: HttpContext, error: OpraException) => void | Promise<void>;
     constructor(adapter: HttpAdapter);
     /**
      * Main http request handler
@@ -60,7 +60,8 @@ export declare class HttpHandler {
      * @param responseValue
      * @protected
      */
-    protected _sendResponse(context: HttpContext, responseValue: any): Promise<void>;
+    sendResponse(context: HttpContext, responseValue?: any): Promise<void>;
+    sendErrorResponse(context: HttpContext, errors: any[]): Promise<void>;
     /**
      *
      * @param context
@@ -69,5 +70,4 @@ export declare class HttpHandler {
      */
     protected _determineResponseArgs(context: HttpContext, body: any): HttpHandler.ResponseArgs;
     sendDocumentSchema(context: HttpContext): Promise<void>;
-    sendErrorResponse(response: HttpOutgoing, errors: any[]): Promise<void>;
 }

package/types/http/impl/multipart-reader.d.ts

@@ -1,27 +1,46 @@
+import { HttpMediaType } from '@opra/common';
+import busboy from 'busboy';
 import { EventEmitter } from 'events';
-import formidable from 'formidable';
-import type IncomingForm from 'formidable/Formidable.js';
-import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface.js';
-export type MultipartFile = formidable.File;
-export type MultipartItem = {
-    fieldName: string;
-    type: 'field' | 'file';
-    value?: string;
-    file?: MultipartFile;
-};
+import { StrictOmit } from 'ts-gems';
+import { HttpContext } from '../http-context';
+export declare namespace MultipartReader {
+    interface Options extends StrictOmit<busboy.BusboyConfig, 'headers'> {
+        tempDirectory?: string;
+    }
+    interface FieldInfo {
+        kind: 'field';
+        field: string;
+        value?: string;
+        mimeType?: string;
+        encoding?: string;
+    }
+    interface FileInfo {
+        kind: 'file';
+        field: string;
+        filename: string;
+        storedPath: string;
+        mimeType?: string;
+        encoding?: string;
+    }
+    type Item = FieldInfo | FileInfo;
+}
 export declare class MultipartReader extends EventEmitter {
-    protected _incoming: NodeIncomingMessage;
+    protected context: HttpContext;
+    protected mediaType?: HttpMediaType | undefined;
     protected _started: boolean;
+    protected _finished: boolean;
     protected _cancelled: boolean;
-    protected _form: IncomingForm;
-    protected _items: MultipartItem[];
-    protected _stack: MultipartItem[];
-    constructor(incoming: NodeIncomingMessage, options?: formidable.Options);
-    get items(): MultipartItem[];
-    getNext(): Promise<MultipartItem | undefined>;
-    getAll(): Promise<MultipartItem[]>;
+    protected _form: busboy.Busboy;
+    protected _items: MultipartReader.Item[];
+    protected _stack: MultipartReader.Item[];
+    protected tempDirectory: string;
+    constructor(context: HttpContext, options?: MultipartReader.Options, mediaType?: HttpMediaType | undefined);
+    get items(): MultipartReader.Item[];
+    getNext(): Promise<MultipartReader.Item | undefined>;
+    getAll(): Promise<MultipartReader.Item[]>;
+    getAll_(): Promise<MultipartReader.Item[]>;
     cancel(): void;
     resume(): void;
     pause(): void;
-    deleteTempFiles(): Promise<PromiseSettledResult<any>[]>;
+    purge(): Promise<PromiseSettledResult<any>[]>;
 }

package/types/index.d.ts

@@ -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/types/platform-adapter.d.ts

@@ -2,16 +2,13 @@ import './augmentation/18n.augmentation.js';
 import { ApiDocument, I18n, OpraSchema } 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';
-import type { ILogger } from './interfaces/logger.interface.js';
 /**
  * @namespace PlatformAdapter
  */
 export declare namespace PlatformAdapter {
     interface Options {
         i18n?: I18n;
-        logger?: ILogger;
     }
 }
 /**
@@ -21,7 +18,6 @@ export declare abstract class PlatformAdapter extends AsyncEventEmitter {
     protected [kAssetCache]: AssetCache;
     readonly document: ApiDocument;
     abstract readonly protocol: OpraSchema.Protocol;
-    logger: Logger;
     i18n: I18n;
     protected constructor(document: ApiDocument, options?: PlatformAdapter.Options);
     abstract close(): Promise<void>;

package/cjs/helpers/logger.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = void 0;
-class Logger {
-    constructor(options = {}) {
-        this._instance = options.instance || (!(process.env.NODE_ENV || '').includes('test') ? globalThis.console : {});
-    }
-    info(message, ...optionalParams) {
-        (this._instance.info || this._instance.log)?.(message, ...optionalParams);
-    }
-    error(message, ...optionalParams) {
-        if (this._instance.error) {
-            this._instance.error(message, ...optionalParams);
-            return;
-        }
-        this.info(message, ...optionalParams);
-    }
-    fatal(message, ...optionalParams) {
-        if (this._instance.fatal) {
-            this._instance.fatal(message, ...optionalParams);
-            return;
-        }
-        this.error(message, ...optionalParams);
-    }
-    warn(message, ...optionalParams) {
-        this._instance.warn?.(message, ...optionalParams);
-    }
-    debug(message, ...optionalParams) {
-        this._instance.debug?.(message, ...optionalParams);
-    }
-    verbose(message, ...optionalParams) {
-        this._instance.verbose?.(message, ...optionalParams);
-    }
-}
-exports.Logger = Logger;

package/esm/helpers/logger.js

@@ -1,31 +0,0 @@
-export class Logger {
-    constructor(options = {}) {
-        this._instance = options.instance || (!(process.env.NODE_ENV || '').includes('test') ? globalThis.console : {});
-    }
-    info(message, ...optionalParams) {
-        (this._instance.info || this._instance.log)?.(message, ...optionalParams);
-    }
-    error(message, ...optionalParams) {
-        if (this._instance.error) {
-            this._instance.error(message, ...optionalParams);
-            return;
-        }
-        this.info(message, ...optionalParams);
-    }
-    fatal(message, ...optionalParams) {
-        if (this._instance.fatal) {
-            this._instance.fatal(message, ...optionalParams);
-            return;
-        }
-        this.error(message, ...optionalParams);
-    }
-    warn(message, ...optionalParams) {
-        this._instance.warn?.(message, ...optionalParams);
-    }
-    debug(message, ...optionalParams) {
-        this._instance.debug?.(message, ...optionalParams);
-    }
-    verbose(message, ...optionalParams) {
-        this._instance.verbose?.(message, ...optionalParams);
-    }
-}

package/i18n/i18n/en/error.json

@@ -1,21 +0,0 @@
-{
-  "BAD_REQUEST": "Bad request",
-  "FAILED_DEPENDENCY": "The request failed due to failure of a previous request",
-  "FORBIDDEN": "You are not authorized to perform this action",
-  "INTERNAL_SERVER_ERROR": "Internal server error",
-  "METHOD_NOT_ALLOWED": "Method not allowed",
-  "NOT_ACCEPTABLE": "Not acceptable",
-  "NOT_FOUND": "Not found",
-  "UNAUTHORIZED": "You have not been authenticated to perform this action",
-  "UNPROCESSABLE_ENTITY": "Unprocessable entity",
-  "REQUEST_VALIDATION": "Request validation failed",
-  "RESPONSE_VALIDATION": "Response validation failed",
-  "RESOURCE_NOT_AVAILABLE": "Resource is not available or you dont have access",
-  "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})",
-  "OPERATION_FORBIDDEN": "The {{resource}} resource does not accept '{{operation}}' operations",
-  "ACTION_NOT_FOUND": "The {{resource}} resource doesn't have an action named '{{action}}'",
-  "UNKNOWN_FIELD": "Unknown field '{{field}}'",
-  "UNACCEPTED_SORT_FIELD": "Field '{{field}}' is not available for sort operation",
-  "UNACCEPTED_FILTER_FIELD": "Field '{{field}}' is not available for filter operation",
-  "UNACCEPTED_FILTER_OPERATION": "'{{operation}}' for field '{{field}}' is not available for filter operation"
-}

package/types/helpers/logger.d.ts

@@ -1,14 +0,0 @@
-import { ILogger } from '../interfaces/logger.interface.js';
-export interface LoggerOptions {
-    instance?: ILogger;
-}
-export declare class Logger implements ILogger {
-    protected _instance: ILogger;
-    constructor(options?: LoggerOptions);
-    info(message: any, ...optionalParams: any[]): void;
-    error(message: any, ...optionalParams: any[]): void;
-    fatal(message: any, ...optionalParams: any[]): void;
-    warn(message: any, ...optionalParams: any[]): void;
-    debug(message: any, ...optionalParams: any[]): void;
-    verbose(message: any, ...optionalParams: any[]): void;
-}