@opra/core 0.2.0 → 0.4.0

package/esm/adapter/adapter.js

@@ -0,0 +1,315 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { ResponsiveMap } from '@opra/common';
+import { FailedDependencyError, ForbiddenError, ResourceNotFoundError, wrapException } from '@opra/exception';
+import { I18n, translate } from '@opra/i18n';
+import { CollectionCountQuery, CollectionResourceInfo, ComplexType, SingletonResourceInfo } from '@opra/schema';
+import { HttpHeaders } from '../enums/index.js';
+import { createI18n } from '../utils/create-i18n.js';
+import { MetadataResource } from './metadata-resource.js';
+export class OpraAdapter {
+    document;
+    i18n;
+    userContextResolver;
+    // protected _metadataResource: SingletonResourceInfo;
+    _internalResources = new ResponsiveMap();
+    constructor(document) {
+        this.document = document;
+    }
+    async handler(executionContext) {
+        let queryContexts;
+        let userContext;
+        let failed = false;
+        try {
+            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 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;
+                }
+                // If previous request in bucket had an error and executed an update
+                // we do not execute next requests
+                if (stop) {
+                    context.errors.push(new FailedDependencyError());
+                    continue;
+                }
+                try {
+                    const promise = (async () => {
+                        // if (context.query.method === 'metadata') {
+                        //   await this._getSchemaExecute(context); //todo
+                        //   return;
+                        // }
+                        const resource = context.query.resource;
+                        await this._resourcePrepare(resource, context);
+                        if (this.userContextResolver && !userContext)
+                            userContext = this.userContextResolver({
+                                executionContext,
+                                isBatch: this.isBatch(executionContext)
+                            });
+                        context.userContext = userContext;
+                        await this._resourceExecute(this.document, resource, context);
+                    })().catch(e => {
+                        context.errors.push(e);
+                    });
+                    if (exclusive)
+                        await promise;
+                    else {
+                        promises = promises || [];
+                        promises.push(promise);
+                    }
+                    // todo execute sub property queries
+                }
+                catch (e) {
+                    context.errors.unshift(e);
+                }
+                if (context.errors.length) {
+                    // noinspection SuspiciousTypeOfGuard
+                    context.errors = context.errors.map(e => wrapException(e));
+                    if (exclusive)
+                        stop = stop || !!context.errors.find(e => !(e.issue.severity === 'warning' || e.issue.severity === 'info'));
+                }
+            }
+            if (promises)
+                await Promise.allSettled(promises);
+            await this.sendResponse(executionContext, queryContexts);
+        }
+        catch (e) {
+            failed = true;
+            const error = wrapException(e);
+            await this.sendError(executionContext, error);
+        }
+        finally {
+            if (executionContext instanceof AsyncEventEmitter) {
+                await executionContext
+                    .emitAsyncSerial('finish', {
+                    userContext,
+                    failed
+                }).catch();
+            }
+        }
+    }
+    async _resourcePrepare(resource, context) {
+        const { query } = context;
+        const fn = resource.metadata['pre_' + query.method];
+        if (fn && typeof fn === 'function') {
+            await fn(context);
+        }
+    }
+    async _resourceExecute(document, resource, context) {
+        if (resource instanceof CollectionResourceInfo) {
+            const { query } = context;
+            if (query.kind === 'SearchCollectionQuery') {
+                const promises = [];
+                let search;
+                promises.push(this._collectionResourceExecute(document, resource, context)
+                    .then(v => search = v));
+                if (query.count && resource.metadata.count) {
+                    const ctx = {
+                        query: new CollectionCountQuery(query.resource, { filter: query.filter }),
+                        resultPath: ''
+                    };
+                    Object.setPrototypeOf(ctx, context);
+                    promises.push(this._collectionResourceExecute(document, resource, ctx));
+                }
+                await Promise.all(promises);
+                context.response = search;
+                return;
+            }
+            context.response = await this._collectionResourceExecute(document, resource, context);
+            return;
+        }
+        else if (resource instanceof SingletonResourceInfo) {
+            context.response = await this._singletonResourceExecute(document, resource, context);
+            return;
+        }
+        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+    }
+    async _init(options) {
+        if (options?.i18n instanceof I18n)
+            this.i18n = options.i18n;
+        else if (typeof options?.i18n === 'function')
+            this.i18n = await options.i18n();
+        else
+            this.i18n = await createI18n(options?.i18n);
+        this.i18n = this.i18n || I18n.defaultInstance;
+        if (!this.i18n.isInitialized)
+            await this.i18n.init();
+        this.userContextResolver = options?.userContext;
+        const metadataResource = new MetadataResource();
+        const metadataResourceInfo = new SingletonResourceInfo(this.document, '$metadata', this.document.getComplexDataType('object'), {
+            kind: 'SingletonResource',
+            type: 'object',
+            instance: metadataResource,
+            get: {
+                handler: metadataResource.get.bind(metadataResource)
+            }
+        });
+        this._internalResources.set(metadataResourceInfo.name, metadataResourceInfo);
+        metadataResource.init(metadataResourceInfo);
+        for (const r of this.document.resources.values()) {
+            if (r.instance) {
+                const init = r.instance.init;
+                if (init)
+                    await init.call(r.instance, r);
+            }
+        }
+    }
+    async _collectionResourceExecute(document, resource, context) {
+        const method = context.query.method;
+        const resolverInfo = resource.metadata[method];
+        if (!(resolverInfo && resolverInfo.handler))
+            throw new ForbiddenError({
+                message: translate('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
+                severity: 'error',
+                code: 'RESOLVER_FORBIDDEN'
+            });
+        let result;
+        switch (method) {
+            case 'create': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query.data, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (result)
+                    context.status = 201;
+                context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return result;
+            }
+            case 'count': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query);
+                context.responseHeaders.set(HttpHeaders.X_Opra_Count, result);
+                return result;
+            }
+            case 'get': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query.keyValue, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (!result)
+                    throw new ResourceNotFoundError(resource.name, query.keyValue);
+                const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
+                if (v.value === undefined)
+                    throw new ResourceNotFoundError(v.path);
+                if (v.dataType)
+                    context.responseHeaders.set(HttpHeaders.X_Opra_DataType, v.dataType.name);
+                return v.value;
+            }
+            case 'search': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query);
+                const items = Array.isArray(result) ? result : (context.response ? [result] : []);
+                context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return items;
+            }
+            case 'update': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query.keyValue, query.data, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (!result)
+                    throw new ResourceNotFoundError(resource.name, query.keyValue);
+                context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return result;
+            }
+            case 'delete':
+            case 'deleteMany':
+            case 'updateMany': {
+                switch (method) {
+                    case 'delete': {
+                        const query = context.query;
+                        result = await resolverInfo.handler(context, query.keyValue, query);
+                        break;
+                    }
+                    case 'deleteMany': {
+                        const query = context.query;
+                        result = await resolverInfo.handler(context, query);
+                        break;
+                    }
+                    case 'updateMany': {
+                        const query = context.query;
+                        result = await resolverInfo.handler(context, query.data, query);
+                        break;
+                    }
+                }
+                let affected;
+                if (typeof result === 'number')
+                    affected = result;
+                if (typeof result === 'boolean')
+                    affected = result ? 1 : 0;
+                if (typeof result === 'object')
+                    affected = result.affectedRows || result.affected;
+                return {
+                    operation: context.query.method,
+                    affected
+                };
+            }
+        }
+    }
+    async _singletonResourceExecute(document, resource, context) {
+        const method = context.query.method;
+        const resolverInfo = resource.metadata[method];
+        if (!(resolverInfo && resolverInfo.handler))
+            throw new ForbiddenError({
+                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 (method) {
+            case 'get': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (!result)
+                    throw new ResourceNotFoundError(resource.name);
+                const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
+                if (v.value === undefined)
+                    throw new ResourceNotFoundError(v.path);
+                if (v.dataType)
+                    context.responseHeaders.set(HttpHeaders.X_Opra_DataType, v.dataType.name);
+                return v.value;
+            }
+        }
+        if (!result)
+            return;
+        result = Array.isArray(result) ? result[0] : result;
+        let dataType = resource.dataType;
+        if (context.resultPath) {
+            const pathArray = context.resultPath.split('.');
+            for (const field of pathArray) {
+                const prop = dataType instanceof ComplexType ? dataType.fields.get(field) : undefined;
+                dataType = prop && prop.type ? this.document.types.get(prop.type) : undefined;
+                result = result && typeof result === 'object' && result[field];
+            }
+        }
+        if (method === 'create')
+            context.status = 201;
+        context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+        return result;
+    }
+    async _pathWalkThrough(query, dataType, value, parentPath) {
+        const { child } = query;
+        if (!child)
+            return { value, dataType, path: parentPath };
+        // Make a case in sensitive lookup
+        const fieldNameLower = child.fieldName.toLowerCase();
+        const path = parentPath + (parentPath ? '.' : '') + child.fieldName;
+        for (const key of Object.keys(value)) {
+            if (key.toLowerCase() === fieldNameLower) {
+                let v = value[key];
+                if (v == null)
+                    return { path };
+                if (child.child && child.dataType instanceof ComplexType) {
+                    if (Array.isArray(v))
+                        v = v[0];
+                    return this._pathWalkThrough(child, child.dataType, v, path);
+                }
+                return { value: v, dataType: child.dataType, path };
+            }
+        }
+        return { path };
+    }
+}

