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

package/dist/cjs/utils/meta.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 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/cjs/utils/storage.js

@@ -0,0 +1,71 @@
+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 storage_exports = {};
+__export(storage_exports, {
+  createStorage: () => createStorage
+});
+module.exports = __toCommonJS(storage_exports);
+var ah = __toESM(require("async_hooks"));
+const createStorage = () => {
+  let storage;
+  if (typeof ah.AsyncLocalStorage !== "undefined") {
+    storage = new ah.AsyncLocalStorage();
+  }
+  const run = (context, cb) => {
+    if (!storage) {
+      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+    }
+    return new Promise((resolve, reject) => {
+      storage.run(context, () => {
+        try {
+          return resolve(cb());
+        } catch (error) {
+          return reject(error);
+        }
+      });
+    });
+  };
+  const useContext = () => {
+    if (!storage) {
+      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+    }
+    const context = storage.getStore();
+    if (!context) {
+      throw new Error(
+        `Can't call useContext out of scope, it should be placed in the bff function`
+      );
+    }
+    return context;
+  };
+  return {
+    run,
+    useContext
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStorage
+});

package/dist/cjs/utils/validate.js

@@ -0,0 +1,74 @@
+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 validate_exports = {};
+__export(validate_exports, {
+  ERR_INVALID_ARG_TYPE: () => ERR_INVALID_ARG_TYPE,
+  getTypeErrorMessage: () => getTypeErrorMessage,
+  validateFunction: () => validateFunction
+});
+module.exports = __toCommonJS(validate_exports);
+var import_util = __toESM(require("util"));
+const getTypeErrorMessage = (actual) => {
+  var _a;
+  let msg = "";
+  if (actual == null) {
+    msg += `. Received ${actual}`;
+  } else if (typeof actual === "function" && actual.name) {
+    msg += `. Received function ${actual.name}`;
+  } else if (typeof actual === "object") {
+    if ((_a = actual.constructor) == null ? void 0 : _a.name) {
+      msg += `. Received an instance of ${actual.constructor.name}`;
+    } else {
+      const inspected = import_util.default.inspect(actual, { depth: -1 });
+      msg += `. Received ${inspected}`;
+    }
+  } else {
+    let inspected = import_util.default.inspect(actual, { colors: false });
+    if (inspected.length > 25) {
+      inspected = `${inspected.slice(0, 25)}...`;
+    }
+    msg += `. Received type ${typeof actual} (${inspected})`;
+  }
+  return msg;
+};
+class ERR_INVALID_ARG_TYPE extends Error {
+  constructor(funcName, expectedType, actual) {
+    const message = `[ERR_INVALID_ARG_TYPE]: The '${funcName}' argument must be of type ${expectedType}${getTypeErrorMessage(
+      actual
+    )}`;
+    super(message);
+  }
+}
+const validateFunction = (maybeFunc, name) => {
+  if (typeof maybeFunc !== "function") {
+    throw new ERR_INVALID_ARG_TYPE(name, "function", maybeFunc);
+  }
+  return true;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERR_INVALID_ARG_TYPE,
+  getTypeErrorMessage,
+  validateFunction
+});

package/dist/esm/api.js

@@ -0,0 +1,47 @@
+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);
+  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 compose(stack)(executeHelper);
+    return executeHelper.result;
+  }
+  runner[HANDLER_WITH_META] = true;
+  return runner;
+}
+export {
+  Api
+};

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

@@ -0,0 +1,61 @@
+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 = 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 ApiRouter({
+    apiDir,
+    prefix,
+    httpMethodDecider
+  });
+  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}', '${httpMethodDecider}', ${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/esm/client/index.js

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

package/dist/esm/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/esm/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/esm/index.js

@@ -0,0 +1,27 @@
+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,
+  INPUT_PARAMS_DECIDER,
+  isInputParamsDeciderHandler,
+  createStorage,
+  registerPaths
+} from "./utils";
+export {
+  Api,
+  HANDLER_WITH_META,
+  HttpError,
+  INPUT_PARAMS_DECIDER,
+  ValidationError,
+  createStorage,
+  getRelativeRuntimePath,
+  isInputParamsDeciderHandler,
+  isWithMetaHandler,
+  registerPaths
+};

package/dist/esm/operators/http.js

@@ -0,0 +1,167 @@
+import {
+  HttpMetadata,
+  OperatorType,
+  HttpMethod,
+  TriggerType,
+  ResponseMetaType
+} from "../types";
+import { ValidationError } from "../errors/http";
+const validateInput = async (schema, input) => {
+  try {
+    return await schema.parseAsync(input);
+  } catch (error) {
+    const { z: zod } = await import("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);
+    },
+    async validate(helper, next) {
+      const {
+        inputs: { data }
+      } = helper;
+      helper.inputs = {
+        ...helper.inputs,
+        data: await validateInput(schema, data)
+      };
+      return next();
+    }
+  };
+};
+const Query = (schema) => {
+  return {
+    name: HttpMetadata.Query,
+    metadata({ setMetadata }) {
+      setMetadata(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: HttpMetadata.Params,
+    metadata({ setMetadata }) {
+      setMetadata(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: HttpMetadata.Headers,
+    metadata({ setMetadata }) {
+      setMetadata(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(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/esm/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
+};