@modern-js/bff-core 1.22.1 → 1.22.2-beta.0

package/dist/js/node/operators/http.js

@@ -1,226 +1,241 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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 __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());
+  });
+};
+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
 });
-exports.createHttpOperator = exports.Trace = exports.SetHeaders = exports.Redirect = exports.Query = exports.Put = exports.Post = exports.Patch = exports.Params = exports.Option = exports.HttpCode = exports.Headers = exports.Head = exports.Get = exports.Delete = exports.Data = exports.Connect = void 0;
-
-var _types = require("../types");
-
-var _http = require("../errors/http");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-const validateInput = async (schema, input) => {
+module.exports = __toCommonJS(http_exports);
+var import_types = require("../types");
+var import_http = require("../errors/http");
+const validateInput = (schema, input) => __async(void 0, null, function* () {
   try {
-    return await schema.parseAsync(input);
+    return yield schema.parseAsync(input);
   } catch (error) {
-    const {
-      z: zod
-    } = require('zod');
-
+    const { z: zod } = require("zod");
     if (error instanceof zod.ZodError) {
-      throw new _http.ValidationError(400, error.message);
+      throw new import_http.ValidationError(400, error.message);
     }
-
     throw error;
   }
-};
-
-const createHttpOperator = method => {
-  return urlPath => {
+});
+const createHttpOperator = (method) => {
+  return (urlPath) => {
     return {
       name: method,
-
-      metadata({
-        setMetadata
-      }) {
-        setMetadata(_types.OperatorType.Trigger, {
-          type: _types.TriggerType.Http,
+      metadata({ setMetadata }) {
+        setMetadata(import_types.OperatorType.Trigger, {
+          type: import_types.TriggerType.Http,
           path: urlPath,
           method
         });
       }
-
     };
   };
 };
-
-exports.createHttpOperator = createHttpOperator;
-const Get = createHttpOperator(_types.HttpMethod.Get);
-exports.Get = Get;
-const Post = createHttpOperator(_types.HttpMethod.Post);
-exports.Post = Post;
-const Put = createHttpOperator(_types.HttpMethod.Put);
-exports.Put = Put;
-const Delete = createHttpOperator(_types.HttpMethod.Delete);
-exports.Delete = Delete;
-const Connect = createHttpOperator(_types.HttpMethod.Connect);
-exports.Connect = Connect;
-const Trace = createHttpOperator(_types.HttpMethod.Trace);
-exports.Trace = Trace;
-const Patch = createHttpOperator(_types.HttpMethod.Patch);
-exports.Patch = Patch;
-const Option = createHttpOperator(_types.HttpMethod.Option);
-exports.Option = Option;
-const Head = createHttpOperator(_types.HttpMethod.Head);
-exports.Head = Head;
-
-const Data = schema => {
+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: _types.HttpMetadata.Data,
-
-    metadata({
-      setMetadata
-    }) {
-      setMetadata(_types.HttpMetadata.Data, schema);
+    name: import_types.HttpMetadata.Data,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Data, schema);
     },
-
-    async validate(helper, next) {
-      const {
-        inputs: {
-          data
-        }
-      } = helper;
-      helper.inputs = _objectSpread(_objectSpread({}, helper.inputs), {}, {
-        data: await validateInput(schema, data)
+    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();
       });
-      return next();
     }
-
   };
 };
-
-exports.Data = Data;
-
-const Query = schema => {
+const Query = (schema) => {
   return {
-    name: _types.HttpMetadata.Query,
-
-    metadata({
-      setMetadata
-    }) {
-      setMetadata(_types.HttpMetadata.Query, schema);
+    name: import_types.HttpMetadata.Query,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Query, schema);
     },
-
-    async validate(helper, next) {
-      const {
-        inputs: {
-          query
-        }
-      } = helper;
-      helper.inputs = _objectSpread(_objectSpread({}, helper.inputs), {}, {
-        query: await validateInput(schema, query)
+    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();
       });
-      return next();
     }
-
   };
 };
-
-exports.Query = Query;
-
-const Params = schema => {
+const Params = (schema) => {
   return {
-    name: _types.HttpMetadata.Params,
-
-    metadata({
-      setMetadata
-    }) {
-      setMetadata(_types.HttpMetadata.Params, schema);
+    name: import_types.HttpMetadata.Params,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Params, schema);
     },
-
-    async validate(helper, next) {
-      const {
-        inputs: {
-          params
-        }
-      } = helper;
-      helper.inputs = _objectSpread(_objectSpread({}, helper.inputs), {}, {
-        params: await validateInput(schema, params)
+    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();
       });
-      return next();
     }
-
   };
 };
-
-exports.Params = Params;
-
-const Headers = schema => {
+const Headers = (schema) => {
   return {
-    name: _types.HttpMetadata.Headers,
-
-    metadata({
-      setMetadata
-    }) {
-      setMetadata(_types.HttpMetadata.Headers, schema);
+    name: import_types.HttpMetadata.Headers,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Headers, schema);
     },
-
-    async validate(helper, next) {
-      const {
-        inputs: {
-          headers
-        }
-      } = helper;
-      helper.inputs = _objectSpread(_objectSpread({}, helper.inputs), {}, {
-        headers: await validateInput(schema, headers)
+    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();
       });
-      return next();
     }
-
   };
 };
-
-exports.Headers = Headers;
-
 const setResponseMeta = (helper, type, value) => {
-  const responseMetaData = helper.getMetadata(_types.HttpMetadata.Response) || [];
-  helper.setMetadata(_types.HttpMetadata.Response, [...responseMetaData, {
-    type,
-    value
-  }]);
+  const responseMetaData = helper.getMetadata(import_types.HttpMetadata.Response) || [];
+  helper.setMetadata(import_types.HttpMetadata.Response, [
+    ...responseMetaData,
+    {
+      type,
+      value
+    }
+  ]);
 };
-
-const HttpCode = statusCode => {
+const HttpCode = (statusCode) => {
   return {
-    name: 'HttpCode',
-
+    name: "HttpCode",
     metadata(helper) {
-      setResponseMeta(helper, _types.ResponseMetaType.StatusCode, statusCode);
+      setResponseMeta(helper, import_types.ResponseMetaType.StatusCode, statusCode);
     }
-
   };
 };
-
-exports.HttpCode = HttpCode;
-
-const SetHeaders = headers => {
+const SetHeaders = (headers) => {
   return {
-    name: 'SetHeaders',
-
+    name: "SetHeaders",
     metadata(helper) {
-      setResponseMeta(helper, _types.ResponseMetaType.Headers, headers);
+      setResponseMeta(helper, import_types.ResponseMetaType.Headers, headers);
     }
-
   };
 };
-
-exports.SetHeaders = SetHeaders;
-
-const Redirect = url => {
+const Redirect = (url) => {
   return {
-    name: 'Redirect',
-
+    name: "Redirect",
     metadata(helper) {
-      setResponseMeta(helper, _types.ResponseMetaType.Redirect, url);
+      setResponseMeta(helper, import_types.ResponseMetaType.Redirect, url);
     }
-
   };
 };
-
-exports.Redirect = Redirect;
+// 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/js/node/router/constants.js

@@ -1,29 +1,61 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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
 });
-exports.INDEX_SUFFIX = exports.FRAMEWORK_MODE_LAMBDA_DIR = exports.FRAMEWORK_MODE_APP_DIR = exports.AllHttpMethods = exports.API_FILE_RULES = exports.API_DIR = exports.APIMode = void 0;
-
-var _types = require("../types");
-
-const AllHttpMethods = Object.values(_types.HttpMethod);
-exports.AllHttpMethods = AllHttpMethods;
-let APIMode;
-exports.APIMode = APIMode;
-
-(function (APIMode) {
-  APIMode["FARMEWORK"] = "framework";
-  APIMode["FUNCTION"] = "function";
-})(APIMode || (exports.APIMode = APIMode = {}));
-
-const FRAMEWORK_MODE_LAMBDA_DIR = 'lambda';
-exports.FRAMEWORK_MODE_LAMBDA_DIR = FRAMEWORK_MODE_LAMBDA_DIR;
-const FRAMEWORK_MODE_APP_DIR = 'app';
-exports.FRAMEWORK_MODE_APP_DIR = FRAMEWORK_MODE_APP_DIR;
-const INDEX_SUFFIX = 'index';
-exports.INDEX_SUFFIX = INDEX_SUFFIX;
-const API_DIR = 'api';
-exports.API_DIR = API_DIR;
-const API_FILE_RULES = ['**/*.[tj]s', '!**/_*', '!**/_*/**/*.[tj]s', '!**/*.test.js', '!**/*.test.ts', '!**/*.d.ts', '!__test__/*.ts', '!__tests__/*.ts', '!node_modules/**', '!bootstrap.js'];
-exports.API_FILE_RULES = API_FILE_RULES;