@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/domains/graphql/handlers.impl.core.runtime.replay.js

@@ -1,718 +0,0 @@
-import { GRAPHQL_MAX_PREVIEW_CHARS, GRAPHQL_MAX_SCHEMA_CHARS, GRAPHQL_MAX_QUERY_CHARS, GRAPHQL_MAX_GRAPH_NODES, GRAPHQL_MAX_GRAPH_EDGES, INTROSPECTION_QUERY, } from '../../domains/graphql/handlers.impl.core.runtime.shared.js';
-import { GraphQLHandlersBase } from '../../domains/graphql/handlers.base.js';
-import { evaluateWithTimeout } from '../../../modules/collector/PageController.js';
-export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
-    async handleCallGraphAnalyze(args) {
-        try {
-            const maxDepth = this.getNumberArg(args, 'maxDepth', 5, 1, 20);
-            const filterPattern = this.getStringArg(args, 'filterPattern')?.trim() || '';
-            if (filterPattern) {
-                try {
-                    RegExp(filterPattern);
-                }
-                catch (error) {
-                    return this.toError('Invalid filterPattern regex', {
-                        filterPattern,
-                        reason: this.getErrorMessage(error),
-                    });
-                }
-            }
-            const page = await this.collector.getActivePage();
-            const rawResult = await evaluateWithTimeout(page, ({ maxDepth: depth, filterPattern: filter }) => {
-                const globalScope = window;
-                const edgeMap = new Map();
-                const nodeMap = new Map();
-                let scannedRecords = 0;
-                let acceptedRecords = 0;
-                const filterRegex = filter ? new RegExp(filter) : null;
-                const matchesFilter = (name) => {
-                    if (!filterRegex) {
-                        return true;
-                    }
-                    filterRegex.lastIndex = 0;
-                    return filterRegex.test(name);
-                };
-                const includeEdge = (source, target) => {
-                    if (!filterRegex) {
-                        return true;
-                    }
-                    return matchesFilter(source) || matchesFilter(target);
-                };
-                const incrementNode = (name, by = 1) => {
-                    const existing = nodeMap.get(name);
-                    if (existing) {
-                        existing.callCount += by;
-                        return;
-                    }
-                    nodeMap.set(name, { id: name, name, callCount: by });
-                };
-                const addEdge = (sourceRaw, targetRaw) => {
-                    const source = typeof sourceRaw === 'string' ? sourceRaw.trim() || '' : '';
-                    const target = typeof targetRaw === 'string' ? targetRaw.trim() || '' : '';
-                    if (!source || !target || source === target) {
-                        return;
-                    }
-                    if (!includeEdge(source, target)) {
-                        return;
-                    }
-                    const key = `${source}__->__${target}`;
-                    const existing = edgeMap.get(key);
-                    if (existing) {
-                        existing.count += 1;
-                    }
-                    else {
-                        edgeMap.set(key, { source, target, count: 1 });
-                    }
-                    incrementNode(source, 1);
-                    incrementNode(target, 1);
-                };
-                const processRecord = (record, fallbackName) => {
-                    scannedRecords += 1;
-                    const calleeRaw = record.callee ??
-                        record.functionName ??
-                        record.fn ??
-                        record.name ??
-                        record.method ??
-                        record.target ??
-                        fallbackName;
-                    const callee = typeof calleeRaw === 'string' ? calleeRaw.trim() || fallbackName : fallbackName;
-                    const callerRaw = record.caller ?? record.parent ?? record.from ?? '';
-                    const caller = typeof callerRaw === 'string' ? callerRaw.trim() || '' : '';
-                    let used = false;
-                    if (caller && callee) {
-                        addEdge(caller, callee);
-                        used = true;
-                    }
-                    const stackValue = record.stack ?? record.stackTrace ?? record.trace;
-                    const frames = typeof stackValue === 'string' && stackValue.trim().length > 0
-                        ? stackValue
-                            .split('\n')
-                            .map((line) => line.trim())
-                            .filter((line) => line.length > 0)
-                            .map((line) => {
-                            const atMatch = line.match(/at\s+([^(<\s]+)/);
-                            if (atMatch?.[1]) {
-                                return atMatch[1];
-                            }
-                            const atFileMatch = line.match(/^([^(<\s]+)@/);
-                            if (atFileMatch?.[1]) {
-                                return atFileMatch[1];
-                            }
-                            return '';
-                        })
-                            .filter((name) => name.length > 0)
-                        : [];
-                    if (frames.length > 1) {
-                        const depthLimit = Math.min(depth, frames.length - 1);
-                        for (let index = 0; index < depthLimit; index += 1) {
-                            addEdge(frames[index + 1], frames[index]);
-                        }
-                        used = true;
-                    }
-                    else if (frames.length === 1 && callee && frames[0] !== callee) {
-                        addEdge(frames[0], callee);
-                        used = true;
-                    }
-                    if (used) {
-                        acceptedRecords += 1;
-                    }
-                };
-                const aiHooks = globalScope.__aiHooks;
-                if (aiHooks && typeof aiHooks === 'object') {
-                    for (const [hookName, hookRecords] of Object.entries(aiHooks)) {
-                        if (!Array.isArray(hookRecords)) {
-                            continue;
-                        }
-                        for (const entry of hookRecords) {
-                            if (entry && typeof entry === 'object') {
-                                processRecord(entry, hookName);
-                            }
-                        }
-                    }
-                }
-                const tracerKeys = [
-                    '__functionTraceRecords',
-                    '__functionTracerRecords',
-                    '__functionCalls',
-                    '__callTrace',
-                    '__traceCalls',
-                ];
-                for (const key of tracerKeys) {
-                    const records = globalScope[key];
-                    if (!Array.isArray(records)) {
-                        continue;
-                    }
-                    for (const entry of records) {
-                        if (entry && typeof entry === 'object') {
-                            processRecord(entry, key);
-                        }
-                    }
-                }
-                const functionTracer = globalScope.__functionTracer;
-                if (functionTracer && typeof functionTracer === 'object') {
-                    const records = functionTracer.records;
-                    if (Array.isArray(records)) {
-                        for (const entry of records) {
-                            if (entry && typeof entry === 'object') {
-                                processRecord(entry, 'functionTracer.records');
-                            }
-                        }
-                    }
-                }
-                const nodes = Array.from(nodeMap.values()).toSorted((left, right) => right.callCount - left.callCount);
-                const edges = Array.from(edgeMap.values()).toSorted((left, right) => right.count - left.count);
-                return {
-                    nodes,
-                    edges,
-                    stats: {
-                        scannedRecords,
-                        acceptedRecords,
-                        nodeCount: nodes.length,
-                        edgeCount: edges.length,
-                        maxDepth: depth,
-                        filterPattern: filter || null,
-                    },
-                };
-            }, {
-                maxDepth,
-                filterPattern,
-            });
-            const result = rawResult;
-            const nodesTruncated = result.nodes.length > GRAPHQL_MAX_GRAPH_NODES;
-            const edgesTruncated = result.edges.length > GRAPHQL_MAX_GRAPH_EDGES;
-            return this.toResponse({
-                success: true,
-                nodes: result.nodes.slice(0, GRAPHQL_MAX_GRAPH_NODES),
-                edges: result.edges.slice(0, GRAPHQL_MAX_GRAPH_EDGES),
-                stats: {
-                    ...result.stats,
-                    nodesReturned: Math.min(result.nodes.length, GRAPHQL_MAX_GRAPH_NODES),
-                    edgesReturned: Math.min(result.edges.length, GRAPHQL_MAX_GRAPH_EDGES),
-                    nodesTruncated,
-                    edgesTruncated,
-                },
-            });
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-    async handleScriptReplacePersist(args) {
-        try {
-            const url = this.getStringArg(args, 'url')?.trim();
-            const replacement = this.getStringArg(args, 'replacement');
-            const matchType = this.parseMatchType(args.matchType);
-            if (!url) {
-                return this.toError('Missing required argument: url');
-            }
-            if (typeof replacement !== 'string' || replacement.length === 0) {
-                return this.toError('Missing required argument: replacement');
-            }
-            if (matchType === 'regex') {
-                try {
-                    RegExp(url);
-                }
-                catch (error) {
-                    return this.toError('Invalid regex in url for matchType=regex', {
-                        url,
-                        reason: this.getErrorMessage(error),
-                    });
-                }
-            }
-            const page = await this.collector.getActivePage();
-            const rule = {
-                id: this.generateRuleId(),
-                url,
-                replacement,
-                matchType,
-                createdAt: Date.now(),
-                hits: 0,
-            };
-            this.scriptReplaceRules.push(rule);
-            await this.ensureScriptInterception(page);
-            await page.evaluateOnNewDocument((payload) => {
-                const runtimeWindow = window;
-                const key = '__scriptReplacePersistRules';
-                const existing = Array.isArray(runtimeWindow[key])
-                    ? runtimeWindow[key]
-                    : [];
-                const filtered = existing.filter((entry) => entry && entry.id !== payload.id);
-                filtered.push(payload);
-                runtimeWindow[key] = filtered;
-            }, {
-                id: rule.id,
-                url: rule.url,
-                matchType: rule.matchType,
-                createdAt: rule.createdAt,
-            });
-            const replacementPreview = this.createPreview(replacement, GRAPHQL_MAX_PREVIEW_CHARS);
-            return this.toResponse({
-                success: true,
-                message: 'Script replacement rule registered and interception enabled',
-                rule: {
-                    id: rule.id,
-                    url: rule.url,
-                    matchType: rule.matchType,
-                    createdAt: rule.createdAt,
-                },
-                replacement: {
-                    length: replacement.length,
-                    preview: replacementPreview.preview,
-                    truncated: replacementPreview.truncated,
-                },
-                activeRuleCount: this.scriptReplaceRules.length,
-            });
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-    async handleGraphqlIntrospect(args) {
-        try {
-            const endpoint = this.getStringArg(args, 'endpoint')?.trim();
-            if (!endpoint) {
-                return this.toError('Missing required argument: endpoint');
-            }
-            const endpointValidationError = await this.validateExternalEndpoint(endpoint);
-            if (endpointValidationError) {
-                return this.toError(endpointValidationError);
-            }
-            const headers = this.normalizeHeaders(args.headers);
-            const page = await this.collector.getActivePage();
-            const browserResult = (await evaluateWithTimeout(page, async (input) => {
-                const requestHeaders = {
-                    'content-type': 'application/json',
-                    ...input.headers,
-                };
-                try {
-                    const ac = new AbortController();
-                    const t = setTimeout(() => ac.abort(), 10000);
-                    let responseText;
-                    let response;
-                    try {
-                        response = await fetch(input.endpoint, {
-                            method: 'POST',
-                            headers: requestHeaders,
-                            body: JSON.stringify({
-                                query: input.query,
-                                operationName: 'IntrospectionQuery',
-                            }),
-                            signal: ac.signal,
-                        });
-                        responseText = await response.text();
-                    }
-                    finally {
-                        clearTimeout(t);
-                    }
-                    let responseJson = null;
-                    try {
-                        responseJson = JSON.parse(responseText);
-                    }
-                    catch {
-                        responseJson = null;
-                    }
-                    const responseHeaders = {};
-                    response.headers.forEach((value, key) => {
-                        responseHeaders[key] = value;
-                    });
-                    return {
-                        ok: response.ok,
-                        status: response.status,
-                        statusText: response.statusText,
-                        responseText,
-                        responseJson,
-                        responseHeaders,
-                    };
-                }
-                catch (error) {
-                    return {
-                        ok: false,
-                        status: 0,
-                        statusText: 'FETCH_ERROR',
-                        responseText: '',
-                        responseJson: null,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            }, {
-                endpoint,
-                headers,
-                query: INTROSPECTION_QUERY,
-            }));
-            if (!browserResult.ok && !browserResult.responseJson) {
-                return this.toResponse({
-                    success: false,
-                    endpoint,
-                    status: browserResult.status,
-                    statusText: browserResult.statusText,
-                    error: browserResult.error ?? 'Introspection request failed',
-                    responsePreview: this.createPreview(browserResult.responseText || '', GRAPHQL_MAX_PREVIEW_CHARS),
-                });
-            }
-            const jsonRecord = browserResult.responseJson && typeof browserResult.responseJson === 'object'
-                ? browserResult.responseJson
-                : null;
-            const schemaPayload = jsonRecord && 'data' in jsonRecord
-                ? jsonRecord.data
-                : (browserResult.responseJson ?? browserResult.responseText);
-            const schemaPreview = this.serializeForPreview(schemaPayload, GRAPHQL_MAX_SCHEMA_CHARS);
-            const payload = {
-                success: browserResult.ok,
-                endpoint,
-                status: browserResult.status,
-                statusText: browserResult.statusText,
-                schemaLength: schemaPreview.totalLength,
-                schemaPreview: schemaPreview.preview,
-                schemaTruncated: schemaPreview.truncated,
-                responseHeaders: browserResult.responseHeaders ?? {},
-            };
-            if (!schemaPreview.truncated) {
-                payload.schema = schemaPayload;
-            }
-            if (jsonRecord && Array.isArray(jsonRecord.errors)) {
-                payload.errors = jsonRecord.errors;
-            }
-            if (browserResult.error) {
-                payload.error = browserResult.error;
-            }
-            return this.toResponse(payload);
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-    async handleGraphqlExtractQueries(args) {
-        try {
-            const limit = this.getNumberArg(args, 'limit', 50, 1, 200);
-            const page = await this.collector.getActivePage();
-            const extraction = (await evaluateWithTimeout(page, (maxItems) => {
-                const globalScope = window;
-                const extracted = [];
-                let scannedRecords = 0;
-                const pushIfGraphQL = (payload, metadata) => {
-                    if (!payload) {
-                        return;
-                    }
-                    const queryRaw = payload.query;
-                    if (typeof queryRaw !== 'string' || queryRaw.trim().length === 0) {
-                        return;
-                    }
-                    const operationNameRaw = payload.operationName;
-                    const operationName = typeof operationNameRaw === 'string' && operationNameRaw.trim().length > 0
-                        ? operationNameRaw
-                        : (queryRaw.match(/^\s*(query|mutation|subscription)\s+([A-Za-z0-9_]+)/)?.[2] ??
-                            null);
-                    extracted.push({
-                        source: metadata.source,
-                        url: metadata.url,
-                        method: metadata.method,
-                        operationName,
-                        query: queryRaw,
-                        variables: payload.variables ?? null,
-                        timestamp: metadata.timestamp,
-                        contentType: metadata.contentType,
-                    });
-                };
-                const processRequestRecord = (record, source) => {
-                    scannedRecords += 1;
-                    const url = typeof record.url === 'string' ? record.url : '';
-                    const method = typeof record.method === 'string' ? record.method : 'POST';
-                    const timestamp = typeof record.timestamp === 'number' ? record.timestamp : null;
-                    const headers = (record.headers &&
-                        typeof record.headers === 'object' &&
-                        !Array.isArray(record.headers)
-                        ? record.headers
-                        : null) ??
-                        (record.requestHeaders &&
-                            typeof record.requestHeaders === 'object' &&
-                            !Array.isArray(record.requestHeaders)
-                            ? record.requestHeaders
-                            : null) ??
-                        {};
-                    let contentType = '';
-                    for (const [key, value] of Object.entries(headers)) {
-                        if (key.toLowerCase() === 'content-type') {
-                            contentType = typeof value === 'string' ? value : String(value);
-                            break;
-                        }
-                    }
-                    contentType = contentType.toLowerCase();
-                    const bodyCandidates = [record.body, record.postData];
-                    if (record.options &&
-                        typeof record.options === 'object' &&
-                        !Array.isArray(record.options)) {
-                        const optionsRecord = record.options;
-                        bodyCandidates.push(optionsRecord.body);
-                    }
-                    for (const bodyCandidate of bodyCandidates) {
-                        let payload = null;
-                        if (bodyCandidate &&
-                            typeof bodyCandidate === 'object' &&
-                            !Array.isArray(bodyCandidate)) {
-                            payload = bodyCandidate;
-                        }
-                        else if (typeof bodyCandidate === 'string') {
-                            const trimmed = bodyCandidate.trim();
-                            if (trimmed) {
-                                try {
-                                    const parsed = JSON.parse(trimmed);
-                                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                                        payload = parsed;
-                                    }
-                                }
-                                catch {
-                                }
-                                if (!payload && trimmed.includes('query=')) {
-                                    try {
-                                        const params = new URLSearchParams(trimmed);
-                                        const query = params.get('query');
-                                        if (query) {
-                                            const operationName = params.get('operationName');
-                                            const variablesRaw = params.get('variables');
-                                            let variables = null;
-                                            if (variablesRaw) {
-                                                try {
-                                                    variables = JSON.parse(variablesRaw);
-                                                }
-                                                catch {
-                                                    variables = variablesRaw;
-                                                }
-                                            }
-                                            payload = {
-                                                query,
-                                                operationName,
-                                                variables,
-                                            };
-                                        }
-                                    }
-                                    catch {
-                                        payload = null;
-                                    }
-                                }
-                                if (!payload &&
-                                    (trimmed.startsWith('query ') ||
-                                        trimmed.startsWith('mutation ') ||
-                                        trimmed.startsWith('subscription '))) {
-                                    payload = { query: trimmed };
-                                }
-                            }
-                        }
-                        pushIfGraphQL(payload, {
-                            source,
-                            url,
-                            method,
-                            timestamp,
-                            contentType,
-                        });
-                    }
-                    if (contentType.includes('application/graphql') && typeof record.body === 'string') {
-                        pushIfGraphQL({ query: record.body, variables: null, operationName: null }, {
-                            source,
-                            url,
-                            method,
-                            timestamp,
-                            contentType,
-                        });
-                    }
-                };
-                const processArray = (value, source) => {
-                    if (!Array.isArray(value)) {
-                        return;
-                    }
-                    for (const item of value) {
-                        if (item && typeof item === 'object') {
-                            processRequestRecord(item, source);
-                        }
-                    }
-                };
-                processArray(globalScope.__fetchRequests, 'window.__fetchRequests');
-                processArray(globalScope.__xhrRequests, 'window.__xhrRequests');
-                processArray(globalScope.__networkRequests, 'window.__networkRequests');
-                const aiHooks = globalScope.__aiHooks;
-                if (aiHooks && typeof aiHooks === 'object') {
-                    for (const [hookName, hookRecords] of Object.entries(aiHooks)) {
-                        if (!Array.isArray(hookRecords)) {
-                            continue;
-                        }
-                        for (const entry of hookRecords) {
-                            if (entry && typeof entry === 'object') {
-                                processRequestRecord(entry, `window.__aiHooks.${hookName}`);
-                            }
-                        }
-                    }
-                }
-                extracted.sort((left, right) => (right.timestamp ?? 0) - (left.timestamp ?? 0));
-                const deduped = [];
-                const seen = new Set();
-                for (const item of extracted) {
-                    const key = `${item.url}|${item.operationName ?? ''}|${item.query}|${JSON.stringify(item.variables)}`;
-                    if (!seen.has(key)) {
-                        seen.add(key);
-                        deduped.push(item);
-                    }
-                }
-                return {
-                    scannedRecords,
-                    totalExtracted: deduped.length,
-                    extracted: deduped.slice(0, maxItems),
-                };
-            }, limit));
-            const queries = extraction.extracted.map((item, index) => {
-                const queryPreview = this.createPreview(item.query, GRAPHQL_MAX_QUERY_CHARS);
-                const variablesPreview = this.serializeForPreview(item.variables, GRAPHQL_MAX_PREVIEW_CHARS);
-                const normalized = {
-                    index,
-                    source: item.source,
-                    url: item.url,
-                    method: item.method,
-                    operationName: item.operationName,
-                    contentType: item.contentType,
-                    timestamp: item.timestamp,
-                    queryLength: item.query.length,
-                    queryPreview: queryPreview.preview,
-                    queryTruncated: queryPreview.truncated,
-                };
-                if (!queryPreview.truncated) {
-                    normalized.query = item.query;
-                }
-                if (!variablesPreview.truncated) {
-                    normalized.variables = item.variables;
-                }
-                else {
-                    normalized.variablesPreview = variablesPreview.preview;
-                    normalized.variablesTruncated = true;
-                }
-                return normalized;
-            });
-            return this.toResponse({
-                success: true,
-                limit,
-                stats: {
-                    scannedRecords: extraction.scannedRecords,
-                    totalExtracted: extraction.totalExtracted,
-                    returned: queries.length,
-                },
-                queries,
-            });
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-    async handleGraphqlReplay(args) {
-        try {
-            const endpoint = this.getStringArg(args, 'endpoint')?.trim();
-            const query = this.getStringArg(args, 'query');
-            if (!endpoint) {
-                return this.toError('Missing required argument: endpoint');
-            }
-            if (typeof query !== 'string' || query.trim().length === 0) {
-                return this.toError('Missing required argument: query');
-            }
-            const endpointValidationError = await this.validateExternalEndpoint(endpoint);
-            if (endpointValidationError) {
-                return this.toError(endpointValidationError);
-            }
-            const variables = this.getObjectArg(args, 'variables') ?? {};
-            const operationNameRaw = this.getStringArg(args, 'operationName');
-            const operationName = operationNameRaw && operationNameRaw.trim().length > 0 ? operationNameRaw.trim() : null;
-            const headers = this.normalizeHeaders(args.headers);
-            const page = await this.collector.getActivePage();
-            const browserResult = (await evaluateWithTimeout(page, async (input) => {
-                const requestHeaders = {
-                    'content-type': 'application/json',
-                    ...input.headers,
-                };
-                try {
-                    const ac = new AbortController();
-                    const t = setTimeout(() => ac.abort(), 10000);
-                    let responseText;
-                    let response;
-                    try {
-                        response = await fetch(input.endpoint, {
-                            method: 'POST',
-                            headers: requestHeaders,
-                            body: JSON.stringify({
-                                query: input.query,
-                                variables: input.variables,
-                                operationName: input.operationName,
-                            }),
-                            signal: ac.signal,
-                        });
-                        responseText = await response.text();
-                    }
-                    finally {
-                        clearTimeout(t);
-                    }
-                    let responseJson = null;
-                    try {
-                        responseJson = JSON.parse(responseText);
-                    }
-                    catch {
-                        responseJson = null;
-                    }
-                    const responseHeaders = {};
-                    response.headers.forEach((value, key) => {
-                        responseHeaders[key] = value;
-                    });
-                    return {
-                        ok: response.ok,
-                        status: response.status,
-                        statusText: response.statusText,
-                        responseText,
-                        responseJson,
-                        responseHeaders,
-                    };
-                }
-                catch (error) {
-                    return {
-                        ok: false,
-                        status: 0,
-                        statusText: 'FETCH_ERROR',
-                        responseText: '',
-                        responseJson: null,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            }, {
-                endpoint,
-                query,
-                variables,
-                operationName,
-                headers,
-            }));
-            const payload = {
-                success: browserResult.ok,
-                endpoint,
-                status: browserResult.status,
-                statusText: browserResult.statusText,
-                operationName,
-                responseHeaders: browserResult.responseHeaders ?? {},
-            };
-            if (browserResult.responseJson !== null) {
-                const responsePreview = this.serializeForPreview(browserResult.responseJson, GRAPHQL_MAX_SCHEMA_CHARS);
-                payload.responseLength = responsePreview.totalLength;
-                payload.responsePreview = responsePreview.preview;
-                payload.responseTruncated = responsePreview.truncated;
-                if (!responsePreview.truncated) {
-                    payload.response = browserResult.responseJson;
-                }
-            }
-            else {
-                const textPreview = this.createPreview(browserResult.responseText, GRAPHQL_MAX_SCHEMA_CHARS);
-                payload.responseLength = textPreview.totalLength;
-                payload.responsePreview = textPreview.preview;
-                payload.responseTruncated = textPreview.truncated;
-                payload.responseFormat = 'text';
-            }
-            if (browserResult.error) {
-                payload.error = browserResult.error;
-            }
-            return this.toResponse(payload);
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-}
-export { GraphQLToolHandlersRuntime as GraphQLToolHandlersCallGraph, GraphQLToolHandlersRuntime as GraphQLToolHandlersScriptReplace, GraphQLToolHandlersRuntime as GraphQLToolHandlersIntrospection, GraphQLToolHandlersRuntime as GraphQLToolHandlersExtract, };