@modern-js/bff-core 2.4.1-beta.0 → 2.5.1-alpha.0

package/CHANGELOG.md

@@ -1,11 +1,21 @@
 # @modern-js/bff-core
 
-## 2.4.1-beta.0
+## 2.5.0
 
 ### Patch Changes
 
+- 89ca6cc: refactor: merge build-config into scripts/build
+
+  refactor: 把 build-config 合并进 scripts/build
+
+- 30614fa: chore: modify package.json entry fields and build config
+  chore: 更改 package.json entry 字段以及构建配置
+- Updated dependencies [89ca6cc]
+- Updated dependencies [30614fa]
+- Updated dependencies [1b0ce87]
 - Updated dependencies [11c053b]
-  - @modern-js/utils@2.4.1-beta.0
+  - @modern-js/bff-runtime@2.5.0
+  - @modern-js/utils@2.5.0
 
 ## 2.4.0
 

package/dist/cjs/api.js

@@ -0,0 +1,76 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 api_exports = {};
+__export(api_exports, {
+  Api: () => Api
+});
+module.exports = __toCommonJS(api_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_koa_compose = __toESM(require("koa-compose"));
+var import_utils = require("./utils");
+function Api(...args) {
+  const handler = args.pop();
+  (0, import_utils.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);
+  async function runner(inputs) {
+    const executeHelper = {
+      result: null,
+      get inputs() {
+        return inputs;
+      },
+      set inputs(val) {
+        inputs = val;
+      }
+    };
+    const stack = [...validateHandlers, ...pipeHandlers];
+    stack.push(async (helper, next) => {
+      const res = await handler(helper.inputs);
+      helper.result = res;
+      return next();
+    });
+    await (0, import_koa_compose.default)(stack)(executeHelper);
+    return executeHelper.result;
+  }
+  runner[import_utils.HANDLER_WITH_META] = true;
+  return runner;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Api
+});

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

