@opra/http 1.19.7 → 1.20.0

package/cjs/express-adapter.js

@@ -49,14 +49,14 @@ class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
             const request = http_incoming_interface_js_1.HttpIncoming.from(_req);
             const response = http_outgoing_interface_js_1.HttpOutgoing.from(_res);
             const ctx = new http_context_js_1.HttpContext({
-                adapter: this,
+                __adapter: this,
                 platform: this.platform,
                 request,
                 response,
-                controller: args?.controller,
-                controllerInstance: args?.controllerInstance,
-                operation: args?.operation,
-                operationHandler: args?.operationHandler,
+                __contDef: args?.controller,
+                __controller: args?.controllerInstance,
+                __oprDef: args?.operation,
+                __handler: args?.operationHandler,
             });
             await this.emitAsync('createContext', ctx);
             return ctx;

package/cjs/http-adapter.js

@@ -10,7 +10,7 @@ const http_handler_js_1 = require("./http-handler.js");
 class HttpAdapter extends core_1.PlatformAdapter {
     constructor(options) {
         super(options);
-        this.protocol = 'http';
+        this.transform = 'http';
         this.handler = new http_handler_js_1.HttpHandler(this);
         this.interceptors = [...(options?.interceptors || [])];
         this.basePath = options?.basePath || '/';
@@ -19,7 +19,7 @@ class HttpAdapter extends core_1.PlatformAdapter {
         this.scope = options?.scope;
     }
     get api() {
-        return this.document.httpApi;
+        return this.document.getHttpApi();
     }
 }
 exports.HttpAdapter = HttpAdapter;

package/cjs/http-context.js

@@ -5,26 +5,25 @@ const tslib_1 = require("tslib");
 const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
 const common_1 = require("@opra/common");
 const core_1 = require("@opra/core");
-const valgen_1 = require("valgen");
 const multipart_reader_js_1 = require("./impl/multipart-reader.js");
 class HttpContext extends core_1.ExecutionContext {
     constructor(init) {
         super({
             ...init,
-            document: init.adapter.document,
-            documentNode: init.controller?.node,
-            protocol: 'http',
+            __docNode: init.__oprDef?.node ||
+                init.__contDef?.node ||
+                init.__adapter.document.node,
+            transport: 'http',
         });
-        this.adapter = init.adapter;
-        this.protocol = 'http';
-        if (init.controller)
-            this.controller = init.controller;
-        if (init.controllerInstance)
-            this.controllerInstance = init.controllerInstance;
-        if (init.operation)
-            this.operation = init.operation;
-        if (init.operationHandler)
-            this.operationHandler = init.operationHandler;
+        this.errors = [];
+        if (init.__contDef)
+            this.__contDef = init.__contDef;
+        if (init.__controller)
+            this.__controller = init.__controller;
+        if (init.__oprDef)
+            this.__oprDef = init.__oprDef;
+        if (init.__handler)
+            this.__handler = init.__handler;
         this.request = init.request;
         this.response = init.response;
         this.mediaType = init.mediaType;
@@ -69,7 +68,7 @@ class HttpContext extends core_1.ExecutionContext {
     async getBody() {
         if (this._body !== undefined)
             return this._body;
-        const { request, operation, mediaType } = this;
+        const { request, __oprDef, mediaType } = this;
         if (this.isMultipart) {
             const reader = await this.getMultipartReader();
             /** Retrieve all fields */
@@ -79,7 +78,7 @@ class HttpContext extends core_1.ExecutionContext {
             return this._body;
         }
         this._body = await this.request.readBody({
-            limit: operation?.requestBody?.maxContentSize,
+            limit: __oprDef?.requestBody?.maxContentSize,
         });
         if (this._body != null) {
             // Convert Buffer to string if media is text
@@ -94,18 +93,17 @@ class HttpContext extends core_1.ExecutionContext {
         if (mediaType) {
             // Decode/Validate the data object according to data model
             if (this._body && mediaType.type) {
-                let decode = this.adapter[core_1.kAssetCache].get(mediaType, 'decode');
+                let decode = this.__adapter[core_1.kAssetCache].get(mediaType, 'decode');
                 if (!decode) {
-                    decode =
-                        mediaType.type?.generateCodec('decode', {
-                            scope: this.adapter.scope,
-                            partial: operation?.requestBody?.partial,
-                            projection: '*',
-                            ignoreReadonlyFields: true,
-                            allowPatchOperators: operation?.requestBody?.allowPatchOperators,
-                            keepKeyFields: operation?.requestBody?.keepKeyFields,
-                        }) || valgen_1.vg.isAny();
-                    this.adapter[core_1.kAssetCache].set(mediaType, 'decode', decode);
+                    decode = mediaType.generateCodec('decode', {
+                        scope: this.__adapter.scope,
+                        partial: __oprDef?.requestBody?.partial,
+                        projection: '*',
+                        ignoreReadonlyFields: true,
+                        allowPatchOperators: __oprDef?.requestBody?.allowPatchOperators,
+                        keepKeyFields: __oprDef?.requestBody?.keepKeyFields,
+                    });
+                    this.__adapter[core_1.kAssetCache].set(mediaType, 'decode', decode);
                 }
                 this._body = decode(this._body);
             }

package/cjs/http-handler.js

@@ -95,11 +95,11 @@ class HttpHandler {
     async parseRequest(context) {
         await this._parseParameters(context);
         await this._parseContentType(context);
-        if (context.operation?.requestBody?.immediateFetch)
+        if (context.__oprDef?.requestBody?.immediateFetch)
             await context.getBody();
         /** Set default status code as the first status code between 200 and 299 */
-        if (context.operation) {
-            for (const r of context.operation.responses) {
+        if (context.__oprDef) {
+            for (const r of context.__oprDef.responses) {
                 const st = r.statusCode.find(sc => sc.start <= 299 && sc.end >= 200);
                 if (st) {
                     context.response.status(st.start);
@@ -114,8 +114,8 @@ class HttpHandler {
      * @protected
      */
     async _parseParameters(context) {
-        const { operation, request } = context;
-        if (!operation)
+        const { __oprDef, request } = context;
+        if (!__oprDef)
             return;
         let key = '';
         try {
@@ -127,24 +127,23 @@ class HttpHandler {
             const getDecoder = (prm) => {
                 let decode = this[core_1.kAssetCache].get(prm, 'decode');
                 if (!decode) {
-                    decode =
-                        prm.type?.generateCodec('decode', {
-                            scope: this.adapter.scope,
-                            ignoreReadonlyFields: true,
-                        }) || valgen_1.vg.isAny();
+                    decode = prm.generateCodec('decode', {
+                        scope: this.adapter.scope,
+                        ignoreReadonlyFields: true,
+                    });
                     this[core_1.kAssetCache].set(prm, 'decode', decode);
                 }
                 return decode;
             };
             const paramsLeft = new Set([
-                ...operation.parameters,
-                ...operation.owner.parameters,
+                ...__oprDef.parameters,
+                ...__oprDef.owner.parameters,
             ]);
             /** parse cookie parameters */
             if (request.cookies) {
                 for (key of Object.keys(request.cookies)) {
-                    const oprPrm = operation.findParameter(key, 'cookie');
-                    const cntPrm = operation.owner.findParameter(key, 'cookie');
+                    const oprPrm = __oprDef.findParameter(key, 'cookie');
+                    const cntPrm = __oprDef.owner.findParameter(key, 'cookie');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -166,8 +165,8 @@ class HttpHandler {
             /** parse headers */
             if (request.headers) {
                 for (key of Object.keys(request.headers)) {
-                    const oprPrm = operation.findParameter(key, 'header');
-                    const cntPrm = operation.owner.findParameter(key, 'header');
+                    const oprPrm = __oprDef.findParameter(key, 'header');
+                    const cntPrm = __oprDef.owner.findParameter(key, 'header');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -189,8 +188,8 @@ class HttpHandler {
             /** parse path parameters */
             if (request.params) {
                 for (key of Object.keys(request.params)) {
-                    const oprPrm = operation.findParameter(key, 'path');
-                    const cntPrm = operation.owner.findParameter(key, 'path');
+                    const oprPrm = __oprDef.findParameter(key, 'path');
+                    const cntPrm = __oprDef.owner.findParameter(key, 'path');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -212,8 +211,8 @@ class HttpHandler {
             const url = new URL(request.originalUrl || request.url || '/', 'http://tempuri.org');
             const { searchParams } = url;
             for (key of searchParams.keys()) {
-                const oprPrm = operation.findParameter(key, 'query');
-                const cntPrm = operation.owner.findParameter(key, 'query');
+                const oprPrm = __oprDef.findParameter(key, 'query');
+                const cntPrm = __oprDef.owner.findParameter(key, 'query');
                 const prm = oprPrm || cntPrm;
                 if (!prm)
                     continue;
@@ -271,19 +270,19 @@ class HttpHandler {
      * @protected
      */
     async _parseContentType(context) {
-        const { request, operation } = context;
-        if (!operation)
+        const { request, __oprDef } = context;
+        if (!__oprDef)
             return;
-        if (operation.requestBody?.content.length) {
+        if (__oprDef.requestBody?.content.length) {
             let mediaType;
             let contentType = request.header('content-type');
             if (contentType) {
                 contentType = (0, content_type_1.parse)(contentType).type;
-                mediaType = operation.requestBody.content.find(mc => mc.contentType &&
+                mediaType = __oprDef.requestBody.content.find(mc => mc.contentType &&
                     type_is_1.default.is(contentType, Array.isArray(mc.contentType) ? mc.contentType : [mc.contentType]));
             }
             if (!mediaType) {
-                const contentTypes = operation.requestBody.content
+                const contentTypes = __oprDef.requestBody.content
                     .map(mc => mc.contentType)
                     .flat();
                 throw new common_1.BadRequestError(`Request body should be one of required content types (${contentTypes.join(', ')})`);
@@ -297,9 +296,9 @@ class HttpHandler {
      * @protected
      */
     async _executeRequest(context) {
-        if (!context.operationHandler)
+        if (!context.__handler)
             throw new common_1.MethodNotAllowedError();
-        const responseValue = await context.operationHandler.call(context.controllerInstance, context);
+        const responseValue = await context.__handler.call(context.__controller, context);
         const { response } = context;
         if (!response.writableEnded) {
             await this.sendResponse(context, responseValue).finally(() => {
@@ -426,19 +425,19 @@ class HttpHandler {
         }
     }
     async _sendErrorResponse(context) {
-        context.errors = this._wrapExceptions(context.errors);
+        let errors = (context.errors = this._wrapExceptions(context.errors));
         try {
             if (context.listenerCount('error')) {
-                await context.emitAsync('error', context.errors[0], context);
-                context.errors = this._wrapExceptions(context.errors);
+                await context.emitAsync('error', errors[0], context);
+                errors = 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);
+                await this.adapter.emitAsync('error', errors[0], context);
+                errors = context.errors = this._wrapExceptions(errors);
             }
             if (this.adapter.logger?.error) {
                 const logger = this.adapter.logger;
-                context.errors.forEach(e => {
+                errors.forEach(e => {
                     if (e.status >= 500 && e.status < 600)
                         logger.error(e);
                 });
@@ -447,7 +446,7 @@ class HttpHandler {
         catch (e) {
             context.errors = this._wrapExceptions([e, ...context.errors]);
         }
-        const { response, errors } = context;
+        const { response } = context;
         if (response.headersSent) {
             response.end();
             return;
@@ -521,7 +520,7 @@ class HttpHandler {
      * @protected
      */
     _determineResponseArgs(context, body) {
-        const { response, operation } = context;
+        const { response, __oprDef } = context;
         const hasBody = body != null;
         const statusCode = !hasBody && response.statusCode === common_1.HttpStatusCode.OK
             ? common_1.HttpStatusCode.NO_CONTENT
@@ -543,12 +542,12 @@ class HttpHandler {
         let responseArgs = this[core_1.kAssetCache].get(response, cacheKey);
         if (!responseArgs) {
             responseArgs = { statusCode, contentType };
-            if (operation?.responses.length) {
+            if (__oprDef?.responses.length) {
                 /** Filter available HttpOperationResponse instances according to status code. */
-                const filteredResponses = operation.responses.filter(r => r.statusCode.find(sc => sc.start <= statusCode && sc.end >= statusCode));
+                const filteredResponses = __oprDef.responses.filter(r => r.statusCode.find(sc => sc.start <= statusCode && sc.end >= statusCode));
                 /** Throw InternalServerError if controller returns non-configured status code */
                 if (!filteredResponses.length && statusCode < 400) {
-                    throw new common_1.InternalServerError(`No responses defined for status code ${statusCode} in operation "${operation.name}"`);
+                    throw new common_1.InternalServerError(`No responses defined for status code ${statusCode} in operation "${__oprDef.name}"`);
                 }
                 /** We search for content-type in filtered HttpOperationResponse array */
                 if (filteredResponses.length) {
@@ -588,7 +587,7 @@ class HttpHandler {
             }
             if (!hasBody)
                 delete responseArgs.contentType;
-            if (operation?.composition?.startsWith('Entity.')) {
+            if (__oprDef?.composition?.startsWith('Entity.')) {
                 if (context.queryParams.projection)
                     responseArgs.projection = context.queryParams.projection;
             }

package/esm/express-adapter.js

@@ -45,14 +45,14 @@ export class ExpressAdapter extends HttpAdapter {
             const request = HttpIncoming.from(_req);
             const response = HttpOutgoing.from(_res);
             const ctx = new HttpContext({
-                adapter: this,
+                __adapter: this,
                 platform: this.platform,
                 request,
                 response,
-                controller: args?.controller,
-                controllerInstance: args?.controllerInstance,
-                operation: args?.operation,
-                operationHandler: args?.operationHandler,
+                __contDef: args?.controller,
+                __controller: args?.controllerInstance,
+                __oprDef: args?.operation,
+                __handler: args?.operationHandler,
             });
             await this.emitAsync('createContext', ctx);
             return ctx;

package/esm/http-adapter.js

@@ -7,7 +7,7 @@ import { HttpHandler } from './http-handler.js';
 export class HttpAdapter extends PlatformAdapter {
     constructor(options) {
         super(options);
-        this.protocol = 'http';
+        this.transform = 'http';
         this.handler = new HttpHandler(this);
         this.interceptors = [...(options?.interceptors || [])];
         this.basePath = options?.basePath || '/';
@@ -16,6 +16,6 @@ export class HttpAdapter extends PlatformAdapter {
         this.scope = options?.scope;
     }
     get api() {
-        return this.document.httpApi;
+        return this.document.getHttpApi();
     }
 }

package/esm/http-context.js

@@ -1,26 +1,25 @@
 import typeIs from '@browsery/type-is';
 import { InternalServerError, NotAcceptableError, } from '@opra/common';
 import { ExecutionContext, kAssetCache } from '@opra/core';
-import { vg } from 'valgen';
 import { MultipartReader } from './impl/multipart-reader.js';
 export class HttpContext extends ExecutionContext {
     constructor(init) {
         super({
             ...init,
-            document: init.adapter.document,
-            documentNode: init.controller?.node,
-            protocol: 'http',
+            __docNode: init.__oprDef?.node ||
+                init.__contDef?.node ||
+                init.__adapter.document.node,
+            transport: 'http',
         });
-        this.adapter = init.adapter;
-        this.protocol = 'http';
-        if (init.controller)
-            this.controller = init.controller;
-        if (init.controllerInstance)
-            this.controllerInstance = init.controllerInstance;
-        if (init.operation)
-            this.operation = init.operation;
-        if (init.operationHandler)
-            this.operationHandler = init.operationHandler;
+        this.errors = [];
+        if (init.__contDef)
+            this.__contDef = init.__contDef;
+        if (init.__controller)
+            this.__controller = init.__controller;
+        if (init.__oprDef)
+            this.__oprDef = init.__oprDef;
+        if (init.__handler)
+            this.__handler = init.__handler;
         this.request = init.request;
         this.response = init.response;
         this.mediaType = init.mediaType;
@@ -65,7 +64,7 @@ export class HttpContext extends ExecutionContext {
     async getBody() {
         if (this._body !== undefined)
             return this._body;
-        const { request, operation, mediaType } = this;
+        const { request, __oprDef, mediaType } = this;
         if (this.isMultipart) {
             const reader = await this.getMultipartReader();
             /** Retrieve all fields */
@@ -75,7 +74,7 @@ export class HttpContext extends ExecutionContext {
             return this._body;
         }
         this._body = await this.request.readBody({
-            limit: operation?.requestBody?.maxContentSize,
+            limit: __oprDef?.requestBody?.maxContentSize,
         });
         if (this._body != null) {
             // Convert Buffer to string if media is text
@@ -90,18 +89,17 @@ export class HttpContext extends ExecutionContext {
         if (mediaType) {
             // Decode/Validate the data object according to data model
             if (this._body && mediaType.type) {
-                let decode = this.adapter[kAssetCache].get(mediaType, 'decode');
+                let decode = this.__adapter[kAssetCache].get(mediaType, 'decode');
                 if (!decode) {
-                    decode =
-                        mediaType.type?.generateCodec('decode', {
-                            scope: this.adapter.scope,
-                            partial: operation?.requestBody?.partial,
-                            projection: '*',
-                            ignoreReadonlyFields: true,
-                            allowPatchOperators: operation?.requestBody?.allowPatchOperators,
-                            keepKeyFields: operation?.requestBody?.keepKeyFields,
-                        }) || vg.isAny();
-                    this.adapter[kAssetCache].set(mediaType, 'decode', decode);
+                    decode = mediaType.generateCodec('decode', {
+                        scope: this.__adapter.scope,
+                        partial: __oprDef?.requestBody?.partial,
+                        projection: '*',
+                        ignoreReadonlyFields: true,
+                        allowPatchOperators: __oprDef?.requestBody?.allowPatchOperators,
+                        keepKeyFields: __oprDef?.requestBody?.keepKeyFields,
+                    });
+                    this.__adapter[kAssetCache].set(mediaType, 'decode', decode);
                 }
                 this._body = decode(this._body);
             }

package/esm/http-handler.js

@@ -91,11 +91,11 @@ export class HttpHandler {
     async parseRequest(context) {
         await this._parseParameters(context);
         await this._parseContentType(context);
-        if (context.operation?.requestBody?.immediateFetch)
+        if (context.__oprDef?.requestBody?.immediateFetch)
             await context.getBody();
         /** Set default status code as the first status code between 200 and 299 */
-        if (context.operation) {
-            for (const r of context.operation.responses) {
+        if (context.__oprDef) {
+            for (const r of context.__oprDef.responses) {
                 const st = r.statusCode.find(sc => sc.start <= 299 && sc.end >= 200);
                 if (st) {
                     context.response.status(st.start);
@@ -110,8 +110,8 @@ export class HttpHandler {
      * @protected
      */
     async _parseParameters(context) {
-        const { operation, request } = context;
-        if (!operation)
+        const { __oprDef, request } = context;
+        if (!__oprDef)
             return;
         let key = '';
         try {
@@ -123,24 +123,23 @@ export class HttpHandler {
             const getDecoder = (prm) => {
                 let decode = this[kAssetCache].get(prm, 'decode');
                 if (!decode) {
-                    decode =
-                        prm.type?.generateCodec('decode', {
-                            scope: this.adapter.scope,
-                            ignoreReadonlyFields: true,
-                        }) || vg.isAny();
+                    decode = prm.generateCodec('decode', {
+                        scope: this.adapter.scope,
+                        ignoreReadonlyFields: true,
+                    });
                     this[kAssetCache].set(prm, 'decode', decode);
                 }
                 return decode;
             };
             const paramsLeft = new Set([
-                ...operation.parameters,
-                ...operation.owner.parameters,
+                ...__oprDef.parameters,
+                ...__oprDef.owner.parameters,
             ]);
             /** parse cookie parameters */
             if (request.cookies) {
                 for (key of Object.keys(request.cookies)) {
-                    const oprPrm = operation.findParameter(key, 'cookie');
-                    const cntPrm = operation.owner.findParameter(key, 'cookie');
+                    const oprPrm = __oprDef.findParameter(key, 'cookie');
+                    const cntPrm = __oprDef.owner.findParameter(key, 'cookie');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -162,8 +161,8 @@ export class HttpHandler {
             /** parse headers */
             if (request.headers) {
                 for (key of Object.keys(request.headers)) {
-                    const oprPrm = operation.findParameter(key, 'header');
-                    const cntPrm = operation.owner.findParameter(key, 'header');
+                    const oprPrm = __oprDef.findParameter(key, 'header');
+                    const cntPrm = __oprDef.owner.findParameter(key, 'header');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -185,8 +184,8 @@ export class HttpHandler {
             /** parse path parameters */
             if (request.params) {
                 for (key of Object.keys(request.params)) {
-                    const oprPrm = operation.findParameter(key, 'path');
-                    const cntPrm = operation.owner.findParameter(key, 'path');
+                    const oprPrm = __oprDef.findParameter(key, 'path');
+                    const cntPrm = __oprDef.owner.findParameter(key, 'path');
                     const prm = oprPrm || cntPrm;
                     if (!prm)
                         continue;
@@ -208,8 +207,8 @@ export class HttpHandler {
             const url = new URL(request.originalUrl || request.url || '/', 'http://tempuri.org');
             const { searchParams } = url;
             for (key of searchParams.keys()) {
-                const oprPrm = operation.findParameter(key, 'query');
-                const cntPrm = operation.owner.findParameter(key, 'query');
+                const oprPrm = __oprDef.findParameter(key, 'query');
+                const cntPrm = __oprDef.owner.findParameter(key, 'query');
                 const prm = oprPrm || cntPrm;
                 if (!prm)
                     continue;
@@ -267,19 +266,19 @@ export class HttpHandler {
      * @protected
      */
     async _parseContentType(context) {
-        const { request, operation } = context;
-        if (!operation)
+        const { request, __oprDef } = context;
+        if (!__oprDef)
             return;
-        if (operation.requestBody?.content.length) {
+        if (__oprDef.requestBody?.content.length) {
             let mediaType;
             let contentType = request.header('content-type');
             if (contentType) {
                 contentType = parseContentType(contentType).type;
-                mediaType = operation.requestBody.content.find(mc => mc.contentType &&
+                mediaType = __oprDef.requestBody.content.find(mc => mc.contentType &&
                     typeIs.is(contentType, Array.isArray(mc.contentType) ? mc.contentType : [mc.contentType]));
             }
             if (!mediaType) {
-                const contentTypes = operation.requestBody.content
+                const contentTypes = __oprDef.requestBody.content
                     .map(mc => mc.contentType)
                     .flat();
                 throw new BadRequestError(`Request body should be one of required content types (${contentTypes.join(', ')})`);
@@ -293,9 +292,9 @@ export class HttpHandler {
      * @protected
      */
     async _executeRequest(context) {
-        if (!context.operationHandler)
+        if (!context.__handler)
             throw new MethodNotAllowedError();
-        const responseValue = await context.operationHandler.call(context.controllerInstance, context);
+        const responseValue = await context.__handler.call(context.__controller, context);
         const { response } = context;
         if (!response.writableEnded) {
             await this.sendResponse(context, responseValue).finally(() => {
@@ -422,19 +421,19 @@ export class HttpHandler {
         }
     }
     async _sendErrorResponse(context) {
-        context.errors = this._wrapExceptions(context.errors);
+        let errors = (context.errors = this._wrapExceptions(context.errors));
         try {
             if (context.listenerCount('error')) {
-                await context.emitAsync('error', context.errors[0], context);
-                context.errors = this._wrapExceptions(context.errors);
+                await context.emitAsync('error', errors[0], context);
+                errors = 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);
+                await this.adapter.emitAsync('error', errors[0], context);
+                errors = context.errors = this._wrapExceptions(errors);
             }
             if (this.adapter.logger?.error) {
                 const logger = this.adapter.logger;
-                context.errors.forEach(e => {
+                errors.forEach(e => {
                     if (e.status >= 500 && e.status < 600)
                         logger.error(e);
                 });
@@ -443,7 +442,7 @@ export class HttpHandler {
         catch (e) {
             context.errors = this._wrapExceptions([e, ...context.errors]);
         }
-        const { response, errors } = context;
+        const { response } = context;
         if (response.headersSent) {
             response.end();
             return;
@@ -517,7 +516,7 @@ export class HttpHandler {
      * @protected
      */
     _determineResponseArgs(context, body) {
-        const { response, operation } = context;
+        const { response, __oprDef } = context;
         const hasBody = body != null;
         const statusCode = !hasBody && response.statusCode === HttpStatusCode.OK
             ? HttpStatusCode.NO_CONTENT
@@ -539,12 +538,12 @@ export class HttpHandler {
         let responseArgs = this[kAssetCache].get(response, cacheKey);
         if (!responseArgs) {
             responseArgs = { statusCode, contentType };
-            if (operation?.responses.length) {
+            if (__oprDef?.responses.length) {
                 /** Filter available HttpOperationResponse instances according to status code. */
-                const filteredResponses = operation.responses.filter(r => r.statusCode.find(sc => sc.start <= statusCode && sc.end >= statusCode));
+                const filteredResponses = __oprDef.responses.filter(r => r.statusCode.find(sc => sc.start <= statusCode && sc.end >= statusCode));
                 /** Throw InternalServerError if controller returns non-configured status code */
                 if (!filteredResponses.length && statusCode < 400) {
-                    throw new InternalServerError(`No responses defined for status code ${statusCode} in operation "${operation.name}"`);
+                    throw new InternalServerError(`No responses defined for status code ${statusCode} in operation "${__oprDef.name}"`);
                 }
                 /** We search for content-type in filtered HttpOperationResponse array */
                 if (filteredResponses.length) {
@@ -584,7 +583,7 @@ export class HttpHandler {
             }
             if (!hasBody)
                 delete responseArgs.contentType;
-            if (operation?.composition?.startsWith('Entity.')) {
+            if (__oprDef?.composition?.startsWith('Entity.')) {
                 if (context.queryParams.projection)
                     responseArgs.projection = context.queryParams.projection;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/http",
-  "version": "1.19.7",
+  "version": "1.20.0",
   "description": "Opra Http Server Adapter",
   "author": "Panates",
   "license": "MIT",
@@ -13,21 +13,21 @@
     "base64-stream": "^1.0.0",
     "busboy": "^1.6.0",
     "bytes": "^3.1.2",
-    "content-disposition": "^0.5.4",
+    "content-disposition": "^1.0.1",
     "content-type": "^1.0.5",
-    "cookie": "^1.0.2",
+    "cookie": "^1.1.1",
     "cookie-signature": "^1.2.2",
     "encodeurl": "^2.0.0",
     "expect": "^30.2.0",
     "fast-tokenizer": "^1.7.0",
     "fresh": "^0.5.2",
     "iconv-lite": "^0.7.0",
-    "mime-types": "^3.0.1",
+    "mime-types": "^3.0.2",
     "node-events-async": "^1.2.0",
     "power-tasks": "^1.11.1",
     "putil-varhelpers": "^1.6.5",
     "range-parser": "^1.2.1",
-    "raw-body": "^3.0.1",
+    "raw-body": "^3.0.2",
     "reflect-metadata": "^0.2.2",
     "super-fast-md5": "^1.0.3",
     "tslib": "^2.8.1",
@@ -35,8 +35,8 @@
     "vary": "^1.1.2"
   },
   "peerDependencies": {
-    "@opra/common": "^1.19.7",
-    "@opra/core": "^1.19.7"
+    "@opra/common": "^1.20.0",
+    "@opra/core": "^1.20.0"
   },
   "optionalDependencies": {
     "express": "^4.0.0 || ^5.0.0",

package/types/http-adapter.d.ts

@@ -9,7 +9,7 @@ import { HttpHandler } from './http-handler.js';
  */
 export declare abstract class HttpAdapter<T extends HttpAdapter.Events = HttpAdapter.Events> extends PlatformAdapter<EventMap<T>> {
     readonly handler: HttpHandler;
-    readonly protocol: OpraSchema.Transport;
+    readonly transform: OpraSchema.Transport;
     readonly basePath: string;
     scope?: string;
     interceptors: (HttpAdapter.InterceptorFunction | HttpAdapter.IHttpInterceptor)[];

package/types/http-context.d.ts

@@ -1,35 +1,17 @@
-import { HttpController, HttpMediaType, HttpOperation, OpraHttpError, OpraSchema } from '@opra/common';
+import { HttpController, HttpMediaType, HttpOperation } from '@opra/common';
 import { ExecutionContext } from '@opra/core';
 import type { HttpAdapter } from './http-adapter';
 import { MultipartReader } from './impl/multipart-reader.js';
 import type { HttpIncoming } from './interfaces/http-incoming.interface.js';
 import type { HttpOutgoing } from './interfaces/http-outgoing.interface.js';
-export declare namespace HttpContext {
-    interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'protocol' | 'documentNode'> {
-        adapter: HttpAdapter;
-        request: HttpIncoming;
-        response: HttpOutgoing;
-        controller?: HttpController;
-        controllerInstance?: any;
-        operation?: HttpOperation;
-        operationHandler?: Function;
-        cookies?: Record<string, any>;
-        headers?: Record<string, any>;
-        pathParams?: Record<string, any>;
-        queryParams?: Record<string, any>;
-        mediaType?: HttpMediaType;
-        body?: any;
-    }
-}
 export declare class HttpContext extends ExecutionContext {
     protected _body?: any;
     protected _multipartReader?: MultipartReader;
-    readonly protocol: OpraSchema.Transport;
-    readonly adapter: HttpAdapter;
-    readonly controller?: HttpController;
-    readonly controllerInstance?: any;
-    readonly operation?: HttpOperation;
-    readonly operationHandler?: Function;
+    readonly __contDef: HttpController;
+    readonly __oprDef: HttpOperation;
+    readonly __controller: any;
+    readonly __handler?: Function;
+    readonly __adapter: HttpAdapter;
     readonly request: HttpIncoming;
     readonly response: HttpOutgoing;
     readonly mediaType?: HttpMediaType;
@@ -37,9 +19,26 @@ export declare class HttpContext extends ExecutionContext {
     readonly headers: Record<string, any>;
     readonly pathParams: Record<string, any>;
     readonly queryParams: Record<string, any>;
-    errors: OpraHttpError[];
+    errors: Error[];
     constructor(init: HttpContext.Initiator);
     get isMultipart(): boolean;
     getMultipartReader(): Promise<MultipartReader>;
     getBody<T>(): Promise<T>;
 }
+export declare namespace HttpContext {
+    interface Initiator extends Omit<ExecutionContext.Initiator, '__adapter' | 'transport'> {
+        __adapter: HttpAdapter;
+        __contDef?: HttpController;
+        __oprDef?: HttpOperation;
+        __controller?: any;
+        __handler?: Function;
+        request: HttpIncoming;
+        response: HttpOutgoing;
+        cookies?: Record<string, any>;
+        headers?: Record<string, any>;
+        pathParams?: Record<string, any>;
+        queryParams?: Record<string, any>;
+        mediaType?: HttpMediaType;
+        body?: any;
+    }
+}