@opra/core 0.0.12 → 0.0.13

package/esm/interfaces/metadata/opra-schema.metadata.d.ts

@@ -0,0 +1,7 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { TypeThunkAsync } from '../../types.js';
+export declare type EntityResourceMetadata = StrictOmit<OpraSchema.EntityResource, 'type' | 'name' | 'resolvers'> & {
+    type: TypeThunkAsync | string;
+    name?: string;
+};

package/esm/interfaces/metadata/opra-schema.metadata.js

@@ -0,0 +1,10 @@
+export {};
+/*
+export type ResourceReadOperationMetadata = StrictOmit<OpraSchema.ResourceReadOperation, 'handler'>;
+export type ResourceSearchOperationMetadata = StrictOmit<OpraSchema.ResourceSearchOperation, 'handler'>;
+export type ResourceCreateOperationMetadata = StrictOmit<OpraSchema.ResourceCreateOperation, 'handler'>;
+export type ResourceUpdateOperationMetadata = StrictOmit<OpraSchema.ResourceUpdateOperation, 'handler'>;
+export type ResourcePatchOperationMetadata = StrictOmit<OpraSchema.ResourcePatchOperation, 'handler'>;
+export type ResourceDeleteOperationMetadata = StrictOmit<OpraSchema.ResourceDeleteOperation, 'handler'>;
+export type ResourceExecuteOperationMetadata = StrictOmit<OpraSchema.ResourceExecuteOperation, 'handler'>;
+*/

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

@@ -3,12 +3,18 @@ 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 OpraQuery = OpraCreateQuery | OpraGetQuery | OpraSearchQuery | OpraUpdateQuery | OpraUpdateManyQuery | OpraDeleteQuery | OpraDeleteManyQuery;
+export declare type OpraQuery = OpraMetadataQuery | OpraCreateQuery | OpraGetEntityQuery | OpraSearchQuery | OpraUpdateQuery | OpraUpdateManyQuery | OpraDeleteQuery | OpraDeleteManyQuery;
 interface BaseOpraQuery {
     queryType: QueryType;
     scope: QueryScope;
     operation: OperationType;
 }
