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

package/dist/types/effect/edge-dispatcher.d.ts

@@ -0,0 +1,37 @@
+import { type NormalizedCrossProjectPolicy } from '@modern-js/bff-core/security/cross-project-policy';
+import { type DispatchEffectBffRequestOptions } from './dispatch';
+import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions } from './handler';
+import { type EffectApiModule, type EffectBffRequestHandler } from './module';
+import type { EffectContext } from './operation-context';
+export * as Config from 'effect/Config';
+export * as Effect from 'effect/Effect';
+export * as Layer from 'effect/Layer';
+export * as Option from 'effect/Option';
+export * as Schema from 'effect/Schema';
+export { Cookies, Etag, FetchHttpClient, FindMyWay, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpEffect, HttpIncomingMessage, HttpMethod, HttpMiddleware, HttpPlatform, HttpRouter, HttpServer, HttpServerError, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer, HttpStatus, HttpTraceContext, Multipart, MultipartParser, Template, Url, UrlParams, } from 'effect/unstable/http';
+export { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpApiTest, OpenApi, } from 'effect/unstable/httpapi';
+export { Rpc, RpcClient, RpcClientError, RpcGroup, RpcMessage, RpcMiddleware, RpcSchema, RpcSerialization, RpcServer, RpcTest, RpcWorker, Utils, } from 'effect/unstable/rpc';
+export { runWithEffectContext, useEffectContext, useOperationContext, } from './edge-context';
+export type { EffectApiClientFromApi, EffectApiPromiseClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler';
+export { createHttpApiHandler, defineEffectBff, defineEffectRpcBff, } from './handler';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
+export type EffectBffEdgeDispatchOptions = Omit<DispatchEffectBffRequestOptions, 'runWithEffectContext'>;
+export type EffectBffEdgeHandlerOptions = {
+    module: EffectApiModule;
+    prefix?: string;
+    openapi?: EffectBffOpenApiConfig;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    crossProjectPolicy?: NormalizedCrossProjectPolicy;
+    onError?: (error: unknown, context: EffectContext) => Promise<Response> | Response;
+    onWarning?: (message: string) => void;
+};
+export declare function dispatchEffectBffRequest(handler: EffectBffRequestHandler, request: Request, options?: EffectBffEdgeDispatchOptions): Promise<Response>;
+export declare function createEffectBffEdgeDispatcher(options: EffectBffEdgeHandlerOptions): Promise<{
+    dispatch: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
+    dispose: () => Promise<void>;
+}>;
+export declare const createEffectBffTestHandler: typeof createEffectBffEdgeHandler;
+export declare function createEffectBffEdgeHandler(options: EffectBffEdgeHandlerOptions): Promise<{
+    handler: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
+    dispose: () => Promise<void>;
+}>;

package/dist/types/effect/edge.d.ts

@@ -0,0 +1 @@
+export * from './edge-dispatcher';

package/dist/types/effect/endpoint-contracts.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared Effect HttpApi endpoint reflection used by BOTH sides of the
+ * cross-project contract:
+ *
+ * - the `@modern-js/plugin-bff-extensions/client-generator` package stamps
+ *   each generated operation with a per-endpoint contract hash;
+ * - the `@modern-js/plugin-bff-extensions/effect-adapter` package derives the
+ *   expected operation-contract map for the cross-project policy from the
+ *   same endpoints.
+ *
+ * Keeping route-path normalization and the endpoint -> contract mapping in
+ * one module is what guarantees the two hashes agree.
+ */
+import { type OperationContractSource } from '@modern-js/bff-core';
+export type EffectEndpointMeta = {
+    apiId: string;
+    groupName: string;
+    endpointName: string;
+    method: string;
+    routePath: string;
+};
+export type HttpApiLike = {
+    identifier?: unknown;
+};
+type HttpApiGroupLike = {
+    identifier?: unknown;
+};
+type HttpApiEndpointLike = {
+    /**
+     * effect 4.0.0-beta.98 renamed the endpoint `name` property to `identifier`,
+     * matching `HttpApiGroup`. `name` is kept as a fallback so reflection over an
+     * older Effect build does not silently degrade to the class name.
+     */
+    identifier?: unknown;
+    name?: unknown;
+    method?: unknown;
+    path?: unknown;
+};
+export type HttpApiReflect = (api: unknown, handlers: {
+    /** Group metadata is unused by contract collection; kept as a no-op. */
+    onGroup?: () => void;
+    onEndpoint: (input: {
+        group: HttpApiGroupLike;
+        endpoint: HttpApiEndpointLike;
+    }) => void;
+}) => void;
+export declare function ensureLeadingSlash(pathname: string): string;
+export declare function normalizeEffectPrefix(prefix: string): string;
+export declare function collectEffectEndpoints(reflect: HttpApiReflect, api: HttpApiLike, prefix: string): EffectEndpointMeta[];
+/**
+ * Maps reflected endpoints onto operation-contract sources for
+ * `buildOperationContractMap`/`resolveCrossProjectPolicy`. Effect endpoints
+ * carry no zod metadata, so the contract hash covers the endpoint identity.
+ */
+export declare function toOperationContractSources(endpoints: EffectEndpointMeta[]): OperationContractSource[];
+/**
+ * Extracts the HttpApi instance from a loaded effect entry module. Mirrors
+ * the shared entry-shape policy accepted by `resolveEffectBffModuleHandler`,
+ * without executing factories during contract extraction.
+ */
+export declare function extractHttpApiFromModule(mod: unknown, isHttpApi: (value: unknown) => boolean): Promise<HttpApiLike | null>;
+/**
+ * Per-endpoint contract hash; MUST stay in sync with the server-side
+ * contract map (it is the same bff-core hash over the same inputs).
+ */
+export declare function createEffectEndpointContractHash(endpoint: EffectEndpointMeta, requestId: string): string;
+export {};

package/dist/types/effect/entry-shape.d.ts

@@ -0,0 +1,32 @@
+type EffectBffEntryModule = {
+    api?: unknown;
+    layer?: unknown;
+    handler?: unknown;
+    createHandler?: unknown;
+    default?: unknown;
+};
+type LegacyEffectBffEntryShape = '`handler` export' | 'default request handler';
+export type EffectBffEntryShapeFacts = {
+    module: EffectBffEntryModule;
+    legacyShape?: LegacyEffectBffEntryShape;
+    createHandler?: unknown;
+    createHandlerValidatorAware: boolean;
+    api?: unknown;
+    layer?: unknown;
+    hasRuntimeLayer: boolean;
+};
+type EffectBffEntryShapePredicates = {
+    isRequestHandler: (value: unknown) => boolean;
+    isValidatorAwareHandlerFactory: (value: unknown) => boolean;
+    isHttpApi: (value: unknown) => boolean;
+};
+/** @internal Registers factories created by `defineEffectBff`. */
+export declare function registerValidatorAwareHandlerFactory<TFactory extends Function>(factory: TFactory): TFactory;
+/**
+ * True when a custom createHandler factory is produced by defineEffectBff and
+ * therefore forwards strict cross-project validation into createHttpApiHandler.
+ */
+export declare function isValidatorAwareHandlerFactory(factory: unknown): boolean;
+export declare const strictEffectApproachMessage = "[BFF][Effect] strictEffectApproach is enforced: Effect API entries export defineEffectBff(...) or { api, layer } HttpApi module. Raw handler exports, default request handlers, unbranded custom createHandler factories not valid Effect API entries.";
+export declare function classifyEffectBffEntryModule(value: unknown, predicates: EffectBffEntryShapePredicates): EffectBffEntryShapeFacts | null;
+export {};

package/dist/types/effect/handler/batch-handler.d.ts

@@ -0,0 +1,11 @@
+import type { EffectDataPlatformValidationOptions } from './types';
+type DataPlatformBatchItemHandler<TContext> = (request: Request, context?: TContext) => Promise<unknown>;
+export declare function createDataPlatformBatchRequestHandler<TContext>(options: {
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    handleItem: DataPlatformBatchItemHandler<TContext>;
+}): {
+    enabled: boolean;
+    path: `/${string}`;
+    handle: (request: Request, context?: TContext) => Promise<Response>;
+};
+export {};

package/dist/types/effect/handler/batch.d.ts

@@ -0,0 +1,15 @@
+import { type DataBatchRequestPayload, type DataBatchResponseItem } from '../../data-platform';
+export { toHeaderRecord } from '../../headers';
+export declare function normalizeBatchPath(pathname: string | undefined): `/${string}`;
+export declare function normalizeBatchAllowedMethods(allowedMethods: string[] | undefined): Set<string>;
+type ParsedBatchRequestPayload = Omit<DataBatchRequestPayload, 'items'> & {
+    items: unknown[];
+};
+export declare function isBatchRequestPayload(value: unknown): value is ParsedBatchRequestPayload;
+export declare function createBatchValidationResponse(message: string, status?: number): Response;
+export declare function prepareJsonRequestBody(request: Request): Promise<Request | Response>;
+export declare function toBatchItemError(id: string, status: number, message: string): DataBatchResponseItem;
+export declare class BatchItemTimeoutError extends Error {
+}
+export declare function promiseWithTimeout<T>(effect: Promise<T>, timeoutMs: number, onTimeout?: (error: BatchItemTimeoutError) => void): Promise<T>;
+export declare function mapWithConcurrency<TItem, TResult>(items: readonly TItem[], concurrency: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;

package/dist/types/effect/handler/definition.d.ts

@@ -0,0 +1,7 @@
+import type { HttpApi } from 'effect/unstable/httpapi';
+import type { Rpc } from 'effect/unstable/rpc';
+import type { EffectBffDefinition, EffectBffRuntime, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcRuntimeLayer, EffectRuntimeLayer } from './types';
+export declare function defineEffectBff<TApi extends HttpApi.Constraint, TLayer extends EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any>(definition: EffectBffDefinition<TApi, TLayer, TRpcs>): EffectBffDefinition<TApi, TLayer, TRpcs> & EffectBffRuntime<TApi, TLayer>;
+export declare function defineEffectRpcBff<TRpcs extends Rpc.Any = Rpc.Any, TLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>>(definition: EffectRpcBffDefinition<TRpcs, TLayer>): EffectRpcBffDefinition<TRpcs, TLayer> & {
+    createHandler: EffectRpcBffHandlerFactory<TRpcs>;
+};

package/dist/types/effect/handler/envelope.d.ts

@@ -0,0 +1,13 @@
+import type { EffectDataPlatformValidationOptions } from './types';
+/**
+ * Validates the `x-modernjs-data-envelope` header (the data-platform
+ * transport/cache contract: protocol version, scope, selection plan).
+ *
+ * This is NOT a security boundary: the envelope is client-constructed cache
+ * metadata used for batching, scope keys and hydration. Cross-project
+ * authorization runs through the bff-core policy evaluator wired in via
+ * `validateRequest` (see `EffectRequestValidator`), which both the direct
+ * and batched request paths hit before this check.
+ */
+export declare function validateDataPlatformRequestEnvelope(request: Request, options: EffectDataPlatformValidationOptions | undefined): Response | null;
+export declare function mergeDataPlatformOptions(base: EffectDataPlatformValidationOptions | undefined, override: Partial<EffectDataPlatformValidationOptions> | undefined): EffectDataPlatformValidationOptions | undefined;

package/dist/types/effect/handler/http.d.ts

@@ -0,0 +1,15 @@
+import type { HttpApi } from 'effect/unstable/httpapi';
+import type { Rpc } from 'effect/unstable/rpc';
+import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestInterceptor, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types';
+export declare function createHttpApiHandler<TApi extends HttpApi.Constraint = HttpApi.Top, TRpcs extends Rpc.Any = Rpc.Any>(options: {
+    api: TApi;
+    layer: EffectRuntimeLayer;
+    openapi?: EffectBffOpenApiConfig;
+    rpc?: EffectRpcBffDefinition<TRpcs>;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    interceptRequest?: EffectRequestInterceptor;
+    validateRequest?: EffectRequestValidator;
+}): {
+    handler: (request: Request, context?: Parameters<(request: globalThis.Request, context: import("effect/Context").Context<unknown>) => Promise<Response>>[1]) => Promise<Response>;
+    dispose: () => Promise<void>;
+};

package/dist/types/effect/handler/openapi.d.ts

@@ -0,0 +1,4 @@
+import { HttpRouter } from 'effect/unstable/http';
+import { type HttpApi } from 'effect/unstable/httpapi';
+import type { EffectBffOpenApiConfig } from './types';
+export declare function createOpenApiLayer(api: HttpApi.Constraint, openapi: EffectBffOpenApiConfig | undefined): import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter> | null;

package/dist/types/effect/handler/routing.d.ts

@@ -0,0 +1,5 @@
+export declare function getRequestPathname(request: Request): string;
+export declare function getMountedPrefixFromContext(request: Request, context: unknown): string;
+export declare function removeMountedPrefixFromBatchPath(pathWithQuery: string, prefix: string): string;
+export declare function getExpectedEnvelopeOrigin(request: Request): string;
+export declare function isRpcRequest(request: Request, rpcPath: `/${string}`): boolean;

package/dist/types/effect/handler/rpc.d.ts

@@ -0,0 +1,7 @@
+import { type Rpc } from 'effect/unstable/rpc';
+import type { EffectRpcBffDefinition } from './types';
+export declare function normalizeRpcPath(pathname: string | undefined): `/${string}`;
+export declare function createRpcApiHandler<TRpcs extends Rpc.Any = Rpc.Any>(options: EffectRpcBffDefinition<TRpcs>): {
+    readonly handler: (request: globalThis.Request, context?: import("effect/Context").Context<never> | undefined) => Promise<Response>;
+    readonly dispose: () => Promise<void>;
+};

package/dist/types/effect/handler/types.d.ts

@@ -0,0 +1,153 @@
+import type { FileSystem, Path } from 'effect';
+import * as Context from 'effect/Context';
+import type * as EffectType from 'effect/Effect';
+import type * as Layer from 'effect/Layer';
+import type { Etag, HttpPlatform, HttpRouter } from 'effect/unstable/http';
+import type { HttpApi, HttpApiClient, HttpApiGroup } from 'effect/unstable/httpapi';
+import type { Rpc, RpcGroup } from 'effect/unstable/rpc';
+import type { createHttpApiHandler } from './http';
+import type { createRpcApiHandler } from './rpc';
+export type EffectRuntimeRequirements = Etag.Generator | FileSystem.FileSystem | HttpPlatform.HttpPlatform | HttpRouter.HttpRouter | HttpRouter.Request<'Error', unknown> | HttpRouter.Request<'GlobalError', unknown> | HttpRouter.Request<'GlobalRequires', unknown> | HttpRouter.Request<'Requires', unknown> | Path.Path;
+export type EffectRuntimeLayer = Layer.Layer<never, never, EffectRuntimeRequirements>;
+export declare const toEffectServiceContext: (context: unknown) => Context.Context<any>;
+export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
+export type EffectRpcRuntimeLayer<TRpcs extends Rpc.Any = Rpc.Any> = Layer.Layer<Rpc.ToHandler<TRpcs> | Rpc.Middleware<TRpcs> | Rpc.ServicesServer<TRpcs>, unknown, never>;
+export type EffectRpcBffDefinition<TRpcs extends Rpc.Any = Rpc.Any, TRpcLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>> = {
+    group: RpcGroup.RpcGroup<TRpcs>;
+    layer: TRpcLayer;
+    path?: `/${string}`;
+    serialization?: EffectRpcSerialization;
+    disableTracing?: boolean;
+    spanPrefix?: string;
+    spanAttributes?: Record<string, unknown>;
+    disableFatalDefects?: boolean;
+};
+export type EffectRpcBffHandlerOptions = Pick<EffectRpcBffDefinition, 'path' | 'serialization' | 'disableTracing' | 'spanPrefix' | 'spanAttributes' | 'disableFatalDefects'>;
+type EffectApiPromiseClient<TClient> = {
+    [GroupName in keyof TClient]: {
+        [EndpointName in keyof TClient[GroupName]]: TClient[GroupName][EndpointName] extends (...args: infer TArgs) => infer TResult ? TResult extends EffectType.Effect<unknown, unknown, unknown> ? (...args: TArgs) => Promise<Exclude<EffectType.Success<TResult>, readonly [unknown, unknown]>> : never : never;
+    };
+};
+export type EffectApiClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Constraint>, never, never> : never;
+export type EffectApiPromiseClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
+export type EffectBffDefinition<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
+    api: TApi;
+    layer: TLayer;
+    rpc?: EffectRpcBffDefinition<TRpcs>;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    interceptRequest?: EffectRequestInterceptor;
+};
+export type EffectDataPlatformSelectionValidationOptions = {
+    maxDepth?: number;
+    maxFields?: number;
+    allowedLeafPaths?: string[];
+};
+export type EffectDataPlatformBatchOptions = {
+    /**
+     * Enable network batching endpoint for Effect HttpApi requests.
+     * Defaults to `true`.
+     */
+    enabled?: boolean;
+    /**
+     * Batch endpoint path mounted under BFF prefix.
+     * Defaults to `/_data/batch`.
+     */
+    endpoint?: `/${string}`;
+    /**
+     * Maximum request items accepted per batch call.
+     * Defaults to `16`.
+     */
+    maxBatchSize?: number;
+    /**
+     * Maximum serialized request payload size in bytes.
+     * Defaults to `65536` (64KiB).
+     */
+    maxBatchBytes?: number;
+    /**
+     * Client-side micro-batch flush window in milliseconds.
+     * Server runtime ignores this value and passes it through for codegen.
+     * Defaults to `8`.
+     */
+    flushIntervalMs?: number;
+    /**
+     * Maximum per-batch internal request concurrency.
+     * Defaults to `4`.
+     */
+    maxConcurrency?: number;
+    /**
+     * Optional timeout per internal request in milliseconds.
+     * Defaults to `10000`.
+     */
+    requestTimeoutMs?: number;
+    /**
+     * Allowed HTTP methods for internal batched dispatch.
+     * Defaults to `['GET']`.
+     */
+    allowedMethods?: string[];
+};
+export type EffectDataPlatformValidationOptions = {
+    /**
+     * Enable envelope validation for HttpApi requests.
+     * Defaults to `true`.
+     */
+    enabled?: boolean;
+    /**
+     * Require every HttpApi request to include an envelope header.
+     * Defaults to `false`.
+     */
+    requireEnvelope?: boolean;
+    /**
+     * Header name used by client/server for the serialized request envelope.
+     * Defaults to `x-modernjs-data-envelope`.
+     */
+    envelopeHeader?: string;
+    /**
+     * Optional namespace assertion for envelope validation.
+     */
+    expectedNamespace?: string;
+    /**
+     * Validate envelope origin against incoming request origin.
+     * Defaults to `true`.
+     */
+    validateOrigin?: boolean;
+    /**
+     * Require trace context inside request envelope.
+     * Defaults to `false`.
+     */
+    requireTraceContext?: boolean;
+    /**
+     * Selection plan guardrails for server-side validation.
+     */
+    selection?: EffectDataPlatformSelectionValidationOptions;
+    /**
+     * Network batching gateway configuration.
+     */
+    batch?: EffectDataPlatformBatchOptions;
+};
+/**
+ * Server-seam request validator applied to every HttpApi request — direct,
+ * batched (per item) and rpc. Returning a Response short-circuits the
+ * request; returning `null`/`undefined` lets it through. Used by the effect
+ * adapter to enforce the cross-project policy at one seam so batched items
+ * cannot bypass it.
+ */
+export type EffectRequestValidator = (request: Request) => Response | null | undefined;
+export type EffectRequestInterceptor = (options: {
+    request: Request;
+    next: () => Promise<Response>;
+}) => Response | Promise<Response>;
+export type EffectBffHandlerFactory<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
+    openapi?: EffectBffOpenApiConfig;
+    rpc?: Partial<EffectRpcBffHandlerOptions>;
+    dataPlatform?: Partial<EffectDataPlatformValidationOptions>;
+    validateRequest?: EffectRequestValidator;
+}) => ReturnType<typeof createHttpApiHandler>;
+export type EffectBffRuntime<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = {
+    createHandler: EffectBffHandlerFactory<TApi, TLayer>;
+    client: EffectApiPromiseClientFromApi<TApi>;
+};
+export type EffectBffOpenApiConfig = boolean | {
+    path?: string;
+};
+export type EffectRpcBffHandlerFactory<TRpcs extends Rpc.Any = Rpc.Any> = (options?: Partial<EffectRpcBffHandlerOptions>) => ReturnType<typeof createRpcApiHandler<TRpcs>>;
+export {};

