@modern-js/bff-core 2.6.1-alpha.1 → 2.7.1-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @modern-js/bff-core
 
+## 2.7.0
+
+### Minor Changes
+
+- 84bfb439b8: feat: support custom apiDir, lambdaDir and style of writing for bff
+  feat: 支持定制 api 目录，lambda 目录，bff 的写法
+
+### Patch Changes
+
+- 7bb1554194: fix: remove process.env.PORT from the bff generate client code
+  fix: 从 bff 的 generate client code 中移除 process.env.PORT
+- 7fff9020e1: chore: make file naming consistent
+
+  chore: 统一文件命名为小驼峰格式
+
+- 1eea234fdd: chore: make test files naming consistent
+
+  chore: 统一测试文件命名为小驼峰格式
+
+- Updated dependencies [0f15fc597c]
+- Updated dependencies [dcad887024]
+- Updated dependencies [a4672f7c16]
+- Updated dependencies [7fff9020e1]
+- Updated dependencies [84bfb439b8]
+  - @modern-js/utils@2.7.0
+  - @modern-js/bff-runtime@2.7.0
+
 ## 2.6.0
 
 ### Patch Changes

package/dist/cjs/client/generateClient.js

@@ -81,13 +81,13 @@ const generateClient = async ({
     }
     const upperHttpMethod = httpMethod.toUpperCase();
     const routeName = routePath;
-    if (target === "client") {
-      handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', ${String(
+    if (target === "server") {
+      handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', process.env.PORT || ${String(
         port
       )}, '${httpMethodDecider ? httpMethodDecider : "functionName"}' ${fetcher ? `, fetch` : ""});
       `;
     } else {
-      handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', process.env.PORT || ${String(
+      handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', ${String(
         port
       )}, '${httpMethodDecider ? httpMethodDecider : "functionName"}' ${fetcher ? `, fetch` : ""});
       `;

package/dist/cjs/operators/http.js