+export interface OpraMetadataQuery extends BaseOpraQuery {
+    queryType: 'metadata';
+    scope: QueryScope;
+    operation: 'read';
+    resourcePath: string[];
+}
 export interface OpraCreateQuery extends BaseOpraQuery {
     queryType: 'create';
     scope: 'collection';
@@ -19,7 +25,7 @@ export interface OpraCreateQuery extends BaseOpraQuery {
     omit?: string[];
     include?: string[];
 }
-export interface OpraGetQuery extends BaseOpraQuery {
+export interface OpraGetEntityQuery extends BaseOpraQuery {
     queryType: 'get';
     scope: 'instance';
     operation: 'read';
@@ -86,7 +92,7 @@ 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'>;
@@ -94,7 +100,8 @@ export declare type DeleteQueryOptions = StrictOmit<OpraDeleteQuery, 'queryType'
 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 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;
@@ -103,7 +110,7 @@ export declare namespace OpraQuery {
     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 isReadQuery(q: any): q is OpraGetEntityQuery;
     function isDeleteQuery(q: any): q is OpraDeleteQuery;
 }
 export {};

package/esm/interfaces/query.interface.js

@@ -21,7 +21,24 @@ export var OpraQuery;
         return out;
     }
     OpraQuery.forCreate = forCreate;
-    function forGet(resource, key, options) {
+    function forGetMetadata(resourcePath, options) {
+        // if (options?.pick)
+        //   options.pick = normalizePick(resource, options.pick);
+        // if (options?.omit)
+        //   options.omit = normalizePick(resource, options.omit);
+        // if (options?.include)
+        //   options.include = normalizePick(resource, options.include);
+        const out = {
+            queryType: 'metadata',
+            scope: 'instance',
+            resourcePath,
+            operation: 'read',
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    OpraQuery.forGetMetadata = forGetMetadata;
+    function forGetEntity(resource, key, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
         if (options?.omit)
@@ -39,7 +56,7 @@ export var OpraQuery;
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    OpraQuery.forGet = forGet;
+    OpraQuery.forGetEntity = forGetEntity;
     function forSearch(resource, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);

package/esm/services/json-data-service.d.ts

@@ -1,9 +1,68 @@
-import { DataService } from './data-service.js';
-export interface JsonDataServiceAgs {
-    data: any[];
-    primaryKey: string | string[];
+import { Maybe } from 'ts-gems';
+import { Expression } from '@opra/url';
+import { QueryContext } from '../implementation/query-context.js';
+import { OpraQuery } from '../interfaces/query.interface.js';
+import { EntityInput, EntityOutput, QueryType } from '../types.js';
+import { IEntityService } from './entity-resource-controller.js';
+export interface JsonDataServiceAgs<T> {
+    resourceName: string;
+    data: T[];
+    primaryKey: string;
 }
-export declare class JsonDataService extends DataService {
-    data: any[];
-    constructor(args: JsonDataServiceAgs);
+export declare namespace JsonDataService {
+    type GetOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type SearchOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        limit?: number;
+        skip?: number;
+        distinct?: boolean;
+        total?: boolean;
+        filter?: string | Expression | {};
+    };
+    type CreateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type UpdateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type UpdateManyOptions = {
+        filter?: string | Expression | {};
+    };
+    type DeleteManyOptions = {
+        filter?: string | Expression | {};
+    };
+}
+export declare class JsonDataService<T, TOutput = EntityOutput<T>> implements IEntityService {
+    resourceName: string;
+    data: T[];
+    primaryKey: string;
+    constructor(args: JsonDataServiceAgs<T>);
+    processRequest(ctx: QueryContext): any;
+    get(keyValue: any, options?: JsonDataService.GetOptions): Maybe<TOutput>;
+    count(options?: JsonDataService.SearchOptions): Maybe<number>;
+    search(options?: JsonDataService.SearchOptions): Maybe<TOutput>[];
+    create(data: EntityInput<T>, options?: JsonDataService.CreateOptions): TOutput;
+    update(keyValue: any, data: EntityInput<T>, options?: JsonDataService.UpdateOptions): Maybe<TOutput>;
+    updateMany(data: EntityInput<T>, options?: JsonDataService.UpdateManyOptions): number;
+    delete(keyValue: any): boolean;
+    deleteMany(options?: JsonDataService.DeleteManyOptions): number;
+    static filterProperties(obj: any, pick: string[] | undefined, omit: string[] | undefined, include: string[] | undefined): any;
+    static prepare(query: OpraQuery): {
+        method: QueryType;
+        options: any;
+        keyValue?: any;
+        values?: any;
+        args: any[];
+    };
+    static convertFilter(str: string | Expression | undefined | {}): any;
 }

package/esm/services/json-data-service.js

@@ -1,10 +1,241 @@
+import _ from 'lodash';
 import ruleJudgment from 'rule-judgment';
-import { DataService } from './data-service.js';
+import { $parse, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, Expression, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/url';
+import { ResourceConflictError } from '../exception/index.js';
 // Fix invalid importing (with ESM) of rule-judgment package
-const toArrayFilter = typeof ruleJudgment === 'function' ? ruleJudgment : ruleJudgment.default;
-export class JsonDataService extends DataService {
+const createFilterFn = typeof ruleJudgment === 'function'
+    ? ruleJudgment
+    : ruleJudgment.default;
+export class JsonDataService {
+    resourceName;
     data;
+    primaryKey;
     constructor(args) {
-        super();
+        this.resourceName = args.resourceName;
+        this.data = args.data;
+        this.primaryKey = args.primaryKey;
+    }
+    processRequest(ctx) {
+        const prepared = JsonDataService.prepare(ctx.query);
+        const fn = this[prepared.method];
+        if (!fn)
+            throw new TypeError(`Unimplemented method (${prepared.method})`);
+        return fn.apply(this, prepared.args);
+    }
+    get(keyValue, options) {
+        const primaryKey = this.primaryKey;
+        let v = this.data.find(x => '' + x[primaryKey] === '' + keyValue);
+        v = JsonDataService.filterProperties(v, options?.pick, options?.omit, options?.include);
+        return v;
+    }
+    count(options) {
+        return this.search(options).length;
+    }
+    search(options) {
+        let out;
+        if (options?.filter) {
+            const filter = JsonDataService.convertFilter(options.filter);
+            const filterFn = createFilterFn(filter);
+            out = this.data.filter(filterFn);
+        }
+        else
+            out = this.data;
+        return out.map(v => JsonDataService.filterProperties(v, options?.pick, options?.omit, options?.include));
+    }
+    create(data, options) {
+        if (this.get(data[this.primaryKey]))
+            throw new ResourceConflictError(this.resourceName, this.primaryKey);
+        this.data.push(data);
+        return JsonDataService.filterProperties(data, options?.pick, options?.omit, options?.include);
+    }
+    update(keyValue, data, options) {
+        const primaryKey = this.primaryKey;
+        const i = this.data.findIndex(x => '' + x[primaryKey] === '' + keyValue);
+        if (i >= 0) {
+            data = Object.assign(this.data[i], data);
+            return JsonDataService.filterProperties(data, options?.pick, options?.omit, options?.include);
+        }
+    }
+    updateMany(data, options) {
+        const items = this.search({ filter: options?.filter });
+        for (let i = 0; i < items.length; i++) {
+            Object.assign(items[i], data);
+        }
+        return items.length;
+    }
+    delete(keyValue) {
+        const primaryKey = this.primaryKey;
+        const i = this.data.findIndex(x => '' + x[primaryKey] === '' + keyValue);
+        if (i >= 0) {
+            this.data = this.data.slice(i, 1);
+            return true;
+        }
+        return false;
+    }
+    deleteMany(options) {
+        const items = this.search({ filter: options?.filter });
+        this.data = this.data.filter(x => !items.includes(x));
+        return items.length;
+    }
+    static filterProperties(obj, pick, omit, include) {
+        if (!obj)
+            return;
+        return obj;
+    }
+    static prepare(query) {
+        switch (query.queryType) {
+            case 'create': {
+                const options = _.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                }, _.isNil);
+                const { data } = query;
+                return {
+                    method: query.queryType,
+                    values: data,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'get': {
+                const options = _.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                }, _.isNil);
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+            case 'search': {
+                const options = _.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                    sort: query.sort?.length ? query.sort : undefined,
+                    limit: query.limit,
+                    offset: query.skip,
+                    distinct: query.distinct,
+                    total: query.count,
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, _.isNil);
+                return {
+                    method: query.queryType,
+                    options,
+                    args: [options]
+                };
+            }
+            case 'update': {
+                const options = _.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                }, _.isNil);
+                const { data } = query;
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue: query.keyValue,
+                    values: data,
+                    options,
+                    args: [keyValue, data, options]
+                };
+            }
+            case 'updateMany': {
+                const options = _.omitBy({
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, _.isNil);
+                const { data } = query;
+                return {
+                    method: query.queryType,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'delete': {
+                const options = {};
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+            case 'deleteMany': {
+                const options = _.omitBy({
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, _.isNil);
+                return {
+                    method: query.queryType,
+                    options,
+                    args: [options]
+                };
+            }
+            default:
+                throw new Error(`Unimplemented query type "${query.queryType}"`);
+        }
+    }
+    static convertFilter(str) {
+        const ast = typeof str === 'string'
+            ? $parse(str)
+            : str;
+        if (!ast || !(ast instanceof Expression))
+            return ast;
+        if (ast instanceof ComparisonExpression) {
+            const left = JsonDataService.convertFilter(ast.left);
+            const right = JsonDataService.convertFilter(ast.right);
+            switch (ast.op) {
+                case '=':
+                    return { $eq: { [left]: right } };
+                case '!=':
+                    return { $ne: { [left]: right } };
+                case '>':
+                    return { $gt: { [left]: right } };
+                case '>=':
+                    return { $gte: { [left]: right } };
+                case '<':
+                    return { $lt: { [left]: right } };
+                case '<=':
+                    return { $lte: { [left]: right } };
+                case 'in':
+                    return { $in: { [left]: right } };
+                case '!in':
+                    return { $nin: { [left]: right } };
+                default:
+                    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+            }
+        }
+        if (ast instanceof QualifiedIdentifier) {
+            return ast.value;
+        }
+        if (ast instanceof NumberLiteral ||
+            ast instanceof StringLiteral ||
+            ast instanceof BooleanLiteral ||
+            ast instanceof NullLiteral ||
+            ast instanceof DateLiteral ||
+            ast instanceof TimeLiteral) {
+            return ast.value;
+        }
+        if (ast instanceof ArrayExpression) {
+            return ast.items.map(JsonDataService.convertFilter);
+        }
+        if (ast instanceof LogicalExpression) {
+            if (ast.op === 'or')
+                return { $or: ast.items.map(JsonDataService.convertFilter) };
+            return { $and: ast.items.map(JsonDataService.convertFilter) };
+        }
+        if (ast instanceof ArrayExpression) {
+            return ast.items.map(JsonDataService.convertFilter);
+        }
+        if (ast instanceof ParenthesesExpression) {
+            return JsonDataService.convertFilter(ast.expression);
+        }
+        throw new Error(`${ast.type} is not implemented yet`);
     }
 }

package/esm/types.d.ts

@@ -1,9 +1,18 @@
 import type { Type } from 'ts-gems';
+import { Builtin, DeepPickWritable } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
 export declare type Thunk<T> = T | (() => T);
 export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
 export declare type TypeThunk<T = any> = Thunk<Type<T>>;
 export declare type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
 export declare type QueryScope = 'collection' | 'instance' | 'property';
-export declare type QueryType = 'create' | 'get' | 'update' | 'patch' | 'delete' | 'execute' | 'search' | 'updateMany' | 'patchMany' | 'deleteMany';
+export declare type QueryType = OpraSchema.EntityResolverType | 'metadata' | 'execute';
 export declare type OperationType = 'create' | 'read' | 'update' | 'patch' | 'delete' | 'execute';
 export declare type KeyValue = string | number | boolean | object;
+export declare type EntityInput<T> = DeepNullableIfPartial<DeepPickWritable<T>>;
+export declare type EntityOutput<T> = DeepNullableIfPartial<T>;
+export declare type DeepNullableIfPartial<T> = _DeepNullableIfPartial<T>;
+declare type _DeepNullableIfPartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullableIfPartial<U>> : T extends (infer U)[] ? DeepNullableIfPartial<U>[] : {
+    [P in keyof T]?: DeepNullableIfPartial<Exclude<T[P], undefined>> | null;
+};
+export {};

package/esm/utils/create-i18n.js

@@ -4,8 +4,8 @@ import { getCallerFile } from './get-caller-file.util.js';
 export async function createI18n(options) {
     const opts = {
         ...options,
-        resourceDirs: undefined
     };
+    delete opts.resourceDirs;
     const instance = I18n.createInstance(opts);
     await instance.init();
     await instance.loadResourceDir(path.resolve(getCallerFile(), '../../../i18n'));

package/esm/utils/get-caller-file.util.d.ts

@@ -1 +1 @@
-export declare function getCallerFile(position?: number): any;
+export declare function getCallerFile(position?: number): string;

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

@@ -1,3 +1,4 @@
+const PATH_PATTERN = /^(?:file:\/\/)?(.+)$/;
 export function getCallerFile(position = 1) {
     if (position >= Error.stackTraceLimit) {
         throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
@@ -10,6 +11,10 @@ export function getCallerFile(position = 1) {
     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;
+        const s = stack[position] ?
+            stack[position].getFileName() : undefined;
+        const m = s ? PATH_PATTERN.exec(s) : undefined;
+        return m ? m[1] : '';
     }
+    return '';
 }

package/i18n/en/error.json

@@ -4,9 +4,12 @@
   "FORBIDDEN": "You are not authorized to perform this action",
   "INTERNAL_SERVER_ERROR": "Internal server error",
   "METHOD_NOT_ALLOWED": "Method Not Allowed",
+  "NOT_ACCEPTABLE": "Not Acceptable",
   "NOT_FOUND": "Not found",
   "UNAUTHORIZED": "You have not been authenticated to perform this action",
   "UNPROCESSABLE_ENTITY": "Unprocessable entity",
 
+  "RESOLVER_FORBIDDEN": "The resource endpoint does not accept '{{queryType}}' operations",
+  "RESOURCE_NOT_FOUND": "The resource '{{resource}}' could not be found",
   "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,13 +27,14 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/i18n": "^0.0.12",
-    "@opra/optionals": "^0.0.12",
-    "@opra/schema": "^0.0.12",
-    "@opra/url": "^0.0.12",
+    "@opra/i18n": "^0.0.13",
+    "@opra/optionals": "^0.0.13",
+    "@opra/schema": "^0.0.13",
+    "@opra/url": "^0.0.13",
     "lodash": "^4.17.21",
     "putil-isplainobject": "^1.1.4",
     "putil-varhelpers": "^1.6.4",
+    "putil-merge": "^3.8.0",
     "rule-judgment": "^1.1.5",
     "strict-typed-events": "^2.2.0",
     "ts-gems": "^2.2.0"
@@ -43,8 +44,6 @@
     "express": "^4.18.1"
   },
   "type": "module",
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "exports": {
     ".": {

package/esm/interfaces/opra-schema.metadata.d.ts

@@ -1,14 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { TypeThunkAsync } from '../types.js';
-export declare type EntityResourceMetadata = StrictOmit<OpraSchema.EntityResource, 'type' | 'name'> & {
-    type: TypeThunkAsync | string;
-    name?: string;
-};
-export declare type ResourceReadOperationMetadata = StrictOmit<OpraSchema.ResourceReadOperation, 'handler'>;
-export declare type ResourceSearchOperationMetadata = StrictOmit<OpraSchema.ResourceSearchOperation, 'handler'>;
-export declare type ResourceCreateOperationMetadata = StrictOmit<OpraSchema.ResourceCreateOperation, 'handler'>;
-export declare type ResourceUpdateOperationMetadata = StrictOmit<OpraSchema.ResourceUpdateOperation, 'handler'>;
-export declare type ResourcePatchOperationMetadata = StrictOmit<OpraSchema.ResourcePatchOperation, 'handler'>;
-export declare type ResourceDeleteOperationMetadata = StrictOmit<OpraSchema.ResourceDeleteOperation, 'handler'>;
-export declare type ResourceExecuteOperationMetadata = StrictOmit<OpraSchema.ResourceExecuteOperation, 'handler'>;