@modern-js/bff-runtime 2.69.4 → 3.0.0-alpha.0

package/dist/cjs/index.js

@@ -1,35 +1,79 @@
 "use strict";
-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 __webpack_modules__ = {
+    "./match" (module) {
+        module.exports = require("./match.js");
+    },
+    "farrow-schema" (module) {
+        module.exports = require("farrow-schema");
+    }
 };
-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, {
-  isHandler: () => import_match.isHandler,
-  isSchemaHandler: () => import_match.isSchemaHandler,
-  match: () => import_match.match
-});
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("farrow-schema"), module.exports);
-var import_match = require("./match");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isHandler,
-  isSchemaHandler,
-  match,
-  ...require("farrow-schema")
+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__, {
+        isHandler: ()=>_match__rspack_import_1.isHandler,
+        isSchemaHandler: ()=>_match__rspack_import_1.isSchemaHandler,
+        match: ()=>_match__rspack_import_1.match
+    });
+    var farrow_schema__rspack_import_0 = __webpack_require__("farrow-schema");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in farrow_schema__rspack_import_0)if ([
+        "isHandler",
+        "default",
+        "isSchemaHandler",
+        "match"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>farrow_schema__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _match__rspack_import_1 = __webpack_require__("./match");
+})();
+exports.isHandler = __webpack_exports__.isHandler;
+exports.isSchemaHandler = __webpack_exports__.isSchemaHandler;
+exports.match = __webpack_exports__.match;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isHandler",
+    "isSchemaHandler",
+    "match"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/match.js

@@ -1,88 +1,82 @@
 "use strict";
