@opra/core 0.0.13 → 0.1.1

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

@@ -0,0 +1,80 @@
+import { translate } from '@opra/i18n';
+import { ComplexType } from '@opra/schema';
+import { HttpHeaders } from '../../enums/index.js';
+import { ForbiddenError, ResourceNotFoundError } from '../../exception/index.js';
+import { OpraQuery } from '../../interfaces/query.interface.js';
+export async function entityResourceExecute(service, resource, context) {
+    const { query } = context;
+    if (OpraQuery.isSearchQuery(query)) {
+        const promises = [];
+        let search;
+        let count;
+        promises.push(executeFn(service, resource, context, query.queryType)
+            .then(v => search = v));
+        if (query.count) {
+            promises.push(executeFn(service, resource, context, 'count')
+                .then(v => count = v));
+        }
+        await Promise.all(promises);
+        context.response.value = {
+            ...search,
+            ...count
+        };
+        return;
+    }
+    context.response.value = await executeFn(service, resource, context, query.queryType);
+}
+async function executeFn(service, resource, context, queryType) {
+    const resolverInfo = resource.metadata.methods?.[queryType];
+    if (!resolverInfo.handler)
+        throw new ForbiddenError({
+            message: translate('RESOLVER_FORBIDDEN', { queryType }),
+            severity: 'error',
+            code: 'RESOLVER_FORBIDDEN'
+        });
+    let result = await resolverInfo.handler(context);
+    switch (queryType) {
+        case 'search':
+            context.response.headers.set(HttpHeaders.X_Opra_Schema, '/$schema/types/' + resource.dataType.name);
+            return {
+                items: Array.isArray(result) ? result : (context.response.value ? [result] : [])
+            };
+        case 'get':
+        case 'update':
+            if (!result) {
+                const query = context.query;
+                throw new ResourceNotFoundError(resource.name, query.keyValue);
+            }
+            break;
+        case 'count':
+            return { count: result || 0 };
+        case 'delete':
+        case 'deleteMany':
+        case 'updateMany':
+            let affectedRecords;
+            if (typeof result === 'number')
+                affectedRecords = result;
+            if (typeof result === 'boolean')
+                affectedRecords = result ? 1 : 0;
+            if (typeof result === 'object')
+                affectedRecords = result.affectedRows || result.affectedRecords;
+            return { affectedRecords };
+    }
+    if (!result)
+        return;
+    result = Array.isArray(result) ? result[0] : result;
+    let dataType = resource.dataType;
+    if (context.resultPath) {
+        const pathArray = context.resultPath.split('.');
+        for (const field of pathArray) {
+            const prop = dataType instanceof ComplexType ? dataType.fields.get(field) : undefined;
+            dataType = prop && prop.type ? service.types.get(prop.type) : undefined;
+            result = result && typeof result === 'object' && result[field];
+        }
+    }
+    if (queryType === 'create')
+        context.response.status = 201;
+    if (dataType)
+        context.response.headers.set(HttpHeaders.X_Opra_Schema, '/$schema/types/' + dataType.name);
+    return result;
+}

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

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

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

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

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

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

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

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

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

@@ -1,8 +1,8 @@
 import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
