[Bug] overrideGlobalObjects: true breaks openapi-fetch middleware instanceof checks #321

import { Hono } from 'hono';
import { serve } from '@hono/node-server';
import createClient, { type Middleware } from 'openapi-fetch';

type Paths = {
  '/api/v1/data': {
    get: {
      responses: { 200: { content: { 'application/json': { ok: boolean } } } };
    };
  };
};

const apiClient = createClient<Paths>({ baseUrl: 'http://localhost:19100' });

// Standard logging middleware — returns the same request/response unmodified
const logMiddleware: Middleware = {
  async onRequest({ request }) {
    console.log(`--> ${request.method} ${request.url}`);
    return request;
  },
  async onResponse({ response }) {
    console.log(`<-- ${response.status} ${response.url}`);
    return response;
  },
};
apiClient.use(logMiddleware);

const app = new Hono();
app.get('/proxy', async (c) => {
  const { data, error } = await apiClient.GET('/api/v1/data');
  if (error) return c.json({ error }, 502);
  return c.json(data);
});

// overrideGlobalObjects defaults to true — this is the trigger
serve({ fetch: app.fetch, port: 3000 });

import { describe, test, expect, beforeAll, afterAll, afterEach } from 'bun:test';
import { Hono } from 'hono';
import { serve, type ServerType } from '@hono/node-server';
import createClient, { type Middleware } from 'openapi-fetch';

type Paths = {
  '/api/v1/secrets': {
    get: {
      responses: {
        200: {
          content: { 'application/json': { data: Record<string, string> } };
        };
      };
    };
  };
};

const MOCK_PORT = 19_100;
const CLIENT_PORT = 19_101;
const OriginalRequest = globalThis.Request;
const OriginalResponse = globalThis.Response;

const middleware: Middleware = {
  async onRequest({ request }) {
    console.log(`--> ${request.method} ${request.url}`);
    return request;
  },
  async onResponse({ response }) {
    console.log(`<-- ${response.status} ${response.url}`);
    return response;
  },
};

function buildMockApp() {
  const app = new Hono();
  app.get('/api/v1/secrets', (c) =>
    c.json({ data: { apiKey: 'sk-live-XXX', dbPassword: 'secret' } }),
  );
  return app;
}

describe('overrideGlobalObjects breaks instanceof checks', () => {
  let mockServer: ReturnType<typeof Bun.serve>;
  let clientServer: ServerType | undefined;

  beforeAll(() => {
    mockServer = Bun.serve({ port: MOCK_PORT, fetch: buildMockApp().fetch });
  });
  afterEach(() => {
    clientServer?.close();
    clientServer = undefined;
    globalThis.Request = OriginalRequest;
    globalThis.Response = OriginalResponse;
  });
  afterAll(() => { mockServer?.stop(); });

  test('overrideGlobalObjects: true → middleware instanceof check fails', async () => {
    const apiClient = createClient<Paths>({ baseUrl: `http://localhost:${MOCK_PORT}` });
    apiClient.use(middleware);

    const app = new Hono();
    app.get('/fetch', async (c) => {
      try {
        const { data, error } = await apiClient.GET('/api/v1/secrets');
        if (error) return c.json({ error: 'upstream' }, 502);
        return c.json(data);
      } catch (err) {
        return c.json({ error: 'middleware_failure', message: String(err) }, 500);
      }
    });

    clientServer = serve({ fetch: app.fetch, port: CLIENT_PORT }); // default: overrideGlobalObjects true
    await Bun.sleep(200);

    expect(globalThis.Response).not.toBe(OriginalResponse); // confirms override

    const res = await fetch(`http://localhost:${CLIENT_PORT}/fetch`);
    const body = await res.json() as { error: string; message: string };
    expect(res.status).toBe(500);
    expect(body.message).toContain('onResponse: must return new Response() when modifying the response');
  });

  test('overrideGlobalObjects: false → same middleware works fine', async () => {
    const apiClient = createClient<Paths>({ baseUrl: `http://localhost:${MOCK_PORT}` });
    apiClient.use(middleware);

    const app = new Hono();
    app.get('/fetch', async (c) => {
      const { data, error } = await apiClient.GET('/api/v1/secrets');
      if (error) return c.json({ error: 'upstream' }, 502);
      return c.json(data);
    });

    clientServer = serve({ fetch: app.fetch, port: CLIENT_PORT, overrideGlobalObjects: false });
    await Bun.sleep(200);

    const res = await fetch(`http://localhost:${CLIENT_PORT}/fetch`);
    const body = await res.json() as { data: Record<string, string> };
    expect(res.status).toBe(200);
    expect(body.data.apiKey).toBe('sk-live-XXX');
  });
});