package/dist/types/effect/handler.d.ts

@@ -0,0 +1,13 @@
+export * as Config from 'effect/Config';
+export * as Effect from 'effect/Effect';
+export * as Layer from 'effect/Layer';
+export * as Option from 'effect/Option';
+export * as Schema from 'effect/Schema';
+export * from 'effect/unstable/http';
+export { HttpTraceContext } from 'effect/unstable/http';
+export * from 'effect/unstable/httpapi';
+export { HttpApiBuilder } from 'effect/unstable/httpapi';
+export * from 'effect/unstable/rpc';
+export { defineEffectBff, defineEffectRpcBff } from './handler/definition';
+export { createHttpApiHandler } from './handler/http';
+export type { EffectApiClientFromApi, EffectApiPromiseClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler/types';

package/dist/types/effect/index.d.ts

@@ -0,0 +1,6 @@
+export * as OpenTelemetry from '@effect/opentelemetry';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, runWithEffectContext, useEffectContext, useOperationContext, } from './context';
+export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, } from './edge';
+export * from './endpoint-contracts';
+export * from './handler';
+export { type EffectApiModule, type EffectBffHandlerFactory, type EffectBffRequestHandler, resolveEffectBffModuleHandler, } from './module';

package/dist/types/effect/module.d.ts

