@opra/core 0.23.1 → 0.24.0

package/esm/adapter/http/request-handlers/entity-request-handler.js

@@ -2,7 +2,7 @@ import bodyParser from 'body-parser';
 import { toBoolean, toInt } from 'putil-varhelpers';
 import * as valgen from 'valgen';
 import { BadRequestError, Collection, HttpHeaderCodes, HttpStatusCodes, InternalServerError, MethodNotAllowedError, OpraException, ResourceNotFoundError, Singleton, translate, } from '@opra/common';
-import { OperationContext } from '../../operation-context.js';
+import { EndpointContext } from '../../endpoint-context.js';
 import { RequestHost } from '../../request.host.js';
 import { ResponseHost } from '../../response.host.js';
 import { parseArrayParam } from '../helpers/query-parsers.js';
@@ -23,9 +23,8 @@ export class EntityRequestHandler extends RequestHandlerBase {
         if (!request)
             return;
         const response = new ResponseHost({ http: outgoing });
-        const context = OperationContext.from(executionContext, request, response);
-        // Execute operation
-        await this.executeOperation(context);
+        const context = EndpointContext.from(executionContext, request, response);
+        await this.callEndpoint(context);
         if (response.errors.length) {
             context.errors.push(...response.errors);
             return;
@@ -48,7 +47,15 @@ export class EntityRequestHandler extends RequestHandlerBase {
     }
     async parseRequest(incoming) {
         const p = incoming.parsedUrl.path[0];
-        const resource = this.adapter.api.getResource(p.resource);
+        const resource = this.adapter.api.getResource(p.resource, true);
+        if (!resource)
+            throw new BadRequestError({
+                message: translate('error:SOURCE_NOT_FOUND,', 'Resource not found'),
+                code: 'SOURCE_NOT_FOUND',
+                details: {
+                    path: incoming.parsedUrl.address
+                }
+            });
         try {
             if (resource instanceof Collection)
                 return await this.parseCollectionRequest(resource, incoming);
@@ -68,18 +75,18 @@ export class EntityRequestHandler extends RequestHandlerBase {
             throw new BadRequestError(e);
         }
     }
-    async executeOperation(context) {
+    async callEndpoint(context) {
         const request = context.request;
         const { response } = context;
         const resource = request.resource;
-        // Call operation handler method
+        // Call endpoint handler method
         let value;
         try {
-            value = await request.controller[request.operation].call(request.controller, context);
+            value = await request.controller[request.endpoint].call(request.controller, context);
             if (value == null)
                 value = response.value;
-            const { operation } = request;
-            if (operation === 'delete' || operation === 'deleteMany' || operation === 'updateMany') {
+            const { endpoint } = request;
+            if (endpoint === 'delete' || endpoint === 'deleteMany' || endpoint === 'updateMany') {
                 let affected = 0;
                 if (typeof value === 'number')
                     affected = value;
@@ -87,15 +94,15 @@ export class EntityRequestHandler extends RequestHandlerBase {
                     affected = value ? 1 : 0;
                 if (typeof value === 'object')
                     affected = value.affected || value.affectedRows ||
-                        (operation === 'updateMany' ? value.updated : value.deleted);
+                        (endpoint === 'updateMany' ? value.updated : value.deleted);
                 response.value = affected;
             }
             else {
-                // "get" and "update" operations must return the entity instance, otherwise it means resource not found
-                if (value == null && (request.operation === 'get' || request.operation === 'update'))
+                // "get" and "update" endpoints must return the entity instance, otherwise it means resource not found
+                if (value == null && (request.endpoint === 'get' || request.endpoint === 'update'))
                     throw new ResourceNotFoundError(resource.name, request.key);
-                // "findMany" operation should return array of entity instances
-                if (request.operation === 'findMany')
+                // "findMany" endpoint should return array of entity instances
+                if (request.endpoint === 'findMany')
                     value = value == null ? [] : Array.isArray(value) ? value : [value];
                 else
                     value = value == null ? {} : Array.isArray(value) ? value[0] : value;
@@ -111,33 +118,40 @@ export class EntityRequestHandler extends RequestHandlerBase {
         const resource = request.resource;
         const outgoing = response.switchToHttp();
         let responseObject;
-        if (request.operation === 'delete' || request.operation === 'deleteMany' || request.operation === 'updateMany') {
+        if (request.endpoint === 'delete' || request.endpoint === 'deleteMany') {
+            responseObject = {
+                resource: resource.name,
+                operation: 'delete',
+                affected: response.value
+            };
+        }
+        else if (request.endpoint === 'updateMany') {
             responseObject = {
                 resource: resource.name,
-                operation: request.operation,
+                operation: 'update',
                 affected: response.value
             };
         }
         else {
             if (!response.value)
-                throw new InternalServerError(`"${request.operation}" operation should return value`);
-            const encode = resource.getEncoder(request.operation);
+                throw new InternalServerError(`"${request.endpoint}" endpoint should return value`);
+            const encode = resource.getEncoder(request.endpoint);
             const data = encode(response.value, { coerce: true });
-            if (request.operation === 'create')
+            if (request.endpoint === 'create')
                 outgoing.statusCode = 201;
             responseObject = {
                 resource: resource.name,
-                operation: request.operation,
+                endpoint: request.endpoint,
                 data
             };
-            if (request.operation === 'create' || request.operation === 'update')
+            if (request.endpoint === 'create' || request.endpoint === 'update')
                 responseObject.affected = 1;
-            if (request.operation === 'findMany' && response.count != null && response.count >= 0)
+            if (request.endpoint === 'findMany' && response.count != null && response.count >= 0)
                 responseObject.totalCount = response.count;
         }
         outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
         const body = this.adapter._i18n.deep(responseObject);
-        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/opra+json; charset=utf-8');
         outgoing.send(JSON.stringify(body));
         outgoing.end();
     }
@@ -151,8 +165,8 @@ export class EntityRequestHandler extends RequestHandlerBase {
         switch (incoming.method) {
             case 'POST': {
                 if (p.key == null) {
-                    const operationMeta = await this.assertOperation(resource, 'create');
-                    const jsonReader = this.getBodyLoader(operationMeta);
+                    const endpointMeta = await this.assertEndpoint(resource, 'create');
+                    const jsonReader = this.getBodyLoader(endpointMeta);
                     const decode = resource.getDecoder('create');
                     let data = await jsonReader(incoming);
                     data = decode(data, { coerce: true });
@@ -160,11 +174,11 @@ export class EntityRequestHandler extends RequestHandlerBase {
                     const omit = parseArrayParam(params.get('$omit'));
                     const include = parseArrayParam(params.get('$include'));
                     return new RequestHost({
-                        controller: operationMeta.controller,
+                        controller: endpointMeta.controller,
                         http: incoming,
                         contentId,
                         resource,
-                        operation: 'create',
+                        endpoint: 'create',
                         data,
                         params: {
                             pick: pick && resource.normalizeFieldPath(pick),
@@ -177,24 +191,24 @@ export class EntityRequestHandler extends RequestHandlerBase {
             }
             case 'DELETE': {
                 if (p.key != null) {
-                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    const endpointMeta = await this.assertEndpoint(resource, 'delete');
                     return new RequestHost({
-                        controller: operationMeta.controller,
+                        controller: endpointMeta.controller,
                         http: incoming,
                         contentId,
                         resource,
-                        operation: 'delete',
+                        endpoint: 'delete',
                         key: resource.parseKeyValue(p.key)
                     });
                 }
-                const operationMeta = await this.assertOperation(resource, 'deleteMany');
+                const endpointMeta = await this.assertEndpoint(resource, 'deleteMany');
                 const filter = resource.normalizeFilter(params.get('$filter'));
                 return new RequestHost({
-                    controller: operationMeta.controller,
+                    controller: endpointMeta.controller,
                     http: incoming,
                     contentId,
                     resource,
-                    operation: 'deleteMany',
+                    endpoint: 'deleteMany',
                     params: {
                         filter
                     }
@@ -205,13 +219,13 @@ export class EntityRequestHandler extends RequestHandlerBase {
                 const omit = parseArrayParam(params.get('$omit'));
                 const include = parseArrayParam(params.get('$include'));
                 if (p.key != null) {
-                    const operationMeta = await this.assertOperation(resource, 'get');
+                    const endpointMeta = await this.assertEndpoint(resource, 'get');
                     return new RequestHost({
-                        controller: operationMeta.controller,
+                        controller: endpointMeta.controller,
                         http: incoming,
                         contentId,
                         resource,
-                        operation: 'get',
+                        endpoint: 'get',
                         key: resource.parseKeyValue(p.key),
                         params: {
                             pick: pick && resource.normalizeFieldPath(pick),
@@ -220,15 +234,15 @@ export class EntityRequestHandler extends RequestHandlerBase {
                         }
                     });
                 }
-                const operationMeta = await this.assertOperation(resource, 'findMany');
+                const endpointMeta = await this.assertEndpoint(resource, 'findMany');
                 const filter = resource.normalizeFilter(params.get('$filter'));
                 const sort = parseArrayParam(params.get('$sort'));
                 return new RequestHost({
-                    controller: operationMeta.controller,
+                    controller: endpointMeta.controller,
                     http: incoming,
                     contentId,
                     resource,
-                    operation: 'findMany',
+                    endpoint: 'findMany',
                     params: {
                         pick: pick && resource.normalizeFieldPath(pick),
                         omit: omit && resource.normalizeFieldPath(omit),
@@ -244,8 +258,8 @@ export class EntityRequestHandler extends RequestHandlerBase {
             }
             case 'PATCH': {
                 if (p.key != null) {
-                    const operationMeta = await this.assertOperation(resource, 'update');
-                    const jsonReader = this.getBodyLoader(operationMeta);
+                    const endpointMeta = await this.assertEndpoint(resource, 'update');
+                    const jsonReader = this.getBodyLoader(endpointMeta);
                     const decode = resource.getDecoder('update');
                     let data = await jsonReader(incoming);
                     data = decode(data, { coerce: true });
@@ -253,11 +267,11 @@ export class EntityRequestHandler extends RequestHandlerBase {
                     const omit = parseArrayParam(params.get('$omit'));
                     const include = parseArrayParam(params.get('$include'));
                     return new RequestHost({
-                        controller: operationMeta.controller,
+                        controller: endpointMeta.controller,
                         http: incoming,
                         contentId,
                         resource,
-                        operation: 'update',
+                        endpoint: 'update',
                         key: resource.parseKeyValue(p.key),
                         data,
                         params: {
@@ -267,18 +281,18 @@ export class EntityRequestHandler extends RequestHandlerBase {
                         }
                     });
                 }
-                const operationMeta = await this.assertOperation(resource, 'updateMany');
-                const jsonReader = this.getBodyLoader(operationMeta);
+                const endpointMeta = await this.assertEndpoint(resource, 'updateMany');
+                const jsonReader = this.getBodyLoader(endpointMeta);
                 const decode = resource.getDecoder('updateMany');
                 let data = await jsonReader(incoming);
                 data = decode(data, { coerce: true });
                 const filter = resource.normalizeFilter(params.get('$filter'));
                 return new RequestHost({
-                    controller: operationMeta.controller,
+                    controller: endpointMeta.controller,
                     http: incoming,
                     contentId,
                     resource,
-                    operation: 'updateMany',
+                    endpoint: 'updateMany',
                     data,
                     params: {
                         filter,
@@ -287,7 +301,7 @@ export class EntityRequestHandler extends RequestHandlerBase {
             }
         }
         throw new MethodNotAllowedError({
-            message: `Collection resources do not accept http "${incoming.method}" method`
+            message: `Collection resource do not accept http "${incoming.method}" method`
         });
     }
     async parseSingletonRequest(resource, incoming) {
@@ -298,8 +312,8 @@ export class EntityRequestHandler extends RequestHandlerBase {
         const params = incoming.parsedUrl.searchParams;
         switch (incoming.method) {
             case 'POST': {
-                const operationMeta = await this.assertOperation(resource, 'create');
-                const jsonReader = this.getBodyLoader(operationMeta);
+                const endpointMeta = await this.assertEndpoint(resource, 'create');
+                const jsonReader = this.getBodyLoader(endpointMeta);
                 const decode = resource.getDecoder('create');
                 let data = await jsonReader(incoming);
                 data = decode(data, { coerce: true });
@@ -307,11 +321,11 @@ export class EntityRequestHandler extends RequestHandlerBase {
                 const omit = parseArrayParam(params.get('$omit'));
                 const include = parseArrayParam(params.get('$include'));
                 return new RequestHost({
-                    controller: operationMeta.controller,
+                    controller: endpointMeta.controller,
                     http: incoming,
                     contentId,
                     resource,
-                    operation: 'create',
+                    endpoint: 'create',
                     data,
                     params: {
                         pick: pick && resource.normalizeFieldPath(pick),
@@ -321,26 +335,26 @@ export class EntityRequestHandler extends RequestHandlerBase {
                 });
             }
             case 'DELETE': {
-                const operationMeta = await this.assertOperation(resource, 'delete');
+                const endpointMeta = await this.assertEndpoint(resource, 'delete');
                 return new RequestHost({
-                    controller: operationMeta.controller,
+                    controller: endpointMeta.controller,
                     http: incoming,
                     contentId,
                     resource,
-                    operation: 'delete',
+                    endpoint: 'delete',
                 });
             }
             case 'GET': {
-                const operationMeta = await this.assertOperation(resource, 'get');
+                const endpointMeta = await this.assertEndpoint(resource, 'get');
                 const pick = parseArrayParam(params.get('$pick'));
                 const omit = parseArrayParam(params.get('$omit'));
                 const include = parseArrayParam(params.get('$include'));
                 return new RequestHost({
-                    controller: operationMeta.controller,
+                    controller: endpointMeta.controller,
                     http: incoming,
                     contentId,
                     resource,
-                    operation: 'get',
+                    endpoint: 'get',
                     params: {
                         pick: pick && resource.normalizeFieldPath(pick),
                         omit: omit && resource.normalizeFieldPath(omit),
@@ -349,8 +363,8 @@ export class EntityRequestHandler extends RequestHandlerBase {
                 });
             }
             case 'PATCH': {
-                const operationMeta = await this.assertOperation(resource, 'update');
-                const jsonReader = this.getBodyLoader(operationMeta);
+                const endpointMeta = await this.assertEndpoint(resource, 'update');
+                const jsonReader = this.getBodyLoader(endpointMeta);
                 const decode = resource.getDecoder('update');
                 let data = await jsonReader(incoming);
                 data = decode(data, { coerce: true });
@@ -358,11 +372,11 @@ export class EntityRequestHandler extends RequestHandlerBase {
                 const omit = parseArrayParam(params.get('$omit'));
                 const include = parseArrayParam(params.get('$include'));
                 return new RequestHost({
-                    controller: operationMeta.controller,
+                    controller: endpointMeta.controller,
                     http: incoming,
                     contentId,
                     resource,
-                    operation: 'update',
+                    endpoint: 'update',
                     data,
                     params: {
                         pick: pick && resource.normalizeFieldPath(pick),
@@ -373,14 +387,14 @@ export class EntityRequestHandler extends RequestHandlerBase {
             }
         }
         throw new MethodNotAllowedError({
-            message: `Singleton resources do not accept http "${incoming.method}" method`
+            message: `Singleton resource do not accept http "${incoming.method}" method`
         });
     }
-    getBodyLoader(operation) {
-        let bodyLoader = this.bodyLoaders.get(operation);
+    getBodyLoader(endpoint) {
+        let bodyLoader = this.bodyLoaders.get(endpoint);
         if (!bodyLoader) {
             const parser = bodyParser.json({
-                limit: operation.input?.maxContentSize,
+                limit: endpoint.input?.maxContentSize,
                 type: 'json'
             });
             bodyLoader = (incoming) => {
@@ -393,7 +407,7 @@ export class EntityRequestHandler extends RequestHandlerBase {
                     parser(incoming, {}, next);
                 });
             };
-            this.bodyLoaders.set(operation, bodyLoader);
+            this.bodyLoaders.set(endpoint, bodyLoader);
         }
         return bodyLoader;
     }

package/esm/adapter/http/request-handlers/request-handler-base.js

@@ -6,16 +6,16 @@ export class RequestHandlerBase {
     constructor(adapter) {
         this.adapter = adapter;
     }
-    async assertOperation(resource, operation) {
+    async assertEndpoint(resource, endpoint) {
         const controller = await this.adapter.getController(resource);
-        const operationMeta = (typeof controller?.[operation] === 'function') && resource.operations[operation];
-        if (operationMeta)
+        const endpointMeta = (typeof controller?.[endpoint] === 'function') && resource.operations[endpoint];
+        if (endpointMeta)
             return {
-                ...operationMeta,
+                ...endpointMeta,
                 controller
             };
         throw new ForbiddenError({
-            message: translate('RESOLVER_FORBIDDEN', { resource: resource.name, operation }, `'{{resource}}' endpoint does not accept '{{operation}}' operations`),
+            message: translate('RESOLVER_FORBIDDEN', { resource: resource.name, endpoint }, `'{{resource}}' endpoint does not accept '{{endpoint}}' operations`),
             severity: 'error',
             code: 'RESOLVER_FORBIDDEN'
         });

package/esm/adapter/http/request-handlers/storage-request-handler.js

@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 import os from 'os';
 import { BadRequestError, HttpStatusCodes, isReadable, OpraException, Storage, uid } from '@opra/common';
-import { OperationContext } from '../../operation-context.js';
+import { EndpointContext } from '../../endpoint-context.js';
 import { RequestHost } from '../../request.host.js';
 import { ResponseHost } from '../../response.host.js';
 import { MultipartIterator } from '../helpers/multipart-helper.js';
@@ -22,9 +22,8 @@ export class StorageRequestHandler extends RequestHandlerBase {
         if (!request)
             return;
         const response = new ResponseHost({ http: outgoing });
-        const context = OperationContext.from(executionContext, request, response);
-        // Execute operation
-        await this.executeOperation(context);
+        const context = EndpointContext.from(executionContext, request, response);
+        await this.callEndpoint(context);
         if (response.errors.length) {
             context.errors.push(...response.errors);
             return;
@@ -40,30 +39,30 @@ export class StorageRequestHandler extends RequestHandlerBase {
                 return;
             switch (incoming.method) {
                 case 'GET': {
-                    const operationMeta = await this.assertOperation(resource, 'get');
+                    const endpointMeta = await this.assertEndpoint(resource, 'get');
                     return new RequestHost({
-                        controller: operationMeta.controller,
+                        controller: endpointMeta.controller,
                         http: incoming,
                         resource,
-                        operation: 'get',
+                        endpoint: 'get',
                         contentId
                     });
                 }
                 case 'DELETE': {
-                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    const endpointMeta = await this.assertEndpoint(resource, 'delete');
                     return new RequestHost({
-                        controller: operationMeta.controller,
+                        controller: endpointMeta.controller,
                         http: incoming,
                         resource,
-                        operation: 'delete',
+                        endpoint: 'delete',
                         contentId
                     });
                 }
                 case 'POST': {
-                    const operationMeta = await this.assertOperation(resource, 'post');
+                    const endpointMeta = await this.assertEndpoint(resource, 'post');
                     await fs.mkdir(this._uploadDir, { recursive: true });
                     const multipartIterator = new MultipartIterator(incoming, {
-                        ...operationMeta,
+                        ...endpointMeta,
                         filename: () => this.adapter.serviceName + '_p' + process.pid +
                             't' + String(Date.now()).substring(8) + 'r' + uid(12)
                     });
@@ -74,10 +73,10 @@ export class StorageRequestHandler extends RequestHandlerBase {
                         await multipartIterator.deleteFiles().catch(() => void 0);
                     });
                     return new RequestHost({
-                        controller: operationMeta.controller,
+                        controller: endpointMeta.controller,
                         http: incoming,
                         resource,
-                        operation: 'post',
+                        endpoint: 'post',
                         contentId,
                         parts: multipartIterator
                     });
@@ -90,13 +89,13 @@ export class StorageRequestHandler extends RequestHandlerBase {
             throw new BadRequestError(e);
         }
     }
-    async executeOperation(context) {
+    async callEndpoint(context) {
         const request = context.request;
         const { response } = context;
-        // Call operation handler method
+        // Call endpoint handler method
         let value;
         try {
-            value = await request.controller[request.operation].call(request.controller, context);
+            value = await request.controller[request.endpoint].call(request.controller, context);
             if (response.value == null)
                 response.value = value;
         }

package/esm/adapter/platform-adapter.host.js

@@ -63,7 +63,7 @@ export class PlatformAdapterHost extends AsyncEventEmitter {
         this._i18n = this._i18n || I18n.defaultInstance;
         if (!this._i18n.isInitialized)
             await this._i18n.init();
-        // Initialize all controllers
+        // Initialize all resources
         for (const resource of this.api.resources.values()) {
             await this.getController(resource);
         }

package/esm/augmentation/resource.augmentation.js

@@ -1,4 +1,4 @@
-import { Collection, METADATA_KEY, Resource, Singleton } from "@opra/common";
+import { Collection, Resource, Singleton, SOURCE_METADATA } from "@opra/common";
 // @ts-ignore
 const oldConstruct = Resource.prototype._construct;
 // @ts-ignore
@@ -10,15 +10,15 @@ Resource.prototype._construct = function (init) {
 };
 Collection.OnInit = Singleton.OnInit = function () {
     return (target, propertyKey) => {
-        const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
-        resourceMetadata.onInit = target[propertyKey];
-        Reflect.defineMetadata(METADATA_KEY, target.constructor, resourceMetadata);
+        const sourceMetadata = (Reflect.getOwnMetadata(SOURCE_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(SOURCE_METADATA, target.constructor, sourceMetadata);
     };
 };
 Collection.OnShutdown = Singleton.OnShutdown = function () {
     return (target, propertyKey) => {
-        const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
-        resourceMetadata.onShutdown = target[propertyKey];
-        Reflect.defineMetadata(METADATA_KEY, target.constructor, resourceMetadata);
+        const sourceMetadata = (Reflect.getOwnMetadata(SOURCE_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(SOURCE_METADATA, target.constructor, sourceMetadata);
     };
 };

package/esm/index.js

@@ -5,7 +5,7 @@ import './augmentation/singleton.augmentation.js';
 import './augmentation/storage.augmentation.js';
 export * from './types.js';
 export * from './adapter/execution-context.js';
-export * from './adapter/operation-context.js';
+export * from './adapter/endpoint-context.js';
 export * from './adapter/platform-adapter.js';
 export * from './adapter/request.js';
 export * from './adapter/response.js';

package/i18n/en/error.json

@@ -8,11 +8,12 @@
   "NOT_FOUND": "Not found",
   "UNAUTHORIZED": "You have not been authenticated to perform this action",
   "UNPROCESSABLE_ENTITY": "Unprocessable entity",
+  "SOURCE_NOT_FOUND": "Source not found",
   "REQUEST_VALIDATION": "Request validation failed",
   "RESPONSE_VALIDATION": "Response validation failed",
-  "RESOURCE_NOT_FOUND": "Resource not found: '{{resource}}'",
+  "RESOURCE_NOT_FOUND": "Resource not found",
   "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})",
-  "RESOLVER_FORBIDDEN": "The {{resource}} endpoint does not accept '{{operation}}' operations",
+  "RESOLVER_FORBIDDEN": "The {{resource}} endpoint does not accept '{{endpoint}}' operations",
   "UNKNOWN_FIELD": "Unknown field '{{field}}'",
   "UNACCEPTED_SORT_FIELD": "Field '{{field}}' is not available for sort operation",
   "UNACCEPTED_FILTER_FIELD": "Field '{{field}}' is not available for filter operation",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,7 +27,7 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/common": "^0.23.1",
+    "@opra/common": "^0.24.0",
     "accepts": "^1.3.8",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",

package/types/adapter/{operation-context.d.ts → endpoint-context.d.ts}

@@ -1,11 +1,11 @@
 import type { ExecutionContext } from './execution-context';
 import type { Request } from './request';
 import type { Response } from './response';
-export interface OperationContext<TRequest extends Request = Request, TResponse extends Response = Response> extends ExecutionContext {
+export interface EndpointContext<TRequest extends Request = Request, TResponse extends Response = Response> extends ExecutionContext {
     request: TRequest;
     response: TResponse;
     requestScope: Record<string | number | symbol, any>;
 }
-export declare namespace OperationContext {
-    function from<TRequest extends Request = Request, TResponse extends Response = Response>(executionContext: ExecutionContext, request: TRequest, response: TResponse): OperationContext;
+export declare namespace EndpointContext {
+    function from<TRequest extends Request = Request, TResponse extends Response = Response>(executionContext: ExecutionContext, request: TRequest, response: TResponse): EndpointContext;
 }

package/types/adapter/http/request-handlers/entity-request-handler.d.ts

@@ -1,6 +1,6 @@
 import { Collection, OpraSchema, Singleton } from '@opra/common';
+import { EndpointContext } from '../../endpoint-context.js';
 import { ExecutionContext } from '../../execution-context.js';
-import { OperationContext } from '../../operation-context.js';
 import { Request } from '../../request.js';
 import type { HttpAdapterBase } from '../http-adapter-base.js';
 import { HttpServerRequest } from '../http-server-request.js';
@@ -15,10 +15,10 @@ export declare class EntityRequestHandler extends RequestHandlerBase {
     constructor(adapter: HttpAdapterBase);
     processRequest(executionContext: ExecutionContext): Promise<void>;
     parseRequest(incoming: HttpServerRequest): Promise<Request | undefined>;
-    executeOperation(context: OperationContext): Promise<void>;
-    sendResponse(context: OperationContext): Promise<void>;
+    callEndpoint(context: EndpointContext): Promise<void>;
+    sendResponse(context: EndpointContext): Promise<void>;
     parseCollectionRequest(resource: Collection, incoming: HttpServerRequest): Promise<Request>;
     parseSingletonRequest(resource: Singleton, incoming: HttpServerRequest): Promise<Request>;
-    getBodyLoader(operation: OpraSchema.Collection.CreateOperation | OpraSchema.Collection.UpdateOperation | OpraSchema.Collection.UpdateManyOperation): BodyLoaderFunction;
+    getBodyLoader(endpoint: OpraSchema.Collection.CreateEndpoint | OpraSchema.Collection.UpdateEndpoint | OpraSchema.Collection.UpdateManyEndpoint): BodyLoaderFunction;
 }
 export {};

package/types/adapter/http/request-handlers/request-handler-base.d.ts

@@ -9,7 +9,7 @@ export declare abstract class RequestHandlerBase implements RequestHandler {
     readonly adapter: HttpAdapterBase;
     protected constructor(adapter: HttpAdapterBase);
     abstract processRequest(executionContext: ExecutionContext): Promise<void>;
-    assertOperation<T extends OpraSchema.Operation = OpraSchema.Operation>(resource: Resource, operation: string): Promise<T & {
+    assertEndpoint<T extends OpraSchema.Endpoint = OpraSchema.Endpoint>(resource: Resource, endpoint: string): Promise<T & {
         controller: any;
     }>;
 }