@opra/core 0.0.5 → 0.0.8

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityResourceHandler = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const execution_query_interface_js_1 = require("../../interfaces/execution-query.interface.js");
+const entity_type_js_1 = require("../data-type/entity-type.js");
+const resource_handler_js_1 = require("./resource-handler.js");
+var isSearchQuery = execution_query_interface_js_1.ExecutionQuery.isSearchQuery;
+class EntityResourceHandler extends resource_handler_js_1.ResourceHandler {
+    service;
+    dataType;
+    constructor(args) {
+        super({
+            kind: 'EntityResource',
+            ...lodash_1.default.omit(args, ['dataType', 'service'])
+        });
+        this.dataType = args.dataType;
+        this.service = args.service;
+        // noinspection SuspiciousTypeOfGuard
+        if (!(args.dataType instanceof entity_type_js_1.EntityType))
+            throw new TypeError(`You should provide an EntityType for EntityResourceController`);
+    }
+    async execute(ctx) {
+        const { query } = ctx.request;
+        if (isSearchQuery(query)) {
+            const promises = [];
+            let search;
+            let count;
+            promises.push(this._executeFn(ctx, query.queryType)
+                .then(v => search = v));
+            if (query.count) {
+                promises.push(this._executeFn(ctx, 'count')
+                    .then(v => count = v));
+            }
+            await Promise.all(promises);
+            ctx.response.value = {
+                ...search,
+                ...count
+            };
+            return;
+        }
+        ctx.response.value = await this._executeFn(ctx, query.queryType);
+    }
+    async _executeFn(ctx, fnName) {
+        const fn = this._args[fnName];
+        let result = typeof fn === 'function' ? (await fn(ctx)) : undefined;
+        switch (fnName) {
+            case 'search':
+                return { items: Array.isArray(result) ? result : (ctx.response.value ? [result] : []) };
+            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 };
+            default:
+                result = Array.isArray(result) ? result[0] : result;
+                if (result && ctx.request.resultPath) {
+                    const pathArray = ctx.request.resultPath.split('.');
+                    for (const property of pathArray) {
+                        result = result && typeof result === 'object' && result[property];
+                    }
+                }
+                return result;
+        }
+    }
+}
+exports.EntityResourceHandler = EntityResourceHandler;

