@e22m4u/ts-rest-router 0.1.2 → 0.2.1

package/dist/cjs/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -18,61 +16,52 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/esm/index.js
 var index_exports = {};
 __export(index_exports, {
-  ACTIONS_METADATA_KEY: () => ACTIONS_METADATA_KEY,
-  AFTER_METADATA_KEY: () => AFTER_METADATA_KEY,
-  ActionReflector: () => ActionReflector,
-  AfterReflector: () => AfterReflector,
-  BEFORE_METADATA_KEY: () => BEFORE_METADATA_KEY,
-  BeforeReflector: () => BeforeReflector,
-  CONTROLLER_METADATA_KEY: () => CONTROLLER_METADATA_KEY,
-  ControllerReflector: () => ControllerReflector,
+  AFTER_ACTION_METADATA_KEY: () => AFTER_ACTION_METADATA_KEY,
+  AfterActionReflector: () => AfterActionReflector,
+  BEFORE_ACTION_METADATA_KEY: () => BEFORE_ACTION_METADATA_KEY,
+  BeforeActionReflector: () => BeforeActionReflector,
   ControllerRegistry: () => ControllerRegistry,
   NotAControllerError: () => NotAControllerError,
   REQUEST_CONTEXT_METADATA_KEY: () => REQUEST_CONTEXT_METADATA_KEY,
   REQUEST_DATA_METADATA_KEY: () => REQUEST_DATA_METADATA_KEY,
+  REST_ACTIONS_METADATA_KEY: () => REST_ACTIONS_METADATA_KEY,
+  REST_CONTROLLER_METADATA_KEY: () => REST_CONTROLLER_METADATA_KEY,
   RequestContextReflector: () => RequestContextReflector,
   RequestDataReflector: () => RequestDataReflector,
   RequestDataSource: () => RequestDataSource,
+  RestActionReflector: () => RestActionReflector,
+  RestControllerReflector: () => RestControllerReflector,
   RestRouter: () => RestRouter,
-  action: () => action,
-  after: () => after,
-  before: () => before,
-  body: () => body,
+  afterAction: () => afterAction,
+  beforeAction: () => beforeAction,
   capitalize: () => capitalize,
-  controller: () => controller,
-  cookie: () => cookie,
-  cookies: () => cookies,
-  createDebugger: () => createDebugger,
   createError: () => createError,
-  del: () => del,
-  field: () => field,
-  get: () => get,
-  header: () => header,
-  headers: () => headers,
-  param: () => param,
-  params: () => params,
-  patch: () => patch,
-  post: () => post,
-  put: () => put,
-  queries: () => queries,
-  query: () => query,
-  request: () => request,
+  deleteAction: () => deleteAction,
+  getAction: () => getAction,
+  httpRequest: () => httpRequest,
+  httpResponse: () => httpResponse,
+  patchAction: () => patchAction,
+  postAction: () => postAction,
+  putAction: () => putAction,
+  requestBody: () => requestBody,
   requestContext: () => requestContext,
+  requestCookie: () => requestCookie,
+  requestCookies: () => requestCookies,
   requestData: () => requestData,
-  response: () => response,
+  requestField: () => requestField,
+  requestHeader: () => requestHeader,
+  requestHeaders: () => requestHeaders,
+  requestParam: () => requestParam,
+  requestParams: () => requestParams,
+  requestQueries: () => requestQueries,
+  requestQuery: () => requestQuery,
+  restAction: () => restAction,
+  restController: () => restController,
   toCamelCase: () => toCamelCase
 });
 module.exports = __toCommonJS(index_exports);
@@ -97,53 +86,27 @@ function toCamelCase(input) {
 }
 __name(toCamelCase, "toCamelCase");
 
-// dist/esm/utils/create-debugger.js
-var import_util = require("util");
-var import_debug = __toESM(require("debug"), 1);
-var import_js_format2 = require("@e22m4u/js-format");
-function colorizeString(input) {
-  const c = Number(import_debug.default["selectColor"](input));
-  const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
-  return `${colorCode};1m${input}\x1B[0m`;
-}
-__name(colorizeString, "colorizeString");
-function createDebugger(name) {
-  const debuggerName = `tsRestRouter:${name}`;
-  const debug = (0, import_debug.default)(debuggerName);
-  return function(messageOrData, ...args) {
-    let prefix = "";
-    if (typeof this === "string") {
-      const isDebugUsesColors = debug.useColors;
-      prefix = isDebugUsesColors ? colorizeString(`[${this}] `) : `[${this}] `;
-    }
-    if (typeof messageOrData === "string") {
-      const interpolatedMessage = (0, import_js_format2.format)(messageOrData, ...args);
-      return debug(prefix + interpolatedMessage);
-    }
-    const inspectOptions = {
-      showHidden: false,
-      depth: null,
-      colors: true,
-      compact: false
-    };
-    const multiString = (0, import_util.inspect)(messageOrData, inspectOptions);
-    const rows = multiString.split("\n");
-    const colorizedDebuggerName = colorizeString(debuggerName);
-    [...args, ...rows].forEach((v) => console.log(`  ${colorizedDebuggerName} ${prefix}${v}`));
-  };
-}
-__name(createDebugger, "createDebugger");
-
 // dist/esm/rest-router.js
 var import_js_trie_router3 = require("@e22m4u/js-trie-router");
 
 // dist/esm/debuggable-service.js
 var import_js_service = require("@e22m4u/js-service");
