@opra/core 0.0.8 → 0.0.9

package/esm/exception/errors/internal-server.error.d.ts

@@ -4,5 +4,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The server has encountered a situation it does not know how to handle.
  */
 export declare class InternalServerError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/errors/internal-server.error.js

@@ -1,3 +1,4 @@
+import _ from 'lodash';
 import { translate } from '@opra/i18n';
 import { HttpStatus } from '../../enums/index.js';
 import { ApiException } from '../api-exception.js';
@@ -7,12 +8,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class InternalServerError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.INTERNAL_SERVER_ERROR;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
             severity: 'error',
             code: 'INTERNAL_SERVER_ERROR',
-            ...response
-        }, cause);
-        this.status = HttpStatus.INTERNAL_SERVER_ERROR;
+            ..._.omitBy(response, _.isNil)
+        });
     }
 }

package/esm/exception/errors/method-not-allowed.error.d.ts

@@ -5,5 +5,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * For example, an API may not allow calling DELETE to remove a resource.
  */
 export declare class MethodNotAllowedError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/errors/method-not-allowed.error.js

@@ -8,12 +8,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class MethodNotAllowedError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.METHOD_NOT_ALLOWED;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:METHOD_NOT_ALLOWED', 'Method Not Allowed'),
             severity: 'error',
             code: 'METHOD_NOT_ALLOWED',
             ...response
-        }, cause);
-        this.status = HttpStatus.METHOD_NOT_ALLOWED;
+        });
     }
 }

package/esm/exception/errors/not-found.error.d.ts

@@ -8,5 +8,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * frequent occurrence on the web.
  */
 export declare class NotFoundError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/errors/not-found.error.js

@@ -11,12 +11,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class NotFoundError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.NOT_FOUND;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:NOT_FOUND', 'Not found'),
             severity: 'error',
             code: 'NOT_FOUND',
             ...response
-        }, cause);
-        this.status = HttpStatus.NOT_FOUND;
+        });
     }
 }

package/esm/exception/errors/unauthorized.error.d.ts

@@ -5,5 +5,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * That is, the client must authenticate itself to get the requested response.
  */
 export declare class UnauthorizedError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/errors/unauthorized.error.js

@@ -8,12 +8,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class UnauthorizedError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.UNAUTHORIZED;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:UNAUTHORIZED', 'Unauthorized'),
             severity: 'error',
             code: 'UNAUTHORIZED',
             ...response
-        }, cause);
-        this.status = HttpStatus.UNAUTHORIZED;
+        });
     }
 }

package/esm/exception/errors/unprocessable-entity.error.d.ts

@@ -4,5 +4,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The request was well-formed but was unable to be followed due to semantic errors.
  */
 export declare class UnprocessableEntityError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/errors/unprocessable-entity.error.js

@@ -7,12 +7,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class UnprocessableEntityError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.UNPROCESSABLE_ENTITY;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:UNPROCESSABLE_ENTITY', 'Unprocessable entity'),
             severity: 'error',
             code: 'UNPROCESSABLE_ENTITY',
             ...response
-        }, cause);
-        this.status = HttpStatus.UNPROCESSABLE_ENTITY;
+        });
     }
 }

package/esm/exception/wrap-error.js

@@ -7,7 +7,7 @@ export function wrapError(response) {
         const x = response;
         if (typeof x.status === 'number' || typeof x.getStatus === 'function')
             return new ApiException(response);
-        return new InternalServerError(undefined, response);
+        return new InternalServerError(response);
     }
     return new InternalServerError();
 }

package/esm/implementation/adapter/adapter.d.ts

@@ -1,14 +1,21 @@
 import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
 import { ApiException } from '../../exception/index.js';
-import { ExecutionContext, ExecutionRequest } from '../execution-context.js';
+import { IExecutionContext } from '../../interfaces/execution-context.interface.js';
 import { OpraService } from '../opra-service.js';