package/cjs/implementation/resource/{resource-info.js → resource-handler.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceInfo = void 0;
+exports.ResourceHandler = void 0;
 const terminal_utils_js_1 = require("../../utils/terminal-utils.js");
-class ResourceInfo {
+class ResourceHandler {
     _args;
     constructor(args) {
         this._args = args;
@@ -16,9 +16,16 @@ class ResourceInfo {
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
     }
+    async prepare(ctx) {
+        const { query } = ctx.request;
+        const fn = this._args['pre_' + query.queryType];
+        if (fn && typeof fn === 'function') {
+            await fn(ctx);
+        }
+    }
     [terminal_utils_js_1.nodeInspectCustom]() {
         return `[${terminal_utils_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + terminal_utils_js_1.colorReset}` +
             ` ${terminal_utils_js_1.colorFgMagenta + this.name + terminal_utils_js_1.colorReset}]`;
     }
 }
-exports.ResourceInfo = ResourceInfo;
+exports.ResourceHandler = ResourceHandler;

package/cjs/implementation/schema-generator.js

@@ -6,7 +6,7 @@ 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");
-const entityMethods = ['search', 'create', 'read', 'update', 'updateMany', 'delete', 'deleteMany'];
+const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
 class SchemaGenerator {
     _dataTypes = {};
     _resources = {};
@@ -104,14 +104,17 @@ class SchemaGenerator {
             resourceSchema = {
                 ...metadata,
                 type,
-                name
+                name,
+                instance
             };
             if (schema_1.OpraSchema.isEntityResource(resourceSchema)) {
                 for (const methodName of entityMethods) {
-                    const fn = instance[methodName];
-                    if (typeof fn === 'function') {
+                    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);
-                    }
                 }
             }
         }

package/cjs/index.js

@@ -9,17 +9,19 @@ tslib_1.__exportStar(require("./exception/index.js"), exports);
 tslib_1.__exportStar(require("./decorators/entity-resource.decorator.js"), exports);
 tslib_1.__exportStar(require("./interfaces/http-context.interface.js"), exports);
 tslib_1.__exportStar(require("./interfaces/execution-query.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/entity-resource.interface.js"), exports);
 tslib_1.__exportStar(require("./interfaces/resource-container.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/user-context.interface.js"), exports);
 tslib_1.__exportStar(require("./implementation/execution-context.js"), exports);
 tslib_1.__exportStar(require("./implementation/opra-document.js"), exports);
 tslib_1.__exportStar(require("./implementation/opra-service.js"), exports);
 tslib_1.__exportStar(require("./implementation/schema-generator.js"), exports);
 tslib_1.__exportStar(require("./implementation/adapter/adapter.js"), exports);
+tslib_1.__exportStar(require("./implementation/adapter/http-adapter.js"), exports);
 tslib_1.__exportStar(require("./implementation/adapter/express-adapter.js"), exports);
 tslib_1.__exportStar(require("./implementation/data-type/data-type.js"), exports);
 tslib_1.__exportStar(require("./implementation/data-type/complex-type.js"), exports);
 tslib_1.__exportStar(require("./implementation/data-type/simple-type.js"), exports);
-tslib_1.__exportStar(require("./implementation/resource/resource-info.js"), exports);
-tslib_1.__exportStar(require("./implementation/resource/entity-resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/resource-handler.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/entity-resource-handler.js"), exports);
+tslib_1.__exportStar(require("./services/entity-resource-controller.js"), exports);
 tslib_1.__exportStar(require("./services/json-data-service.js"), exports);

package/cjs/interfaces/execution-query.interface.js

@@ -25,7 +25,7 @@ var ExecutionQuery;
         return out;
     }
     ExecutionQuery.forCreate = forCreate;
-    function forRead(resource, key, options) {
+    function forGet(resource, key, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
         if (options?.omit)
@@ -34,7 +34,7 @@ var ExecutionQuery;
             options.include = normalizePick(resource, options.include);
         checkKeyFields(resource, key);
         const out = {
-            queryType: 'read',
+            queryType: 'get',
             scope: 'instance',
             operationType: 'read',
             resource,
@@ -43,7 +43,7 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forRead = forRead;
+    ExecutionQuery.forGet = forGet;
     function forSearch(resource, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -63,9 +63,9 @@ var ExecutionQuery;
         return out;
     }
     ExecutionQuery.forSearch = forSearch;
-    function forProperty(property, options) {
+    function forGetProperty(property, options) {
         const out = {
-            queryType: 'read',
+            queryType: 'get',
             scope: 'property',
             operationType: 'read',
             property
@@ -73,7 +73,7 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forProperty = forProperty;
+    ExecutionQuery.forGetProperty = forGetProperty;
     function forUpdate(resource, keyValue, values, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);

package/cjs/services/entity-resource-controller.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityResourceController = void 0;
+class EntityResourceController {
+    async search(ctx) {
+        return (await this.getService(ctx)).processRequest(ctx);
+    }
+    async get(ctx) {
+        return (await this.getService(ctx)).processRequest(ctx);
+    }
+    async count(ctx) {
+        return (await this.getService(ctx)).processRequest(ctx);
+    }
+    async create(ctx) {
+        return (await this.getService(ctx)).processRequest(ctx);
+    }
+    async update(ctx) {
+        return (await this.getService(ctx)).processRequest(ctx);
+    }
+    async updateMany(ctx) {
+        return (await this.getService(ctx)).processRequest(ctx);
+    }
+    async delete(ctx) {
+        return (await this.getService(ctx)).processRequest(ctx);
+    }
+    async deleteMany(ctx) {
+        return (await this.getService(ctx)).processRequest(ctx);
+    }
+}
+exports.EntityResourceController = EntityResourceController;

package/esm/exception/api-exception.d.ts

@@ -20,19 +20,20 @@ export interface ErrorResponse {
     /**
      * Additional diagnostic information about the issue. Error stack etc.
      */
-    diagnostics?: string;
+    diagnostics?: string | string[];
     [index: string]: any;
 }
 /**
  * Defines the base Opra exception, which is handled by the default Exceptions Handler.
  */
 export declare class ApiException extends Error {
-    readonly originalError?: Error;
+    static stackAsDiagnostics: boolean;
     response: ErrorResponse;
     status: number;
-    constructor(response: string | ErrorResponse | Error, status?: number);
+    cause?: Error;
+    constructor(response: string | ErrorResponse | Error, cause?: Error);
     setStatus(status: number | HttpStatus): this;
     protected _initName(): void;
     protected _initResponse(init: string | ErrorResponse | Error): void;
-    static wrap(response: string | ErrorResponse | Error, status?: number): ApiException;
+    static wrap(response: string | ErrorResponse | Error): ApiException;
 }

package/esm/exception/api-exception.js

@@ -1,18 +1,20 @@
 import { HttpStatus } from '../enums/index.js';
-const nodeEnv = process.env.NODE_ENV || '';
 /**
  * Defines the base Opra exception, which is handled by the default Exceptions Handler.
  */
 export class ApiException extends Error {
-    originalError;
+    static stackAsDiagnostics = false;
     response;
     status;
-    constructor(response, status) {
-        super();
+    cause;
+    constructor(response, cause) {
+        super('');
         this._initName();
-        this.setStatus(status || HttpStatus.INTERNAL_SERVER_ERROR);
-        if (response instanceof Error)
-            this.originalError = response;
+        if (cause)
+            Object.defineProperty(this, 'cause', { enumerable: false, configurable: true, writable: true, value: cause });
+        else if (response instanceof Error)
+            Object.defineProperty(this, 'cause', { enumerable: false, configurable: true, writable: true, value: response });
+        this.status = HttpStatus.INTERNAL_SERVER_ERROR;
         this._initResponse(response);
     }
     setStatus(status) {
@@ -35,11 +37,7 @@ export class ApiException extends Error {
             this.response = {
                 message: x.message || x.details || ('' + init),
             };
-            if (init instanceof Error) {
-                if (nodeEnv === 'dev' || nodeEnv === 'development')
-                    this.response.diagnostics = init.stack;
-            }
-            else
+            if (!(init instanceof Error))
                 Object.assign(this.response, init);
         }
         else {
@@ -47,13 +45,23 @@ export class ApiException extends Error {
                 message: '' + init,
             };
         }
+        if (this.cause instanceof Error && this.cause.stack) {
+            if (ApiException.stackAsDiagnostics)
+                this.response.diagnostics = this.cause.stack.split('\n');
+            this.stack = this.cause.stack;
+        }
         if (!this.response.severity)
             if (this.status >= 500)
                 this.response.severity = 'fatal';
             else
                 this.response.severity = 'error';
     }
-    static wrap(response, status) {
-        return response instanceof ApiException ? response : new this(response, status);
+    static wrap(response) {
+        if (response instanceof ApiException)
+            return response;
+        const out = new this(response, response instanceof Error ? response : undefined);
+        if (response instanceof Error)
+            out.stack = response.stack;
+        return out;
     }
 }

package/esm/exception/errors/bad-request.error.d.ts

@@ -5,5 +5,5 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
  */
 export declare class BadRequestError extends ApiException {
-    constructor(response?: ErrorResponse);
+    constructor(response?: ErrorResponse, cause?: Error);
 }

package/esm/exception/errors/bad-request.error.js

@@ -7,12 +7,13 @@ import { ApiException } from '../api-exception.js';
  * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
  */
 export class BadRequestError extends ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: translate('error:BAD_REQUEST', 'Bad request'),
             severity: 'error',
             code: 'BAD_REQUEST',
             ...response
-        }, HttpStatus.BAD_REQUEST);
+        }, cause);
+        this.status = HttpStatus.BAD_REQUEST;
     }
 }

package/esm/exception/errors/failed-dependency.error.d.ts

@@ -4,5 +4,5 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The request failed due to failure of a previous request.
  */
 export declare class FailedDependencyError extends ApiException {
-    constructor(response?: ErrorResponse);
+    constructor(response?: ErrorResponse, cause?: Error);
 }

package/esm/exception/errors/failed-dependency.error.js

@@ -6,12 +6,13 @@ import { ApiException } from '../api-exception.js';
  * The request failed due to failure of a previous request.
  */
 export class FailedDependencyError extends ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: translate('error:FAILED_DEPENDENCY', 'The request failed due to failure of a previous request.'),
             severity: 'error',
             code: 'FAILED_DEPENDENCY',
             ...response
-        }, HttpStatus.FAILED_DEPENDENCY);
+        }, cause);
+        this.status = HttpStatus.FAILED_DEPENDENCY;
     }
 }

