@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/tests/request-policy/requestFactory.outbound-contract.test.ts

@@ -1,290 +0,0 @@
-import { createClient as createBrowserClient } from '@modern-js/runtime-extensions/request-policy/client';
-import { createClient as createServerClient } from '@modern-js/runtime-extensions/request-policy/server';
-import { storage } from '@modern-js/runtime-utils/node';
-import {
-  BFF_ENVELOPE_HEADER,
-  BFF_OPERATION_CONTEXT_DETAIL_HEADER,
-  BFF_OPERATION_CONTEXT_HEADER,
-  type TransportTarget,
-} from '../../src/request-policy/types';
-
-const ACCEPT_HEADER = 'application/json,*/*;q=0.8';
-const REQUEST_PATH = '/api/widgets';
-const PORT = 8080;
-const SERVER_URL = `http://127.0.0.1:${PORT}${REQUEST_PATH}`;
-const PRODUCER_URL = `https://producer.example${REQUEST_PATH}`;
-const CONSUMER_ORIGIN = 'https://consumer.example';
-const INCOMING_TRACEPARENT =
-  '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01';
-const OPERATION_TRACEPARENT =
-  '00-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-bbbbbbbbbbbbbbbb-01';
-
-type HeaderMap = Record<string, any>;
-
-const createHarness = (
-  target: TransportTarget,
-  incomingHeaders: HeaderMap = {},
-) => {
-  const request = rs.fn(
-    (_requestPath: RequestInfo | URL, _init?: RequestInit) =>
-      Promise.resolve(new Response(JSON.stringify({ ok: true }))),
-  );
-
-  rs.spyOn(storage, 'useContext').mockReturnValue({ headers: incomingHeaders });
-  const requestFactory =
-    target === 'server' ? createServerClient() : createBrowserClient();
-
-  return { request, requestFactory };
-};
-
-describe('requestFactory outbound request contract', () => {
-  test('browser GET drops the caller body, canonicalizes accept and withholds the incoming traceparent', async () => {
-    const { request, requestFactory } = createHarness('browser', {
-      traceparent: INCOMING_TRACEPARENT,
-    });
-    requestFactory.configure({ request: request as unknown as typeof fetch });
-
-    const send = requestFactory.createRequest({
-      path: REQUEST_PATH,
-      method: 'GET',
-      port: PORT,
-    });
-    await send({
-      body: 'drop-me',
-      headers: { Accept: 'application/problem+json' },
-    });
-
-    const [url, init] = request.mock.calls[0];
-    expect(String(url)).toBe(REQUEST_PATH);
-    expect(init.method).toBe('GET');
-    expect(init.body).toBeUndefined();
-    const headers = init.headers as HeaderMap;
-    expect(headers.accept).toBe(ACCEPT_HEADER);
-    expect(
-      Object.keys(headers).filter(key => key.toLowerCase() === 'accept'),
-    ).toEqual(['accept']);
-    expect(headers.traceparent).toBeUndefined();
-  });
-
-  test('server POST keeps the caller body and propagates the incoming traceparent', async () => {
-    const { request, requestFactory } = createHarness('server', {
-      traceparent: INCOMING_TRACEPARENT,
-    });
-    requestFactory.configure({ request: request as unknown as typeof fetch });
-
-    const send = requestFactory.createRequest({
-      path: REQUEST_PATH,
-      method: 'POST',
-      port: PORT,
-    });
-    await send({ body: 'keep-me' });
-
-    const [url, init] = request.mock.calls[0];
-    expect(String(url)).toBe(SERVER_URL);
-    expect(init.method).toBe('POST');
-    expect(init.body).toBe('keep-me');
-    expect((init.headers as HeaderMap).traceparent).toBe(INCOMING_TRACEPARENT);
-  });
-
-  test('secured producer request emits the cross-origin envelope and operation context', async () => {
-    const requestId = 'producer-checkout';
-    const { request, requestFactory } = createHarness('server', {
-      origin: CONSUMER_ORIGIN,
-    });
-
-    requestFactory.configure({
-      request: request as unknown as typeof fetch,
-      requestId,
-      setDomain: () => 'https://producer.example',
-      requireEnvelope: true,
-      allowCrossOriginEnvelope: true,
-      operationContract: {
-        enabled: true,
-        requireSchemaHash: true,
-        requireOperationVersion: true,
-      },
-    });
-
-    const send = requestFactory.createRequest({
-      path: REQUEST_PATH,
-      method: 'POST',
-      port: PORT,
-      requestId,
-      operationContext: {
-        operationId: 'create-widget',
-        routePath: REQUEST_PATH,
-        method: 'POST',
-        schemaHash: 'sha256:create-widget',
-        operationVersion: 3,
-        traceparent: OPERATION_TRACEPARENT,
-      },
-    });
-    await send({ body: 'keep-me' });
-
-    const [url, init] = request.mock.calls[0];
-    expect(String(url)).toBe(PRODUCER_URL);
-    const headers = init.headers as HeaderMap;
-    expect(headers.traceparent).toBe(OPERATION_TRACEPARENT);
-    expect(headers[BFF_OPERATION_CONTEXT_HEADER]).toBe(
-      'producer-checkout:create-widget',
-    );
-    expect(JSON.parse(headers[BFF_ENVELOPE_HEADER])).toMatchObject({
-      requestId,
-      target: 'server',
-      sourceOrigin: CONSUMER_ORIGIN,
-      targetOrigin: 'https://producer.example',
-      traceId: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      spanId: 'bbbbbbbbbbbbbbbb',
-    });
-    expect(
-      JSON.parse(headers[BFF_OPERATION_CONTEXT_DETAIL_HEADER]),
-    ).toMatchObject({
-      operationId: 'producer-checkout:create-widget',
-      schemaHash: 'sha256:create-widget',
-      operationVersion: 3,
-    });
-  });
-
-  test('forwards only allowlisted and server-derived identity headers', async () => {
-    const requestId = 'producer-input-params-identity';
-    const { request, requestFactory } = createHarness('server', {
-      'x-tenant-id': 'tenant-server',
-      'x-subject-id': 'subject-server',
-      'x-forwarded-feature': 'feature-server',
-      'x-private-incoming': 'must-not-forward',
-    });
-
-    requestFactory.configure({
-      request: request as unknown as typeof fetch,
-      requestId,
-      allowedHeaders: ['x-forwarded-feature'],
-      operationContract: { enabled: false },
-      requireEnvelope: false,
-      setDomain: () => 'https://producer.example',
-    });
-
-    const send = requestFactory.createRequest({
-      path: REQUEST_PATH,
-      method: 'POST',
-      port: PORT,
-      httpMethodDecider: 'inputParams',
-      requestId,
-    });
-    await send('widget');
-
-    const headers = request.mock.calls[0][1]?.headers as HeaderMap;
-    expect(headers).toMatchObject({
-      'x-tenant-id': 'tenant-server',
-      'x-subject-id': 'subject-server',
-      'x-forwarded-feature': 'feature-server',
-    });
-    expect(headers['x-private-incoming']).toBeUndefined();
-  });
-
-  test('uploader sends the file as form data under the same header policy', async () => {
-    const requestId = 'producer-uploader-identity';
-    const { request, requestFactory } = createHarness('server', {
-      origin: CONSUMER_ORIGIN,
-      'x-tenant-id': 'tenant-server',
-      'x-private-incoming': 'must-not-forward',
-    });
-
-    requestFactory.configure({
-      request: request as unknown as typeof fetch,
-      requestId,
-      operationContract: { enabled: false },
-      requireEnvelope: false,
-      setDomain: () => 'https://producer.example',
-    });
-
-    const upload = requestFactory.createUploader({
-      path: REQUEST_PATH,
-      requestId,
-    });
-    await upload({
-      files: {
-        file: new File(['widget'], 'widget.txt', { type: 'text/plain' }),
-      },
-    });
-
-    const [, init] = request.mock.calls[0];
-    expect(init.method).toBe('POST');
-    expect(init.body).toBeInstanceOf(FormData);
-    const uploaded = (init.body as FormData).get('file') as File;
-    expect(uploaded.name).toBe('widget.txt');
-    expect(await uploaded.text()).toBe('widget');
-    const headers = init.headers as HeaderMap;
-    expect(headers['x-tenant-id']).toBe('tenant-server');
-    expect(headers['x-private-incoming']).toBeUndefined();
-  });
-
-  test('resolved headers replace caller and incoming values without injecting unlisted ones', async () => {
-    const resolveHeaders = rs.fn(() => ({
-      AUTHORIZATION: 'Bearer resolved',
-      'x-injected': 'must-not-forward',
-    }));
-    const { request, requestFactory } = createHarness('server', {
-      Authorization: 'Bearer incoming',
-    });
-
-    requestFactory.configure({
-      request: request as unknown as typeof fetch,
-      allowedHeaders: ['authorization'],
-      resolveHeaders,
-    });
-
-    const send = requestFactory.createRequest({
-      path: REQUEST_PATH,
-      method: 'GET',
-      port: PORT,
-    });
-    await send({ headers: { Authorization: 'Bearer caller' } });
-
-    expect(resolveHeaders).toHaveBeenCalledWith(
-      expect.objectContaining({
-        incomingHeaders: { authorization: 'Bearer incoming' },
-      }),
-    );
-    const headers = request.mock.calls[0][1]?.headers as HeaderMap;
-    expect(headers.authorization).toBe('Bearer resolved');
-    expect(headers['x-injected']).toBeUndefined();
-    expect(
-      Object.keys(headers).filter(key => key.toLowerCase() === 'authorization'),
-    ).toEqual(['authorization']);
-  });
-
-  test('reconfiguration drops an omitted header and envelope policy', async () => {
-    const resolveHeaders = rs.fn(() => ({ authorization: 'Bearer stale' }));
-    const { request, requestFactory } = createHarness('server', {
-      authorization: 'Bearer incoming',
-    });
-
-    requestFactory.configure({
-      request: request as unknown as typeof fetch,
-      allowedHeaders: ['authorization'],
-      resolveHeaders,
-      requireEnvelope: true,
-      identityBinding: {
-        enabled: true,
-        strict: false,
-        protectedHeaders: ['x-user-id'],
-        deriveHeaders: () => ({ 'x-user-id': 'stale-user' }),
-      },
-    });
-    requestFactory.configure({
-      request: request as unknown as typeof fetch,
-    });
-
-    const send = requestFactory.createRequest({
-      path: REQUEST_PATH,
-      method: 'GET',
-      port: PORT,
-    });
-    await send();
-
-    expect(resolveHeaders).not.toHaveBeenCalled();
-    expect(request.mock.calls[0][1]?.headers).toEqual({
-      accept: ACCEPT_HEADER,
-    });
-  });
-});

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