@@ -0,0 +1,91 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 generate_client_exports = {};
+__export(generate_client_exports, {
+  DEFAULT_CLIENT_REQUEST_CREATOR: () => DEFAULT_CLIENT_REQUEST_CREATOR,
+  generateClient: () => generateClient
+});
+module.exports = __toCommonJS(generate_client_exports);
+var path = __toESM(require("path"));
+var import_router = require("../router");
+var import_result = require("./result");
+const DEFAULT_CLIENT_REQUEST_CREATOR = "@modern-js/create-request";
+const generateClient = async ({
+  resourcePath,
+  apiDir,
+  prefix,
+  port,
+  target,
+  requestCreator,
+  fetcher,
+  requireResolve = require.resolve,
+  httpMethodDecider
+}) => {
+  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 import_router.ApiRouter({
+    apiDir,
+    prefix,
+    httpMethodDecider
+  });
+  const handlerInfos = apiRouter.getSingleModuleHandlers(resourcePath);
+  if (!handlerInfos) {
+    return (0, import_result.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}', '${httpMethodDecider}', ${process.env.PORT || String(port)}${fetcher ? `, fetch` : ""});
+`;
+  }
+  const importCode = `import { createRequest } from '${requestCreator}';
+${fetcher ? `import { fetch } from '${fetcher}';
+` : ""}`;
+  return (0, import_result.Ok)(`${importCode}
+${handlersCode}`);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CLIENT_REQUEST_CREATOR,
+  generateClient
+});

package/dist/cjs/client/index.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+module.exports = __toCommonJS(client_exports);
+__reExport(client_exports, require("./generate-client"), module.exports);

package/dist/cjs/client/result.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var result_exports = {};
+__export(result_exports, {
+  Err: () => Err,
+  Ok: () => Ok
+});
+module.exports = __toCommonJS(result_exports);
+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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Err,
+  Ok
+});

package/dist/cjs/errors/http.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_exports = {};
+__export(http_exports, {
+  HttpError: () => HttpError,
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(http_exports);
+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";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpError,
+  ValidationError
+});

package/dist/cjs/index.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__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
+});
+module.exports = __toCommonJS(src_exports);
+var import_api = require("./api");
+var import_http = require("./errors/http");
+__reExport(src_exports, require("./router"), module.exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./client"), module.exports);
+__reExport(src_exports, require("./operators/http"), module.exports);
+var import_utils = require("./utils");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Api,
+  HANDLER_WITH_META,
+  HttpError,
+  INPUT_PARAMS_DECIDER,
+  ValidationError,
+  createStorage,
+  getRelativeRuntimePath,
+  isInputParamsDeciderHandler,
+  isWithMetaHandler,
+  registerPaths
+});

package/dist/cjs/operators/http.js

@@ -0,0 +1,206 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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, {
+  Connect: () => Connect,
+  Data: () => Data,
+  Delete: () => Delete,
+  Get: () => Get,
+  Head: () => Head,
+  Headers: () => Headers,
+  HttpCode: () => HttpCode,
+  Option: () => Option,
+  Params: () => Params,
+  Patch: () => Patch,
+  Post: () => Post,
+  Put: () => Put,
+  Query: () => Query,
+  Redirect: () => Redirect,
+  SetHeaders: () => SetHeaders,
+  Trace: () => Trace,
+  createHttpOperator: () => createHttpOperator
+});
+module.exports = __toCommonJS(http_exports);
+var import_types = require("../types");
+var import_http = require("../errors/http");
+const validateInput = async (schema, input) => {
+  try {
+    return await schema.parseAsync(input);
+  } catch (error) {
+    const { z: zod } = await Promise.resolve().then(() => __toESM(require("zod")));
+    if (error instanceof zod.ZodError) {
+      throw new import_http.ValidationError(400, error.message);
+    }
+    throw error;
+  }
+};
+const createHttpOperator = (method) => {
+  return (urlPath) => {
+    return {
+      name: method,
+      metadata({ setMetadata }) {
+        setMetadata(import_types.OperatorType.Trigger, {
+          type: import_types.TriggerType.Http,
+          path: urlPath,
+          method
+        });
+      }
+    };
+  };
+};
+const Get = createHttpOperator(import_types.HttpMethod.Get);
+const Post = createHttpOperator(import_types.HttpMethod.Post);
+const Put = createHttpOperator(import_types.HttpMethod.Put);
+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 Head = createHttpOperator(import_types.HttpMethod.Head);
+const Data = (schema) => {
+  return {
+    name: import_types.HttpMetadata.Data,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Data, schema);
+    },
+    async validate(helper, next) {
+      const {
+        inputs: { data }
+      } = helper;
+      helper.inputs = {
+        ...helper.inputs,
+        data: await validateInput(schema, data)
+      };
+      return next();
+    }
+  };
+};
+const Query = (schema) => {
+  return {
+    name: import_types.HttpMetadata.Query,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Query, schema);
+    },
+    async validate(helper, next) {
+      const {
+        inputs: { query }
+      } = helper;
+      helper.inputs = {
+        ...helper.inputs,
+        query: await validateInput(schema, query)
+      };
+      return next();
+    }
+  };
+};
+const Params = (schema) => {
+  return {
+    name: import_types.HttpMetadata.Params,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Params, schema);
+    },
+    async validate(helper, next) {
+      const {
+        inputs: { params }
+      } = helper;
+      helper.inputs = {
+        ...helper.inputs,
+        params: await validateInput(schema, params)
+      };
+      return next();
+    }
+  };
+};
+const Headers = (schema) => {
+  return {
+    name: import_types.HttpMetadata.Headers,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Headers, schema);
+    },
+    async validate(helper, next) {
+      const {
+        inputs: { headers }
+      } = helper;
+      helper.inputs = {
+        ...helper.inputs,
+        headers: await validateInput(schema, headers)
+      };
+      return next();
+    }
+  };
+};
+const setResponseMeta = (helper, type, value) => {
+  const responseMetaData = helper.getMetadata(import_types.HttpMetadata.Response) || [];
+  helper.setMetadata(import_types.HttpMetadata.Response, [
+    ...responseMetaData,
+    {
+      type,
+      value
+    }
+  ]);
+};
+const HttpCode = (statusCode) => {
+  return {
+    name: "HttpCode",
+    metadata(helper) {
+      setResponseMeta(helper, import_types.ResponseMetaType.StatusCode, statusCode);
+    }
+  };
+};
+const SetHeaders = (headers) => {
+  return {
+    name: "SetHeaders",
+    metadata(helper) {
+      setResponseMeta(helper, import_types.ResponseMetaType.Headers, headers);
+    }
+  };
+};
+const Redirect = (url) => {
+  return {
+    name: "Redirect",
+    metadata(helper) {
+      setResponseMeta(helper, import_types.ResponseMetaType.Redirect, url);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Connect,
+  Data,
+  Delete,
+  Get,
+  Head,
+  Headers,
+  HttpCode,
+  Option,
+  Params,
+  Patch,
+  Post,
+  Put,
+  Query,
+  Redirect,
+  SetHeaders,
+  Trace,
+  createHttpOperator
+});

package/dist/cjs/router/constants.js

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  APIMode: () => APIMode,
+  API_DIR: () => API_DIR,
+  API_FILE_RULES: () => API_FILE_RULES,
+  AllHttpMethods: () => AllHttpMethods,
+  FRAMEWORK_MODE_APP_DIR: () => FRAMEWORK_MODE_APP_DIR,
+  FRAMEWORK_MODE_LAMBDA_DIR: () => FRAMEWORK_MODE_LAMBDA_DIR,
+  INDEX_SUFFIX: () => INDEX_SUFFIX
+});
+module.exports = __toCommonJS(constants_exports);
+var import_types = require("../types");
+const AllHttpMethods = Object.values(import_types.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"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIMode,
+  API_DIR,
+  API_FILE_RULES,
+  AllHttpMethods,
+  FRAMEWORK_MODE_APP_DIR,
+  FRAMEWORK_MODE_LAMBDA_DIR,
+  INDEX_SUFFIX
+});