package/esm/exception/errors/forbidden.error.d.ts

@@ -6,5 +6,5 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * the client's identity is known to the server.
  */
 export declare class ForbiddenError extends ApiException {
-    constructor(response?: ErrorResponse);
+    constructor(response?: ErrorResponse, cause?: Error);
 }

package/esm/exception/errors/forbidden.error.js

@@ -8,12 +8,13 @@ import { ApiException } from '../api-exception.js';
  * the client's identity is known to the server.
  */
 export class ForbiddenError extends ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: translate('error:FORBIDDEN', 'Forbidden'),
             severity: 'error',
             code: 'FORBIDDEN',
             ...response
-        }, HttpStatus.FORBIDDEN);
+        }, cause);
+        this.status = HttpStatus.FORBIDDEN;
     }
 }

package/esm/exception/errors/internal-server.error.d.ts

@@ -4,5 +4,5 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The server has encountered a situation it does not know how to handle.
  */
 export declare class InternalServerError extends ApiException {
-    constructor(response?: ErrorResponse);
+    constructor(response?: ErrorResponse, cause?: Error);
 }

package/esm/exception/errors/internal-server.error.js

@@ -6,12 +6,13 @@ import { ApiException } from '../api-exception.js';
  * The server has encountered a situation it does not know how to handle.
  */
 export class InternalServerError extends ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: translate('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
             severity: 'error',
             code: 'INTERNAL_SERVER_ERROR',
             ...response
-        }, HttpStatus.INTERNAL_SERVER_ERROR);
+        }, cause);
+        this.status = HttpStatus.INTERNAL_SERVER_ERROR;
     }
 }