@@ -1,52 +0,0 @@
-import { parseTraceparent } from '@modern-js/runtime-extensions/request-context';
-
-describe('parseTraceparent', () => {
-  const traceId = '4bf92f3577b34da6a3ce929d0e0e4736';
-  const spanId = '00f067aa0ba902b7';
-
-  test.each([
-    ['01', true],
-    ['00', false],
-    ['03', true],
-    ['02', false],
-  ])('parses a valid traceparent with flags %s', (flags, sampled) => {
-    expect(parseTraceparent(`00-${traceId}-${spanId}-${flags}`)).toEqual({
-      traceId,
-      spanId,
-      sampled,
-    });
-  });
-
-  test('lowercases mixed-case ids and trims surrounding whitespace', () => {
-    expect(
-      parseTraceparent(
-        `  00-${traceId.toUpperCase()}-${spanId.toUpperCase()}-01  `,
-      ),
-    ).toEqual({
-      traceId,
-      spanId,
-      sampled: true,
-    });
-  });
-
-  test('rejects missing, empty, and malformed headers', () => {
-    expect(parseTraceparent(undefined)).toBeUndefined();
-    expect(parseTraceparent(null)).toBeUndefined();
-    expect(parseTraceparent('')).toBeUndefined();
-    expect(parseTraceparent('not-a-traceparent')).toBeUndefined();
-    expect(parseTraceparent(`00-${traceId}-${spanId}`)).toBeUndefined();
-    expect(parseTraceparent(`01-${traceId}-${spanId}-01`)).toBeUndefined();
-    expect(
-      parseTraceparent(`00-${traceId.slice(1)}-${spanId}-01`),
-    ).toBeUndefined();
-  });
-
-  test('rejects all-zero trace and span ids per the W3C spec', () => {
-    expect(
-      parseTraceparent(`00-${'0'.repeat(32)}-${spanId}-01`),
-    ).toBeUndefined();
-    expect(
-      parseTraceparent(`00-${traceId}-${'0'.repeat(16)}-01`),
-    ).toBeUndefined();
-  });
-});

