@bleedingdev/modern-js-bff-core 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

package/dist/cjs/adapter-kit/index.js

@@ -0,0 +1,140 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    HANDLER_WITH_SCHEMA: ()=>HANDLER_WITH_SCHEMA,
+    buildPositionalHandlerArgs: ()=>buildPositionalHandlerArgs,
+    checkCrossProjectPolicy: ()=>checkCrossProjectPolicy,
+    getApiHandlerMode: ()=>getApiHandlerMode,
+    getResponseMetaList: ()=>getResponseMetaList,
+    getRouteMiddlewares: ()=>getRouteMiddlewares,
+    isSchemaApiHandler: ()=>isSchemaApiHandler,
+    mapSchemaHandlerResult: ()=>mapSchemaHandlerResult,
+    planApiRoutes: ()=>planApiRoutes,
+    toApiRouteMethod: ()=>toApiRouteMethod
+});
+require("reflect-metadata");
+const crossProjectPolicy_js_namespaceObject = require("../security/crossProjectPolicy.js");
+const external_types_js_namespaceObject = require("../types.js");
+const index_js_namespaceObject = require("../utils/index.js");
+const API_ROUTE_METHODS = {
+    [external_types_js_namespaceObject.HttpMethod.Get]: 'get',
+    [external_types_js_namespaceObject.HttpMethod.Post]: 'post',
+    [external_types_js_namespaceObject.HttpMethod.Put]: 'put',
+    [external_types_js_namespaceObject.HttpMethod.Delete]: 'delete',
+    [external_types_js_namespaceObject.HttpMethod.Connect]: 'connect',
+    [external_types_js_namespaceObject.HttpMethod.Trace]: 'trace',
+    [external_types_js_namespaceObject.HttpMethod.Patch]: 'patch',
+    [external_types_js_namespaceObject.HttpMethod.Options]: 'options',
+    [external_types_js_namespaceObject.HttpMethod.Head]: 'head'
+};
+const toApiRouteMethod = (httpMethod)=>{
+    const method = API_ROUTE_METHODS[httpMethod];
+    if (!method) throw new Error(`[bff-core] Unsupported HTTP method "${String(httpMethod)}" in API handler info`);
+    return method;
+};
+const getRouteMiddlewares = (handler)=>{
+    const middlewares = Reflect.getMetadata('middleware', handler);
+    return Array.isArray(middlewares) ? middlewares : [];
+};
+const planApiRoutes = (handlerInfos)=>handlerInfos.map(({ routePath, handler, httpMethod })=>({
+            method: toApiRouteMethod(httpMethod),
+            routePath,
+            handler,
+            middlewares: getRouteMiddlewares(handler)
+        }));
+const HANDLER_WITH_SCHEMA = 'HANDLER_WITH_SCHEMA';
+const isSchemaApiHandler = (handler)=>{
+    if ('function' != typeof handler) return false;
+    const marked = handler;
+    return true === marked[HANDLER_WITH_SCHEMA];
+};
+const getApiHandlerMode = (handler)=>{
+    if ((0, index_js_namespaceObject.isWithMetaHandler)(handler)) return 'meta';
+    if (isSchemaApiHandler(handler)) return 'schema';
+    if ((0, index_js_namespaceObject.isInputParamsDeciderHandler)(handler)) return 'inputParamsDecider';
+    return 'plain';
+};
+const mapSchemaHandlerResult = (result)=>{
+    if ('HandleSuccess' === result.type) return {
+        success: true,
+        status: 200,
+        body: result.value
+    };
+    return {
+        success: false,
+        status: 'InputValidationError' === result.type ? 400 : 500,
+        body: result.message
+    };
+};
+const getResponseMetaList = (handler)=>{
+    const responseMeta = Reflect.getMetadata(external_types_js_namespaceObject.HttpMetadata.Response, handler);
+    return Array.isArray(responseMeta) ? responseMeta : [];
+};
+const buildPositionalHandlerArgs = (input)=>[
+        ...Object.values(input.params),
+        input
+    ];
+const checkCrossProjectPolicy = (headers, policy)=>{
+    const violation = (0, crossProjectPolicy_js_namespaceObject.evaluateCrossProjectPolicy)(headers, policy);
+    if (!violation) return null;
+    return {
+        status: violation.status,
+        body: {
+            code: violation.code,
+            reason: violation.reason,
+            message: violation.message
+        }
+    };
+};
+exports.HANDLER_WITH_SCHEMA = __webpack_exports__.HANDLER_WITH_SCHEMA;
+exports.buildPositionalHandlerArgs = __webpack_exports__.buildPositionalHandlerArgs;
+exports.checkCrossProjectPolicy = __webpack_exports__.checkCrossProjectPolicy;
+exports.getApiHandlerMode = __webpack_exports__.getApiHandlerMode;
+exports.getResponseMetaList = __webpack_exports__.getResponseMetaList;
+exports.getRouteMiddlewares = __webpack_exports__.getRouteMiddlewares;
+exports.isSchemaApiHandler = __webpack_exports__.isSchemaApiHandler;
+exports.mapSchemaHandlerResult = __webpack_exports__.mapSchemaHandlerResult;
+exports.planApiRoutes = __webpack_exports__.planApiRoutes;
+exports.toApiRouteMethod = __webpack_exports__.toApiRouteMethod;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HANDLER_WITH_SCHEMA",
+    "buildPositionalHandlerArgs",
+    "checkCrossProjectPolicy",
+    "getApiHandlerMode",
+    "getResponseMetaList",
+    "getRouteMiddlewares",
+    "isSchemaApiHandler",
+    "mapSchemaHandlerResult",
+    "planApiRoutes",
+    "toApiRouteMethod"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/adapter-kit/parity.js

