@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.5 → 3.9.0-ultramodern.7

package/tests/request-policy/node-policy.test.ts

@@ -11,7 +11,6 @@ import { storage } from '@modern-js/runtime-utils/node';
 import nock from 'nock';
 
 describe('configure', () => {
-  const url = 'http://127.0.0.1:8080';
   const path = '/api';
   const method = 'GET';
   const response = {
@@ -88,99 +87,6 @@ describe('configure', () => {
     ).toThrow(ProducerDomainNotConfiguredError);
   });
 
-  test('should isolate custom request by requestId', async () => {
-    const producerA = 'producer-a';
-    const producerB = 'producer-b';
-    const urlA = 'http://127.0.0.1:9081';
-    const urlB = 'http://127.0.0.1:9082';
-
-    nock(urlA).get(path).reply(200, response);
-    nock(urlB).get(path).reply(200, response);
-
-    const customRequestA = rs.fn((requestPath: any) => fetch(requestPath));
-    const customRequestB = rs.fn((requestPath: any) => fetch(requestPath));
-
-    configure({
-      request: customRequestA as unknown as typeof fetch,
-      requestId: producerA,
-      operationContract: {
-        enabled: false,
-      },
-      setDomain: () => urlA,
-    });
-    configure({
-      request: customRequestB as unknown as typeof fetch,
-      requestId: producerB,
-      operationContract: {
-        enabled: false,
-      },
-      setDomain: () => urlB,
-    });
-
-    const requestA = createRequest({
-      path,
-      method,
-      port: 8080,
-      requestId: producerA,
-    });
-    const requestB = createRequest({
-      path,
-      method,
-      port: 8080,
-      requestId: producerB,
-    });
-
-    const resA = await requestA();
-    const resB = await requestB();
-
-    expect(customRequestA).toHaveBeenCalledTimes(1);
-    expect(customRequestB).toHaveBeenCalledTimes(1);
-    expect(resA instanceof Response).toBe(true);
-    expect(resB instanceof Response).toBe(true);
-  });
-
-  test('should propagate allowed headers for non-default requestId', async () => {
-    const producer = 'producer-non-default';
-    const authKey = 'token-abc';
-    const producerUrl = 'http://127.0.0.1:9083';
-
-    await run(
-      {
-        authorization: authKey,
-      },
-      async () => {
-        nock(producerUrl, {
-          reqheaders: {
-            authorization: authKey,
-          },
-        })
-          .get(path)
-          .reply(200, response);
-
-        configure({
-          requestId: producer,
-          allowedHeaders: ['authorization'],
-          operationContract: {
-            enabled: false,
-          },
-          setDomain: () => producerUrl,
-        });
-
-        const request = createRequest(
-          path,
-          method,
-          8080,
-          undefined,
-          undefined,
-          producer,
-        );
-        const data = await request();
-
-        expect(data).toStrictEqual(response);
-      },
-    );
-  });
-
   test('should support secure resolveHeaders callback for non-default requestId', async () => {
     const producer = 'producer-with-resolver';
     const authKey = 'token-def';
@@ -538,204 +444,4 @@ describe('configure', () => {
       delete process.env.MODERN_BFF_STRICT_DEFAULT_REQUEST_ID;
     }
   });
-
-  test('should retry with backoff and emit degraded telemetry events', async () => {
-    rs.useFakeTimers();
-    const onDegraded = rs.fn();
-    let attempts = 0;
-
-    const customRequest = rs.fn(async () => {
-      attempts += 1;
-      if (attempts < 3) {
-        const error: any = new Error('temporary upstream error');
-        error.status = 503;
-        throw error;
-      }
-      return response;
-    });
-
-    try {
-      configure({
-        request: customRequest as unknown as typeof fetch,
-        transport: {
-          retry: {
-            retries: 2,
-            baseDelayMs: 20,
-            maxDelayMs: 20,
-            jitterRatio: 0,
-          },
-          onDegraded,
-        },
-      });
-
-      const request = createRequest(path, method, 8080);
-      const pending = request();
-
-      await Promise.resolve();
-      await rs.advanceTimersByTimeAsync(20);
-      await Promise.resolve();
-      await rs.advanceTimersByTimeAsync(20);
-      await Promise.resolve();
-
-      await expect(pending).resolves.toStrictEqual(response);
-      expect(customRequest).toHaveBeenCalledTimes(3);
-      expect(onDegraded).toHaveBeenCalledWith(
-        expect.objectContaining({
-          reason: 'retry',
-          attempt: 1,
-          maxAttempts: 3,
-          backoffMs: 20,
-        }),
-      );
-      expect(onDegraded).toHaveBeenCalledWith(
-        expect.objectContaining({
-          reason: 'retry',
-          attempt: 2,
-          maxAttempts: 3,
-          backoffMs: 20,
-        }),
-      );
-    } finally {
-      rs.useRealTimers();
-    }
-  });
-
-  test('should not retry non-idempotent requests by default', async () => {
-    rs.useFakeTimers();
-    const onDegraded = rs.fn();
-    const customRequest = rs.fn(async () => {
-      const error: any = new Error('post failed');
-      error.status = 503;
-      throw error;
-    });
-
-    try {
-      configure({
-        request: customRequest as unknown as typeof fetch,
-        transport: {
-          retry: {
-            retries: 2,
-            baseDelayMs: 1,
-            maxDelayMs: 1,
-            jitterRatio: 0,
-          },
-          onDegraded,
-        },
-      });
-
-      const request = createRequest(path, 'POST', 8080);
-      const pending = request({ body: 'payload' });
-      const failure = expect(pending).rejects.toThrow('post failed');
-
-      await Promise.resolve();
-      await rs.advanceTimersByTimeAsync(1);
-      await Promise.resolve();
-      await rs.advanceTimersByTimeAsync(1);
-      await failure;
-
-      expect(customRequest).toHaveBeenCalledTimes(1);
-      expect(onDegraded).not.toHaveBeenCalledWith(
-        expect.objectContaining({ reason: 'retry' }),
-      );
-    } finally {
-      rs.useRealTimers();
-    }
-  });
-
-  test('should emit retry_exhausted when retry budget is consumed', async () => {
-    rs.useFakeTimers();
-    const onDegraded = rs.fn();
-    const customRequest = rs.fn(async () => {
-      const error: any = new Error('upstream unavailable');
-      error.status = 503;
-      throw error;
-    });
-
-    try {
-      configure({
-        request: customRequest as unknown as typeof fetch,
-        transport: {
-          retry: {
-            retries: 1,
-            baseDelayMs: 10,
-            maxDelayMs: 10,
-            jitterRatio: 0,
-          },
-          onDegraded,
-        },
-      });
-
-      const request = createRequest(path, method, 8080);
-      const pending = request();
-      const failure = expect(pending).rejects.toThrow('upstream unavailable');
-
-      await Promise.resolve();
-      await rs.advanceTimersByTimeAsync(10);
-      await failure;
-
-      expect(customRequest).toHaveBeenCalledTimes(2);
-      expect(onDegraded).toHaveBeenCalledWith(
-        expect.objectContaining({
-          reason: 'retry',
-          attempt: 1,
-          maxAttempts: 2,
-        }),
-      );
-      expect(onDegraded).toHaveBeenCalledWith(
-        expect.objectContaining({
-          reason: 'retry_exhausted',
-          attempt: 2,
-          maxAttempts: 2,
-        }),
-      );
-    } finally {
-      rs.useRealTimers();
-    }
-  });
-
-  test('should abort timed out requests and emit timeout degraded event', async () => {
-    rs.useFakeTimers();
-    const onDegraded = rs.fn();
-
-    const customRequest = rs.fn((_requestPath: any, init?: any) => {
-      return new Promise((_, reject) => {
-        init?.signal?.addEventListener('abort', () => {
-          const error: any = new Error('aborted');
-          error.name = 'AbortError';
-          reject(error);
-        });
-      });
-    });
-
-    try {
-      configure({
-        request: customRequest as unknown as typeof fetch,
-        transport: {
-          timeoutMs: 50,
-          onDegraded,
-        },
-      });
-
-      const request = createRequest(path, method, 8080);
-      const pending = request();
-      const failure = expect(pending).rejects.toMatchObject({
-        name: 'TimeoutError',
-      });
-
-      await rs.advanceTimersByTimeAsync(50);
-      await failure;
-
-      expect(customRequest).toHaveBeenCalledTimes(1);
-      expect(onDegraded).toHaveBeenCalledWith(
-        expect.objectContaining({
-          reason: 'timeout',
-          timeoutMs: 50,
-          attempt: 1,
-          maxAttempts: 1,
-        }),
-      );
-    } finally {
-      rs.useRealTimers();
-    }
-  });
 });

package/tests/request-policy/policyCore.test.ts

@@ -8,8 +8,6 @@ import {
   isSecuredRequestId,
   OperationContractViolationError,
   readHeader,
-  resolveConfiguredRequest,
-  toOrigin,
   validateOperationContract,
   writeHeader,
 } from '../../src/request-policy/policyCore';
@@ -28,34 +26,11 @@ describe('policyCore (shared browser/node policy module)', () => {
     expect(headers).toEqual({});
   });
 
-  test('toOrigin behaves identically for both targets', () => {
-    expect(toOrigin('https://example.com/a/b?c=1')).toBe('https://example.com');
-    expect(toOrigin('not-a-url')).toBeUndefined();
-  });
-
   test('isSecuredRequestId treats only "default" as unsecured by default', () => {
     expect(isSecuredRequestId('default')).toBe(false);
     expect(isSecuredRequestId('crm-producer')).toBe(true);
   });
 
-  test('buildOperationContext prefixes operationId with the requestId', () => {
-    const context = buildOperationContext({
-      requestId: 'crm',
-      method: 'get',
-      path: '/hello',
-      operationContext: {
-        operationId: 'getHello',
-        schemaHash: 'abc',
-        operationVersion: 2,
-      },
-    });
-
-    expect(context.operationId).toBe('crm:getHello');
-    expect(context.method).toBe('GET');
-    expect(context.schemaHash).toBe('abc');
-    expect(context.operationVersion).toBe(2);
-  });
-
   test('validateOperationContract throws on missing schema hash for secured ids', () => {
     const contextPayload = buildOperationContext({
       requestId: 'crm',
@@ -151,100 +126,4 @@ describe('policyCore (shared browser/node policy module)', () => {
       operationVersion: 1,
     });
   });
-
-  test('resolveConfiguredRequest throws for unconfigured non-default producers', () => {
-    const map = new Map<string, string>();
-    expect(() => resolveConfiguredRequest(map, 'crm', 'fallback')).toThrow(
-      'Producer client "crm" is not initialized',
-    );
-    expect(resolveConfiguredRequest(map, 'default', 'fallback')).toBe(
-      'fallback',
-    );
-    map.set('crm', 'configured');
-    expect(resolveConfiguredRequest(map, 'crm', 'fallback')).toBe('configured');
-  });
-});
-
-describe('createUploader policy headers (node entry)', () => {
-  test('attaches envelope and operation-context headers for secured producers', async () => {
-    const { configure, createUploader } = await import(
-      '@modern-js/runtime-extensions/request-policy/server'
-    );
-
-    const seenInit: Array<{ url: string; init: any }> = [];
-    const fakeFetch = (async (url: any, init: any) => {
-      seenInit.push({ url: String(url), init });
-      return new Response('{}', { status: 200 });
-    }) as typeof fetch;
-
-    configure({
-      requestId: 'upload-producer',
-      request: fakeFetch,
-      setDomain: () => 'http://producer.example',
-    });
-
-    const upload = createUploader({
-      path: '/api/upload',
-      requestId: 'upload-producer',
-      operationContext: {
-        operationId: 'upload',
-        routePath: '/api/upload',
-        method: 'POST',
-        schemaHash: 'hash-1',
-        operationVersion: 1,
-      },
-    });
-
-    const file = new File(['hello'], 'hello.txt', { type: 'text/plain' });
-    await upload({ files: { file } });
-
-    expect(seenInit).toHaveLength(1);
-    const { url, init } = seenInit[0]!;
-    expect(url).toBe('http://producer.example/api/upload');
-    expect(init.method).toBe('POST');
-
-    const envelope = JSON.parse(init.headers['x-modernjs-bff-envelope']);
-    expect(envelope.requestId).toBe('upload-producer');
-
-    expect(init.headers['x-operation-id']).toBe('upload-producer:upload');
-    const details = JSON.parse(
-      init.headers['x-modernjs-bff-operation-context'],
-    );
-    expect(details).toMatchObject({
-      requestId: 'upload-producer',
-      operationId: 'upload-producer:upload',
-      routePath: '/api/upload',
-      method: 'POST',
-      schemaHash: 'hash-1',
-      operationVersion: 1,
-    });
-  });
-
-  test('keeps the default uploader free of policy headers', async () => {
-    const { createUploader } = await import(
-      '@modern-js/runtime-extensions/request-policy/server'
-    );
-
-    const seenInit: Array<{ init: any }> = [];
-    const fakeFetch = (async (_url: any, init: any) => {
-      seenInit.push({ init });
-      return new Response('{}', { status: 200 });
-    }) as typeof fetch;
-
-    // default requestId falls back to the passed fetch only via configure-less
-    // path; install a custom request for determinism.
-    const { configure } = await import(
-      '@modern-js/runtime-extensions/request-policy/server'
-    );
-    configure({ request: fakeFetch });
-
-    const upload = createUploader({ path: '/api/upload' });
-    const file = new File(['hi'], 'hi.txt', { type: 'text/plain' });
-    await upload({ files: { file } });
-
-    expect(seenInit).toHaveLength(1);
-    const headers = seenInit[0]!.init.headers as Record<string, unknown>;
-    expect(headers['x-modernjs-bff-envelope']).toBeUndefined();
-    expect(headers['x-operation-id']).toBeUndefined();
-  });
 });

package/tests/request-policy/requestContext.test.ts

@@ -54,27 +54,13 @@ describe('request context helpers', () => {
       },
     });
 