-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 match_exports = {};
-__export(match_exports, {
-  baseMatch: () => baseMatch,
-  isHandler: () => isHandler,
-  isSchemaHandler: () => isSchemaHandler,
-  match: () => match
+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__, {
+    isHandler: ()=>isHandler,
+    baseMatch: ()=>baseMatch,
+    isSchemaHandler: ()=>isSchemaHandler,
+    match: ()=>match
 });
-module.exports = __toCommonJS(match_exports);
-var import_farrow_schema = require("farrow-schema");
-var import_validator = require("farrow-schema/validator");
-var import_response = require("./response");
-const getErrorMessage = (error) => {
-  let { message } = error;
-  if (Array.isArray(error.path) && error.path.length > 0) {
-    message = `path: ${JSON.stringify(error.path)}
-${message}`;
-  }
-  return message;
+const external_farrow_schema_namespaceObject = require("farrow-schema");
+const validator_namespaceObject = require("farrow-schema/validator");
+const external_response_js_namespaceObject = require("./response.js");
+const getErrorMessage = (error)=>{
+    let { message } = error;
+    if (Array.isArray(error.path) && error.path.length > 0) message = `path: ${JSON.stringify(error.path)}\n${message}`;
+    return message;
 };
-const HANDLER_WITH_SCHEMA = "HANDLER_WITH_SCHEMA";
-const isSchemaHandler = (input) => input && (input === null || input === void 0 ? void 0 : input[HANDLER_WITH_SCHEMA]) === true;
-const isHandler = (input) => input && typeof input === "function";
-const baseMatch = (schema, handler) => {
-  const validateApiInput = createRequestSchemaValidator(schema.request);
-  const validateApiOutput = (0, import_validator.createSchemaValidator)((0, import_farrow_schema.toSchemaCtor)(schema.response));
-  const handle = async (input) => {
-    const inputResult = validateApiInput(input);
-    if (inputResult.isErr) {
-      return (0, import_response.InputValidationError)(getErrorMessage(inputResult.value));
-    }
-    const output = await handler(input);
-    const outputResult = validateApiOutput(output);
-    if (outputResult.isErr) {
-      return (0, import_response.OutputValidationError)(getErrorMessage(outputResult.value));
-    }
-    return (0, import_response.HandleSuccess)(output);
-  };
-  return Object.assign(handle, {
-    schema,
-    [HANDLER_WITH_SCHEMA]: true
-  });
+const HANDLER_WITH_SCHEMA = 'HANDLER_WITH_SCHEMA';
+const isSchemaHandler = (input)=>input && input?.[HANDLER_WITH_SCHEMA] === true;
+const isHandler = (input)=>input && 'function' == typeof input;
+const baseMatch = (schema, handler)=>{
+    const validateApiInput = createRequestSchemaValidator(schema.request);
+    const validateApiOutput = (0, validator_namespaceObject.createSchemaValidator)((0, external_farrow_schema_namespaceObject.toSchemaCtor)(schema.response));
+    const handle = async (input)=>{
+        const inputResult = validateApiInput(input);
+        if (inputResult.isErr) return (0, external_response_js_namespaceObject.InputValidationError)(getErrorMessage(inputResult.value));
+        const output = await handler(input);
+        const outputResult = validateApiOutput(output);
+        if (outputResult.isErr) return (0, external_response_js_namespaceObject.OutputValidationError)(getErrorMessage(outputResult.value));
+        return (0, external_response_js_namespaceObject.HandleSuccess)(output);
+    };
+    return Object.assign(handle, {
+        schema,
+        [HANDLER_WITH_SCHEMA]: true
+    });
 };
 const match = baseMatch;
-const createRequestSchemaValidator = (schema) => {
-  const descriptors = {};
-  if (schema.params) {
-    descriptors.params = schema.params;
-  }
-  if (schema.query) {
-    descriptors.query = schema.query;
-  }
-  if (schema.data) {
-    descriptors.data = schema.data;
-  }
-  if (schema.headers) {
-    descriptors.headers = schema.headers;
-  }
-  if (schema.cookies) {
-    descriptors.cookies = schema.cookies;
-  }
-  const RequestStruct = (0, import_farrow_schema.Struct)(descriptors);
-  return (0, import_validator.createSchemaValidator)((0, import_farrow_schema.NonStrict)(RequestStruct));
+const createRequestSchemaValidator = (schema)=>{
+    const descriptors = {};
+    if (schema.params) descriptors.params = schema.params;
+    if (schema.query) descriptors.query = schema.query;
+    if (schema.data) descriptors.data = schema.data;
+    if (schema.headers) descriptors.headers = schema.headers;
+    if (schema.cookies) descriptors.cookies = schema.cookies;
+    const RequestStruct = (0, external_farrow_schema_namespaceObject.Struct)(descriptors);
+    return (0, validator_namespaceObject.createSchemaValidator)((0, external_farrow_schema_namespaceObject.NonStrict)(RequestStruct));
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  baseMatch,
-  isHandler,
-  isSchemaHandler,
-  match
+exports.baseMatch = __webpack_exports__.baseMatch;
+exports.isHandler = __webpack_exports__.isHandler;
+exports.isSchemaHandler = __webpack_exports__.isSchemaHandler;
+exports.match = __webpack_exports__.match;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "baseMatch",
+    "isHandler",
+    "isSchemaHandler",
+    "match"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/request.js

@@ -1,16 +1,18 @@
 "use strict";
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var request_exports = {};
-module.exports = __toCommonJS(request_exports);
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/response.js

@@ -1,43 +1,53 @@
 "use strict";
-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 response_exports = {};
-__export(response_exports, {
-  HandleSuccess: () => HandleSuccess,
-  InputValidationError: () => InputValidationError,
-  OutputValidationError: () => OutputValidationError
+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__, {
+    HandleSuccess: ()=>HandleSuccess,
+    InputValidationError: ()=>InputValidationError,
+    OutputValidationError: ()=>OutputValidationError
 });
-module.exports = __toCommonJS(response_exports);
-const HandleSuccess = (output) => ({
-  type: "HandleSuccess",
-  value: output
-});
-const InputValidationError = (message) => ({
-  type: "InputValidationError",
-  message
-});
-const OutputValidationError = (message) => ({
-  type: "OutputValidationError",
-  message
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  HandleSuccess,
-  InputValidationError,
-  OutputValidationError
+const HandleSuccess = (output)=>({
+        type: 'HandleSuccess',
+        value: output
+    });
+const InputValidationError = (message)=>({
+        type: 'InputValidationError',
+        message
+    });
+const OutputValidationError = (message)=>({
+        type: 'OutputValidationError',
+        message
+    });
+exports.HandleSuccess = __webpack_exports__.HandleSuccess;
+exports.InputValidationError = __webpack_exports__.InputValidationError;
+exports.OutputValidationError = __webpack_exports__.OutputValidationError;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HandleSuccess",
+    "InputValidationError",
+    "OutputValidationError"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/types.js

@@ -1,16 +1,18 @@
 "use strict";
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+import { isHandler, isSchemaHandler, match } from "./match";
+export * from "farrow-schema";
+export { isHandler, isSchemaHandler, match };

package/dist/esm/match.mjs

@@ -0,0 +1,39 @@
+import { NonStrict, Struct, toSchemaCtor } from "farrow-schema";
+import { createSchemaValidator } from "farrow-schema/validator";
+import { HandleSuccess, InputValidationError, OutputValidationError } from "./response";
+const getErrorMessage = (error)=>{
+    let { message } = error;
+    if (Array.isArray(error.path) && error.path.length > 0) message = `path: ${JSON.stringify(error.path)}\n${message}`;
+    return message;
+};
+const HANDLER_WITH_SCHEMA = 'HANDLER_WITH_SCHEMA';
+const isSchemaHandler = (input)=>input && input?.[HANDLER_WITH_SCHEMA] === true;
+const isHandler = (input)=>input && 'function' == typeof input;
+const baseMatch = (schema, handler)=>{
+    const validateApiInput = createRequestSchemaValidator(schema.request);
+    const validateApiOutput = createSchemaValidator(toSchemaCtor(schema.response));
+    const handle = async (input)=>{
+        const inputResult = validateApiInput(input);
+        if (inputResult.isErr) return InputValidationError(getErrorMessage(inputResult.value));
+        const output = await handler(input);
+        const outputResult = validateApiOutput(output);
+        if (outputResult.isErr) return OutputValidationError(getErrorMessage(outputResult.value));
+        return HandleSuccess(output);
+    };
+    return Object.assign(handle, {
+        schema,
+        [HANDLER_WITH_SCHEMA]: true
+    });
+};
+const match = baseMatch;
+const createRequestSchemaValidator = (schema)=>{
+    const descriptors = {};
+    if (schema.params) descriptors.params = schema.params;
+    if (schema.query) descriptors.query = schema.query;
+    if (schema.data) descriptors.data = schema.data;
+    if (schema.headers) descriptors.headers = schema.headers;
+    if (schema.cookies) descriptors.cookies = schema.cookies;
+    const RequestStruct = Struct(descriptors);
+    return createSchemaValidator(NonStrict(RequestStruct));
+};
+export { baseMatch, isHandler, isSchemaHandler, match };

package/dist/esm/response.mjs

@@ -0,0 +1,13 @@
+const HandleSuccess = (output)=>({
+        type: 'HandleSuccess',
+        value: output
+    });
+const InputValidationError = (message)=>({
+        type: 'InputValidationError',
+        message
+    });
+const OutputValidationError = (message)=>({
+        type: 'OutputValidationError',
+        message
+    });
+export { HandleSuccess, InputValidationError, OutputValidationError };

package/dist/esm-node/index.mjs

@@ -0,0 +1,3 @@
+import { isHandler, isSchemaHandler, match } from "./match.mjs";
+export * from "farrow-schema";
+export { isHandler, isSchemaHandler, match };

package/dist/esm-node/match.mjs

@@ -0,0 +1,39 @@
+import { NonStrict, Struct, toSchemaCtor } from "farrow-schema";
+import { createSchemaValidator } from "farrow-schema/validator";
+import { HandleSuccess, InputValidationError, OutputValidationError } from "./response.mjs";
+const getErrorMessage = (error)=>{
+    let { message } = error;
+    if (Array.isArray(error.path) && error.path.length > 0) message = `path: ${JSON.stringify(error.path)}\n${message}`;
+    return message;
+};
+const HANDLER_WITH_SCHEMA = 'HANDLER_WITH_SCHEMA';
+const isSchemaHandler = (input)=>input && input?.[HANDLER_WITH_SCHEMA] === true;
+const isHandler = (input)=>input && 'function' == typeof input;
+const baseMatch = (schema, handler)=>{
+    const validateApiInput = createRequestSchemaValidator(schema.request);
+    const validateApiOutput = createSchemaValidator(toSchemaCtor(schema.response));
+    const handle = async (input)=>{
+        const inputResult = validateApiInput(input);
+        if (inputResult.isErr) return InputValidationError(getErrorMessage(inputResult.value));
+        const output = await handler(input);
+        const outputResult = validateApiOutput(output);
+        if (outputResult.isErr) return OutputValidationError(getErrorMessage(outputResult.value));
+        return HandleSuccess(output);
+    };
+    return Object.assign(handle, {
+        schema,
+        [HANDLER_WITH_SCHEMA]: true
+    });
+};
+const match = baseMatch;
+const createRequestSchemaValidator = (schema)=>{
+    const descriptors = {};
+    if (schema.params) descriptors.params = schema.params;
+    if (schema.query) descriptors.query = schema.query;
+    if (schema.data) descriptors.data = schema.data;
+    if (schema.headers) descriptors.headers = schema.headers;
+    if (schema.cookies) descriptors.cookies = schema.cookies;
+    const RequestStruct = Struct(descriptors);
+    return createSchemaValidator(NonStrict(RequestStruct));
+};
+export { baseMatch, isHandler, isSchemaHandler, match };

package/dist/esm-node/response.mjs

@@ -0,0 +1,13 @@
+const HandleSuccess = (output)=>({
+        type: 'HandleSuccess',
+        value: output
+    });
+const InputValidationError = (message)=>({
+        type: 'InputValidationError',
+        message
+    });
+const OutputValidationError = (message)=>({
+        type: 'OutputValidationError',
+        message
+    });
+export { HandleSuccess, InputValidationError, OutputValidationError };

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.69.4",
+  "version": "3.0.0-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -24,7 +24,7 @@
     ".": {
       "node": {
         "jsnext:source": "./src/index.ts",
-        "import": "./dist/esm-node/index.js",
+        "import": "./dist/esm-node/index.mjs",
         "require": "./dist/cjs/index.js"
       },
       "default": "./dist/esm/index.js"
@@ -37,21 +37,18 @@
     "farrow-schema": "^1.12.1"
   },
   "devDependencies": {
-    "@types/jest": "^29",
-    "@types/node": "^18",
-    "jest": "^29",
-    "ts-jest": "^29.1.0",
+    "@types/node": "^20",
+    "@rslib/core": "0.18.5",
     "typescript": "^5",
-    "@scripts/build": "2.66.0",
-    "@scripts/jest-config": "2.66.0"
+    "@modern-js/rslib": "2.68.10"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "scripts": {
-    "new": "modern-lib new",
-    "build": "modern-lib build",
-    "test": "jest --passWithNoTests"
+    "dev": "rslib build --watch",
+    "build": "rslib build",
+    "test": "rstest --passWithNoTests"
   }
 }

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  globals: true,
+});

package/dist/esm/index.js

@@ -1,7 +0,0 @@
-export * from "farrow-schema";
-import { match, isHandler, isSchemaHandler } from "./match";
-export {
-  isHandler,
-  isSchemaHandler,
-  match
-};

package/dist/esm/match.js

@@ -1,91 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { NonStrict, Struct, toSchemaCtor } from "farrow-schema";
-import { createSchemaValidator } from "farrow-schema/validator";
-import { HandleSuccess, InputValidationError, OutputValidationError } from "./response";
-var getErrorMessage = function(error) {
-  var message = error.message;
-  if (Array.isArray(error.path) && error.path.length > 0) {
-    message = "path: ".concat(JSON.stringify(error.path), "\n").concat(message);
-  }
-  return message;
-};
-var HANDLER_WITH_SCHEMA = "HANDLER_WITH_SCHEMA";
-var isSchemaHandler = function(input) {
-  return input && (input === null || input === void 0 ? void 0 : input[HANDLER_WITH_SCHEMA]) === true;
-};
-var isHandler = function(input) {
-  return input && typeof input === "function";
-};
-var baseMatch = function(schema, handler) {
-  var validateApiInput = createRequestSchemaValidator(schema.request);
-  var validateApiOutput = createSchemaValidator(toSchemaCtor(schema.response));
-  var handle = function() {
-    var _ref = _async_to_generator(function(input) {
-      var inputResult, output, outputResult;
-      return _ts_generator(this, function(_state) {
-        switch (_state.label) {
-          case 0:
-            inputResult = validateApiInput(input);
-            if (inputResult.isErr) {
-              return [
-                2,
-                InputValidationError(getErrorMessage(inputResult.value))
-              ];
-            }
-            return [
-              4,
-              handler(input)
-            ];
-          case 1:
-            output = _state.sent();
-            outputResult = validateApiOutput(output);
-            if (outputResult.isErr) {
-              return [
-                2,
-                OutputValidationError(getErrorMessage(outputResult.value))
-              ];
-            }
-            return [
-              2,
-              HandleSuccess(output)
-            ];
-        }
-      });
-    });
-    return function handle2(input) {
-      return _ref.apply(this, arguments);
-    };
-  }();
-  return Object.assign(handle, _define_property({
-    schema
-  }, HANDLER_WITH_SCHEMA, true));
-};
-var match = baseMatch;
-var createRequestSchemaValidator = function(schema) {
-  var descriptors = {};
-  if (schema.params) {
-    descriptors.params = schema.params;
-  }
-  if (schema.query) {
-    descriptors.query = schema.query;
-  }
-  if (schema.data) {
-    descriptors.data = schema.data;
-  }
-  if (schema.headers) {
-    descriptors.headers = schema.headers;
-  }
-  if (schema.cookies) {
-    descriptors.cookies = schema.cookies;
-  }
-  var RequestStruct = Struct(descriptors);
-  return createSchemaValidator(NonStrict(RequestStruct));
-};
-export {
-  baseMatch,
-  isHandler,
-  isSchemaHandler,
-  match
-};

package/dist/esm/response.js

@@ -1,23 +0,0 @@
-var HandleSuccess = function(output) {
-  return {
-    type: "HandleSuccess",
-    value: output
-  };
-};
-var InputValidationError = function(message) {
-  return {
-    type: "InputValidationError",
-    message
-  };
-};
-var OutputValidationError = function(message) {
-  return {
-    type: "OutputValidationError",
-    message
-  };
-};
-export {
-  HandleSuccess,
-  InputValidationError,
-  OutputValidationError
-};

package/dist/esm-node/index.js

@@ -1,7 +0,0 @@
-export * from "farrow-schema";
-import { match, isHandler, isSchemaHandler } from "./match";
-export {
-  isHandler,
-  isSchemaHandler,
-  match
-};

package/dist/esm-node/match.js

@@ -1,61 +0,0 @@
-import { NonStrict, Struct, toSchemaCtor } from "farrow-schema";
-import { createSchemaValidator } from "farrow-schema/validator";
-import { HandleSuccess, InputValidationError, OutputValidationError } from "./response";
-const getErrorMessage = (error) => {
-  let { message } = error;
-  if (Array.isArray(error.path) && error.path.length > 0) {
-    message = `path: ${JSON.stringify(error.path)}
-${message}`;
-  }
-  return message;
-};
-const HANDLER_WITH_SCHEMA = "HANDLER_WITH_SCHEMA";
-const isSchemaHandler = (input) => input && (input === null || input === void 0 ? void 0 : input[HANDLER_WITH_SCHEMA]) === true;
-const isHandler = (input) => input && typeof input === "function";
-const baseMatch = (schema, handler) => {
-  const validateApiInput = createRequestSchemaValidator(schema.request);
-  const validateApiOutput = createSchemaValidator(toSchemaCtor(schema.response));
-  const handle = async (input) => {
-    const inputResult = validateApiInput(input);
-    if (inputResult.isErr) {
-      return InputValidationError(getErrorMessage(inputResult.value));
-    }
-    const output = await handler(input);
-    const outputResult = validateApiOutput(output);
-    if (outputResult.isErr) {
-      return OutputValidationError(getErrorMessage(outputResult.value));
-    }
-    return HandleSuccess(output);
-  };
-  return Object.assign(handle, {
-    schema,
-    [HANDLER_WITH_SCHEMA]: true
-  });
-};
-const match = baseMatch;
-const createRequestSchemaValidator = (schema) => {
-  const descriptors = {};
-  if (schema.params) {
-    descriptors.params = schema.params;
-  }
-  if (schema.query) {
-    descriptors.query = schema.query;
-  }
-  if (schema.data) {
-    descriptors.data = schema.data;
-  }
-  if (schema.headers) {
-    descriptors.headers = schema.headers;
-  }
-  if (schema.cookies) {
-    descriptors.cookies = schema.cookies;
-  }
-  const RequestStruct = Struct(descriptors);
-  return createSchemaValidator(NonStrict(RequestStruct));
-};
-export {
-  baseMatch,
-  isHandler,
-  isSchemaHandler,
-  match
-};

package/dist/esm-node/response.js

@@ -1,17 +0,0 @@
-const HandleSuccess = (output) => ({
-  type: "HandleSuccess",
-  value: output
-});
-const InputValidationError = (message) => ({
-  type: "InputValidationError",
-  message
-});
-const OutputValidationError = (message) => ({
-  type: "OutputValidationError",
-  message
-});
-export {
-  HandleSuccess,
-  InputValidationError,
-  OutputValidationError
-};