@opra/core 0.5.0 → 0.6.0

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

@@ -2,13 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonCollectionService = void 0;
 const tslib_1 = require("tslib");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const lodash_1 = require("lodash");
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
 const core_1 = require("@nano-sql/core");
-const exception_1 = require("@opra/exception");
-const schema_1 = require("@opra/schema");
-const url_1 = require("@opra/url");
-const path_to_tree_js_1 = require("../utils/path-to-tree.js");
+const common_1 = require("@opra/common");
 let dbId = 1;
 const indexingTypes = ['int', 'float', 'number', 'date', 'string'];
 class JsonCollectionService {
@@ -101,7 +98,7 @@ class JsonCollectionService {
     }
     async create(data, options) {
         if (!data[this.primaryKey])
-            throw new exception_1.BadRequestError({
+            throw new common_1.BadRequestError({
                 message: 'You must provide primary key value'
             });
         await this._init();
@@ -111,7 +108,7 @@ class JsonCollectionService {
             .where([this.primaryKey, '=', keyValue])
             .exec();
         if (rows.length)
-            throw new exception_1.ResourceConflictError(this.resourceName, this.primaryKey);
+            throw new common_1.ResourceConflictError(this.resourceName, this.primaryKey);
         await (0, core_1.nSQL)(this.resourceName).query('upsert', data)
             .exec();
         return await this.get(keyValue, options);
@@ -245,16 +242,16 @@ class JsonCollectionService {
         }
     }
     _prepare(query) {
-        if (query.resource instanceof schema_1.CollectionResourceInfo) {
+        if (query.resource instanceof common_1.CollectionResourceInfo) {
             if (query.dataType !== this.dataType)
                 throw new TypeError(`Query data type (${query.dataType.name}) ` +
                     `differs from JsonCollectionService data type (${this.dataType.name})`);
         }
         switch (query.method) {
             case 'count': {
-                const options = lodash_1.default.omitBy({
+                const options = (0, lodash_1.omitBy)({
                     filter: this._convertFilter(query.filter)
-                }, lodash_1.default.isNil);
+                }, lodash_1.isNil);
                 return {
                     method: query.method,
                     options,
@@ -262,11 +259,11 @@ class JsonCollectionService {
                 };
             }
             case 'create': {
-                const options = lodash_1.default.omitBy({
+                const options = (0, lodash_1.omitBy)({
                     pick: query.pick,
                     omit: query.omit,
                     include: query.include
-                }, lodash_1.default.isNil);
+                }, lodash_1.isNil);
                 const { data } = query;
                 return {
                     method: query.method,
@@ -277,11 +274,11 @@ class JsonCollectionService {
             }
             case 'get': {
                 if (query.kind === 'CollectionGetQuery') {
-                    const options = lodash_1.default.omitBy({
+                    const options = (0, lodash_1.omitBy)({
                         pick: query.pick,
                         omit: query.omit,
                         include: query.include
-                    }, lodash_1.default.isNil);
+                    }, lodash_1.isNil);
                     const keyValue = query.keyValue;
                     return {
                         method: query.method,
@@ -297,10 +294,10 @@ class JsonCollectionService {
             }
             case 'search': {
                 if (query.distinct)
-                    throw new exception_1.MethodNotAllowedError({
+                    throw new common_1.MethodNotAllowedError({
                         message: '$distinct parameter is not supported by JsonDataService'
                     });
-                const options = lodash_1.default.omitBy({
+                const options = (0, lodash_1.omitBy)({
                     pick: query.pick,
                     omit: query.omit,
                     include: query.include,
@@ -310,7 +307,7 @@ class JsonCollectionService {
                     limit: query.limit,
                     offset: query.skip,
                     count: query.count,
-                }, lodash_1.default.isNil);
+                }, lodash_1.isNil);
                 return {
                     method: query.method,
                     options,
@@ -318,11 +315,11 @@ class JsonCollectionService {
                 };
             }
             case 'update': {
-                const options = lodash_1.default.omitBy({
+                const options = (0, lodash_1.omitBy)({
                     pick: query.pick,
                     omit: query.omit,
                     include: query.include
-                }, lodash_1.default.isNil);
+                }, lodash_1.isNil);
                 const { data } = query;
                 const keyValue = query.keyValue;
                 return {
@@ -334,9 +331,9 @@ class JsonCollectionService {
                 };
             }
             case 'updateMany': {
-                const options = lodash_1.default.omitBy({
+                const options = (0, lodash_1.omitBy)({
                     filter: this._convertFilter(query.filter)
-                }, lodash_1.default.isNil);
+                }, lodash_1.isNil);
                 const { data } = query;
                 return {
                     method: query.method,
@@ -355,9 +352,9 @@ class JsonCollectionService {
                 };
             }
             case 'deleteMany': {
-                const options = lodash_1.default.omitBy({
+                const options = (0, lodash_1.omitBy)({
                     filter: this._convertFilter(query.filter)
-                }, lodash_1.default.isNil);
+                }, lodash_1.isNil);
                 return {
                     method: query.method,
                     options,
@@ -379,7 +376,7 @@ class JsonCollectionService {
                 if ((((!pick && !f.exclusive) || pick?.[kl])) || include?.[kl]) {
                     const fieldType = document.getDataType(f.type);
                     const subPath = (path ? path + '.' : '') + f.name;
-                    if (fieldType instanceof schema_1.ComplexType) {
+                    if (fieldType instanceof common_1.ComplexType) {
                         processDataType(fieldType, subPath, typeof pick?.[kl] === 'object' ? pick?.[kl] : undefined, typeof omit?.[kl] === 'object' ? omit?.[kl] : undefined, typeof include?.[kl] === 'object' ? include?.[kl] : undefined);
                         continue;
                     }
@@ -387,16 +384,16 @@ class JsonCollectionService {
                 }
             }
         };
-        processDataType(this.dataType, '', (args.pick ? (0, path_to_tree_js_1.pathToTree)(args.pick, true) : undefined), (args.omit ? (0, path_to_tree_js_1.pathToTree)(args.omit, true) : undefined), (args.include ? (0, path_to_tree_js_1.pathToTree)(args.include, true) : undefined));
+        processDataType(this.dataType, '', (args.pick ? (0, common_1.pathToTree)(args.pick, true) : undefined), (args.omit ? (0, common_1.pathToTree)(args.omit, true) : undefined), (args.include ? (0, common_1.pathToTree)(args.include, true) : undefined));
         return result;
     }
     _convertFilter(str) {
         const ast = typeof str === 'string'
-            ? (0, url_1.$parse)(str)
+            ? (0, common_1.parseFilter)(str)
             : str;
-        if (!ast || !(ast instanceof url_1.Expression))
+        if (!ast || !(ast instanceof common_1.Expression))
             return ast;
-        if (ast instanceof url_1.ComparisonExpression) {
+        if (ast instanceof common_1.ComparisonExpression) {
             const left = this._convertFilter(ast.left);
             const right = this._convertFilter(ast.right);
             switch (ast.op) {
@@ -424,21 +421,21 @@ class JsonCollectionService {
                     throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
             }
         }
-        if (ast instanceof url_1.QualifiedIdentifier) {
+        if (ast instanceof common_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) {
+        if (ast instanceof common_1.NumberLiteral ||
+            ast instanceof common_1.StringLiteral ||
+            ast instanceof common_1.BooleanLiteral ||
+            ast instanceof common_1.NullLiteral ||
+            ast instanceof common_1.DateLiteral ||
+            ast instanceof common_1.TimeLiteral) {
             return ast.value;
         }
-        if (ast instanceof url_1.ArrayExpression) {
+        if (ast instanceof common_1.ArrayExpression) {
             return ast.items.map(item => this._convertFilter(item));
         }
-        if (ast instanceof url_1.LogicalExpression) {
+        if (ast instanceof common_1.LogicalExpression) {
             return ast.items.map(item => this._convertFilter(item))
                 .reduce((a, v) => {
                 if (a.length)
@@ -447,10 +444,10 @@ class JsonCollectionService {
                 return a;
             }, []);
         }
-        if (ast instanceof url_1.ArrayExpression) {
+        if (ast instanceof common_1.ArrayExpression) {
             return ast.items.map(item => this._convertFilter(item));
         }
-        if (ast instanceof url_1.ParenthesesExpression) {
+        if (ast instanceof common_1.ParenthesesExpression) {
             return this._convertFilter(ast.expression);
         }
         throw new Error(`${ast.kind} is not implemented yet`);

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

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonSingletonService = void 0;
-const tslib_1 = require("tslib");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const schema_1 = require("@opra/schema");
+const lodash_1 = require("lodash");
+const common_1 = require("@opra/common");
 class JsonSingletonService {
     dataType;
     _data;
@@ -24,18 +23,18 @@ class JsonSingletonService {
         return this._data;
     }
     _prepare(query) {
-        if (query.resource instanceof schema_1.SingletonResourceInfo) {
+        if (query.resource instanceof common_1.SingletonResourceInfo) {
             if (query.dataType !== this.dataType)
                 throw new TypeError(`Query data type (${query.dataType.name}) ` +
                     `differs from JsonCollectionService data type (${this.dataType.name})`);
         }
         switch (query.method) {
             case 'create': {
-                const options = lodash_1.default.omitBy({
+                const options = (0, lodash_1.omitBy)({
                     pick: query.pick,
                     omit: query.omit,
                     include: query.include
-                }, lodash_1.default.isNil);
+                }, lodash_1.isNil);
                 const { data } = query;
                 return {
                     method: query.method,
@@ -46,11 +45,11 @@ class JsonSingletonService {
             }
             case 'get': {
                 if (query.kind === 'CollectionGetQuery') {
-                    const options = lodash_1.default.omitBy({
+                    const options = (0, lodash_1.omitBy)({
                         pick: query.pick,
                         omit: query.omit,
                         include: query.include
-                    }, lodash_1.default.isNil);
+                    }, lodash_1.isNil);
                     const keyValue = query.keyValue;
                     return {
                         method: query.method,
@@ -65,11 +64,11 @@ class JsonSingletonService {
                 break;
             }
             case 'update': {
-                const options = lodash_1.default.omitBy({
+                const options = (0, lodash_1.omitBy)({
                     pick: query.pick,
                     omit: query.omit,
                     include: query.include
-                }, lodash_1.default.isNil);
+                }, lodash_1.isNil);
                 const { data } = query;
                 const keyValue = query.keyValue;
                 return {

package/cjs/utils/create-i18n.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createI18n = void 0;
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
-const i18n_1 = require("@opra/i18n");
+const common_1 = require("@opra/common");
 const get_caller_file_util_js_1 = require("./get-caller-file.util.js");
 async function createI18n(options) {
     const opts = {
         ...options,
     };
     delete opts.resourceDirs;
-    const instance = i18n_1.I18n.createInstance(opts);
+    const instance = common_1.I18n.createInstance(opts);
     await instance.init();
     await instance.loadResourceDir(path_1.default.resolve((0, get_caller_file_util_js_1.getCallerFile)(), '../../../i18n'));
     if (options?.resourceDirs)

package/esm/adapter/adapter.d.ts

@@ -1,62 +1,31 @@
-import { ResponsiveMap } from '@opra/common';
-import { OpraException } from '@opra/exception';
-import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
-import { CollectionGetQuery, CollectionResourceInfo, ComplexType, DataType, FieldGetQuery, OpraDocument, ResourceInfo, SingletonGetQuery, SingletonResourceInfo } from '@opra/schema';
+import { Task } from 'power-tasks';
+import { CollectionGetQuery, CollectionResourceInfo, ComplexType, DataType, FieldGetQuery, I18n, OpraDocument, OpraException, ResourceInfo, ResponsiveMap, SingletonGetQuery, SingletonResourceInfo } from '@opra/common';
 import { IExecutionContext } from '../interfaces/execution-context.interface.js';
-import { QueryContext } from './query-context.js';
+import { I18nOptions } from '../interfaces/i18n-options.interface.js';
+import { RequestContext } from './request-contexts/request-context.js';
+import { SingleRequestContext } from './request-contexts/single-request-context.js';
 export declare namespace OpraAdapter {
-    type UserContextResolver = (args: {
-        executionContext: IExecutionContext;
-        isBatch: boolean;
-    }) => object | Promise<object>;
+    type UserContextResolver = (executionContext: IExecutionContext) => object | Promise<object>;
     interface Options {
         i18n?: I18n | I18nOptions | (() => Promise<I18n>);
         userContext?: UserContextResolver;
     }
-    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[];
-    }
 }
 export declare abstract class OpraAdapter<TExecutionContext extends IExecutionContext> {
     readonly document: OpraDocument;
-    protected i18n: I18n;
     protected userContextResolver?: OpraAdapter.UserContextResolver;
     protected _internalResources: ResponsiveMap<string, ResourceInfo>;
+    i18n: I18n;
     constructor(document: OpraDocument);
-    protected abstract prepareRequests(executionContext: TExecutionContext): QueryContext[];
-    protected abstract sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
+    protected abstract parse(executionContext: TExecutionContext): Promise<RequestContext>;
+    protected abstract sendResponse(executionContext: TExecutionContext, requestContext: RequestContext): Promise<void>;
     protected abstract sendError(executionContext: TExecutionContext, error: OpraException): Promise<void>;
-    protected abstract isBatch(executionContext: TExecutionContext): boolean;
     protected handler(executionContext: TExecutionContext): Promise<void>;
-    protected _resourcePrepare(resource: ResourceInfo, context: QueryContext): Promise<void>;
-    protected _resourceExecute(document: OpraDocument, resource: ResourceInfo, context: QueryContext): Promise<void>;
+    protected _requestContextToTask(executionContext: TExecutionContext, requestContext: RequestContext): Task;
     protected _init(options?: OpraAdapter.Options): Promise<void>;
-    protected _collectionResourceExecute(document: OpraDocument, resource: CollectionResourceInfo, context: QueryContext): Promise<any>;
-    protected _singletonResourceExecute(document: OpraDocument, resource: SingletonResourceInfo, context: QueryContext): Promise<any>;
+    protected _executeResourceQuery(document: OpraDocument, resource: ResourceInfo, context: SingleRequestContext): Promise<void>;
+    protected _executeCollectionResource(document: OpraDocument, resource: CollectionResourceInfo, context: SingleRequestContext): Promise<any>;
+    protected _executeSingletonResource(document: OpraDocument, resource: SingletonResourceInfo, context: SingleRequestContext): Promise<any>;
     protected _pathWalkThrough(query: CollectionGetQuery | SingletonGetQuery | FieldGetQuery, dataType: ComplexType, value: any, parentPath: string): Promise<{
         value?: any;
         dataType?: DataType;

package/esm/adapter/adapter.js

@@ -1,81 +1,29 @@
+import { Task } from 'power-tasks';
 import { AsyncEventEmitter } from 'strict-typed-events';
-import { HttpHeaders, 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 { CollectionCountQuery, CollectionResourceInfo, CollectionSearchQuery, ComplexType, FailedDependencyError, ForbiddenError, HttpHeaders, I18n, InternalServerError, ResourceNotFoundError, ResponsiveMap, SingletonResourceInfo, translate, wrapException } from '@opra/common';
 import { createI18n } from '../utils/create-i18n.js';
-import { MetadataResource } from './metadata-resource.js';
+import { MetadataResource } from './classes/metadata.resource.js';
+import { BatchRequestContext } from './request-contexts/batch-request-context.js';
+import { SingleRequestContext } from './request-contexts/single-request-context.js';
+const noOp = () => void 0;
 export class OpraAdapter {
     document;
-    i18n;
     userContextResolver;
-    // protected _metadataResource: SingletonResourceInfo;
     _internalResources = new ResponsiveMap();
+    i18n;
     constructor(document) {
         this.document = document;
     }
     async handler(executionContext) {
-        let queryContexts;
-        let userContext;
+        let requestContext;
         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);
+            if (this.userContextResolver)
+                executionContext.userContext = this.userContextResolver(executionContext);
+            requestContext = await this.parse(executionContext);
+            const task = this._requestContextToTask(executionContext, requestContext);
+            await task.toPromise().catch(noOp);
+            await this.sendResponse(executionContext, requestContext);
         }
         catch (e) {
             failed = true;
@@ -86,47 +34,49 @@ export class OpraAdapter {
             if (executionContext instanceof AsyncEventEmitter) {
                 await executionContext
                     .emitAsyncSerial('finish', {
-                    userContext,
+                    context: executionContext,
                     failed
                 }).catch();
             }
         }
     }
-    async _resourcePrepare(resource, context) {
-        const { query } = context;
-        const fn = resource.metadata['pre_' + query.method];
-        if (fn && typeof fn === 'function') {
-            await fn(context);
+    _requestContextToTask(executionContext, requestContext) {
+        if (requestContext instanceof BatchRequestContext) {
+            const children = requestContext.queries.map(q => this._requestContextToTask(executionContext, q));
+            return new Task(children, { bail: true });
         }
-    }
-    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));
+        else if (requestContext instanceof SingleRequestContext) {
+            const { query } = requestContext;
+            const task = new Task(async () => {
+                if (query.resource) {
+                    const { resource } = query;
+                    // call pre_xxx method
+                    const fn = resource.metadata['pre_' + query.method];
+                    if (fn && typeof fn === 'function') {
+                        await fn(requestContext);
+                    }
+                    await this._executeResourceQuery(this.document, resource, requestContext);
+                    // todo execute sub property queries
+                    return;
                 }
-                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 InternalServerError('Not implemented yet');
+            }, {
+                id: requestContext.contentId,
+                exclusive: query.operation !== 'read'
+            });
+            task.on('finish', () => {
+                if (task.error) {
+                    if (task.failedDependencies)
+                        requestContext.errors.push(new FailedDependencyError());
+                    else
+                        requestContext.errors.push(wrapException(task.error));
+                    return;
+                }
+            });
+            return task;
         }
-        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+        /* istanbul ignore next */
+        throw new TypeError('Invalid request context instance');
     }
     async _init(options) {
         if (options?.i18n instanceof I18n)
@@ -158,7 +108,39 @@ export class OpraAdapter {
             }
         }
     }
-    async _collectionResourceExecute(document, resource, context) {
+    async _executeResourceQuery(document, resource, context) {
+        if (resource instanceof CollectionResourceInfo) {
+            const { query } = context;
+            if (query instanceof CollectionSearchQuery) {
+                const promises = [];
+                let search;
+                promises.push(this._executeCollectionResource(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._executeCollectionResource(document, resource, ctx)
+                        .then(r => {
+                        context.responseHeaders[HttpHeaders.X_Opra_Count] = r;
+                    }));
+                }
+                await Promise.all(promises);
+                context.response = search;
+                return;
+            }
+            context.response = await this._executeCollectionResource(document, resource, context);
+            return;
+        }
+        else if (resource instanceof SingletonResourceInfo) {
+            context.response = await this._executeSingletonResource(document, resource, context);
+            return;
+        }
+        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+    }
+    async _executeCollectionResource(document, resource, context) {
         const method = context.query.method;
         const resolverInfo = resource.metadata[method];
         if (!(resolverInfo && resolverInfo.handler))
@@ -175,13 +157,12 @@ export class OpraAdapter {
                 result = Array.isArray(result) ? result[0] : result;
                 if (result)
                     context.status = 201;
-                context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                context.responseHeaders[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': {
@@ -194,14 +175,14 @@ export class OpraAdapter {
                 if (v.value === undefined)
                     throw new ResourceNotFoundError(v.path);
                 if (v.dataType)
-                    context.responseHeaders.set(HttpHeaders.X_Opra_DataType, v.dataType.name);
+                    context.responseHeaders[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);
+                context.responseHeaders[HttpHeaders.X_Opra_DataType] = resource.dataType.name;
                 return items;
             }
             case 'update': {
@@ -210,7 +191,7 @@ export class OpraAdapter {
                 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);
+                context.responseHeaders[HttpHeaders.X_Opra_DataType] = resource.dataType.name;
                 return result;
             }
             case 'delete':
@@ -247,7 +228,7 @@ export class OpraAdapter {
             }
         }
     }
-    async _singletonResourceExecute(document, resource, context) {
+    async _executeSingletonResource(document, resource, context) {
         const method = context.query.method;
         const resolverInfo = resource.metadata[method];
         if (!(resolverInfo && resolverInfo.handler))
@@ -268,7 +249,7 @@ export class OpraAdapter {
                 if (v.value === undefined)
                     throw new ResourceNotFoundError(v.path);
                 if (v.dataType)
-                    context.responseHeaders.set(HttpHeaders.X_Opra_DataType, v.dataType.name);
+                    context.responseHeaders[HttpHeaders.X_Opra_DataType] = v.dataType.name;
                 return v.value;
             }
         }
@@ -286,7 +267,7 @@ export class OpraAdapter {
         }
         if (method === 'create')
             context.status = 201;
-        context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+        context.responseHeaders[HttpHeaders.X_Opra_DataType] = resource.dataType.name;
         return result;
     }
     async _pathWalkThrough(query, dataType, value, parentPath) {