+var import_js_debug = require("@e22m4u/js-debug");
 var _DebuggableService = class _DebuggableService extends import_js_service.Service {
   /**
    * Debug.
    */
   debug;
+  /**
+   * Возвращает функцию-отладчик с сегментом пространства имен
+   * указанного в параметре метода.
+   *
+   * @param method
+   * @protected
+   */
+  getDebuggerFor(method) {
+    return this.debug.withHash().withNs(method.name);
+  }
   /**
    * Constructor.
    *
@@ -152,25 +115,42 @@ var _DebuggableService = class _DebuggableService extends import_js_service.Serv
   constructor(container) {
     super(container);
     const serviceName = toCamelCase(this.constructor.name);
-    this.debug = createDebugger(serviceName);
-    this.debug.bind("constructor")("Service created.");
+    this.debug = (0, import_js_debug.createDebugger)("tsRestRouter", serviceName);
+    const debug = this.debug.withNs("constructor").withHash();
+    debug("Service created.");
   }
 };
 __name(_DebuggableService, "DebuggableService");
 var DebuggableService = _DebuggableService;
 
 // dist/esm/controller-registry.js
-var import_js_format4 = require("@e22m4u/js-format");
+var import_js_format3 = require("@e22m4u/js-format");
 var import_js_trie_router2 = require("@e22m4u/js-trie-router");
 var import_ts_data_schema2 = require("@e22m4u/ts-data-schema");
+var import_ts_data_schema3 = require("@e22m4u/ts-data-schema");
 
-// dist/esm/decorators/after/after-metadata.js
+// dist/esm/errors/not-a-controller-error.js
+var import_js_format2 = require("@e22m4u/js-format");
+var _NotAControllerError = class _NotAControllerError extends import_js_format2.Errorf {
+  /**
+   * Constructor.
+   *
+   * @param value
+   */
+  constructor(value) {
+    super("%v is not a controller, do use @restController decorator on it.", value);
+  }
+};
+__name(_NotAControllerError, "NotAControllerError");
+var NotAControllerError = _NotAControllerError;
+
+// dist/esm/decorators/rest-action/rest-action-metadata.js
 var import_ts_reflector = require("@e22m4u/ts-reflector");
-var AFTER_METADATA_KEY = new import_ts_reflector.MetadataKey("afterMetadataKey");
+var REST_ACTIONS_METADATA_KEY = new import_ts_reflector.MetadataKey("restActionsMetadataKey");
 
-// dist/esm/decorators/after/after-reflector.js
+// dist/esm/decorators/rest-action/rest-action-reflector.js
 var import_ts_reflector2 = require("@e22m4u/ts-reflector");