+import { QueryContext } from '../query-context.js';
 export declare namespace OpraAdapter {
+    type UserContextResolver = (args: {
+        executionContext: IExecutionContext;
+        isBatch: boolean;
+    }) => object | Promise<object>;
+    type RequestFinishEvent = (args: {
+        executionContext: IExecutionContext;
+        userContext?: any;
+        failed: boolean;
+    }) => Promise<void>;
     interface Options {
         i18n?: I18n | I18nOptions | (() => Promise<I18n>);
-        userContext?: (request: any, options: {
-            platform: string;
-            isBatch: boolean;
-        }) => object | Promise<object>;
+        userContext?: UserContextResolver;
     }
     interface I18nOptions {
         /**
@@ -37,17 +44,18 @@ export declare namespace OpraAdapter {
          */
         resourceDirs?: string[];
     }
-    type UserContextResolver = (isBatch: boolean) => any | Promise<any>;
 }
-export declare abstract class OpraAdapter<TAdapterContext = any> {
+export declare abstract class OpraAdapter<TExecutionContext extends IExecutionContext> {
     readonly service: OpraService;
     readonly i18n: I18n;
-    constructor(service: OpraService, i18n?: I18n);
-    protected abstract prepareRequests(adapterContext: TAdapterContext): ExecutionRequest[];
-    protected abstract createExecutionContext(adapterContext: any, request: ExecutionRequest): ExecutionContext;
-    protected abstract sendResponse(adapterContext: TAdapterContext, executionContexts: ExecutionContext[]): Promise<void>;
-    protected abstract sendError(adapterContext: TAdapterContext, error: ApiException): Promise<void>;
-    protected abstract isBatch(adapterContext: TAdapterContext): boolean;
-    protected handler(adapterContext: TAdapterContext, userContextResolver?: OpraAdapter.UserContextResolver): Promise<void>;
+    readonly userContextResolver?: OpraAdapter.UserContextResolver;
+    constructor(service: OpraService, options?: Omit<OpraAdapter.Options, 'i18n'> & {
+        i18n: I18n;
+    });
+    protected abstract prepareRequests(executionContext: TExecutionContext): QueryContext[];
+    protected abstract sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
+    protected abstract sendError(executionContext: TExecutionContext, error: ApiException): Promise<void>;
+    protected abstract isBatch(executionContext: TExecutionContext): boolean;
+    protected handler(executionContext: TExecutionContext): Promise<void>;
     protected static initI18n(options?: OpraAdapter.Options): Promise<I18n>;
 }

package/esm/implementation/adapter/adapter.js

@@ -1,35 +1,35 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
 import { I18n } from '@opra/i18n';
 import { FailedDependencyError } from '../../exception/index.js';
 import { wrapError } from '../../exception/wrap-error.js';
 export class OpraAdapter {
     service;
     i18n;
-    constructor(service, i18n) {
+    userContextResolver;
+    constructor(service, options) {
         this.service = service;
-        this.i18n = i18n || I18n.defaultInstance;
+        this.i18n = options?.i18n || I18n.defaultInstance;
+        this.userContextResolver = options?.userContext;
     }
-    async handler(adapterContext, userContextResolver) {
+    async handler(executionContext) {
         if (!this.i18n.isInitialized)
             await this.i18n.init();
-        const executionContexts = [];
-        let requests;
+        let queryContexts;
         let userContext;
+        let failed = false;
         try {
-            requests = this.prepareRequests(adapterContext);
+            queryContexts = this.prepareRequests(executionContext);
             let stop = false;
             // Read requests can be executed simultaneously, write request should be executed one by one
             let promises;
             let exclusive = false;
-            for (const request of requests) {
-                exclusive = exclusive || request.query.operationType !== 'read';
+            for (const context of queryContexts) {
+                exclusive = exclusive || context.query.operationType !== 'read';
                 // Wait previous read requests before executing update request
                 if (exclusive && promises) {
                     await Promise.allSettled(promises);
                     promises = undefined;
                 }
-                const resource = request.query.resource;
-                const context = this.createExecutionContext(adapterContext, request);
-                executionContexts.push(context);
                 // If previous request in bucket had an error and executed an update
                 // we do not execute next requests
                 if (stop) {
@@ -37,10 +37,14 @@ export class OpraAdapter {
                     continue;
                 }
                 try {
+                    const resource = context.query.resource;
                     const promise = (async () => {
                         await resource.prepare(context);
-                        if (userContextResolver && !userContext)
-                            userContext = userContextResolver(this.isBatch(adapterContext));
+                        if (this.userContextResolver && !userContext)
+                            userContext = this.userContextResolver({
+                                executionContext,
+                                isBatch: this.isBatch(executionContext)
+                            });
                         context.userContext = userContext;
                         await resource.execute(context);
                     })().catch(e => {
@@ -66,22 +70,21 @@ export class OpraAdapter {
             }
             if (promises)
                 await Promise.allSettled(promises);
-            if (userContext && typeof userContext.onRequestFinish === 'function') {
-                try {
-                    const hasError = !!executionContexts.find(ctx => ctx.response.errors?.length);
-                    await userContext.onRequestFinish(hasError);
-                }
-                catch (e) {
-                    await this.sendError(adapterContext, wrapError(e));
-                    return;
-                }
-            }
-            await this.sendResponse(adapterContext, executionContexts);
+            await this.sendResponse(executionContext, queryContexts);
         }
         catch (e) {
+            failed = true;
             const error = wrapError(e);
-            await this.sendError(adapterContext, error);
-            return;
+            await this.sendError(executionContext, error);
+        }
+        finally {
+            if (executionContext instanceof AsyncEventEmitter) {
+                await executionContext
+                    .emitAsyncSerial('finish', {
+                    userContext,
+                    failed
+                }).catch();
+            }
         }
     }
     static async initI18n(options) {

package/esm/implementation/adapter/express-adapter.d.ts

@@ -1,11 +1,11 @@
 import type { Application } from 'express';
-import type { IHttpAdapterContext } from '../../interfaces/http-context.interface.js';
+import type { IHttpExecutionContext } from '../../interfaces/execution-context.interface';
 import type { OpraService } from '../opra-service.js';
 import { OpraHttpAdapter } from './http-adapter.js';
 export declare namespace OpraExpressAdapter {
     interface Options extends OpraHttpAdapter.Options {
     }
 }
-export declare class OpraExpressAdapter extends OpraHttpAdapter<IHttpAdapterContext> {
+export declare class OpraExpressAdapter extends OpraHttpAdapter<IHttpExecutionContext> {
     static init(app: Application, service: OpraService, options?: OpraExpressAdapter.Options): Promise<OpraExpressAdapter>;
 }

package/esm/implementation/adapter/express-adapter.js

@@ -1,25 +1,56 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
 import { normalizePath } from '@opra/url';
 import { OpraHttpAdapter } from './http-adapter.js';
 export class OpraExpressAdapter extends OpraHttpAdapter {
     static async init(app, service, options) {
         const i18n = await this.initI18n(options);
-        const adapter = new OpraExpressAdapter(service, i18n);
+        const adapter = new OpraExpressAdapter(service, {
+            ...options,
+            i18n
+        });
         const prefix = '/' + normalizePath(options?.prefix, true);
-        const userContextResolver = options?.userContext;
         app.use(prefix, (request, response, next) => {
             (async () => {
-                const req = new ExpressRequestWrapper(request);
-                const res = new ExpressResponseWrapper(response);
-                const adapterContext = {
-                    getRequest: () => req,
-                    getResponse: () => res
-                };
-                await adapter.handler(adapterContext, (isBatch) => userContextResolver && userContextResolver(request, { platform: 'express', isBatch }));
+                const executionContext = new ExpressExecutionContext(request, response);
+                await adapter.handler(executionContext);
             })().catch(e => next(e));
         });
         return adapter;
     }
 }
+class ExpressExecutionContext extends AsyncEventEmitter {
+    _request;
+    _response;
+    constructor(request, response) {
+        super();
+        this._request = new ExpressRequestWrapper(request);
+        this._response = new ExpressResponseWrapper(response);
+    }
+    getType() {
+        return 'http';
+    }
+    getPlatform() {
+        return 'express';
+    }
+    switchToHttp() {
+        return this;
+    }
+    getRequest() {
+        return this._request.getInstance();
+    }
+    getResponse() {
+        return this._response.getInstance();
+    }
+    getRequestWrapper() {
+        return this._request;
+    }
+    getResponseWrapper() {
+        return this._response;
+    }
+    onFinish(fn) {
+        this.on('finish', fn);
+    }
+}
 class ExpressRequestWrapper {
     instance;
     constructor(instance) {

package/esm/implementation/adapter/http-adapter.d.ts

@@ -1,9 +1,9 @@
 import { OpraURL } from '@opra/url';
 import { ApiException } from '../../exception/index.js';
-import { ExecutionQuery } from '../../interfaces/execution-query.interface.js';
-import { IHttpAdapterContext } from '../../interfaces/http-context.interface.js';
+import { IHttpExecutionContext } from '../../interfaces/execution-context.interface.js';
+import { OpraQuery } from '../../interfaces/query.interface.js';
 import { HeadersObject } from '../../utils/headers.js';
-import { ExecutionContext, ExecutionRequest } from '../execution-context.js';
+import { QueryContext } from '../query-context.js';
 import { OpraAdapter } from './adapter.js';
 export declare namespace OpraHttpAdapter {
     type Options = OpraAdapter.Options & {
@@ -15,14 +15,13 @@ interface PreparedOutput {
     headers?: Record<string, string>;
     body?: any;
 }
-export declare class OpraHttpAdapter<TAdapterContext extends IHttpAdapterContext> extends OpraAdapter<IHttpAdapterContext> {
-    protected prepareRequests(adapterContext: TAdapterContext): ExecutionRequest[];
-    prepareRequest(adapterContext: any, url: OpraURL, method: string, headers: HeadersObject, body?: any): ExecutionRequest;
-    createExecutionContext(adapterContext: any, request: ExecutionRequest): ExecutionContext;
-    buildQuery(url: OpraURL, method: string, body?: any): ExecutionQuery | undefined;
-    protected sendResponse(adapterContext: TAdapterContext, executionContexts: ExecutionContext[]): Promise<void>;
-    protected isBatch(adapterContext: TAdapterContext): boolean;
-    protected createOutput(ctx: ExecutionContext): PreparedOutput;
-    protected sendError(adapterContext: TAdapterContext, error: ApiException): Promise<void>;
+export declare class OpraHttpAdapter<TExecutionContext extends IHttpExecutionContext> extends OpraAdapter<IHttpExecutionContext> {
+    protected prepareRequests(executionContext: TExecutionContext): QueryContext[];
+    prepareRequest(executionContext: IHttpExecutionContext, url: OpraURL, method: string, headers: HeadersObject, body?: any): QueryContext;
+    buildQuery(url: OpraURL, method: string, body?: any): OpraQuery | undefined;
+    protected sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
+    protected isBatch(executionContext: TExecutionContext): boolean;
+    protected createOutput(ctx: QueryContext): PreparedOutput;
+    protected sendError(executionContext: TExecutionContext, error: ApiException): Promise<void>;
 }
 export {};

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

@@ -3,26 +3,26 @@ import { OpraVersion } from '../../constants.js';
 import { HttpHeaders, HttpStatus } from '../../enums/index.js';
 import { ApiException, BadRequestError, InternalServerError, MethodNotAllowedError, NotFoundError, } from '../../exception/index.js';
 import { wrapError } from '../../exception/wrap-error.js';
-import { ExecutionQuery } from '../../interfaces/execution-query.interface.js';
+import { OpraQuery } from '../../interfaces/query.interface.js';
 import { Headers } from '../../utils/headers.js';
 import { ComplexType } from '../data-type/complex-type.js';
-import { ExecutionContext, ExecutionRequest, ExecutionResponse } from '../execution-context.js';
+import { QueryContext } from '../query-context.js';
 import { ContainerResourceHandler } from '../resource/container-resource-handler.js';
 import { EntityResourceHandler } from '../resource/entity-resource-handler.js';
 import { OpraAdapter } from './adapter.js';
 export class OpraHttpAdapter extends OpraAdapter {
-    prepareRequests(adapterContext) {
-        const req = adapterContext.getRequest();
+    prepareRequests(executionContext) {
+        const req = executionContext.getRequestWrapper();
         // todo implement batch requests
-        if (this.isBatch(adapterContext)) {
+        if (this.isBatch(executionContext)) {
             throw new Error('not implemented yet');
         }
         const url = new OpraURL(req.getUrl());
         return [
-            this.prepareRequest(adapterContext, url, req.getMethod(), Headers.from(req.getHeaders()), req.getBody())
+            this.prepareRequest(executionContext, url, req.getMethod(), Headers.from(req.getHeaders()), req.getBody())
         ];
     }
-    prepareRequest(adapterContext, url, method, headers, body) {
+    prepareRequest(executionContext, url, method, headers, body) {
         if (!url.path.size)
             throw new BadRequestError();
         if (method !== 'GET' && url.path.size > 1)
@@ -32,20 +32,13 @@ export class OpraHttpAdapter extends OpraAdapter {
             throw new MethodNotAllowedError({
                 message: `Method "${method}" is not allowed by target resource`
             });
-        return new ExecutionRequest({
+        return new QueryContext({
+            service: this.service,
+            executionContext,
             query,
             headers,
             params: url.searchParams,
-        });
-    }
-    createExecutionContext(adapterContext, request) {
-        return new ExecutionContext({
-            type: 'http',
-            service: this.service,
-            request,
-            response: new ExecutionResponse(),
-            adapterContext,
-            continueOnError: request.query.operationType === 'read'
+            continueOnError: query.operationType === 'read'
         });
     }
     buildQuery(url, method, body) {
@@ -70,7 +63,7 @@ export class OpraHttpAdapter extends OpraAdapter {
                         switch (method) {
                             case 'GET': {
                                 if (scope === 'collection') {
-                                    query = ExecutionQuery.forSearch(resource, {
+                                    query = OpraQuery.forSearch(resource, {
                                         filter: url.searchParams.get('$filter'),
                                         limit: url.searchParams.get('$limit'),
                                         skip: url.searchParams.get('$skip'),
@@ -83,7 +76,7 @@ export class OpraHttpAdapter extends OpraAdapter {
                                     });
                                 }
                                 else {
-                                    query = ExecutionQuery.forGet(resource, p.key, {
+                                    query = OpraQuery.forGet(resource, p.key, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -102,7 +95,7 @@ export class OpraHttpAdapter extends OpraAdapter {
                                         const prop = dataType.properties?.[p.resource];
                                         if (!prop)
                                             throw new NotFoundError({ message: `Invalid or unknown resource path (${path})` });
-                                        const q = ExecutionQuery.forGetProperty(prop);
+                                        const q = OpraQuery.forGetProperty(prop);
                                         if (nested) {
                                             nested.nested = q;
                                         }
@@ -116,18 +109,18 @@ export class OpraHttpAdapter extends OpraAdapter {
                             }
                             case 'DELETE': {
                                 if (scope === 'collection') {
-                                    query = ExecutionQuery.forDeleteMany(resource, {
+                                    query = OpraQuery.forDeleteMany(resource, {
                                         filter: url.searchParams.get('$filter'),
                                     });
                                 }
                                 else {
-                                    query = ExecutionQuery.forDelete(resource, p.key);
+                                    query = OpraQuery.forDelete(resource, p.key);
                                 }
                                 break;
                             }
                             case 'POST': {
                                 if (scope === 'collection') {
-                                    query = ExecutionQuery.forCreate(resource, body, {
+                                    query = OpraQuery.forCreate(resource, body, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -137,12 +130,12 @@ export class OpraHttpAdapter extends OpraAdapter {
                             }
                             case 'PATCH': {
                                 if (scope === 'collection') {
-                                    query = ExecutionQuery.forUpdateMany(resource, body, {
+                                    query = OpraQuery.forUpdateMany(resource, body, {
                                         filter: url.searchParams.get('$filter')
                                     });
                                 }
                                 else {
-                                    query = ExecutionQuery.forUpdate(resource, p.key, body, {
+                                    query = OpraQuery.forUpdate(resource, p.key, body, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -163,13 +156,13 @@ export class OpraHttpAdapter extends OpraAdapter {
             throw new BadRequestError({ message: e.message });
         }
     }
-    async sendResponse(adapterContext, executionContexts) {
+    async sendResponse(executionContext, queryContexts) {
         const outputPackets = [];
-        for (const ctx of executionContexts) {
+        for (const ctx of queryContexts) {
             const v = this.createOutput(ctx);
             outputPackets.push(v);
         }
-        if (this.isBatch(adapterContext)) {
+        if (this.isBatch(executionContext)) {
             // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
             return;
         }
@@ -183,7 +176,7 @@ export class OpraHttpAdapter extends OpraAdapter {
             });
         }
         const out = outputPackets[0];
-        const resp = adapterContext.getResponse();
+        const resp = executionContext.getResponseWrapper();
         resp.setStatus(out.status);
         resp.setHeader(HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
@@ -198,11 +191,11 @@ export class OpraHttpAdapter extends OpraAdapter {
         resp.send(JSON.stringify(out.body));
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBatch(adapterContext) {
+    isBatch(executionContext) {
         return false;
     }
     createOutput(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         let status = ctx.response.status;
         let body = ctx.response.value || {};
         const errors = ctx.response.errors?.map(e => wrapError(e));
@@ -228,8 +221,8 @@ export class OpraHttpAdapter extends OpraAdapter {
             body
         };
     }
-    async sendError(adapterContext, error) {
-        const resp = adapterContext.getResponse();
+    async sendError(executionContext, error) {
+        const resp = executionContext.getResponseWrapper();
         resp.setStatus(error.status || 500);
         resp.setHeader(HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');

package/esm/implementation/query-context.d.ts

@@ -0,0 +1,32 @@
+import { SearchParams } from '@opra/url';
+import { HttpStatus } from '../enums/index.js';
+import { ApiException } from '../exception/index.js';
+import { ContextType, IExecutionContext, IHttpExecutionContext } from '../interfaces/execution-context.interface.js';
+import { OpraQuery } from '../interfaces/query.interface.js';
+import { HeadersObject } from '../utils/headers.js';
+import { OpraService } from './opra-service.js';
+export declare type QueryContextArgs = Pick<QueryContext, 'service' | 'executionContext' | 'query' | 'params' | 'headers' | 'userContext' | 'parentValue' | 'continueOnError'>;
+export declare class QueryContext {
+    readonly service: OpraService;
+    readonly executionContext: IExecutionContext;
+    readonly query: OpraQuery;
+    readonly params: SearchParams;
+    readonly headers: HeadersObject;
+    readonly parentValue?: any;
+    readonly resultPath: string;
+    readonly response: QueryResponse;
+    userContext?: any;
+    continueOnError?: boolean;
+    constructor(args: QueryContextArgs);
+    get type(): ContextType;
+    switchToHttp(): IHttpExecutionContext;
+}
+export declare type QueryResponseArgs = Pick<QueryResponse, 'status' | 'value' | 'total'>;
+export declare class QueryResponse {
+    headers: HeadersObject;
+    errors: ApiException[];
+    status?: HttpStatus;
+    value?: any;
+    total?: number;
+    constructor(args?: QueryResponseArgs);
+}