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

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

@@ -1,210 +1,187 @@
-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";
+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; }
+
+import { HttpMetadata, OperatorType, HttpMethod, TriggerType, ResponseMetaType } from "../types";
 import { ValidationError } from "../errors/http";
-const validateInput = (schema, input) => __async(void 0, null, function* () {
+
+const validateInput = async (schema, input) => {
   try {
-    return yield schema.parseAsync(input);
+    return await schema.parseAsync(input);
   } catch (error) {
-    const { z: zod } = require("zod");
+    const {
+      z: zod
+    } = require('zod');
+
     if (error instanceof zod.ZodError) {
       throw new ValidationError(400, error.message);
     }
+
     throw error;
   }
-});
-const createHttpOperator = (method) => {
-  return (urlPath) => {
+};
+
+export const createHttpOperator = method => {
+  return urlPath => {
     return {
       name: method,
-      metadata({ setMetadata }) {
+
+      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) => {
+export const Get = createHttpOperator(HttpMethod.Get);
+export const Post = createHttpOperator(HttpMethod.Post);
+export const Put = createHttpOperator(HttpMethod.Put);
+export const Delete = createHttpOperator(HttpMethod.Delete);
+export const Connect = createHttpOperator(HttpMethod.Connect);
+export const Trace = createHttpOperator(HttpMethod.Trace);
+export const Patch = createHttpOperator(HttpMethod.Patch);
+export const Option = createHttpOperator(HttpMethod.Option);
+export const Head = createHttpOperator(HttpMethod.Head);
+export const Data = schema => {
   return {
     name: HttpMetadata.Data,
-    metadata({ setMetadata }) {
+
+    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();
+
+    async validate(helper, next) {
+      const {
+        inputs: {
+          data
+        }
+      } = helper;
+      helper.inputs = _objectSpread(_objectSpread({}, helper.inputs), {}, {
+        data: await validateInput(schema, data)
       });
+      return next();
     }
+
   };
 };
-const Query = (schema) => {
+export const Query = schema => {
   return {
     name: HttpMetadata.Query,
-    metadata({ setMetadata }) {
+
+    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();
+
+    async validate(helper, next) {
+      const {
+        inputs: {
+          query
+        }
+      } = helper;
+      helper.inputs = _objectSpread(_objectSpread({}, helper.inputs), {}, {
+        query: await validateInput(schema, query)
       });
+      return next();
     }
+
   };
 };
-const Params = (schema) => {
+export const Params = schema => {
   return {
     name: HttpMetadata.Params,
-    metadata({ setMetadata }) {
+
+    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();
+
+    async validate(helper, next) {
+      const {
+        inputs: {
+          params
+        }
+      } = helper;
+      helper.inputs = _objectSpread(_objectSpread({}, helper.inputs), {}, {
+        params: await validateInput(schema, params)
       });
+      return next();
     }
+
   };
 };
-const Headers = (schema) => {
+export const Headers = schema => {
   return {
     name: HttpMetadata.Headers,
-    metadata({ setMetadata }) {
+
+    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();
+
+    async validate(helper, next) {
+      const {
+        inputs: {
+          headers
+        }
+      } = helper;
+      helper.inputs = _objectSpread(_objectSpread({}, 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
-    }
-  ]);
+  helper.setMetadata(HttpMetadata.Response, [...responseMetaData, {
+    type,
+    value
+  }]);
 };
-const HttpCode = (statusCode) => {
+
+export const HttpCode = statusCode => {
   return {
-    name: "HttpCode",
+    name: 'HttpCode',
+
     metadata(helper) {
       setResponseMeta(helper, ResponseMetaType.StatusCode, statusCode);
     }
+
   };
 };
-const SetHeaders = (headers) => {
+export const SetHeaders = headers => {
   return {
-    name: "SetHeaders",
+    name: 'SetHeaders',
+
     metadata(helper) {
       setResponseMeta(helper, ResponseMetaType.Headers, headers);
     }
+
   };
 };
-const Redirect = (url) => {
+export const Redirect = url => {
   return {
-    name: "Redirect",
+    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

@@ -1,32 +1,14 @@
 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
-};
+export const AllHttpMethods = Object.values(HttpMethod);
+export let APIMode;
+
+(function (APIMode) {
+  APIMode["FARMEWORK"] = "framework";
+  APIMode["FUNCTION"] = "function";
+})(APIMode || (APIMode = {}));
+
+export const FRAMEWORK_MODE_LAMBDA_DIR = 'lambda';
+export const FRAMEWORK_MODE_APP_DIR = 'app';
+export const INDEX_SUFFIX = 'index';
+export const API_DIR = 'api';
+export const API_FILE_RULES = ['**/*.[tj]s', '!**/_*', '!**/_*/**/*.[tj]s', '!**/*.test.js', '!**/*.test.ts', '!**/*.d.ts', '!__test__/*.ts', '!__tests__/*.ts', '!node_modules/**', '!bootstrap.js'];