package/tests/request-policy/transport-retry.test.ts

@@ -1,367 +0,0 @@
-import { executeWithResilience } from '../../src/request-policy/transport';
-
-const requestUrl = 'https://modern.test/api';
-const retryableStatusCodes = [408, 425, 429, 500, 502, 503, 504];
-const nonRetryableStatusCodes = [400, 401, 404, 418, 501];
-
-const flushMicrotasks = async () => {
-  await Promise.resolve();
-  await Promise.resolve();
-};
-
-const createNamedError = (name: string) => {
-  const error = new Error(name);
-  (error as any).name = name;
-  return error;
-};
-
-const createStatusError = (status: number) => {
-  const error = new Error(`status ${status}`);
-  (error as any).status = status;
-  return error;
-};
-
-const executeRetryRequest = ({
-  fetcher,
-  method = 'GET',
-  init = { method },
-  retry,
-  onDegraded,
-}: {
-  fetcher: (...args: any[]) => Promise<any>;
-  method?: string;
-  init?: Record<string, any>;
-  retry?: Record<string, any>;
-  onDegraded?: (event: any) => void;
-}) =>
-  executeWithResilience({
-    requestId: 'transport-retry-test',
-    target: 'browser',
-    method,
-    url: requestUrl,
-    init,
-    fetcher,
-    transport: {
-      retry,
-      onDegraded,
-    },
-  });
-
-describe('transport retry behavior', () => {
-  test.each([
-    'FetchError',
-  ])('retries %s up to the configured max then rejects', async errorName => {
-    rs.useFakeTimers();
-    const errors = [
-      createNamedError(errorName),
-      createNamedError(errorName),
-      createNamedError(errorName),
-    ];
-    let callCount = 0;
-    const fetcher = rs.fn(async () => {
-      const error = errors[callCount];
-      callCount += 1;
-      throw error;
-    });
-
-    const pending = executeRetryRequest({
-      fetcher,
-      retry: {
-        retries: 2,
-        baseDelayMs: 10,
-        maxDelayMs: 100,
-        jitterRatio: 0,
-      },
-    });
-    const observed = pending.catch(error => error);
-
-    try {
-      await flushMicrotasks();
-      expect(fetcher).toHaveBeenCalledTimes(1);
-
-      await rs.advanceTimersByTimeAsync(9);
-      expect(fetcher).toHaveBeenCalledTimes(1);
-      await rs.advanceTimersByTimeAsync(1);
-      await flushMicrotasks();
-      expect(fetcher).toHaveBeenCalledTimes(2);
-
-      await rs.advanceTimersByTimeAsync(19);
-      expect(fetcher).toHaveBeenCalledTimes(2);
-      await rs.advanceTimersByTimeAsync(1);
-      await flushMicrotasks();
-      expect(fetcher).toHaveBeenCalledTimes(3);
-      await expect(observed).resolves.toBe(errors[2]);
-    } finally {
-      await rs.advanceTimersByTimeAsync(1000);
-      await observed;
-      rs.useRealTimers();
-    }
-  });
-
-  test('should not retry caller-aborted requests', async () => {
-    rs.useFakeTimers();
-    const onDegraded = rs.fn();
-    const abortController = new AbortController();
-    abortController.abort();
-    const abortError = createNamedError('AbortError');
-    const fetcher = rs.fn(async (_url: string, init: RequestInit) => {
-      expect(init.signal).toBe(abortController.signal);
-      throw abortError;
-    });
-
-    const pending = executeRetryRequest({
-      fetcher,
-      init: {
-        method: 'GET',
-        signal: abortController.signal,
-      },
-      retry: {
-        retries: 2,
-        baseDelayMs: 1,
-        maxDelayMs: 1,
-        jitterRatio: 0,
-      },
-      onDegraded,
-    });
-    const observed = pending.catch(error => error);
-
-    try {
-      await flushMicrotasks();
-      expect(fetcher).toHaveBeenCalledTimes(1);
-      expect(onDegraded).not.toHaveBeenCalledWith(
-        expect.objectContaining({ reason: 'retry' }),
-      );
-      await expect(observed).resolves.toBe(abortError);
-    } finally {
-      await rs.advanceTimersByTimeAsync(5);
-      await observed;
-      rs.useRealTimers();
-    }
-  });
-
-  test('retries default retryable status codes after the backoff delay', async () => {
-    rs.useFakeTimers();
-
-    try {
-      const statusCode = retryableStatusCodes[0];
-      const retryableError = createStatusError(statusCode);
-      const response = { ok: true, status: 200 };
-      let callCount = 0;
-      const fetcher = rs.fn(async () => {
-        callCount += 1;
-        if (callCount === 1) {
-          throw retryableError;
-        }
-        return response;
-      });
-
-      const pending = executeRetryRequest({
-        fetcher,
-        retry: {
-          retries: 1,
-          baseDelayMs: 5,
-          maxDelayMs: 5,
-          jitterRatio: 0,
-        },
-      });
-
-      await flushMicrotasks();
-      expect(fetcher).toHaveBeenCalledTimes(1);
-      await rs.advanceTimersByTimeAsync(4);
-      expect(fetcher).toHaveBeenCalledTimes(1);
-      await rs.advanceTimersByTimeAsync(1);
-      await expect(pending).resolves.toBe(response);
-      expect(fetcher).toHaveBeenCalledTimes(2);
-    } finally {
-      await rs.advanceTimersByTimeAsync(1000);
-      rs.useRealTimers();
-    }
-  });
-
-  test('does not retry non-retryable status codes', async () => {
-    const statusCode = nonRetryableStatusCodes[0];
-    const error = createStatusError(statusCode);
-    const fetcher = rs.fn(async () => {
-      throw error;
-    });
-
-    await expect(
-      executeRetryRequest({
-        fetcher,
-        retry: {
-          retries: 2,
-          baseDelayMs: 1,
-          maxDelayMs: 1,
-          jitterRatio: 0,
-        },
-      }),
-    ).rejects.toBe(error);
-    expect(fetcher).toHaveBeenCalledTimes(1);
-  });
-
-  test('uses a custom shouldRetry predicate instead of default rules', async () => {
-    rs.useFakeTimers();
-    const retryableByPolicy = createStatusError(400);
-    const response = { ok: true, status: 200 };
-    const shouldRetry = rs.fn(() => true);
-    let callCount = 0;
-    const fetcher = rs.fn(async () => {
-      callCount += 1;
-      if (callCount === 1) {
-        throw retryableByPolicy;
-      }
-      return response;
-    });
-
-    const pending = executeRetryRequest({
-      fetcher,
-      method: 'POST',
-      init: { method: 'POST' },
-      retry: {
-        retries: 1,
-        baseDelayMs: 7,
-        maxDelayMs: 7,
-        jitterRatio: 0,
-        shouldRetry,
-      },
-    });
-
-    try {
-      await flushMicrotasks();
-      expect(fetcher).toHaveBeenCalledTimes(1);
-      expect(shouldRetry).toHaveBeenCalledWith(
-        expect.objectContaining({
-          attempt: 1,
-          error: retryableByPolicy,
-          maxAttempts: 2,
-          method: 'POST',
-          statusCode: 400,
-        }),
-      );
-
-      await rs.advanceTimersByTimeAsync(6);
-      expect(fetcher).toHaveBeenCalledTimes(1);
-      await rs.advanceTimersByTimeAsync(1);
-      await expect(pending).resolves.toBe(response);
-      expect(fetcher).toHaveBeenCalledTimes(2);
-    } finally {
-      await rs.advanceTimersByTimeAsync(1000);
-      rs.useRealTimers();
-    }
-  });
-
-  test('does not retry non-idempotent methods by default', async () => {
-    const error = createNamedError('FetchError');
-    const fetcher = rs.fn(async () => {
-      throw error;
-    });
-
-    await expect(
-      executeRetryRequest({
-        fetcher,
-        method: 'POST',
-        init: { method: 'POST' },
-        retry: {
-          retries: 2,
-          baseDelayMs: 1,
-          maxDelayMs: 1,
-          jitterRatio: 0,
-        },
-      }),
-    ).rejects.toBe(error);
-    expect(fetcher).toHaveBeenCalledTimes(1);
-  });
-
-  test('timeout aborts the in-flight request when a caller signal is present', async () => {
-    rs.useFakeTimers();
-    const callerController = new AbortController();
-    const onDegraded = rs.fn();
-    let inFlightSignal: AbortSignal | undefined;
-    const fetcher = rs.fn((_url: string, init: RequestInit) => {
-      inFlightSignal = init.signal || undefined;
-      return new Promise((_, reject) => {
-        init.signal?.addEventListener('abort', () => {
-          reject(createNamedError('AbortError'));
-        });
-      });
-    });
-
-    const pending = executeWithResilience({
-      requestId: 'transport-timeout-with-caller-signal',
-      target: 'browser',
-      method: 'GET',
-      url: requestUrl,
-      init: {
-        method: 'GET',
-        signal: callerController.signal,
-      },
-      fetcher,
-      transport: {
-        timeoutMs: 25,
-        onDegraded,
-      },
-    });
-    const observed = pending.catch(error => error);
-
-    try {
-      await flushMicrotasks();
-      expect(inFlightSignal?.aborted).toBe(false);
-      await rs.advanceTimersByTimeAsync(25);
-
-      await expect(observed).resolves.toMatchObject({ name: 'TimeoutError' });
-      expect(inFlightSignal?.aborted).toBe(true);
-      expect(callerController.signal.aborted).toBe(false);
-      expect(onDegraded).toHaveBeenCalledWith(
-        expect.objectContaining({ reason: 'timeout', timeoutMs: 25 }),
-      );
-    } finally {
-      await rs.advanceTimersByTimeAsync(1000);
-      await observed;
-      rs.useRealTimers();
-    }
-  });
-
-  test('caller abort still cancels a request that has a timeout', async () => {
-    rs.useFakeTimers();
-    const callerController = new AbortController();
-    const onDegraded = rs.fn();
-    let inFlightSignal: AbortSignal | undefined;
-    const abortError = createNamedError('AbortError');
-    const fetcher = rs.fn((_url: string, init: RequestInit) => {
-      inFlightSignal = init.signal || undefined;
-      return new Promise((_, reject) => {
-        init.signal?.addEventListener('abort', () => reject(abortError));
-      });
-    });
-
-    const pending = executeWithResilience({
-      requestId: 'transport-caller-abort-with-timeout',
-      target: 'browser',
-      method: 'GET',
-      url: requestUrl,
-      init: {
-        method: 'GET',
-        signal: callerController.signal,
-      },
-      fetcher,
-      transport: {
-        timeoutMs: 25,
-        onDegraded,
-      },
-    });
-    const observed = pending.catch(error => error);
-
-    try {
-      await flushMicrotasks();
-      callerController.abort();
-
-      await expect(observed).resolves.toBe(abortError);
-      expect(inFlightSignal?.aborted).toBe(true);
-      expect(onDegraded).not.toHaveBeenCalled();
-    } finally {
-      await rs.advanceTimersByTimeAsync(1000);
-      await observed;
-      rs.useRealTimers();
-    }
-  });
-});