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

package/src/effect-client/batch.ts

@@ -0,0 +1,50 @@
+// @effect-diagnostics processEnv:off strictBooleanExpressions:off
+import { createDataBatchTransport } from '../data-platform';
+import { resolveOrigin } from './envelope';
+import type {
+  EffectRequestRuntime,
+  GeneratedEffectClientConfig,
+} from './types';
+
+const resolveRuntimeFetch = (): typeof fetch | undefined =>
+  typeof fetch === 'function' ? fetch.bind(globalThis) : undefined;
+
+export const configureGeneratedEffectClientRuntime = (
+  config: GeneratedEffectClientConfig,
+  configureRequest: EffectRequestRuntime['configure'] | undefined,
+): void => {
+  const defaultOrigin = config.defaultOrigin;
+
+  if (config.requestId && configureRequest) {
+    const configurePayload: Record<string, unknown> = {
+      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 (config.batch.enabled !== false && 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);
+  }
+};

package/src/effect-client/envelope.ts

@@ -0,0 +1,238 @@
+// @effect-diagnostics processEnv:off strictBooleanExpressions:off
+import {
+  createRequestEnvelope,
+  DEFAULT_DATA_BATCH_HEADER,
+  DEFAULT_DATA_ENVELOPE_HEADER,
+  encodeRequestEnvelopeHeader,
+  type RequestEnvelope,
+  type SelectionPlan,
+  type TraceContext,
+} from '../data-platform';
+import { isRecord, stringOrUndefined } from './guards';
+import { normalizeRequest } from './request';
+import { applyRequestContext } from './request-context';
+import type {
+  EffectOperationDescriptor,
+  EffectRequestContext,
+  EffectRequestContextInput,
+  GeneratedEffectClientConfig,
+  GeneratedEffectEndpoint,
+} from './types';
+
+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: unknown) =>
+  typeof value === 'string' && DATA_REQUEST_MODES.has(value);
+
+const isDataMutationMode = (value: unknown) =>
+  typeof value === 'string' && DATA_MUTATION_MODES.has(value);
+
+const normalizeOrigin = (value: unknown): string | undefined => {
+  if (typeof value !== 'string' || value.length === 0) {
+    return undefined;
+  }
+  try {
+    return new URL(value).origin;
+  } catch {
+    return undefined;
+  }
+};
+
+const resolveRuntimeFetch = (): typeof fetch | undefined =>
+  typeof fetch === 'function' ? fetch.bind(globalThis) : undefined;
+
+/**
+ * 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 const resolveOrigin = (defaultOrigin: string): string => {
+  if (
+    typeof window !== 'undefined' &&
+    window.location &&
+    typeof window.location.origin === 'string' &&
+    window.location.origin
+  ) {
+    return window.location.origin;
+  }
+
+  const globalLocation = (
+    globalThis as { location?: { origin?: unknown } } | undefined
+  )?.location;
+  if (
+    globalLocation &&
+    typeof globalLocation.origin === 'string' &&
+    globalLocation.origin
+  ) {
+    return globalLocation.origin;
+  }
+
+  return defaultOrigin;
+};
+
+const resolveTargetOrigin = (
+  dataPlatform: Record<string, unknown>,
+  defaultOrigin: string,
+): string => {
+  const explicitTargetOrigin =
+    stringOrUndefined(dataPlatform.targetOrigin) ||
+    stringOrUndefined(dataPlatform.endpointOrigin);
+  if (explicitTargetOrigin) {
+    return explicitTargetOrigin;
+  }
+  return defaultOrigin;
+};
+
+const shouldAttachEnvelopeHeader = (
+  dataPlatform: Record<string, unknown>,
+  defaultOrigin: string,
+): boolean => {
+  if (dataPlatform.allowCrossOriginEnvelope === true) {
+    return true;
+  }
+  const currentOrigin = normalizeOrigin(resolveOrigin(defaultOrigin));
+  const targetOrigin = normalizeOrigin(
+    resolveTargetOrigin(dataPlatform, defaultOrigin),
+  );
+  if (!currentOrigin || !targetOrigin) {
+    return true;
+  }
+  return currentOrigin === targetOrigin;
+};
+
+const toEnvelopeInput = (
+  normalizedRequest: Record<string, unknown>,
+): Record<string, unknown> => {
+  const payload: Record<string, unknown> = {};
+  if (isRecord(normalizedRequest.params)) {
+    payload.path = normalizedRequest.params;
+  }
+  if (isRecord(normalizedRequest.query)) {
+    payload.query = normalizedRequest.query;
+  }
+  if ('data' in normalizedRequest && normalizedRequest.data !== undefined) {
+    payload.data = normalizedRequest.data;
+  }
+  if ('body' in normalizedRequest && normalizedRequest.body !== undefined) {
+    payload.body = normalizedRequest.body;
+  }
+  if (
+    typeof FormData !== 'undefined' &&
+    normalizedRequest.formData instanceof FormData
+  ) {
+    payload.formData = Array.from(normalizedRequest.formData.entries()).map(
+      ([key, value]) => [key, String(value)],
+    );
+  }
+  if (
+    typeof URLSearchParams !== 'undefined' &&
+    normalizedRequest.formUrlencoded instanceof URLSearchParams
+  ) {
+    payload.formUrlencoded = normalizedRequest.formUrlencoded.toString();
+  }
+  return payload;
+};
+
+export const prepareEffectRequest = (options: {
+  endpoint: GeneratedEffectEndpoint;
+  operation: EffectOperationDescriptor;
+  request: unknown;
+  config: GeneratedEffectClientConfig;
+  createEffectRequestContext: (
+    requestContext: EffectRequestContextInput,
+  ) => EffectRequestContext;
+}): Record<string, unknown> => {
+  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 =
+    dataPlatform.requireEnvelope === true || dataPlatform.strict === true;
+
+  if (
+    !strictEnvelope &&
+    !shouldAttachEnvelopeHeader(dataPlatform, defaultOrigin)
+  ) {
+    return normalizedRequest;
+  }
+
+  try {
+    const namespace =
+      stringOrUndefined(dataPlatform.appNamespace) || config.appNamespace;
+    const origin =
+      stringOrUndefined(dataPlatform.origin) || resolveOrigin(defaultOrigin);
+    const envelope: RequestEnvelope = 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 as RequestEnvelope['requestMode'])
+        : undefined,
+      mutationMode: isDataMutationMode(dataPlatform.mutationMode)
+        ? (dataPlatform.mutationMode as RequestEnvelope['mutationMode'])
+        : undefined,
+      selectionPlan: isRecord(dataPlatform.selectionPlan)
+        ? (dataPlatform.selectionPlan as SelectionPlan)
+        : undefined,
+      traceContext: isRecord(dataPlatform.traceContext)
+        ? (dataPlatform.traceContext as unknown as TraceContext)
+        : undefined,
+      requireTraceContext: dataPlatform.requireTraceContext === true,
+    });
+
+    const headerName =
+      stringOrUndefined(dataPlatform.envelopeHeader) ||
+      DEFAULT_DATA_ENVELOPE_HEADER;
+    const headers = isRecord(normalizedRequest.headers)
+      ? { ...normalizedRequest.headers }
+      : {};
+
+    if (dataPlatform.batch === false) {
+      headers[DEFAULT_DATA_BATCH_HEADER] = 'off';
+    }
+
+    headers[headerName] = encodeRequestEnvelopeHeader(envelope);
+
+    return {
+      ...normalizedRequest,
+      headers,
+    };
+  } catch (error) {
+    if (strictEnvelope) {
+      throw error;
+    }
+    return normalizedRequest;
+  }
+};

package/src/effect-client/guards.ts

@@ -0,0 +1,6 @@
+// @effect-diagnostics processEnv:off strictBooleanExpressions:off
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+export const stringOrUndefined = (value: unknown): string | undefined =>
+  typeof value === 'string' && value.length > 0 ? value : undefined;

package/src/effect-client/index.ts

@@ -0,0 +1,325 @@
+// @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off newPromise:off strictEffectProvide:off
+import {
+  createRequestContextHeaders,
+  type RequestContextInput,
+} from '@modern-js/create-request';
+import * as Data from 'effect/Data';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import * as Scope from 'effect/Scope';
+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';
+
+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';
+
+export class EffectRpcClientError extends Data.TaggedError(
+  'EffectRpcClientError',
+)<{
+  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>;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function applySelection(value: unknown, selection: unknown): unknown {
+  if (selection === true || selection === undefined) {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(item => applySelection(item, selection));
+  }
+
+  if (!isRecord(value) || !isRecord(selection)) {
+    return value;
+  }
+
+  const masked: Record<string, unknown> = {};
+  for (const key of Object.keys(selection)) {
+    const selected = selection[key];
+    if (
+      selected === undefined ||
+      !(key in value) ||
+      (selected !== true && !isRecord(selected))
+    ) {
+      continue;
+    }
+    masked[key] = applySelection(value[key], selected);
+  }
+  return masked;
+}
+
+export function view<T>() {
+  return <const Selection extends EffectViewSelection<T>>(
+    selection: Selection,
+  ) => selection;
+}
+
+export function mask<T, const Selection extends EffectViewSelection<T>>(
+  value: T,
+  selection: Selection,
+): EffectViewData<T, Selection> {
+  return applySelection(value, selection) as EffectViewData<T, Selection>;
+}
+
+export function runEffectView<
+  T,
+  const Selection extends EffectViewSelection<T>,
+>(
+  request: PromiseLike<T>,
+  selection: Selection,
+): Promise<EffectViewData<T, Selection>> {
+  return new Promise((resolve, reject) => {
+    request.then(
+      value => resolve(mask(value, selection)),
+      reason => reject(reason),
+    );
+  });
+}
+
+export 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>
+> {
+  const requestContextHeaders = createRequestContextHeaders(
+    options?.requestContext,
+  );
+  const transformClient = (client: HttpClient.HttpClient) => {
+    const contextClient =
+      Object.keys(requestContextHeaders).length === 0
+        ? client
+        : client.pipe(
+            HttpClient.mapRequest(request => {
+              let nextRequest = request;
+              for (const [header, value] of Object.entries(
+                requestContextHeaders,
+              )) {
+                if (nextRequest.headers[header.toLowerCase()] === undefined) {
+                  nextRequest = HttpClientRequest.setHeader(
+                    nextRequest,
+                    header,
+                    value,
+                  );
+                }
+              }
+              return nextRequest;
+            }),
+          );
+
+    return typeof options?.transformClient === 'function'
+      ? options.transformClient(contextClient)
+      : contextClient;
+  };
+
+  return HttpApiClient.make(api, {
+    baseUrl: options?.baseUrl,
+    transformClient,
+    transformResponse: options?.transformResponse,
+  }).pipe(Effect.provide(FetchHttpClient.layer));
+}
+
+export function makeEffectRpcClient<
+  Rpcs extends Rpc.Any,
+  const Flatten extends boolean = false,
+>(
+  group: RpcGroup.RpcGroup<Rpcs>,
+  options: EffectRpcClientOptions<Rpcs, Flatten>,
+) {
+  const protocolLayer = Layer.provide(
+    RpcClient.layerProtocolHttp({
+      url: options.url,
+    }),
+    Layer.mergeAll(
+      getRpcSerializationLayer(options.serialization),
+      FetchHttpClient.layer,
+    ),
+  );
+  const middlewareLayer = options.middlewareLayer ?? Layer.empty;
+  const runtimeLayer = Layer.mergeAll(protocolLayer, middlewareLayer);
+
+  return Effect.tryPromise({
+    try: async () => {
+      const runtime = ManagedRuntime.make(runtimeLayer);
+      let scope: Scope.Closeable | undefined;
+      try {
+        const clientScope = await runtime.runPromise(Scope.make());
+        scope = clientScope;
+        const client = await runtime.runPromise(
+          RpcClient.make(group, {
+            flatten: options.flatten,
+          }).pipe(Effect.provideService(Scope.Scope, clientScope)),
+        );
+        let disposePromise: Promise<void> | undefined;
+        const clientWithDispose: EffectRpcClientHandle<Rpcs, Flatten> =
+          Object.assign(client, {
+            dispose: () => {
+              disposePromise ??= (async () => {
+                let scopeCloseError: unknown;
+                try {
+                  await runtime.runPromise(Scope.close(clientScope, Exit.void));
+                } catch (error) {
+                  scopeCloseError = error;
+                }
+                try {
+                  await runtime.dispose();
+                } catch (error) {
+                  if (scopeCloseError === undefined) {
+                    throw error;
+                  }
+                }
+                if (scopeCloseError !== undefined) {
+                  throw scopeCloseError;
+                }
+              })();
+              return disposePromise;
+            },
+          });
+        return clientWithDispose;
+      } catch (error) {
+        if (scope !== undefined) {
+          try {
+            await runtime.runPromise(Scope.close(scope, Exit.void));
+          } catch {
+            // ignore scope close errors and preserve the original construction error
+          }
+        }
+        try {
+          await runtime.dispose();
+        } catch {
+          // ignore disposal errors and preserve the original construction error
+        }
+        throw error;
+      }
+    },
+    catch: (error: unknown) => new EffectRpcClientError({ cause: error }),
+  });
+}
+
+export const runEffectRequest = Effect.runPromise;

package/src/effect-client/request-context.ts

@@ -0,0 +1,54 @@
+// @effect-diagnostics processEnv:off strictBooleanExpressions:off
+import { isRecord } from './guards';
+import type {
+  EffectRequestContext,
+  EffectRequestContextInput,
+  EffectRequestRuntime,
+} from './types';
+
+export const createEffectRequestContext = (
+  createRequestContextHeaders: EffectRequestRuntime['createRequestContextHeaders'],
+  requestContext: EffectRequestContextInput,
+): EffectRequestContext => {
+  if (!isRecord(requestContext)) {
+    return {} as EffectRequestContext;
+  }
+
+  const headers = createRequestContextHeaders
+    ? createRequestContextHeaders(requestContext)
+    : {};
+
+  return {
+    ...requestContext,
+    headers,
+  };
+};
+
+export const applyRequestContext = (
+  normalizedRequest: Record<string, unknown>,
+  request: unknown,
+  createRequestContext: (
+    requestContext: EffectRequestContextInput,
+  ) => EffectRequestContext,
+): Record<string, unknown> => {
+  if (!isRecord(request) || !isRecord(request.requestContext)) {
+    return normalizedRequest;
+  }
+
+  const requestContext = createRequestContext(request.requestContext);
+  const requestHeaders = isRecord(requestContext.headers)
+    ? requestContext.headers
+    : {};
+
+  if (Object.keys(requestHeaders).length === 0) {
+    return normalizedRequest;
+  }
+
+  return {
+    ...normalizedRequest,
+    headers: {
+      ...(isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {}),
+      ...requestHeaders,
+    },
+  };
+};