package/esm/exception/errors/method-not-allowed.error.d.ts

@@ -5,5 +5,5 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * For example, an API may not allow calling DELETE to remove a resource.
  */
 export declare class MethodNotAllowedError extends ApiException {
-    constructor(response?: ErrorResponse);
+    constructor(response?: ErrorResponse, cause?: Error);
 }

package/esm/exception/errors/method-not-allowed.error.js

@@ -7,12 +7,13 @@ import { ApiException } from '../api-exception.js';
  * For example, an API may not allow calling DELETE to remove a resource.
  */
 export class MethodNotAllowedError extends ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: translate('error:METHOD_NOT_ALLOWED', 'Method Not Allowed'),
             severity: 'error',
             code: 'METHOD_NOT_ALLOWED',
             ...response
-        }, HttpStatus.METHOD_NOT_ALLOWED);
+        }, cause);
+        this.status = HttpStatus.METHOD_NOT_ALLOWED;
     }
 }

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

@@ -8,5 +8,5 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * frequent occurrence on the web.
  */
 export declare class NotFoundError extends ApiException {
-    constructor(response?: ErrorResponse);
+    constructor(response?: ErrorResponse, cause?: Error);
 }

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

@@ -10,12 +10,13 @@ import { ApiException } from '../api-exception.js';
  * frequent occurrence on the web.
  */
 export class NotFoundError extends ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: translate('error:NOT_FOUND', 'Not found'),
             severity: 'error',
             code: 'NOT_FOUND',
             ...response
-        }, HttpStatus.NOT_FOUND);
+        }, cause);
+        this.status = HttpStatus.NOT_FOUND;
     }
 }

package/esm/exception/errors/unauthorized.error.d.ts

@@ -5,5 +5,5 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * That is, the client must authenticate itself to get the requested response.
  */
 export declare class UnauthorizedError extends ApiException {
-    constructor(response?: ErrorResponse);
+    constructor(response?: ErrorResponse, cause?: Error);
 }

package/esm/exception/errors/unauthorized.error.js

@@ -7,12 +7,13 @@ import { ApiException } from '../api-exception.js';
  * That is, the client must authenticate itself to get the requested response.
  */
 export class UnauthorizedError extends ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: translate('error:UNAUTHORIZED', 'Unauthorized'),
             severity: 'error',
             code: 'UNAUTHORIZED',
             ...response
-        }, HttpStatus.UNAUTHORIZED);
+        }, cause);
+        this.status = HttpStatus.UNAUTHORIZED;
     }
 }

package/esm/exception/errors/unprocessable-entity.error.d.ts