@@ -0,0 +1,36 @@
+import type * as EffectServiceContext from 'effect/Context';
+import { type EffectBffOpenApiConfig, type EffectDataPlatformValidationOptions, type EffectRequestValidator } from './handler';
+import type { EffectContext } from './operation-context';
+export type EffectBffRequestHandler = (request: Request, context?: EffectServiceContext.Context<any> | EffectContext) => Promise<Response> | Response;
+export type EffectBffHandlerFactory = (options?: {
+    openapi?: EffectBffOpenApiConfig;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    validateRequest?: EffectRequestValidator;
+}) => {
+    handler: EffectBffRequestHandler;
+    dispose: () => Promise<void>;
+};
+export type EffectApiModule = {
+    api?: unknown;
+    layer?: unknown;
+    handler?: EffectBffRequestHandler;
+    createHandler?: EffectBffHandlerFactory;
+    default?: unknown;
+};
+type LoadedEffectBffHandler = {
+    handler: EffectBffRequestHandler;
+    dispose?: () => Promise<void>;
+};
+type ResolveEffectBffModuleHandlerOptions = {
+    openapi?: EffectBffOpenApiConfig;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    /**
+     * Server-seam request validator (cross-project policy). Strict Effect
+     * entries forward it into `createHttpApiHandler`, where it applies to
+     * direct, batched and rpc requests.
+     */
+    validateRequest?: EffectRequestValidator;
+    onWarning?: (message: string) => void;
+};
+export declare function resolveEffectBffModuleHandler(mod: EffectApiModule, options?: ResolveEffectBffModuleHandlerOptions): Promise<LoadedEffectBffHandler | null>;
+export {};

