@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

package/dist/cjs/runtime/effect-client/runtime.js

@@ -0,0 +1,266 @@
+"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__, {
+    createGeneratedEffectClient: ()=>createGeneratedEffectClient
+});
+const index_js_namespaceObject = require("../data-platform/index.js");
+const METHODS_WITHOUT_BODY = new Set([
+    'GET',
+    'DELETE',
+    'HEAD',
+    'OPTIONS'
+]);
+const DATA_REQUEST_MODES = new Set([
+    'cache-first',
+    'stale-while-revalidate',
+    'network-only'
+]);
+const DATA_MUTATION_MODES = new Set([
+    'optimistic',
+    'pessimistic',
+    'fire-and-forget'
+]);
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+const isDataRequestMode = (value)=>'string' == typeof value && DATA_REQUEST_MODES.has(value);
+const isDataMutationMode = (value)=>'string' == typeof value && DATA_MUTATION_MODES.has(value);
+const normalizeOrigin = (value)=>{
+    if ('string' != typeof value || 0 === value.length) return;
+    try {
+        return new URL(value).origin;
+    } catch  {
+        return;
+    }
+};
+const resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
+const resolveOrigin = (defaultOrigin)=>{
+    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
+    const globalLocation = globalThis?.location;
+    if (globalLocation && 'string' == typeof globalLocation.origin && globalLocation.origin) return globalLocation.origin;
+    return defaultOrigin;
+};
+const normalizeRequest = (method, request)=>{
+    if (!isRecord(request)) return {};
+    const payload = {
+        ...request
+    };
+    if (isRecord(request.path) && !isRecord(payload.params)) payload.params = request.path;
+    if (isRecord(request.urlParams) && !isRecord(payload.query)) payload.query = request.urlParams;
+    if (isRecord(request.headers) && !isRecord(payload.headers)) payload.headers = request.headers;
+    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
+    else if (METHODS_WITHOUT_BODY.has(method)) {
+        if (isRecord(request.payload)) payload.query = isRecord(payload.query) ? {
+            ...payload.query,
+            ...request.payload
+        } : request.payload;
+        else if (!('body' in payload)) payload.body = request.payload;
+    } else if (!isRecord(request.payload) || 'data' in payload) {
+        if (!('body' in payload)) payload.body = request.payload;
+    } else payload.data = request.payload;
+    return payload;
+};
+const resolveTargetOrigin = (dataPlatform, defaultOrigin)=>{
+    const explicitTargetOrigin = stringOrUndefined(dataPlatform.targetOrigin) || stringOrUndefined(dataPlatform.endpointOrigin);
+    if (explicitTargetOrigin) return explicitTargetOrigin;
+    return defaultOrigin;
+};
+const shouldAttachEnvelopeHeader = (dataPlatform, defaultOrigin)=>{
+    if (true === dataPlatform.allowCrossOriginEnvelope) return true;
+    const currentOrigin = normalizeOrigin(resolveOrigin(defaultOrigin));
+    const targetOrigin = normalizeOrigin(resolveTargetOrigin(dataPlatform, defaultOrigin));
+    if (!currentOrigin || !targetOrigin) return true;
+    return currentOrigin === targetOrigin;
+};
+const toEnvelopeInput = (normalizedRequest)=>{
+    const payload = {};
+    if (isRecord(normalizedRequest.params)) payload.path = normalizedRequest.params;
+    if (isRecord(normalizedRequest.query)) payload.query = normalizedRequest.query;
+    if ('data' in normalizedRequest && void 0 !== normalizedRequest.data) payload.data = normalizedRequest.data;
+    if ('body' in normalizedRequest && void 0 !== normalizedRequest.body) payload.body = normalizedRequest.body;
+    if ("u" > typeof FormData && normalizedRequest.formData instanceof FormData) payload.formData = Array.from(normalizedRequest.formData.entries()).map(([key, value])=>[
+            key,
+            String(value)
+        ]);
+    if ("u" > typeof URLSearchParams && normalizedRequest.formUrlencoded instanceof URLSearchParams) payload.formUrlencoded = normalizedRequest.formUrlencoded.toString();
+    return payload;
+};
+const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
+    const createRequest = requestRuntime.createRequest;
+    const configureRequest = 'function' == typeof requestRuntime.configure ? requestRuntime.configure : void 0;
+    const createRequestContextHeaders = 'function' == typeof requestRuntime.createRequestContextHeaders ? requestRuntime.createRequestContextHeaders : void 0;
+    const defaultOrigin = config.defaultOrigin;
+    const httpMethodDecider = config.httpMethodDecider || 'functionName';
+    const port = config.useEnvPort && "u" > typeof process && process.env && process.env.PORT ? process.env.PORT : config.port;
+    if (config.requestId && configureRequest) {
+        const configurePayload = {
+            requestId: config.requestId,
+            requireEnvelope: true,
+            identityBinding: {
+                enabled: true,
+                strict: true
+            },
+            operationContract: {
+                enabled: true,
+                strict: true,
+                requireSchemaHash: true,
+                requireOperationVersion: true
+            },
+            setDomain: ()=>resolveOrigin(defaultOrigin)
+        };
+        const runtimeFetch = resolveRuntimeFetch();
+        if (false !== config.batch.enabled && runtimeFetch) configurePayload.request = (0, index_js_namespaceObject.createDataBatchTransport)({
+            fetch: runtimeFetch,
+            endpoint: config.batch.endpoint,
+            flushIntervalMs: config.batch.flushIntervalMs,
+            maxBatchSize: config.batch.maxBatchSize,
+            maxBatchBytes: config.batch.maxBatchBytes,
+            requestTimeoutMs: config.batch.requestTimeoutMs,
+            allowedMethods: config.batch.allowedMethods
+        });
+        configureRequest(configurePayload);
+    }
+    const createEffectRequestContext = (requestContext)=>{
+        if (!isRecord(requestContext)) return {};
+        const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
+        return {
+            ...requestContext,
+            headers
+        };
+    };
+    const applyRequestContext = (normalizedRequest, request)=>{
+        if (!isRecord(request) || !isRecord(request.requestContext)) return normalizedRequest;
+        const requestContext = createEffectRequestContext(request.requestContext);
+        const requestHeaders = isRecord(requestContext.headers) ? requestContext.headers : {};
+        if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
+        return {
+            ...normalizedRequest,
+            headers: {
+                ...requestHeaders,
+                ...isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {}
+            }
+        };
+    };
+    const prepareEffectRequest = (endpoint, operation, request)=>{
+        const normalizedRequest = applyRequestContext(normalizeRequest(endpoint.method, request), request);
+        const dataPlatform = isRecord(request) && isRecord(request.dataPlatform) ? request.dataPlatform : {};
+        const strictEnvelope = true === dataPlatform.requireEnvelope || true === dataPlatform.strict;
+        if (!strictEnvelope && !shouldAttachEnvelopeHeader(dataPlatform, defaultOrigin)) return normalizedRequest;
+        try {
+            const namespace = stringOrUndefined(dataPlatform.appNamespace) || config.appNamespace;
+            const origin = stringOrUndefined(dataPlatform.origin) || resolveOrigin(defaultOrigin);
+            const envelope = (0, index_js_namespaceObject.createRequestEnvelope)({
+                operation: {
+                    ...operation,
+                    appNamespace: namespace
+                },
+                scope: {
+                    appNamespace: namespace,
+                    origin,
+                    tenantId: stringOrUndefined(dataPlatform.tenantId),
+                    userId: stringOrUndefined(dataPlatform.userId),
+                    sessionId: stringOrUndefined(dataPlatform.sessionId)
+                },
+                requestInput: {
+                    method: endpoint.method,
+                    routePath: endpoint.routePath,
+                    payload: toEnvelopeInput(normalizedRequest)
+                },
+                requestMode: isDataRequestMode(dataPlatform.requestMode) ? dataPlatform.requestMode : void 0,
+                mutationMode: isDataMutationMode(dataPlatform.mutationMode) ? dataPlatform.mutationMode : void 0,
+                selectionPlan: isRecord(dataPlatform.selectionPlan) ? dataPlatform.selectionPlan : void 0,
+                traceContext: isRecord(dataPlatform.traceContext) ? dataPlatform.traceContext : void 0,
+                requireTraceContext: true === dataPlatform.requireTraceContext
+            });
+            const headerName = stringOrUndefined(dataPlatform.envelopeHeader) || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
+            const headers = isRecord(normalizedRequest.headers) ? {
+                ...normalizedRequest.headers
+            } : {};
+            if (false === dataPlatform.batch) headers[index_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER] = 'off';
+            headers[headerName] = (0, index_js_namespaceObject.encodeRequestEnvelopeHeader)(envelope);
+            return {
+                ...normalizedRequest,
+                headers
+            };
+        } catch (error) {
+            if (strictEnvelope) throw error;
+            return normalizedRequest;
+        }
+    };
+    const client = {};
+    const operationManifest = {};
+    for (const endpoint of manifest.endpoints){
+        const operationId = `${endpoint.method}:${endpoint.routePath}`;
+        const operation = {
+            appNamespace: config.appNamespace,
+            apiId: endpoint.apiId,
+            group: endpoint.group,
+            endpoint: endpoint.endpoint,
+            operationId,
+            routePath: endpoint.routePath,
+            method: endpoint.method,
+            operationVersion: endpoint.operationVersion,
+            schemaHash: endpoint.schemaHash,
+            version: endpoint.operationVersion
+        };
+        const sender = createRequest({
+            path: endpoint.routePath,
+            method: endpoint.method,
+            port,
+            operationContext: {
+                operationId,
+                routePath: endpoint.routePath,
+                method: endpoint.method,
+                schemaHash: endpoint.schemaHash,
+                operationVersion: endpoint.operationVersion
+            },
+            httpMethodDecider,
+            ...config.requestId ? {
+                requestId: config.requestId
+            } : {}
+        });
+        const call = (request = {})=>sender(prepareEffectRequest(endpoint, operation, request));
+        client[endpoint.group] ??= {};
+        client[endpoint.group][endpoint.endpoint] = call;
+        operationManifest[endpoint.group] ??= {};
+        operationManifest[endpoint.group][endpoint.endpoint] = operation;
+    }
+    return {
+        client,
+        operationManifest,
+        createEffectRequestContext
+    };
+};
+exports.createGeneratedEffectClient = __webpack_exports__.createGeneratedEffectClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createGeneratedEffectClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/hono/adapter.js

