@opra/core 0.0.12 → 0.0.13

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

@@ -1,7 +1,7 @@
 import { OpraURL } from '@opra/url';
 import { OpraVersion } from '../../constants.js';
 import { HttpHeaders, HttpStatus } from '../../enums/index.js';
-import { ApiException, BadRequestError, InternalServerError, MethodNotAllowedError, NotFoundError, } from '../../exception/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';
@@ -30,7 +30,7 @@ export class OpraHttpAdapter extends OpraAdapter {
         const query = this.buildQuery(url, method, body);
         if (!query)
             throw new MethodNotAllowedError({
-                message: `Method "${method}" is not allowed by target resource`
+                message: `Method "${method}" is not allowed by target endpoint`
             });
         return new QueryContext({
             service: this.service,
@@ -41,119 +41,146 @@ export class OpraHttpAdapter extends OpraAdapter {
             continueOnError: query.operation === 'read'
         });
     }
+    buildMetadataQuery(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 !== '$metadata') {
+                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.forGetMetadata(resourcePath, opts);
+    }
     buildQuery(url, method, body) {
         let container = this.service;
         try {
-            let pathIndex = 0;
             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 === '$metadata') {
+                    if (method !== 'GET')
+                        return;
+                    return this.buildMetadataQuery(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 ContainerResourceHandler) {
                     container = resource;
+                    continue;
                 }
-                else {
-                    method = method.toUpperCase();
-                    if (resource instanceof EntityResourceHandler) {
-                        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.forGet(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 properties.`);
-                                        p = url.path.get(pathIndex++);
-                                        path += '.' + p.resource;
-                                        const prop = dataType.properties?.[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;
+                method = method.toUpperCase();
+                if (resource instanceof EntityResourceHandler) {
+                    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 properties.`);
+                                    p = url.path.get(pathIndex++);
+                                    path += '.' + p.resource;
+                                    const prop = dataType.properties?.[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;
+                            break;
+                        }
+                        case 'DELETE': {
+                            if (scope === 'collection') {
+                                query = OpraQuery.forDeleteMany(resource, {
+                                    filter: url.searchParams.get('$filter'),
+                                });
                             }
-                            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;
+                            else {
+                                query = OpraQuery.forDelete(resource, p.key);
                             }
-                            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;
+                            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;
                     }
+                    return query;
                 }
             }
             throw new InternalServerError();
         }
         catch (e) {
-            if (e instanceof ApiException)
-                throw e;
-            throw new BadRequestError({ message: e.message });
+            throw BadRequestError.wrap(e);
         }
     }
     async sendResponse(executionContext, queryContexts) {

package/esm/implementation/data-type/complex-type.d.ts

@@ -13,6 +13,7 @@ export declare class ComplexType extends DataType {
     get abstract(): boolean;
     get additionalProperties(): boolean | string | Pick<OpraSchema.Property, 'type' | 'format' | 'isArray' | 'enum'> | undefined;
     getProperty(name: string): OpraSchema.Property;
+    getMetadata(): OpraSchema.ComplexTypeMetadata;
     toString(): string;
     [nodeInspectCustom](): string;
 }

package/esm/implementation/data-type/complex-type.js

@@ -1,3 +1,4 @@
+import merge from 'putil-merge';
 import { Responsive } from '../../utils/responsive-object.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
 import { DataType } from './data-type.js';
@@ -25,6 +26,18 @@ export class ComplexType extends DataType {
             throw new Error(`"${this.name}" type has no property named "${name}"`);
         return t;
     }
+    getMetadata() {
+        const out = super.getMetadata();
+        if (this.additionalProperties)
+            out.additionalProperties = this.additionalProperties;
+        if (this.ownProperties) {
+            out.properties = {};
+            for (const [k, prop] of Object.entries(this.ownProperties)) {
+                out.properties[k] = merge({}, prop, { deep: true });
+            }
+        }
+        return out;
+    }
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
     }

package/esm/implementation/data-type/data-type.d.ts

@@ -10,6 +10,8 @@ export declare abstract class DataType {
     get kind(): OpraSchema.DataTypeKind;
     get name(): string;
     get description(): string | undefined;
+    get abstract(): boolean;
     get ctor(): Type;
     is(typeName: string): boolean;
+    getMetadata(): any;
 }

package/esm/implementation/data-type/data-type.js

@@ -22,10 +22,22 @@ export class DataType {
     get description() {
         return this._args.description;
     }
+    get abstract() {
+        return !!this._args.abstract;
+    }
     get ctor() {
         return this._args.ctor;
     }
     is(typeName) {
         return this.name === typeName || !!(this.base && this.base.is(typeName));
     }
+    getMetadata() {
+        return {
+            kind: this.kind,
+            base: this.base?.name,
+            abstract: this.abstract ? true : undefined,
+            name: this.name,
+            description: this.description,
+        };
+    }
 }

package/esm/implementation/data-type/entity-type.js

@@ -1,4 +1,4 @@
-import { SqbConnect } from '@opra/optionals';
+import * as Optionals from '@opra/optionals';
 import { ComplexType } from './complex-type.js';
 export class EntityType extends ComplexType {
     constructor(owner, args, base) {
@@ -7,8 +7,8 @@ export class EntityType extends ComplexType {
         }, base);
         this._args.kind = 'EntityType';
         // Try to determine primary key info from SQB
-        if (args.ctor) {
-            const sqbEntity = SqbConnect.EntityMetadata.get(args.ctor);
+        if (Optionals.SqbConnect && args.ctor) {
+            const sqbEntity = Optionals.SqbConnect.EntityMetadata.get(args.ctor);
             if (sqbEntity?.indexes) {
                 const primaryIndex = sqbEntity.indexes.find(x => x.primary);
                 if (primaryIndex) {

package/esm/implementation/opra-document.js

@@ -70,7 +70,8 @@ export class OpraDocument {
             recursiveSet.add(schema.name);
             let baseType;
             if (schema.base) {
-                if (!this.types[schema.base]) {
+                baseType = this.types[schema.base];
+                if (!baseType) {
                     const baseSchema = dataTypes.find(dt => dt.name.toLowerCase() === schema.base?.toLowerCase()) ||
                         internalDataTypes.get(schema.base.toLowerCase());
                     if (!baseSchema)
@@ -102,10 +103,5 @@ export class OpraDocument {
             return dataType;
         };
         dataTypes.forEach(dataType => processDataType(dataType));
-        // Sort data types by name
-        const newTypes = Responsive();
-        Object.keys(this.types).sort()
-            .forEach(name => newTypes[name] = this.types[name]);
-        this._types = newTypes;
     }
 }

package/esm/implementation/opra-service.d.ts

@@ -14,6 +14,7 @@ export declare class OpraService extends OpraDocument implements IResourceContai
     get servers(): OpraSchema.ServerInfo[] | undefined;
     getResource<T extends ResourceHandler>(name: string): T;
     getEntityResource(name: string): EntityResourceHandler;
+    getMetadata(): OpraSchema.ServiceMetadata;
     protected _addResources(resources: OpraSchema.Resource[]): void;
     static create(args: SchemaGenerator.GenerateServiceArgs): Promise<OpraService>;
 }

package/esm/implementation/opra-service.js

@@ -1,4 +1,7 @@
+import merge from 'putil-merge';
 import { OpraSchema } from '@opra/schema';
+import { OpraVersion } from '../constants.js';
+import { internalDataTypes } from '../utils/internal-data-types.js';
 import { Responsive } from '../utils/responsive-object.js';
 import { EntityType } from './data-type/entity-type.js';
 import { OpraDocument } from './opra-document.js';
@@ -29,6 +32,24 @@ export class OpraService extends OpraDocument {
             throw new Error(`"${name}" is not an EntityResource`);
         return t;
     }
+    getMetadata() {
+        const out = {
+            '@opra:metadata': '/$metadata',
+            version: OpraVersion,
+            servers: this.servers?.map(x => merge({}, x, { deep: true })),
+            info: merge({}, this.info, { deep: true }),
+            types: [],
+            resources: []
+        };
+        for (const [k, dataType] of Object.entries(this.types)) {
+            if (!internalDataTypes.has(k))
+                out.types.push(dataType.getMetadata());
+        }
+        for (const resource of Object.values(this.resources)) {
+            out.resources.push(resource.getMetadata());
+        }
+        return out;
+    }
     _addResources(resources) {
         for (const r of resources) {
             if (OpraSchema.isEntityResource(r)) {

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

@@ -14,5 +14,5 @@ export declare class EntityResourceHandler extends ResourceHandler {
     readonly dataType: EntityType;
     constructor(args: EntityResourceControllerArgs);
     execute(ctx: QueryContext): Promise<void>;
-    _executeFn(ctx: QueryContext, fnName: string): Promise<any>;
+    _executeFn(ctx: QueryContext, queryType: string): Promise<any>;
 }

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

@@ -1,9 +1,10 @@
 import _ from 'lodash';
+import { translate } from '@opra/i18n';
+import { ForbiddenError, ResourceNotFoundError } from '../../exception/index.js';
 import { OpraQuery } from '../../interfaces/query.interface.js';
+import { ComplexType } from '../data-type/complex-type.js';
 import { EntityType } from '../data-type/entity-type.js';
 import { ResourceHandler } from './resource-handler.js';
-var isSearchQuery = OpraQuery.isSearchQuery;
-import { UnprocessableEntityError } from '../../exception/index.js';
 export class EntityResourceHandler extends ResourceHandler {
     service;
     dataType;
@@ -20,7 +21,7 @@ export class EntityResourceHandler extends ResourceHandler {
     }
     async execute(ctx) {
         const { query } = ctx;
-        if (isSearchQuery(query)) {
+        if (OpraQuery.isSearchQuery(query)) {
             const promises = [];
             let search;
             let count;
@@ -39,12 +40,28 @@ export class EntityResourceHandler extends ResourceHandler {
         }
         ctx.response.value = await this._executeFn(ctx, query.queryType);
     }
-    async _executeFn(ctx, fnName) {
-        const fn = this._args[fnName];
-        let result = typeof fn === 'function' ? (await fn(ctx)) : undefined;
-        switch (fnName) {
+    async _executeFn(ctx, queryType) {
+        const resolverInfo = this._args.resolvers?.[queryType];
+        if (resolverInfo.forbidden || !resolverInfo.handler)
+            throw new ForbiddenError({
+                message: translate('RESOLVER_FORBIDDEN', { queryType }),
+                severity: 'error',
+                code: 'RESOLVER_FORBIDDEN'
+            });
+        let result = await resolverInfo.handler(ctx);
+        switch (queryType) {
             case 'search':
-                return { items: Array.isArray(result) ? result : (ctx.response.value ? [result] : []) };
+                return {
+                    '@opra:metadata': '/$metadata/types/' + this.dataType.name,
+                    items: Array.isArray(result) ? result : (ctx.response.value ? [result] : [])
+                };
+            case 'get':
+            case 'update':
+                if (!result) {
+                    const query = ctx.query;
+                    throw new ResourceNotFoundError(this.name, query.keyValue);
+                }
+                break;
             case 'count':
                 return { count: result || 0 };
             case 'delete':
@@ -59,17 +76,23 @@ export class EntityResourceHandler extends ResourceHandler {
                     affectedRecords = result.affectedRows || result.affectedRecords;
                 return { affectedRecords };
         }
-        result = Array.isArray(result) ? result[0] : result;
         if (!result)
-            throw new UnprocessableEntityError();
+            return;
+        result = Array.isArray(result) ? result[0] : result;
+        let dataType = this.dataType;
         if (ctx.resultPath) {
             const pathArray = ctx.resultPath.split('.');
             for (const property of pathArray) {
+                const prop = dataType instanceof ComplexType ? dataType.properties?.[property] : undefined;
+                dataType = prop && prop.type ? this.service.types[prop.type || 'string'] : undefined;
                 result = result && typeof result === 'object' && result[property];
             }
         }
-        if (fnName === 'create')
+        if (queryType === 'create')
             ctx.response.status = 201;
-        return result;
+        return {
+            '@opra:metadata': dataType ? '/$metadata/types/' + dataType.name : '__unknown__',
+            ...result
+        };
     }
 }

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

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

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

@@ -1,6 +1,8 @@
+import merge from 'putil-merge';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
 export class ResourceHandler {
     _args;
+    path;
     constructor(args) {
         this._args = args;
     }
@@ -20,6 +22,17 @@ export class ResourceHandler {
             await fn(ctx);
         }
     }
+    getMetadata() {
+        return merge({}, {
+            ...this._args,
+            instance: undefined,
+        }, {
+            deep: true,
+            filter: (source, key) => {
+                return (key !== 'instance' && typeof source[key] !== 'function' && source[key] != null);
+            }
+        });
+    }
     [nodeInspectCustom]() {
         return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
             ` ${colorFgMagenta + this.name + colorReset}]`;

package/esm/implementation/schema-generator.js

@@ -1,9 +1,8 @@
 import { isPromise } from 'util/types';
 import { DATATYPE_METADATA, DATATYPE_PROPERTIES, OpraSchema } from '@opra/schema';
-import { RESOURCE_METADATA } from '../constants.js';
+import { RESOLVER_METADATA, 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 = {};
@@ -55,7 +54,7 @@ export class SchemaGenerator {
             }
             return this.addDataType(schema);
         }
-        if (!isDataType(thunk))
+        if (!OpraSchema.isDataType(thunk))
             throw new TypeError(`Invalid data type schema`);
         // Check if datatype previously added
         const currentSchema = this._dataTypes[thunk.name];
@@ -89,16 +88,25 @@ export class SchemaGenerator {
                 ...metadata,
                 type,
                 name,
-                instance
+                instance,
+                resolvers: {}
             };
             if (OpraSchema.isEntityResource(resourceSchema)) {
                 for (const methodName of entityMethods) {
-                    let fn = instance['pre_' + methodName];
-                    if (typeof fn === 'function')
-                        resourceSchema['pre_' + methodName] = fn.bind(instance);
-                    fn = instance[methodName];
-                    if (typeof fn === 'function')
-                        resourceSchema[methodName] = fn.bind(instance);
+                    let fn = instance[methodName];
+                    if (typeof fn === 'function') {
+                        const info = resourceSchema.resolvers[methodName] = {
+                            ...Reflect.getMetadata(RESOLVER_METADATA, proto, methodName)
+                        };
+                        if (!info.forbidden) {
+                            info.handler = fn.bind(instance);
+                            fn = instance['pre_' + methodName];
+                            if (typeof fn === 'function')
+                                resourceSchema['pre_' + methodName] = fn.bind(instance);
+                        }
+                    }
+                    else
+                        resourceSchema.resolvers[methodName] = { forbidden: true };
                 }
             }
         }
@@ -145,8 +153,21 @@ export class SchemaGenerator {
                 await generator.addResource(resource);
             }
         }
-        const types = Object.keys(generator._dataTypes).sort()
-            .map(name => generator._dataTypes[name]);
+        const types = Object.keys(generator._dataTypes)
+            .map(name => generator._dataTypes[name])
+            .sort((a, b) => {
+            if (a.kind !== b.kind) {
+                if (a.kind === 'SimpleType')
+                    return -1;
+                if (b.kind === 'SimpleType')
+                    return 1;
+                if (a.kind === 'ComplexType')
+                    return -1;
+                if (b.kind === 'ComplexType')
+                    return 1;
+            }
+            return (a.name < b.name ? -1 : 1);
+        });
         const resources = Object.keys(generator._resources).sort()
             .map(name => generator._resources[name]);
         return {

package/esm/index.d.ts

@@ -3,7 +3,7 @@ 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 './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';

package/esm/index.js

@@ -3,7 +3,7 @@ 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 './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';

package/esm/interfaces/metadata/api-resolver.metadata.d.ts

@@ -0,0 +1,3 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+export declare type ApiResolverMetadata = StrictOmit<OpraSchema.ResolverInfo, 'handler'>;