package/dist/types/effect/operation-context.d.ts

@@ -0,0 +1,15 @@
+import { type OperationContext } from '@modern-js/create-request';
+export type EffectContext = {
+    request: Request;
+    env: Record<string, unknown>;
+    path: string;
+    method: string;
+    operationContext: OperationContext;
+};
+export type EffectContextStorage = {
+    getStore: () => EffectContext | undefined;
+    run: <TResult>(value: EffectContext, cb: () => TResult) => TResult;
+};
+export declare const kEffectContextStorage: unique symbol;
+export type CreateEffectOperationContextOptions = Omit<EffectContext, 'operationContext'>;
+export declare const createEffectOperationContext: ({ request, path, method, }: CreateEffectOperationContextOptions) => OperationContext;

package/dist/types/effect/rpcSerialization.d.ts

@@ -0,0 +1,3 @@
+import { RpcSerialization } from 'effect/unstable/rpc';
+import type { EffectRpcSerialization } from './handler/types';
+export declare function getRpcSerializationLayer(serialization: EffectRpcSerialization | undefined): import("effect/Layer").Layer<RpcSerialization.RpcSerialization, never, never>;

package/dist/types/effect-client/batch.d.ts

@@ -0,0 +1,2 @@
+import type { EffectRequestRuntime, GeneratedEffectClientConfig } from './types';
+export declare const configureGeneratedEffectClientRuntime: (config: GeneratedEffectClientConfig, configureRequest: EffectRequestRuntime['configure'] | undefined) => void;

