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

package/tests/rendererHead.test.ts

@@ -5,14 +5,10 @@ import {
   collectHeadRecord,
   completeHeadRender,
   createHeadChunkProcessor,
-  createWebHeadMarkerStripper,
+  LATE_HEAD_MESSAGE,
   publishHeadRender,
 } from '../src';
-import {
-  createNodeHeadMarkerStripper,
-  createOnceErrorReporter,
-  pipeNodeHeadStream,
-} from '../src/node';
+import { createNodeHeadMarkerStripper, pipeNodeHeadStream } from '../src/node';
 
 const marker = (props: Record<string, string>) =>
   `<template data-modern-helmet="${props['data-modern-helmet']}"></template>`;
@@ -21,7 +17,7 @@ describe('renderer head transactions', () => {
   it('commits only markers observed in completed output', () => {
     const context = {};
     let published: string[] = [];
-    beginHeadRender(context);
+    beginHeadRender(context, () => {});
     const committed = collectHeadRecord(
       context,
       () => 'committed',
@@ -41,28 +37,59 @@ describe('renderer head transactions', () => {
     expect(published).toEqual(['committed']);
   });
 
-  it('preserves user templates that are not current transaction markers', () => {
+  it('reports head records whose markers commit after the seal', () => {
     const context = {};
-    beginHeadRender(context);
-    const userTemplate =
-      '<template data-modern-helmet="h00000000-0000-0000-0000-000000000000000000000000"></template>';
+    const reports: string[] = [];
+    let published: string[] = [];
+    const publish = (records: string[]) => {
+      published = records;
+    };
+    beginHeadRender(context, message => reports.push(message));
+    const shell = collectHeadRecord(context, () => 'shell', publish)!;
+    // A boundary rendered before the seal but flushed after it.
+    const flushedLate = collectHeadRecord(context, () => 'flushed', publish)!;
+    const processor = createHeadChunkProcessor(context);
+    expect(processor.push(`a${marker(shell)}`)).toBe('a');
+    publishHeadRender(context);
+    // A boundary rendered after the seal.
+    const renderedLate = collectHeadRecord(context, () => 'rendered', publish)!;
+    // A retry that renders a Helmet and then suspends again never commits.
+    collectHeadRecord(context, () => 'discarded', publish);
+    expect(reports).toEqual([]);
 
-    expect(completeHeadRender(context, userTemplate)).toBe(userTemplate);
+    expect(processor.push(`b${marker(flushedLate)}${marker(shell)}`)).toBe('b');
+    expect(processor.finish(`c${marker(renderedLate)}`)).toBe('c');
+
+    expect(published).toEqual(['shell']);
+    expect(reports).toEqual([LATE_HEAD_MESSAGE]);
   });
 
-  it('does not retain ordinary streaming content', () => {
+  it('does not report a late Helmet whose boundary never commits', () => {
     const context = {};
-    beginHeadRender(context);
-    const processor = createHeadChunkProcessor(context);
-    const content = 'x'.repeat(128 * 1024);
+    const reports: string[] = [];
+    beginHeadRender(context, message => reports.push(message));
+    publishHeadRender(context);
+    collectHeadRecord(
+      context,
+      () => 'discarded',
+      () => {},
+    );
+    expect(completeHeadRender(context, 'done')).toBe('done');
+    expect(reports).toEqual([]);
+  });
 
-    expect(processor.push(content)).toBe(content);
-    expect(processor.finish()).toBe('');
+  it('preserves user templates that are not current transaction markers', () => {
+    const context = {};
+    beginHeadRender(context, () => {});
+    const userTemplate =
+      '<template data-modern-helmet="h00000000-0000-0000-0000-000000000000000000000000"></template>';
+
+    expect(completeHeadRender(context, userTemplate)).toBe(userTemplate);
   });
 
   it('strips markers split across chunks without corrupting unicode', () => {
     const sampleContext = {};
-    beginHeadRender(sampleContext);
+    beginHeadRender(sampleContext, () => {});
     const sampleProps = collectHeadRecord(
       sampleContext,
       () => 'head',
@@ -72,7 +99,7 @@ describe('renderer head transactions', () => {
 
     for (let split = 1; split < sampleHtml.length; split += 1) {
       const context = {};
-      beginHeadRender(context);
+      beginHeadRender(context, () => {});
       const props = collectHeadRecord(
         context,
         () => 'head',
@@ -87,41 +114,6 @@ describe('renderer head transactions', () => {
     }
   });
 
-  it('freezes the published shell and ignores late records', () => {
-    const context = {};
-    let published: string[] = [];
-    beginHeadRender(context);
-    const shell = collectHeadRecord(
-      context,
-      () => 'shell',
-      records => {
-        published = records;
-      },
-    )!;
-    const late = collectHeadRecord(
-      context,
-      () => 'late',
-      records => {
-        published = records;
-      },
-    )!;
-    const processor = createHeadChunkProcessor(context);
-    expect(processor.push(marker(shell))).toBe('');
-    publishHeadRender(context);
-
-    expect(
-      collectHeadRecord(
-        context,
-        () => 'late',
-        records => {
-          published = records;
-        },
-      ),
-    ).toBeNull();
-    expect(processor.finish(marker(late))).toBe('');
-    expect(published).toEqual(['shell']);
-  });
-
   it('clears the previous snapshot while rendering and restores it on abort', () => {
     const context = {};
     let published: string[] = [];
@@ -129,52 +121,22 @@ describe('renderer head transactions', () => {
       published = records;
     };
 
-    beginHeadRender(context);
+    beginHeadRender(context, () => {});
     const previous = collectHeadRecord(context, () => 'previous', publish)!;
     completeHeadRender(context, marker(previous));
     expect(published).toEqual(['previous']);
 
-    beginHeadRender(context);
+    beginHeadRender(context, () => {});
     expect(published).toEqual([]);
     collectHeadRecord(context, () => 'provisional', publish);
     abortHeadRender(context);
     expect(published).toEqual(['previous']);
   });
 
-  it('strips split markers from a web byte stream', async () => {
-    const context = {};
-    let published: string[] = [];
-    beginHeadRender(context);
-    const props = collectHeadRecord(
-      context,
-      () => 'web',
-      records => {
-        published = records;
-      },
-    )!;
-    const html = `č${marker(props)}尾`;
-    const encoder = new TextEncoder();
-    const encoded = encoder.encode(html);
-    const source = new ReadableStream<Uint8Array>({
-      start(controller) {
-        controller.enqueue(encoded.slice(0, 1));
-        controller.enqueue(encoded.slice(1, 17));
-        controller.enqueue(encoded.slice(17));
-        controller.close();
-      },
-    });
-
-    const output = await new Response(
-      source.pipeThrough(createWebHeadMarkerStripper(context)),
-    ).text();
-    expect(output).toBe('č尾');
-    expect(published).toEqual(['web']);
-  });
-
   it('strips split markers from a Node stream', async () => {
     const context = {};
     let published: string[] = [];
-    beginHeadRender(context);
+    beginHeadRender(context, () => {});
     const props = collectHeadRecord(
       context,
       () => 'node',
@@ -208,7 +170,7 @@ describe('renderer head transactions', () => {
     const prefix = Buffer.from('x'.repeat(9 * 1024));
     const unicodeTail = Buffer.from('č尾');
     const input = Buffer.concat([prefix, unicodeTail]);
-    beginHeadRender(context);
+    beginHeadRender(context, () => {});
     const stripper = createNodeHeadMarkerStripper(context, terminalMarker);
     const output = new Promise<string>((resolve, reject) => {
       let rendered = '';
@@ -233,7 +195,7 @@ describe('renderer head transactions', () => {
     const terminalMarker = '<!-- shell stream end -->';
     const input = Buffer.from(`shell${terminalMarker}č尾`);
     const markerOffset = Buffer.byteLength('shell') + 7;
-    beginHeadRender(context);
+    beginHeadRender(context, () => {});
     const stripper = createNodeHeadMarkerStripper(context, terminalMarker);
     const output = new Promise<string>((resolve, reject) => {
       let rendered = '';
@@ -265,35 +227,4 @@ describe('renderer head transactions', () => {
     await expect(output).rejects.toThrow('source failed');
     expect(onError).toHaveBeenCalledTimes(1);
   });
-
-  it('rejects the destination and reports a stripper error exactly once', async () => {
-    const source = new PassThrough();
-    const destination = new PassThrough();
-    const output = new Response(
-      Readable.toWeb(destination) as ReadableStream<Uint8Array>,
-    ).text();
-    const onError = rstest.fn();
-    pipeNodeHeadStream({
-      source,
-      destination,
-      context: Object.freeze({}),
-      onError,
-    });
-
-    source.end('trigger frozen-context failure');
-
-    await expect(output).rejects.toThrow('object is not extensible');
-    expect(onError).toHaveBeenCalledTimes(1);
-  });
-
-  it('reports a shared render and stream failure only once', () => {
-    const onError = rstest.fn();
-    const reportError = createOnceErrorReporter(onError);
-    const failure = new Error('shared failure');
-
-    reportError(failure);
-    reportError(failure);
-
-    expect(onError).toHaveBeenCalledExactlyOnceWith(failure);
-  });
 });

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

@@ -0,0 +1,108 @@
+import {
+  configure,
+  createRequest,
+} from '@modern-js/runtime-extensions/request-policy/client';
+import nock from 'nock';
+
+describe('configure', () => {
+  const path = '/api';
+  const method = 'GET';
+  const response = {
+    code: 200,
+    data: {
+      message: 'hello Modernjs',
+    },
+  };
+
+  test('should allow explicit cross-origin policy and attach envelope header', async () => {
+    const producer = 'producer-browser-policy';
+    const producerUrl = 'https://producer.internal';
+    const previousEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'production';
+
+    try {
+      nock(producerUrl).get(path).reply(200, response);
+      const customRequest = rs.fn(
+        (requestPath: RequestInfo, init?: RequestInit) =>
+          fetch(requestPath, init),
+      );
+
+      configure({
+        request: customRequest,
+        requestId: producer,
+        operationContract: {
+          enabled: false,
+        },
+        setDomain: () => producerUrl,
+        allowCrossOriginEnvelope: true,
+      });
+
+      const request = createRequest(
+        path,
+        method,
+        8080,
+        undefined,
+        undefined,
+        producer,
+      );
+      const res = await request();
+
+      const headers = customRequest.mock.calls[0][1].headers as Record<
+        string,
+        string
+      >;
+      const envelope = JSON.parse(headers['x-modernjs-bff-envelope']);
+      expect(envelope.requestId).toBe(producer);
+      expect(envelope.target).toBe('browser');
+      expect(res instanceof Response).toBe(true);
+    } finally {
+      process.env.NODE_ENV = previousEnv;
+    }
+  });
+
+  test('should not require process to exist in browser runtime', async () => {
+    const previousProcess = globalThis.process;
+    const customRequest = rs.fn(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            code: 200,
+            data: {
+              message: 'ok',
+            },
+          }),
+        ),
+      ),
+    );
+
+    try {
+      Object.defineProperty(globalThis, 'process', {
+        configurable: true,
+        value: undefined,
+      });
+      configure({
+        request: customRequest,
+      });
+
+      const request = createRequest({
+        path,
+        method,
+        port: 8080,
+      });
+      const response = await request();
+      const data = await response.json();
+
+      expect(data).toStrictEqual({
+        code: 200,
+        data: {
+          message: 'ok',
+        },
+      });
+    } finally {
+      Object.defineProperty(globalThis, 'process', {
+        configurable: true,
+        value: previousProcess,
+      });
+    }
+  });
+});

package/tests/request-policy/client-isolation.test.ts

@@ -0,0 +1,109 @@
+import { createClient as createNativeClient } from '@modern-js/create-request/server';
+import * as server from '@modern-js/runtime-extensions/request-policy/server';
+
+const options = {
+  path: '/api',
+  method: 'GET',
+  port: 8080,
+  requestId: 'shared-producer',
+};
+
+describe('isolated producer policy clients', () => {
+  test('does not share producer initialization or request configuration between instances', async () => {
+    const first = server.createClient();
+    const second = server.createClient();
+    const firstRequest = rs.fn(async () => new Response('first'));
+    const secondRequest = rs.fn(async () => new Response('second'));
+    first.configure({
+      requestId: options.requestId,
+      request: firstRequest,
+      setDomain: () => 'https://first.example',
+      operationContract: { enabled: false },
+    });
+    expect(() => second.createRequest(options)()).toThrow(
+      server.ProducerClientNotInitializedError,
+    );
+    second.configure({
+      requestId: options.requestId,
+      request: secondRequest,
+      setDomain: () => 'https://second.example',
+      operationContract: { enabled: false },
+    });
+    expect(await (await first.createRequest(options)()).text()).toBe('first');
+    expect(await (await second.createRequest(options)()).text()).toBe('second');
+    expect(firstRequest).toHaveBeenCalledWith(
+      'https://first.example/api',
+      expect.any(Object),
+    );
+    expect(secondRequest).toHaveBeenCalledWith(
+      'https://second.example/api',
+      expect.any(Object),
+    );
+  });
+
+  test('does not initialize producer policy by configuring a separate native client', () => {
+    createNativeClient().configure({
+      requestId: options.requestId,
+      request: rs.fn(),
+    });
+    const producer = server.createClient();
+    expect(() => producer.createRequest(options)()).toThrow(
+      server.ProducerClientNotInitializedError,
+    );
+  });
+
+  test('retains secured behavior for an explicitly empty requestId', () => {
+    const client = server.createClient();
+    const request = rs.fn();
+    client.configure({
+      requestId: '',
+      request,
+      setDomain: () => 'https://producer.example',
+    });
+    expect(() => client.createRequest({ ...options, requestId: '' })()).toThrow(
+      server.OperationContractViolationError,
+    );
+    expect(request).not.toHaveBeenCalled();
+  });
+
+  test('calls setDomain once after interceptor and keeps native and policy state on rejection', async () => {
+    const client = server.createClient();
+    const order: string[] = [];
+    const request = rs.fn(async () => new Response('original'));
+    const setDomain = rs.fn(() => {
+      order.push('domain');
+      return 'https://original.example';
+    });
+    client.configure({
+      requestId: options.requestId,
+      interceptor: () => {
+        order.push('interceptor');
+        return request;
+      },
+      setDomain,
+      requireEnvelope: false,
+      operationContract: { enabled: false },
+    });
+    const replacement = rs.fn();
+    expect(() =>
+      client.configure({
+        requestId: options.requestId,
+        request: replacement,
+        setDomain: () => '',
+      }),
+    ).toThrow(server.ProducerDomainNotConfiguredError);
+    const response = await client.createRequest(options)();
+    expect(await response.text()).toBe('original');
+    expect(order).toEqual(['interceptor', 'domain']);
+    expect(setDomain).toHaveBeenCalledTimes(1);
+    expect(request).toHaveBeenCalledWith(
+      'https://original.example/api',
+      expect.objectContaining({
+        headers: expect.not.objectContaining({
+          'x-modernjs-bff-envelope': expect.anything(),
+        }),
+      }),
+    );
+    expect(replacement).not.toHaveBeenCalled();
+  });
+});