@bleedingdev/modern-js-bff-core 3.2.0-ultramodern.0

package/dist/cjs/index.js

@@ -0,0 +1,229 @@
+"use strict";
+var __webpack_modules__ = {
+    "./api" (module) {
+        module.exports = require("./api.js");
+    },
+    "./client" (module) {
+        module.exports = require("./client/index.js");
+    },
+    "./contracts/eventContracts" (module) {
+        module.exports = require("./contracts/eventContracts.js");
+    },
+    "./errors/http" (module) {
+        module.exports = require("./errors/http.js");
+    },
+    "./operators/http" (module) {
+        module.exports = require("./operators/http.js");
+    },
+    "./router" (module) {
+        module.exports = require("./router/index.js");
+    },
+    "./security/crossProjectPolicy" (module) {
+        module.exports = require("./security/crossProjectPolicy.js");
+    },
+    "./security/operationContracts" (module) {
+        module.exports = require("./security/operationContracts.js");
+    },
+    "./types" (module) {
+        module.exports = require("./types.js");
+    },
+    "./utils?637c" (module) {
+        module.exports = require("./utils/index.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        Api: ()=>_api__rspack_import_0.Api,
+        HANDLER_WITH_META: ()=>_utils__rspack_import_9.HANDLER_WITH_META,
+        HttpError: ()=>_errors_http__rspack_import_3.HttpError,
+        INPUT_PARAMS_DECIDER: ()=>_utils__rspack_import_9.INPUT_PARAMS_DECIDER,
+        ValidationError: ()=>_errors_http__rspack_import_3.ValidationError,
+        createStorage: ()=>_utils__rspack_import_9.createStorage,
+        getRelativeRuntimePath: ()=>_utils__rspack_import_9.getRelativeRuntimePath,
+        isInputParamsDeciderHandler: ()=>_utils__rspack_import_9.isInputParamsDeciderHandler,
+        isWithMetaHandler: ()=>_utils__rspack_import_9.isWithMetaHandler,
+        registerPaths: ()=>_utils__rspack_import_9.registerPaths
+    });
+    var _api__rspack_import_0 = __webpack_require__("./api");
+    var _client__rspack_import_1 = __webpack_require__("./client");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _client__rspack_import_1)if ([
+        "HttpError",
+        "registerPaths",
+        "createStorage",
+        "isWithMetaHandler",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_client__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _contracts_eventContracts__rspack_import_2 = __webpack_require__("./contracts/eventContracts");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _contracts_eventContracts__rspack_import_2)if ([
+        "HttpError",
+        "registerPaths",
+        "createStorage",
+        "isWithMetaHandler",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_contracts_eventContracts__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _errors_http__rspack_import_3 = __webpack_require__("./errors/http");
+    var _operators_http__rspack_import_4 = __webpack_require__("./operators/http");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _operators_http__rspack_import_4)if ([
+        "HttpError",
+        "registerPaths",
+        "createStorage",
+        "isWithMetaHandler",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_operators_http__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _router__rspack_import_5 = __webpack_require__("./router");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _router__rspack_import_5)if ([
+        "HttpError",
+        "registerPaths",
+        "createStorage",
+        "isWithMetaHandler",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_router__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _security_crossProjectPolicy__rspack_import_6 = __webpack_require__("./security/crossProjectPolicy");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _security_crossProjectPolicy__rspack_import_6)if ([
+        "HttpError",
+        "registerPaths",
+        "createStorage",
+        "isWithMetaHandler",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_security_crossProjectPolicy__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _security_operationContracts__rspack_import_7 = __webpack_require__("./security/operationContracts");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _security_operationContracts__rspack_import_7)if ([
+        "HttpError",
+        "registerPaths",
+        "createStorage",
+        "isWithMetaHandler",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_security_operationContracts__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types__rspack_import_8 = __webpack_require__("./types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_8)if ([
+        "HttpError",
+        "registerPaths",
+        "createStorage",
+        "isWithMetaHandler",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_8[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _utils__rspack_import_9 = __webpack_require__("./utils?637c");
+})();
+exports.Api = __webpack_exports__.Api;
+exports.HANDLER_WITH_META = __webpack_exports__.HANDLER_WITH_META;
+exports.HttpError = __webpack_exports__.HttpError;
+exports.INPUT_PARAMS_DECIDER = __webpack_exports__.INPUT_PARAMS_DECIDER;
+exports.ValidationError = __webpack_exports__.ValidationError;
+exports.createStorage = __webpack_exports__.createStorage;
+exports.getRelativeRuntimePath = __webpack_exports__.getRelativeRuntimePath;
+exports.isInputParamsDeciderHandler = __webpack_exports__.isInputParamsDeciderHandler;
+exports.isWithMetaHandler = __webpack_exports__.isWithMetaHandler;
+exports.registerPaths = __webpack_exports__.registerPaths;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Api",
+    "HANDLER_WITH_META",
+    "HttpError",
+    "INPUT_PARAMS_DECIDER",
+    "ValidationError",
+    "createStorage",
+    "getRelativeRuntimePath",
+    "isInputParamsDeciderHandler",
+    "isWithMetaHandler",
+    "registerPaths"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/operators/http.js

@@ -0,0 +1,220 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Connect: ()=>Connect,
+    Data: ()=>Data,
+    Delete: ()=>Delete,
+    Get: ()=>Get,
+    Head: ()=>Head,
+    Headers: ()=>Headers,
+    HttpCode: ()=>HttpCode,
+    Options: ()=>Options,
+    Params: ()=>Params,
+    Patch: ()=>Patch,
+    Post: ()=>Post,
+    Put: ()=>Put,
+    Query: ()=>Query,
+    Redirect: ()=>Redirect,
+    SetHeaders: ()=>SetHeaders,
+    Trace: ()=>Trace,
+    Upload: ()=>Upload,
+    createHttpOperator: ()=>createHttpOperator
+});
+const http_js_namespaceObject = require("../errors/http.js");
+const external_types_js_namespaceObject = require("../types.js");
+const validateInput = async (schema, input)=>{
+    try {
+        return await schema.parseAsync(input);
+    } catch (error) {
+        if ('name' in error && 'ZodError' === error.name) throw new http_js_namespaceObject.ValidationError(400, error.message);
+        throw error;
+    }
+};
+const createHttpOperator = (method)=>(urlPath)=>({
+            name: method,
+            metadata ({ setMetadata }) {
+                setMetadata(external_types_js_namespaceObject.OperatorType.Trigger, {
+                    type: external_types_js_namespaceObject.TriggerType.Http,
+                    path: urlPath,
+                    method
+                });
+            }
+        });
+const Get = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Get);
+const Post = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Post);
+const Put = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Put);
+const Delete = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Delete);
+const Connect = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Connect);
+const Trace = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Trace);
+const Patch = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Patch);
+const Options = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Options);
+const Head = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Head);
+const Data = (schema)=>({
+        name: external_types_js_namespaceObject.HttpMetadata.Data,
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.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)=>({
+        name: external_types_js_namespaceObject.HttpMetadata.Query,
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.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)=>({
+        name: external_types_js_namespaceObject.HttpMetadata.Params,
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.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)=>({
+        name: external_types_js_namespaceObject.HttpMetadata.Headers,
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.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(external_types_js_namespaceObject.HttpMetadata.Response) || [];
+    helper.setMetadata(external_types_js_namespaceObject.HttpMetadata.Response, [
+        ...responseMetaData,
+        {
+            type,
+            value
+        }
+    ]);
+};
+const HttpCode = (statusCode)=>({
+        name: 'HttpCode',
+        metadata (helper) {
+            setResponseMeta(helper, external_types_js_namespaceObject.ResponseMetaType.StatusCode, statusCode);
+        }
+    });
+const SetHeaders = (headers)=>({
+        name: 'SetHeaders',
+        metadata (helper) {
+            setResponseMeta(helper, external_types_js_namespaceObject.ResponseMetaType.Headers, headers);
+        }
+    });
+const Redirect = (url)=>({
+        name: 'Redirect',
+        metadata (helper) {
+            setResponseMeta(helper, external_types_js_namespaceObject.ResponseMetaType.Redirect, url);
+        }
+    });
+const Upload = (urlPath, schema)=>({
+        name: 'Upload',
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.OperatorType.Trigger, {
+                type: external_types_js_namespaceObject.TriggerType.Http,
+                path: urlPath,
+                method: external_types_js_namespaceObject.HttpMethod.Post,
+                action: 'upload'
+            });
+            setMetadata(external_types_js_namespaceObject.HttpMetadata.Files, schema);
+        },
+        async validate (helper, next) {
+            if (!schema) return next();
+            const { inputs: { formData: files } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                files: await validateInput(schema, files)
+            };
+            return next();
+        }
+    });
+exports.Connect = __webpack_exports__.Connect;
+exports.Data = __webpack_exports__.Data;
+exports.Delete = __webpack_exports__.Delete;
+exports.Get = __webpack_exports__.Get;
+exports.Head = __webpack_exports__.Head;
+exports.Headers = __webpack_exports__.Headers;
+exports.HttpCode = __webpack_exports__.HttpCode;
+exports.Options = __webpack_exports__.Options;
+exports.Params = __webpack_exports__.Params;
+exports.Patch = __webpack_exports__.Patch;
+exports.Post = __webpack_exports__.Post;
+exports.Put = __webpack_exports__.Put;
+exports.Query = __webpack_exports__.Query;
+exports.Redirect = __webpack_exports__.Redirect;
+exports.SetHeaders = __webpack_exports__.SetHeaders;
+exports.Trace = __webpack_exports__.Trace;
+exports.Upload = __webpack_exports__.Upload;
+exports.createHttpOperator = __webpack_exports__.createHttpOperator;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Connect",
+    "Data",
+    "Delete",
+    "Get",
+    "Head",
+    "Headers",
+    "HttpCode",
+    "Options",
+    "Params",
+    "Patch",
+    "Post",
+    "Put",
+    "Query",
+    "Redirect",
+    "SetHeaders",
+    "Trace",
+    "Upload",
+    "createHttpOperator"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/constants.js

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    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
+});
+const external_types_js_namespaceObject = require("../types.js");
+const AllHttpMethods = Object.values(external_types_js_namespaceObject.HttpMethod);
+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.jsx'
+];
+exports.API_DIR = __webpack_exports__.API_DIR;
+exports.API_FILE_RULES = __webpack_exports__.API_FILE_RULES;
+exports.AllHttpMethods = __webpack_exports__.AllHttpMethods;
+exports.FRAMEWORK_MODE_APP_DIR = __webpack_exports__.FRAMEWORK_MODE_APP_DIR;
+exports.FRAMEWORK_MODE_LAMBDA_DIR = __webpack_exports__.FRAMEWORK_MODE_LAMBDA_DIR;
+exports.INDEX_SUFFIX = __webpack_exports__.INDEX_SUFFIX;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "API_DIR",
+    "API_FILE_RULES",
+    "AllHttpMethods",
+    "FRAMEWORK_MODE_APP_DIR",
+    "FRAMEWORK_MODE_LAMBDA_DIR",
+    "INDEX_SUFFIX"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});