@@ -43,6 +43,8 @@ const server_core_namespaceObject = require("@modern-js/server-core");
 const utils_namespaceObject = require("@modern-js/utils");
 const createHonoRoutes_js_namespaceObject = require("../../utils/createHonoRoutes.js");
 var createHonoRoutes_js_default = /*#__PURE__*/ __webpack_require__.n(createHonoRoutes_js_namespaceObject);
+const crossProjectServerPolicy_js_namespaceObject = require("../../utils/crossProjectServerPolicy.js");
+const external_safe_failure_js_namespaceObject = require("../safe-failure.js");
 const before = [
     'custom-server-hook',
     'custom-server-middleware',
@@ -60,6 +62,7 @@ class HonoAdapter {
         this.apiMiddleware = [];
         this.apiServer = null;
         this.isHono = true;
+        this.prefix = '/api';
         this.setHandlers = async ()=>{
             if (!this.isHono) return;
             const { apiHandlerInfos } = this.api.getServerContext();
@@ -72,6 +75,22 @@ class HonoAdapter {
                     order: 'post',
                     before
                 }));
+            this.crossProjectPolicy = (0, crossProjectServerPolicy_js_namespaceObject.resolveAdapterCrossProjectPolicy)(this.api, apiHandlerInfos || []);
+            if (this.crossProjectPolicy) {
+                const policyMiddleware = async (c, next)=>{
+                    const denial = (0, crossProjectServerPolicy_js_namespaceObject.checkCrossProjectPolicyResponse)(c.req.header(), this.crossProjectPolicy);
+                    if (denial) return denial;
+                    await next();
+                };
+                this.apiMiddleware.unshift({
+                    name: 'bff-cross-project-policy',
+                    path: `${this.prefix}/*`,
+                    method: 'all',
+                    handler: policyMiddleware,
+                    order: 'post',
+                    before
+                });
+            }
         };
         this.registerApiRoutes = async ()=>{
             if (!this.isHono) return;
@@ -108,15 +127,7 @@ class HonoAdapter {
                 } catch (configError) {
                     utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${configError}`);
                 }
-                const status = 'object' == typeof err && null !== err && 'status' in err && 'number' == typeof err.status ? err.status : 500;
-                return new Response(JSON.stringify({
-                    message: err instanceof Error ? err.message : '[BFF] Internal Server Error'
-                }), {
-                    status,
-                    headers: {
-                        'content-type': 'application/json; charset=utf-8'
-                    }
-                });
+                return (0, external_safe_failure_js_namespaceObject.createSafeFailureResponse)(err);
             });
         };
         this.registerMiddleware = async (options)=>{
@@ -126,6 +137,7 @@ class HonoAdapter {
                 this.isHono = false;
                 return;
             }
+            this.prefix = prefix || this.prefix;
             const { middlewares: globalMiddlewares } = this.api.getServerContext();
             await this.setHandlers();
             if ((0, utils_namespaceObject.isProd)()) globalMiddlewares.push(...this.apiMiddleware);

package/dist/cjs/runtime/safe-failure.js

@@ -0,0 +1,83 @@
+"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__);
+const SAFE_FAILURE_MESSAGES = {
+    500: 'Internal Server Error',
+    503: 'Service Unavailable'
+};
+const SAFE_FAILURE_CODES = {
+    500: 'INTERNAL_SERVER_ERROR',
+    503: 'SERVICE_UNAVAILABLE'
+};
+const readErrorProperty = (error, key)=>{
+    if ('object' != typeof error || null === error || !(key in error)) return;
+    return error[key];
+};
+const normalizeFailureStatus = (value)=>{
+    if ('number' != typeof value || !Number.isInteger(value)) return;
+    return value >= 400 && value <= 599 ? value : void 0;
+};
+const normalizeRetryAfter = (value)=>{
+    if ('number' == typeof value && Number.isFinite(value) && value >= 0) return String(Math.ceil(value));
+    if ('string' == typeof value) {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : void 0;
+    }
+    if (value instanceof Date) return value.toUTCString();
+};
+const createSafeFailureResponse = (error)=>{
+    const status = normalizeFailureStatus(readErrorProperty(error, 'status')) ?? normalizeFailureStatus(readErrorProperty(error, 'statusCode')) ?? 500;
+    const retryAfter = 503 === status ? normalizeRetryAfter(readErrorProperty(error, 'retryAfter')) ?? normalizeRetryAfter(readErrorProperty(error, 'retryAfterSeconds')) ?? normalizeRetryAfter('number' == typeof readErrorProperty(error, 'retryAfterMs') ? readErrorProperty(error, 'retryAfterMs') / 1000 : void 0) : void 0;
+    const body = {
+        success: false,
+        error: {
+            code: SAFE_FAILURE_CODES[status] ?? 'REQUEST_FAILED',
+            message: SAFE_FAILURE_MESSAGES[status] ?? 'Request failed',
+            status
+        }
+    };
+    const headers = {
+        'content-type': 'application/json; charset=utf-8'
+    };
+    if (void 0 !== retryAfter) headers['Retry-After'] = retryAfter;
+    return new Response(JSON.stringify(body), {
+        status,
+        headers
+    });
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    createSafeFailureResponse: createSafeFailureResponse
+});
+exports.createSafeFailureResponse = __webpack_exports__.createSafeFailureResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSafeFailureResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/clientGenerator.js

@@ -306,7 +306,7 @@ async function clientGenerator(draftOptions) {
                     source: effectSource,
                     relativeDistPath: draftOptions.relativeDistPath
                 });
-                const effectClientCode = await (0, external_effectClientGenerator_js_namespaceObject.generateEffectClientCode)({
+                const effectClientArtifacts = await (0, external_effectClientGenerator_js_namespaceObject.generateEffectClient)({
                     appDir: draftOptions.appDir,
                     apiDir: draftOptions.apiDir,
                     resourcePath: effectEntryFile,
@@ -317,10 +317,10 @@ async function clientGenerator(draftOptions) {
                     httpMethodDecider: draftOptions.httpMethodDecider,
                     dataPlatformBatch: draftOptions.effectDataPlatformBatch
                 });
-                if (effectClientCode) {
+                if (effectClientArtifacts) {
                     const targetTypeFile = effectFileDetails.targetDir.replace(/\.js$/, '.d.ts');
-                    await writeTargetFile(effectFileDetails.absTargetDir, effectClientCode);
-                    await writeTargetFile(external_path_default().resolve(targetTypeFile), (0, external_effectClientGenerator_js_namespaceObject.renderEffectClientDeclaration)());
+                    await writeTargetFile(effectFileDetails.absTargetDir, effectClientArtifacts.code);
+                    await writeTargetFile(external_path_default().resolve(targetTypeFile), effectClientArtifacts.declaration);
                     generatedSourceList.push(effectFileDetails);
                 }
             }

package/dist/cjs/utils/crossProjectServerPolicy.js

@@ -0,0 +1,104 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    checkCrossProjectPolicyForRequest: ()=>checkCrossProjectPolicyForRequest,
+    checkCrossProjectPolicyResponse: ()=>checkCrossProjectPolicyResponse,
+    resolveAdapterCrossProjectPolicy: ()=>resolveAdapterCrossProjectPolicy
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const readNearestPackageVersion = (startDir)=>{
+    if (!startDir) return;
+    let current = external_path_default().resolve(startDir);
+    for(let depth = 0; depth < 10; depth += 1){
+        try {
+            const packageJson = require(external_path_default().join(current, 'package.json'));
+            if ('string' == typeof packageJson.version) return packageJson.version;
+        } catch  {}
+        const parent = external_path_default().dirname(current);
+        if (parent === current) break;
+        current = parent;
+    }
+};
+const resolveAdapterCrossProjectPolicy = (api, handlers)=>{
+    const bff = api.getServerConfig()?.bff;
+    const { apiDirectory, appDirectory } = api.getServerContext();
+    return (0, bff_core_namespaceObject.resolveCrossProjectPolicy)({
+        crossProjectPolicy: bff?.crossProjectPolicy,
+        handlers,
+        requestId: bff?.requestId,
+        isCrossProjectServer: bff?.isCrossProjectServer,
+        operationVersion: (0, bff_core_namespaceObject.deriveOperationVersion)(readNearestPackageVersion(apiDirectory) ?? readNearestPackageVersion(appDirectory))
+    });
+};
+const DENIAL_HEADERS = {
+    'content-type': 'application/json; charset=utf-8'
+};
+const checkCrossProjectPolicyResponse = (headers, policy)=>{
+    if (!policy?.enabled) return null;
+    const denial = (0, bff_core_namespaceObject.checkCrossProjectPolicy)(headers, policy);
+    if (!denial) return null;
+    return new Response(JSON.stringify(denial.body), {
+        status: denial.status,
+        headers: DENIAL_HEADERS
+    });
+};
+const toHeaderRecord = (headers)=>{
+    const record = {};
+    headers.forEach((value, key)=>{
+        record[key] = value;
+    });
+    return record;
+};
+const checkCrossProjectPolicyForRequest = (request, policy)=>{
+    if (!policy?.enabled) return null;
+    return checkCrossProjectPolicyResponse(toHeaderRecord(request.headers), policy);
+};
+exports.checkCrossProjectPolicyForRequest = __webpack_exports__.checkCrossProjectPolicyForRequest;
+exports.checkCrossProjectPolicyResponse = __webpack_exports__.checkCrossProjectPolicyResponse;
+exports.resolveAdapterCrossProjectPolicy = __webpack_exports__.resolveAdapterCrossProjectPolicy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "checkCrossProjectPolicyForRequest",
+    "checkCrossProjectPolicyResponse",
+    "resolveAdapterCrossProjectPolicy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});