-var _AfterReflector = class _AfterReflector {
+var _RestActionReflector = class _RestActionReflector {
   /**
    * Set metadata.
    *
@@ -178,60 +158,112 @@ var _AfterReflector = class _AfterReflector {
    * @param target
    * @param propertyKey
    */
-  static addMetadata(metadata, target, propertyKey) {
-    const oldArray = import_ts_reflector2.Reflector.getOwnMetadata(AFTER_METADATA_KEY, target, propertyKey) ?? [];
-    const newArray = [metadata, ...oldArray];
-    import_ts_reflector2.Reflector.defineMetadata(AFTER_METADATA_KEY, newArray, target, propertyKey);
+  static setMetadata(metadata, target, propertyKey) {
+    const oldMap = import_ts_reflector2.Reflector.getOwnMetadata(REST_ACTIONS_METADATA_KEY, target);
+    const newMap = new Map(oldMap);
+    newMap.set(propertyKey, metadata);
+    import_ts_reflector2.Reflector.defineMetadata(REST_ACTIONS_METADATA_KEY, newMap, target);
   }
   /**
    * Get metadata.
    *
    * @param target
-   * @param propertyKey
    */
-  static getMetadata(target, propertyKey) {
-    const metadata = import_ts_reflector2.Reflector.getOwnMetadata(AFTER_METADATA_KEY, target, propertyKey);
-    return metadata ?? [];
+  static getMetadata(target) {
+    const metadata = import_ts_reflector2.Reflector.getOwnMetadata(REST_ACTIONS_METADATA_KEY, target);
+    return metadata ?? /* @__PURE__ */ new Map();
   }
 };
-__name(_AfterReflector, "AfterReflector");
-var AfterReflector = _AfterReflector;
+__name(_RestActionReflector, "RestActionReflector");
+var RestActionReflector = _RestActionReflector;
 
-// dist/esm/decorators/after/after-decorator.js
+// dist/esm/decorators/rest-action/rest-action-decorator.js
+var import_js_trie_router = require("@e22m4u/js-trie-router");
 var import_ts_reflector3 = require("@e22m4u/ts-reflector");
 var import_ts_reflector4 = require("@e22m4u/ts-reflector");
-function after(middleware) {
+function restAction(options) {
   return function(target, propertyKey, descriptor) {
     const decoratorType = (0, import_ts_reflector4.getDecoratorTargetType)(target, propertyKey, descriptor);
-    if (decoratorType === import_ts_reflector3.DecoratorTargetType.CONSTRUCTOR) {
-      AfterReflector.addMetadata({ middleware }, target);
-    } else if (decoratorType === import_ts_reflector3.DecoratorTargetType.INSTANCE_METHOD) {
-      AfterReflector.addMetadata({ propertyKey, middleware }, target.constructor, propertyKey);
-    } else {
-      throw new Error("@after decorator is only supported on a class or an instance method.");
-    }
+    if (decoratorType !== import_ts_reflector3.DecoratorTargetType.INSTANCE_METHOD)
+      throw new Error("@restAction decorator is only supported on an instance method.");
+    RestActionReflector.setMetadata({ ...options, propertyKey }, target.constructor, propertyKey);
   };
 }
-__name(after, "after");
+__name(restAction, "restAction");
+function getAction(pathOrOptions, options) {
+  let path = typeof pathOrOptions === "string" ? pathOrOptions : "";
+  options = typeof pathOrOptions === "object" ? pathOrOptions : options;
+  if (typeof options === "object" && !path && options.path != null)
+    path = options.path;
+  return restAction({ ...options, path, method: import_js_trie_router.HttpMethod.GET });
+}
+__name(getAction, "getAction");
+function postAction(pathOrOptions, options) {
+  let path = typeof pathOrOptions === "string" ? pathOrOptions : "";
+  options = typeof pathOrOptions === "object" ? pathOrOptions : options;
+  if (typeof options === "object" && !path && options.path != null)
+    path = options.path;
+  return restAction({ ...options, path, method: import_js_trie_router.HttpMethod.POST });
+}
+__name(postAction, "postAction");
+function putAction(pathOrOptions, options) {
+  let path = typeof pathOrOptions === "string" ? pathOrOptions : "";
+  options = typeof pathOrOptions === "object" ? pathOrOptions : options;
+  if (typeof options === "object" && !path && options.path != null)
+    path = options.path;
+  return restAction({ ...options, path, method: import_js_trie_router.HttpMethod.PUT });
+}
+__name(putAction, "putAction");
+function patchAction(pathOrOptions, options) {
+  let path = typeof pathOrOptions === "string" ? pathOrOptions : "";
+  options = typeof pathOrOptions === "object" ? pathOrOptions : options;
+  if (typeof options === "object" && !path && options.path != null)
+    path = options.path;
+  return restAction({ ...options, path, method: import_js_trie_router.HttpMethod.PATCH });
+}
+__name(patchAction, "patchAction");
+function deleteAction(pathOrOptions, options) {
+  let path = typeof pathOrOptions === "string" ? pathOrOptions : "";
+  options = typeof pathOrOptions === "object" ? pathOrOptions : options;
+  if (typeof options === "object" && !path && options.path != null)
+    path = options.path;
+  return restAction({ ...options, path, method: import_js_trie_router.HttpMethod.DELETE });
+}
+__name(deleteAction, "deleteAction");
 
-// dist/esm/decorators/before/before-metadata.js
+// dist/esm/decorators/request-data/request-data-metadata.js
 var import_ts_reflector5 = require("@e22m4u/ts-reflector");
-var BEFORE_METADATA_KEY = new import_ts_reflector5.MetadataKey("beforeMetadataKey");
+var RequestDataSource;
+(function(RequestDataSource2) {
+  RequestDataSource2["PARAMS"] = "params";
+  RequestDataSource2["QUERY"] = "query";
+  RequestDataSource2["HEADERS"] = "headers";
+  RequestDataSource2["COOKIE"] = "cookie";
+  RequestDataSource2["BODY"] = "body";
+})(RequestDataSource || (RequestDataSource = {}));
+var REQUEST_DATA_METADATA_KEY = new import_ts_reflector5.MetadataKey("requestDataMetadataKey");
 
-// dist/esm/decorators/before/before-reflector.js
+// dist/esm/decorators/request-data/request-data-decorator.js
+var import_ts_data_schema = require("@e22m4u/ts-data-schema");
+var import_ts_reflector7 = require("@e22m4u/ts-reflector");
+var import_ts_reflector8 = require("@e22m4u/ts-reflector");
+
+// dist/esm/decorators/request-data/request-data-reflector.js
 var import_ts_reflector6 = require("@e22m4u/ts-reflector");
-var _BeforeReflector = class _BeforeReflector {
+var _RequestDataReflector = class _RequestDataReflector {
   /**
    * Set metadata.
    *
    * @param metadata
    * @param target
+   * @param index
    * @param propertyKey
    */
-  static addMetadata(metadata, target, propertyKey) {
-    const oldArray = import_ts_reflector6.Reflector.getOwnMetadata(BEFORE_METADATA_KEY, target, propertyKey) ?? [];
-    const newArray = [metadata, ...oldArray];
-    import_ts_reflector6.Reflector.defineMetadata(BEFORE_METADATA_KEY, newArray, target, propertyKey);
+  static setMetadata(metadata, target, index, propertyKey) {
+    const oldMap = import_ts_reflector6.Reflector.getOwnMetadata(REQUEST_DATA_METADATA_KEY, target, propertyKey);
+    const newMap = new Map(oldMap);
+    newMap.set(index, metadata);
+    import_ts_reflector6.Reflector.defineMetadata(REQUEST_DATA_METADATA_KEY, newMap, target, propertyKey);
   }
   /**
    * Get metadata.
@@ -240,37 +272,78 @@ var _BeforeReflector = class _BeforeReflector {
    * @param propertyKey
    */
   static getMetadata(target, propertyKey) {
-    const metadata = import_ts_reflector6.Reflector.getOwnMetadata(BEFORE_METADATA_KEY, target, propertyKey);
-    return metadata ?? [];
+    const metadata = import_ts_reflector6.Reflector.getOwnMetadata(REQUEST_DATA_METADATA_KEY, target, propertyKey);
+    return metadata ?? /* @__PURE__ */ new Map();
   }
 };
-__name(_BeforeReflector, "BeforeReflector");
-var BeforeReflector = _BeforeReflector;
+__name(_RequestDataReflector, "RequestDataReflector");
+var RequestDataReflector = _RequestDataReflector;
 
-// dist/esm/decorators/before/before-decorator.js
-var import_ts_reflector7 = require("@e22m4u/ts-reflector");
-var import_ts_reflector8 = require("@e22m4u/ts-reflector");
-function before(middleware) {
-  return function(target, propertyKey, descriptor) {
-    const decoratorType = (0, import_ts_reflector8.getDecoratorTargetType)(target, propertyKey, descriptor);
-    if (decoratorType === import_ts_reflector7.DecoratorTargetType.CONSTRUCTOR) {
-      BeforeReflector.addMetadata({ middleware }, target);
-    } else if (decoratorType === import_ts_reflector7.DecoratorTargetType.INSTANCE_METHOD) {
-      BeforeReflector.addMetadata({ propertyKey, middleware }, target.constructor, propertyKey);
-    } else {
-      throw new Error("@before decorator is only supported on a class or an instance method.");
+// dist/esm/decorators/request-data/request-data-decorator.js
+function requestData(options) {
+  return function(target, propertyKey, indexOrDescriptor) {
+    const decoratorType = (0, import_ts_reflector8.getDecoratorTargetType)(target, propertyKey, indexOrDescriptor);
+    if (decoratorType !== import_ts_reflector7.DecoratorTargetType.INSTANCE_METHOD_PARAMETER)
+      throw new Error("@requestData decorator is only supported on an instance method parameter.");
+    RequestDataReflector.setMetadata(options, target.constructor, indexOrDescriptor, propertyKey);
+  };
+}
+__name(requestData, "requestData");
+function createRequestDataDecoratorWithSource(source) {
+  return function() {
+    const schema = { type: import_ts_data_schema.DataType.OBJECT };
+    return requestData({ schema, source });
+  };
+}
+__name(createRequestDataDecoratorWithSource, "createRequestDataDecoratorWithSource");
+function createRequestDataPropertyDecoratorWithSource(source) {
+  return function(propertyKey, schemaOrType) {
+    const properties = {};
+    const rootSchema = { type: import_ts_data_schema.DataType.OBJECT };
+    if (typeof schemaOrType === "object") {
+      properties[propertyKey] = schemaOrType;
+      rootSchema.properties = properties;
+    } else if (typeof schemaOrType === "string") {
+      properties[propertyKey] = { type: schemaOrType };
+      rootSchema.properties = properties;
     }
+    return requestData({
+      source,
+      schema: rootSchema,
+      property: propertyKey
+    });
   };
 }
-__name(before, "before");
+__name(createRequestDataPropertyDecoratorWithSource, "createRequestDataPropertyDecoratorWithSource");
+var requestParams = createRequestDataDecoratorWithSource(RequestDataSource.PARAMS);
+var requestParam = createRequestDataPropertyDecoratorWithSource(RequestDataSource.PARAMS);
+var requestQueries = createRequestDataDecoratorWithSource(RequestDataSource.QUERY);
+var requestQuery = createRequestDataPropertyDecoratorWithSource(RequestDataSource.QUERY);
+var requestHeaders = createRequestDataDecoratorWithSource(RequestDataSource.HEADERS);
+var requestHeader = createRequestDataPropertyDecoratorWithSource(RequestDataSource.HEADERS);
+var requestCookies = createRequestDataDecoratorWithSource(RequestDataSource.COOKIE);
+var requestCookie = createRequestDataPropertyDecoratorWithSource(RequestDataSource.COOKIE);
+var requestField = createRequestDataPropertyDecoratorWithSource(RequestDataSource.BODY);
+function requestBody(schemaOrType) {
+  let schema;
+  if (typeof schemaOrType === "object") {
+    schema = schemaOrType;
+  } else if (typeof schemaOrType === "string") {
+    schema = { type: schemaOrType };
+  } else {
+    schema = { type: import_ts_data_schema.DataType.ANY };
+  }
+  return requestData({ schema, source: RequestDataSource.BODY });
+}
+__name(requestBody, "requestBody");
 
-// dist/esm/decorators/action/action-metadata.js
+// dist/esm/decorators/after-action/after-action-metadata.js
 var import_ts_reflector9 = require("@e22m4u/ts-reflector");
-var ACTIONS_METADATA_KEY = new import_ts_reflector9.MetadataKey("actionsMetadataKey");
+var AFTER_ACTION_METADATA_KEY = new import_ts_reflector9.MetadataKey("afterActionMetadataKey");
 
-// dist/esm/decorators/action/action-reflector.js
+// dist/esm/decorators/after-action/after-action-reflector.js
 var import_ts_reflector10 = require("@e22m4u/ts-reflector");
-var _ActionReflector = class _ActionReflector {
+var _AfterActionReflector = class _AfterActionReflector {
   /**
    * Set metadata.
    *
@@ -278,211 +351,143 @@ var _ActionReflector = class _ActionReflector {
    * @param target
    * @param propertyKey
    */
-  static setMetadata(metadata, target, propertyKey) {
-    const oldMap = import_ts_reflector10.Reflector.getOwnMetadata(ACTIONS_METADATA_KEY, target);
-    const newMap = new Map(oldMap);
-    newMap.set(propertyKey, metadata);
-    import_ts_reflector10.Reflector.defineMetadata(ACTIONS_METADATA_KEY, newMap, target);
+  static addMetadata(metadata, target, propertyKey) {
+    const oldArray = import_ts_reflector10.Reflector.getOwnMetadata(AFTER_ACTION_METADATA_KEY, target, propertyKey) ?? [];
+    const newArray = [metadata, ...oldArray];
+    import_ts_reflector10.Reflector.defineMetadata(AFTER_ACTION_METADATA_KEY, newArray, target, propertyKey);
   }
   /**
    * Get metadata.
    *
    * @param target
+   * @param propertyKey
    */
-  static getMetadata(target) {
-    const metadata = import_ts_reflector10.Reflector.getOwnMetadata(ACTIONS_METADATA_KEY, target);
-    return metadata ?? /* @__PURE__ */ new Map();
+  static getMetadata(target, propertyKey) {
+    const metadata = import_ts_reflector10.Reflector.getOwnMetadata(AFTER_ACTION_METADATA_KEY, target, propertyKey);
+    return metadata ?? [];
   }
 };
-__name(_ActionReflector, "ActionReflector");
-var ActionReflector = _ActionReflector;
+__name(_AfterActionReflector, "AfterActionReflector");
+var AfterActionReflector = _AfterActionReflector;
 
-// dist/esm/decorators/action/action-decorator.js
-var import_js_trie_router = require("@e22m4u/js-trie-router");
+// dist/esm/decorators/after-action/after-action-decorator.js
 var import_ts_reflector11 = require("@e22m4u/ts-reflector");
 var import_ts_reflector12 = require("@e22m4u/ts-reflector");
-function action(options) {
+function afterAction(middleware) {
   return function(target, propertyKey, descriptor) {
     const decoratorType = (0, import_ts_reflector12.getDecoratorTargetType)(target, propertyKey, descriptor);
-    if (decoratorType !== import_ts_reflector11.DecoratorTargetType.INSTANCE_METHOD)
-      throw new Error("@action decorator is only supported on an instance method.");
-    ActionReflector.setMetadata({ ...options, propertyKey }, target.constructor, propertyKey);
+    if (decoratorType === import_ts_reflector11.DecoratorTargetType.CONSTRUCTOR) {
+      AfterActionReflector.addMetadata({ middleware }, target);
+    } else if (decoratorType === import_ts_reflector11.DecoratorTargetType.INSTANCE_METHOD) {
+      AfterActionReflector.addMetadata({ propertyKey, middleware }, target.constructor, propertyKey);
+    } else {
+      throw new Error("@afterAction decorator is only supported on a class or an instance method.");
+    }
   };
 }
-__name(action, "action");
-var get = /* @__PURE__ */ __name((path, options) => {
-  return action({ ...options, path, method: import_js_trie_router.HttpMethod.GET });
-}, "get");
-var post = /* @__PURE__ */ __name((path, options) => {
-  return action({ ...options, path, method: import_js_trie_router.HttpMethod.POST });
-}, "post");
-var put = /* @__PURE__ */ __name((path, options) => {
-  return action({ ...options, path, method: import_js_trie_router.HttpMethod.PUT });
-}, "put");
-var patch = /* @__PURE__ */ __name((path, options) => {
-  return action({ ...options, path, method: import_js_trie_router.HttpMethod.PATCH });
-}, "patch");
-var del = /* @__PURE__ */ __name((path, options) => {
-  return action({ ...options, path, method: import_js_trie_router.HttpMethod.DELETE });
-}, "del");
+__name(afterAction, "afterAction");
 
-// dist/esm/decorators/controller/controller-metadata.js
+// dist/esm/decorators/before-action/before-action-metadata.js
 var import_ts_reflector13 = require("@e22m4u/ts-reflector");
-var CONTROLLER_METADATA_KEY = new import_ts_reflector13.MetadataKey("controllerMetadataKey");
-
-// dist/esm/decorators/controller/controller-decorator.js
-var import_ts_reflector15 = require("@e22m4u/ts-reflector");
-var import_ts_reflector16 = require("@e22m4u/ts-reflector");
+var BEFORE_ACTION_METADATA_KEY = new import_ts_reflector13.MetadataKey("beforeActionMetadataKey");
 
-// dist/esm/decorators/controller/controller-reflector.js
+// dist/esm/decorators/before-action/before-action-reflector.js
 var import_ts_reflector14 = require("@e22m4u/ts-reflector");
-var _ControllerReflector = class _ControllerReflector {
+var _BeforeActionReflector = class _BeforeActionReflector {
   /**
    * Set metadata.
    *
    * @param metadata
    * @param target
+   * @param propertyKey
    */
-  static setMetadata(metadata, target) {
-    return import_ts_reflector14.Reflector.defineMetadata(CONTROLLER_METADATA_KEY, metadata, target);
+  static addMetadata(metadata, target, propertyKey) {
+    const oldArray = import_ts_reflector14.Reflector.getOwnMetadata(BEFORE_ACTION_METADATA_KEY, target, propertyKey) ?? [];
+    const newArray = [metadata, ...oldArray];
+    import_ts_reflector14.Reflector.defineMetadata(BEFORE_ACTION_METADATA_KEY, newArray, target, propertyKey);
   }
   /**
    * Get metadata.
    *
    * @param target
+   * @param propertyKey
    */
-  static getMetadata(target) {
-    return import_ts_reflector14.Reflector.getOwnMetadata(CONTROLLER_METADATA_KEY, target);
+  static getMetadata(target, propertyKey) {
+    const metadata = import_ts_reflector14.Reflector.getOwnMetadata(BEFORE_ACTION_METADATA_KEY, target, propertyKey);
+    return metadata ?? [];
   }
 };
-__name(_ControllerReflector, "ControllerReflector");
-var ControllerReflector = _ControllerReflector;
+__name(_BeforeActionReflector, "BeforeActionReflector");
+var BeforeActionReflector = _BeforeActionReflector;
 
-// dist/esm/decorators/controller/controller-decorator.js
-function controller(pathOrOptions, options) {
-  return function(target) {
-    const decoratorType = (0, import_ts_reflector16.getDecoratorTargetType)(target);
-    if (decoratorType !== import_ts_reflector15.DecoratorTargetType.CONSTRUCTOR)
-      throw new Error("@controller decorator is only supported on a class.");
-    if (typeof pathOrOptions === "string") {
-      if (!options) {
-        options = { path: pathOrOptions };
-      } else {
-        options.path = pathOrOptions;
-      }
-    } else if (typeof pathOrOptions === "object") {
-      options = pathOrOptions;
+// dist/esm/decorators/before-action/before-action-decorator.js
+var import_ts_reflector15 = require("@e22m4u/ts-reflector");
+var import_ts_reflector16 = require("@e22m4u/ts-reflector");
+function beforeAction(middleware) {
+  return function(target, propertyKey, descriptor) {
+    const decoratorType = (0, import_ts_reflector16.getDecoratorTargetType)(target, propertyKey, descriptor);
+    if (decoratorType === import_ts_reflector15.DecoratorTargetType.CONSTRUCTOR) {
+      BeforeActionReflector.addMetadata({ middleware }, target);
+    } else if (decoratorType === import_ts_reflector15.DecoratorTargetType.INSTANCE_METHOD) {
+      BeforeActionReflector.addMetadata({ propertyKey, middleware }, target.constructor, propertyKey);
+    } else {
+      throw new Error("@beforeAction decorator is only supported on a class or an instance method.");
     }
-    ControllerReflector.setMetadata({ ...options, className: target.name }, target);
   };
 }
-__name(controller, "controller");
+__name(beforeAction, "beforeAction");
 
-// dist/esm/decorators/request-data/request-data-metadata.js
+// dist/esm/decorators/rest-controller/rest-controller-metadata.js
 var import_ts_reflector17 = require("@e22m4u/ts-reflector");
-var RequestDataSource;
-(function(RequestDataSource2) {
-  RequestDataSource2["PARAMS"] = "params";
-  RequestDataSource2["QUERY"] = "query";
-  RequestDataSource2["HEADERS"] = "headers";
-  RequestDataSource2["COOKIE"] = "cookie";
-  RequestDataSource2["BODY"] = "body";
-})(RequestDataSource || (RequestDataSource = {}));
-var REQUEST_DATA_METADATA_KEY = new import_ts_reflector17.MetadataKey("requestDataMetadataKey");
+var REST_CONTROLLER_METADATA_KEY = new import_ts_reflector17.MetadataKey("restControllerMetadataKey");
 
-// dist/esm/decorators/request-data/request-data-decorator.js
-var import_ts_data_schema = require("@e22m4u/ts-data-schema");
+// dist/esm/decorators/rest-controller/rest-controller-decorator.js
 var import_ts_reflector19 = require("@e22m4u/ts-reflector");
 var import_ts_reflector20 = require("@e22m4u/ts-reflector");
 
-// dist/esm/decorators/request-data/request-data-reflector.js
+// dist/esm/decorators/rest-controller/rest-controller-reflector.js
 var import_ts_reflector18 = require("@e22m4u/ts-reflector");
-var _RequestDataReflector = class _RequestDataReflector {
+var _RestControllerReflector = class _RestControllerReflector {
   /**
    * Set metadata.
    *
    * @param metadata
    * @param target
-   * @param index
-   * @param propertyKey
    */
-  static setMetadata(metadata, target, index, propertyKey) {
-    const oldMap = import_ts_reflector18.Reflector.getOwnMetadata(REQUEST_DATA_METADATA_KEY, target, propertyKey);
-    const newMap = new Map(oldMap);
-    newMap.set(index, metadata);
-    import_ts_reflector18.Reflector.defineMetadata(REQUEST_DATA_METADATA_KEY, newMap, target, propertyKey);
+  static setMetadata(metadata, target) {
+    return import_ts_reflector18.Reflector.defineMetadata(REST_CONTROLLER_METADATA_KEY, metadata, target);
   }
   /**
    * Get metadata.
    *
    * @param target
-   * @param propertyKey
    */
-  static getMetadata(target, propertyKey) {
-    const metadata = import_ts_reflector18.Reflector.getOwnMetadata(REQUEST_DATA_METADATA_KEY, target, propertyKey);
-    return metadata ?? /* @__PURE__ */ new Map();
+  static getMetadata(target) {
+    return import_ts_reflector18.Reflector.getOwnMetadata(REST_CONTROLLER_METADATA_KEY, target);
   }
 };
-__name(_RequestDataReflector, "RequestDataReflector");
-var RequestDataReflector = _RequestDataReflector;
+__name(_RestControllerReflector, "RestControllerReflector");
+var RestControllerReflector = _RestControllerReflector;
 
-// dist/esm/decorators/request-data/request-data-decorator.js
-function requestData(options) {
-  return function(target, propertyKey, indexOrDescriptor) {
-    const decoratorType = (0, import_ts_reflector20.getDecoratorTargetType)(target, propertyKey, indexOrDescriptor);
-    if (decoratorType !== import_ts_reflector19.DecoratorTargetType.INSTANCE_METHOD_PARAMETER)
-      throw new Error("@requestData decorator is only supported on an instance method parameter.");
-    RequestDataReflector.setMetadata(options, target.constructor, indexOrDescriptor, propertyKey);
-  };
-}
-__name(requestData, "requestData");
-function createRequestDataDecoratorWithSource(source) {
-  return function() {
-    const schema = { type: import_ts_data_schema.DataType.OBJECT };
-    return requestData({ schema, source });
-  };
-}
-__name(createRequestDataDecoratorWithSource, "createRequestDataDecoratorWithSource");
-function createRequestDataPropertyDecoratorWithSource(source) {
-  return function(propertyKey, schemaOrType) {
-    const properties = {};
-    const rootSchema = { type: import_ts_data_schema.DataType.OBJECT };
-    if (typeof schemaOrType === "object") {
-      properties[propertyKey] = schemaOrType;
-      rootSchema.properties = properties;
-    } else if (typeof schemaOrType === "string") {
-      properties[propertyKey] = { type: schemaOrType };
-      rootSchema.properties = properties;
+// dist/esm/decorators/rest-controller/rest-controller-decorator.js
+function restController(pathOrOptions, options) {
+  return function(target) {
+    const decoratorType = (0, import_ts_reflector20.getDecoratorTargetType)(target);
+    if (decoratorType !== import_ts_reflector19.DecoratorTargetType.CONSTRUCTOR)
+      throw new Error("@restController decorator is only supported on a class.");
+    if (typeof pathOrOptions === "string") {
+      if (!options) {
+        options = { path: pathOrOptions };
+      } else {
+        options.path = pathOrOptions;
+      }
+    } else if (typeof pathOrOptions === "object") {
+      options = pathOrOptions;
     }
-    return requestData({
-      source,
-      schema: rootSchema,
-      property: propertyKey
-    });
+    RestControllerReflector.setMetadata({ ...options, className: target.name }, target);
   };
 }
-__name(createRequestDataPropertyDecoratorWithSource, "createRequestDataPropertyDecoratorWithSource");
-var params = createRequestDataDecoratorWithSource(RequestDataSource.PARAMS);
-var param = createRequestDataPropertyDecoratorWithSource(RequestDataSource.PARAMS);
-var queries = createRequestDataDecoratorWithSource(RequestDataSource.QUERY);
-var query = createRequestDataPropertyDecoratorWithSource(RequestDataSource.QUERY);
-var headers = createRequestDataDecoratorWithSource(RequestDataSource.HEADERS);
-var header = createRequestDataPropertyDecoratorWithSource(RequestDataSource.HEADERS);
-var cookies = createRequestDataDecoratorWithSource(RequestDataSource.COOKIE);
-var cookie = createRequestDataPropertyDecoratorWithSource(RequestDataSource.COOKIE);
-var field = createRequestDataPropertyDecoratorWithSource(RequestDataSource.BODY);
-function body(schemaOrType) {
-  let schema;
-  if (typeof schemaOrType === "object") {
-    schema = schemaOrType;
-  } else if (typeof schemaOrType === "string") {
-    schema = { type: schemaOrType };
-  } else {
-    schema = { type: import_ts_data_schema.DataType.ANY };
-  }
-  return requestData({ schema, source: RequestDataSource.BODY });
-}
-__name(body, "body");
+__name(restController, "restController");
 
 // dist/esm/decorators/request-context/request-context-metadata.js
 var import_ts_reflector21 = require("@e22m4u/ts-reflector");
@@ -533,34 +538,17 @@ function requestContext(propertyName) {
   };
 }
 __name(requestContext, "requestContext");
-function request() {
+function httpRequest() {
   return requestContext("req");
 }
-__name(request, "request");
-function response() {
+__name(httpRequest, "httpRequest");
+function httpResponse() {
   return requestContext("res");
 }
-__name(response, "response");
-
-// dist/esm/controller-registry.js
-var import_ts_data_schema3 = require("@e22m4u/ts-data-schema");
-
-// dist/esm/errors/not-a-controller-error.js
-var import_js_format3 = require("@e22m4u/js-format");
-var _NotAControllerError = class _NotAControllerError extends import_js_format3.Errorf {
-  /**
-   * Constructor.
-   *
-   * @param value
-   */
-  constructor(value) {
-    super("%v is not a controller, do use @controller decorator on it.", value);
-  }
-};
-__name(_NotAControllerError, "NotAControllerError");
-var NotAControllerError = _NotAControllerError;
+__name(httpResponse, "httpResponse");
 
 // dist/esm/controller-registry.js
+var import_ts_data_schema4 = require("@e22m4u/ts-data-schema");
 var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
   /**
    * Controllers.
@@ -573,10 +561,10 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param options
    */
   addController(ctor, options) {
-    const debug = this.debug.bind(this.addController.name);
+    const debug = this.getDebuggerFor(this.addController);
     if (this.hasController(ctor))
-      throw new import_js_format4.Errorf("The controller %v is already registered.");
-    const controllerMd = ControllerReflector.getMetadata(ctor);
+      throw new import_js_format3.Errorf("The controller %v is already registered.");
+    const controllerMd = RestControllerReflector.getMetadata(ctor);
     if (!controllerMd)
       throw new NotAControllerError(ctor);
     debug("Adding controller %s.", ctor.name);
@@ -598,7 +586,7 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
       ...this.getPostHandlersFromControllerMetadata(ctor)
     ];
     debug("Controller has %v post-handlers.", postHandlers.length);
-    const actionsMd = ActionReflector.getMetadata(ctor);
+    const actionsMd = RestActionReflector.getMetadata(ctor);
     debug("%v actions found.", actionsMd.size);
     const router = this.getService(import_js_trie_router2.TrieRouter);
     actionsMd.forEach((actionMd, actionName) => {
@@ -645,7 +633,7 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param options
    */
   getPathPrefixFromControllerRootOptions(options) {
-    const debug = this.debug.bind(this.getPathPrefixFromControllerRootOptions.name);
+    const debug = this.getDebuggerFor(this.getPathPrefixFromControllerRootOptions);
     debug("Getting path prefix from controller root options.");
     const res = (options == null ? void 0 : options.pathPrefix) || "";
     debug("Controller path prefix is %v.", res);
@@ -657,12 +645,12 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param ctor
    */
   getPathPrefixFromControllerMetadata(ctor) {
-    const debug = this.debug.bind(this.getPathPrefixFromControllerMetadata.name);
-    debug("Getting path prefix from @controller metadata.");
+    const debug = this.getDebuggerFor(this.getPathPrefixFromControllerMetadata);
+    debug("Getting path prefix from @restController metadata.");
     debug("Metadata target is %s.", ctor.name);
-    const md = ControllerReflector.getMetadata(ctor);
+    const md = RestControllerReflector.getMetadata(ctor);
     if (!md)
-      throw new import_js_format4.Errorf("Controller %v has no metadata.", ctor);
+      throw new import_js_format3.Errorf("Controller %v has no metadata.", ctor);
     const res = md.path || "";
     debug("Controller path prefix is %v.", res);
     return md.path || "";
@@ -673,7 +661,7 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param options
    */
   getPreHandlersFromControllerRootOptions(options) {
-    const debug = this.debug.bind(this.getPreHandlersFromControllerRootOptions.name);
+    const debug = this.getDebuggerFor(this.getPreHandlersFromControllerRootOptions);
     debug("Getting pre-handlers from controller root options.");
     let res = [];
     if (options == null ? void 0 : options.before)
@@ -687,7 +675,7 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param options
    */
   getPostHandlersFromControllerRootOptions(options) {
-    const debug = this.debug.bind(this.getPostHandlersFromControllerRootOptions.name);
+    const debug = this.getDebuggerFor(this.getPostHandlersFromControllerRootOptions);
     debug("Getting post-handlers from controller root options.");
     let res = [];
     if (options == null ? void 0 : options.after)
@@ -702,7 +690,7 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param actionName
    */
   getPreHandlersFromBeforeMetadata(ctor, actionName) {
-    const debug = this.debug.bind(this.getPreHandlersFromBeforeMetadata.name);
+    const debug = this.getDebuggerFor(this.getPreHandlersFromBeforeMetadata);
     debug("Getting pre-handlers from @before metadata.");
     if (actionName) {
       debug("Target is %s.%s.", ctor.name, actionName);
@@ -710,7 +698,7 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
       debug("Target is %s.", ctor.name);
     }
     let preHandlers = [];
-    const mdArray = BeforeReflector.getMetadata(ctor, actionName);
+    const mdArray = BeforeActionReflector.getMetadata(ctor, actionName);
     mdArray.forEach((md) => {
       if (Array.isArray(md.middleware)) {
         preHandlers = [...preHandlers, ...md.middleware];
@@ -732,7 +720,7 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param actionName
    */
   getPostHandlersFromAfterMetadata(ctor, actionName) {
-    const debug = this.debug.bind(this.getPostHandlersFromAfterMetadata.name);
+    const debug = this.getDebuggerFor(this.getPostHandlersFromAfterMetadata);
     debug("Getting post-handlers from @after metadata.");
     if (actionName) {
       debug("Target is %s.%s.", ctor.name, actionName);
@@ -740,7 +728,7 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
       debug("Target is %s.", ctor.name);
     }
     let res = [];
-    const mdArray = AfterReflector.getMetadata(ctor, actionName);
+    const mdArray = AfterActionReflector.getMetadata(ctor, actionName);
     mdArray.forEach((md) => {
       if (Array.isArray(md.middleware)) {
         res = [...res, ...md.middleware];
@@ -761,12 +749,12 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param ctor
    */
   getPreHandlersFromControllerMetadata(ctor) {
-    const debug = this.debug.bind(this.getPreHandlersFromControllerMetadata.name);
-    debug("Getting pre-handlers from @controller metadata.");
+    const debug = this.getDebuggerFor(this.getPreHandlersFromControllerMetadata);
+    debug("Getting pre-handlers from @restController metadata.");
     debug("Target is %s.", ctor.name);
-    const md = ControllerReflector.getMetadata(ctor);
+    const md = RestControllerReflector.getMetadata(ctor);
     if (!md)
-      throw new import_js_format4.Errorf("Controller %v has no metadata.", ctor);
+      throw new import_js_format3.Errorf("Controller %v has no metadata.", ctor);
     let res = [];
     if (md.before)
       res = Array.isArray(md.before) ? md.before : [md.before];
@@ -779,11 +767,11 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param ctor
    */
   getPostHandlersFromControllerMetadata(ctor) {
-    const debug = this.debug.bind(this.getPostHandlersFromControllerMetadata.name);
-    debug("Getting post-handlers from @controller metadata.");
-    const md = ControllerReflector.getMetadata(ctor);
+    const debug = this.getDebuggerFor(this.getPostHandlersFromControllerMetadata);
+    debug("Getting post-handlers from @restController metadata.");
+    const md = RestControllerReflector.getMetadata(ctor);
     if (!md)
-      throw new import_js_format4.Errorf("Controller %v has no metadata.", ctor);
+      throw new import_js_format3.Errorf("Controller %v has no metadata.", ctor);
     let res = [];
     if (md.after)
       res = Array.isArray(md.after) ? md.after : [md.after];
@@ -797,12 +785,12 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param actionName
    */
   getPreHandlersFromActionMetadata(ctor, actionName) {
-    const debug = this.debug.bind(this.getPreHandlersFromActionMetadata.name);
+    const debug = this.getDebuggerFor(this.getPreHandlersFromActionMetadata);
     debug("Getting pre-handlers from @action metadata.");
-    const actionsMd = ActionReflector.getMetadata(ctor);
+    const actionsMd = RestActionReflector.getMetadata(ctor);
     const actionMd = actionsMd.get(actionName);
     if (!actionMd)
-      throw new import_js_format4.Errorf("Action %s.%s has no metadata.", ctor.name, actionName);
+      throw new import_js_format3.Errorf("Action %s.%s has no metadata.", ctor.name, actionName);
     let res = [];
     if (actionMd.before)
       res = Array.isArray(actionMd.before) ? actionMd.before : [actionMd.before];
@@ -816,12 +804,12 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @param actionName
    */
   getPostHandlersFromActionMetadata(ctor, actionName) {
-    const debug = this.debug.bind(this.getPreHandlersFromActionMetadata.name);
+    const debug = this.getDebuggerFor(this.getPreHandlersFromActionMetadata);
     debug("Getting post-handlers from @action metadata.");
-    const actionsMd = ActionReflector.getMetadata(ctor);
+    const actionsMd = RestActionReflector.getMetadata(ctor);
     const actionMd = actionsMd.get(actionName);
     if (!actionMd)
-      throw new import_js_format4.Errorf("Action %s.%s has no metadata.", ctor.name, actionName);
+      throw new import_js_format3.Errorf("Action %s.%s has no metadata.", ctor.name, actionName);
     let res = [];
     if (actionMd.after)
       res = Array.isArray(actionMd.after) ? actionMd.after : [actionMd.after];
@@ -836,11 +824,12 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
    * @protected
    */
   createRouteHandler(controllerCtor, actionName) {
-    const debug = this.debug.bind(this.createRouteHandler.name);
+    const debug = this.getDebuggerFor(this.createRouteHandler);
     debug("Creating route handler for %s.%s.", controllerCtor.name, actionName);
     const requestContextMetadataMap = RequestContextReflector.getMetadata(controllerCtor, actionName);
     const requestDataMetadataMap = RequestDataReflector.getMetadata(controllerCtor, actionName);
     const argsNumber = controllerCtor.prototype[actionName].length;
+    const defaultsApplier = this.getService(import_ts_data_schema4.DefaultValuesApplier);
     const dataTypeCaster = this.getService(import_ts_data_schema3.DataTypeCaster);
     const dataValidator = this.getService(import_ts_data_schema2.DataValidator);
     return (requestContext2) => {
@@ -885,13 +874,15 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
           }
           debug("Request data source is %v.", requestDataMd.source);
           if (requestDataMd.schema) {
+            data = defaultsApplier.applyDefaultValuesIfNeeded(data, requestDataMd.schema, requestDataMd.source);
+            debug("Default values applied.");
             data = dataTypeCaster.cast(data, requestDataMd.schema, {
               noTypeCastError: true,
               sourcePath: requestDataMd.source
             });
-            debug("Data type casting is passed.");
+            debug("Data type casting applied.");
             dataValidator.validate(data, requestDataMd.schema, requestDataMd.source);
-            debug("Data validation is passed.");
+            debug("Data validation passed.");
           }
           if (requestDataMd.property == null) {
             debug("Request data property is not specified.");
@@ -908,8 +899,8 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
           debug("No RequestDataMetadata specified for %v argument.", index);
         }
       });
-      const controller2 = this.getService(controllerCtor);
-      return controller2[actionName](...args);
+      const controller = this.getService(controllerCtor);
+      return controller[actionName](...args);
     };
   }
 };
@@ -939,47 +930,46 @@ __name(_RestRouter, "RestRouter");
 var RestRouter = _RestRouter;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ACTIONS_METADATA_KEY,
-  AFTER_METADATA_KEY,
-  ActionReflector,
-  AfterReflector,
-  BEFORE_METADATA_KEY,
-  BeforeReflector,
-  CONTROLLER_METADATA_KEY,
-  ControllerReflector,
+  AFTER_ACTION_METADATA_KEY,
+  AfterActionReflector,
+  BEFORE_ACTION_METADATA_KEY,
+  BeforeActionReflector,
   ControllerRegistry,
   NotAControllerError,
   REQUEST_CONTEXT_METADATA_KEY,
   REQUEST_DATA_METADATA_KEY,
+  REST_ACTIONS_METADATA_KEY,
+  REST_CONTROLLER_METADATA_KEY,
   RequestContextReflector,
   RequestDataReflector,
   RequestDataSource,
+  RestActionReflector,
+  RestControllerReflector,
   RestRouter,
-  action,
-  after,
-  before,
-  body,
+  afterAction,
+  beforeAction,
   capitalize,
-  controller,
-  cookie,
-  cookies,
-  createDebugger,
   createError,
-  del,
-  field,
-  get,
-  header,
-  headers,
-  param,
-  params,
-  patch,
-  post,
-  put,
-  queries,
-  query,
-  request,
+  deleteAction,
+  getAction,
+  httpRequest,
+  httpResponse,
+  patchAction,
+  postAction,
+  putAction,
+  requestBody,
   requestContext,
+  requestCookie,
+  requestCookies,
   requestData,
-  response,
+  requestField,
+  requestHeader,
+  requestHeaders,
+  requestParam,
+  requestParams,
+  requestQueries,
+  requestQuery,
+  restAction,
+  restController,
   toCamelCase
 });