@opra/core 0.0.12 → 0.0.13

package/cjs/implementation/schema-generator.js

@@ -6,7 +6,6 @@ const schema_1 = require("@opra/schema");
 const constants_js_1 = require("../constants.js");
 const class_utils_js_1 = require("../utils/class-utils.js");
 const internal_data_types_js_1 = require("../utils/internal-data-types.js");
-var isDataType = schema_1.OpraSchema.isDataType;
 const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
 class SchemaGenerator {
     _dataTypes = {};
@@ -58,7 +57,7 @@ class SchemaGenerator {
             }
             return this.addDataType(schema);
         }
-        if (!isDataType(thunk))
+        if (!schema_1.OpraSchema.isDataType(thunk))
             throw new TypeError(`Invalid data type schema`);
         // Check if datatype previously added
         const currentSchema = this._dataTypes[thunk.name];
@@ -92,16 +91,25 @@ class SchemaGenerator {
                 ...metadata,
                 type,
                 name,
-                instance
+                instance,
+                resolvers: {}
             };
             if (schema_1.OpraSchema.isEntityResource(resourceSchema)) {
                 for (const methodName of entityMethods) {
-                    let fn = instance['pre_' + methodName];
-                    if (typeof fn === 'function')
-                        resourceSchema['pre_' + methodName] = fn.bind(instance);
-                    fn = instance[methodName];
-                    if (typeof fn === 'function')
-                        resourceSchema[methodName] = fn.bind(instance);
+                    let fn = instance[methodName];
+                    if (typeof fn === 'function') {
+                        const info = resourceSchema.resolvers[methodName] = {
+                            ...Reflect.getMetadata(constants_js_1.RESOLVER_METADATA, proto, methodName)
+                        };
+                        if (!info.forbidden) {
+                            info.handler = fn.bind(instance);
+                            fn = instance['pre_' + methodName];
+                            if (typeof fn === 'function')
+                                resourceSchema['pre_' + methodName] = fn.bind(instance);
+                        }
+                    }
+                    else
+                        resourceSchema.resolvers[methodName] = { forbidden: true };
                 }
             }
         }
@@ -148,8 +156,21 @@ class SchemaGenerator {
                 await generator.addResource(resource);
             }
         }
-        const types = Object.keys(generator._dataTypes).sort()
-            .map(name => generator._dataTypes[name]);
+        const types = Object.keys(generator._dataTypes)
+            .map(name => generator._dataTypes[name])
+            .sort((a, b) => {
+            if (a.kind !== b.kind) {
+                if (a.kind === 'SimpleType')
+                    return -1;
+                if (b.kind === 'SimpleType')
+                    return 1;
+                if (a.kind === 'ComplexType')
+                    return -1;
+                if (b.kind === 'ComplexType')
+                    return 1;
+            }
+            return (a.name < b.name ? -1 : 1);
+        });
         const resources = Object.keys(generator._resources).sort()
             .map(name => generator._resources[name]);
         return {

package/cjs/index.js

@@ -6,7 +6,7 @@ tslib_1.__exportStar(require("./constants.js"), exports);
 tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./enums/index.js"), exports);
 tslib_1.__exportStar(require("./exception/index.js"), exports);
-tslib_1.__exportStar(require("./decorators/entity-resource.decorator.js"), exports);
+tslib_1.__exportStar(require("./decorators/api-entity-resource.decorator.js"), exports);
 tslib_1.__exportStar(require("./interfaces/execution-context.interface.js"), exports);
 tslib_1.__exportStar(require("./interfaces/query.interface.js"), exports);
 tslib_1.__exportStar(require("./interfaces/resource-container.interface.js"), exports);

package/cjs/interfaces/metadata/opra-schema.metadata.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+export type ResourceReadOperationMetadata = StrictOmit<OpraSchema.ResourceReadOperation, 'handler'>;
+export type ResourceSearchOperationMetadata = StrictOmit<OpraSchema.ResourceSearchOperation, 'handler'>;
+export type ResourceCreateOperationMetadata = StrictOmit<OpraSchema.ResourceCreateOperation, 'handler'>;
+export type ResourceUpdateOperationMetadata = StrictOmit<OpraSchema.ResourceUpdateOperation, 'handler'>;
+export type ResourcePatchOperationMetadata = StrictOmit<OpraSchema.ResourcePatchOperation, 'handler'>;
+export type ResourceDeleteOperationMetadata = StrictOmit<OpraSchema.ResourceDeleteOperation, 'handler'>;
+export type ResourceExecuteOperationMetadata = StrictOmit<OpraSchema.ResourceExecuteOperation, 'handler'>;
+*/

package/cjs/interfaces/query.interface.js

@@ -25,7 +25,24 @@ var OpraQuery;
         return out;
     }
     OpraQuery.forCreate = forCreate;
