@bleedingdev/modern-js-bff-effect 3.8.3-ultramodern.2

package/dist/esm/effect/handler/rpc.mjs

@@ -0,0 +1,22 @@
+import { HttpRouter } from "effect/unstable/http";
+import { RpcServer } from "effect/unstable/rpc";
+import { getRpcSerializationLayer } from "../rpcSerialization.mjs";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+function normalizeRpcPath(pathname) {
+    if (!pathname || '/' === pathname) return '/rpc';
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function createRpcApiHandler(options) {
+    const rpcPath = normalizeRpcPath(options.path);
+    const rpcLayer = __rspack_external_effect_Layer_69c46453.provide(RpcServer.layerHttp({
+        group: options.group,
+        path: rpcPath,
+        protocol: 'http',
+        disableTracing: options.disableTracing,
+        spanPrefix: options.spanPrefix,
+        spanAttributes: options.spanAttributes
+    }), __rspack_external_effect_Layer_69c46453.mergeAll(options.layer, getRpcSerializationLayer(options.serialization)));
+    return HttpRouter.toWebHandler(rpcLayer);
+}
+export { createRpcApiHandler, normalizeRpcPath };

package/dist/esm/effect/handler/types.mjs

@@ -0,0 +1,5 @@
+import * as __rspack_external_effect_Context_b3520bd3 from "effect/Context";
+const emptyEffectServiceContext = __rspack_external_effect_Context_b3520bd3.empty();
+const isEffectServiceContext = (context)=>'object' == typeof context && null !== context && 'mapUnsafe' in context;
+const toEffectServiceContext = (context)=>isEffectServiceContext(context) ? context : emptyEffectServiceContext;
+export { toEffectServiceContext };

package/dist/esm/effect/handler.mjs

@@ -0,0 +1,13 @@
+import * as __rspack_external_effect_Config_76cfa59d from "effect/Config";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+import * as __rspack_external_effect_Option_0498e63a from "effect/Option";
+import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
+export * from "effect/unstable/http";
+export * from "effect/unstable/httpapi";
+export * from "effect/unstable/rpc";
+export { HttpTraceContext } from "effect/unstable/http";
+export { HttpApiBuilder } from "effect/unstable/httpapi";
+export { defineEffectBff, defineEffectRpcBff } from "./handler/definition.mjs";
+export { createHttpApiHandler } from "./handler/http.mjs";
+export { __rspack_external_effect_Config_76cfa59d as Config, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Option_0498e63a as Option, __rspack_external_effect_Schema_6065f72d as Schema };

package/dist/esm/effect/index.mjs

@@ -0,0 +1,7 @@
+import * as __rspack_external__effect_opentelemetry_66324c75 from "@effect/opentelemetry";
+export * from "./endpoint-contracts.mjs";
+export * from "./handler.mjs";
+export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext } from "./context.mjs";
+export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest } from "./edge.mjs";
+export { resolveEffectBffModuleHandler } from "./module.mjs";
+export { __rspack_external__effect_opentelemetry_66324c75 as OpenTelemetry };

package/dist/esm/effect/module.mjs

