@opra/core 0.1.0 → 0.2.0

package/esm/implementation/adapter-utils/entity-resource-execute.util.js

@@ -1,44 +1,43 @@
+import { ForbiddenError, ResourceNotFoundError } from '@opra/exception';
 import { translate } from '@opra/i18n';
-import { ComplexType } from '@opra/schema';
+import { ComplexType, OpraCountCollectionQuery } from '@opra/schema';
 import { HttpHeaders } from '../../enums/index.js';
-import { ForbiddenError, ResourceNotFoundError } from '../../exception/index.js';
-import { OpraQuery } from '../../interfaces/query.interface.js';
 export async function entityResourceExecute(service, resource, context) {
     const { query } = context;
-    if (OpraQuery.isSearchQuery(query)) {
+    if (query.kind === 'SearchCollectionQuery') {
         const promises = [];
         let search;
-        let count;
-        promises.push(executeFn(service, resource, context, query.queryType)
+        promises.push(executeFn(service, resource, context)
             .then(v => search = v));
-        if (query.count) {
-            promises.push(executeFn(service, resource, context, 'count')
-                .then(v => count = v));
+        if (query.count && resource.metadata.methods.count) {
+            const ctx = {
+                query: new OpraCountCollectionQuery(query.resource, { filter: query.filter }),
+                resultPath: ''
+            };
+            Object.setPrototypeOf(ctx, context);
+            promises.push(executeFn(service, resource, ctx));
         }
         await Promise.all(promises);
-        context.response.value = {
-            ...search,
-            ...count
-        };
+        context.response = search;
         return;
     }
-    context.response.value = await executeFn(service, resource, context, query.queryType);
+    context.response = await executeFn(service, resource, context);
 }
-async function executeFn(service, resource, context, queryType) {
-    const resolverInfo = resource.metadata.methods?.[queryType];
-    if (!resolverInfo.handler)
+async function executeFn(service, resource, context) {
+    const method = context.query.method;
+    const resolverInfo = resource.metadata.methods?.[method];
+    if (!(resolverInfo && resolverInfo.handler))
         throw new ForbiddenError({
-            message: translate('RESOLVER_FORBIDDEN', { queryType }),
+            message: translate('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
             severity: 'error',
             code: 'RESOLVER_FORBIDDEN'
         });
     let result = await resolverInfo.handler(context);
-    switch (queryType) {
+    switch (method) {
         case 'search':
-            context.response.headers.set(HttpHeaders.X_Opra_Schema, '/$schema/types/' + resource.dataType.name);
-            return {
-                items: Array.isArray(result) ? result : (context.response.value ? [result] : [])
-            };
+            const items = Array.isArray(result) ? result : (context.response ? [result] : []);
+            context.responseHeaders.set(HttpHeaders.X_Opra_Schema, resource.dataType.name);
+            return items;
         case 'get':
         case 'update':
             if (!result) {
@@ -47,18 +46,22 @@ async function executeFn(service, resource, context, queryType) {
             }
             break;
         case 'count':
-            return { count: result || 0 };
+            context.responseHeaders.set(HttpHeaders.X_Opra_Count, result);
+            return;
         case 'delete':
         case 'deleteMany':
         case 'updateMany':
-            let affectedRecords;
+            let affected;
             if (typeof result === 'number')
-                affectedRecords = result;
+                affected = result;
             if (typeof result === 'boolean')
-                affectedRecords = result ? 1 : 0;
+                affected = result ? 1 : 0;
             if (typeof result === 'object')
-                affectedRecords = result.affectedRows || result.affectedRecords;
-            return { affectedRecords };
+                affected = result.affectedRows || result.affected;
+            return {
+                operation: context.query.method,
+                affected
+            };
     }
     if (!result)
         return;
@@ -72,9 +75,8 @@ async function executeFn(service, resource, context, queryType) {
             result = result && typeof result === 'object' && result[field];
         }
     }
-    if (queryType === 'create')
-        context.response.status = 201;
-    if (dataType)
-        context.response.headers.set(HttpHeaders.X_Opra_Schema, '/$schema/types/' + dataType.name);
+    if (method === 'create')
+        context.status = 201;
+    context.responseHeaders.set(HttpHeaders.X_Opra_Schema, resource.dataType.name);
     return result;
 }

package/esm/implementation/adapter-utils/resource-execute.util.d.ts

@@ -1,3 +1,3 @@
-import { BaseResource, OpraService } from '@opra/schema';
+import { OpraResource, OpraService } from '@opra/schema';
 import { QueryContext } from '../query-context.js';
-export declare function resourceExecute(service: OpraService, resource: BaseResource, context: QueryContext): Promise<void>;
+export declare function resourceExecute(service: OpraService, resource: OpraResource, context: QueryContext): Promise<void>;

package/esm/implementation/adapter-utils/resource-prepare.util.d.ts

@@ -1,3 +1,3 @@
-import { BaseResource } from '@opra/schema';
+import { OpraResource } from '@opra/schema';
 import { QueryContext } from '../query-context.js';
-export declare function resourcePrepare(resource: BaseResource, context: QueryContext): Promise<void>;
+export declare function resourcePrepare(resource: OpraResource, context: QueryContext): Promise<void>;

package/esm/implementation/adapter-utils/resource-prepare.util.js

@@ -1,6 +1,6 @@
 export async function resourcePrepare(resource, context) {
     const { query } = context;
-    const fn = resource.metadata['pre_' + query.queryType];
+    const fn = resource.metadata['pre_' + query.method];
     if (fn && typeof fn === 'function') {
         await fn(context);
     }

package/esm/implementation/adapter.d.ts

@@ -1,6 +1,6 @@
+import { OpraException } from '@opra/exception';
 import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
 import { OpraService } from '@opra/schema';
-import { ApiException } from '../exception/index.js';
 import { IExecutionContext } from '../interfaces/execution-context.interface.js';
 import { QueryContext } from './query-context.js';
 export declare namespace OpraAdapter {
@@ -49,7 +49,7 @@ export declare abstract class OpraAdapter<TExecutionContext extends IExecutionCo
     });
     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 sendError(executionContext: TExecutionContext, error: OpraException): Promise<void>;
     protected abstract isBatch(executionContext: TExecutionContext): boolean;
     protected handler(executionContext: TExecutionContext): Promise<void>;
     protected _getSchemaExecute(ctx: QueryContext): Promise<void>;

package/esm/implementation/adapter.js

@@ -1,8 +1,6 @@
 import { AsyncEventEmitter } from 'strict-typed-events';
+import { BadRequestError, FailedDependencyError, wrapException } from '@opra/exception';
 import { I18n } from '@opra/i18n';
-import { HttpHeaders } from '../enums/index.js';
-import { BadRequestError, FailedDependencyError } from '../exception/index.js';
-import { wrapError } from '../exception/wrap-error.js';
 import { createI18n } from '../utils/create-i18n.js';
 import { resourceExecute } from './adapter-utils/resource-execute.util.js';
 import { resourcePrepare } from './adapter-utils/resource-prepare.util.js';
@@ -37,12 +35,12 @@ export class OpraAdapter {
                 // If previous request in bucket had an error and executed an update
                 // we do not execute next requests
                 if (stop) {
-                    context.response.errors.push(new FailedDependencyError());
+                    context.errors.push(new FailedDependencyError());
                     continue;
                 }
                 try {
                     const promise = (async () => {
-                        if (context.query.queryType === 'schema') {
+                        if (context.query.method === 'metadata') {
                             await this._getSchemaExecute(context);
                             return;
                         }
@@ -56,7 +54,7 @@ export class OpraAdapter {
                         context.userContext = userContext;
                         await resourceExecute(this.service, resource, context);
                     })().catch(e => {
-                        context.response.errors.push(e);
+                        context.errors.push(e);
                     });
                     if (exclusive)
                         await promise;
@@ -67,13 +65,13 @@ export class OpraAdapter {
                     // todo execute sub property queries
                 }
                 catch (e) {
-                    context.response.errors.unshift(e);
+                    context.errors.unshift(e);
                 }
-                if (context.response.errors.length) {
+                if (context.errors.length) {
                     // noinspection SuspiciousTypeOfGuard
-                    context.response.errors = context.response.errors.map(e => wrapError(e));
+                    context.errors = context.errors.map(e => wrapException(e));
                     if (exclusive)
-                        stop = stop || !!context.response.errors.find(e => !(e.response.severity === 'warning' || e.response.severity === 'info'));
+                        stop = stop || !!context.errors.find(e => !(e.issue.severity === 'warning' || e.issue.severity === 'info'));
                 }
             }
             if (promises)
@@ -82,7 +80,7 @@ export class OpraAdapter {
         }
         catch (e) {
             failed = true;
-            const error = wrapError(e);
+            const error = wrapException(e);
             await this.sendError(executionContext, error);
         }
         finally {
@@ -98,28 +96,25 @@ export class OpraAdapter {
     async _getSchemaExecute(ctx) {
         const query = ctx.query;
         let out;
-        if (query.resourcePath.length > 2)
+        if (query.resourcePath && query.resourcePath.length > 2)
             throw new BadRequestError();
         if (query.resourcePath?.length) {
             if (query.resourcePath[0] === 'resources') {
                 const resource = this.service.getResource(query.resourcePath[1]);
                 out = resource.getSchema(true);
                 query.resourcePath[1] = resource.name;
-                ctx.response.headers.set(HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema#' + resource.kind);
             }
             else if (query.resourcePath[0] === 'types') {
                 const dataType = this.service.getDataType(query.resourcePath[1]);
                 out = dataType.getSchema(true);
                 query.resourcePath[1] = dataType.name;
-                ctx.response.headers.set(HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema#' + dataType.kind);
             }
             else
                 throw new BadRequestError();
-            ctx.response.value = out;
+            ctx.response = out;
             return;
         }
-        ctx.response.headers.set(HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema');
-        ctx.response.value = this.service.getSchema(true);
+        ctx.response = this.service.getSchema(true);
     }
     static async initI18n(options) {
         if (options?.i18n instanceof I18n)

package/esm/implementation/express-adapter.js

@@ -1,3 +1,4 @@
+import bodyParser from 'body-parser';
 import { AsyncEventEmitter } from 'strict-typed-events';
 import { normalizePath } from '@opra/url';
 import { OpraHttpAdapter } from './http-adapter.js';
@@ -9,6 +10,7 @@ export class OpraExpressAdapter extends OpraHttpAdapter {
             i18n
         });
         const prefix = '/' + normalizePath(options?.prefix, true);
+        app.use(prefix, bodyParser.json());
         app.use(prefix, (request, response, next) => {
             (async () => {
                 const executionContext = new ExpressExecutionContext(request, response);

package/esm/implementation/headers-map.d.ts

@@ -0,0 +1,5 @@
+import { ResponsiveMap } from '@opra/schema';
+export declare class HeadersMap extends ResponsiveMap<string, string> {
+    constructor(data?: any);
+    toObject(): Record<string, string>;
+}

package/esm/implementation/headers-map.js

@@ -0,0 +1,14 @@
+import { ResponsiveMap } from '@opra/schema';
+import { HttpHeaders } from '../enums/index.js';
+export class HeadersMap extends ResponsiveMap {
+    constructor(data) {
+        super(data, Array.from(Object.values(HttpHeaders)));
+    }
+    toObject() {
+        return Array.from(this.keys()).sort()
+            .reduce((a, k) => {
+            a[k] = this.get(k);
+            return a;
+        }, {});
+    }
+}

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

@@ -1,7 +1,7 @@
+import { OpraException } from '@opra/exception';
+import { OpraAnyQuery, OpraGetMetadataQuery } from '@opra/schema';
 import { OpraURL } from '@opra/url';
-import { ApiException } from '../exception/index.js';
 import { IHttpExecutionContext } from '../interfaces/execution-context.interface.js';
-import { OpraGetSchemaQuery, OpraQuery } from '../interfaces/query.interface.js';
 import { OpraAdapter } from './adapter.js';
 import { QueryContext } from './query-context.js';
 export declare namespace OpraHttpAdapter {
@@ -11,17 +11,17 @@ export declare namespace OpraHttpAdapter {
 }
 interface PreparedOutput {
     status: number;
-    headers?: Record<string, string>;
+    headers: Record<string, string>;
     body?: any;
 }
 export declare class OpraHttpAdapter<TExecutionContext extends IHttpExecutionContext> extends OpraAdapter<IHttpExecutionContext> {
     protected prepareRequests(executionContext: TExecutionContext): QueryContext[];
     prepareRequest(executionContext: IHttpExecutionContext, url: OpraURL, method: string, headers: Map<string, string>, body?: any): QueryContext;
-    buildGetSchemaQuery(url: OpraURL): OpraGetSchemaQuery;
-    buildQuery(url: OpraURL, method: string, body?: any): OpraQuery | undefined;
+    buildGGetMetadataQuery(url: OpraURL): OpraGetMetadataQuery;
+    buildQuery(url: OpraURL, method: string, body?: any): OpraAnyQuery | 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>;
+    protected sendError(executionContext: TExecutionContext, error: OpraException): Promise<void>;
 }
 export {};

package/esm/implementation/http-adapter.js

@@ -1,10 +1,9 @@
-import { ComplexType, ContainerResource, EntityResource, OpraSchema, ResponsiveMap } from '@opra/schema';
+import { BadRequestError, InternalServerError, IssueSeverity, MethodNotAllowedError, NotFoundError, OpraException, wrapException } from '@opra/exception';
+import { ComplexType, ContainerResource, EntityResource, OpraCreateInstanceQuery, OpraDeleteCollectionQuery, OpraDeleteInstanceQuery, OpraGetFieldQuery, OpraGetInstanceQuery, OpraGetMetadataQuery, OpraSchema, OpraSearchCollectionQuery, OpraUpdateCollectionQuery, OpraUpdateInstanceQuery, } from '@opra/schema';
 import { OpraURL } from '@opra/url';
 import { HttpHeaders, HttpStatus } from '../enums/index.js';
-import { BadRequestError, InternalServerError, MethodNotAllowedError, NotFoundError, } from '../exception/index.js';
-import { wrapError } from '../exception/wrap-error.js';
-import { OpraQuery } from '../interfaces/query.interface.js';
 import { OpraAdapter } from './adapter.js';
+import { HeadersMap } from './headers-map.js';
 import { QueryContext } from './query-context.js';
 export class OpraHttpAdapter extends OpraAdapter {
     prepareRequests(executionContext) {
@@ -15,7 +14,7 @@ export class OpraHttpAdapter extends OpraAdapter {
         }
         const url = new OpraURL(req.getUrl());
         return [
-            this.prepareRequest(executionContext, url, req.getMethod(), new ResponsiveMap(req.getHeaders()), req.getBody())
+            this.prepareRequest(executionContext, url, req.getMethod(), new HeadersMap(req.getHeaders()), req.getBody())
         ];
     }
     prepareRequest(executionContext, url, method, headers, body) {
@@ -32,12 +31,12 @@ export class OpraHttpAdapter extends OpraAdapter {
             service: this.service,
             executionContext,
             query,
-            headers,
+            headers: new HeadersMap(),
             params: url.searchParams,
             continueOnError: query.operation === 'read'
         });
     }
-    buildGetSchemaQuery(url) {
+    buildGGetMetadataQuery(url) {
         const pathLen = url.path.size;
         const resourcePath = [];
         let pathIndex = 0;
@@ -45,7 +44,7 @@ export class OpraHttpAdapter extends OpraAdapter {
             const p = url.path.get(pathIndex++);
             if (p.key)
                 throw new BadRequestError();
-            if (p.resource !== '$schema') {
+            if (p.resource !== '$metadata') {
                 if (pathIndex === 1)
                     resourcePath.push('resources');
                 resourcePath.push(p.resource);
@@ -55,8 +54,9 @@ export class OpraHttpAdapter extends OpraAdapter {
             pick: url.searchParams.get('$pick'),
             omit: url.searchParams.get('$omit'),
             include: url.searchParams.get('$include'),
+            resourcePath
         };
-        return OpraQuery.forGetSchema(resourcePath, opts);
+        return new OpraGetMetadataQuery(opts);
     }
     buildQuery(url, method, body) {
         let container = this.service;
@@ -65,10 +65,10 @@ export class OpraHttpAdapter extends OpraAdapter {
             // Check if requesting metadata
             for (let i = 0; i < pathLen; i++) {
                 const p = url.path.get(i);
-                if (p.resource === '$schema') {
+                if (p.resource === '$metadata') {
                     if (method !== 'GET')
                         return;
-                    return this.buildGetSchemaQuery(url);
+                    return this.buildGGetMetadataQuery(url);
                 }
             }
             let pathIndex = 0;
@@ -89,7 +89,7 @@ export class OpraHttpAdapter extends OpraAdapter {
                     switch (method) {
                         case 'GET': {
                             if (scope === 'collection') {
-                                query = OpraQuery.forSearch(resource, {
+                                query = new OpraSearchCollectionQuery(resource, {
                                     filter: url.searchParams.get('$filter'),
                                     limit: url.searchParams.get('$limit'),
                                     skip: url.searchParams.get('$skip'),
@@ -102,51 +102,39 @@ export class OpraHttpAdapter extends OpraAdapter {
                                 });
                             }
                             else {
-                                query = OpraQuery.forGetEntity(resource, p.key, {
+                                query = new OpraGetInstanceQuery(resource, p.key, {
                                     pick: url.searchParams.get('$pick'),
                                     omit: url.searchParams.get('$omit'),
                                     include: url.searchParams.get('$include')
                                 });
                                 // Move through properties
-                                let nested;
-                                let path = resource.name;
+                                let dataType = resource.dataType;
+                                const curPath = [];
+                                let parent = query;
                                 while (pathIndex < pathLen) {
-                                    const dataType = nested
-                                        ? this.service.getDataType(nested.property.type || 'string')
-                                        : query.resource.dataType;
                                     if (!(dataType instanceof ComplexType))
-                                        throw new Error(`"${path}" is not a ComplexType and has no fields.`);
+                                        throw new TypeError(`"${resource.name}.${curPath.join()}" is not a ComplexType and has no fields.`);
                                     p = url.path.get(pathIndex++);
-                                    path += '.' + p.resource;
-                                    const prop = dataType.fields.get(p.resource);
-                                    if (!prop)
-                                        throw new NotFoundError({ message: `Invalid or unknown resource path (${path})` });
-                                    const q = OpraQuery.forGetProperty(prop);
-                                    if (nested) {
-                                        nested.nested = q;
-                                    }
-                                    else {
-                                        query.nested = q;
-                                    }
-                                    nested = q;
+                                    curPath.push(p.resource);
+                                    const field = dataType.getField(p.resource);
+                                    parent.nested = new OpraGetFieldQuery(parent, field.name);
+                                    parent = parent.nested;
+                                    dataType = parent.dataType;
                                 }
                             }
                             break;
                         }
                         case 'DELETE': {
-                            if (scope === 'collection') {
-                                query = OpraQuery.forDeleteMany(resource, {
+                            query = scope === 'collection'
+                                ? new OpraDeleteCollectionQuery(resource, {
                                     filter: url.searchParams.get('$filter'),
-                                });
-                            }
-                            else {
-                                query = OpraQuery.forDelete(resource, p.key);
-                            }
+                                })
+                                : new OpraDeleteInstanceQuery(resource, p.key);
                             break;
                         }
                         case 'POST': {
                             if (scope === 'collection') {
-                                query = OpraQuery.forCreate(resource, body, {
+                                query = new OpraCreateInstanceQuery(resource, body, {
                                     pick: url.searchParams.get('$pick'),
                                     omit: url.searchParams.get('$omit'),
                                     include: url.searchParams.get('$include')
@@ -155,18 +143,15 @@ export class OpraHttpAdapter extends OpraAdapter {
                             break;
                         }
                         case 'PATCH': {
-                            if (scope === 'collection') {
-                                query = OpraQuery.forUpdateMany(resource, body, {
+                            query = scope === 'collection'
+                                ? new OpraUpdateCollectionQuery(resource, body, {
                                     filter: url.searchParams.get('$filter')
-                                });
-                            }
-                            else {
-                                query = OpraQuery.forUpdate(resource, p.key, body, {
+                                })
+                                : new OpraUpdateInstanceQuery(resource, p.key, body, {
                                     pick: url.searchParams.get('$pick'),
                                     omit: url.searchParams.get('$omit'),
                                     include: url.searchParams.get('$include')
                                 });
-                            }
                             break;
                         }
                     }
@@ -176,7 +161,9 @@ export class OpraHttpAdapter extends OpraAdapter {
             throw new InternalServerError();
         }
         catch (e) {
-            throw BadRequestError.wrap(e);
+            if (e instanceof OpraException)
+                throw e;
+            throw new BadRequestError(e);
         }
     }
     async sendResponse(executionContext, queryContexts) {
@@ -189,19 +176,12 @@ export class OpraHttpAdapter extends OpraAdapter {
             // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
             return;
         }
-        if (!outputPackets.length) {
-            const err = new NotFoundError();
-            outputPackets.push({
-                status: err.status,
-                body: {
-                    errors: [err.response]
-                }
-            });
-        }
+        if (!outputPackets.length)
+            return this.sendError(executionContext, new NotFoundError());
         const out = outputPackets[0];
         const resp = executionContext.getResponseWrapper();
         resp.setStatus(out.status);
-        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(HttpHeaders.Content_Type, 'application/opra+json');
         resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
         resp.setHeader(HttpHeaders.Pragma, 'no-cache');
         resp.setHeader(HttpHeaders.Expires, '-1');
@@ -219,34 +199,35 @@ export class OpraHttpAdapter extends OpraAdapter {
     }
     createOutput(ctx) {
         const { query } = ctx;
-        let status = ctx.response.status;
-        let body = ctx.response.value || {};
-        const errors = ctx.response.errors?.map(e => wrapError(e));
+        let body;
+        let status = ctx.status || 0;
+        const errors = ctx.errors.map(e => wrapException(e));
         if (errors && errors.length) {
-            if (!status || status < 400) {
-                status = 0;
-                for (const e of errors) {
-                    status = Math.max(status, e.status || status);
-                }
+            // 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 < HttpStatus.BAD_REQUEST) {
+                status = errors[0].status;
                 if (status < HttpStatus.BAD_REQUEST)
                     status = HttpStatus.INTERNAL_SERVER_ERROR;
             }
-            body.errors = errors.map(e => e.response);
+            body = {
+                operation: ctx.query.method,
+                errors: errors.map(e => e.issue)
+            };
         }
         else {
-            delete body.errors;
+            body = ctx.response;
             status = status || (query.operation === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
         }
-        // Convert headers map to object
-        const headers = Array.from(ctx.response.headers.keys()).map(k => k.toLowerCase()).sort()
-            .reduce((a, k) => {
-            a[k] = ctx.response.headers.get(k);
-            return a;
-        }, {});
         body = this.i18n.deep(body);
         return {
             status,
-            headers,
+            headers: ctx.responseHeaders.toObject(),
             body
         };
     }
@@ -258,6 +239,11 @@ export class OpraHttpAdapter extends OpraAdapter {
         resp.setHeader(HttpHeaders.Pragma, 'no-cache');
         resp.setHeader(HttpHeaders.Expires, '-1');
         resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
-        resp.send(JSON.stringify(error.response));
+        const issue = this.i18n.deep(error.issue);
+        const body = {
+            operation: 'unknown',
+            errors: [issue]
+        };
+        resp.send(JSON.stringify(body));
     }
 }

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

@@ -1,31 +1,25 @@
-import { OpraService, ResponsiveMap } from '@opra/schema';
+import { OpraException } from '@opra/exception';
+import { OpraAnyQuery, OpraService } from '@opra/schema';
 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 { HeadersMap } from './headers-map.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 query: OpraAnyQuery;
     readonly params: SearchParams;
-    readonly headers: Map<string, string>;
+    readonly headers: HeadersMap;
     readonly parentValue?: any;
     readonly resultPath: string;
-    readonly response: QueryResponse;
+    readonly responseHeaders: HeadersMap;
+    response?: any;
+    errors: OpraException[];
+    status?: HttpStatus;
     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: ResponsiveMap<string, string>;
-    errors: ApiException[];
-    status?: HttpStatus;
-    value?: any;
-    total?: number;
-    constructor(args?: QueryResponseArgs);
-}