package/dist/types/effect-client/envelope.d.ts

@@ -0,0 +1,15 @@
+import type { EffectOperationDescriptor, EffectRequestContext, EffectRequestContextInput, GeneratedEffectClientConfig, GeneratedEffectEndpoint } from './types';
+/**
+ * Resolves the current page origin with a configurable fallback. Single
+ * implementation shared by the configure() bootstrap and the data envelope
+ * (the generated template previously duplicated data-platform's
+ * `resolveRuntimeOrigin` with a different fallback).
+ */
+export declare const resolveOrigin: (defaultOrigin: string) => string;
+export declare const prepareEffectRequest: (options: {
+    endpoint: GeneratedEffectEndpoint;
+    operation: EffectOperationDescriptor;
+    request: unknown;
+    config: GeneratedEffectClientConfig;
+    createEffectRequestContext: (requestContext: EffectRequestContextInput) => EffectRequestContext;
+}) => Record<string, unknown>;

package/dist/types/effect-client/guards.d.ts

@@ -0,0 +1,2 @@
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const stringOrUndefined: (value: unknown) => string | undefined;

package/dist/types/effect-client/index.d.ts

@@ -0,0 +1,58 @@
+import { type RequestContextInput } from '@modern-js/create-request';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { HttpClient } from 'effect/unstable/http';
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from 'effect/unstable/httpapi';
+import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from 'effect/unstable/rpc';
+export * as Effect from 'effect/Effect';
+export * as Layer from 'effect/Layer';
+export * as Schema from 'effect/Schema';
+export * as HttpClientError from 'effect/unstable/http/HttpClientError';
+export { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, };
+export type EffectHttpApiClientOptions = {
+    baseUrl?: URL | string;
+    requestContext?: RequestContextInput;
+    transformClient?: (client: HttpClient.HttpClient) => HttpClient.HttpClient;
+    transformResponse?: ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>) | undefined;
+};
+type Nullish = null | undefined;
+type NonNullish<T> = Exclude<T, Nullish>;
+type PreserveNullish<T, Next> = Extract<T, Nullish> extends never ? Next : Next | Extract<T, Nullish>;
+type EffectViewObjectSelection<T> = NonNullish<T> extends Record<string, unknown> ? EffectViewSelection<NonNullish<T>> : never;
+type EffectViewSelectionValue<T> = NonNullish<T> extends readonly (infer Item)[] ? true | EffectViewObjectSelection<Item> : NonNullish<T> extends Record<string, unknown> ? true | EffectViewSelection<NonNullish<T>> : true;
+type EffectMaskedValue<T, Selection> = Selection extends true ? T : NonNullish<T> extends readonly (infer Item)[] ? PreserveNullish<T, Array<EffectMaskedValue<Item, Selection>>> : NonNullish<T> extends Record<string, unknown> ? PreserveNullish<T, EffectViewData<NonNullish<T>, Selection>> : T;
+export type EffectViewSelection<T> = {
+    [K in keyof T]?: EffectViewSelectionValue<T[K]>;
+};
+export type EffectViewData<T, Selection> = Selection extends true ? T : Selection extends Record<string, unknown> ? {
+    [K in keyof Selection & keyof T]: EffectMaskedValue<T[K], Selection[K]>;
+} : T;
+export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
+declare const EffectRpcClientError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "EffectRpcClientError";
+} & Readonly<A>;
+export declare class EffectRpcClientError extends EffectRpcClientError_base<{
+    readonly cause: unknown;
+}> {
+}
+type EffectRpcMiddlewareLayerOption<Rpcs extends Rpc.Any> = [
+    Rpc.MiddlewareClient<Rpcs>
+] extends [never] ? {
+    middlewareLayer?: Layer.Layer<Rpc.MiddlewareClient<Rpcs>, never, never>;
+} : {
+    middlewareLayer: Layer.Layer<Rpc.MiddlewareClient<Rpcs>, unknown, never>;
+};
+export type EffectRpcClientOptions<Rpcs extends Rpc.Any, Flatten extends boolean = false> = EffectRpcMiddlewareLayerOption<Rpcs> & {
+    url: string;
+    flatten?: Flatten;
+    serialization?: EffectRpcSerialization;
+};
+export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean = false> = (Flatten extends true ? RpcClient.RpcClient.Flat<Rpcs, unknown> : RpcClient.RpcClient<Rpcs, unknown>) & {
+    dispose: () => Promise<void>;
+};
+export declare function view<T>(): <const Selection extends EffectViewSelection<T>>(selection: Selection) => Selection;
+export declare function mask<T, const Selection extends EffectViewSelection<T>>(value: T, selection: Selection): EffectViewData<T, Selection>;
+export declare function runEffectView<T, const Selection extends EffectViewSelection<T>>(request: PromiseLike<T>, selection: Selection): Promise<EffectViewData<T, Selection>>;
+export declare function makeEffectHttpApiClient<ApiId extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<ApiId, Groups>, options?: EffectHttpApiClientOptions): Effect.Effect<HttpApiClient.Client<Groups, never, never>, never, HttpApiGroup.MiddlewareClient<Groups>>;
+export declare function makeEffectRpcClient<Rpcs extends Rpc.Any, const Flatten extends boolean = false>(group: RpcGroup.RpcGroup<Rpcs>, options: EffectRpcClientOptions<Rpcs, Flatten>): Effect.Effect<EffectRpcClientHandle<Rpcs, Flatten>, EffectRpcClientError, never>;
+export declare const runEffectRequest: <A, E>(effect: Effect.Effect<A, E>, options?: Effect.RunOptions | undefined) => Promise<A>;