@@ -0,0 +1,80 @@
+import { HttpApi } from "effect/unstable/httpapi";
+import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory, strictEffectApproachMessage } from "./entry-shape.mjs";
+import { createHttpApiHandler } from "./handler.mjs";
+function isRequestHandler(value) {
+    return 'function' == typeof value;
+}
+function shareDispose(dispose) {
+    let disposePromise;
+    return ()=>{
+        disposePromise ??= Promise.resolve().then(dispose);
+        return disposePromise;
+    };
+}
+function rejectLegacyEffectModuleShape(options, shape) {
+    options.onWarning?.(`${strictEffectApproachMessage} Rejected ${shape}.`);
+    return true;
+}
+function callEffectBffRequestHandler(handler, request, context) {
+    return void 0 === context ? handler(request) : handler(request, context);
+}
+function createLoadedHandler(webHandler) {
+    return {
+        handler: (request, context)=>callEffectBffRequestHandler(webHandler.handler, request, context),
+        dispose: shareDispose(webHandler.dispose)
+    };
+}
+function createLoadedHttpApiHandler(webHandler) {
+    return createLoadedHandler({
+        handler: webHandler.handler,
+        dispose: webHandler.dispose
+    });
+}
+function classifyEffectBffRuntimeEntryShape(module) {
+    return classifyEffectBffEntryModule(module, {
+        isRequestHandler: isRequestHandler,
+        isValidatorAwareHandlerFactory: isValidatorAwareHandlerFactory,
+        isHttpApi: HttpApi.isHttpApi
+    });
+}
+function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
+    if (!facts) return null;
+    if (facts.legacyShape) {
+        if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) return null;
+    }
+    if ('function' == typeof facts.createHandler) {
+        if (facts.createHandlerValidatorAware) {
+            const factory = facts.createHandler;
+            const webHandler = factory({
+                openapi: options.openapi,
+                dataPlatform: options.dataPlatform,
+                validateRequest: options.validateRequest
+            });
+            return createLoadedHandler(webHandler);
+        }
+        if (void 0 === facts.api || !facts.hasRuntimeLayer) {
+            rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export');
+            return null;
+        }
+        options.onWarning?.(`${strictEffectApproachMessage} Ignored unbranded \`createHandler\` export and rebuilt the handler from its { api, layer } exports.`);
+    }
+    if (void 0 !== facts.api && facts.hasRuntimeLayer) {
+        if (void 0 === facts.createHandler) options.onWarning?.('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/bff-effect/effect to avoid module instance mismatch.');
+        const webHandler = createHttpApiHandler({
+            api: facts.api,
+            layer: facts.layer,
+            openapi: options.openapi,
+            dataPlatform: options.dataPlatform,
+            validateRequest: options.validateRequest
+        });
+        return createLoadedHttpApiHandler(webHandler);
+    }
+    return null;
+}
+function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
+    return resolveClassifiedEffectBffModuleHandler(classifyEffectBffRuntimeEntryShape(normalizedModule), options);
+}
+function resolveEffectBffModuleHandler(mod, options = {}) {
+    return Promise.resolve(resolveNormalizedEffectBffModuleHandler(mod, options));
+}
+export { resolveEffectBffModuleHandler };

package/dist/esm/effect/operation-context.mjs

@@ -0,0 +1,75 @@
+import { BFF_LOCALE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, BFF_TRACEPARENT_HEADER, parseTraceparent } from "@modern-js/create-request";
+const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
+const readHeader = (headers, header)=>{
+    const value = headers.get(header);
+    return value && value.length > 0 ? value : void 0;
+};
+const copyStringField = (target, details, key)=>{
+    const value = details[key];
+    if ('string' == typeof value && value.length > 0) target[key] = value;
+};
+const readOperationContextDetails = (request)=>{
+    const rawDetails = readHeader(request.headers, BFF_OPERATION_CONTEXT_DETAIL_HEADER);
+    if (!rawDetails) return {};
+    try {
+        const parsed = JSON.parse(rawDetails);
+        if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) return {};
+        const details = parsed;
+        const safeDetails = {};
+        copyStringField(safeDetails, details, 'requestId');
+        copyStringField(safeDetails, details, 'operationId');
+        copyStringField(safeDetails, details, 'schemaHash');
+        copyStringField(safeDetails, details, 'traceparent');
+        copyStringField(safeDetails, details, 'traceId');
+        copyStringField(safeDetails, details, 'spanId');
+        if ('number' == typeof details.operationVersion) safeDetails.operationVersion = details.operationVersion;
+        return safeDetails;
+    } catch  {
+        return {};
+    }
+};
+const createEffectOperationContext = ({ request, path, method })=>{
+    const details = readOperationContextDetails(request);
+    const operationDetails = {
+        ...details
+    };
+    delete operationDetails.traceparent;
+    delete operationDetails.traceId;
+    delete operationDetails.spanId;
+    const servicePath = new URL(request.url).pathname;
+    const headerTraceparent = readHeader(request.headers, BFF_TRACEPARENT_HEADER);
+    const headerTraceContext = parseTraceparent(headerTraceparent);
+    const detailTraceContext = parseTraceparent(details.traceparent);
+    const traceparent = headerTraceContext ? headerTraceparent : detailTraceContext ? details.traceparent : void 0;
+    const parsedTraceparent = headerTraceContext || detailTraceContext || (details.traceId && details.spanId ? {
+        traceId: details.traceId,
+        spanId: details.spanId
+    } : void 0);
+    const locale = readHeader(request.headers, BFF_LOCALE_HEADER);
+    const headerOperationId = readHeader(request.headers, BFF_OPERATION_CONTEXT_HEADER);
+    return {
+        ...operationDetails,
+        ...headerOperationId || details.operationId ? {
+            operationId: headerOperationId || details.operationId
+        } : {},
+        routePath: servicePath,
+        method: (method || request.method || 'GET').toUpperCase(),
+        source: 'effect-adapter',
+        ...path && path !== servicePath ? {
+            attributes: {
+                mountedPath: path
+            }
+        } : {},
+        ...locale ? {
+            locale
+        } : {},
+        ...traceparent ? {
+            traceparent
+        } : {},
+        ...parsedTraceparent ? {
+            traceId: parsedTraceparent.traceId,
+            spanId: parsedTraceparent.spanId
+        } : {}
+    };
+};
+export { createEffectOperationContext, kEffectContextStorage };

