@opra/core 0.0.12 → 0.1.0

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

@@ -1,8 +1,11 @@
 import { AsyncEventEmitter } from 'strict-typed-events';
 import { I18n } from '@opra/i18n';
-import { 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;
@@ -38,16 +41,20 @@ export class OpraAdapter {
                     continue;
                 }
                 try {
-                    const resource = context.query.resource;
                     const promise = (async () => {
-                        await resource.prepare(context);
+                        if (context.query.queryType === 'schema') {
+                            await this._getSchemaExecute(context);
+                            return;
+                        }
+                        const resource = context.query.resource;
+                        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);
                     });
@@ -88,6 +95,32 @@ export class OpraAdapter {
             }
         }
     }
+    async _getSchemaExecute(ctx) {
+        const query = ctx.query;
+        let out;
+        if (query.resourcePath.length > 2)
+            throw new BadRequestError();
+        if (query.resourcePath?.length) {
+            if (query.resourcePath[0] === 'resources') {
+                const resource = this.service.getResource(query.resourcePath[1]);
+                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.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 = out;
+            return;
+        }
+        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)
             return options.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 { 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,7 +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;
+    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/http-adapter.js

@@ -0,0 +1,263 @@
+import { ComplexType, ContainerResource, EntityResource, OpraSchema, ResponsiveMap } from '@opra/schema';
+import { OpraURL } from '@opra/url';
+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();
+        // todo implement batch requests
+        if (this.isBatch(executionContext)) {
+            throw new Error('not implemented yet');
+        }
+        const url = new OpraURL(req.getUrl());
+        return [
+            this.prepareRequest(executionContext, url, req.getMethod(), new ResponsiveMap(req.getHeaders()), req.getBody())
+        ];
+    }
+    prepareRequest(executionContext, url, method, headers, body) {
+        if (!url.path.size)
+            throw new BadRequestError();
+        if (method !== 'GET' && url.path.size > 1)
+            throw new BadRequestError();
+        const query = this.buildQuery(url, method, body);
+        if (!query)
+            throw new MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target endpoint`
+            });
+        return new QueryContext({
+            service: this.service,
+            executionContext,
+            query,
+            headers,
+            params: url.searchParams,
+            continueOnError: query.operation === 'read'
+        });
+    }
+    buildGetSchemaQuery(url) {
+        const pathLen = url.path.size;
+        const resourcePath = [];
+        let pathIndex = 0;
+        while (pathIndex < pathLen) {
+            const p = url.path.get(pathIndex++);
+            if (p.key)
+                throw new BadRequestError();
+            if (p.resource !== '$schema') {
+                if (pathIndex === 1)
+                    resourcePath.push('resources');
+                resourcePath.push(p.resource);
+            }
+        }
+        const opts = {
+            pick: url.searchParams.get('$pick'),
+            omit: url.searchParams.get('$omit'),
+            include: url.searchParams.get('$include'),
+        };
+        return OpraQuery.forGetSchema(resourcePath, opts);
+    }
+    buildQuery(url, method, body) {
+        let container = this.service;
+        try {
+            const pathLen = url.path.size;
+            // Check if requesting metadata
+            for (let i = 0; i < pathLen; i++) {
+                const p = url.path.get(i);
+                if (p.resource === '$schema') {
+                    if (method !== 'GET')
+                        return;
+                    return this.buildGetSchemaQuery(url);
+                }
+            }
+            let pathIndex = 0;
+            while (pathIndex < pathLen) {
+                let p = url.path.get(pathIndex++);
+                const resource = container.getResource(p.resource);
+                // Move through path directories (containers)
+                if (resource instanceof ContainerResource) {
+                    container = resource;
+                    continue;
+                }
+                method = method.toUpperCase();
+                if (resource instanceof EntityResource) {
+                    const scope = p.key ? 'instance' : 'collection';
+                    if (pathIndex < pathLen && !(method === 'GET' && scope === 'instance'))
+                        return;
+                    let query;
+                    switch (method) {
+                        case 'GET': {
+                            if (scope === 'collection') {
+                                query = OpraQuery.forSearch(resource, {
+                                    filter: url.searchParams.get('$filter'),
+                                    limit: url.searchParams.get('$limit'),
+                                    skip: url.searchParams.get('$skip'),
+                                    distinct: url.searchParams.get('$distinct'),
+                                    count: url.searchParams.get('$count'),
+                                    sort: url.searchParams.get('$sort'),
+                                    pick: url.searchParams.get('$pick'),
+                                    omit: url.searchParams.get('$omit'),
+                                    include: url.searchParams.get('$include'),
+                                });
+                            }
+                            else {
+                                query = OpraQuery.forGetEntity(resource, p.key, {
+                                    pick: url.searchParams.get('$pick'),
+                                    omit: url.searchParams.get('$omit'),
+                                    include: url.searchParams.get('$include')
+                                });
+                                // Move through properties
+                                let nested;
+                                let path = resource.name;
+                                while (pathIndex < pathLen) {
+                                    const dataType = nested
+                                        ? 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 fields.`);
+                                    p = url.path.get(pathIndex++);
+                                    path += '.' + 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);
+                                    if (nested) {
+                                        nested.nested = q;
+                                    }
+                                    else {
+                                        query.nested = q;
+                                    }
+                                    nested = q;
+                                }
+                            }
+                            break;
+                        }
+                        case 'DELETE': {
+                            if (scope === 'collection') {
+                                query = OpraQuery.forDeleteMany(resource, {
+                                    filter: url.searchParams.get('$filter'),
+                                });
+                            }
+                            else {
+                                query = OpraQuery.forDelete(resource, p.key);
+                            }
+                            break;
+                        }
+                        case 'POST': {
+                            if (scope === 'collection') {
+                                query = OpraQuery.forCreate(resource, body, {
+                                    pick: url.searchParams.get('$pick'),
+                                    omit: url.searchParams.get('$omit'),
+                                    include: url.searchParams.get('$include')
+                                });
+                            }
+                            break;
+                        }
+                        case 'PATCH': {
+                            if (scope === 'collection') {
+                                query = OpraQuery.forUpdateMany(resource, body, {
+                                    filter: url.searchParams.get('$filter')
+                                });
+                            }
+                            else {
+                                query = OpraQuery.forUpdate(resource, p.key, body, {
+                                    pick: url.searchParams.get('$pick'),
+                                    omit: url.searchParams.get('$omit'),
+                                    include: url.searchParams.get('$include')
+                                });
+                            }
+                            break;
+                        }
+                    }
+                    return query;
+                }
+            }
+            throw new InternalServerError();
+        }
+        catch (e) {
+            throw BadRequestError.wrap(e);
+        }
+    }
+    async sendResponse(executionContext, queryContexts) {
+        const outputPackets = [];
+        for (const ctx of queryContexts) {
+            const v = this.createOutput(ctx);
+            outputPackets.push(v);
+        }
+        if (this.isBatch(executionContext)) {
+            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
+            return;
+        }
+        if (!outputPackets.length) {
+            const err = new NotFoundError();
+            outputPackets.push({
+                status: err.status,
+                body: {
+                    errors: [err.response]
+                }
+            });
+        }
+        const out = outputPackets[0];
+        const resp = executionContext.getResponseWrapper();
+        resp.setStatus(out.status);
+        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(HttpHeaders.Expires, '-1');
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
+        if (out.headers) {
+            for (const [k, v] of Object.entries(out.headers)) {
+                resp.setHeader(k, v);
+            }
+        }
+        resp.send(JSON.stringify(out.body));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isBatch(executionContext) {
+        return false;
+    }
+    createOutput(ctx) {
+        const { query } = ctx;
+        let status = ctx.response.status;
+        let body = ctx.response.value || {};
+        const errors = ctx.response.errors?.map(e => wrapError(e));
+        if (errors && errors.length) {
+            if (!status || status < 400) {
+                status = 0;
+                for (const e of errors) {
+                    status = Math.max(status, e.status || status);
+                }
+                if (status < HttpStatus.BAD_REQUEST)
+                    status = HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+            body.errors = errors.map(e => e.response);
+        }
+        else {
+            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,
+            body
+        };
+    }
+    async sendError(executionContext, error) {
+        const resp = executionContext.getResponseWrapper();
+        resp.setStatus(error.status || 500);
+        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(HttpHeaders.Expires, '-1');
+        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/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/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,29 +1,34 @@
 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 = OpraCreateQuery | OpraGetQuery | 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 OpraGetSchemaQuery extends BaseOpraQuery {
+    queryType: 'schema';
+    scope: OpraSchema.QueryScope;
+    operation: 'read';
+    resourcePath: string[];
 }
 export interface OpraCreateQuery extends BaseOpraQuery {
     queryType: 'create';
     scope: 'collection';
     operation: 'create';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     data: {};
     pick?: string[];
     omit?: string[];
     include?: string[];
 }
-export interface OpraGetQuery extends BaseOpraQuery {
+export interface OpraGetEntityQuery extends BaseOpraQuery {
     queryType: 'get';
     scope: 'instance';
     operation: 'read';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     keyValue: KeyValue;
     pick?: string[];
     omit?: string[];
@@ -34,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[];
@@ -52,7 +57,7 @@ export interface OpraUpdateManyQuery extends BaseOpraQuery {
     queryType: 'updateMany';
     scope: 'collection';
     operation: 'update';
-    resource: EntityResourceHandler;
+    resource: EntityResource;
     filter?: string | Expression;
     data: {};
 }
@@ -60,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[];
@@ -86,24 +91,25 @@ export interface OpraSearchQuery extends BaseOpraQuery {
     sort?: string[];
 }
 export declare type CreateQueryOptions = StrictOmit<OpraCreateQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'data'>;
-export declare type GetQueryOptions = StrictOmit<OpraGetQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue'>;
+export declare type GetEntityQueryOptions = StrictOmit<OpraGetEntityQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue'>;
 export declare type SearchQueryOptions = StrictOmit<OpraSearchQuery, 'queryType' | 'scope' | 'operation' | 'resource'>;
 export declare type UpdateQueryOptions = StrictOmit<OpraUpdateQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue' | 'data'>;
 export declare type UpdateManyQueryOptions = StrictOmit<OpraUpdateManyQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'data'>;
 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 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' | '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 OpraGetQuery;
+    function isReadQuery(q: any): q is OpraGetEntityQuery;
     function isDeleteQuery(q: any): q is OpraDeleteQuery;
 }
 export {};