@opra/core 0.0.12 → 0.1.0

package/cjs/interfaces/query.interface.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraQuery = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const complex_type_js_1 = require("../implementation/data-type/complex-type.js");
-const string_path_to_object_tree_js_1 = require("../utils/string-path-to-object-tree.js");
+const schema_1 = require("@opra/schema");
+const path_to_tree_js_1 = require("../utils/path-to-tree.js");
 var OpraQuery;
 (function (OpraQuery) {
     function forCreate(resource, values, options) {
@@ -25,7 +25,24 @@ var OpraQuery;
         return out;
     }
     OpraQuery.forCreate = forCreate;
-    function forGet(resource, key, options) {
+    function forGetSchema(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: 'schema',
+            scope: 'instance',
+            resourcePath,
+            operation: 'read',
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    OpraQuery.forGetSchema = forGetSchema;
+    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);
@@ -151,19 +168,19 @@ function checkKeyFields(resource, key) {
         throw new Error(`"${resource.name}" has no primary key`);
 }
 function normalizePick(resource, fields) {
-    const fieldsTree = (0, string_path_to_object_tree_js_1.stringPathToObjectTree)(fields) || {};
+    const fieldsTree = (0, path_to_tree_js_1.pathToTree)(fields) || {};
     return _normalizeFieldsList([], resource.service, resource, resource.dataType, fieldsTree, '', {
-        additionalProperties: true
+        additionalFields: true
     });
 }
 function _normalizeFieldsList(target, service, resource, dataType, node, parentPath = '', options) {
     let curPath = '';
     for (const k of Object.keys(node)) {
         const nodeVal = node[k];
-        const prop = dataType?.properties?.[k];
+        const prop = dataType?.fields.get(k);
         if (!prop) {
             curPath = parentPath ? parentPath + '.' + k : k;
-            if (!options?.additionalProperties || (dataType && !dataType.additionalProperties))
+            if (!options?.additionalFields || (dataType && !dataType.additionalFields))
                 throw new TypeError(`Unknown field path "${resource.name + '.' + curPath}"`);
             if (typeof nodeVal === 'object')
                 _normalizeFieldsList(target, service, resource, undefined, nodeVal, curPath, options);
@@ -174,7 +191,7 @@ function _normalizeFieldsList(target, service, resource, dataType, node, parentP
         curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
         const propType = service.getDataType(prop.type || 'string');
         if (typeof nodeVal === 'object') {
-            if (!(propType instanceof complex_type_js_1.ComplexType))
+            if (!(propType && propType instanceof schema_1.ComplexType))
                 throw new TypeError(`"${curPath}" is not a complex type and has no sub fields`);
             if (target.findIndex(x => x === parentPath) >= 0)
                 continue;

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

@@ -2,14 +2,251 @@
 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.filterFields(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.filterFields(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.filterFields(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.filterFields(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 filterFields(obj, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    pick, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    omit, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    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/cjs/utils/{string-path-to-object-tree.js → path-to-tree.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringPathToObjectTree = void 0;
+exports.pathToTree = void 0;
 const dotPattern = /^([^.]+)\.(.*)$/;
-function stringPathToObjectTree(arr) {
+function pathToTree(arr) {
     if (!arr.length)
         return;
     return _stringPathToObjectTree(arr, {});
 }
-exports.stringPathToObjectTree = stringPathToObjectTree;
+exports.pathToTree = pathToTree;
 function _stringPathToObjectTree(arr, target) {
     for (const k of arr) {
         const m = dotPattern.exec(k);

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

@@ -2,7 +2,8 @@
  * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#controls
  */
 export declare enum HttpHeaders {
-    X_Opra_Version = "X-Opra-Version",
+    X_Opra_Version = "X-OPRA-Version",
+    X_Opra_Schema = "X-OPRA-Schema",
     /**
      * Defines the authentication method that should be used to access a resource.
      */

package/esm/enums/http-headers.enum.js

@@ -5,7 +5,8 @@
 export var HttpHeaders;
 (function (HttpHeaders) {
     /* *** Custom Headers *** */
-    HttpHeaders["X_Opra_Version"] = "X-Opra-Version";
+    HttpHeaders["X_Opra_Version"] = "X-OPRA-Version";
+    HttpHeaders["X_Opra_Schema"] = "X-OPRA-Schema";
     /* *** Authentication *** */
     /**
      * Defines the authentication method that should be used to access a resource.

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-utils/entity-resource-execute.util.d.ts

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

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

@@ -0,0 +1,80 @@
+import { translate } from '@opra/i18n';
+import { ComplexType } 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)) {
+        const promises = [];
+        let search;
+        let count;
+        promises.push(executeFn(service, resource, context, query.queryType)
+            .then(v => search = v));
+        if (query.count) {
+            promises.push(executeFn(service, resource, context, 'count')
+                .then(v => count = v));
+        }
+        await Promise.all(promises);
+        context.response.value = {
+            ...search,
+            ...count
+        };
+        return;
+    }
+    context.response.value = await executeFn(service, resource, context, query.queryType);
+}
+async function executeFn(service, resource, context, queryType) {
+    const resolverInfo = resource.metadata.methods?.[queryType];
+    if (!resolverInfo.handler)
+        throw new ForbiddenError({
+            message: translate('RESOLVER_FORBIDDEN', { queryType }),
+            severity: 'error',
+            code: 'RESOLVER_FORBIDDEN'
+        });
+    let result = await resolverInfo.handler(context);
+    switch (queryType) {
+        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] : [])
+            };
+        case 'get':
+        case 'update':
+            if (!result) {
+                const query = context.query;
+                throw new ResourceNotFoundError(resource.name, query.keyValue);
+            }
+            break;
+        case 'count':
+            return { count: result || 0 };
+        case 'delete':
+        case 'deleteMany':
+        case 'updateMany':
+            let affectedRecords;
+            if (typeof result === 'number')
+                affectedRecords = result;
+            if (typeof result === 'boolean')
+                affectedRecords = result ? 1 : 0;
+            if (typeof result === 'object')
+                affectedRecords = result.affectedRows || result.affectedRecords;
+            return { affectedRecords };
+    }
+    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 ? service.types.get(prop.type) : undefined;
+            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);
+    return result;
+}

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

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

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

@@ -0,0 +1,7 @@
+import { EntityResource } from '@opra/schema';
+import { entityResourceExecute } from './entity-resource-execute.util.js';
+export async function resourceExecute(service, resource, context) {
+    if (resource instanceof EntityResource)
+        return await entityResourceExecute(service, resource, context);
+    throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+}

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

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

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

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

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

@@ -1,18 +1,13 @@
 import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
-import { ApiException } from '../../exception/index.js';
-import { IExecutionContext } from '../../interfaces/execution-context.interface.js';
-import { OpraService } from '../opra-service.js';
-import { QueryContext } from '../query-context.js';
+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 {
     type UserContextResolver = (args: {
         executionContext: IExecutionContext;
         isBatch: boolean;
     }) => object | Promise<object>;
-    type RequestFinishEvent = (args: {
-        executionContext: IExecutionContext;
-        userContext?: any;
-        failed: boolean;
-    }) => Promise<void>;
     interface Options {
         i18n?: I18n | I18nOptions | (() => Promise<I18n>);
         userContext?: 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 _getSchemaExecute(ctx: QueryContext): Promise<void>;
     protected static initI18n(options?: OpraAdapter.Options): Promise<I18n>;
 }