package/dist/esm/effect/rpcSerialization.mjs

@@ -0,0 +1,16 @@
+import { RpcSerialization } from "effect/unstable/rpc";
+function getRpcSerializationLayer(serialization) {
+    switch(serialization){
+        case 'ndjson':
+            return RpcSerialization.layerNdjson;
+        case 'jsonRpc':
+            return RpcSerialization.layerJsonRpc();
+        case 'ndJsonRpc':
+            return RpcSerialization.layerNdJsonRpc();
+        case 'msgPack':
+            return RpcSerialization.layerMsgPack;
+        default:
+            return RpcSerialization.layerJsonRpc();
+    }
+}
+export { getRpcSerializationLayer };

package/dist/esm/effect-client/batch.mjs

@@ -0,0 +1,35 @@
+import { createDataBatchTransport } from "../data-platform/index.mjs";
+import { resolveOrigin } from "./envelope.mjs";
+const resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
+const configureGeneratedEffectClientRuntime = (config, configureRequest)=>{
+    const defaultOrigin = config.defaultOrigin;
+    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 = 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);
+    }
+};
+export { configureGeneratedEffectClientRuntime };

package/dist/esm/effect-client/envelope.mjs

@@ -0,0 +1,104 @@
+import { DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, createRequestEnvelope, encodeRequestEnvelopeHeader } from "../data-platform/index.mjs";
+import { isRecord, stringOrUndefined } from "./guards.mjs";
+import { normalizeRequest } from "./request.mjs";
+import { applyRequestContext } from "./request-context.mjs";
+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 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 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 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 prepareEffectRequest = (options)=>{
+    const { endpoint, operation, request, config, createEffectRequestContext } = options;
+    const defaultOrigin = config.defaultOrigin;
+    const normalizedRequest = applyRequestContext(normalizeRequest(endpoint.method, request), request, createEffectRequestContext);
+    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 = 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) || DEFAULT_DATA_ENVELOPE_HEADER;
+        const headers = isRecord(normalizedRequest.headers) ? {
+            ...normalizedRequest.headers
+        } : {};
+        if (false === dataPlatform.batch) headers[DEFAULT_DATA_BATCH_HEADER] = 'off';
+        headers[headerName] = encodeRequestEnvelopeHeader(envelope);
+        return {
+            ...normalizedRequest,
+            headers
+        };
+    } catch (error) {
+        if (strictEnvelope) throw error;
+        return normalizedRequest;
+    }
+};
+export { prepareEffectRequest, resolveOrigin };

package/dist/esm/effect-client/guards.mjs

@@ -0,0 +1,3 @@
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+export { isRecord, stringOrUndefined };

package/dist/esm/effect-client/index.mjs

