@opra/http 1.0.4 → 1.0.5

package/cjs/express-adapter.js

@@ -10,19 +10,24 @@ 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");
 class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
-    constructor(app, document, options) {
-        super(document, options);
+    constructor(app, options) {
+        super(options);
         this._controllerInstances = new Map();
         this.app = app;
-        if (!(this.document.api instanceof common_1.HttpApi))
-            throw new TypeError('document.api must be instance of HttpApi');
-        for (const c of this.api.controllers.values())
-            this._createControllers(c);
-        this._initRouter();
     }
     get platform() {
         return 'express';
     }
+    initialize(document) {
+        if (this._document)
+            throw new TypeError(`${this.constructor.name} already initialized.`);
+        if (!(document.api instanceof common_1.HttpApi))
+            throw new TypeError(`The document does not expose an HTTP Api`);
+        this._document = document;
+        for (const c of this.api.controllers.values())
+            this._createControllers(c);
+        this._initRouter();
+    }
     async close() {
         const processInstance = async (controller) => {
             if (controller.controllers.size) {

package/cjs/http-adapter.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpAdapter = void 0;
-const common_1 = require("@opra/common");
 const core_1 = require("@opra/core");
 const http_handler_js_1 = require("./http-handler.js");
 /**
@@ -9,11 +8,9 @@ const http_handler_js_1 = require("./http-handler.js");
  * @class HttpAdapter
  */
 class HttpAdapter extends core_1.PlatformAdapter {
-    constructor(document, options) {
-        super(document, options);
+    constructor(options) {
+        super(options);
         this.protocol = 'http';
-        if (!(document.api instanceof common_1.HttpApi))
-            throw new TypeError(`The document does not expose an HTTP Api`);
         this.handler = new http_handler_js_1.HttpHandler(this);
         this.interceptors = [...(options?.interceptors || [])];
         this.basePath = options?.basePath || '/';

package/cjs/http-handler.js

@@ -394,8 +394,21 @@ class HttpHandler {
     async _sendErrorResponse(context) {
         context.errors = this._wrapExceptions(context.errors);
         try {
-            await this.adapter.emitAsync('error', context);
-            context.errors = this._wrapExceptions(context.errors);
+            if (context.listenerCount('error')) {
+                await this.adapter.emitAsync('error', context);
+                context.errors = this._wrapExceptions(context.errors);
+            }
+            if (this.adapter.listenerCount('error')) {
+                await this.adapter.emitAsync('error', context.errors[0], context);
+                context.errors = this._wrapExceptions(context.errors);
+            }
+            if (this.adapter.logger?.error) {
+                const logger = this.adapter.logger;
+                context.errors.forEach(e => {
+                    if (e.status >= 500 && e.status < 600)
+                        logger.error(e);
+                });
+            }
         }
         catch (e) {
             context.errors = this._wrapExceptions([e, ...context.errors]);

package/esm/express-adapter.js

@@ -6,19 +6,24 @@ import { HttpContext } from './http-context.js';
 import { HttpIncoming } from './interfaces/http-incoming.interface.js';
 import { HttpOutgoing } from './interfaces/http-outgoing.interface.js';
 export class ExpressAdapter extends HttpAdapter {
-    constructor(app, document, options) {
-        super(document, options);
+    constructor(app, options) {
+        super(options);
         this._controllerInstances = new Map();
         this.app = app;
-        if (!(this.document.api instanceof HttpApi))
-            throw new TypeError('document.api must be instance of HttpApi');
-        for (const c of this.api.controllers.values())
-            this._createControllers(c);
-        this._initRouter();
     }
     get platform() {
         return 'express';
     }
+    initialize(document) {
+        if (this._document)
+            throw new TypeError(`${this.constructor.name} already initialized.`);
+        if (!(document.api instanceof HttpApi))
+            throw new TypeError(`The document does not expose an HTTP Api`);
+        this._document = document;
+        for (const c of this.api.controllers.values())
+            this._createControllers(c);
+        this._initRouter();
+    }
     async close() {
         const processInstance = async (controller) => {
             if (controller.controllers.size) {

package/esm/http-adapter.js

@@ -1,4 +1,3 @@
-import { HttpApi } from '@opra/common';
 import { PlatformAdapter } from '@opra/core';
 import { HttpHandler } from './http-handler.js';
 /**
@@ -6,11 +5,9 @@ import { HttpHandler } from './http-handler.js';
  * @class HttpAdapter
  */
 export class HttpAdapter extends PlatformAdapter {
-    constructor(document, options) {
-        super(document, options);
+    constructor(options) {
+        super(options);
         this.protocol = 'http';
-        if (!(document.api instanceof HttpApi))
-            throw new TypeError(`The document does not expose an HTTP Api`);
         this.handler = new HttpHandler(this);
         this.interceptors = [...(options?.interceptors || [])];
         this.basePath = options?.basePath || '/';

package/esm/http-handler.js

@@ -390,8 +390,21 @@ export class HttpHandler {
     async _sendErrorResponse(context) {
         context.errors = this._wrapExceptions(context.errors);
         try {
-            await this.adapter.emitAsync('error', context);
-            context.errors = this._wrapExceptions(context.errors);
+            if (context.listenerCount('error')) {
+                await this.adapter.emitAsync('error', context);
+                context.errors = this._wrapExceptions(context.errors);
+            }
+            if (this.adapter.listenerCount('error')) {
+                await this.adapter.emitAsync('error', context.errors[0], context);
+                context.errors = this._wrapExceptions(context.errors);
+            }
+            if (this.adapter.logger?.error) {
+                const logger = this.adapter.logger;
+                context.errors.forEach(e => {
+                    if (e.status >= 500 && e.status < 600)
+                        logger.error(e);
+                });
+            }
         }
         catch (e) {
             context.errors = this._wrapExceptions([e, ...context.errors]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/http",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Opra Http Server Adapter",
   "author": "Panates",
   "license": "MIT",
@@ -8,8 +8,8 @@
     "@browsery/antlr4": "^4.13.3-r1",
     "@browsery/http-parser": "^0.5.9-r1",
     "@browsery/type-is": "^1.6.18-r5",
-    "@opra/common": "^1.0.4",
-    "@opra/core": "^1.0.4",
+    "@opra/common": "^1.0.5",
+    "@opra/core": "^1.0.5",
     "accepts": "^1.3.8",
     "base64-stream": "^1.0.0",
     "busboy": "^1.6.0",
@@ -33,7 +33,7 @@
     "raw-body": "^3.0.0",
     "reflect-metadata": "^0.2.2",
     "super-fast-md5": "^1.0.3",
-    "tslib": "^2.7.0",
+    "tslib": "^2.8.0",
     "valgen": "^5.10.0",
     "vary": "^1.1.2"
   },

package/types/express-adapter.d.ts

@@ -4,8 +4,9 @@ import { HttpAdapter } from './http-adapter.js';
 export declare class ExpressAdapter extends HttpAdapter {
     readonly app: Application;
     protected _controllerInstances: Map<HttpController, any>;
-    constructor(app: Application, document: ApiDocument, options?: HttpAdapter.Options);
+    constructor(app: Application, options?: HttpAdapter.Options);
     get platform(): string;
+    initialize(document: ApiDocument): void;
     close(): Promise<void>;
     getControllerInstance<T>(controllerPath: string): T | undefined;
     protected _initRouter(): void;

package/types/http-adapter.d.ts

@@ -1,4 +1,4 @@
-import { ApiDocument, HttpApi, OpraSchema } from '@opra/common';
+import { HttpApi, OpraSchema } from '@opra/common';
 import { PlatformAdapter } from '@opra/core';
 import { HttpContext } from './http-context.js';
 import { HttpHandler } from './http-handler.js';
@@ -28,6 +28,6 @@ export declare abstract class HttpAdapter extends PlatformAdapter {
     readonly protocol: OpraSchema.Transport;
     readonly basePath: string;
     interceptors: (HttpAdapter.InterceptorFunction | HttpAdapter.IHttpInterceptor)[];
-    protected constructor(document: ApiDocument, options?: HttpAdapter.Options);
+    protected constructor(options?: HttpAdapter.Options);
     get api(): HttpApi;
 }

package/types/http-context.d.ts

@@ -1,4 +1,4 @@
-import { HttpController, HttpMediaType, HttpOperation, OpraSchema } from '@opra/common';
+import { HttpController, HttpMediaType, HttpOperation, OpraHttpError, OpraSchema } from '@opra/common';
 import { ExecutionContext } from '@opra/core';
 import type { HttpAdapter } from './http-adapter';
 import { MultipartReader } from './impl/multipart-reader.js';
@@ -37,6 +37,7 @@ export declare class HttpContext extends ExecutionContext {
     readonly headers: Record<string, any>;
     readonly pathParams: Record<string, any>;
     readonly queryParams: Record<string, any>;
+    errors: OpraHttpError[];
     constructor(init: HttpContext.Initiator);
     get isMultipart(): boolean;
     getMultipartReader(): Promise<MultipartReader>;