@@ -0,0 +1,546 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    PARITY_PRODUCER_REQUEST_ID: ()=>PARITY_PRODUCER_REQUEST_ID,
+    PARITY_REQUEST_ID: ()=>PARITY_REQUEST_ID,
+    assertParityResult: ()=>assertParityResult,
+    createAdapterParityScenarios: ()=>createAdapterParityScenarios,
+    createParityApiHandlerInfos: ()=>createParityApiHandlerInfos,
+    createParityBffConfig: ()=>createParityBffConfig,
+    toParityResult: ()=>toParityResult
+});
+const operationContracts_js_namespaceObject = require("../security/operationContracts.js");
+const external_types_js_namespaceObject = require("../types.js");
+const PARITY_REQUEST_ID = 'crm';
+const PARITY_PRODUCER_REQUEST_ID = 'crm.producer-a';
+const PARITY_FIXTURE_FILENAME = 'bff-core/adapter-kit/parity-fixture.ts';
+const HANDLER_WITH_SCHEMA = 'HANDLER_WITH_SCHEMA';
+const isRecord = (value)=>Boolean(value) && 'object' == typeof value;
+const createSchemaFixtureHandler = ()=>{
+    const handler = (input)=>{
+        const data = isRecord(input) && isRecord(input.data) ? input.data : void 0;
+        const id = data?.id;
+        if ('number' == typeof id) return {
+            type: 'HandleSuccess',
+            value: {
+                id
+            }
+        };
+        if ('boom' === id) return {
+            type: 'OutputValidationError',
+            message: 'invalid output'
+        };
+        return {
+            type: 'InputValidationError',
+            message: 'invalid input'
+        };
+    };
+    return Object.assign(handler, {
+        [HANDLER_WITH_SCHEMA]: true
+    });
+};
+const createParityApiHandlerInfos = ()=>[
+        {
+            name: 'getHello',
+            httpMethod: external_types_js_namespaceObject.HttpMethod.Get,
+            routeName: '/hello',
+            routePath: '/hello',
+            filename: PARITY_FIXTURE_FILENAME,
+            handler: ()=>({
+                    message: 'hello'
+                })
+        },
+        {
+            name: 'postHello',
+            httpMethod: external_types_js_namespaceObject.HttpMethod.Post,
+            routeName: '/hello',
+            routePath: '/hello',
+            filename: PARITY_FIXTURE_FILENAME,
+            handler: ()=>'hello'
+        },
+        {
+            name: 'getNothing',
+            httpMethod: external_types_js_namespaceObject.HttpMethod.Get,
+            routeName: '/nothing',
+            routePath: '/nothing',
+            filename: PARITY_FIXTURE_FILENAME,
+            handler: ()=>void 0
+        },
+        {
+            name: 'postEcho',
+            httpMethod: external_types_js_namespaceObject.HttpMethod.Post,
+            routeName: '/echo',
+            routePath: '/echo',
+            filename: PARITY_FIXTURE_FILENAME,
+            handler: (input)=>{
+                const normalized = isRecord(input) ? input : {};
+                return {
+                    data: normalized.data ?? null,
+                    query: normalized.query ?? {},
+                    cookie: normalized.cookies ?? null
+                };
+            }
+        },
+        {
+            name: 'getItem',
+            httpMethod: external_types_js_namespaceObject.HttpMethod.Get,
+            routeName: '/items/:id',
+            routePath: '/items/:id',
+            filename: PARITY_FIXTURE_FILENAME,
+            handler: (id, input)=>({
+                    id,
+                    query: isRecord(input) ? input.query ?? {} : {}
+                })
+        },
+        {
+            name: 'patchSchema',
+            httpMethod: external_types_js_namespaceObject.HttpMethod.Patch,
+            routeName: '/schema',
+            routePath: '/schema',
+            filename: PARITY_FIXTURE_FILENAME,
+            handler: createSchemaFixtureHandler()
+        }
+    ];
+const createParityBffConfig = ()=>({
+        requestId: PARITY_REQUEST_ID,
+        crossProjectPolicy: {
+            enabled: true,
+            allowedNamespaces: [
+                PARITY_REQUEST_ID
+            ]
+        }
+    });
+const getParityContracts = ()=>(0, operationContracts_js_namespaceObject.buildOperationContractMap)({
+        handlers: createParityApiHandlerInfos(),
+        requestId: PARITY_REQUEST_ID
+    });
+const envelopeHeader = (requestId)=>JSON.stringify(void 0 === requestId ? {} : {
+        requestId
+    });
+const detailHeader = (details)=>JSON.stringify(details);
+const deniedScenario = (name, reason, headers)=>({
+        name,
+        policy: true,
+        request: {
+            method: 'get',
+            path: '/hello',
+            headers
+        },
+        expected: {
+            kind: 'denied',
+            status: 403,
+            reason
+        }
+    });
+const createAdapterParityScenarios = ()=>{
+    const contracts = getParityContracts();
+    const helloContract = contracts['GET:/hello'];
+    const validEnvelope = envelopeHeader(PARITY_PRODUCER_REQUEST_ID);
+    const validOperationId = `${PARITY_PRODUCER_REQUEST_ID}:parity`;
+    return [
+        {
+            name: 'plain handler returns object payload',
+            policy: false,
+            request: {
+                method: 'get',
+                path: '/hello'
+            },
+            expected: {
+                kind: 'payload',
+                status: 200,
+                payload: {
+                    message: 'hello'
+                }
+            }
+        },
+        {
+            name: 'plain handler returns scalar payload',
+            policy: false,
+            request: {
+                method: 'post',
+                path: '/hello'
+            },
+            expected: {
+                kind: 'payload',
+                status: 200,
+                payload: 'hello'
+            }
+        },
+        {
+            name: 'plain handler returning undefined (pinned adapter drift)',
+            policy: false,
+            request: {
+                method: 'get',
+                path: '/nothing'
+            },
+            expected: {
+                kind: 'perAdapter',
+                expectations: {
+                    express: {
+                        status: 200,
+                        payload: void 0
+                    },
+                    koa: {
+                        status: 404,
+                        payload: 'Not Found'
+                    },
+                    hono: {
+                        status: 404,
+                        payload: '404 Not Found'
+                    }
+                }
+            }
+        },
+        {
+            name: 'plain handler receives data, query and cookies',
+            policy: false,
+            request: {
+                method: 'post',
+                path: '/echo?q=z',
+                headers: {
+                    'content-type': 'application/json',
+                    cookie: 'id=666'
+                },
+                body: {
+                    a: 1
+                }
+            },
+            expected: {
+                kind: 'payload',
+                status: 200,
+                payload: {
+                    data: {
+                        a: 1
+                    },
+                    query: {
+                        q: 'z'
+                    },
+                    cookie: 'id=666'
+                }
+            }
+        },
+        {
+            name: 'plain handler receives positional route params',
+            policy: false,
+            request: {
+                method: 'get',
+                path: '/items/123?q=x'
+            },
+            expected: {
+                kind: 'payload',
+                status: 200,
+                payload: {
+                    id: '123',
+                    query: {
+                        q: 'x'
+                    }
+                }
+            }
+        },
+        {
+            name: 'schema handler success (pinned adapter drift)',
+            policy: false,
+            request: {
+                method: 'patch',
+                path: '/schema',
+                headers: {
+                    'content-type': 'application/json'
+                },
+                body: {
+                    id: 777
+                }
+            },
+            expected: {
+                kind: 'perAdapter',
+                expectations: {
+                    express: {
+                        status: 200,
+                        payload: {
+                            id: 777
+                        }
+                    },
+                    koa: {
+                        status: 200,
+                        payload: {
+                            id: 777
+                        }
+                    },
+                    hono: {
+                        status: 200,
+                        payload: {
+                            type: 'HandleSuccess',
+                            value: {
+                                id: 777
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        {
+            name: 'schema handler input validation error (pinned adapter drift)',
+            policy: false,
+            request: {
+                method: 'patch',
+                path: '/schema',
+                headers: {
+                    'content-type': 'application/json'
+                },
+                body: {
+                    id: 'aaa'
+                }
+            },
+            expected: {
+                kind: 'perAdapter',
+                expectations: {
+                    express: {
+                        status: 400,
+                        payload: 'invalid input'
+                    },
+                    koa: {
+                        status: 400,
+                        payload: 'invalid input'
+                    },
+                    hono: {
+                        status: 200,
+                        payload: {
+                            type: 'InputValidationError',
+                            message: 'invalid input'
+                        }
+                    }
+                }
+            }
+        },
+        {
+            name: 'schema handler output validation error (pinned adapter drift)',
+            policy: false,
+            request: {
+                method: 'patch',
+                path: '/schema',
+                headers: {
+                    'content-type': 'application/json'
+                },
+                body: {
+                    id: 'boom'
+                }
+            },
+            expected: {
+                kind: 'perAdapter',
+                expectations: {
+                    express: {
+                        status: 500,
+                        payload: 'invalid output'
+                    },
+                    koa: {
+                        status: 500,
+                        payload: 'invalid output'
+                    },
+                    hono: {
+                        status: 200,
+                        payload: {
+                            type: 'OutputValidationError',
+                            message: 'invalid output'
+                        }
+                    }
+                }
+            }
+        },
+        {
+            name: 'policy pass with full operation context',
+            policy: true,
+            request: {
+                method: 'get',
+                path: '/hello',
+                headers: {
+                    'x-modernjs-bff-envelope': validEnvelope,
+                    'x-operation-id': validOperationId,
+                    'x-modernjs-bff-operation-context': detailHeader({
+                        requestId: PARITY_PRODUCER_REQUEST_ID,
+                        method: 'GET',
+                        routePath: '/hello',
+                        schemaHash: helloContract.schemaHash,
+                        operationVersion: helloContract.operationVersion
+                    })
+                }
+            },
+            expected: {
+                kind: 'payload',
+                status: 200,
+                payload: {
+                    message: 'hello'
+                }
+            }
+        },
+        deniedScenario('policy denies missing envelope', 'missing_envelope', {}),
+        deniedScenario('policy denies invalid envelope', 'invalid_envelope', {
+            'x-modernjs-bff-envelope': 'not-json'
+        }),
+        deniedScenario('policy denies envelope that is valid JSON but not an object', 'invalid_envelope', {
+            'x-modernjs-bff-envelope': '123'
+        }),
+        deniedScenario('policy denies missing requestId', 'missing_request_id', {
+            'x-modernjs-bff-envelope': envelopeHeader(void 0)
+        }),
+        deniedScenario('policy denies namespace outside allowlist', 'namespace_not_allowed', {
+            'x-modernjs-bff-envelope': envelopeHeader('billing.producer-z')
+        }),
+        deniedScenario('policy denies missing operation context', 'missing_operation_context', {
+            'x-modernjs-bff-envelope': validEnvelope
+        }),
+        deniedScenario('policy denies operation context mismatch', 'operation_context_mismatch', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': 'someone-else:parity'
+        }),
+        deniedScenario('policy denies missing operation context details', 'missing_operation_context_details', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId
+        }),
+        deniedScenario('policy denies JSON-array operation context details', 'invalid_operation_context_details', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId,
+            'x-modernjs-bff-operation-context': '[]'
+        }),
+        deniedScenario('policy denies invalid operation context details', 'invalid_operation_context_details', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId,
+            'x-modernjs-bff-operation-context': 'not-json'
+        }),
+        deniedScenario('policy denies detail requestId mismatch', 'operation_context_details_request_id_mismatch', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId,
+            'x-modernjs-bff-operation-context': detailHeader({
+                requestId: 'crm.producer-b',
+                method: 'GET',
+                routePath: '/hello',
+                schemaHash: helloContract.schemaHash,
+                operationVersion: helloContract.operationVersion
+            })
+        }),
+        deniedScenario('policy denies missing operation schema hash', 'missing_operation_schema_hash', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId,
+            'x-modernjs-bff-operation-context': detailHeader({
+                requestId: PARITY_PRODUCER_REQUEST_ID,
+                method: 'GET',
+                routePath: '/hello',
+                operationVersion: helloContract.operationVersion
+            })
+        }),
+        deniedScenario('policy denies missing operation version', 'missing_operation_version', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId,
+            'x-modernjs-bff-operation-context': detailHeader({
+                requestId: PARITY_PRODUCER_REQUEST_ID,
+                method: 'GET',
+                routePath: '/hello',
+                schemaHash: helloContract.schemaHash
+            })
+        }),
+        deniedScenario('policy denies unknown operation contract', 'unknown_operation_contract', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId,
+            'x-modernjs-bff-operation-context': detailHeader({
+                requestId: PARITY_PRODUCER_REQUEST_ID,
+                method: 'GET',
+                routePath: '/does-not-exist',
+                schemaHash: helloContract.schemaHash,
+                operationVersion: helloContract.operationVersion
+            })
+        }),
+        deniedScenario('policy denies operation schema hash mismatch', 'operation_schema_hash_mismatch', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId,
+            'x-modernjs-bff-operation-context': detailHeader({
+                requestId: PARITY_PRODUCER_REQUEST_ID,
+                method: 'GET',
+                routePath: '/hello',
+                schemaHash: 'deadbeef',
+                operationVersion: helloContract.operationVersion
+            })
+        }),
+        deniedScenario('policy denies operation version mismatch', 'operation_version_mismatch', {
+            'x-modernjs-bff-envelope': validEnvelope,
+            'x-operation-id': validOperationId,
+            'x-modernjs-bff-operation-context': detailHeader({
+                requestId: PARITY_PRODUCER_REQUEST_ID,
+                method: 'GET',
+                routePath: '/hello',
+                schemaHash: helloContract.schemaHash,
+                operationVersion: helloContract.operationVersion + 1
+            })
+        })
+    ];
+};
+const toParityResult = (res)=>({
+        status: res.status,
+        payload: res.type.includes('json') ? res.body : '' === res.text ? void 0 : res.text
+    });
+const formatValue = (value)=>JSON.stringify(value);
+const assertParityResult = (scenario, res, adapter)=>{
+    const result = toParityResult(res);
+    const failures = [];
+    let { expected } = scenario;
+    if ('perAdapter' === expected.kind) {
+        if (void 0 === adapter) throw new Error(`Adapter parity scenario "${scenario.name}" pins per-adapter drift; pass the adapter id to assertParityResult.`);
+        expected = {
+            kind: 'payload',
+            ...expected.expectations[adapter]
+        };
+    }
+    if (result.status !== expected.status) failures.push(`status: expected ${expected.status}, received ${result.status}`);
+    if ('payload' === expected.kind) {
+        if (formatValue(result.payload) !== formatValue(expected.payload)) failures.push(`payload: expected ${formatValue(expected.payload)}, received ${formatValue(result.payload)}`);
+    } else {
+        const payload = isRecord(result.payload) ? result.payload : {};
+        if ('BFF_CROSS_PROJECT_POLICY_DENIED' !== payload.code) failures.push(`denial code: expected "BFF_CROSS_PROJECT_POLICY_DENIED", received ${formatValue(payload.code)}`);
+        if (payload.reason !== expected.reason) failures.push(`denial reason: expected "${expected.reason}", received ${formatValue(payload.reason)}`);
+        if ('string' != typeof payload.message || 0 === payload.message.length) failures.push(`denial message: expected non-empty string, received ${formatValue(payload.message)}`);
+    }
+    if (failures.length > 0) throw new Error(`Adapter parity scenario "${scenario.name}" failed:\n- ${failures.join('\n- ')}`);
+};
+exports.PARITY_PRODUCER_REQUEST_ID = __webpack_exports__.PARITY_PRODUCER_REQUEST_ID;
+exports.PARITY_REQUEST_ID = __webpack_exports__.PARITY_REQUEST_ID;
+exports.assertParityResult = __webpack_exports__.assertParityResult;
+exports.createAdapterParityScenarios = __webpack_exports__.createAdapterParityScenarios;
+exports.createParityApiHandlerInfos = __webpack_exports__.createParityApiHandlerInfos;
+exports.createParityBffConfig = __webpack_exports__.createParityBffConfig;
+exports.toParityResult = __webpack_exports__.toParityResult;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PARITY_PRODUCER_REQUEST_ID",
+    "PARITY_REQUEST_ID",
+    "assertParityResult",
+    "createAdapterParityScenarios",
+    "createParityApiHandlerInfos",
+    "createParityBffConfig",
+    "toParityResult"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});