@modern-js/bff-core 2.5.0 → 2.5.1-alpha.1

package/dist/cjs/client/generate-client.js

@@ -34,12 +34,14 @@ const DEFAULT_CLIENT_REQUEST_CREATOR = "@modern-js/create-request";
 const generateClient = async ({
   resourcePath,
   apiDir,
+  lambdaDir,
   prefix,
   port,
   target,
   requestCreator,
   fetcher,
-  requireResolve = require.resolve
+  requireResolve = require.resolve,
+  httpMethodDecider
 }) => {
   if (!requestCreator) {
     requestCreator = requireResolve(
@@ -58,7 +60,9 @@ const generateClient = async ({
   }
   const apiRouter = new import_router.ApiRouter({
     apiDir,
-    prefix
+    lambdaDir,
+    prefix,
+    httpMethodDecider
   });
   const handlerInfos = apiRouter.getSingleModuleHandlers(resourcePath);
   if (!handlerInfos) {
@@ -73,7 +77,7 @@ const generateClient = async ({
     }
     const upperHttpMethod = httpMethod.toUpperCase();
     const routeName = routePath;
-    handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', ${process.env.PORT || String(port)}${fetcher ? `, fetch` : ""});
+    handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', '${httpMethodDecider}', ${process.env.PORT || String(port)}${fetcher ? `, fetch` : ""});
 `;
   }
   const importCode = `import { createRequest } from '${requestCreator}';

package/dist/cjs/index.js

@@ -21,9 +21,11 @@ __export(src_exports, {
   Api: () => import_api.Api,
   HANDLER_WITH_META: () => import_utils.HANDLER_WITH_META,
   HttpError: () => import_http.HttpError,
+  INPUT_PARAMS_DECIDER: () => import_utils.INPUT_PARAMS_DECIDER,
   ValidationError: () => import_http.ValidationError,
   createStorage: () => import_utils.createStorage,
   getRelativeRuntimePath: () => import_utils.getRelativeRuntimePath,
+  isInputParamsDeciderHandler: () => import_utils.isInputParamsDeciderHandler,
   isWithMetaHandler: () => import_utils.isWithMetaHandler,
   registerPaths: () => import_utils.registerPaths
 });
@@ -40,9 +42,11 @@ var import_utils = require("./utils");
   Api,
   HANDLER_WITH_META,
   HttpError,
+  INPUT_PARAMS_DECIDER,
   ValidationError,
   createStorage,
   getRelativeRuntimePath,
+  isInputParamsDeciderHandler,
   isWithMetaHandler,
   registerPaths
 });

package/dist/cjs/operators/http.js

@@ -1,6 +1,8 @@
+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 __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var http_exports = {};
 __export(http_exports, {
@@ -42,7 +48,7 @@ const validateInput = async (schema, input) => {
   try {
     return await schema.parseAsync(input);
   } catch (error) {
-    const { z: zod } = require("zod");
+    const { z: zod } = await Promise.resolve().then(() => __toESM(require("zod")));
     if (error instanceof zod.ZodError) {
       throw new import_http.ValidationError(400, error.message);
     }

package/dist/cjs/router/index.js

@@ -40,7 +40,8 @@ class ApiRouter {
   constructor({
     apiDir,
     lambdaDir,
-    prefix
+    prefix,
+    httpMethodDecider = "functionName"
   }) {
     this.apiFiles = [];
     this.getExactApiMode = (apiDir) => {
@@ -66,6 +67,7 @@ class ApiRouter {
     this.prefix = this.initPrefix(prefix);
     this.apiDir = apiDir;
     this.apiMode = this.getExactApiMode(apiDir);
+    this.httpMethodDecider = httpMethodDecider;
     this.lambdaDir = lambdaDir || this.getExactLambdaDir(this.apiDir);
     this.existLambdaDir = import_utils.fs.existsSync(this.lambdaDir);
   }
@@ -126,7 +128,14 @@ class ApiRouter {
         return trigger.path;
       }
     }
-    const routePath = (0, import_utils3.getPathFromFilename)(this.lambdaDir, filename);
+    let routePath = (0, import_utils3.getPathFromFilename)(this.lambdaDir, filename);
+    if (this.httpMethodDecider === "inputParams") {
+      if (routePath.endsWith("/")) {
+        routePath += `${handler == null ? void 0 : handler.name}`;
+      } else {
+        routePath += `/${handler == null ? void 0 : handler.name}`;
+      }
+    }
     return routePath;
   }
   getHttpMethod(originHandlerName, handler) {
@@ -136,33 +145,44 @@ class ApiRouter {
         return trigger.method;
       }
     }
-    const upperName = originHandlerName.toUpperCase();
-    switch (upperName) {
-      case "GET":
-        return import_types.HttpMethod.Get;
-      case "POST":
-        return import_types.HttpMethod.Post;
-      case "PUT":
-        return import_types.HttpMethod.Put;
-      case "DELETE":
-      case "DEL":
-        return import_types.HttpMethod.Delete;
-      case "CONNECT":
-        return import_types.HttpMethod.Connect;
-      case "TRACE":
-        return import_types.HttpMethod.Trace;
-      case "PATCH":
-        return import_types.HttpMethod.Patch;
-      case "OPTION":
-        return import_types.HttpMethod.Option;
-      case "DEFAULT": {
-        return import_types.HttpMethod.Get;
+    if (this.httpMethodDecider === "functionName") {
+      const upperName = originHandlerName.toUpperCase();
+      switch (upperName) {
+        case "GET":
+          return import_types.HttpMethod.Get;
+        case "POST":
+          return import_types.HttpMethod.Post;
+        case "PUT":
+          return import_types.HttpMethod.Put;
+        case "DELETE":
+        case "DEL":
+          return import_types.HttpMethod.Delete;
+        case "CONNECT":
+          return import_types.HttpMethod.Connect;
+        case "TRACE":
+          return import_types.HttpMethod.Trace;
+        case "PATCH":
+          return import_types.HttpMethod.Patch;
+        case "OPTION":
+          return import_types.HttpMethod.Option;
+        case "DEFAULT": {
+          return import_types.HttpMethod.Get;
+        }
+        default:
+          if (process.env.NODE_ENV !== "test") {
+            import_utils.logger.warn(
+              `Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`
+            );
+          }
+          return null;
       }
-      default:
-        import_utils.logger.warn(
-          `Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`
-        );
+    } else {
+      if (!handler)
         return null;
+      if (typeof handler === "function" && handler.length > 0) {
+        return import_types.HttpMethod.Post;
+      }
+      return import_types.HttpMethod.Get;
     }
   }
   loadApiFiles() {
@@ -231,8 +251,14 @@ class ApiRouter {
   }
   getModuleHandlerInfos(moduleInfo) {
     const { module: module2, filename } = moduleInfo;
+    const { httpMethodDecider } = this;
     return Object.entries(module2).filter(([, handler]) => typeof handler === "function").map(([key]) => {
       const handler = module2[key];
+      if (httpMethodDecider === "inputParams") {
+        Object.assign(handler, {
+          [import_utils2.INPUT_PARAMS_DECIDER]: true
+        });
+      }
       const handlerInfo = this.getHandlerInfo(filename, key, handler);
       return handlerInfo;
     }).filter((handlerInfo) => Boolean(handlerInfo));

package/dist/cjs/utils/meta.js

@@ -18,15 +18,23 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var meta_exports = {};
 __export(meta_exports, {
   HANDLER_WITH_META: () => HANDLER_WITH_META,
+  INPUT_PARAMS_DECIDER: () => INPUT_PARAMS_DECIDER,
+  isInputParamsDeciderHandler: () => isInputParamsDeciderHandler,
   isWithMetaHandler: () => isWithMetaHandler
 });
 module.exports = __toCommonJS(meta_exports);
 const HANDLER_WITH_META = "HANDLER_WITH_META";
+const INPUT_PARAMS_DECIDER = "INPUT_PARAMS_DECIDER";
 const isWithMetaHandler = (handler) => {
   return typeof handler === "function" && handler[HANDLER_WITH_META];
 };
+const isInputParamsDeciderHandler = (handler) => {
+  return typeof handler === "function" && handler[INPUT_PARAMS_DECIDER];
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HANDLER_WITH_META,
+  INPUT_PARAMS_DECIDER,
+  isInputParamsDeciderHandler,
   isWithMetaHandler
 });

package/dist/esm/client/generate-client.js

@@ -5,12 +5,14 @@ const DEFAULT_CLIENT_REQUEST_CREATOR = "@modern-js/create-request";
 const generateClient = async ({
   resourcePath,
   apiDir,
+  lambdaDir,
   prefix,
   port,
   target,
   requestCreator,
   fetcher,
-  requireResolve = require.resolve
+  requireResolve = require.resolve,
+  httpMethodDecider
 }) => {
   if (!requestCreator) {
     requestCreator = requireResolve(
@@ -29,7 +31,9 @@ const generateClient = async ({
   }
   const apiRouter = new ApiRouter({
     apiDir,
-    prefix
+    lambdaDir,
+    prefix,
+    httpMethodDecider
   });
   const handlerInfos = apiRouter.getSingleModuleHandlers(resourcePath);
   if (!handlerInfos) {
@@ -44,7 +48,7 @@ const generateClient = async ({
     }
     const upperHttpMethod = httpMethod.toUpperCase();
     const routeName = routePath;
-    handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', ${process.env.PORT || String(port)}${fetcher ? `, fetch` : ""});
+    handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', '${httpMethodDecider}', ${process.env.PORT || String(port)}${fetcher ? `, fetch` : ""});
 `;
   }
   const importCode = `import { createRequest } from '${requestCreator}';

package/dist/esm/index.js

@@ -8,6 +8,8 @@ import {
   getRelativeRuntimePath,
   HANDLER_WITH_META,
   isWithMetaHandler,
+  INPUT_PARAMS_DECIDER,
+  isInputParamsDeciderHandler,
   createStorage,
   registerPaths
 } from "./utils";
@@ -15,9 +17,11 @@ export {
   Api,
   HANDLER_WITH_META,
   HttpError,
+  INPUT_PARAMS_DECIDER,
   ValidationError,
   createStorage,
   getRelativeRuntimePath,
+  isInputParamsDeciderHandler,
   isWithMetaHandler,
   registerPaths
 };

package/dist/esm/operators/http.js

@@ -10,7 +10,7 @@ const validateInput = async (schema, input) => {
   try {
     return await schema.parseAsync(input);
   } catch (error) {
-    const { z: zod } = require("zod");
+    const { z: zod } = await import("zod");
     if (error instanceof zod.ZodError) {
       throw new ValidationError(400, error.message);
     }

package/dist/esm/router/index.js

@@ -2,7 +2,7 @@ import path from "path";
 import { fs, logger } from "@modern-js/utils";
 import "reflect-metadata";
 import { HttpMethod, httpMethods, OperatorType, TriggerType } from "../types";
-import { debug } from "../utils";
+import { debug, INPUT_PARAMS_DECIDER } from "../utils";
 import {
   APIMode,
   FRAMEWORK_MODE_LAMBDA_DIR,
@@ -21,7 +21,8 @@ class ApiRouter {
   constructor({
     apiDir,
     lambdaDir,
-    prefix
+    prefix,
+    httpMethodDecider = "functionName"
   }) {
     this.apiFiles = [];
     this.getExactApiMode = (apiDir) => {
@@ -47,6 +48,7 @@ class ApiRouter {
     this.prefix = this.initPrefix(prefix);
     this.apiDir = apiDir;
     this.apiMode = this.getExactApiMode(apiDir);
+    this.httpMethodDecider = httpMethodDecider;
     this.lambdaDir = lambdaDir || this.getExactLambdaDir(this.apiDir);
     this.existLambdaDir = fs.existsSync(this.lambdaDir);
   }
@@ -107,7 +109,14 @@ class ApiRouter {
         return trigger.path;
       }
     }
-    const routePath = getPathFromFilename(this.lambdaDir, filename);
+    let routePath = getPathFromFilename(this.lambdaDir, filename);
+    if (this.httpMethodDecider === "inputParams") {
+      if (routePath.endsWith("/")) {
+        routePath += `${handler == null ? void 0 : handler.name}`;
+      } else {
+        routePath += `/${handler == null ? void 0 : handler.name}`;
+      }
+    }
     return routePath;
   }
   getHttpMethod(originHandlerName, handler) {
@@ -117,33 +126,44 @@ class ApiRouter {
         return trigger.method;
       }
     }
-    const upperName = originHandlerName.toUpperCase();
-    switch (upperName) {
-      case "GET":
-        return HttpMethod.Get;
-      case "POST":
-        return HttpMethod.Post;
-      case "PUT":
-        return HttpMethod.Put;
-      case "DELETE":
-      case "DEL":
-        return HttpMethod.Delete;
-      case "CONNECT":
-        return HttpMethod.Connect;
-      case "TRACE":
-        return HttpMethod.Trace;
-      case "PATCH":
-        return HttpMethod.Patch;
-      case "OPTION":
-        return HttpMethod.Option;
-      case "DEFAULT": {
-        return HttpMethod.Get;
+    if (this.httpMethodDecider === "functionName") {
+      const upperName = originHandlerName.toUpperCase();
+      switch (upperName) {
+        case "GET":
+          return HttpMethod.Get;
+        case "POST":
+          return HttpMethod.Post;
+        case "PUT":
+          return HttpMethod.Put;
+        case "DELETE":
+        case "DEL":
+          return HttpMethod.Delete;
+        case "CONNECT":
+          return HttpMethod.Connect;
+        case "TRACE":
+          return HttpMethod.Trace;
+        case "PATCH":
+          return HttpMethod.Patch;
+        case "OPTION":
+          return HttpMethod.Option;
+        case "DEFAULT": {
+          return HttpMethod.Get;
+        }
+        default:
+          if (process.env.NODE_ENV !== "test") {
+            logger.warn(
+              `Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`
+            );
+          }
+          return null;
       }
-      default:
-        logger.warn(
-          `Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`
-        );
+    } else {
+      if (!handler)
         return null;
+      if (typeof handler === "function" && handler.length > 0) {
+        return HttpMethod.Post;
+      }
+      return HttpMethod.Get;
     }
   }
   loadApiFiles() {
@@ -212,8 +232,14 @@ class ApiRouter {
   }
   getModuleHandlerInfos(moduleInfo) {
     const { module, filename } = moduleInfo;
+    const { httpMethodDecider } = this;
     return Object.entries(module).filter(([, handler]) => typeof handler === "function").map(([key]) => {
       const handler = module[key];
+      if (httpMethodDecider === "inputParams") {
+        Object.assign(handler, {
+          [INPUT_PARAMS_DECIDER]: true
+        });
+      }
       const handlerInfo = this.getHandlerInfo(filename, key, handler);
       return handlerInfo;
     }).filter((handlerInfo) => Boolean(handlerInfo));

package/dist/esm/utils/meta.js

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

package/dist/js/modern/api.js

@@ -0,0 +1,69 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import "reflect-metadata";
+import compose from "koa-compose";
+import { validateFunction, HANDLER_WITH_META } from "./utils";
+function Api(...args) {
+  const handler = args.pop();
+  validateFunction(handler, "Apihandler");
+  const operators = args;
+  const metadataHelper = {
+    getMetadata(key) {
+      return Reflect.getMetadata(key, runner);
+    },
+    setMetadata(key, value) {
+      return Reflect.defineMetadata(key, value, runner);
+    }
+  };
+  for (const operator of operators) {
+    if (operator.metadata) {
+      operator.metadata(metadataHelper);
+    }
+  }
+  const validateHandlers = operators.filter((operator) => operator.validate).map((operator) => operator.validate);
+  const pipeHandlers = operators.filter((operator) => operator.execute).map((operator) => operator.execute);
+  function runner(inputs) {
+    return __async(this, null, function* () {
+      const executeHelper = {
+        result: null,
+        get inputs() {
+          return inputs;
+        },
+        set inputs(val) {
+          inputs = val;
+        }
+      };
+      const stack = [...validateHandlers, ...pipeHandlers];
+      stack.push((helper, next) => __async(this, null, function* () {
+        const res = yield handler(helper.inputs);
+        helper.result = res;
+        return next();
+      }));
+      yield compose(stack)(executeHelper);
+      return executeHelper.result;
+    });
+  }
+  runner[HANDLER_WITH_META] = true;
+  return runner;
+}
+export {
+  Api
+};

package/dist/js/modern/client/generate-client.js

@@ -0,0 +1,79 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import * as path from "path";
+import { ApiRouter } from "../router";
+import { Ok, Err } from "./result";
+const DEFAULT_CLIENT_REQUEST_CREATOR = "@modern-js/create-request";
+const generateClient = (_0) => __async(void 0, [_0], function* ({
+  resourcePath,
+  apiDir,
+  prefix,
+  port,
+  target,
+  requestCreator,
+  fetcher,
+  requireResolve = require.resolve
+}) {
+  if (!requestCreator) {
+    requestCreator = requireResolve(
+      `${DEFAULT_CLIENT_REQUEST_CREATOR}${target ? `/${target}` : ""}`
+    ).replace(/\\/g, "/");
+  } else {
+    let resolvedPath = requestCreator;
+    try {
+      resolvedPath = path.dirname(requireResolve(requestCreator));
+    } catch (error) {
+    }
+    requestCreator = `${resolvedPath}${target ? `/${target}` : ""}`.replace(
+      /\\/g,
+      "/"
+    );
+  }
+  const apiRouter = new ApiRouter({
+    apiDir,
+    prefix
+  });
+  const handlerInfos = apiRouter.getSingleModuleHandlers(resourcePath);
+  if (!handlerInfos) {
+    return Err(`generate client error: Cannot require module ${resourcePath}`);
+  }
+  let handlersCode = "";
+  for (const handlerInfo of handlerInfos) {
+    const { name, httpMethod, routePath } = handlerInfo;
+    let exportStatement = `const ${name} =`;
+    if (name.toLowerCase() === "default") {
+      exportStatement = "default";
+    }
+    const upperHttpMethod = httpMethod.toUpperCase();
+    const routeName = routePath;
+    handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', ${process.env.PORT || String(port)}${fetcher ? `, fetch` : ""});
+`;
+  }
+  const importCode = `import { createRequest } from '${requestCreator}';
+${fetcher ? `import { fetch } from '${fetcher}';
+` : ""}`;
+  return Ok(`${importCode}
+${handlersCode}`);
+});
+export {
+  DEFAULT_CLIENT_REQUEST_CREATOR,
+  generateClient
+};

package/dist/js/modern/client/index.js

@@ -0,0 +1 @@
+export * from "./generate-client";

package/dist/js/modern/client/result.js

@@ -0,0 +1,22 @@
+const Err = (value) => {
+  const err = {
+    kind: "Err",
+    value,
+    isErr: true,
+    isOk: false
+  };
+  return err;
+};
+const Ok = (value) => {
+  const ok = {
+    kind: "Ok",
+    value,
+    isErr: false,
+    isOk: true
+  };
+  return ok;
+};
+export {
+  Err,
+  Ok
+};

package/dist/js/modern/errors/http.js

@@ -0,0 +1,16 @@
+class HttpError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+class ValidationError extends HttpError {
+  constructor(status, message) {
+    super(status, message);
+    this.code = "VALIDATION_ERROR";
+  }
+}
+export {
+  HttpError,
+  ValidationError
+};

package/dist/js/modern/index.js

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