@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/graphql/runtime-remaining.test.js

@@ -0,0 +1,477 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const isSsrfTargetMock = vi.fn(async () => false);
+vi.mock('@src/server/domains/network/replay', () => ({
+    isSsrfTarget: vi.fn(async () => isSsrfTargetMock()),
+}));
+import { GraphQLToolHandlersIntrospection } from '../../../../src/server/domains/graphql/handlers.impl.core.runtime.introspection.js';
+import { GraphQLToolHandlersRuntime } from '../../../../src/server/domains/graphql/handlers.impl.core.runtime.replay.js';
+import { GraphQLToolHandlersScriptReplace } from '../../../../src/server/domains/graphql/handlers.impl.core.runtime.script-replace.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('GraphQLToolHandlersIntrospection - evaluate callback', () => {
+    const page = {
+        evaluate: vi.fn(),
+        evaluateOnNewDocument: vi.fn(),
+        setRequestInterception: vi.fn(),
+        on: vi.fn(),
+    };
+    const collector = {
+        getActivePage: vi.fn(async () => page),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        isSsrfTargetMock.mockResolvedValue(false);
+        handlers = new GraphQLToolHandlersIntrospection(collector);
+    });
+    it('executes the introspection browser callback with successful fetch', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                text: async () => '{"data":{"__schema":{"types":[]}}}',
+                headers: new Map([['content-type', 'application/json']]),
+            };
+            mockResponse.headers = {
+                forEach: (cb) => {
+                    cb('application/json', 'content-type');
+                },
+            };
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+                return await fn(input);
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlIntrospect({
+            endpoint: 'https://example.com/graphql',
+        }));
+        expect(body.success).toBe(true);
+        expect(body.status).toBe(200);
+    });
+    it('executes callback with non-JSON response', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                text: async () => 'not valid json',
+                headers: {
+                    forEach: (cb) => {
+                        cb('text/plain', 'content-type');
+                    },
+                },
+            };
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+                return await fn(input);
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlIntrospect({
+            endpoint: 'https://example.com/graphql',
+        }));
+        expect(body.success).toBe(true);
+        expect(body.schema).toBe('not valid json');
+    });
+    it('executes callback when fetch throws', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn().mockRejectedValue(new Error('Network failure'));
+                return await fn(input);
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlIntrospect({
+            endpoint: 'https://example.com/graphql',
+        }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('Network failure');
+    });
+    it('executes callback when fetch throws non-Error', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn().mockRejectedValue('string error');
+                return await fn(input);
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlIntrospect({
+            endpoint: 'https://example.com/graphql',
+        }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('string error');
+    });
+    it('merges custom headers with default content-type', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            let capturedHeaders;
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                text: async () => '{}',
+                headers: {
+                    forEach: (cb) => {
+                        cb('application/json', 'content-type');
+                    },
+                },
+            };
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn(async (_url, opts) => {
+                    capturedHeaders = opts.headers;
+                    return mockResponse;
+                });
+                const result = await fn(input);
+                expect(capturedHeaders).toBeDefined();
+                expect(capturedHeaders['x-custom']).toBe('test');
+                expect(capturedHeaders['content-type']).toBe('application/json');
+                return result;
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlIntrospect({
+            endpoint: 'https://example.com/graphql',
+            headers: { 'x-custom': 'test' },
+        }));
+        expect(body.success).toBe(true);
+    });
+});
+describe('GraphQLToolHandlersRuntime (replay) - evaluate callback', () => {
+    const page = {
+        evaluate: vi.fn(),
+        evaluateOnNewDocument: vi.fn(),
+        setRequestInterception: vi.fn(),
+        on: vi.fn(),
+    };
+    const collector = {
+        getActivePage: vi.fn(async () => page),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        isSsrfTargetMock.mockResolvedValue(false);
+        handlers = new GraphQLToolHandlersRuntime(collector);
+    });
+    it('executes the replay browser callback with successful fetch', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                text: async () => '{"data":{"replay":true}}',
+                headers: {
+                    forEach: (cb) => {
+                        cb('application/json', 'content-type');
+                    },
+                },
+            };
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+                return await fn(input);
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlReplay({
+            endpoint: 'https://example.com/graphql',
+            query: 'query Test { test }',
+        }));
+        expect(body.success).toBe(true);
+        expect(body.status).toBe(200);
+        expect(body.response).toEqual({ data: { replay: true } });
+    });
+    it('executes callback when response is not JSON', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                text: async () => 'plain text response',
+                headers: {
+                    forEach: (_cb) => { },
+                },
+            };
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+                return await fn(input);
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlReplay({
+            endpoint: 'https://example.com/graphql',
+            query: 'query Test { test }',
+        }));
+        expect(body.success).toBe(true);
+        expect(body.responseFormat).toBe('text');
+    });
+    it('executes callback when fetch throws', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn().mockRejectedValue(new Error('Replay network error'));
+                return await fn(input);
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlReplay({
+            endpoint: 'https://example.com/graphql',
+            query: 'query Test { test }',
+        }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('Replay network error');
+    });
+    it('passes variables and operationName through to fetch body', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            let capturedBody;
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                text: async () => '{}',
+                headers: {
+                    forEach: (_cb) => { },
+                },
+            };
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn(async (_url, opts) => {
+                    capturedBody = opts.body;
+                    return mockResponse;
+                });
+                const result = await fn(input);
+                const parsedBody = JSON.parse(capturedBody);
+                expect(parsedBody.query).toContain('GetUser');
+                expect(parsedBody.variables).toEqual({ id: '42' });
+                expect(parsedBody.operationName).toBe('GetUser');
+                return result;
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        await handlers.handleGraphqlReplay({
+            endpoint: 'https://example.com/graphql',
+            query: 'query GetUser($id: ID!) { user(id: $id) { name } }',
+            variables: { id: '42' },
+            operationName: 'GetUser',
+        });
+    });
+    it('executes callback when fetch throws non-Error', async () => {
+        page.evaluate.mockImplementationOnce(async (fn, input) => {
+            const origFetch = globalThis.fetch;
+            try {
+                globalThis.fetch = vi.fn().mockRejectedValue(42);
+                return await fn(input);
+            }
+            finally {
+                globalThis.fetch = origFetch;
+            }
+        });
+        const body = parseJson(await handlers.handleGraphqlReplay({
+            endpoint: 'https://example.com/graphql',
+            query: 'query Test { test }',
+        }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('42');
+    });
+});
+describe('GraphQLToolHandlersScriptReplace - additional coverage', () => {
+    const page = {
+        evaluate: vi.fn(),
+        evaluateOnNewDocument: vi.fn(),
+        setRequestInterception: vi.fn().mockResolvedValue(undefined),
+        on: vi.fn(),
+    };
+    const collector = {
+        getActivePage: vi.fn(async () => page),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        isSsrfTargetMock.mockResolvedValue(false);
+        handlers = new GraphQLToolHandlersScriptReplace(collector);
+    });
+    it('returns error when replacement is empty string', async () => {
+        const response = await handlers.handleScriptReplacePersist({
+            url: '/script.js',
+            replacement: '',
+        });
+        expect(response.isError).toBe(true);
+        const body = parseJson(response);
+        expect(body.error).toContain('Missing required argument: replacement');
+    });
+    it('returns error when replacement is not a string', async () => {
+        const response = await handlers.handleScriptReplacePersist({
+            url: '/script.js',
+            replacement: 42,
+        });
+        expect(response.isError).toBe(true);
+        const body = parseJson(response);
+        expect(body.error).toContain('Missing required argument: replacement');
+    });
+    it('registers replacement rule with default matchType', async () => {
+        const body = parseJson(await handlers.handleScriptReplacePersist({
+            url: '/app.js',
+            replacement: 'console.log("patched")',
+        }));
+        expect(body.success).toBe(true);
+        expect(body.rule.matchType).toBe('contains');
+        expect(body.replacement.length).toBe('console.log("patched")'.length);
+        expect(body.replacement.truncated).toBe(false);
+    });
+    it('registers replacement rule with exact matchType', async () => {
+        const body = parseJson(await handlers.handleScriptReplacePersist({
+            url: 'https://example.com/bundle.js',
+            replacement: 'void 0',
+            matchType: 'exact',
+        }));
+        expect(body.success).toBe(true);
+        expect(body.rule.matchType).toBe('exact');
+    });
+    it('truncates large replacement in preview', async () => {
+        const largeReplacement = 'x'.repeat(10000);
+        const body = parseJson(await handlers.handleScriptReplacePersist({
+            url: '/script.js',
+            replacement: largeReplacement,
+        }));
+        expect(body.success).toBe(true);
+        expect(body.replacement.truncated).toBe(true);
+        expect(body.replacement.length).toBe(10000);
+    });
+    it('increments activeRuleCount for multiple rules', async () => {
+        const body1 = parseJson(await handlers.handleScriptReplacePersist({
+            url: '/first.js',
+            replacement: 'a',
+        }));
+        expect(body1.activeRuleCount).toBe(1);
+        const body2 = parseJson(await handlers.handleScriptReplacePersist({
+            url: '/second.js',
+            replacement: 'b',
+        }));
+        expect(body2.activeRuleCount).toBe(2);
+    });
+    it('calls evaluateOnNewDocument with rule metadata', async () => {
+        await handlers.handleScriptReplacePersist({
+            url: '/eval-doc.js',
+            replacement: 'patched()',
+        });
+        expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(expect.any(Function), expect.objectContaining({
+            url: '/eval-doc.js',
+            matchType: 'contains',
+        }));
+    });
+    it('evaluateOnNewDocument callback works correctly', async () => {
+        let capturedCallback;
+        page.evaluateOnNewDocument.mockImplementationOnce((fn, ...args) => {
+            capturedCallback = fn;
+            const fakeWindow = {};
+            const origWindow = globalThis.window;
+            try {
+                Object.defineProperty(globalThis, 'window', {
+                    value: fakeWindow,
+                    writable: true,
+                    configurable: true,
+                });
+                fn(...args);
+                expect(Array.isArray(fakeWindow.__scriptReplacePersistRules)).toBe(true);
+                const rules = fakeWindow.__scriptReplacePersistRules;
+                expect(rules).toHaveLength(1);
+            }
+            finally {
+                Object.defineProperty(globalThis, 'window', {
+                    value: origWindow,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+        });
+        await handlers.handleScriptReplacePersist({
+            url: '/callback-test.js',
+            replacement: 'code()',
+        });
+        expect(capturedCallback).toBeDefined();
+    });
+    it('evaluateOnNewDocument callback deduplicates rules by id', async () => {
+        page.evaluateOnNewDocument.mockImplementationOnce((fn, payload) => {
+            const fakeWindow = {
+                __scriptReplacePersistRules: [
+                    { id: payload.id, url: 'old', matchType: 'exact', createdAt: 0 },
+                    { id: 'other-rule', url: 'other', matchType: 'contains', createdAt: 0 },
+                ],
+            };
+            const origWindow = globalThis.window;
+            try {
+                Object.defineProperty(globalThis, 'window', {
+                    value: fakeWindow,
+                    writable: true,
+                    configurable: true,
+                });
+                fn(payload);
+                const rules = fakeWindow.__scriptReplacePersistRules;
+                expect(rules).toHaveLength(2);
+                const ids = rules.map((r) => r.id);
+                expect(ids).toContain('other-rule');
+                expect(ids).toContain(payload.id);
+            }
+            finally {
+                Object.defineProperty(globalThis, 'window', {
+                    value: origWindow,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+        });
+        await handlers.handleScriptReplacePersist({
+            url: '/dedup-test.js',
+            replacement: 'code()',
+        });
+    });
+    it('catches error in handleScriptReplacePersist', async () => {
+        collector.getActivePage.mockRejectedValueOnce(new Error('Page crashed'));
+        const response = await handlers.handleScriptReplacePersist({
+            url: '/crash.js',
+            replacement: 'code()',
+        });
+        expect(response.isError).toBe(true);
+        const body = parseJson(response);
+        expect(body.error).toBe('Page crashed');
+    });
+});
+describe('graphql manifest bind functions', () => {
+    it('bind functions invoke the correct handler methods', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        const ctx = {
+            config: { puppeteer: {} },
+            registerCaches: vi.fn(async () => { }),
+        };
+        manifest.ensure(ctx);
+        for (const reg of manifest.registrations) {
+            expect(typeof reg.bind).toBe('function');
+        }
+    });
+});

package/dist/tests/server/domains/graphql/runtime-replay.test.d.ts

@@ -0,0 +1 @@
+export {};