@bleedingdev/modern-js-bff-effect 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/src/effect/edge-dispatcher.ts

@@ -3,7 +3,8 @@ import {
   evaluateCrossProjectPolicy,
   type NormalizedCrossProjectPolicy,
   resolveCrossProjectRequestObservation,
-} from '@modern-js/bff-core/security/cross-project-policy';
+} from '@modern-js/server-runtime-extensions/bff-policy';
+import * as Effect from 'effect/Effect';
 import { toHeaderRecord } from '../headers';
 import {
   type DispatchEffectBffRequestOptions,
@@ -285,9 +286,11 @@ export async function createEffectBffEdgeDispatcher(
       disposePromise ??= (async () => {
         acceptingRequests = false;
         if (activeDispatches > 0) {
-          await new Promise<void>(resolve => {
-            resolveDrain = resolve;
-          });
+          await Effect.runPromise(
+            Effect.callback<void>(resume => {
+              resolveDrain = () => resume(Effect.void);
+            }),
+          );
         }
         await loaded.dispose?.();
       })();

package/src/effect/edge.ts

@@ -1 +1,2 @@
 export * from './edge-dispatcher';
+export { createEffectBffEdgeDispatcherFactory } from './generated-entry';

package/src/effect/endpoint-contracts.ts

@@ -15,7 +15,7 @@
 import {
   createOperationContractHash,
   type OperationContractSource,
-} from '@modern-js/bff-core';
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
 import {
   classifyEffectBffEntryModule,
   isValidatorAwareHandlerFactory,

package/src/effect/entry-shape.ts

@@ -42,8 +42,11 @@ function loadNodeValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandlerFa
   }
 }
 
+declare const __MODERN_EFFECT_NODE_RUNTIME__: boolean;
+
 const validatorAwareHandlerFactoryRegistry =
-  process.env.MODERN_EFFECT_NODE_RUNTIME === 'true'
+  typeof __MODERN_EFFECT_NODE_RUNTIME__ !== 'undefined' &&
+  __MODERN_EFFECT_NODE_RUNTIME__
     ? loadNodeValidatorAwareHandlerFactoryRegistry()
     : createLocalValidatorAwareHandlerFactoryRegistry();
 

package/src/effect/generated-entry.ts

@@ -0,0 +1,36 @@
+import {
+  createEffectBffEdgeDispatcher,
+  type EffectBffEdgeHandlerOptions,
+} from './edge-dispatcher';
+
+type OperationContracts = NonNullable<
+  EffectBffEdgeHandlerOptions['crossProjectPolicy']
+>['expectedOperationContracts'];
+
+export function createEffectBffEdgeDispatcherFactory(
+  module: EffectBffEdgeHandlerOptions['module'],
+  generatedOperationContracts: OperationContracts,
+) {
+  return (options?: Omit<EffectBffEdgeHandlerOptions, 'module'>) => {
+    const policy = options?.crossProjectPolicy;
+    const crossProjectPolicy =
+      policy === undefined ||
+      policy === null ||
+      policy.expectedOperationContracts === null ||
+      typeof policy.expectedOperationContracts !== 'object' ||
+      Array.isArray(policy.expectedOperationContracts)
+        ? policy
+        : {
+            ...policy,
+            expectedOperationContracts: {
+              ...policy.expectedOperationContracts,
+              ...generatedOperationContracts,
+            },
+          };
+    return createEffectBffEdgeDispatcher({
+      ...options,
+      crossProjectPolicy,
+      module,
+    });
+  };
+}

package/src/effect/handler/batch-handler.ts

@@ -1,4 +1,5 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
+import * as Effect from 'effect/Effect';
 import {
   type DataBatchResponsePayload,
   DEFAULT_DATA_BATCH_HEADER,
@@ -417,14 +418,16 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
           );
         } catch (error) {
           if (error instanceof BatchItemTimeoutError) {
-            console.error({
-              event: 'bff.batch.item.timeout',
-              batchId: payload.batchId,
-              itemId,
-              method: itemMethod,
-              path: itemPathname,
-              errorName: error.name,
-            });
+            Effect.runSync(
+              Effect.logError({
+                event: 'bff.batch.item.timeout',
+                batchId: payload.batchId,
+                itemId,
+                method: itemMethod,
+                path: itemPathname,
+                errorName: error.name,
+              }),
+            );
             return toBatchItemError(
               itemId,
               504,
@@ -435,14 +438,16 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
             return toBatchResponseItem(itemId, error, itemMethod === 'HEAD');
           }
 
-          console.error({
-            event: 'bff.batch.item.failure',
-            batchId: payload.batchId,
-            itemId,
-            method: itemMethod,
-            path: itemPathname,
-            errorName: error instanceof Error ? error.name : 'UnknownError',
-          });
+          Effect.runSync(
+            Effect.logError({
+              event: 'bff.batch.item.failure',
+              batchId: payload.batchId,
+              itemId,
+              method: itemMethod,
+              path: itemPathname,
+              errorName: error instanceof Error ? error.name : 'UnknownError',
+            }),
+          );
           return toBatchItemError(itemId, 500, 'Internal Server Error');
         } finally {
           request.signal.removeEventListener('abort', abortFromBatchRequest);

package/src/effect/handler/batch.ts

@@ -1,5 +1,6 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
 
+import * as Data from 'effect/Data';
 import {
   type DataBatchRequestPayload,
   type DataBatchResponseItem,
@@ -117,7 +118,14 @@ export function toBatchItemError(
   };
 }
 
-export class BatchItemTimeoutError extends Error {}
+export class BatchItemTimeoutError extends Data.TaggedError(
+  'BatchItemTimeoutError',
+)<{ readonly message: string }> {
+  constructor(message: string) {
+    super({ message });
+    this.name = 'Error';
+  }
+}
 
 export function promiseWithTimeout<T>(
   effect: Promise<T>,

package/src/effect/operation-context.ts

@@ -6,7 +6,7 @@ import {
   BFF_TRACEPARENT_HEADER,
   type OperationContext,
   parseTraceparent,
-} from '@modern-js/create-request';
+} from '@modern-js/runtime-extensions/request-context';
 
 export type EffectContext = {
   request: Request;

package/src/effect-client/index.ts

@@ -2,7 +2,7 @@
 import {
   createRequestContextHeaders,
   type RequestContextInput,
-} from '@modern-js/create-request';
+} from '@modern-js/runtime-extensions/request-context';
 import * as Data from 'effect/Data';
 import * as Effect from 'effect/Effect';
 import * as Exit from 'effect/Exit';

package/src/effect-client/types.ts

@@ -59,7 +59,7 @@ export type EffectRequestContext = {
   headers: Record<string, string>;
 } & Record<string, unknown>;
 
-/** Structural slice of `@modern-js/create-request` the runtime relies on. */
+/** Structural slice of `@modern-js/runtime-extensions/request-policy` the runtime relies on. */
 export type EffectRequestRuntime = {
   createRequest: (options: {
     path: string;

package/src/microvertical-api.ts

@@ -0,0 +1,102 @@
+import { Schema } from 'effect';
+
+const MicroVerticalAppIdSchema = Schema.String.pipe(
+  Schema.brand('MicroVerticalAppId'),
+  Schema.decodeTo(Schema.String),
+);
+const MicroVerticalUnitIdSchema = Schema.String.pipe(
+  Schema.brand('MicroVerticalUnitId'),
+  Schema.decodeTo(Schema.String),
+);
+const MicroVerticalOperationIdSchema = Schema.String.pipe(
+  Schema.brand('MicroVerticalOperationId'),
+  Schema.decodeTo(Schema.String),
+);
+const MicroVerticalTraceIdSchema = Schema.String.pipe(
+  Schema.brand('MicroVerticalTraceId'),
+  Schema.decodeTo(Schema.String),
+);
+
+export const MicroVerticalBuildMarkerSchema = Schema.Struct({
+  appId: MicroVerticalAppIdSchema,
+  build: Schema.String,
+  buildMarker: Schema.String,
+  deployProfile: Schema.String,
+  packageName: Schema.String,
+  sourceRevision: Schema.String,
+  surface: Schema.String,
+  unitId: MicroVerticalUnitIdSchema,
+  version: Schema.String,
+});
+export type MicroVerticalBuildMarker =
+  typeof MicroVerticalBuildMarkerSchema.Type;
+
+export const MicroVerticalReadinessSchema = Schema.Struct({
+  checks: Schema.Struct({
+    api: Schema.Literal('ready'),
+    moduleFederation: Schema.Literal('ready'),
+    ssr: Schema.Literal('ready'),
+    translations: Schema.Literal('ready'),
+  }),
+  marker: MicroVerticalBuildMarkerSchema,
+  status: Schema.Literal('ready'),
+  versionSkew: Schema.Literal('none'),
+});
+export type MicroVerticalReadiness = typeof MicroVerticalReadinessSchema.Type;
+
+export const MicroVerticalOperationSourceSchema = Schema.Literals([
+  'client',
+  'server',
+  'generated-client',
+  'effect-adapter',
+  'data-platform',
+  'unknown',
+]);
+export type MicroVerticalOperationSource =
+  typeof MicroVerticalOperationSourceSchema.Type;
+
+export const MicroVerticalOperationContextSchema = Schema.Struct({
+  method: Schema.String,
+  operationId: MicroVerticalOperationIdSchema,
+  routePath: Schema.String,
+  source: MicroVerticalOperationSourceSchema,
+  traceId: Schema.optionalKey(MicroVerticalTraceIdSchema),
+});
+export type MicroVerticalOperationContext =
+  typeof MicroVerticalOperationContextSchema.Type;
+
+export const createMicroVerticalOperationContext = <
+  const Method extends string,
+  const OperationId extends string,
+  const RoutePath extends string,
+>(input: {
+  readonly method: Method;
+  readonly operationId: OperationId;
+  readonly routePath: RoutePath;
+  // eslint-disable-next-line effect-native/no-threaded-correlation-parameter -- This pure browser-safe contract deliberately carries optional trace metadata; it does not perform ambient request work.
+  readonly traceId?: string;
+}): Readonly<typeof input & { source: 'generated-client' }> => {
+  const context = {
+    method: input.method,
+    operationId: input.operationId,
+    routePath: input.routePath,
+    source: 'generated-client' as const,
+  };
+  return input.traceId === undefined
+    ? context
+    : { ...context, traceId: input.traceId };
+};
+
+export const microVerticalOperationAttributes = (
+  operationContext: MicroVerticalOperationContext,
+) => {
+  const attributes = {
+    'modernjs.operation.id': operationContext.operationId,
+    'modernjs.operation.method': operationContext.method,
+    'modernjs.operation.route': operationContext.routePath,
+    'modernjs.operation.source': operationContext.source,
+  };
+  return operationContext.traceId === undefined
+    ? attributes
+    : { ...attributes, 'modernjs.trace.id': operationContext.traceId };
+};