@@ -34,7 +34,7 @@ __export(http_exports, {
   Head: () => Head,
   Headers: () => Headers,
   HttpCode: () => HttpCode,
-  Option: () => Option,
+  Options: () => Options,
   Params: () => Params,
   Patch: () => Patch,
   Post: () => Post,
@@ -80,7 +80,7 @@ const Delete = createHttpOperator(import_types.HttpMethod.Delete);
 const Connect = createHttpOperator(import_types.HttpMethod.Connect);
 const Trace = createHttpOperator(import_types.HttpMethod.Trace);
 const Patch = createHttpOperator(import_types.HttpMethod.Patch);
-const Option = createHttpOperator(import_types.HttpMethod.Option);
+const Options = createHttpOperator(import_types.HttpMethod.Options);
 const Head = createHttpOperator(import_types.HttpMethod.Head);
 const Data = (schema) => {
   return {
@@ -197,7 +197,7 @@ const Redirect = (url) => {
   Head,
   Headers,
   HttpCode,
-  Option,
+  Options,
   Params,
   Patch,
   Post,

package/dist/cjs/router/index.js

@@ -165,8 +165,8 @@ class ApiRouter {
           return import_types.HttpMethod.Trace;
         case "PATCH":
           return import_types.HttpMethod.Patch;
-        case "OPTION":
-          return import_types.HttpMethod.Option;
+        case "OPTIONS":
+          return import_types.HttpMethod.Options;
         case "DEFAULT": {
           return import_types.HttpMethod.Get;
         }

package/dist/cjs/types.js

@@ -57,7 +57,7 @@ var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
   HttpMethod2["Connect"] = "CONNECT";
   HttpMethod2["Trace"] = "TRACE";
   HttpMethod2["Patch"] = "PATCH";
-  HttpMethod2["Option"] = "OPTION";
+  HttpMethod2["Options"] = "OPTIONS";
   HttpMethod2["Head"] = "HEAD";
   return HttpMethod2;
 })(HttpMethod || {});

package/dist/esm/client/generateClient.js

@@ -48,13 +48,13 @@ const generateClient = async ({
     }
     const upperHttpMethod = httpMethod.toUpperCase();
     const routeName = routePath;
-    if (target === "client") {
-      handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', ${String(
+    if (target === "server") {
+      handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', process.env.PORT || ${String(
         port
       )}, '${httpMethodDecider ? httpMethodDecider : "functionName"}' ${fetcher ? `, fetch` : ""});
       `;
     } else {
-      handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', process.env.PORT || ${String(
+      handlersCode += `export ${exportStatement} createRequest('${routeName}', '${upperHttpMethod}', ${String(
         port
       )}, '${httpMethodDecider ? httpMethodDecider : "functionName"}' ${fetcher ? `, fetch` : ""});
       `;

package/dist/esm/operators/http.js

@@ -38,7 +38,7 @@ const Delete = createHttpOperator(HttpMethod.Delete);
 const Connect = createHttpOperator(HttpMethod.Connect);
 const Trace = createHttpOperator(HttpMethod.Trace);
 const Patch = createHttpOperator(HttpMethod.Patch);
-const Option = createHttpOperator(HttpMethod.Option);
+const Options = createHttpOperator(HttpMethod.Options);
 const Head = createHttpOperator(HttpMethod.Head);
 const Data = (schema) => {
   return {
@@ -154,7 +154,7 @@ export {
   Head,
   Headers,
   HttpCode,
-  Option,
+  Options,
   Params,
   Patch,
   Post,

package/dist/esm/router/index.js

@@ -142,8 +142,8 @@ class ApiRouter {
           return HttpMethod.Trace;
         case "PATCH":
           return HttpMethod.Patch;
-        case "OPTION":
-          return HttpMethod.Option;
+        case "OPTIONS":
+          return HttpMethod.Options;
         case "DEFAULT": {
           return HttpMethod.Get;
         }

package/dist/esm/types.js

@@ -30,7 +30,7 @@ var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
   HttpMethod2["Connect"] = "CONNECT";
   HttpMethod2["Trace"] = "TRACE";
   HttpMethod2["Patch"] = "PATCH";
-  HttpMethod2["Option"] = "OPTION";
+  HttpMethod2["Options"] = "OPTIONS";
   HttpMethod2["Head"] = "HEAD";
   return HttpMethod2;
 })(HttpMethod || {});

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
+};

package/dist/js/modern/operators/http.js

@@ -0,0 +1,210 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 {
+  HttpMetadata,
+  OperatorType,
+  HttpMethod,
+  TriggerType,
+  ResponseMetaType
+} from "../types";
+import { ValidationError } from "../errors/http";
+const validateInput = (schema, input) => __async(void 0, null, function* () {
+  try {
+    return yield schema.parseAsync(input);
+  } catch (error) {
+    const { z: zod } = require("zod");
+    if (error instanceof zod.ZodError) {
+      throw new ValidationError(400, error.message);
+    }
+    throw error;
+  }
+});
+const createHttpOperator = (method) => {
+  return (urlPath) => {
+    return {
+      name: method,
+      metadata({ setMetadata }) {
+        setMetadata(OperatorType.Trigger, {
+          type: TriggerType.Http,
+          path: urlPath,
+          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 Option = createHttpOperator(HttpMethod.Option);
+const Head = createHttpOperator(HttpMethod.Head);
+const Data = (schema) => {
+  return {
+    name: HttpMetadata.Data,
+    metadata({ setMetadata }) {
+      setMetadata(HttpMetadata.Data, schema);
+    },
+    validate(helper, next) {
+      return __async(this, null, function* () {
+        const {
+          inputs: { data }
+        } = helper;
+        helper.inputs = __spreadProps(__spreadValues({}, helper.inputs), {
+          data: yield validateInput(schema, data)
+        });
+        return next();
+      });
+    }
+  };
+};
+const Query = (schema) => {
+  return {
+    name: HttpMetadata.Query,
+    metadata({ setMetadata }) {
+      setMetadata(HttpMetadata.Query, schema);
+    },
+    validate(helper, next) {
+      return __async(this, null, function* () {
+        const {
+          inputs: { query }
+        } = helper;
+        helper.inputs = __spreadProps(__spreadValues({}, helper.inputs), {
+          query: yield validateInput(schema, query)
+        });
+        return next();
+      });
+    }
+  };
+};
+const Params = (schema) => {
+  return {
+    name: HttpMetadata.Params,
+    metadata({ setMetadata }) {
+      setMetadata(HttpMetadata.Params, schema);
+    },
+    validate(helper, next) {
+      return __async(this, null, function* () {
+        const {
+          inputs: { params }
+        } = helper;
+        helper.inputs = __spreadProps(__spreadValues({}, helper.inputs), {
+          params: yield validateInput(schema, params)
+        });
+        return next();
+      });
+    }
+  };
+};
+const Headers = (schema) => {
+  return {
+    name: HttpMetadata.Headers,
+    metadata({ setMetadata }) {
+      setMetadata(HttpMetadata.Headers, schema);
+    },
+    validate(helper, next) {
+      return __async(this, null, function* () {
+        const {
+          inputs: { headers }
+        } = helper;
+        helper.inputs = __spreadProps(__spreadValues({}, helper.inputs), {
+          headers: yield validateInput(schema, headers)
+        });
+        return next();
+      });
+    }
+  };
+};
+const setResponseMeta = (helper, type, value) => {
+  const responseMetaData = helper.getMetadata(HttpMetadata.Response) || [];
+  helper.setMetadata(HttpMetadata.Response, [
+    ...responseMetaData,
+    {
+      type,
+      value
+    }
+  ]);
+};
+const HttpCode = (statusCode) => {
+  return {
+    name: "HttpCode",
+    metadata(helper) {
+      setResponseMeta(helper, ResponseMetaType.StatusCode, statusCode);
+    }
+  };
+};
+const SetHeaders = (headers) => {
+  return {
+    name: "SetHeaders",
+    metadata(helper) {
+      setResponseMeta(helper, ResponseMetaType.Headers, headers);
+    }
+  };
+};
+const Redirect = (url) => {
+  return {
+    name: "Redirect",
+    metadata(helper) {
+      setResponseMeta(helper, ResponseMetaType.Redirect, url);
+    }
+  };
+};
+export {
+  Connect,
+  Data,
+  Delete,
+  Get,
+  Head,
+  Headers,
+  HttpCode,
+  Option,
+  Params,
+  Patch,
+  Post,
+  Put,
+  Query,
+  Redirect,
+  SetHeaders,
+  Trace,
+  createHttpOperator
+};

package/dist/js/modern/router/constants.js

@@ -0,0 +1,32 @@
+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 = [
+  "**/*.[tj]s",
+  "!**/_*",
+  "!**/_*/**/*.[tj]s",
+  "!**/*.test.js",
+  "!**/*.test.ts",
+  "!**/*.d.ts",
+  "!__test__/*.ts",
+  "!__tests__/*.ts",
+  "!node_modules/**",
+  "!bootstrap.js"
+];
+export {
+  APIMode,
+  API_DIR,
+  API_FILE_RULES,
+  AllHttpMethods,
+  FRAMEWORK_MODE_APP_DIR,
+  FRAMEWORK_MODE_LAMBDA_DIR,
+  INDEX_SUFFIX
+};