@@ -4,5 +4,5 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The request was well-formed but was unable to be followed due to semantic errors.
  */
 export declare class UnprocessableEntityError extends ApiException {
-    constructor(response?: ErrorResponse);
+    constructor(response?: ErrorResponse, cause?: Error);
 }

package/esm/exception/errors/unprocessable-entity.error.js

@@ -6,12 +6,13 @@ import { ApiException } from '../api-exception.js';
  * The request was well-formed but was unable to be followed due to semantic errors.
  */
 export class UnprocessableEntityError extends ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: translate('error:UNPROCESSABLE_ENTITY', 'Unprocessable entity'),
             severity: 'error',
             code: 'UNPROCESSABLE_ENTITY',
             ...response
-        }, HttpStatus.UNPROCESSABLE_ENTITY);
+        }, cause);
+        this.status = HttpStatus.UNPROCESSABLE_ENTITY;
     }
 }

package/esm/exception/wrap-error.d.ts

@@ -0,0 +1,2 @@
+import { ApiException, ErrorResponse } from './api-exception.js';
+export declare function wrapError(response: string | ErrorResponse | Error): ApiException;

package/esm/exception/wrap-error.js

@@ -0,0 +1,13 @@
+import { ApiException } from './api-exception.js';
+import { InternalServerError } from './errors/internal-server.error.js';
+export function wrapError(response) {
+    if (response instanceof ApiException)
+        return response;
+    if (response instanceof Error) {
+        const x = response;
+        if (typeof x.status === 'number' || typeof x.getStatus === 'function')
+            return new ApiException(response);
+        return new InternalServerError(undefined, response);
+    }
+    return new InternalServerError();
+}

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

@@ -1,18 +1,53 @@
-import { I18n } from '@opra/i18n';
+import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
 import { ApiException } from '../../exception/index.js';
-import { ExecutionContext } from '../execution-context.js';
+import { ExecutionContext, ExecutionRequest } from '../execution-context.js';
 import { OpraService } from '../opra-service.js';
 export declare namespace OpraAdapter {
     interface Options {
-        i18n?: I18n;
+        i18n?: I18n | I18nOptions | (() => Promise<I18n>);
+        userContext?: (request: any, options: {
+            platform: string;
+            isBatch: boolean;
+        }) => object | Promise<object>;
     }
+    interface I18nOptions {
+        /**
+         * Language to use
+         * @default undefined
+         */
+        lng?: string;
+        /**
+         * Language to use if translations in user language are not available.
+         * @default 'dev'
+         */
+        fallbackLng?: false | FallbackLng;
+        /**
+         * Default namespace used if not passed to translation function
+         * @default 'translation'
+         */
+        defaultNS?: string;
+        /**
+         * Resources to initialize with
+         * @default undefined
+         */
+        resources?: LanguageResource;
+        /**
+         * Resource directories to initialize with (if not using loading or not appending using addResourceBundle)
+         * @default undefined
+         */
+        resourceDirs?: string[];
+    }
+    type UserContextResolver = (isBatch: boolean) => any | Promise<any>;
 }
-export declare abstract class OpraAdapter<TAdapterContext = any, TOptions extends OpraAdapter.Options = OpraAdapter.Options> {
+export declare abstract class OpraAdapter<TAdapterContext = any> {
     readonly service: OpraService;
-    i18n: I18n;
-    constructor(service: OpraService, options?: TOptions);
-    protected abstract prepareExecutionContexts(adapterContext: TAdapterContext, userContext: any): ExecutionContext[];
+    readonly i18n: I18n;
+    constructor(service: OpraService, i18n?: I18n);
+    protected abstract prepareRequests(adapterContext: TAdapterContext): ExecutionRequest[];
+    protected abstract createExecutionContext(adapterContext: any, request: ExecutionRequest): ExecutionContext;
     protected abstract sendResponse(adapterContext: TAdapterContext, executionContexts: ExecutionContext[]): Promise<void>;
     protected abstract sendError(adapterContext: TAdapterContext, error: ApiException): Promise<void>;
-    protected handler(adapterContext: TAdapterContext, userContext: any): Promise<void>;
+    protected abstract isBatch(adapterContext: TAdapterContext): boolean;
+    protected handler(adapterContext: TAdapterContext, userContextResolver?: OpraAdapter.UserContextResolver): Promise<void>;
+    protected static initI18n(options?: OpraAdapter.Options): Promise<I18n>;
 }