@@ -0,0 +1,110 @@
+import { createRequestContextHeaders } from "@modern-js/create-request";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
+import { getRpcSerializationLayer } from "../effect/rpcSerialization.mjs";
+import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
+import * as __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 from "effect/unstable/http/HttpClientError";
+import * as __rspack_external_effect_Data_2b3f4efb from "effect/Data";
+import * as __rspack_external_effect_Exit_1ca64b33 from "effect/Exit";
+import * as __rspack_external_effect_ManagedRuntime_bfe218e3 from "effect/ManagedRuntime";
+import * as __rspack_external_effect_Scope_f87b0bd6 from "effect/Scope";
+class EffectRpcClientError extends __rspack_external_effect_Data_2b3f4efb.TaggedError('EffectRpcClientError') {
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function applySelection(value, selection) {
+    if (true === selection || void 0 === selection) return value;
+    if (Array.isArray(value)) return value.map((item)=>applySelection(item, selection));
+    if (!isRecord(value) || !isRecord(selection)) return value;
+    const masked = {};
+    for (const key of Object.keys(selection)){
+        const selected = selection[key];
+        if (void 0 !== selected && key in value && (true === selected || isRecord(selected))) masked[key] = applySelection(value[key], selected);
+    }
+    return masked;
+}
+function view() {
+    return (selection)=>selection;
+}
+function mask(value, selection) {
+    return applySelection(value, selection);
+}
+function runEffectView(request, selection) {
+    return new Promise((resolve, reject)=>{
+        request.then((value)=>resolve(mask(value, selection)), (reason)=>reject(reason));
+    });
+}
+function makeEffectHttpApiClient(api, options) {
+    const requestContextHeaders = createRequestContextHeaders(options?.requestContext);
+    const transformClient = (client)=>{
+        const contextClient = 0 === Object.keys(requestContextHeaders).length ? client : client.pipe(HttpClient.mapRequest((request)=>{
+            let nextRequest = request;
+            for (const [header, value] of Object.entries(requestContextHeaders))if (void 0 === nextRequest.headers[header.toLowerCase()]) nextRequest = HttpClientRequest.setHeader(nextRequest, header, value);
+            return nextRequest;
+        }));
+        return 'function' == typeof options?.transformClient ? options.transformClient(contextClient) : contextClient;
+    };
+    return HttpApiClient.make(api, {
+        baseUrl: options?.baseUrl,
+        transformClient,
+        transformResponse: options?.transformResponse
+    }).pipe(__rspack_external_effect_Effect_41060786.provide(FetchHttpClient.layer));
+}
+function makeEffectRpcClient(group, options) {
+    const protocolLayer = __rspack_external_effect_Layer_69c46453.provide(RpcClient.layerProtocolHttp({
+        url: options.url
+    }), __rspack_external_effect_Layer_69c46453.mergeAll(getRpcSerializationLayer(options.serialization), FetchHttpClient.layer));
+    const middlewareLayer = options.middlewareLayer ?? __rspack_external_effect_Layer_69c46453.empty;
+    const runtimeLayer = __rspack_external_effect_Layer_69c46453.mergeAll(protocolLayer, middlewareLayer);
+    return __rspack_external_effect_Effect_41060786.tryPromise({
+        try: async ()=>{
+            const runtime = __rspack_external_effect_ManagedRuntime_bfe218e3.make(runtimeLayer);
+            let scope;
+            try {
+                const clientScope = await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.make());
+                scope = clientScope;
+                const client = await runtime.runPromise(RpcClient.make(group, {
+                    flatten: options.flatten
+                }).pipe(__rspack_external_effect_Effect_41060786.provideService(__rspack_external_effect_Scope_f87b0bd6.Scope, clientScope)));
+                let disposePromise;
+                const clientWithDispose = Object.assign(client, {
+                    dispose: ()=>{
+                        disposePromise ??= (async ()=>{
+                            let scopeCloseError;
+                            try {
+                                await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.close(clientScope, __rspack_external_effect_Exit_1ca64b33["void"]));
+                            } catch (error) {
+                                scopeCloseError = error;
+                            }
+                            try {
+                                await runtime.dispose();
+                            } catch (error) {
+                                if (void 0 === scopeCloseError) throw error;
+                            }
+                            if (void 0 !== scopeCloseError) throw scopeCloseError;
+                        })();
+                        return disposePromise;
+                    }
+                });
+                return clientWithDispose;
+            } catch (error) {
+                if (void 0 !== scope) try {
+                    await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.close(scope, __rspack_external_effect_Exit_1ca64b33["void"]));
+                } catch  {}
+                try {
+                    await runtime.dispose();
+                } catch  {}
+                throw error;
+            }
+        },
+        catch: (error)=>new EffectRpcClientError({
+                cause: error
+            })
+    });
+}
+const runEffectRequest = __rspack_external_effect_Effect_41060786.runPromise;
+export { EffectRpcClientError, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Schema_6065f72d as Schema, __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 as HttpClientError, makeEffectHttpApiClient, makeEffectRpcClient, mask, runEffectRequest, runEffectView, view };