-    expect(snapshot.headers).toEqual({
-      [BFF_LOCALE_HEADER]: 'cs-CZ',
-      [BFF_TRACEPARENT_HEADER]:
-        '00-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-bbbbbbbbbbbbbbbb-01',
-    });
-    expect(snapshot).toMatchObject({
-      locale: 'cs-CZ',
-      traceparent: '00-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-bbbbbbbbbbbbbbbb-01',
-      traceId: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      spanId: 'bbbbbbbbbbbbbbbb',
-      operationContext: {
-        operationId: 'shell:list',
-        routePath: '/effect/recommendations',
-        method: 'GET',
-        source: 'generated-client',
-        scope: { workspace: 'demo' },
-        sessionClaims: { role: 'viewer' },
-        traceparent: '00-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-bbbbbbbbbbbbbbbb-01',
-        traceId: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-        spanId: 'bbbbbbbbbbbbbbbb',
-      },
-    });
+    expect(Object.keys(snapshot.headers)).toEqual([
+      BFF_LOCALE_HEADER,
+      BFF_TRACEPARENT_HEADER,
+    ]);
+    expect(snapshot.operationContext?.traceId).toBe(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+    );
+    expect(snapshot.operationContext?.spanId).toBe('bbbbbbbbbbbbbbbb');
   });
 });