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

package/src/effect-client/request.ts

@@ -0,0 +1,51 @@
+// @effect-diagnostics processEnv:off strictBooleanExpressions:off
+import { isRecord } from './guards';
+
+const METHODS_WITHOUT_BODY = new Set(['GET', 'DELETE', 'HEAD', 'OPTIONS']);
+
+export const normalizeRequest = (
+  method: string,
+  request: unknown,
+): Record<string, unknown> => {
+  if (!isRecord(request)) {
+    return {};
+  }
+
+  const payload: Record<string, unknown> = { ...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 && request.payload !== undefined) {
+    if (
+      typeof FormData !== 'undefined' &&
+      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)) {
+      payload.data = request.payload;
+    } else if (!('body' in payload)) {
+      payload.body = request.payload;
+    }
+  }
+
+  return payload;
+};

package/src/effect-client/runtime.ts

@@ -0,0 +1,122 @@
+// @effect-diagnostics processEnv:off strictBooleanExpressions:off
+import { configureGeneratedEffectClientRuntime } from './batch';
+import { prepareEffectRequest } from './envelope';
+import { createEffectRequestContext as createEffectRequestContextWithHeaders } from './request-context';
+import type {
+  EffectClient,
+  EffectClientOperation,
+  EffectOperationDescriptor,
+  EffectOperationManifest,
+  EffectRequestContext,
+  EffectRequestContextInput,
+  EffectRequestRuntime,
+  GeneratedEffectClientConfig,
+  GeneratedEffectClientModule,
+  GeneratedEffectEndpoint,
+} from './types';
+
+export type {
+  EffectClient,
+  EffectClientGroup,
+  EffectClientOperation,
+  EffectOperationDescriptor,
+  EffectOperationManifest,
+  EffectRequestContext,
+  EffectRequestContextInput,
+  EffectRequestRuntime,
+  GeneratedEffectBatchConfig,
+  GeneratedEffectClientConfig,
+  GeneratedEffectClientModule,
+  GeneratedEffectEndpoint,
+} from './types';
+
+export const createGeneratedEffectClient = (
+  manifest: { endpoints: GeneratedEffectEndpoint[] },
+  config: GeneratedEffectClientConfig,
+  requestRuntime: EffectRequestRuntime,
+): GeneratedEffectClientModule => {
+  const createRequest = requestRuntime.createRequest;
+  const configureRequest =
+    typeof requestRuntime.configure === 'function'
+      ? requestRuntime.configure
+      : undefined;
+  const createRequestContextHeaders =
+    typeof requestRuntime.createRequestContextHeaders === 'function'
+      ? requestRuntime.createRequestContextHeaders
+      : undefined;
+
+  const httpMethodDecider = config.httpMethodDecider || 'functionName';
+  const port =
+    config.useEnvPort &&
+    typeof process !== 'undefined' &&
+    process.env &&
+    process.env.PORT
+      ? process.env.PORT
+      : config.port;
+
+  configureGeneratedEffectClientRuntime(config, configureRequest);
+
+  const createEffectRequestContext = (
+    requestContext: EffectRequestContextInput,
+  ): EffectRequestContext =>
+    createEffectRequestContextWithHeaders(
+      createRequestContextHeaders,
+      requestContext,
+    );
+
+  const client: EffectClient = {};
+  const operationManifest: EffectOperationManifest = {};
+
+  for (const endpoint of manifest.endpoints) {
+    const operationId = `${endpoint.method}:${endpoint.routePath}`;
+    const operation: EffectOperationDescriptor = {
+      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: EffectClientOperation = (request: unknown = {}) =>
+      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,
+  };
+};

package/src/effect-client/types.ts

@@ -0,0 +1,84 @@
+// @effect-diagnostics processEnv:off strictBooleanExpressions:off
+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;
+};

package/src/headers.ts

@@ -0,0 +1,7 @@
+export function toHeaderRecord(headers: Headers): Record<string, string> {
+  const record: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * as DataPlatform from './data-platform';
+export * from './effect';
+export * as EffectClient from './effect-client';