@modern-js/bff-core 2.15.0 → 2.17.0

package/dist/esm/errors/http.js

@@ -1,16 +1,27 @@
-class HttpError extends Error {
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+export class HttpError extends Error {
   constructor(status, message) {
     super(message);
+    _define_property(this, "status", void 0);
     this.status = status;
   }
 }
-class ValidationError extends HttpError {
+export class ValidationError extends HttpError {
   constructor(status, message) {
     super(status, message);
+    _define_property(this, "code", void 0);
     this.code = "VALIDATION_ERROR";
   }
 }
-export {
-  HttpError,
-  ValidationError
-};

package/dist/esm/index.js

@@ -1,27 +1,7 @@
-import { Api } from "./api";
-import { HttpError, ValidationError } from "./errors/http";
+export { Api } from "./api";
+export { HttpError, ValidationError } from "./errors/http";
 export * from "./router";
 export * from "./types";
 export * from "./client";
 export * from "./operators/http";
-import {
-  getRelativeRuntimePath,
-  HANDLER_WITH_META,
-  isWithMetaHandler,
-  INPUT_PARAMS_DECIDER,
-  isInputParamsDeciderHandler,
-  createStorage,
-  registerPaths
-} from "./utils";
-export {
-  Api,
-  HANDLER_WITH_META,
-  HttpError,
-  INPUT_PARAMS_DECIDER,
-  ValidationError,
-  createStorage,
-  getRelativeRuntimePath,
-  isInputParamsDeciderHandler,
-  isWithMetaHandler,
-  registerPaths
-};
+export { getRelativeRuntimePath, HANDLER_WITH_META, isWithMetaHandler, INPUT_PARAMS_DECIDER, isInputParamsDeciderHandler, createStorage, registerPaths } from "./utils";

package/dist/esm/operators/http.js

@@ -1,10 +1,4 @@
-import {
-  HttpMetadata,
-  OperatorType,
-  HttpMethod,
-  TriggerType,
-  ResponseMetaType
-} from "../types";
+import { HttpMetadata, OperatorType, HttpMethod, TriggerType, ResponseMetaType } from "../types";
 import { ValidationError } from "../errors/http";
 const validateInput = async (schema, input) => {
   try {
@@ -17,7 +11,7 @@ const validateInput = async (schema, input) => {
     throw error;
   }
 };
-const createHttpOperator = (method) => {
+export const createHttpOperator = (method) => {
   return (urlPath) => {
     return {
       name: method,
@@ -31,25 +25,23 @@ const createHttpOperator = (method) => {
     };
   };
 };
-const Get = createHttpOperator(HttpMethod.Get);
-const Post = createHttpOperator(HttpMethod.Post);
-const Put = createHttpOperator(HttpMethod.Put);
-const Delete = createHttpOperator(HttpMethod.Delete);
-const Connect = createHttpOperator(HttpMethod.Connect);
-const Trace = createHttpOperator(HttpMethod.Trace);
-const Patch = createHttpOperator(HttpMethod.Patch);
-const Options = createHttpOperator(HttpMethod.Options);
-const Head = createHttpOperator(HttpMethod.Head);
-const Data = (schema) => {
+export const Get = createHttpOperator(HttpMethod.Get);
+export const Post = createHttpOperator(HttpMethod.Post);
+export const Put = createHttpOperator(HttpMethod.Put);
+export const Delete = createHttpOperator(HttpMethod.Delete);
+export const Connect = createHttpOperator(HttpMethod.Connect);
+export const Trace = createHttpOperator(HttpMethod.Trace);
+export const Patch = createHttpOperator(HttpMethod.Patch);
+export const Options = createHttpOperator(HttpMethod.Options);
+export const Head = createHttpOperator(HttpMethod.Head);
+export const Data = (schema) => {
   return {
     name: HttpMetadata.Data,
     metadata({ setMetadata }) {
       setMetadata(HttpMetadata.Data, schema);
     },
     async validate(helper, next) {
-      const {
-        inputs: { data }
-      } = helper;
+      const { inputs: { data } } = helper;
       helper.inputs = {
         ...helper.inputs,
         data: await validateInput(schema, data)
@@ -58,16 +50,14 @@ const Data = (schema) => {
     }
   };
 };
-const Query = (schema) => {
+export const Query = (schema) => {
   return {
     name: HttpMetadata.Query,
     metadata({ setMetadata }) {
       setMetadata(HttpMetadata.Query, schema);
     },
     async validate(helper, next) {
-      const {
-        inputs: { query }
-      } = helper;
+      const { inputs: { query } } = helper;
       helper.inputs = {
         ...helper.inputs,
         query: await validateInput(schema, query)
@@ -76,16 +66,14 @@ const Query = (schema) => {
     }
   };
 };
-const Params = (schema) => {
+export const Params = (schema) => {
   return {
     name: HttpMetadata.Params,
     metadata({ setMetadata }) {
       setMetadata(HttpMetadata.Params, schema);
     },
     async validate(helper, next) {
-      const {
-        inputs: { params }
-      } = helper;
+      const { inputs: { params } } = helper;
       helper.inputs = {
         ...helper.inputs,
         params: await validateInput(schema, params)
@@ -94,16 +82,14 @@ const Params = (schema) => {
     }
   };
 };
-const Headers = (schema) => {
+export const Headers = (schema) => {
   return {
     name: HttpMetadata.Headers,
     metadata({ setMetadata }) {
       setMetadata(HttpMetadata.Headers, schema);
     },
     async validate(helper, next) {
-      const {
-        inputs: { headers }
-      } = helper;
+      const { inputs: { headers } } = helper;
       helper.inputs = {
         ...helper.inputs,
         headers: await validateInput(schema, headers)
@@ -122,7 +108,7 @@ const setResponseMeta = (helper, type, value) => {
     }
   ]);
 };
-const HttpCode = (statusCode) => {
+export const HttpCode = (statusCode) => {
   return {
     name: "HttpCode",
     metadata(helper) {
@@ -130,7 +116,7 @@ const HttpCode = (statusCode) => {
     }
   };
 };
-const SetHeaders = (headers) => {
+export const SetHeaders = (headers) => {
   return {
     name: "SetHeaders",
     metadata(helper) {
@@ -138,7 +124,7 @@ const SetHeaders = (headers) => {
     }
   };
 };
-const Redirect = (url) => {
+export const Redirect = (url) => {
   return {
     name: "Redirect",
     metadata(helper) {
@@ -146,22 +132,3 @@ const Redirect = (url) => {
     }
   };
 };
-export {
-  Connect,
-  Data,
-  Delete,
-  Get,
-  Head,
-  Headers,
-  HttpCode,
-  Options,
-  Params,
-  Patch,
-  Post,
-  Put,
-  Query,
-  Redirect,
-  SetHeaders,
-  Trace,
-  createHttpOperator
-};

package/dist/esm/router/constants.js

@@ -1,15 +1,25 @@
 import { HttpMethod } from "../types";
-const AllHttpMethods = Object.values(HttpMethod);
-var APIMode = /* @__PURE__ */ ((APIMode2) => {
-  APIMode2["FARMEWORK"] = "framework";
-  APIMode2["FUNCTION"] = "function";
-  return APIMode2;
-})(APIMode || {});
-const FRAMEWORK_MODE_LAMBDA_DIR = "lambda";
-const FRAMEWORK_MODE_APP_DIR = "app";
-const INDEX_SUFFIX = "index";
-const API_DIR = "api";
-const API_FILE_RULES = [
+export const AllHttpMethods = Object.values(HttpMethod);
+export var APIMode;
+(function(APIMode2) {
+  APIMode2[
+    /**
+    * 框架模式
+    */
+    "FARMEWORK"
+  ] = "framework";
+  APIMode2[
+    /**
+    * 函数模式
+    */
+    "FUNCTION"
+  ] = "function";
+})(APIMode || (APIMode = {}));
+export const FRAMEWORK_MODE_LAMBDA_DIR = "lambda";
+export const FRAMEWORK_MODE_APP_DIR = "app";
+export const INDEX_SUFFIX = "index";
+export const API_DIR = "api";
+export const API_FILE_RULES = [
   "**/*.[tj]s",
   "!**/_*",
   "!**/_*/**/*.[tj]s",
@@ -21,12 +31,3 @@ const API_FILE_RULES = [
   "!node_modules/**",
   "!bootstrap.js"
 ];
-export {
-  APIMode,
-  API_DIR,
-  API_FILE_RULES,
-  AllHttpMethods,
-  FRAMEWORK_MODE_APP_DIR,
-  FRAMEWORK_MODE_LAMBDA_DIR,
-  INDEX_SUFFIX
-};

package/dist/esm/router/index.js

@@ -1,57 +1,26 @@
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 import path from "path";
 import { fs, logger } from "@modern-js/utils";
 import "reflect-metadata";
 import { HttpMethod, httpMethods, OperatorType, TriggerType } from "../types";
 import { debug, INPUT_PARAMS_DECIDER } from "../utils";
-import {
-  APIMode,
-  FRAMEWORK_MODE_LAMBDA_DIR,
-  API_FILE_RULES,
-  FRAMEWORK_MODE_APP_DIR
-} from "./constants";
-import {
-  getFiles,
-  getPathFromFilename,
-  requireHandlerModule,
-  sortRoutes
-} from "./utils";
+import { APIMode, FRAMEWORK_MODE_LAMBDA_DIR, API_FILE_RULES, FRAMEWORK_MODE_APP_DIR } from "./constants";
+import { getFiles, getPathFromFilename, requireHandlerModule, sortRoutes } from "./utils";
 export * from "./types";
 export * from "./constants";
-class ApiRouter {
-  constructor({
-    apiDir,
-    lambdaDir,
-    prefix,
-    httpMethodDecider = "functionName"
-  }) {
-    this.apiFiles = [];
-    this.getExactApiMode = (apiDir, lambdaDir) => {
-      const exist = this.createExistChecker(apiDir);
-      const existLambdaDir = lambdaDir && fs.pathExistsSync(lambdaDir) || exist(FRAMEWORK_MODE_LAMBDA_DIR);
-      const existAppDir = exist(FRAMEWORK_MODE_APP_DIR);
-      const existAppFile = exist("app.ts") || exist("app.js");
-      if (existLambdaDir || existAppDir || existAppFile) {
-        return APIMode.FARMEWORK;
-      }
-      return APIMode.FUNCTION;
-    };
-    this.createExistChecker = (base) => (target) => fs.pathExistsSync(path.resolve(base, target));
-    this.getExactLambdaDir = (apiDir, originLambdaDir) => {
-      if (this.apiMode === APIMode.FUNCTION) {
-        return apiDir;
-      }
-      return originLambdaDir || path.join(apiDir, FRAMEWORK_MODE_LAMBDA_DIR);
-    };
-    this.validateAbsolute(apiDir, "apiDir");
-    this.validateAbsolute(lambdaDir, "lambdaDir");
-    this.prefix = this.initPrefix(prefix);
-    this.apiDir = apiDir;
-    this.httpMethodDecider = httpMethodDecider;
-    this.apiMode = this.getExactApiMode(apiDir, lambdaDir);
-    this.lambdaDir = this.getExactLambdaDir(this.apiDir, lambdaDir);
-    this.existLambdaDir = fs.existsSync(this.lambdaDir);
-    debug(`apiDir:`, this.apiDir, `lambdaDir:`, this.lambdaDir);
-  }
+export class ApiRouter {
   isExistLambda() {
     return this.existLambdaDir;
   }
@@ -100,9 +69,7 @@ class ApiRouter {
       const trigger = Reflect.getMetadata(OperatorType.Trigger, handler);
       if (trigger && trigger.type === TriggerType.Http) {
         if (!trigger.path) {
-          throw new Error(
-            `The http trigger ${trigger.name} needs to specify a path`
-          );
+          throw new Error(`The http trigger ${trigger.name} needs to specify a path`);
         }
         return trigger.path;
       }
@@ -110,9 +77,9 @@ class ApiRouter {
     let routePath = getPathFromFilename(this.lambdaDir, filename);
     if (this.httpMethodDecider === "inputParams") {
       if (routePath.endsWith("/")) {
-        routePath += `${handler == null ? void 0 : handler.name}`;
+        routePath += `${handler === null || handler === void 0 ? void 0 : handler.name}`;
       } else {
-        routePath += `/${handler == null ? void 0 : handler.name}`;
+        routePath += `/${handler === null || handler === void 0 ? void 0 : handler.name}`;
       }
     }
     return routePath;
@@ -149,9 +116,7 @@ class ApiRouter {
         }
         default:
           if (process.env.NODE_ENV !== "test") {
-            logger.warn(
-              `Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`
-            );
+            logger.warn(`Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`);
           }
           return null;
       }
@@ -189,9 +154,9 @@ class ApiRouter {
     return apiHandlers;
   }
   /**
-   * 如果用户未传入或传入空串，默认为 /api
-   * 如果传入 /，则 prefix 为 /
-   */
+  * 如果用户未传入或传入空串，默认为 /api
+  * 如果传入 /，则 prefix 为 /
+  */
   initPrefix(prefix) {
     if (prefix === "/") {
       return "";
@@ -259,7 +224,39 @@ class ApiRouter {
     }
     return `${prefix}${finalRouteName}`;
   }
+  constructor({ apiDir, lambdaDir, prefix, httpMethodDecider = "functionName" }) {
+    _define_property(this, "apiMode", void 0);
+    _define_property(this, "apiDir", void 0);
+    _define_property(this, "existLambdaDir", void 0);
+    _define_property(this, "httpMethodDecider", void 0);
+    _define_property(this, "lambdaDir", void 0);
+    _define_property(this, "prefix", void 0);
+    _define_property(this, "apiFiles", []);
+    _define_property(this, "getExactApiMode", (apiDir2, lambdaDir2) => {
+      const exist = this.createExistChecker(apiDir2);
+      const existLambdaDir = lambdaDir2 && fs.pathExistsSync(lambdaDir2) || exist(FRAMEWORK_MODE_LAMBDA_DIR);
+      const existAppDir = exist(FRAMEWORK_MODE_APP_DIR);
+      const existAppFile = exist("app.ts") || exist("app.js");
+      if (existLambdaDir || existAppDir || existAppFile) {
+        return APIMode.FARMEWORK;
+      }
+      return APIMode.FUNCTION;
+    });
+    _define_property(this, "createExistChecker", (base) => (target) => fs.pathExistsSync(path.resolve(base, target)));
+    _define_property(this, "getExactLambdaDir", (apiDir2, originLambdaDir) => {
+      if (this.apiMode === APIMode.FUNCTION) {
+        return apiDir2;
+      }
+      return originLambdaDir || path.join(apiDir2, FRAMEWORK_MODE_LAMBDA_DIR);
+    });
+    this.validateAbsolute(apiDir, "apiDir");
+    this.validateAbsolute(lambdaDir, "lambdaDir");
+    this.prefix = this.initPrefix(prefix);
+    this.apiDir = apiDir;
+    this.httpMethodDecider = httpMethodDecider;
+    this.apiMode = this.getExactApiMode(apiDir, lambdaDir);
+    this.lambdaDir = this.getExactLambdaDir(this.apiDir, lambdaDir);
+    this.existLambdaDir = fs.existsSync(this.lambdaDir);
+    debug(`apiDir:`, this.apiDir, `lambdaDir:`, this.lambdaDir);
+  }
 }
-export {
-  ApiRouter
-};

package/dist/esm/router/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/router/utils.js

@@ -1,11 +1,11 @@
 import path from "path";
 import { globby } from "@modern-js/utils";
 import { INDEX_SUFFIX } from "./constants";
-const getFiles = (lambdaDir, rules) => globby.sync(rules, {
+export const getFiles = (lambdaDir, rules) => globby.sync(rules, {
   cwd: lambdaDir,
   gitignore: true
 }).map((file) => path.resolve(lambdaDir, file));
-const getPathFromFilename = (baseDir, filename) => {
+export const getPathFromFilename = (baseDir, filename) => {
   const relativeName = filename.substring(baseDir.length);
   const relativePath = relativeName.split(".").slice(0, -1).join(".");
   const nameSplit = relativePath.split(path.sep).map((item) => {
@@ -30,7 +30,7 @@ const clearRouteName = (routeName) => {
   }
   return finalRouteName;
 };
-const isHandler = (input) => input && typeof input === "function";
+export const isHandler = (input) => input && typeof input === "function";
 const enableRegister = (requireFn) => {
   let existTsLoader = false;
   let firstCall = true;
@@ -50,7 +50,9 @@ const enableRegister = (requireFn) => {
           },
           scope: true,
           transpileOnly: true,
-          ignore: ["(?:^|/)node_modules/"]
+          ignore: [
+            "(?:^|/)node_modules/"
+          ]
         });
         existTsLoader = true;
         const tsConfigPaths = require("tsconfig-paths");
@@ -69,11 +71,13 @@ const enableRegister = (requireFn) => {
   };
 };
 const isFunction = (input) => input && {}.toString.call(input) === "[object Function]";
-const requireHandlerModule = enableRegister((modulePath) => {
+export const requireHandlerModule = enableRegister((modulePath) => {
   const originRequire = process.env.NODE_ENV === "test" ? jest.requireActual : require;
   const module = originRequire(modulePath);
   if (isFunction(module)) {
-    return { default: module };
+    return {
+      default: module
+    };
   }
   return module;
 });
@@ -83,15 +87,8 @@ const routeValue = (routePath) => {
   }
   return 1;
 };
-const sortRoutes = (apiHandlers) => {
+export const sortRoutes = (apiHandlers) => {
   return apiHandlers.sort((handlerA, handlerB) => {
     return routeValue(handlerA.routeName) - routeValue(handlerB.routeName);
   });
 };
-export {
-  getFiles,
-  getPathFromFilename,
-  isHandler,
-  requireHandlerModule,
-  sortRoutes
-};

package/dist/esm/types.js

@@ -1,28 +1,29 @@
-var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
+export var OperatorType;
+(function(OperatorType2) {
   OperatorType2[OperatorType2["Trigger"] = 0] = "Trigger";
   OperatorType2[OperatorType2["Middleware"] = 1] = "Middleware";
-  return OperatorType2;
-})(OperatorType || {});
-var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
+})(OperatorType || (OperatorType = {}));
+export var TriggerType;
+(function(TriggerType2) {
   TriggerType2[TriggerType2["Http"] = 0] = "Http";
-  return TriggerType2;
-})(TriggerType || {});
-var HttpMetadata = /* @__PURE__ */ ((HttpMetadata2) => {
+})(TriggerType || (TriggerType = {}));
+export var HttpMetadata;
+(function(HttpMetadata2) {
   HttpMetadata2["Method"] = "METHOD";
   HttpMetadata2["Data"] = "DATA";
   HttpMetadata2["Query"] = "QUERY";
   HttpMetadata2["Params"] = "PARAMS";
   HttpMetadata2["Headers"] = "HEADERS";
   HttpMetadata2["Response"] = "RESPONSE";
-  return HttpMetadata2;
-})(HttpMetadata || {});
-var ResponseMetaType = /* @__PURE__ */ ((ResponseMetaType2) => {
+})(HttpMetadata || (HttpMetadata = {}));
+export var ResponseMetaType;
+(function(ResponseMetaType2) {
   ResponseMetaType2[ResponseMetaType2["StatusCode"] = 0] = "StatusCode";
   ResponseMetaType2[ResponseMetaType2["Redirect"] = 1] = "Redirect";
   ResponseMetaType2[ResponseMetaType2["Headers"] = 2] = "Headers";
-  return ResponseMetaType2;
-})(ResponseMetaType || {});
-var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+})(ResponseMetaType || (ResponseMetaType = {}));
+export var HttpMethod;
+(function(HttpMethod2) {
   HttpMethod2["Get"] = "GET";
   HttpMethod2["Post"] = "POST";
   HttpMethod2["Put"] = "PUT";
@@ -32,14 +33,5 @@ var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
   HttpMethod2["Patch"] = "PATCH";
   HttpMethod2["Options"] = "OPTIONS";
   HttpMethod2["Head"] = "HEAD";
-  return HttpMethod2;
-})(HttpMethod || {});
-const httpMethods = Object.values(HttpMethod);
-export {
-  HttpMetadata,
-  HttpMethod,
-  OperatorType,
-  ResponseMetaType,
-  TriggerType,
-  httpMethods
-};
+})(HttpMethod || (HttpMethod = {}));
+export const httpMethods = Object.values(HttpMethod);

package/dist/esm/utils/alias.js

@@ -2,18 +2,12 @@ import * as path from "path";
 import * as os from "os";
 import fs from "fs";
 import Module from "module";
-const getRelativeRuntimePath = (appDirectory, serverRuntimePath) => {
+export const getRelativeRuntimePath = (appDirectory, serverRuntimePath) => {
   let relativeRuntimePath = "";
   if (os.platform() === "win32") {
-    relativeRuntimePath = `../${path.relative(
-      appDirectory,
-      serverRuntimePath
-    )}`;
+    relativeRuntimePath = `../${path.relative(appDirectory, serverRuntimePath)}`;
   } else {
-    relativeRuntimePath = path.join(
-      "../",
-      path.relative(appDirectory, serverRuntimePath)
-    );
+    relativeRuntimePath = path.join("../", path.relative(appDirectory, serverRuntimePath));
   }
   if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
     relativeRuntimePath = `./${path.relative(appDirectory, serverRuntimePath)}`;
@@ -23,7 +17,7 @@ const getRelativeRuntimePath = (appDirectory, serverRuntimePath) => {
 const sortByLongestPrefix = (arr) => {
   return arr.concat().sort((a, b) => b.length - a.length);
 };
-const createMatchPath = (paths) => {
+export const createMatchPath = (paths) => {
   const sortedKeys = sortByLongestPrefix(Object.keys(paths));
   const sortedPaths = {};
   sortedKeys.forEach((key) => {
@@ -36,7 +30,9 @@ const createMatchPath = (paths) => {
     if (found) {
       let foundPaths = sortedPaths[found];
       if (!Array.isArray(foundPaths)) {
-        foundPaths = [foundPaths];
+        foundPaths = [
+          foundPaths
+        ];
       }
       foundPaths = foundPaths.filter((foundPath) => path.isAbsolute(foundPath));
       for (const p of foundPaths) {
@@ -50,7 +46,7 @@ const createMatchPath = (paths) => {
     return null;
   };
 };
-const registerPaths = (paths) => {
+export const registerPaths = (paths) => {
   const originalResolveFilename = Module._resolveFilename;
   const { builtinModules } = Module;
   const matchPath = createMatchPath(paths);
@@ -59,7 +55,10 @@ const registerPaths = (paths) => {
     if (!isCoreModule) {
       const matched = matchPath(request);
       if (matched) {
-        const modifiedArguments = [matched, ...[].slice.call(arguments, 1)];
+        const modifiedArguments = [
+          matched,
+          ...[].slice.call(arguments, 1)
+        ];
         return originalResolveFilename.apply(this, modifiedArguments);
       }
     }
@@ -69,8 +68,3 @@ const registerPaths = (paths) => {
     Module._resolveFilename = originalResolveFilename;
   };
 };
-export {
-  createMatchPath,
-  getRelativeRuntimePath,
-  registerPaths
-};

package/dist/esm/utils/debug.js

@@ -1,5 +1,2 @@
 import { createDebugger } from "@modern-js/utils";
-const debug = createDebugger("bff");
-export {
-  debug
-};
+export const debug = createDebugger("bff");

package/dist/esm/utils/index.js

@@ -1,8 +1,5 @@
 export * from "./storage";
 export * from "./alias";
-import { debug } from "./debug";
+export { debug } from "./debug";
 export * from "./meta";
 export * from "./validate";
-export {
-  debug
-};

package/dist/esm/utils/meta.js

@@ -1,14 +1,8 @@
-const HANDLER_WITH_META = "HANDLER_WITH_META";
-const INPUT_PARAMS_DECIDER = "INPUT_PARAMS_DECIDER";
-const isWithMetaHandler = (handler) => {
+export const HANDLER_WITH_META = "HANDLER_WITH_META";
+export const INPUT_PARAMS_DECIDER = "INPUT_PARAMS_DECIDER";
+export const isWithMetaHandler = (handler) => {
   return typeof handler === "function" && handler[HANDLER_WITH_META];
 };
-const isInputParamsDeciderHandler = (handler) => {
+export const isInputParamsDeciderHandler = (handler) => {
   return typeof handler === "function" && handler[INPUT_PARAMS_DECIDER];
 };
-export {
-  HANDLER_WITH_META,
-  INPUT_PARAMS_DECIDER,
-  isInputParamsDeciderHandler,
-  isWithMetaHandler
-};