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

package/tests/rendererHead.test.ts

@@ -1,187 +0,0 @@
-import { PassThrough, Readable } from 'node:stream';
-import {
-  abortHeadRender,
-  beginHeadRender,
-  collectHeadRecord,
-  completeHeadRender,
-  createHeadChunkProcessor,
-} from '../src';
-import { createNodeHeadMarkerStripper, pipeNodeHeadStream } from '../src/node';
-
-const marker = (props: Record<string, string>) =>
-  `<template data-modern-helmet="${props['data-modern-helmet']}"></template>`;
-
-describe('renderer head transactions', () => {
-  it('commits only markers observed in completed output', () => {
-    const context = {};
-    let published: string[] = [];
-    beginHeadRender(context);
-    const committed = collectHeadRecord(
-      context,
-      () => 'committed',
-      records => {
-        published = records;
-      },
-    )!;
-    collectHeadRecord(
-      context,
-      () => 'abandoned',
-      records => {
-        published = records;
-      },
-    );
-
-    expect(completeHeadRender(context, `a${marker(committed)}b`)).toBe('ab');
-    expect(published).toEqual(['committed']);
-  });
-
-  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);
-    const sampleProps = collectHeadRecord(
-      sampleContext,
-      () => 'head',
-      () => {},
-    )!;
-    const sampleHtml = `č${marker(sampleProps)}尾`;
-
-    for (let split = 1; split < sampleHtml.length; split += 1) {
-      const context = {};
-      beginHeadRender(context);
-      const props = collectHeadRecord(
-        context,
-        () => 'head',
-        () => {},
-      )!;
-      const html = `č${marker(props)}尾`;
-      const processor = createHeadChunkProcessor(context);
-      expect(
-        processor.push(html.slice(0, split)) +
-          processor.finish(html.slice(split)),
-      ).toBe('č尾');
-    }
-  });
-
-  it('clears the previous snapshot while rendering and restores it on abort', () => {
-    const context = {};
-    let published: string[] = [];
-    const publish = (records: string[]) => {
-      published = records;
-    };
-
-    beginHeadRender(context);
-    const previous = collectHeadRecord(context, () => 'previous', publish)!;
-    completeHeadRender(context, marker(previous));
-    expect(published).toEqual(['previous']);
-
-    beginHeadRender(context);
-    expect(published).toEqual([]);
-    collectHeadRecord(context, () => 'provisional', publish);
-    abortHeadRender(context);
-    expect(published).toEqual(['previous']);
-  });
-
-  it('strips split markers from a Node stream', async () => {
-    const context = {};
-    let published: string[] = [];
-    beginHeadRender(context);
-    const props = collectHeadRecord(
-      context,
-      () => 'node',
-      records => {
-        published = records;
-      },
-    )!;
-    const html = `č${marker(props)}尾`;
-    const encoded = Buffer.from(html);
-    const stripper = createNodeHeadMarkerStripper(context);
-    const output = new Promise<string>((resolve, reject) => {
-      let rendered = '';
-      stripper.setEncoding('utf8');
-      stripper.on('data', chunk => {
-        rendered += chunk;
-      });
-      stripper.on('end', () => resolve(rendered));
-      stripper.on('error', reject);
-    });
-    stripper.write(encoded.subarray(0, 1));
-    stripper.write(encoded.subarray(1, 17));
-    stripper.end(encoded.subarray(17));
-
-    await expect(output).resolves.toBe('č尾');
-    expect(published).toEqual(['node']);
-  });
-
-  it('injects one missing terminal marker without truncating multichunk UTF-8', async () => {
-    const context = {};
-    const terminalMarker = '<!-- shell stream end -->';
-    const prefix = Buffer.from('x'.repeat(9 * 1024));
-    const unicodeTail = Buffer.from('č尾');
-    const input = Buffer.concat([prefix, unicodeTail]);
-    beginHeadRender(context);
-    const stripper = createNodeHeadMarkerStripper(context, terminalMarker);
-    const output = new Promise<string>((resolve, reject) => {
-      let rendered = '';
-      stripper.setEncoding('utf8');
-      stripper.on('data', chunk => {
-        rendered += chunk;
-      });
-      stripper.on('end', () => resolve(rendered));
-      stripper.on('error', reject);
-    });
-    stripper.write(input.subarray(0, prefix.length + 1));
-    stripper.write(input.subarray(prefix.length + 1, prefix.length + 3));
-    stripper.end(input.subarray(prefix.length + 3));
-
-    await expect(output).resolves.toBe(
-      `${input.toString('utf8')}${terminalMarker}`,
-    );
-  });
-
-  it('does not duplicate a split terminal marker or corrupt its tail', async () => {
-    const context = {};
-    const terminalMarker = '<!-- shell stream end -->';
-    const input = Buffer.from(`shell${terminalMarker}č尾`);
-    const markerOffset = Buffer.byteLength('shell') + 7;
-    beginHeadRender(context);
-    const stripper = createNodeHeadMarkerStripper(context, terminalMarker);
-    const output = new Promise<string>((resolve, reject) => {
-      let rendered = '';
-      stripper.setEncoding('utf8');
-      stripper.on('data', chunk => {
-        rendered += chunk;
-      });
-      stripper.on('end', () => resolve(rendered));
-      stripper.on('error', reject);
-    });
-    stripper.write(input.subarray(0, markerOffset));
-    stripper.write(input.subarray(markerOffset, input.length - 1));
-    stripper.end(input.subarray(input.length - 1));
-
-    await expect(output).resolves.toBe(input.toString('utf8'));
-  });
-
-  it('rejects the destination and reports a source 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: {}, onError });
-
-    source.destroy(new Error('source failed'));
-
-    await expect(output).rejects.toThrow('source failed');
-    expect(onError).toHaveBeenCalledTimes(1);
-  });
-});

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

@@ -1,108 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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();
-  });
-});