@opra/core 0.0.8 → 0.0.11

package/cjs/implementation/adapter/http-adapter.js

@@ -6,26 +6,26 @@ const constants_js_1 = require("../../constants.js");
 const index_js_1 = require("../../enums/index.js");
 const index_js_2 = require("../../exception/index.js");
 const wrap_error_js_1 = require("../../exception/wrap-error.js");
-const execution_query_interface_js_1 = require("../../interfaces/execution-query.interface.js");
+const query_interface_js_1 = require("../../interfaces/query.interface.js");
 const headers_js_1 = require("../../utils/headers.js");
 const complex_type_js_1 = require("../data-type/complex-type.js");
-const execution_context_js_1 = require("../execution-context.js");
+const query_context_js_1 = require("../query-context.js");
 const container_resource_handler_js_1 = require("../resource/container-resource-handler.js");
 const entity_resource_handler_js_1 = require("../resource/entity-resource-handler.js");
 const adapter_js_1 = require("./adapter.js");
 class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
-    prepareRequests(adapterContext) {
-        const req = adapterContext.getRequest();
+    prepareRequests(executionContext) {
+        const req = executionContext.getRequestWrapper();
         // todo implement batch requests
-        if (this.isBatch(adapterContext)) {
+        if (this.isBatch(executionContext)) {
             throw new Error('not implemented yet');
         }
         const url = new url_1.OpraURL(req.getUrl());
         return [
-            this.prepareRequest(adapterContext, url, req.getMethod(), headers_js_1.Headers.from(req.getHeaders()), req.getBody())
+            this.prepareRequest(executionContext, url, req.getMethod(), headers_js_1.Headers.from(req.getHeaders()), req.getBody())
         ];
     }
-    prepareRequest(adapterContext, url, method, headers, body) {
+    prepareRequest(executionContext, url, method, headers, body) {
         if (!url.path.size)
             throw new index_js_2.BadRequestError();
         if (method !== 'GET' && url.path.size > 1)
@@ -35,20 +35,13 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             throw new index_js_2.MethodNotAllowedError({
                 message: `Method "${method}" is not allowed by target resource`
             });
-        return new execution_context_js_1.ExecutionRequest({
+        return new query_context_js_1.QueryContext({
+            service: this.service,
+            executionContext,
             query,
             headers,
             params: url.searchParams,
-        });
-    }
-    createExecutionContext(adapterContext, request) {
-        return new execution_context_js_1.ExecutionContext({
-            type: 'http',
-            service: this.service,
-            request,
-            response: new execution_context_js_1.ExecutionResponse(),
-            adapterContext,
-            continueOnError: request.query.operationType === 'read'
+            continueOnError: query.operation === 'read'
         });
     }
     buildQuery(url, method, body) {
@@ -73,7 +66,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                         switch (method) {
                             case 'GET': {
                                 if (scope === 'collection') {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forSearch(resource, {
+                                    query = query_interface_js_1.OpraQuery.forSearch(resource, {
                                         filter: url.searchParams.get('$filter'),
                                         limit: url.searchParams.get('$limit'),
                                         skip: url.searchParams.get('$skip'),
@@ -86,7 +79,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                                     });
                                 }
                                 else {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forGet(resource, p.key, {
+                                    query = query_interface_js_1.OpraQuery.forGet(resource, p.key, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -105,7 +98,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                                         const prop = dataType.properties?.[p.resource];
                                         if (!prop)
                                             throw new index_js_2.NotFoundError({ message: `Invalid or unknown resource path (${path})` });
-                                        const q = execution_query_interface_js_1.ExecutionQuery.forGetProperty(prop);
+                                        const q = query_interface_js_1.OpraQuery.forGetProperty(prop);
                                         if (nested) {
                                             nested.nested = q;
                                         }
@@ -119,18 +112,18 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                             }
                             case 'DELETE': {
                                 if (scope === 'collection') {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forDeleteMany(resource, {
+                                    query = query_interface_js_1.OpraQuery.forDeleteMany(resource, {
                                         filter: url.searchParams.get('$filter'),
                                     });
                                 }
                                 else {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forDelete(resource, p.key);
+                                    query = query_interface_js_1.OpraQuery.forDelete(resource, p.key);
                                 }
                                 break;
                             }
                             case 'POST': {
                                 if (scope === 'collection') {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forCreate(resource, body, {
+                                    query = query_interface_js_1.OpraQuery.forCreate(resource, body, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -140,12 +133,12 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                             }
                             case 'PATCH': {
                                 if (scope === 'collection') {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forUpdateMany(resource, body, {
+                                    query = query_interface_js_1.OpraQuery.forUpdateMany(resource, body, {
                                         filter: url.searchParams.get('$filter')
                                     });
                                 }
                                 else {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forUpdate(resource, p.key, body, {
+                                    query = query_interface_js_1.OpraQuery.forUpdate(resource, p.key, body, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -166,13 +159,13 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             throw new index_js_2.BadRequestError({ message: e.message });
         }
     }
-    async sendResponse(adapterContext, executionContexts) {
+    async sendResponse(executionContext, queryContexts) {
         const outputPackets = [];
-        for (const ctx of executionContexts) {
+        for (const ctx of queryContexts) {
             const v = this.createOutput(ctx);
             outputPackets.push(v);
         }
-        if (this.isBatch(adapterContext)) {
+        if (this.isBatch(executionContext)) {
             // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
             return;
         }
@@ -186,7 +179,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             });
         }
         const out = outputPackets[0];
-        const resp = adapterContext.getResponse();
+        const resp = executionContext.getResponseWrapper();
         resp.setStatus(out.status);
         resp.setHeader(index_js_1.HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(index_js_1.HttpHeaders.Cache_Control, 'no-cache');
@@ -201,11 +194,11 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
         resp.send(JSON.stringify(out.body));
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBatch(adapterContext) {
+    isBatch(executionContext) {
         return false;
     }
     createOutput(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         let status = ctx.response.status;
         let body = ctx.response.value || {};
         const errors = ctx.response.errors?.map(e => (0, wrap_error_js_1.wrapError)(e));
@@ -222,7 +215,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
         }
         else {
             delete body.errors;
-            status = status || (query.operationType === 'create' ? index_js_1.HttpStatus.CREATED : index_js_1.HttpStatus.OK);
+            status = status || (query.operation === 'create' ? index_js_1.HttpStatus.CREATED : index_js_1.HttpStatus.OK);
         }
         body = this.i18n.deep(body);
         return {
@@ -231,8 +224,8 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             body
         };
     }
-    async sendError(adapterContext, error) {
-        const resp = adapterContext.getResponse();
+    async sendError(executionContext, error) {
+        const resp = executionContext.getResponseWrapper();
         resp.setStatus(error.status || 500);
         resp.setHeader(index_js_1.HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(index_js_1.HttpHeaders.Cache_Control, 'no-cache');

package/cjs/implementation/{execution-context.js → query-context.js}

@@ -1,41 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionResponse = exports.ExecutionRequest = exports.ExecutionContext = void 0;
+exports.QueryResponse = exports.QueryContext = void 0;
 const url_1 = require("@opra/url");
 const headers_js_1 = require("../utils/headers.js");
-class ExecutionContext {
-    type;
+class QueryContext {
     service;
-    request;
-    response;
-    adapterContext;
-    userContext;
-    continueOnError;
-    constructor(args) {
-        Object.assign(this, args);
-    }
-    switchToHttp() {
-        if (this.type !== 'http')
-            throw new Error(`You can't access http context within an ${this.type} context`);
-        return this.adapterContext;
-    }
-}
-exports.ExecutionContext = ExecutionContext;
-class ExecutionRequest {
+    executionContext;
     query;
     params;
     headers;
     parentValue;
     resultPath;
+    response;
+    userContext;
+    continueOnError;
     constructor(args) {
         Object.assign(this, args);
+        this.response = new QueryResponse();
         this.params = this.params || new url_1.OpraURLSearchParams();
         this.headers = this.headers || headers_js_1.Headers.create();
         this.resultPath = this.resultPath || '';
     }
+    get type() {
+        return this.executionContext.getType();
+    }
+    switchToHttp() {
+        if (this.type !== 'http')
+            throw new Error(`You can't access http context within an ${this.type} context`);
+        return this.executionContext;
+    }
 }
-exports.ExecutionRequest = ExecutionRequest;
-class ExecutionResponse {
+exports.QueryContext = QueryContext;
+class QueryResponse {
     headers = headers_js_1.Headers.create();
     errors = [];
     status;
@@ -46,4 +42,4 @@ class ExecutionResponse {
             Object.assign(this, args);
     }
 }
-exports.ExecutionResponse = ExecutionResponse;
+exports.QueryResponse = QueryResponse;

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

@@ -3,10 +3,11 @@ 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 query_interface_js_1 = require("../../interfaces/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;
+var isSearchQuery = query_interface_js_1.OpraQuery.isSearchQuery;
+const index_js_1 = require("../../exception/index.js");
 class EntityResourceHandler extends resource_handler_js_1.ResourceHandler {
     service;
     dataType;
@@ -22,7 +23,7 @@ class EntityResourceHandler extends resource_handler_js_1.ResourceHandler {
             throw new TypeError(`You should provide an EntityType for EntityResourceController`);
     }
     async execute(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         if (isSearchQuery(query)) {
             const promises = [];
             let search;
@@ -61,16 +62,19 @@ class EntityResourceHandler extends resource_handler_js_1.ResourceHandler {
                 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;
         }
+        result = Array.isArray(result) ? result[0] : result;
+        if (!result)
+            throw new index_js_1.UnprocessableEntityError();
+        if (ctx.resultPath) {
+            const pathArray = ctx.resultPath.split('.');
+            for (const property of pathArray) {
+                result = result && typeof result === 'object' && result[property];
+            }
+        }
+        if (fnName === 'create')
+            ctx.response.status = 201;
+        return result;
     }
 }
 exports.EntityResourceHandler = EntityResourceHandler;

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

@@ -17,7 +17,7 @@ class ResourceHandler {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
     }
     async prepare(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         const fn = this._args['pre_' + query.queryType];
         if (fn && typeof fn === 'function') {
             await fn(ctx);

package/cjs/implementation/schema-generator.js

@@ -6,6 +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");
+var isDataType = schema_1.OpraSchema.isDataType;
 const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
 class SchemaGenerator {
     _dataTypes = {};
@@ -14,24 +15,16 @@ class SchemaGenerator {
         //
     }
     async addDataType(thunk) {
-        let schema;
         thunk = (0, types_1.isPromise)(thunk) ? await thunk : thunk;
-        if (typeof thunk === 'function' && !(0, class_utils_js_1.isConstructor)(thunk))
-            thunk = await thunk();
-        if (!(0, class_utils_js_1.isConstructor)(thunk) || schema_1.OpraSchema.isDataType(thunk))
-            throw new TypeError(`Function must return a type class or type schema`);
-        if ((0, class_utils_js_1.isConstructor)(thunk)) {
+        if (typeof thunk === 'function') {
+            if (!(0, class_utils_js_1.isConstructor)(thunk))
+                return this.addDataType(await thunk());
+            if (internal_data_types_js_1.builtinClassMap.has(thunk))
+                return this.addDataType(internal_data_types_js_1.builtinClassMap.get(thunk));
             const ctor = thunk;
             const metadata = Reflect.getOwnMetadata(schema_1.DATATYPE_METADATA, ctor);
             if (!metadata)
                 throw new TypeError(`Class "${ctor}" has no type metadata`);
-            schema = this._dataTypes[metadata.name];
-            if (schema) {
-                if (schema.kind !== metadata.kind ||
-                    (schema_1.OpraSchema.isComplexType(schema) && schema.ctor !== ctor))
-                    throw new Error(`An other instance of "${schema.name}" data type previously defined`);
-                return schema;
-            }
             // Add base data type
             let base;
             let baseCtor = Object.getPrototypeOf(ctor);
@@ -42,49 +35,43 @@ class SchemaGenerator {
                 const baseSchema = await this.addDataType(baseCtor);
                 base = baseSchema.name;
             }
-            if (schema_1.OpraSchema.isComplexType(metadata) || schema_1.OpraSchema.isEntityType(metadata)) {
-                schema = {
-                    ...metadata,
-                    ctor,
-                    base
-                };
-                const properties = Reflect.getMetadata(schema_1.DATATYPE_PROPERTIES, ctor.prototype);
-                if (properties) {
-                    for (const [k, p] of Object.entries(properties)) {
-                        let type;
-                        if ((0, class_utils_js_1.isConstructor)(p.type) && internal_data_types_js_1.builtinClassMap.has(p.type))
-                            type = internal_data_types_js_1.builtinClassMap.get(p.type);
-                        else if (typeof p.type === 'function' || typeof p.type === 'object') {
-                            const t = await this.addDataType(p.type);
-                            type = t.name;
-                        }
-                        else
-                            type = p.type || 'string';
-                        if (internal_data_types_js_1.internalDataTypes.has(type) && !this._dataTypes[type])
-                            this._dataTypes[type] = internal_data_types_js_1.internalDataTypes.get(type.toLowerCase());
-                        schema.properties = schema.properties || {};
-                        schema.properties[k] = { ...p, type };
+            const schema = {
+                ...metadata,
+                ctor,
+                base
+            };
+            const properties = Reflect.getMetadata(schema_1.DATATYPE_PROPERTIES, ctor.prototype);
+            if (properties) {
+                for (const [k, p] of Object.entries(properties)) {
+                    let type = p.type || 'string';
+                    if (typeof type !== 'string') {
+                        const propSchema = await this.addDataType(type);
+                        type = propSchema.name;
                     }
+                    else {
+                        if (internal_data_types_js_1.internalDataTypes.has(type))
+                            await this.addDataType(internal_data_types_js_1.internalDataTypes.get(type));
+                    }
+                    schema.properties = schema.properties || {};
+                    schema.properties[k] = { ...p, type };
                 }
             }
-            else if (schema_1.OpraSchema.isSimpleType(metadata)) {
-                if (!internal_data_types_js_1.primitiveDataTypeNames.includes(metadata.type))
-                    throw new Error(`"type" of SimpleType schema must be one of enumerated value (${internal_data_types_js_1.primitiveDataTypeNames})`);
-                schema = {
-                    ...metadata
-                };
-            }
-            else
-                /* istanbul ignore next */
-                throw new TypeError(`Invalid metadata`);
+            return this.addDataType(schema);
         }
-        else if (schema_1.OpraSchema.isDataType(thunk)) {
-            schema = thunk;
-        }
-        else
+        if (!isDataType(thunk))
             throw new TypeError(`Invalid data type schema`);
-        this._dataTypes[schema.name] = schema;
-        return schema;
+        // Check if datatype previously added
+        const currentSchema = this._dataTypes[thunk.name];
+        if (currentSchema) {
+            if (!(currentSchema.kind === thunk.kind && currentSchema.ctor && currentSchema.ctor === thunk.ctor))
+                throw new Error(`An other instance of "${currentSchema.name}" data type previously defined`);
+            return currentSchema;
+        }
+        if (schema_1.OpraSchema.isSimpleType(thunk) && !internal_data_types_js_1.primitiveDataTypeNames.includes(thunk.type))
+            throw new Error(`"type" of SimpleType schema must be one of enumerated value (${internal_data_types_js_1.primitiveDataTypeNames})`);
+        return this._dataTypes[thunk.name] = {
+            ...thunk
+        };
     }
     async addResource(instance) {
         if ((0, class_utils_js_1.isConstructor)(instance))

package/cjs/index.js

@@ -7,11 +7,10 @@ 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("./interfaces/http-context.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/execution-query.interface.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);
-tslib_1.__exportStar(require("./interfaces/user-context.interface.js"), exports);
-tslib_1.__exportStar(require("./implementation/execution-context.js"), exports);
+tslib_1.__exportStar(require("./implementation/query-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);

package/cjs/interfaces/{execution-query.interface.js → query.interface.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionQuery = void 0;
+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");
-var ExecutionQuery;
-(function (ExecutionQuery) {
+var OpraQuery;
+(function (OpraQuery) {
     function forCreate(resource, values, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -17,14 +17,14 @@ var ExecutionQuery;
         const out = {
             queryType: 'create',
             scope: 'collection',
-            operationType: 'create',
+            operation: 'create',
             resource,
             data: values
         };
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forCreate = forCreate;
+    OpraQuery.forCreate = forCreate;
     function forGet(resource, key, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -36,14 +36,14 @@ var ExecutionQuery;
         const out = {
             queryType: 'get',
             scope: 'instance',
-            operationType: 'read',
+            operation: 'read',
             resource,
             keyValue: key
         };
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forGet = forGet;
+    OpraQuery.forGet = forGet;
     function forSearch(resource, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -56,24 +56,24 @@ var ExecutionQuery;
         const out = {
             queryType: 'search',
             scope: 'collection',
-            operationType: 'read',
+            operation: 'read',
             resource
         };
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forSearch = forSearch;
+    OpraQuery.forSearch = forSearch;
     function forGetProperty(property, options) {
         const out = {
             queryType: 'get',
             scope: 'property',
-            operationType: 'read',
+            operation: 'read',
             property
         };
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forGetProperty = forGetProperty;
+    OpraQuery.forGetProperty = forGetProperty;
     function forUpdate(resource, keyValue, values, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -85,7 +85,7 @@ var ExecutionQuery;
         const out = {
             queryType: 'update',
             scope: 'instance',
-            operationType: 'update',
+            operation: 'update',
             resource,
             keyValue,
             data: values
@@ -93,58 +93,58 @@ var ExecutionQuery;
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forUpdate = forUpdate;
+    OpraQuery.forUpdate = forUpdate;
     function forUpdateMany(resource, values, options) {
         const out = {
             queryType: 'updateMany',
             scope: 'collection',
-            operationType: 'update',
+            operation: 'update',
             resource,
             data: values
         };
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forUpdateMany = forUpdateMany;
+    OpraQuery.forUpdateMany = forUpdateMany;
     function forDelete(resource, key) {
         checkKeyFields(resource, key);
         return {
             queryType: 'delete',
             scope: 'instance',
-            operationType: 'delete',
+            operation: 'delete',
             resource,
             keyValue: key
         };
     }
-    ExecutionQuery.forDelete = forDelete;
+    OpraQuery.forDelete = forDelete;
     function forDeleteMany(resource, options) {
         const out = {
             queryType: 'deleteMany',
             scope: 'collection',
-            operationType: 'delete',
+            operation: 'delete',
             resource,
         };
         Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forDeleteMany = forDeleteMany;
+    OpraQuery.forDeleteMany = forDeleteMany;
     function isCreateQuery(q) {
         return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'create';
     }
-    ExecutionQuery.isCreateQuery = isCreateQuery;
+    OpraQuery.isCreateQuery = isCreateQuery;
     function isSearchQuery(q) {
         return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'search';
     }
-    ExecutionQuery.isSearchQuery = isSearchQuery;
+    OpraQuery.isSearchQuery = isSearchQuery;
     function isReadQuery(q) {
         return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'read';
     }
-    ExecutionQuery.isReadQuery = isReadQuery;
+    OpraQuery.isReadQuery = isReadQuery;
     function isDeleteQuery(q) {
         return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'delete';
     }
-    ExecutionQuery.isDeleteQuery = isDeleteQuery;
-})(ExecutionQuery = exports.ExecutionQuery || (exports.ExecutionQuery = {}));
+    OpraQuery.isDeleteQuery = isDeleteQuery;
+})(OpraQuery = exports.OpraQuery || (exports.OpraQuery = {}));
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function checkKeyFields(resource, key) {
     if (!resource.dataType.primaryKey)

package/cjs/utils/create-i18n.js

@@ -0,0 +1,21 @@
+"use strict";
+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 get_caller_file_util_js_1 = require("./get-caller-file.util.js");
+async function createI18n(options) {
+    const opts = {
+        ...options,
+        resourceDirs: undefined
+    };
+    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'));
+    if (options?.resourceDirs)
+        for (const dir of options.resourceDirs)
+            await instance.loadResourceDir(dir);
+    return instance;
+}
+exports.createI18n = createI18n;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallerFile = void 0;
+function getCallerFile(position = 1) {
+    if (position >= Error.stackTraceLimit) {
+        throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
+            position + '` and Error.stackTraceLimit was: `' + Error.stackTraceLimit + '`');
+    }
+    const oldPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    const stack = new Error().stack;
+    Error.prepareStackTrace = oldPrepareStackTrace;
+    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;
+    }
+}
+exports.getCallerFile = getCallerFile;