package/esm/{implementation → adapter}/express-adapter.d.ts

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

package/esm/{implementation → adapter}/express-adapter.js

@@ -3,12 +3,9 @@ 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, {
-            ...options,
-            i18n
-        });
+    static async init(app, document, options) {
+        const adapter = new OpraExpressAdapter(document);
+        await adapter._init(options);
         const prefix = '/' + normalizePath(options?.prefix, true);
         app.use(prefix, bodyParser.json());
         app.use(prefix, (request, response, next) => {

package/esm/{implementation → adapter}/http-adapter.d.ts

@@ -1,5 +1,5 @@
 import { OpraException } from '@opra/exception';
-import { OpraAnyQuery, OpraGetMetadataQuery } from '@opra/schema';
+import { OpraQuery } from '@opra/schema';
 import { OpraURL } from '@opra/url';
 import { IHttpExecutionContext } from '../interfaces/execution-context.interface.js';
 import { OpraAdapter } from './adapter.js';
@@ -17,8 +17,7 @@ interface PreparedOutput {
 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;
-    buildGGetMetadataQuery(url: OpraURL): OpraGetMetadataQuery;
-    buildQuery(url: OpraURL, method: string, body?: any): OpraAnyQuery | undefined;
+    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;

package/esm/adapter/http-adapter.js

@@ -0,0 +1,238 @@
+import { BadRequestError, InternalServerError, IssueSeverity, MethodNotAllowedError, NotFoundError, OpraException, wrapException } from '@opra/exception';
+import { CollectionCreateQuery, CollectionDeleteManyQuery, CollectionDeleteQuery, CollectionGetQuery, CollectionResourceInfo, CollectionSearchQuery, CollectionUpdateManyQuery, CollectionUpdateQuery, ComplexType, ContainerResourceInfo, FieldGetQuery, OpraSchema, SingletonGetQuery, SingletonResourceInfo, UnionType, } from '@opra/schema';
+import { OpraURL } from '@opra/url';
+import { HttpHeaders, HttpStatus } from '../enums/index.js';
+import { HeadersMap } from '../helpers/headers-map.js';
+import { OpraAdapter } from './adapter.js';
+import { QueryContext } from './query-context.js';
+export class OpraHttpAdapter extends OpraAdapter {
+    prepareRequests(executionContext) {
+        const req = executionContext.getRequestWrapper();
+        // todo implement batch requests
+        if (this.isBatch(executionContext)) {
+            throw new Error('not implemented yet');
+        }
+        const url = new OpraURL(req.getUrl());
+        return [
+            this.prepareRequest(executionContext, url, req.getMethod(), new HeadersMap(req.getHeaders()), req.getBody())
+        ];
+    }
+    prepareRequest(executionContext, url, method, headers, body) {
+        if (!url.path.size)
+            throw new BadRequestError();
+        if (method !== 'GET' && url.path.size > 1)
+            throw new BadRequestError();
+        const query = this.buildQuery(url, method, body);
+        if (!query)
+            throw new MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target endpoint`
+            });
+        return new QueryContext({
+            service: this.document,
+            executionContext,
+            query,
+            headers: new HeadersMap(),
+            params: url.searchParams,
+            continueOnError: query.operation === 'read'
+        });
+    }
+    buildQuery(url, method, body) {
+        const pathLen = url.path.size;
+        let p = url.path.get(0);
+        let resource = this._internalResources.get(p.resource) || this.document.getResource(p.resource);
+        let container;
+        let pathIndex = 0;
+        while (resource && resource instanceof ContainerResourceInfo) {
+            container = resource;
+            p = url.path.get(++pathIndex);
+            resource = container.getResource(p.resource);
+        }
+        try {
+            method = method.toUpperCase();
+            let query;
+            if (resource instanceof SingletonResourceInfo && !p.key) {
+                switch (method) {
+                    case 'GET': {
+                        query = new SingletonGetQuery(resource);
+                    }
+                }
+            }
+            else if (resource instanceof CollectionResourceInfo) {
+                switch (method) {
+                    case 'GET': {
+                        if (p.key) {
+                            const searchParams = url.searchParams;
+                            query = new CollectionGetQuery(resource, p.key, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        else {
+                            const searchParams = url.searchParams;
+                            query = new CollectionSearchQuery(resource, {
+                                filter: searchParams.get('$filter'),
+                                limit: searchParams.get('$limit'),
+                                skip: searchParams.get('$skip'),
+                                distinct: searchParams.get('$distinct'),
+                                count: searchParams.get('$count'),
+                                sort: searchParams.get('$sort'),
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        break;
+                    }
+                    case 'DELETE': {
+                        const searchParams = url.searchParams;
+                        query = p.key
+                            ? new CollectionDeleteQuery(resource, p.key)
+                            : new CollectionDeleteManyQuery(resource, {
+                                filter: searchParams.get('$filter'),
+                            });
+                        break;
+                    }
+                    case 'POST': {
+                        if (!p.key) {
+                            const searchParams = url.searchParams;
+                            query = new CollectionCreateQuery(resource, body, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        break;
+                    }
+                    case 'PATCH': {
+                        if (p.key) {
+                            const searchParams = url.searchParams;
+                            query = new CollectionUpdateQuery(resource, p.key, body, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        else {
+                            const searchParams = url.searchParams;
+                            query = new CollectionUpdateManyQuery(resource, body, {
+                                filter: searchParams.get('$filter')
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+            else
+                throw new InternalServerError();
+            if (query instanceof SingletonGetQuery || query instanceof CollectionGetQuery || query instanceof FieldGetQuery) {
+                // Move through properties
+                let parentType;
+                const curPath = [];
+                let parent = query;
+                while (++pathIndex < pathLen) {
+                    p = url.path.get(pathIndex);
+                    parentType = parent.dataType;
+                    if (parent.dataType instanceof UnionType) {
+                        if (parent.dataType.name === 'any')
+                            parentType = this.document.getComplexDataType('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 FieldGetQuery(parent, p.resource, { castingType: parentType });
+                    parent = parent.child;
+                }
+            }
+            return query;
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            throw new BadRequestError(e);
+        }
+    }
+    async sendResponse(executionContext, queryContexts) {
+        const outputPackets = [];
+        for (const ctx of queryContexts) {
+            const v = this.createOutput(ctx);
+            outputPackets.push(v);
+        }
+        if (this.isBatch(executionContext)) {
+            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
+            return;
+        }
+        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.Cache_Control, 'no-cache');
+        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(HttpHeaders.Expires, '-1');
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
+        if (out.headers) {
+            for (const [k, v] of Object.entries(out.headers)) {
+                resp.setHeader(k, v);
+            }
+        }
+        resp.send(JSON.stringify(out.body));
+        resp.end();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isBatch(executionContext) {
+        return false;
+    }
+    createOutput(ctx) {
+        const { query } = ctx;
+        let body;
+        let status = ctx.status || 0;
+        const errors = ctx.errors.map(e => wrapException(e));
+        if (errors && errors.length) {
+            // 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 = {
+                operation: ctx.query.method,
+                errors: errors.map(e => e.issue)
+            };
+        }
+        else {
+            body = ctx.response;
+            status = status || (query.operation === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
+        }
+        body = this.i18n.deep(body);
+        return {
+            status,
+            headers: ctx.responseHeaders.toObject(),
+            body
+        };
+    }
+    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');
+        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(HttpHeaders.Expires, '-1');
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
+        const issue = this.i18n.deep(error.issue);
+        const body = {
+            operation: 'unknown',
+            errors: [issue]
+        };
+        resp.send(JSON.stringify(body));
+    }
+}

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

@@ -0,0 +1,8 @@
+import { SingletonResourceInfo } from '@opra/schema';
+import { ISingletonResource } from '../interfaces/resource.interface.js';
+import { JsonSingletonService } from '../services/json-singleton-service.js';
+export declare class MetadataResource implements ISingletonResource<any> {
+    service: JsonSingletonService<any>;
+    init(resource: SingletonResourceInfo): void;
+    get(): any;
+}

package/esm/adapter/metadata-resource.js

@@ -0,0 +1,20 @@
+import { __decorate } from "tslib";
+import { OprSingletonResource } from '@opra/schema';
+import { JsonSingletonService } from '../services/json-singleton-service.js';
+let MetadataResource = class MetadataResource {
+    service;
+    init(resource) {
+        this.service = new JsonSingletonService(resource.dataType, {
+            data: resource.document.getMetadata(true)
+        });
+    }
+    get() {
+        return this.service.get();
+    }
+};
+MetadataResource = __decorate([
+    OprSingletonResource(Object, {
+        name: '$metadata'
+    })
+], MetadataResource);
+export { MetadataResource };

package/esm/{implementation → adapter}/query-context.d.ts

@@ -1,15 +1,15 @@
 import { OpraException } from '@opra/exception';
-import { OpraAnyQuery, OpraService } from '@opra/schema';
-import { SearchParams } from '@opra/url';
+import { OpraDocument, OpraQuery } from '@opra/schema';
+import { OpraURLSearchParams } from '@opra/url';
 import { HttpStatus } from '../enums/index.js';
+import { HeadersMap } from '../helpers/headers-map.js';
 import { ContextType, IExecutionContext, IHttpExecutionContext } from '../interfaces/execution-context.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 service: OpraDocument;
     readonly executionContext: IExecutionContext;
-    readonly query: OpraAnyQuery;
-    readonly params: SearchParams;
+    readonly query: OpraQuery;
+    readonly params: OpraURLSearchParams;
     readonly headers: HeadersMap;
     readonly parentValue?: any;
     readonly resultPath: string;

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

@@ -1,5 +1,5 @@
 import { OpraURLSearchParams } from '@opra/url';
-import { HeadersMap } from './headers-map.js';
+import { HeadersMap } from '../helpers/headers-map.js';
 export class QueryContext {
     service;
     executionContext;

package/esm/enums/http-headers.enum.d.ts

@@ -3,7 +3,7 @@
  */
 export declare enum HttpHeaders {
     X_Opra_Version = "X-Opra-Version",
-    X_Opra_Schema = "X-Opra-Schema",
+    X_Opra_DataType = "X-Opra-DataType",
     X_Opra_Count = "X-Opra-Count",
     /**
      * Defines the authentication method that should be used to access a resource.