package/dist/esm/effect-client/request-context.mjs

@@ -0,0 +1,23 @@
+import { isRecord } from "./guards.mjs";
+const createEffectRequestContext = (createRequestContextHeaders, requestContext)=>{
+    if (!isRecord(requestContext)) return {};
+    const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
+    return {
+        ...requestContext,
+        headers
+    };
+};
+const applyRequestContext = (normalizedRequest, request, createRequestContext)=>{
+    if (!isRecord(request) || !isRecord(request.requestContext)) return normalizedRequest;
+    const requestContext = createRequestContext(request.requestContext);
+    const requestHeaders = isRecord(requestContext.headers) ? requestContext.headers : {};
+    if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
+    return {
+        ...normalizedRequest,
+        headers: {
+            ...isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {},
+            ...requestHeaders
+        }
+    };
+};
+export { applyRequestContext, createEffectRequestContext };

package/dist/esm/effect-client/request.mjs

@@ -0,0 +1,28 @@
+import { isRecord } from "./guards.mjs";
+const METHODS_WITHOUT_BODY = new Set([
+    'GET',
+    'DELETE',
+    'HEAD',
+    'OPTIONS'
+]);
+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;
+};
+export { normalizeRequest };

package/dist/esm/effect-client/runtime.mjs

@@ -0,0 +1,62 @@
+import { configureGeneratedEffectClientRuntime } from "./batch.mjs";
+import { prepareEffectRequest } from "./envelope.mjs";
+import { createEffectRequestContext as external_request_context_mjs_createEffectRequestContext } from "./request-context.mjs";
+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 httpMethodDecider = config.httpMethodDecider || 'functionName';
+    const port = config.useEnvPort && "u" > typeof process && process.env && process.env.PORT ? process.env.PORT : config.port;
+    configureGeneratedEffectClientRuntime(config, configureRequest);
+    const createEffectRequestContext = (requestContext)=>external_request_context_mjs_createEffectRequestContext(createRequestContextHeaders, requestContext);
+    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,
+                config,
+                createEffectRequestContext
+            }));
+        client[endpoint.group] ??= {};
+        client[endpoint.group][endpoint.endpoint] = call;
+        operationManifest[endpoint.group] ??= {};
+        operationManifest[endpoint.group][endpoint.endpoint] = operation;
+    }
+    return {
+        client,
+        operationManifest,
+        createEffectRequestContext
+    };
+};
+export { createGeneratedEffectClient };

package/dist/esm/headers.mjs

@@ -0,0 +1,8 @@
+function toHeaderRecord(headers) {
+    const record = {};
+    headers.forEach((value, key)=>{
+        record[key] = value;
+    });
+    return record;
+}
+export { toHeaderRecord };

package/dist/esm/index.mjs

@@ -0,0 +1,4 @@
+import * as __rspack_external__data_platform_index_mjs_e91ceab4 from "./data-platform/index.mjs";
+import * as __rspack_external__effect_client_index_mjs_a83cfa33 from "./effect-client/index.mjs";
+export * from "./effect/index.mjs";
+export { __rspack_external__data_platform_index_mjs_e91ceab4 as DataPlatform, __rspack_external__effect_client_index_mjs_a83cfa33 as EffectClient };

package/dist/esm/rslib-runtime.mjs

@@ -0,0 +1,18 @@
+var __webpack_modules__ = {};
+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__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+export { __webpack_require__ };