@opra/core 0.0.8 → 0.0.11

package/esm/implementation/adapter/adapter.js

@@ -1,35 +1,36 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
 import { I18n } from '@opra/i18n';
 import { FailedDependencyError } from '../../exception/index.js';
 import { wrapError } from '../../exception/wrap-error.js';
+import { createI18n } from '../../utils/create-i18n.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.operation !== '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 +38,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 +71,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) {
@@ -89,8 +93,6 @@ export class OpraAdapter {
             return options.i18n;
         if (typeof options?.i18n === 'function')
             return options.i18n();
-        const instance = I18n.createInstance(options?.i18n);
-        await instance.init();
-        return instance;
+        return createI18n(options?.i18n);
     }
 }

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.operation === '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));
@@ -219,7 +212,7 @@ export class OpraHttpAdapter extends OpraAdapter {
         }
         else {
             delete body.errors;
-            status = status || (query.operationType === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
+            status = status || (query.operation === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
         }
         body = this.i18n.deep(body);
         return {
@@ -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);
+}

package/esm/implementation/{execution-context.js → query-context.js}

@@ -1,36 +1,33 @@
 import { OpraURLSearchParams } from '@opra/url';
 import { Headers } from '../utils/headers.js';
-export class ExecutionContext {
-    type;
+export class QueryContext {
     service;
-    request;
-    response;
-    adapterContext;
-    userContext;
-    continueOnError;
-    constructor(args) {
-        Object.assign(this, args);
-    }
-    switchToHttp() {
-        if (this.type !== 'http')
-            throw new Error(`You can't access http context within an ${this.type} context`);
-        return this.adapterContext;
-    }
-}
-export class ExecutionRequest {
+    executionContext;
     query;
     params;
     headers;
     parentValue;
     resultPath;
+    response;
+    userContext;
+    continueOnError;
     constructor(args) {
         Object.assign(this, args);
+        this.response = new QueryResponse();
         this.params = this.params || new OpraURLSearchParams();
         this.headers = this.headers || Headers.create();
         this.resultPath = this.resultPath || '';
     }
+    get type() {
+        return this.executionContext.getType();
+    }
+    switchToHttp() {
+        if (this.type !== 'http')
+            throw new Error(`You can't access http context within an ${this.type} context`);
+        return this.executionContext;
+    }
 }
-export class ExecutionResponse {
+export class QueryResponse {
     headers = Headers.create();
     errors = [];
     status;

package/esm/implementation/resource/container-resource-handler.d.ts

@@ -1,7 +1,7 @@
 import { StrictOmit } from 'ts-gems';
 import { OpraSchema } from '@opra/schema';
 import { IResourceContainer } from '../../interfaces/resource-container.interface.js';
-import { ExecutionContext } from '../execution-context.js';
+import { QueryContext } from '../query-context.js';
 import { EntityResourceHandler } from './entity-resource-handler.js';
 import { ResourceHandler } from './resource-handler.js';
 export declare type ContainerResourceControllerArgs = StrictOmit<OpraSchema.ContainerResource, 'kind'> & {};
@@ -10,5 +10,5 @@ export declare class ContainerResourceHandler extends ResourceHandler implements
     constructor(args: ContainerResourceControllerArgs);
     getResource<T extends ResourceHandler>(name: string): T;
     getEntityResource(name: string): EntityResourceHandler;
-    execute(ctx: ExecutionContext): Promise<void>;
+    execute(ctx: QueryContext): Promise<void>;
 }

package/esm/implementation/resource/entity-resource-handler.d.ts

@@ -1,8 +1,8 @@
 import { StrictOmit } from 'ts-gems';
 import { OpraSchema } from '@opra/schema';
 import { EntityType } from '../data-type/entity-type.js';
-import { ExecutionContext } from '../execution-context.js';
 import { OpraService } from '../opra-service.js';
+import { QueryContext } from '../query-context.js';
 import { ResourceHandler } from './resource-handler.js';
 export declare type EntityResourceControllerArgs = StrictOmit<OpraSchema.EntityResource, 'kind'> & {
     service: OpraService;
@@ -13,6 +13,6 @@ export declare class EntityResourceHandler extends ResourceHandler {
     readonly service: OpraService;
     readonly dataType: EntityType;
     constructor(args: EntityResourceControllerArgs);
-    execute(ctx: ExecutionContext): Promise<void>;
-    _executeFn(ctx: ExecutionContext, fnName: string): Promise<any>;
+    execute(ctx: QueryContext): Promise<void>;
+    _executeFn(ctx: QueryContext, fnName: string): Promise<any>;
 }

package/esm/implementation/resource/entity-resource-handler.js

@@ -1,8 +1,9 @@
 import _ from 'lodash';
-import { ExecutionQuery } from '../../interfaces/execution-query.interface.js';
+import { OpraQuery } from '../../interfaces/query.interface.js';
 import { EntityType } from '../data-type/entity-type.js';
 import { ResourceHandler } from './resource-handler.js';
-var isSearchQuery = ExecutionQuery.isSearchQuery;
+var isSearchQuery = OpraQuery.isSearchQuery;
+import { UnprocessableEntityError } from '../../exception/index.js';
 export class EntityResourceHandler extends ResourceHandler {
     service;
     dataType;
@@ -18,7 +19,7 @@ export class EntityResourceHandler extends ResourceHandler {
             throw new TypeError(`You should provide an EntityType for EntityResourceController`);
     }
     async execute(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         if (isSearchQuery(query)) {
             const promises = [];
             let search;
@@ -57,15 +58,18 @@ export class EntityResourceHandler extends ResourceHandler {
                 if (typeof result === 'object')
                     affectedRecords = result.affectedRows || result.affectedRecords;
                 return { affectedRecords };
-            default:
-                result = Array.isArray(result) ? result[0] : result;
-                if (result && ctx.request.resultPath) {
-                    const pathArray = ctx.request.resultPath.split('.');
-                    for (const property of pathArray) {
-                        result = result && typeof result === 'object' && result[property];
-                    }
-                }
-                return result;
         }
+        result = Array.isArray(result) ? result[0] : result;
+        if (!result)
+            throw new UnprocessableEntityError();
+        if (ctx.resultPath) {
+            const pathArray = ctx.resultPath.split('.');
+            for (const property of pathArray) {
+                result = result && typeof result === 'object' && result[property];
+            }
+        }
+        if (fnName === 'create')
+            ctx.response.status = 201;
+        return result;
     }
 }

package/esm/implementation/resource/resource-handler.d.ts

@@ -1,6 +1,6 @@
 import { OpraSchema } from '@opra/schema';
 import { nodeInspectCustom } from '../../utils/terminal-utils.js';
-import { ExecutionContext } from '../execution-context.js';
+import { QueryContext } from '../query-context.js';
 export declare abstract class ResourceHandler {
     protected readonly _args: OpraSchema.Resource & {
         prepare?: Function;
@@ -9,7 +9,7 @@ export declare abstract class ResourceHandler {
     get name(): string;
     get description(): string | undefined;
     toString(): string;
-    prepare(ctx: ExecutionContext): Promise<void>;
-    abstract execute(ctx: ExecutionContext): Promise<void>;
+    prepare(ctx: QueryContext): Promise<void>;
+    abstract execute(ctx: QueryContext): Promise<void>;
     [nodeInspectCustom](): string;
 }

package/esm/implementation/resource/resource-handler.js

@@ -14,7 +14,7 @@ export class ResourceHandler {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
     }
     async prepare(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         const fn = this._args['pre_' + query.queryType];
         if (fn && typeof fn === 'function') {
             await fn(ctx);