package/dist/types/effect-client/request-context.d.ts

@@ -0,0 +1,3 @@
+import type { EffectRequestContext, EffectRequestContextInput, EffectRequestRuntime } from './types';
+export declare const createEffectRequestContext: (createRequestContextHeaders: EffectRequestRuntime['createRequestContextHeaders'], requestContext: EffectRequestContextInput) => EffectRequestContext;
+export declare const applyRequestContext: (normalizedRequest: Record<string, unknown>, request: unknown, createRequestContext: (requestContext: EffectRequestContextInput) => EffectRequestContext) => Record<string, unknown>;

package/dist/types/effect-client/request.d.ts

@@ -0,0 +1 @@
+export declare const normalizeRequest: (method: string, request: unknown) => Record<string, unknown>;

package/dist/types/effect-client/runtime.d.ts

@@ -0,0 +1,5 @@
+import type { EffectRequestRuntime, GeneratedEffectClientConfig, GeneratedEffectClientModule, GeneratedEffectEndpoint } from './types';
+export type { EffectClient, EffectClientGroup, EffectClientOperation, EffectOperationDescriptor, EffectOperationManifest, EffectRequestContext, EffectRequestContextInput, EffectRequestRuntime, GeneratedEffectBatchConfig, GeneratedEffectClientConfig, GeneratedEffectClientModule, GeneratedEffectEndpoint, } from './types';
+export declare const createGeneratedEffectClient: (manifest: {
+    endpoints: GeneratedEffectEndpoint[];
+}, config: GeneratedEffectClientConfig, requestRuntime: EffectRequestRuntime) => GeneratedEffectClientModule;