-    function forGet(resource, key, options) {
+    function forGetMetadata(resourcePath, options) {
+        // if (options?.pick)
+        //   options.pick = normalizePick(resource, options.pick);
+        // if (options?.omit)
+        //   options.omit = normalizePick(resource, options.omit);
+        // if (options?.include)
+        //   options.include = normalizePick(resource, options.include);
+        const out = {
+            queryType: 'metadata',
+            scope: 'instance',
+            resourcePath,
+            operation: 'read',
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    OpraQuery.forGetMetadata = forGetMetadata;
+    function forGetEntity(resource, key, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
         if (options?.omit)
@@ -43,7 +60,7 @@ var OpraQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    OpraQuery.forGet = forGet;
+    OpraQuery.forGetEntity = forGetEntity;
     function forSearch(resource, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);

package/cjs/services/json-data-service.js

@@ -2,14 +2,245 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonDataService = void 0;
 const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const rule_judgment_1 = tslib_1.__importDefault(require("rule-judgment"));
-const data_service_js_1 = require("./data-service.js");
+const url_1 = require("@opra/url");
+const index_js_1 = require("../exception/index.js");
 // Fix invalid importing (with ESM) of rule-judgment package
-const toArrayFilter = typeof rule_judgment_1.default === 'function' ? rule_judgment_1.default : rule_judgment_1.default.default;
-class JsonDataService extends data_service_js_1.DataService {
+const createFilterFn = typeof rule_judgment_1.default === 'function'
+    ? rule_judgment_1.default
+    : rule_judgment_1.default.default;
+class JsonDataService {
+    resourceName;
     data;
+    primaryKey;
     constructor(args) {
-        super();
+        this.resourceName = args.resourceName;
+        this.data = args.data;
+        this.primaryKey = args.primaryKey;
+    }
+    processRequest(ctx) {
+        const prepared = JsonDataService.prepare(ctx.query);
+        const fn = this[prepared.method];
+        if (!fn)
+            throw new TypeError(`Unimplemented method (${prepared.method})`);
+        return fn.apply(this, prepared.args);
+    }
+    get(keyValue, options) {
+        const primaryKey = this.primaryKey;
+        let v = this.data.find(x => '' + x[primaryKey] === '' + keyValue);
+        v = JsonDataService.filterProperties(v, options?.pick, options?.omit, options?.include);
+        return v;
+    }
+    count(options) {
+        return this.search(options).length;
+    }
+    search(options) {
+        let out;
+        if (options?.filter) {
+            const filter = JsonDataService.convertFilter(options.filter);
+            const filterFn = createFilterFn(filter);
+            out = this.data.filter(filterFn);
+        }
+        else
+            out = this.data;
+        return out.map(v => JsonDataService.filterProperties(v, options?.pick, options?.omit, options?.include));
+    }
+    create(data, options) {
+        if (this.get(data[this.primaryKey]))
+            throw new index_js_1.ResourceConflictError(this.resourceName, this.primaryKey);
+        this.data.push(data);
+        return JsonDataService.filterProperties(data, options?.pick, options?.omit, options?.include);
+    }
+    update(keyValue, data, options) {
+        const primaryKey = this.primaryKey;
+        const i = this.data.findIndex(x => '' + x[primaryKey] === '' + keyValue);
+        if (i >= 0) {
+            data = Object.assign(this.data[i], data);
+            return JsonDataService.filterProperties(data, options?.pick, options?.omit, options?.include);
+        }
+    }
+    updateMany(data, options) {
+        const items = this.search({ filter: options?.filter });
+        for (let i = 0; i < items.length; i++) {
+            Object.assign(items[i], data);
+        }
+        return items.length;
+    }
+    delete(keyValue) {
+        const primaryKey = this.primaryKey;
+        const i = this.data.findIndex(x => '' + x[primaryKey] === '' + keyValue);
+        if (i >= 0) {
+            this.data = this.data.slice(i, 1);
+            return true;
+        }
+        return false;
+    }
+    deleteMany(options) {
+        const items = this.search({ filter: options?.filter });
+        this.data = this.data.filter(x => !items.includes(x));
+        return items.length;
+    }
+    static filterProperties(obj, pick, omit, include) {
+        if (!obj)
+            return;
+        return obj;
+    }
+    static prepare(query) {
+        switch (query.queryType) {
+            case 'create': {
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                }, lodash_1.default.isNil);
+                const { data } = query;
+                return {
+                    method: query.queryType,
+                    values: data,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'get': {
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                }, lodash_1.default.isNil);
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+            case 'search': {
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                    sort: query.sort?.length ? query.sort : undefined,
+                    limit: query.limit,
+                    offset: query.skip,
+                    distinct: query.distinct,
+                    total: query.count,
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, lodash_1.default.isNil);
+                return {
+                    method: query.queryType,
+                    options,
+                    args: [options]
+                };
+            }
+            case 'update': {
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                }, lodash_1.default.isNil);
+                const { data } = query;
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue: query.keyValue,
+                    values: data,
+                    options,
+                    args: [keyValue, data, options]
+                };
+            }
+            case 'updateMany': {
+                const options = lodash_1.default.omitBy({
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, lodash_1.default.isNil);
+                const { data } = query;
+                return {
+                    method: query.queryType,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'delete': {
+                const options = {};
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+            case 'deleteMany': {
+                const options = lodash_1.default.omitBy({
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, lodash_1.default.isNil);
+                return {
+                    method: query.queryType,
+                    options,
+                    args: [options]
+                };
+            }
+            default:
+                throw new Error(`Unimplemented query type "${query.queryType}"`);
+        }
+    }
+    static convertFilter(str) {
+        const ast = typeof str === 'string'
+            ? (0, url_1.$parse)(str)
+            : str;
+        if (!ast || !(ast instanceof url_1.Expression))
+            return ast;
+        if (ast instanceof url_1.ComparisonExpression) {
+            const left = JsonDataService.convertFilter(ast.left);
+            const right = JsonDataService.convertFilter(ast.right);
+            switch (ast.op) {
+                case '=':
+                    return { $eq: { [left]: right } };
+                case '!=':
+                    return { $ne: { [left]: right } };
+                case '>':
+                    return { $gt: { [left]: right } };
+                case '>=':
+                    return { $gte: { [left]: right } };
+                case '<':
+                    return { $lt: { [left]: right } };
+                case '<=':
+                    return { $lte: { [left]: right } };
+                case 'in':
+                    return { $in: { [left]: right } };
+                case '!in':
+                    return { $nin: { [left]: right } };
+                default:
+                    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+            }
+        }
+        if (ast instanceof url_1.QualifiedIdentifier) {
+            return ast.value;
+        }
+        if (ast instanceof url_1.NumberLiteral ||
+            ast instanceof url_1.StringLiteral ||
+            ast instanceof url_1.BooleanLiteral ||
+            ast instanceof url_1.NullLiteral ||
+            ast instanceof url_1.DateLiteral ||
+            ast instanceof url_1.TimeLiteral) {
+            return ast.value;
+        }
+        if (ast instanceof url_1.ArrayExpression) {
+            return ast.items.map(JsonDataService.convertFilter);
+        }
+        if (ast instanceof url_1.LogicalExpression) {
+            if (ast.op === 'or')
+                return { $or: ast.items.map(JsonDataService.convertFilter) };
+            return { $and: ast.items.map(JsonDataService.convertFilter) };
+        }
+        if (ast instanceof url_1.ArrayExpression) {
+            return ast.items.map(JsonDataService.convertFilter);
+        }
+        if (ast instanceof url_1.ParenthesesExpression) {
+            return JsonDataService.convertFilter(ast.expression);
+        }
+        throw new Error(`${ast.type} is not implemented yet`);
     }
 }
 exports.JsonDataService = JsonDataService;

package/cjs/utils/create-i18n.js

@@ -8,8 +8,8 @@ const get_caller_file_util_js_1 = require("./get-caller-file.util.js");
 async function createI18n(options) {
     const opts = {
         ...options,
-        resourceDirs: undefined
     };
+    delete opts.resourceDirs;
     const instance = i18n_1.I18n.createInstance(opts);
     await instance.init();
     await instance.loadResourceDir(path_1.default.resolve((0, get_caller_file_util_js_1.getCallerFile)(), '../../../i18n'));

package/cjs/utils/get-caller-file.util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCallerFile = void 0;
+const PATH_PATTERN = /^(?:file:\/\/)?(.+)$/;
 function getCallerFile(position = 1) {
     if (position >= Error.stackTraceLimit) {
         throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
@@ -13,7 +14,11 @@ function getCallerFile(position = 1) {
     if (stack !== null && typeof stack === 'object') {
         // stack[0] holds this file
         // stack[1] holds where this function was called
-        return stack[position] ? stack[position].getFileName() : undefined;
+        const s = stack[position] ?
+            stack[position].getFileName() : undefined;
+        const m = s ? PATH_PATTERN.exec(s) : undefined;
+        return m ? m[1] : '';
     }
+    return '';
 }
 exports.getCallerFile = getCallerFile;

package/esm/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const OpraVersion = "1.0";
 export declare const RESOURCE_METADATA = "opra:resource.metadata";
+export declare const RESOLVER_METADATA = "opra:resolver.metadata";

package/esm/constants.js

@@ -1,2 +1,3 @@
 export const OpraVersion = '1.0';
 export const RESOURCE_METADATA = 'opra:resource.metadata';
+export const RESOLVER_METADATA = 'opra:resolver.metadata';

package/esm/decorators/{entity-resource.decorator.d.ts → api-entity-resource.decorator.d.ts}

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { EntityResourceMetadata } from '../interfaces/opra-schema.metadata.js';
+import { EntityResourceMetadata } from '../interfaces/metadata/opra-schema.metadata.js';
 import { TypeThunkAsync } from '../types.js';
 export declare type EntityResourceOptions = Pick<EntityResourceMetadata, 'name' | 'description'> & {};
 export declare function ApiEntityResource(entityFunc: TypeThunkAsync, options?: EntityResourceOptions): (target: Function) => void;

package/esm/decorators/api-resolver.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ApiResolverMetadata } from '../interfaces/metadata/api-resolver.metadata.js';
+export declare function ApiResolver(options?: ApiResolverMetadata): PropertyDecorator;

package/esm/decorators/api-resolver.decorator.js

@@ -0,0 +1,9 @@
+import { RESOLVER_METADATA } from '../constants.js';
+export function ApiResolver(options) {
+    return (target, propertyKey) => {
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}

package/esm/exception/http-errors/not-acceptable.error.d.ts

@@ -0,0 +1,10 @@
+import { ApiException, ErrorResponse } from '../api-exception.js';
+/**
+ * 406 Not Acceptable
+ * This response is sent when the web server, after performing server-driven content negotiation,
+ * doesn't find any content that conforms to the criteria given by the user agent.
+ */
+export declare class NotAcceptableError extends ApiException {
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
+}

package/esm/exception/http-errors/not-acceptable.error.js

@@ -0,0 +1,22 @@
+import { translate } from '@opra/i18n';
+import { HttpStatus } from '../../enums/index.js';
+import { ApiException } from '../api-exception.js';
+/**
+ * 406 Not Acceptable
+ * This response is sent when the web server, after performing server-driven content negotiation,
+ * doesn't find any content that conforms to the criteria given by the user agent.
+ */
+export class NotAcceptableError extends ApiException {
+    constructor(response, cause) {
+        super(response, cause);
+        this.status = HttpStatus.NOT_ACCEPTABLE;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: translate('error:NOT_ACCEPTABLE', 'Not Acceptable'),
+            severity: 'error',
+            code: 'NOT_ACCEPTABLE',
+            ...response
+        });
+    }
+}

package/esm/exception/index.d.ts

@@ -4,7 +4,9 @@ export * from './http-errors/failed-dependency.error.js';
 export * from './http-errors/forbidden.error.js';
 export * from './http-errors/internal-server.error.js';
 export * from './http-errors/method-not-allowed.error.js';
+export * from './http-errors/not-acceptable.error.js';
 export * from './http-errors/not-found.error.js';
 export * from './http-errors/unauthorized.error.js';
 export * from './http-errors/unprocessable-entity.error.js';
 export * from './resource-errors/resource-conflict.error.js';
+export * from './resource-errors/resource-not-found.error.js';

package/esm/exception/index.js

@@ -4,7 +4,9 @@ export * from './http-errors/failed-dependency.error.js';
 export * from './http-errors/forbidden.error.js';
 export * from './http-errors/internal-server.error.js';
 export * from './http-errors/method-not-allowed.error.js';
+export * from './http-errors/not-acceptable.error.js';
 export * from './http-errors/not-found.error.js';
 export * from './http-errors/unauthorized.error.js';
 export * from './http-errors/unprocessable-entity.error.js';
 export * from './resource-errors/resource-conflict.error.js';
+export * from './resource-errors/resource-not-found.error.js';

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

@@ -0,0 +1,4 @@
+import { ApiException } from '../api-exception.js';
+export declare class ResourceNotFoundError extends ApiException {
+    constructor(resource: string, keyValue: any, cause?: Error);
+}

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

@@ -0,0 +1,15 @@
+import { translate } from '@opra/i18n';
+import { HttpStatus } from '../../enums/index.js';
+import { ApiException } from '../api-exception.js';
+export class ResourceNotFoundError extends ApiException {
+    constructor(resource, keyValue, cause) {
+        super({
+            message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + '@' + keyValue }),
+            severity: 'error',
+            code: 'RESOURCE_NOT_FOUND',
+            subject: resource,
+            key: keyValue
+        }, cause);
+        this.status = HttpStatus.NOT_FOUND;
+    }
+}

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

@@ -8,11 +8,6 @@ export declare namespace OpraAdapter {
         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?: UserContextResolver;
@@ -57,5 +52,6 @@ export declare abstract class OpraAdapter<TExecutionContext extends IExecutionCo
     protected abstract sendError(executionContext: TExecutionContext, error: ApiException): Promise<void>;
     protected abstract isBatch(executionContext: TExecutionContext): boolean;
     protected handler(executionContext: TExecutionContext): Promise<void>;
+    protected _metadataExecute(ctx: QueryContext): Promise<void>;
     protected static initI18n(options?: OpraAdapter.Options): Promise<I18n>;
 }

package/esm/implementation/adapter/adapter.js

@@ -1,6 +1,6 @@
 import { AsyncEventEmitter } from 'strict-typed-events';
 import { I18n } from '@opra/i18n';
-import { FailedDependencyError } from '../../exception/index.js';
+import { BadRequestError, FailedDependencyError } from '../../exception/index.js';
 import { wrapError } from '../../exception/wrap-error.js';
 import { createI18n } from '../../utils/create-i18n.js';
 export class OpraAdapter {
@@ -38,8 +38,12 @@ export class OpraAdapter {
                     continue;
                 }
                 try {
-                    const resource = context.query.resource;
                     const promise = (async () => {
+                        if (context.query.queryType === 'metadata') {
+                            await this._metadataExecute(context);
+                            return;
+                        }
+                        const resource = context.query.resource;
                         await resource.prepare(context);
                         if (this.userContextResolver && !userContext)
                             userContext = this.userContextResolver({
@@ -88,6 +92,32 @@ export class OpraAdapter {
             }
         }
     }
+    async _metadataExecute(ctx) {
+        const query = ctx.query;
+        let out;
+        if (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.getMetadata();
+                query.resourcePath[1] = resource.name;
+            }
+            else if (query.resourcePath[0] === 'types') {
+                const dataType = this.service.getDataType(query.resourcePath[1]);
+                out = dataType.getMetadata();
+                query.resourcePath[1] = dataType.name;
+            }
+            else
+                throw new BadRequestError();
+            ctx.response.value = {
+                '@opra:metadata': '/$metadata/' + query.resourcePath.join('/'),
+                ...out
+            };
+            return;
+        }
+        ctx.response.value = this.service.getMetadata();
+    }
     static async initI18n(options) {
         if (options?.i18n instanceof I18n)
             return options.i18n;

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

@@ -1,7 +1,7 @@
 import { OpraURL } from '@opra/url';
 import { ApiException } from '../../exception/index.js';
 import { IHttpExecutionContext } from '../../interfaces/execution-context.interface.js';
-import { OpraQuery } from '../../interfaces/query.interface.js';
+import { OpraMetadataQuery, OpraQuery } from '../../interfaces/query.interface.js';
 import { HeadersObject } from '../../utils/headers.js';
 import { QueryContext } from '../query-context.js';
 import { OpraAdapter } from './adapter.js';
@@ -18,6 +18,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: HeadersObject, body?: any): QueryContext;
+    buildMetadataQuery(url: OpraURL): OpraMetadataQuery;
     buildQuery(url: OpraURL, method: string, body?: any): OpraQuery | undefined;
     protected sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
     protected isBatch(executionContext: TExecutionContext): boolean;