@opra/core 0.0.7 → 0.0.9

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

@@ -1,36 +1,33 @@
 import { OpraURLSearchParams } from '@opra/url';
 import { Headers } from '../utils/headers.js';
-export class ExecutionContext {
-    type;
+export 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;
-    }
-}
-export 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 OpraURLSearchParams();
         this.headers = this.headers || 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;
+    }
 }
-export class ExecutionResponse {
+export class QueryResponse {
     headers = Headers.create();
     errors = [];
     status;

package/esm/implementation/resource/container-resource-handler.d.ts

@@ -1,7 +1,7 @@
 import { StrictOmit } from 'ts-gems';
 import { OpraSchema } from '@opra/schema';
 import { IResourceContainer } from '../../interfaces/resource-container.interface.js';
-import { ExecutionContext } from '../execution-context.js';
+import { QueryContext } from '../query-context.js';
 import { EntityResourceHandler } from './entity-resource-handler.js';
 import { ResourceHandler } from './resource-handler.js';
 export declare type ContainerResourceControllerArgs = StrictOmit<OpraSchema.ContainerResource, 'kind'> & {};
@@ -10,5 +10,5 @@ export declare class ContainerResourceHandler extends ResourceHandler implements
     constructor(args: ContainerResourceControllerArgs);
     getResource<T extends ResourceHandler>(name: string): T;
     getEntityResource(name: string): EntityResourceHandler;
-    execute(ctx: ExecutionContext): Promise<void>;
+    execute(ctx: QueryContext): Promise<void>;
 }

package/esm/implementation/resource/entity-resource-handler.d.ts

@@ -1,8 +1,8 @@
 import { StrictOmit } from 'ts-gems';
 import { OpraSchema } from '@opra/schema';
 import { EntityType } from '../data-type/entity-type.js';
-import { ExecutionContext } from '../execution-context.js';
 import { OpraService } from '../opra-service.js';
+import { QueryContext } from '../query-context.js';
 import { ResourceHandler } from './resource-handler.js';
 export declare type EntityResourceControllerArgs = StrictOmit<OpraSchema.EntityResource, 'kind'> & {
     service: OpraService;
@@ -13,6 +13,6 @@ export declare class EntityResourceHandler extends ResourceHandler {
     readonly service: OpraService;
     readonly dataType: EntityType;
     constructor(args: EntityResourceControllerArgs);
-    execute(ctx: ExecutionContext): Promise<void>;
-    _executeFn(ctx: ExecutionContext, fnName: string): Promise<any>;
+    execute(ctx: QueryContext): Promise<void>;
+    _executeFn(ctx: QueryContext, fnName: string): Promise<any>;
 }

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

@@ -1,8 +1,9 @@
 import _ from 'lodash';
-import { ExecutionQuery } from '../../interfaces/execution-query.interface.js';
+import { OpraQuery } from '../../interfaces/query.interface.js';
 import { EntityType } from '../data-type/entity-type.js';
 import { ResourceHandler } from './resource-handler.js';
-var isSearchQuery = ExecutionQuery.isSearchQuery;
+var isSearchQuery = OpraQuery.isSearchQuery;
+import { UnprocessableEntityError } from '../../exception/index.js';
 export class EntityResourceHandler extends ResourceHandler {
     service;
     dataType;
@@ -18,7 +19,7 @@ export class EntityResourceHandler extends 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;
@@ -57,15 +58,18 @@ export class EntityResourceHandler extends 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 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;
     }
 }

package/esm/implementation/resource/resource-handler.d.ts

@@ -1,6 +1,6 @@
 import { OpraSchema } from '@opra/schema';
 import { nodeInspectCustom } from '../../utils/terminal-utils.js';
-import { ExecutionContext } from '../execution-context.js';
+import { QueryContext } from '../query-context.js';
 export declare abstract class ResourceHandler {
     protected readonly _args: OpraSchema.Resource & {
         prepare?: Function;
@@ -9,7 +9,7 @@ export declare abstract class ResourceHandler {
     get name(): string;
     get description(): string | undefined;
     toString(): string;
-    prepare(ctx: ExecutionContext): Promise<void>;
-    abstract execute(ctx: ExecutionContext): Promise<void>;
+    prepare(ctx: QueryContext): Promise<void>;
+    abstract execute(ctx: QueryContext): Promise<void>;
     [nodeInspectCustom](): string;
 }

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

@@ -14,7 +14,7 @@ export 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/esm/implementation/schema-generator.js

@@ -3,6 +3,7 @@ import { DATATYPE_METADATA, DATATYPE_PROPERTIES, OpraSchema } from '@opra/schema
 import { RESOURCE_METADATA } from '../constants.js';
 import { isConstructor, resolveClassAsync } from '../utils/class-utils.js';
 import { builtinClassMap, internalDataTypes, primitiveDataTypeNames } from '../utils/internal-data-types.js';
+var isDataType = OpraSchema.isDataType;
 const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
 export class SchemaGenerator {
     _dataTypes = {};
@@ -11,24 +12,16 @@ export class SchemaGenerator {
         //
     }
     async addDataType(thunk) {
-        let schema;
         thunk = isPromise(thunk) ? await thunk : thunk;
-        if (typeof thunk === 'function' && !isConstructor(thunk))
-            thunk = await thunk();
-        if (!isConstructor(thunk) || OpraSchema.isDataType(thunk))
-            throw new TypeError(`Function must return a type class or type schema`);
-        if (isConstructor(thunk)) {
+        if (typeof thunk === 'function') {
+            if (!isConstructor(thunk))
+                return this.addDataType(await thunk());
+            if (builtinClassMap.has(thunk))
+                return this.addDataType(builtinClassMap.get(thunk));
             const ctor = thunk;
             const metadata = Reflect.getOwnMetadata(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 ||
-                    (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);
@@ -39,49 +32,43 @@ export class SchemaGenerator {
                 const baseSchema = await this.addDataType(baseCtor);
                 base = baseSchema.name;
             }
-            if (OpraSchema.isComplexType(metadata) || OpraSchema.isEntityType(metadata)) {
-                schema = {
-                    ...metadata,
-                    ctor,
-                    base
-                };
-                const properties = Reflect.getMetadata(DATATYPE_PROPERTIES, ctor.prototype);
-                if (properties) {
-                    for (const [k, p] of Object.entries(properties)) {
-                        let type;
-                        if (isConstructor(p.type) && builtinClassMap.has(p.type))
-                            type = 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 (internalDataTypes.has(type) && !this._dataTypes[type])
-                            this._dataTypes[type] = internalDataTypes.get(type.toLowerCase());
-                        schema.properties = schema.properties || {};
-                        schema.properties[k] = { ...p, type };
+            const schema = {
+                ...metadata,
+                ctor,
+                base
+            };
+            const properties = Reflect.getMetadata(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 (internalDataTypes.has(type))
+                            await this.addDataType(internalDataTypes.get(type));
+                    }
+                    schema.properties = schema.properties || {};
+                    schema.properties[k] = { ...p, type };
                 }
             }
-            else if (OpraSchema.isSimpleType(metadata)) {
-                if (!primitiveDataTypeNames.includes(metadata.type))
-                    throw new Error(`"type" of SimpleType schema must be one of enumerated value (${primitiveDataTypeNames})`);
-                schema = {
-                    ...metadata
-                };
-            }
-            else
-                /* istanbul ignore next */
-                throw new TypeError(`Invalid metadata`);
+            return this.addDataType(schema);
         }
-        else if (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 (OpraSchema.isSimpleType(thunk) && !primitiveDataTypeNames.includes(thunk.type))
+            throw new Error(`"type" of SimpleType schema must be one of enumerated value (${primitiveDataTypeNames})`);
+        return this._dataTypes[thunk.name] = {
+            ...thunk
+        };
     }
     async addResource(instance) {
         if (isConstructor(instance))

package/esm/index.d.ts

@@ -4,11 +4,10 @@ export * from './types.js';
 export * from './enums/index.js';
 export * from './exception/index.js';
 export * from './decorators/entity-resource.decorator.js';
-export * from './interfaces/http-context.interface.js';
-export * from './interfaces/execution-query.interface.js';
+export * from './interfaces/execution-context.interface.js';
+export * from './interfaces/query.interface.js';
 export * from './interfaces/resource-container.interface.js';
-export * from './interfaces/user-context.interface.js';
-export * from './implementation/execution-context.js';
+export * from './implementation/query-context.js';
 export * from './implementation/opra-document.js';
 export * from './implementation/opra-service.js';
 export * from './implementation/schema-generator.js';

package/esm/index.js

@@ -4,11 +4,10 @@ export * from './types.js';
 export * from './enums/index.js';
 export * from './exception/index.js';
 export * from './decorators/entity-resource.decorator.js';
-export * from './interfaces/http-context.interface.js';
-export * from './interfaces/execution-query.interface.js';
+export * from './interfaces/execution-context.interface.js';
+export * from './interfaces/query.interface.js';
 export * from './interfaces/resource-container.interface.js';
-export * from './interfaces/user-context.interface.js';
-export * from './implementation/execution-context.js';
+export * from './implementation/query-context.js';
 export * from './implementation/opra-document.js';
 export * from './implementation/opra-service.js';
 export * from './implementation/schema-generator.js';

package/esm/interfaces/execution-context.interface.d.ts

@@ -0,0 +1,39 @@
+export declare type ContextType = 'http' | 'ws' | 'rpc';
+export declare type PlatformType = 'express';
+export declare namespace IExecutionContext {
+    type OnFinishArgs = {
+        userContext: any;
+        failed: boolean;
+    };
+}
+export interface IExecutionContext {
+    getType(): ContextType;
+    getPlatform(): PlatformType;
+    switchToHttp(): IHttpExecutionContext;
+    onFinish(fn: (args: IExecutionContext.OnFinishArgs) => void | Promise<void>): any;
+}
+export interface IHttpExecutionContext extends IExecutionContext {
+    getRequest(): any;
+    getResponse(): any;
+    getRequestWrapper(): IHttpRequestWrapper;
+    getResponseWrapper(): IHttpResponseWrapper;
+}
+export interface IHttpRequestWrapper {
+    getInstance(): any;
+    getUrl(): string;
+    getMethod(): string;
+    getHeaderNames(): string[];
+    getHeader(name: string): string | undefined;
+    getHeaders(): Record<string, any>;
+    getBody(): any;
+}
+export interface IHttpResponseWrapper {
+    getInstance(): any;
+    getStatus(): number | undefined;
+    setStatus(value: number): this;
+    getHeaderNames(name: string): string[];
+    getHeader(name: string): string | undefined;
+    setHeader(name: string, value: string): this;
+    send(body: any): this;
+    end(): this;
+}

package/esm/interfaces/{execution-query.interface.d.ts → query.interface.d.ts}

@@ -3,13 +3,13 @@ import { OpraSchema } from '@opra/schema';
 import { Expression } from '@opra/url';
 import { EntityResourceHandler } from '../implementation/resource/entity-resource-handler.js';
 import { KeyValue, OperationType, QueryScope, QueryType } from '../types.js';
-export declare type ExecutionQuery = CreateQuery | ReadQuery | SearchQuery | UpdateQuery | UpdateManyQuery | DeleteQuery | DeleteManyQuery;
-interface BaseQuery {
+export declare type OpraQuery = OpraCreateQuery | OpraGetQuery | OpraSearchQuery | OpraUpdateQuery | OpraUpdateManyQuery | OpraDeleteQuery | OpraDeleteManyQuery;
+interface BaseOpraQuery {
     queryType: QueryType;
     scope: QueryScope;
     operationType: OperationType;
 }
-export interface CreateQuery extends BaseQuery {
+export interface OpraCreateQuery extends BaseOpraQuery {
     queryType: 'create';
     scope: 'collection';
     operationType: 'create';
@@ -19,7 +19,7 @@ export interface CreateQuery extends BaseQuery {
     omit?: string[];
     include?: string[];
 }
-export interface ReadQuery extends BaseQuery {
+export interface OpraGetQuery extends BaseOpraQuery {
     queryType: 'get';
     scope: 'instance';
     operationType: 'read';
@@ -28,16 +28,16 @@ export interface ReadQuery extends BaseQuery {
     pick?: string[];
     omit?: string[];
     include?: string[];
-    nested?: PropertyQuery;
+    nested?: OpraPropertyQuery;
 }
-export interface PropertyQuery extends BaseQuery {
+export interface OpraPropertyQuery extends BaseOpraQuery {
     queryType: 'get';
     scope: 'property';
     operationType: 'read';
     property: OpraSchema.Property;
-    nested?: PropertyQuery;
+    nested?: OpraPropertyQuery;
 }
-export interface UpdateQuery extends BaseQuery {
+export interface OpraUpdateQuery extends BaseOpraQuery {
     queryType: 'update';
     scope: 'instance';
     operationType: 'update';
@@ -48,7 +48,7 @@ export interface UpdateQuery extends BaseQuery {
     omit?: string[];
     include?: string[];
 }
-export interface UpdateManyQuery extends BaseQuery {
+export interface OpraUpdateManyQuery extends BaseOpraQuery {
     queryType: 'updateMany';
     scope: 'collection';
     operationType: 'update';
@@ -56,21 +56,21 @@ export interface UpdateManyQuery extends BaseQuery {
     filter?: string | Expression;
     data: {};
 }
-export interface DeleteQuery extends BaseQuery {
+export interface OpraDeleteQuery extends BaseOpraQuery {
     queryType: 'delete';
     scope: 'instance';
     operationType: 'delete';
     resource: EntityResourceHandler;
     keyValue: KeyValue;
 }
-export interface DeleteManyQuery extends BaseQuery {
+export interface OpraDeleteManyQuery extends BaseOpraQuery {
     queryType: 'deleteMany';
     scope: 'collection';
     operationType: 'delete';
     resource: EntityResourceHandler;
     filter?: string | Expression;
 }
-export interface SearchQuery extends BaseQuery {
+export interface OpraSearchQuery extends BaseOpraQuery {
     queryType: 'search';
     scope: 'collection';
     operationType: 'read';
@@ -85,18 +85,24 @@ export interface SearchQuery extends BaseQuery {
     count?: boolean;
     sort?: string[];
 }
-export declare namespace ExecutionQuery {
-    function forCreate(resource: EntityResourceHandler, values: {}, options?: StrictOmit<CreateQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'data'>): CreateQuery;
-    function forGet(resource: EntityResourceHandler, key: KeyValue, options?: StrictOmit<ReadQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'keyValue'>): ReadQuery;
-    function forSearch(resource: EntityResourceHandler, options?: StrictOmit<SearchQuery, 'queryType' | 'scope' | 'operationType' | 'resource'>): SearchQuery;
-    function forGetProperty(property: OpraSchema.Property, options?: StrictOmit<PropertyQuery, 'queryType' | 'scope' | 'operationType' | 'property'>): PropertyQuery;
-    function forUpdate(resource: EntityResourceHandler, keyValue: KeyValue, values: any, options?: StrictOmit<UpdateQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'keyValue' | 'data'>): UpdateQuery;
-    function forUpdateMany(resource: EntityResourceHandler, values: any, options?: StrictOmit<UpdateManyQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'data'>): UpdateManyQuery;
-    function forDelete(resource: EntityResourceHandler, key: KeyValue): DeleteQuery;
-    function forDeleteMany(resource: EntityResourceHandler, options?: StrictOmit<DeleteManyQuery, 'queryType' | 'scope' | 'operationType' | 'resource'>): DeleteManyQuery;
-    function isCreateQuery(q: any): q is CreateQuery;
-    function isSearchQuery(q: any): q is SearchQuery;
-    function isReadQuery(q: any): q is ReadQuery;
-    function isDeleteQuery(q: any): q is DeleteQuery;
+export declare type CreateQueryOptions = StrictOmit<OpraCreateQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'data'>;
+export declare type GetQueryOptions = StrictOmit<OpraGetQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'keyValue'>;
+export declare type SearchQueryOptions = StrictOmit<OpraSearchQuery, 'queryType' | 'scope' | 'operationType' | 'resource'>;
+export declare type UpdateQueryOptions = StrictOmit<OpraUpdateQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'keyValue' | 'data'>;
+export declare type UpdateManyQueryOptions = StrictOmit<OpraUpdateManyQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'data'>;
+export declare type DeleteManyQueryOption = StrictOmit<OpraDeleteManyQuery, 'queryType' | 'scope' | 'operationType' | 'resource'>;
+export declare namespace OpraQuery {
+    function forCreate(resource: EntityResourceHandler, values: {}, options?: CreateQueryOptions): OpraCreateQuery;
+    function forGet(resource: EntityResourceHandler, key: KeyValue, options?: GetQueryOptions): OpraGetQuery;
+    function forSearch(resource: EntityResourceHandler, options?: SearchQueryOptions): OpraSearchQuery;
+    function forGetProperty(property: OpraSchema.Property, options?: StrictOmit<OpraPropertyQuery, 'queryType' | 'scope' | 'operationType' | 'property'>): OpraPropertyQuery;
+    function forUpdate(resource: EntityResourceHandler, keyValue: KeyValue, values: any, options?: UpdateQueryOptions): OpraUpdateQuery;
+    function forUpdateMany(resource: EntityResourceHandler, values: any, options?: UpdateManyQueryOptions): OpraUpdateManyQuery;
+    function forDelete(resource: EntityResourceHandler, key: KeyValue): OpraDeleteQuery;
+    function forDeleteMany(resource: EntityResourceHandler, options?: DeleteManyQueryOption): OpraDeleteManyQuery;
+    function isCreateQuery(q: any): q is OpraCreateQuery;
+    function isSearchQuery(q: any): q is OpraSearchQuery;
+    function isReadQuery(q: any): q is OpraGetQuery;
+    function isDeleteQuery(q: any): q is OpraDeleteQuery;
 }
 export {};

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

@@ -1,8 +1,8 @@
 import _ from 'lodash';
 import { ComplexType } from '../implementation/data-type/complex-type.js';
 import { stringPathToObjectTree } from '../utils/string-path-to-object-tree.js';
-export var ExecutionQuery;
-(function (ExecutionQuery) {
+export var OpraQuery;
+(function (OpraQuery) {
     function forCreate(resource, values, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -20,7 +20,7 @@ export var ExecutionQuery;
         Object.assign(out, _.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);
@@ -39,7 +39,7 @@ export var ExecutionQuery;
         Object.assign(out, _.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);
@@ -58,7 +58,7 @@ export var ExecutionQuery;
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forSearch = forSearch;
+    OpraQuery.forSearch = forSearch;
     function forGetProperty(property, options) {
         const out = {
             queryType: 'get',
@@ -69,7 +69,7 @@ export var ExecutionQuery;
         Object.assign(out, _.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);
@@ -89,7 +89,7 @@ export var ExecutionQuery;
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forUpdate = forUpdate;
+    OpraQuery.forUpdate = forUpdate;
     function forUpdateMany(resource, values, options) {
         const out = {
             queryType: 'updateMany',
@@ -101,7 +101,7 @@ export var ExecutionQuery;
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    ExecutionQuery.forUpdateMany = forUpdateMany;
+    OpraQuery.forUpdateMany = forUpdateMany;
     function forDelete(resource, key) {
         checkKeyFields(resource, key);
         return {
@@ -112,7 +112,7 @@ export var ExecutionQuery;
             keyValue: key
         };
     }
-    ExecutionQuery.forDelete = forDelete;
+    OpraQuery.forDelete = forDelete;
     function forDeleteMany(resource, options) {
         const out = {
             queryType: 'deleteMany',
@@ -123,24 +123,24 @@ export var ExecutionQuery;
         Object.assign(out, _.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 || (ExecutionQuery = {}));
+    OpraQuery.isDeleteQuery = isDeleteQuery;
+})(OpraQuery || (OpraQuery = {}));
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function checkKeyFields(resource, key) {
     if (!resource.dataType.primaryKey)

package/esm/services/entity-resource-controller.d.ts

@@ -1,17 +1,17 @@
 import { Maybe } from 'ts-gems';
 import { EntityOutput } from '@sqb/connect';
-import { ExecutionContext } from '../implementation/execution-context.js';
+import { QueryContext } from '../implementation/query-context.js';
 export interface IEntityService {
-    processRequest(ctx: ExecutionContext): any;
+    processRequest(ctx: QueryContext): any;
 }
 export declare abstract class EntityResourceController<T> {
-    search(ctx: ExecutionContext): Promise<Maybe<EntityOutput<T>>[]>;
-    get(ctx: ExecutionContext): Promise<Maybe<EntityOutput<T>>>;
-    count(ctx: ExecutionContext): Promise<Maybe<number>>;
-    create(ctx: ExecutionContext): Promise<Maybe<EntityOutput<T>>>;
-    update(ctx: ExecutionContext): Promise<Maybe<EntityOutput<T>>>;
-    updateMany(ctx: ExecutionContext): Promise<Maybe<number>>;
-    delete(ctx: ExecutionContext): Promise<Maybe<boolean | number>>;
-    deleteMany(ctx: ExecutionContext): Promise<Maybe<number>>;
-    abstract getService(ctx: ExecutionContext): IEntityService | Promise<IEntityService>;
+    search(ctx: QueryContext): Promise<Maybe<EntityOutput<T>>[]>;
+    get(ctx: QueryContext): Promise<Maybe<EntityOutput<T>>>;
+    count(ctx: QueryContext): Promise<Maybe<number>>;
+    create(ctx: QueryContext): Promise<Maybe<EntityOutput<T>>>;
+    update(ctx: QueryContext): Promise<Maybe<EntityOutput<T>>>;
+    updateMany(ctx: QueryContext): Promise<Maybe<number>>;
+    delete(ctx: QueryContext): Promise<Maybe<boolean | number>>;
+    deleteMany(ctx: QueryContext): Promise<Maybe<number>>;
+    abstract getService(ctx: QueryContext): IEntityService | Promise<IEntityService>;
 }

package/esm/utils/internal-data-types.d.ts

@@ -1,4 +1,5 @@
+import { Type } from 'ts-gems';
 import { OpraSchema } from '@opra/schema';
-export declare const builtinClassMap: Map<any, any>;
 export declare const primitiveDataTypeNames: string[];
+export declare const builtinClassMap: Map<Type<any>, OpraSchema.DataType>;
 export declare const internalDataTypes: Map<string, OpraSchema.DataType>;