package/dist/types/effect-client/types.d.ts

@@ -0,0 +1,68 @@
+export type GeneratedEffectEndpoint = {
+    apiId: string;
+    group: string;
+    endpoint: string;
+    method: string;
+    routePath: string;
+    /** Per-endpoint operation contract hash (bff-core hash). */
+    schemaHash: string;
+    operationVersion: number;
+};
+export type GeneratedEffectBatchConfig = {
+    enabled: boolean;
+    endpoint: string;
+    flushIntervalMs: number;
+    maxBatchSize: number;
+    maxBatchBytes: number;
+    requestTimeoutMs: number;
+    allowedMethods: string[];
+};
+export type GeneratedEffectClientConfig = {
+    appNamespace: string;
+    /** Cross-project producer id; absent for same-project clients. */
+    requestId?: string;
+    port: number;
+    /** Resolve the port from process.env.PORT first (server bundles). */
+    useEnvPort?: boolean;
+    defaultOrigin: string;
+    httpMethodDecider?: string;
+    batch: GeneratedEffectBatchConfig;
+};
+export type EffectOperationDescriptor = {
+    appNamespace: string;
+    apiId: string;
+    group: string;
+    endpoint: string;
+    operationId: string;
+    routePath: string;
+    method: string;
+    operationVersion: number;
+    schemaHash: string;
+    version: number;
+};
+export type EffectClientOperation = (request?: unknown) => Promise<unknown>;
+export type EffectClientGroup = Record<string, EffectClientOperation>;
+export type EffectClient = Record<string, EffectClientGroup>;
+export type EffectOperationManifest = Record<string, Record<string, EffectOperationDescriptor>>;
+export type EffectRequestContextInput = Record<string, unknown>;
+export type EffectRequestContext = {
+    headers: Record<string, string>;
+} & Record<string, unknown>;
+/** Structural slice of `@modern-js/create-request` the runtime relies on. */
+export type EffectRequestRuntime = {
+    createRequest: (options: {
+        path: string;
+        method: string;
+        port: number | string;
+        operationContext: Record<string, unknown>;
+        httpMethodDecider: string;
+        requestId?: string;
+    }) => (...args: unknown[]) => Promise<unknown>;
+    configure?: (options: Record<string, unknown>) => void;
+    createRequestContextHeaders?: (input: EffectRequestContextInput) => Record<string, string>;
+};
+export type GeneratedEffectClientModule = {
+    client: EffectClient;
+    operationManifest: EffectOperationManifest;
+    createEffectRequestContext: (requestContext: EffectRequestContextInput) => EffectRequestContext;
+};