@opra/core 0.13.0 → 0.15.0

package/esm/adapter/http/http-adapter.js

@@ -0,0 +1,462 @@
+import { Task } from 'power-tasks';
+import { BadRequestError, Collection, HttpHeaderCodes, HttpStatusCodes, InternalServerError, isReadable, IssueSeverity, MethodNotAllowedError, OpraException, OpraSchema, OpraURL, Singleton, wrapException } from '@opra/common';
+import { OpraAdapter } from '../adapter.js';
+import { HttpRequestHost } from './http-request.host.js';
+import { HttpRequestContextHost } from './http-request-context.host.js';
+import { HttpResponseHost } from './http-response.host.js';
+/**
+ *
+ * @class OpraHttpAdapter
+ */
+export class OpraHttpAdapter extends OpraAdapter {
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    async handler(incoming, outgoing) {
+        try {
+            // Batch
+            if (incoming.is('multipart/mixed')) {
+                throw new BadRequestError({ message: 'Not implemented yet' });
+            }
+            if (!(incoming.method === 'POST' || incoming.method === 'PATCH') || incoming.is('json')) {
+                const request = await this.parseRequest(incoming);
+                const response = new HttpResponseHost({}, outgoing);
+                const context = new HttpRequestContextHost(this.platform, this.api, request, response);
+                const task = new Task(async () => {
+                    try {
+                        await this.executeRequest(context);
+                        if (request.operation === 'search' && request.args.count && response.count != null) {
+                            response.switchToHttp().header(HttpHeaderCodes.X_Opra_Total_Matches, String(response.count));
+                        }
+                    }
+                    catch (error) {
+                        return this.errorHandler(incoming, outgoing, [error]);
+                    }
+                    await this.sendResponse(context);
+                }, {
+                    id: incoming.get('content-id'),
+                    exclusive: request.crud !== 'read'
+                });
+                await task.toPromise().catch(e => {
+                    this.logger?.error?.(e);
+                    outgoing.sendStatus(500);
+                });
+                return;
+            }
+            throw new BadRequestError({ message: 'Unsupported Content-Type' });
+        }
+        catch (error) {
+            await this.errorHandler(incoming, outgoing, [error]);
+        }
+    }
+    async errorHandler(incoming, outgoing, errors) {
+        errors.forEach(e => {
+            this.log((e instanceof OpraException) ? 'error' : 'fatal', incoming, e); // todo. implement a better logger
+        });
+        errors = errors.map(wrapException);
+        let status = outgoing.statusCode || 0;
+        // Sort errors from fatal to info
+        errors.sort((a, b) => {
+            const i = IssueSeverity.Keys.indexOf(a.issue.severity) - IssueSeverity.Keys.indexOf(b.issue.severity);
+            if (i === 0)
+                return b.status - a.status;
+            return i;
+        });
+        if (!status || status < HttpStatusCodes.BAD_REQUEST) {
+            status = errors[0].status;
+            if (status < HttpStatusCodes.BAD_REQUEST)
+                status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
+        }
+        const body = this.i18n.deep({
+            errors: errors.map(e => e.issue)
+        });
+        outgoing.set(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.set(HttpHeaderCodes.Cache_Control, 'no-cache');
+        outgoing.set(HttpHeaderCodes.Pragma, 'no-cache');
+        outgoing.set(HttpHeaderCodes.Expires, '-1');
+        outgoing.set(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+        outgoing.status(status);
+        outgoing.send(JSON.stringify(body));
+        outgoing.end();
+    }
+    log(logType, incoming, message, ...optionalParams) {
+        const logFn = logType === 'fatal'
+            ? this.logger?.fatal || this.logger?.error
+            : this.logger?.[logType];
+        if (!logFn)
+            return;
+        logFn.apply(this.logger, [String(message), ...optionalParams]);
+    }
+    async afterExecuteRequest(context) {
+        await super.afterExecuteRequest(context);
+        const { request } = context;
+        const response = context.response;
+        const { crud } = request;
+        const httpResponse = response.switchToHttp();
+        if (request.resource instanceof Singleton || request.resource instanceof Collection) {
+            httpResponse.set(HttpHeaderCodes.X_Opra_Data_Type, request.resource.type.name);
+            httpResponse.set(HttpHeaderCodes.X_Opra_Operation, request.operation);
+        }
+        if (crud === 'create') {
+            if (!response.value)
+                throw new InternalServerError();
+            // todo validate
+            httpResponse.status(201);
+        }
+    }
+    /**
+     *
+     * @param incoming
+     * @protected
+     */
+    async parseRequest(incoming) {
+        try {
+            const url = new OpraURL();
+            url.searchParams.define({
+                '$pick': { codec: 'string', array: true },
+                '$omit': { codec: 'string', array: true },
+                '$include': { codec: 'string', array: true },
+                '$sort': { codec: 'string', array: true },
+                '$filter': { codec: 'filter' },
+                '$limit': { codec: 'number' },
+                '$skip': { codec: 'number' },
+                '$distinct': { codec: 'boolean' },
+                '$count': { codec: 'boolean' },
+            });
+            url.parse(incoming.url);
+            // const {context, url, method, headers, body, contentId} = args;
+            if (!url.path.size)
+                throw new BadRequestError();
+            const method = incoming.method;
+            if (method !== 'GET' && url.path.size > 1)
+                throw new BadRequestError();
+            // const pathLen = url.path.size;
+            // let pathIndex = 0;
+            const params = url.searchParams;
+            const p = url.path.get(0);
+            const resource = this._internalDoc.getResource(p.resource);
+            // let container: IResourceContainer | undefined;
+            // while (resource && resource instanceof ContainerResourceInfo) {
+            //   container = resource;
+            //   p = url.path.get(++pathIndex);
+            //   resource = container.getResource(p.resource);
+            // }
+            // const headers = incoming.headers;
+            /*
+             * Collection
+             */
+            if (resource instanceof Collection) {
+                switch (method) {
+                    case 'POST': {
+                        if (!p.key) {
+                            return new HttpRequestHost({
+                                kind: 'CollectionCreateRequest',
+                                resource,
+                                operation: 'create',
+                                crud: 'create',
+                                many: false,
+                                args: {
+                                    data: incoming.body,
+                                    pick: resource.normalizeFieldNames(params.get('$pick')),
+                                    omit: resource.normalizeFieldNames(params.get('$omit')),
+                                    include: resource.normalizeFieldNames(params.get('$include'))
+                                }
+                            }, incoming);
+                        }
+                        break;
+                    }
+                    case 'DELETE': {
+                        if (p.key) {
+                            return new HttpRequestHost({
+                                kind: 'CollectionDeleteRequest',
+                                resource,
+                                operation: 'delete',
+                                crud: 'delete',
+                                many: false,
+                                args: {
+                                    key: resource.parseKeyValue(p.key)
+                                }
+                            }, incoming);
+                        }
+                        return new HttpRequestHost({
+                            kind: 'CollectionDeleteManyRequest',
+                            resource,
+                            operation: 'deleteMany',
+                            crud: 'delete',
+                            many: true,
+                            args: {
+                                filter: resource.normalizeFilterFields(params.get('$filter'))
+                            }
+                        }, incoming);
+                    }
+                    case 'GET': {
+                        if (p.key) {
+                            return new HttpRequestHost({
+                                kind: 'CollectionGetRequest',
+                                resource,
+                                operation: 'get',
+                                crud: 'read',
+                                many: false,
+                                args: {
+                                    key: resource.parseKeyValue(p.key),
+                                    pick: resource.normalizeFieldNames(params.get('$pick')),
+                                    omit: resource.normalizeFieldNames(params.get('$omit')),
+                                    include: resource.normalizeFieldNames(params.get('$include'))
+                                }
+                            }, incoming);
+                        }
+                        return new HttpRequestHost({
+                            kind: 'CollectionSearchRequest',
+                            resource,
+                            operation: 'search',
+                            crud: 'read',
+                            many: true,
+                            args: {
+                                sort: resource.normalizeSortFields(params.get('$sort')),
+                                pick: resource.normalizeFieldNames(params.get('$pick')),
+                                omit: resource.normalizeFieldNames(params.get('$omit')),
+                                include: resource.normalizeFieldNames(params.get('$include')),
+                                filter: resource.normalizeFilterFields(params.get('$filter')),
+                                limit: params.get('$limit'),
+                                skip: params.get('$skip'),
+                                distinct: params.get('$distinct'),
+                                count: params.get('$count'),
+                            }
+                        }, incoming);
+                    }
+                    case 'PATCH': {
+                        if (p.key) {
+                            return new HttpRequestHost({
+                                kind: 'CollectionUpdateRequest',
+                                resource,
+                                operation: 'update',
+                                crud: 'update',
+                                many: false,
+                                args: {
+                                    key: resource.parseKeyValue(p.key),
+                                    data: incoming.body,
+                                    pick: resource.normalizeFieldNames(params.get('$pick')),
+                                    omit: resource.normalizeFieldNames(params.get('$omit')),
+                                    include: resource.normalizeFieldNames(params.get('$include'))
+                                }
+                            }, incoming);
+                        }
+                        return new HttpRequestHost({
+                            kind: 'CollectionUpdateManyRequest',
+                            resource,
+                            operation: 'updateMany',
+                            crud: 'update',
+                            many: true,
+                            args: {
+                                data: incoming.body,
+                                filter: resource.normalizeFilterFields(params.get('$filter'))
+                            }
+                        }, incoming);
+                    }
+                }
+            }
+            else 
+            /*
+             * Singleton
+             */
+            if (resource instanceof Singleton && !p.key) {
+                switch (method) {
+                    case 'POST': {
+                        return new HttpRequestHost({
+                            kind: 'SingletonCreateRequest',
+                            resource,
+                            operation: 'create',
+                            crud: 'create',
+                            many: false,
+                            args: {
+                                data: incoming.body,
+                                pick: resource.normalizeFieldNames(params.get('$pick')),
+                                omit: resource.normalizeFieldNames(params.get('$omit')),
+                                include: resource.normalizeFieldNames(params.get('$include'))
+                            }
+                        }, incoming);
+                    }
+                    case 'DELETE': {
+                        return new HttpRequestHost({
+                            kind: 'SingletonDeleteRequest',
+                            resource,
+                            operation: 'delete',
+                            crud: 'delete',
+                            many: false,
+                            args: {}
+                        }, incoming);
+                    }
+                    case 'GET': {
+                        return new HttpRequestHost({
+                            kind: 'SingletonGetRequest',
+                            resource,
+                            operation: 'get',
+                            crud: 'read',
+                            many: false,
+                            args: {
+                                pick: resource.normalizeFieldNames(params.get('$pick')),
+                                omit: resource.normalizeFieldNames(params.get('$omit')),
+                                include: resource.normalizeFieldNames(params.get('$include'))
+                            }
+                        }, incoming);
+                    }
+                    case 'PATCH': {
+                        return new HttpRequestHost({
+                            kind: 'SingletonUpdateRequest',
+                            resource,
+                            operation: 'update',
+                            crud: 'update',
+                            many: false,
+                            args: {
+                                data: incoming.body,
+                                pick: resource.normalizeFieldNames(params.get('$pick')),
+                                omit: resource.normalizeFieldNames(params.get('$omit')),
+                                include: resource.normalizeFieldNames(params.get('$include'))
+                            }
+                        }, incoming);
+                    }
+                }
+            }
+            else
+                throw new InternalServerError();
+            // if (query instanceof SingletonGetQuery || query instanceof CollectionGetQuery || query instanceof ElementReadQuery) {
+            //   // Move through properties
+            //   let parentType: DataType;
+            //   const curPath: string[] = [];
+            //   let parent: SingletonGetQuery | CollectionGetQuery | ElementReadQuery = query;
+            //   while (++pathIndex < pathLen) {
+            //     p = url.path.get(pathIndex);
+            //     parentType = parent.type;
+            //     if (parent.type instanceof UnionType) {
+            //       if (parent.type.name === 'any')
+            //         parentType = this.document.getComplexType('object');
+            //       else
+            //         throw new TypeError(`"${resource.name}.${curPath.join()}" is a UnionType and needs type casting.`);
+            //     }
+            //     if (!(parentType instanceof ComplexType))
+            //       throw new TypeError(`"${resource.name}.${curPath.join()}" is not a ComplexType and has no fields.`);
+            //     curPath.push(p.resource);
+            //     parent.child = new ElementReadQuery(parent, p.resource, {castingType: parentType});
+            //     parent = parent.child;
+            //   }
+            // }
+            throw new MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target endpoint`
+            });
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            throw new BadRequestError(e);
+        }
+    }
+    // async parseMultiPart(
+    //     context: TExecutionContext,
+    //     url: OpraURL,
+    //     headers: IncomingHttpHeaders,
+    //     input: Readable,
+    //     boundary: string
+    // ): Promise<BatchRequestContext> {
+    //   return await new Promise((resolve, reject) => {
+    //     let _resolved = false;
+    //     const dicer = new Dicer({boundary});
+    //     const doReject = (e) => {
+    //       if (_resolved) return;
+    //       _resolved = true;
+    //       reject(e);
+    //       taskQueue.clearQueue();
+    //       dicer.destroy();
+    //     }
+    //     const taskQueue = new TaskQueue({concurrency: 1});
+    //     taskQueue.on('error', doReject);
+    //
+    //     const queries: SingleRequestContext[] = [];
+    //     let partCounter = 0;
+    //     dicer.on('error', doReject);
+    //     dicer.on('part', part => {
+    //       const partIndex = partCounter++;
+    //       let header: any;
+    //       const chunks: Buffer[] = [];
+    //       part.on('error', doReject);
+    //       part.on('header', (_header) => header = normalizeHeaders(_header));
+    //       part.on('data', (chunk: Buffer) => chunks.push(chunk));
+    //       part.on('end', () => {
+    //         if (_resolved || !(header || chunks.length))
+    //           return;
+    //         const ct = header['content-type'];
+    //         if (ct === 'application/http') {
+    //           taskQueue.enqueue(async () => {
+    //             const data = Buffer.concat(chunks);
+    //             if (!(data && data.length))
+    //               return;
+    //             const r = HttpRequest.parse(data);
+    //             await callMiddlewares(r, [jsonBodyParser]);
+    //             const subUrl = new OpraURL(r.url);
+    //             const contentId = header && header['content-id'];
+    //             queries.push(this.parseSingleQuery({
+    //               context,
+    //               url: subUrl,
+    //               method: r.method,
+    //               headers: r.headers,
+    //               body: r.body,
+    //               contentId
+    //             }));
+    //           });
+    //         } else doReject(new BadRequestError({
+    //           message: 'Unaccepted "content-type" header in multipart data',
+    //           details: {
+    //             position: `${boundary}[${partIndex}]`
+    //           }
+    //         }))
+    //       });
+    //     });
+    //     dicer.on('finish', () => {
+    //       taskQueue.enqueue(() => {
+    //         if (_resolved) return;
+    //         _resolved = true;
+    //         const batch = new BatchRequestContext({
+    //           service: this.document,
+    //           context,
+    //           headers,
+    //           queries,
+    //           params: url.searchParams,
+    //           continueOnError: false
+    //         });
+    //         resolve(batch);
+    //       });
+    //     });
+    //     input.pipe(dicer);
+    //   });
+    // }
+    async sendResponse(context) {
+        const { request, response } = context;
+        const outgoing = response.switchToHttp();
+        const errors = response.errors?.map(e => wrapException(e));
+        if (errors && errors.length) {
+            await this.errorHandler(request.switchToHttp(), outgoing, errors);
+            return;
+        }
+        outgoing.set(HttpHeaderCodes.Cache_Control, 'no-cache');
+        outgoing.set(HttpHeaderCodes.Pragma, 'no-cache');
+        outgoing.set(HttpHeaderCodes.Expires, '-1');
+        outgoing.set(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
+        outgoing.status(outgoing.statusCode || HttpStatusCodes.OK);
+        if (response.value) {
+            if (typeof response.value === 'object') {
+                if (isReadable(response.value) || Buffer.isBuffer(response.value))
+                    outgoing.send(response.value);
+                else {
+                    const body = this.i18n.deep(response.value);
+                    outgoing.set(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+                    outgoing.send(JSON.stringify(body));
+                }
+            }
+            else
+                outgoing.send(JSON.stringify(response.value));
+        }
+        outgoing.end();
+    }
+}

package/esm/adapter/http/http-request-context.host.d.ts

@@ -0,0 +1,16 @@
+import { ApiDocument } from '@opra/common';
+import { Request } from '../interfaces/request.interface.js';
+import { HttpRequestContext, RpcRequestContext, WsRequestContext } from '../interfaces/request-context.interface.js';
+import { Response } from '../interfaces/response.interface.js';
+import { RequestContextHost } from '../request-context.host.js';
+export declare class HttpRequestContextHost extends RequestContextHost {
+    readonly platform: string;
+    readonly api: ApiDocument;
+    protected _request: Request;
+    protected _response: Response;
+    user?: any;
+    constructor(platform: string, api: ApiDocument, _request: Request, _response: Response);
+    switchToHttp(): HttpRequestContext;
+    switchToWs(): WsRequestContext;
+    switchToRpc(): RpcRequestContext;
+}

package/esm/adapter/http/http-request-context.host.js

@@ -0,0 +1,24 @@
+import { RequestContextHost } from '../request-context.host.js';
+export class HttpRequestContextHost extends RequestContextHost {
+    constructor(platform, api, _request, _response) {
+        super('http', platform, api, _request, _response);
+        this.platform = platform;
+        this.api = api;
+        this._request = _request;
+        this._response = _response;
+    }
+    switchToHttp() {
+        const obj = {
+            request: this._request.switchToHttp(),
+            response: this._response.switchToHttp()
+        };
+        Object.setPrototypeOf(obj, this);
+        return obj;
+    }
+    switchToWs() {
+        throw new TypeError('Not executing in an "WebSocket" protocol');
+    }
+    switchToRpc() {
+        throw new TypeError('Not executing in an "RPC" protocol');
+    }
+}

package/esm/adapter/http/http-request.host.d.ts

@@ -0,0 +1,7 @@
+import { HttpRequestMessage } from '@opra/common';
+import { RequestHost } from '../request.host.js';
+export declare class HttpRequestHost extends RequestHost {
+    protected _incoming: HttpRequestMessage;
+    constructor(init: RequestHost.Initiator, _incoming: HttpRequestMessage);
+    switchToHttp(): HttpRequestMessage;
+}

package/esm/adapter/http/http-request.host.js

@@ -0,0 +1,10 @@
+import { RequestHost } from '../request.host.js';
+export class HttpRequestHost extends RequestHost {
+    constructor(init, _incoming) {
+        super(init);
+        this._incoming = _incoming;
+    }
+    switchToHttp() {
+        return this._incoming;
+    }
+}

package/esm/adapter/http/http-response.host.d.ts

@@ -0,0 +1,7 @@
+import { HttpResponseMessage } from '@opra/common';
+import { ResponseHost } from '../response.host.js';
+export declare class HttpResponseHost extends ResponseHost {
+    protected _outgoing: HttpResponseMessage;
+    constructor(init: ResponseHost.Initiator, _outgoing: HttpResponseMessage);
+    switchToHttp(): HttpResponseMessage;
+}

package/esm/adapter/http/http-response.host.js

@@ -0,0 +1,10 @@
+import { ResponseHost } from '../response.host.js';
+export class HttpResponseHost extends ResponseHost {
+    constructor(init, _outgoing) {
+        super(init);
+        this._outgoing = _outgoing;
+    }
+    switchToHttp() {
+        return this._outgoing;
+    }
+}

package/esm/{interfaces → adapter/interfaces}/logger.interface.d.ts

@@ -1,6 +1,7 @@
 export interface ILogger {
     log(message: any, ...optionalParams: any[]): any;
     error(message: any, ...optionalParams: any[]): any;
+    fatal?(message: any, ...optionalParams: any[]): any;
     warn(message: any, ...optionalParams: any[]): any;
     debug?(message: any, ...optionalParams: any[]): any;
     verbose?(message: any, ...optionalParams: any[]): any;

package/esm/adapter/interfaces/request-context.interface.d.ts

@@ -0,0 +1,25 @@
+import { ApiDocument, HttpRequestMessage, HttpResponseMessage } from '@opra/common';
+import { Request } from './request.interface.js';
+import { Response } from './response.interface.js';
+export declare namespace RequestContext {
+    type Protocol = 'http' | 'ws' | 'rpc';
+}
+export interface RequestContext {
+    readonly protocol: RequestContext.Protocol;
+    readonly platform: string;
+    readonly api: ApiDocument;
+    readonly request: Request;
+    readonly response: Response;
+    user?: any;
+    switchToHttp(): HttpRequestContext;
+    switchToWs(): WsRequestContext;
+    switchToRpc(): RpcRequestContext;
+}
+export interface HttpRequestContext extends Omit<RequestContext, 'request' | 'response'> {
+    readonly request: HttpRequestMessage;
+    readonly response: HttpResponseMessage;
+}
+export interface WsRequestContext extends Omit<RequestContext, 'request' | 'response'> {
+}
+export interface RpcRequestContext extends Omit<RequestContext, 'request' | 'response'> {
+}

package/esm/adapter/interfaces/request.interface.d.ts

@@ -0,0 +1,13 @@
+import { HttpRequestMessage, OpraSchema, Resource } from '@opra/common';
+export interface Request {
+    readonly kind: string;
+    readonly resource: Resource;
+    readonly resourceKind: OpraSchema.Resource.Kind;
+    readonly operation: string;
+    readonly crud: 'create' | 'read' | 'update' | 'delete';
+    readonly many: boolean;
+    readonly args: any;
+    switchToHttp(): HttpRequestMessage;
+    switchToWs(): never;
+    switchToRpc(): never;
+}

package/esm/adapter/interfaces/response.interface.d.ts

@@ -0,0 +1,22 @@
+import { HttpResponseMessage } from '@opra/common';
+export interface Response {
+    /**
+     * Result value
+     */
+    value?: any;
+    /**
+     * List of errors
+     */
+    errors: Error[];
+    /**
+     *
+     */
+    continueOnError?: boolean;
+    /**
+     * Total count of matched entities. (Used in "search" operation with "count" option
+     */
+    count?: number;
+    switchToHttp(): HttpResponseMessage;
+    switchToWs(): never;
+    switchToRpc(): never;
+}

package/esm/adapter/internal/metadata.resource.d.ts

@@ -0,0 +1,7 @@
+import { ApiDocument } from '@opra/common';
+export declare class MetadataResource {
+    readonly document: ApiDocument;
+    private _schema;
+    constructor(document: ApiDocument);
+    get(): import("../../build/common/esm/schema/document.interface").ApiDocument;
+}

package/esm/adapter/internal/metadata.resource.js

@@ -0,0 +1,24 @@
+import { __decorate, __metadata } from "tslib";
+import { ApiDocument, cloneObject, Singleton } from '@opra/common';
+let MetadataResource = class MetadataResource {
+    constructor(document) {
+        this.document = document;
+        this._schema = document.exportSchema();
+    }
+    get() {
+        return cloneObject(this.document.exportSchema(), true);
+    }
+};
+__decorate([
+    Singleton.GetOperation(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], MetadataResource.prototype, "get", null);
+MetadataResource = __decorate([
+    Singleton(Object, {
+        name: '$metadata',
+    }),
+    __metadata("design:paramtypes", [ApiDocument])
+], MetadataResource);
+export { MetadataResource };

package/esm/adapter/request-context.host.d.ts

@@ -0,0 +1,19 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { ApiDocument } from '@opra/common';
+import { Request } from './interfaces/request.interface.js';
+import { HttpRequestContext, RequestContext, RpcRequestContext, WsRequestContext } from './interfaces/request-context.interface.js';
+import { Response } from './interfaces/response.interface.js';
+export declare abstract class RequestContextHost extends AsyncEventEmitter implements RequestContext {
+    readonly protocol: RequestContext.Protocol;
+    readonly platform: string;
+    readonly api: ApiDocument;
+    protected _request: Request;
+    protected _response: Response;
+    user?: any;
+    protected constructor(protocol: RequestContext.Protocol, platform: string, api: ApiDocument, _request: Request, _response: Response);
+    get request(): Request;
+    get response(): Response;
+    switchToHttp(): HttpRequestContext;
+    switchToWs(): WsRequestContext;
+    switchToRpc(): RpcRequestContext;
+}