-import { ApiException } from '../../exception/index.js';
-import { IExecutionContext } from '../../interfaces/execution-context.interface.js';
-import { OpraService } from '../opra-service.js';
-import { QueryContext } from '../query-context.js';
+import { OpraService } from '@opra/schema';
+import { ApiException } from '../exception/index.js';
+import { IExecutionContext } from '../interfaces/execution-context.interface.js';
+import { QueryContext } from './query-context.js';
 export declare namespace OpraAdapter {
     type UserContextResolver = (args: {
         executionContext: IExecutionContext;
@@ -52,6 +52,6 @@ export declare abstract class OpraAdapter<TExecutionContext extends IExecutionCo
     protected abstract sendError(executionContext: TExecutionContext, error: ApiException): Promise<void>;
     protected abstract isBatch(executionContext: TExecutionContext): boolean;
     protected handler(executionContext: TExecutionContext): Promise<void>;
-    protected _metadataExecute(ctx: QueryContext): Promise<void>;
+    protected _getSchemaExecute(ctx: QueryContext): Promise<void>;
     protected static initI18n(options?: OpraAdapter.Options): Promise<I18n>;
 }

package/esm/implementation/{adapter/adapter.js → adapter.js}

@@ -1,8 +1,11 @@
 import { AsyncEventEmitter } from 'strict-typed-events';
 import { I18n } from '@opra/i18n';
-import { BadRequestError, FailedDependencyError } from '../../exception/index.js';
-import { wrapError } from '../../exception/wrap-error.js';
-import { createI18n } from '../../utils/create-i18n.js';
+import { HttpHeaders } from '../enums/index.js';
+import { BadRequestError, FailedDependencyError } from '../exception/index.js';
+import { wrapError } from '../exception/wrap-error.js';
+import { createI18n } from '../utils/create-i18n.js';
+import { resourceExecute } from './adapter-utils/resource-execute.util.js';
+import { resourcePrepare } from './adapter-utils/resource-prepare.util.js';
 export class OpraAdapter {
     service;
     i18n;
@@ -39,19 +42,19 @@ export class OpraAdapter {
                 }
                 try {
                     const promise = (async () => {
-                        if (context.query.queryType === 'metadata') {
-                            await this._metadataExecute(context);
+                        if (context.query.queryType === 'schema') {
+                            await this._getSchemaExecute(context);
                             return;
                         }
                         const resource = context.query.resource;
-                        await resource.prepare(context);
+                        await resourcePrepare(resource, context);
                         if (this.userContextResolver && !userContext)
                             userContext = this.userContextResolver({
                                 executionContext,
                                 isBatch: this.isBatch(executionContext)
                             });
                         context.userContext = userContext;
-                        await resource.execute(context);
+                        await resourceExecute(this.service, resource, context);
                     })().catch(e => {
                         context.response.errors.push(e);
                     });
@@ -92,7 +95,7 @@ export class OpraAdapter {
             }
         }
     }
-    async _metadataExecute(ctx) {
+    async _getSchemaExecute(ctx) {
         const query = ctx.query;
         let out;
         if (query.resourcePath.length > 2)
@@ -100,23 +103,23 @@ export class OpraAdapter {
         if (query.resourcePath?.length) {
             if (query.resourcePath[0] === 'resources') {
                 const resource = this.service.getResource(query.resourcePath[1]);
-                out = resource.getMetadata();
+                out = resource.getSchema(true);
                 query.resourcePath[1] = resource.name;
+                ctx.response.headers.set(HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema#' + resource.kind);
             }
             else if (query.resourcePath[0] === 'types') {
                 const dataType = this.service.getDataType(query.resourcePath[1]);
-                out = dataType.getMetadata();
+                out = dataType.getSchema(true);
                 query.resourcePath[1] = dataType.name;
+                ctx.response.headers.set(HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema#' + dataType.kind);
             }
             else
                 throw new BadRequestError();
-            ctx.response.value = {
-                '@opra:metadata': '/$metadata/' + query.resourcePath.join('/'),
-                ...out
-            };
+            ctx.response.value = out;
             return;
         }
-        ctx.response.value = this.service.getMetadata();
+        ctx.response.headers.set(HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema');
+        ctx.response.value = this.service.getSchema(true);
     }
     static async initI18n(options) {
         if (options?.i18n instanceof I18n)

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

@@ -1,6 +1,6 @@
 import type { Application } from 'express';
-import type { IHttpExecutionContext } from '../../interfaces/execution-context.interface';
-import type { OpraService } from '../opra-service.js';
+import { OpraService } from '@opra/schema';
+import type { IHttpExecutionContext } from '../interfaces/execution-context.interface';
 import { OpraHttpAdapter } from './http-adapter.js';
 export declare namespace OpraExpressAdapter {
     interface Options extends OpraHttpAdapter.Options {

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

@@ -1,10 +1,9 @@
 import { OpraURL } from '@opra/url';
-import { ApiException } from '../../exception/index.js';
-import { IHttpExecutionContext } from '../../interfaces/execution-context.interface.js';
-import { OpraMetadataQuery, OpraQuery } from '../../interfaces/query.interface.js';
-import { HeadersObject } from '../../utils/headers.js';
-import { QueryContext } from '../query-context.js';
+import { ApiException } from '../exception/index.js';
+import { IHttpExecutionContext } from '../interfaces/execution-context.interface.js';
+import { OpraGetSchemaQuery, OpraQuery } from '../interfaces/query.interface.js';
 import { OpraAdapter } from './adapter.js';
+import { QueryContext } from './query-context.js';
 export declare namespace OpraHttpAdapter {
     type Options = OpraAdapter.Options & {
         prefix?: string;
@@ -17,8 +16,8 @@ interface PreparedOutput {
 }
 export declare class OpraHttpAdapter<TExecutionContext extends IHttpExecutionContext> extends OpraAdapter<IHttpExecutionContext> {
     protected prepareRequests(executionContext: TExecutionContext): QueryContext[];
-    prepareRequest(executionContext: IHttpExecutionContext, url: OpraURL, method: string, headers: HeadersObject, body?: any): QueryContext;
-    buildMetadataQuery(url: OpraURL): OpraMetadataQuery;
+    prepareRequest(executionContext: IHttpExecutionContext, url: OpraURL, method: string, headers: Map<string, string>, body?: any): QueryContext;
+    buildGetSchemaQuery(url: OpraURL): OpraGetSchemaQuery;
     buildQuery(url: OpraURL, method: string, body?: any): OpraQuery | undefined;
     protected sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
     protected isBatch(executionContext: TExecutionContext): boolean;

package/esm/implementation/{adapter/http-adapter.js → http-adapter.js}

@@ -1,15 +1,11 @@
+import { ComplexType, ContainerResource, EntityResource, OpraSchema, ResponsiveMap } from '@opra/schema';
 import { OpraURL } from '@opra/url';
-import { OpraVersion } from '../../constants.js';
-import { HttpHeaders, HttpStatus } from '../../enums/index.js';
-import { BadRequestError, InternalServerError, MethodNotAllowedError, NotFoundError, } from '../../exception/index.js';
-import { wrapError } from '../../exception/wrap-error.js';
-import { OpraQuery } from '../../interfaces/query.interface.js';
-import { Headers } from '../../utils/headers.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { QueryContext } from '../query-context.js';
-import { ContainerResourceHandler } from '../resource/container-resource-handler.js';
-import { EntityResourceHandler } from '../resource/entity-resource-handler.js';
+import { HttpHeaders, HttpStatus } from '../enums/index.js';
+import { BadRequestError, InternalServerError, MethodNotAllowedError, NotFoundError, } from '../exception/index.js';
+import { wrapError } from '../exception/wrap-error.js';
+import { OpraQuery } from '../interfaces/query.interface.js';
 import { OpraAdapter } from './adapter.js';
+import { QueryContext } from './query-context.js';
 export class OpraHttpAdapter extends OpraAdapter {
     prepareRequests(executionContext) {
         const req = executionContext.getRequestWrapper();
@@ -19,7 +15,7 @@ export class OpraHttpAdapter extends OpraAdapter {
         }
         const url = new OpraURL(req.getUrl());
         return [
-            this.prepareRequest(executionContext, url, req.getMethod(), Headers.from(req.getHeaders()), req.getBody())
+            this.prepareRequest(executionContext, url, req.getMethod(), new ResponsiveMap(req.getHeaders()), req.getBody())
         ];
     }
     prepareRequest(executionContext, url, method, headers, body) {
@@ -41,7 +37,7 @@ export class OpraHttpAdapter extends OpraAdapter {
             continueOnError: query.operation === 'read'
         });
     }
-    buildMetadataQuery(url) {
+    buildGetSchemaQuery(url) {
         const pathLen = url.path.size;
         const resourcePath = [];
         let pathIndex = 0;
@@ -49,7 +45,7 @@ export class OpraHttpAdapter extends OpraAdapter {
             const p = url.path.get(pathIndex++);
             if (p.key)
                 throw new BadRequestError();
-            if (p.resource !== '$metadata') {
+            if (p.resource !== '$schema') {
                 if (pathIndex === 1)
                     resourcePath.push('resources');
                 resourcePath.push(p.resource);
@@ -60,7 +56,7 @@ export class OpraHttpAdapter extends OpraAdapter {
             omit: url.searchParams.get('$omit'),
             include: url.searchParams.get('$include'),
         };
-        return OpraQuery.forGetMetadata(resourcePath, opts);
+        return OpraQuery.forGetSchema(resourcePath, opts);
     }
     buildQuery(url, method, body) {
         let container = this.service;
@@ -69,10 +65,10 @@ export class OpraHttpAdapter extends OpraAdapter {
             // Check if requesting metadata
             for (let i = 0; i < pathLen; i++) {
                 const p = url.path.get(i);
-                if (p.resource === '$metadata') {
+                if (p.resource === '$schema') {
                     if (method !== 'GET')
                         return;
-                    return this.buildMetadataQuery(url);
+                    return this.buildGetSchemaQuery(url);
                 }
             }
             let pathIndex = 0;
@@ -80,12 +76,12 @@ export class OpraHttpAdapter extends OpraAdapter {
                 let p = url.path.get(pathIndex++);
                 const resource = container.getResource(p.resource);
                 // Move through path directories (containers)
-                if (resource instanceof ContainerResourceHandler) {
+                if (resource instanceof ContainerResource) {
                     container = resource;
                     continue;
                 }
                 method = method.toUpperCase();
-                if (resource instanceof EntityResourceHandler) {
+                if (resource instanceof EntityResource) {
                     const scope = p.key ? 'instance' : 'collection';
                     if (pathIndex < pathLen && !(method === 'GET' && scope === 'instance'))
                         return;
@@ -119,10 +115,10 @@ export class OpraHttpAdapter extends OpraAdapter {
                                         ? this.service.getDataType(nested.property.type || 'string')
                                         : query.resource.dataType;
                                     if (!(dataType instanceof ComplexType))
-                                        throw new Error(`"${path}" is not a ComplexType and has no properties.`);
+                                        throw new Error(`"${path}" is not a ComplexType and has no fields.`);
                                     p = url.path.get(pathIndex++);
                                     path += '.' + p.resource;
-                                    const prop = dataType.properties?.[p.resource];
+                                    const prop = dataType.fields.get(p.resource);
                                     if (!prop)
                                         throw new NotFoundError({ message: `Invalid or unknown resource path (${path})` });
                                     const q = OpraQuery.forGetProperty(prop);
@@ -209,7 +205,7 @@ export class OpraHttpAdapter extends OpraAdapter {
         resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
         resp.setHeader(HttpHeaders.Pragma, 'no-cache');
         resp.setHeader(HttpHeaders.Expires, '-1');
-        resp.setHeader(HttpHeaders.X_Opra_Version, OpraVersion);
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
         if (out.headers) {
             for (const [k, v] of Object.entries(out.headers)) {
                 resp.setHeader(k, v);
@@ -241,10 +237,16 @@ export class OpraHttpAdapter extends OpraAdapter {
             delete body.errors;
             status = status || (query.operation === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
         }
+        // Convert headers map to object
+        const headers = Array.from(ctx.response.headers.keys()).map(k => k.toLowerCase()).sort()
+            .reduce((a, k) => {
+            a[k] = ctx.response.headers.get(k);
+            return a;
+        }, {});
         body = this.i18n.deep(body);
         return {
             status,
-            headers: ctx.response.headers,
+            headers,
             body
         };
     }
@@ -255,7 +257,7 @@ export class OpraHttpAdapter extends OpraAdapter {
         resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
         resp.setHeader(HttpHeaders.Pragma, 'no-cache');
         resp.setHeader(HttpHeaders.Expires, '-1');
-        resp.setHeader(HttpHeaders.X_Opra_Version, OpraVersion);
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
         resp.send(JSON.stringify(error.response));
     }
 }

package/esm/implementation/query-context.d.ts

@@ -1,17 +1,16 @@
+import { OpraService, ResponsiveMap } from '@opra/schema';
 import { SearchParams } from '@opra/url';
 import { HttpStatus } from '../enums/index.js';
 import { ApiException } from '../exception/index.js';
 import { ContextType, IExecutionContext, IHttpExecutionContext } from '../interfaces/execution-context.interface.js';
 import { OpraQuery } from '../interfaces/query.interface.js';
-import { HeadersObject } from '../utils/headers.js';
-import { OpraService } from './opra-service.js';
 export declare type QueryContextArgs = Pick<QueryContext, 'service' | 'executionContext' | 'query' | 'params' | 'headers' | 'userContext' | 'parentValue' | 'continueOnError'>;
 export declare class QueryContext {
     readonly service: OpraService;
     readonly executionContext: IExecutionContext;
     readonly query: OpraQuery;
     readonly params: SearchParams;
-    readonly headers: HeadersObject;
+    readonly headers: Map<string, string>;
     readonly parentValue?: any;
     readonly resultPath: string;
     readonly response: QueryResponse;
@@ -23,7 +22,7 @@ export declare class QueryContext {
 }
 export declare type QueryResponseArgs = Pick<QueryResponse, 'status' | 'value' | 'total'>;
 export declare class QueryResponse {
-    headers: HeadersObject;
+    headers: ResponsiveMap<string, string>;
     errors: ApiException[];
     status?: HttpStatus;
     value?: any;

package/esm/implementation/query-context.js

@@ -1,5 +1,6 @@
+import { ResponsiveMap } from '@opra/schema';
 import { OpraURLSearchParams } from '@opra/url';
-import { Headers } from '../utils/headers.js';
+import { HttpHeaders } from '../enums/index.js';
 export class QueryContext {
     service;
     executionContext;
@@ -15,7 +16,7 @@ export class QueryContext {
         Object.assign(this, args);
         this.response = new QueryResponse();
         this.params = this.params || new OpraURLSearchParams();
-        this.headers = this.headers || Headers.create();
+        this.headers = this.headers || new ResponsiveMap();
         this.resultPath = this.resultPath || '';
     }
     get type() {
@@ -28,7 +29,7 @@ export class QueryContext {
     }
 }
 export class QueryResponse {
-    headers = Headers.create();
+    headers;
     errors = [];
     status;
     value;
@@ -36,5 +37,6 @@ export class QueryResponse {
     constructor(args) {
         if (args)
             Object.assign(this, args);
+        this.headers = new ResponsiveMap(undefined, Array.from(Object.values(HttpHeaders)));
     }
 }

package/esm/index.d.ts

@@ -1,23 +1,13 @@
 import "reflect-metadata";
-export * from './constants.js';
 export * from './types.js';
 export * from './enums/index.js';
 export * from './exception/index.js';
-export * from './decorators/api-entity-resource.decorator.js';
 export * from './interfaces/execution-context.interface.js';
 export * from './interfaces/query.interface.js';
-export * from './interfaces/resource-container.interface.js';
+export * from './interfaces/entity-service.interface.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';
-export * from './implementation/adapter/adapter.js';
-export * from './implementation/adapter/http-adapter.js';
-export * from './implementation/adapter/express-adapter.js';
-export * from './implementation/data-type/data-type.js';
-export * from './implementation/data-type/complex-type.js';
-export * from './implementation/data-type/simple-type.js';
-export * from './implementation/resource/resource-handler.js';
-export * from './implementation/resource/entity-resource-handler.js';
-export * from './services/entity-resource-controller.js';
+export * from './implementation/adapter.js';
+export * from './implementation/http-adapter.js';
+export * from './implementation/express-adapter.js';
+export * from './services/data-service.js';
 export * from './services/json-data-service.js';

package/esm/index.js

@@ -1,23 +1,13 @@
 import "reflect-metadata";
-export * from './constants.js';
 export * from './types.js';
 export * from './enums/index.js';
 export * from './exception/index.js';
-export * from './decorators/api-entity-resource.decorator.js';
 export * from './interfaces/execution-context.interface.js';
 export * from './interfaces/query.interface.js';
-export * from './interfaces/resource-container.interface.js';
+export * from './interfaces/entity-service.interface.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';
-export * from './implementation/adapter/adapter.js';
-export * from './implementation/adapter/http-adapter.js';
-export * from './implementation/adapter/express-adapter.js';
-export * from './implementation/data-type/data-type.js';
-export * from './implementation/data-type/complex-type.js';
-export * from './implementation/data-type/simple-type.js';
-export * from './implementation/resource/resource-handler.js';
-export * from './implementation/resource/entity-resource-handler.js';
-export * from './services/entity-resource-controller.js';
+export * from './implementation/adapter.js';
+export * from './implementation/http-adapter.js';
+export * from './implementation/express-adapter.js';
+export * from './services/data-service.js';
 export * from './services/json-data-service.js';

package/esm/interfaces/query.interface.d.ts

@@ -1,17 +1,16 @@
 import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
+import { EntityResource, 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 OpraQuery = OpraMetadataQuery | OpraCreateQuery | OpraGetEntityQuery | OpraSearchQuery | OpraUpdateQuery | OpraUpdateManyQuery | OpraDeleteQuery | OpraDeleteManyQuery;
+import { KeyValue, QueryType } from '../types.js';
+export declare type OpraQuery = OpraGetSchemaQuery | OpraCreateQuery | OpraGetEntityQuery | OpraSearchQuery | OpraUpdateQuery | OpraUpdateManyQuery | OpraDeleteQuery | OpraDeleteManyQuery;
 interface BaseOpraQuery {
     queryType: QueryType;
-    scope: QueryScope;
-    operation: OperationType;
+    scope: OpraSchema.QueryScope;
+    operation: OpraSchema.OperationType;
 }
-export interface OpraMetadataQuery extends BaseOpraQuery {
-    queryType: 'metadata';
-    scope: QueryScope;
+export interface OpraGetSchemaQuery extends BaseOpraQuery {
+    queryType: 'schema';
+    scope: OpraSchema.QueryScope;
     operation: 'read';
     resourcePath: string[];
 }
@@ -19,7 +18,7 @@ export interface OpraCreateQuery extends BaseOpraQuery {
     queryType: 'create';
     scope: 'collection';
     operation: 'create';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     data: {};
     pick?: string[];
     omit?: string[];
@@ -29,7 +28,7 @@ export interface OpraGetEntityQuery extends BaseOpraQuery {
     queryType: 'get';
     scope: 'instance';
     operation: 'read';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     keyValue: KeyValue;
     pick?: string[];
     omit?: string[];
@@ -40,14 +39,14 @@ export interface OpraPropertyQuery extends BaseOpraQuery {
     queryType: 'get';
     scope: 'property';
     operation: 'read';
-    property: OpraSchema.Property;
+    property: OpraSchema.Field;
     nested?: OpraPropertyQuery;
 }
 export interface OpraUpdateQuery extends BaseOpraQuery {
     queryType: 'update';
     scope: 'instance';
     operation: 'update';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     keyValue: KeyValue;
     data: {};
     pick?: string[];
@@ -58,7 +57,7 @@ export interface OpraUpdateManyQuery extends BaseOpraQuery {
     queryType: 'updateMany';
     scope: 'collection';
     operation: 'update';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     filter?: string | Expression;
     data: {};
 }
@@ -66,21 +65,21 @@ export interface OpraDeleteQuery extends BaseOpraQuery {
     queryType: 'delete';
     scope: 'instance';
     operation: 'delete';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     keyValue: KeyValue;
 }
 export interface OpraDeleteManyQuery extends BaseOpraQuery {
     queryType: 'deleteMany';
     scope: 'collection';
     operation: 'delete';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     filter?: string | Expression;
 }
 export interface OpraSearchQuery extends BaseOpraQuery {
     queryType: 'search';
     scope: 'collection';
     operation: 'read';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     pick?: string[];
     omit?: string[];
     include?: string[];
@@ -99,15 +98,15 @@ export declare type UpdateManyQueryOptions = StrictOmit<OpraUpdateManyQuery, 'qu
 export declare type DeleteQueryOptions = StrictOmit<OpraDeleteQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue'>;
 export declare type DeleteManyQueryOption = StrictOmit<OpraDeleteManyQuery, 'queryType' | 'scope' | 'operation' | 'resource'>;
 export declare namespace OpraQuery {
-    function forCreate(resource: EntityResourceHandler, values: {}, options?: CreateQueryOptions): OpraCreateQuery;
-    function forGetMetadata(resourcePath: string[], options?: GetEntityQueryOptions): OpraMetadataQuery;
-    function forGetEntity(resource: EntityResourceHandler, key: KeyValue, options?: GetEntityQueryOptions): OpraGetEntityQuery;
-    function forSearch(resource: EntityResourceHandler, options?: SearchQueryOptions): OpraSearchQuery;
-    function forGetProperty(property: OpraSchema.Property, options?: StrictOmit<OpraPropertyQuery, 'queryType' | 'scope' | 'operation' | '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 forCreate(resource: EntityResource, values: {}, options?: CreateQueryOptions): OpraCreateQuery;
+    function forGetSchema(resourcePath: string[], options?: GetEntityQueryOptions): OpraGetSchemaQuery;
+    function forGetEntity(resource: EntityResource, key: KeyValue, options?: GetEntityQueryOptions): OpraGetEntityQuery;
+    function forSearch(resource: EntityResource, options?: SearchQueryOptions): OpraSearchQuery;
+    function forGetProperty(property: OpraSchema.Field, options?: StrictOmit<OpraPropertyQuery, 'queryType' | 'scope' | 'operation' | 'property'>): OpraPropertyQuery;
+    function forUpdate(resource: EntityResource, keyValue: KeyValue, values: any, options?: UpdateQueryOptions): OpraUpdateQuery;
+    function forUpdateMany(resource: EntityResource, values: any, options?: UpdateManyQueryOptions): OpraUpdateManyQuery;
+    function forDelete(resource: EntityResource, key: KeyValue): OpraDeleteQuery;
+    function forDeleteMany(resource: EntityResource, options?: DeleteManyQueryOption): OpraDeleteManyQuery;
     function isCreateQuery(q: any): q is OpraCreateQuery;
     function isSearchQuery(q: any): q is OpraSearchQuery;
     function isReadQuery(q: any): q is OpraGetEntityQuery;