dbgate-rest 7.1.3-alpha.2

package/README.md

@@ -0,0 +1,7 @@
+# dbgate-rest
+
+REST API support for DbGate
+
+## Installation
+
+yarn add dbgate-rest

package/lib/arrayify.d.ts

@@ -0,0 +1,3 @@
+type FlatObject = Record<string, any>;
+export declare function arrayifyToFlatObjects(input: any): FlatObject[] | undefined;
+export {};

package/lib/arrayify.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayifyToFlatObjects = void 0;
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function flattenValue(value) {
+    if (Array.isArray(value)) {
+        const primitiveArray = value.every(item => item == null || typeof item !== 'object');
+        if (primitiveArray) {
+            return value.join(', ');
+        }
+        return JSON.stringify(value);
+    }
+    return value;
+}
+function flattenObject(obj, prefix = '', out = {}, visited = new WeakSet()) {
+    if (visited.has(obj))
+        return out;
+    visited.add(obj);
+    for (const [key, value] of Object.entries(obj)) {
+        const nextKey = prefix ? `${prefix}.${key}` : key;
+        if (isPlainObject(value)) {
+            flattenObject(value, nextKey, out, visited);
+            continue;
+        }
+        out[nextKey] = flattenValue(value);
+    }
+    return out;
+}
+function unwrapArrayItem(item) {
+    if (isPlainObject(item) && isPlainObject(item.node)) {
+        return item.node;
+    }
+    return item;
+}
+function collectArrayCandidates(value, set, visited = new WeakSet(), depth = 0) {
+    if (depth > 10)
+        return;
+    if (Array.isArray(value)) {
+        set.add(value);
+        return;
+    }
+    if (!isPlainObject(value))
+        return;
+    if (visited.has(value))
+        return;
+    visited.add(value);
+    if (Array.isArray(value.edges))
+        set.add(value.edges);
+    if (Array.isArray(value.nodes))
+        set.add(value.nodes);
+    if (Array.isArray(value.items))
+        set.add(value.items);
+    for (const nested of Object.values(value)) {
+        collectArrayCandidates(nested, set, visited, depth + 1);
+    }
+}
+function findUniqueArrayCandidate(value) {
+    var _a;
+    if (Array.isArray(value))
+        return value;
+    const candidates = new Set();
+    collectArrayCandidates(value, candidates);
+    if (candidates.size !== 1)
+        return null;
+    return (_a = candidates.values().next().value) !== null && _a !== void 0 ? _a : null;
+}
+function arrayifyToFlatObjects(input) {
+    const arrayCandidate = findUniqueArrayCandidate(input);
+    if (!arrayCandidate)
+        return undefined;
+    return arrayCandidate.map(item => {
+        const unwrapped = unwrapArrayItem(item);
+        if (isPlainObject(unwrapped)) {
+            return flattenObject(unwrapped);
+        }
+        return { value: unwrapped };
+    });
+}
+exports.arrayifyToFlatObjects = arrayifyToFlatObjects;

package/lib/graphQlDriver.d.ts

@@ -0,0 +1,2 @@
+import type { EngineDriver } from 'dbgate-types';
+export declare const graphQlDriver: EngineDriver;

package/lib/graphQlDriver.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphQlDriver = void 0;
+const graphqlIntrospection_1 = require("./graphqlIntrospection");
+const restDriverBase_1 = require("./restDriverBase");
+const restAuthTools_1 = require("./restAuthTools");
+async function loadGraphQlSchema(dbhan) {
+    var _a;
+    if (!((_a = dbhan === null || dbhan === void 0 ? void 0 : dbhan.connection) === null || _a === void 0 ? void 0 : _a.apiServerUrl1)) {
+        throw new Error('DBGM-00310 GraphQL endpoint URL is not configured');
+    }
+    const introspectionResult = await (0, graphqlIntrospection_1.fetchGraphQLSchema)(dbhan.connection.apiServerUrl1, (0, restAuthTools_1.buildRestAuthHeaders)(dbhan.connection.restAuth), dbhan.axios);
+    if (!introspectionResult || typeof introspectionResult !== 'object') {
+        throw new Error('DBGM-00311 GraphQL schema is empty or could not be loaded');
+    }
+    return introspectionResult;
+}
+// @ts-ignore
+exports.graphQlDriver = {
+    ...restDriverBase_1.apiDriverBase,
+    engine: 'graphql@rest',
+    title: 'GraphQL',
+    databaseEngineTypes: ['rest', 'graphql'],
+    icon: '<svg version="1.1" id="GraphQL_Logo" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 400 400" enable-background="new 0 0 400 400" xml:space="preserve"><g><g><g><rect x="122" y="-0.4" transform="matrix(-0.866 -0.5 0.5 -0.866 163.3196 363.3136)" fill="#E535AB" width="16.6" height="320.3"/></g></g><g><g><rect x="39.8" y="272.2" fill="#E535AB" width="320.3" height="16.6"/></g></g><g><g><rect x="37.9" y="312.2" transform="matrix(-0.866 -0.5 0.5 -0.866 83.0693 663.3409)" fill="#E535AB" width="185" height="16.6"/></g></g><g><g><rect x="177.1" y="71.1" transform="matrix(-0.866 -0.5 0.5 -0.866 463.3409 283.0693)" fill="#E535AB" width="185" height="16.6"/></g></g><g><g><rect x="122.1" y="-13" transform="matrix(-0.5 -0.866 0.866 -0.5 126.7903 232.1221)" fill="#E535AB" width="16.6" height="185"/></g></g><g><g><rect x="109.6" y="151.6" transform="matrix(-0.5 -0.866 0.866 -0.5 266.0828 473.3766)" fill="#E535AB" width="320.3" height="16.6"/></g></g><g><g><rect x="52.5" y="107.5" fill="#E535AB" width="16.6" height="185"/></g></g><g><g><rect x="330.9" y="107.5" fill="#E535AB" width="16.6" height="185"/></g></g><g><g><rect x="262.4" y="240.1" transform="matrix(-0.5 -0.866 0.866 -0.5 126.7953 714.2875)" fill="#E535AB" width="14.5" height="160.9"/></g></g><path fill="#E535AB" d="M369.5,297.9c-9.6,16.7-31,22.4-47.7,12.8c-16.7-9.6-22.4-31-12.8-47.7c9.6-16.7,31-22.4,47.7-12.8 C373.5,259.9,379.2,281.2,369.5,297.9"/><path fill="#E535AB" d="M90.9,137c-9.6,16.7-31,22.4-47.7,12.8c-16.7-9.6-22.4-31-12.8-47.7c9.6-16.7,31-22.4,47.7-12.8 C94.8,99,100.5,120.3,90.9,137"/><path fill="#E535AB" d="M30.5,297.9c-9.6-16.7-3.9-38,12.8-47.7c16.7-9.6,38-3.9,47.7,12.8c9.6,16.7,3.9,38-12.8,47.7 C61.4,320.3,40.1,314.6,30.5,297.9"/><path fill="#E535AB" d="M309.1,137c-9.6-16.7-3.9-38,12.8-47.7c16.7-9.6,38-3.9,47.7,12.8c9.6-16.7,3.9-38-12.8,47.7 C340.1,159.4,318.7,153.7,309.1,137"/><path fill="#E535AB" d="M200,395.8c-19.3,0-34.9-15.6-34.9-34.9c0-19.3,15.6-34.9,34.9-34.9c19.3,0,34.9,15.6,34.9,34.9 C234.9,380.1,219.3,395.8,200,395.8"/><path fill="#E535AB" d="M200,74c-19.3,0-34.9-15.6-34.9-34.9c0-19.3,15.6-34.9,34.9-34.9c19.3,0,34.9,15.6,34.9,34.9 C234.9,58.4,219.3,74,200,74"/></g></svg>',
+    showConnectionField: (field, values) => {
+        if (restDriverBase_1.apiDriverBase.showAuthConnectionField(field, values))
+            return true;
+        if (field === 'apiServerUrl1')
+            return true;
+        return false;
+    },
+    apiServerUrl1Label: 'GraphQL Endpoint URL',
+    beforeConnectionSave: connection => ({
+        ...connection,
+        singleDatabase: true,
+        defaultDatabase: '_api_database_',
+    }),
+    async connect(connection) {
+        return {
+            connection,
+            client: null,
+            database: '_api_database_',
+            axios: connection.axios,
+        };
+    },
+    async getVersion(dbhan) {
+        var _a;
+        const introspectionResult = await loadGraphQlSchema(dbhan);
+        const schema = introspectionResult.__schema;
+        // const version = 'GraphQL';
+        return {
+            version: `GraphQL, ${((_a = schema.types) === null || _a === void 0 ? void 0 : _a.length) || 0} types`,
+        };
+    },
+};

package/lib/graphQlQueryParser.d.ts

@@ -0,0 +1,5 @@
+export declare function parseGraphQlSelectionPaths(text: string): {
+    fieldPaths: string[];
+    argumentPaths: string[];
+    argumentValues: Record<string, Record<string, string>>;
+};

package/lib/graphQlQueryParser.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGraphQlSelectionPaths = void 0;
+function parseGraphQlSelectionPaths(text) {
+    if (!text)
+        return { fieldPaths: [], argumentPaths: [], argumentValues: {} };
+    const cleaned = text.replace(/#[^\n]*/g, '');
+    const tokens = cleaned.match(/\.\.\.|"(?:[^"\\]|\\.)*"|[A-Za-z_][A-Za-z0-9_]*|\$[A-Za-z_][A-Za-z0-9_]*|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|[@{}()\[\],!:$]/g) || [];
+    const startIndex = tokens.indexOf('{');
+    if (startIndex === -1)
+        return { fieldPaths: [], argumentPaths: [], argumentValues: {} };
+    const result = parseSelectionSet(tokens, startIndex, []);
+    return {
+        fieldPaths: result.fieldPaths.map(parts => parts.join('.')),
+        argumentPaths: result.argumentPaths.map(parts => parts.join('.')),
+        argumentValues: result.argumentValues,
+    };
+}
+exports.parseGraphQlSelectionPaths = parseGraphQlSelectionPaths;
+function parseArgumentValue(tokens, startIndex) {
+    const valueTokens = [];
+    let index = startIndex;
+    let parenthesesDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (token === '(') {
+            parenthesesDepth += 1;
+            valueTokens.push(token);
+            index += 1;
+            continue;
+        }
+        if (token === '[') {
+            bracketDepth += 1;
+            valueTokens.push(token);
+            index += 1;
+            continue;
+        }
+        if (token === '{') {
+            braceDepth += 1;
+            valueTokens.push(token);
+            index += 1;
+            continue;
+        }
+        if (token === ')') {
+            if (parenthesesDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+                break;
+            }
+            parenthesesDepth -= 1;
+            valueTokens.push(token);
+            index += 1;
+            continue;
+        }
+        if (token === ']') {
+            if (bracketDepth === 0)
+                break;
+            bracketDepth -= 1;
+            valueTokens.push(token);
+            index += 1;
+            continue;
+        }
+        if (token === '}') {
+            if (braceDepth === 0)
+                break;
+            braceDepth -= 1;
+            valueTokens.push(token);
+            index += 1;
+            continue;
+        }
+        if (token === ',' && parenthesesDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+            break;
+        }
+        valueTokens.push(token);
+        index += 1;
+    }
+    return {
+        value: valueTokens.join(''),
+        endIndex: index,
+    };
+}
+function parseArgumentsFromField(tokens, startIndex) {
+    const args = [];
+    let index = startIndex;
+    if (tokens[index] !== '(') {
+        return { arguments: args, endIndex: index };
+    }
+    let depth = 1;
+    index += 1;
+    while (index < tokens.length && depth > 0) {
+        if (tokens[index] === '(')
+            depth += 1;
+        if (tokens[index] === ')')
+            depth -= 1;
+        // Look for argument names (identifier followed by colon) and their values
+        if (depth > 0 && /^[A-Za-z_]/.test(tokens[index]) && tokens[index + 1] === ':') {
+            const argumentName = tokens[index];
+            const { value, endIndex } = parseArgumentValue(tokens, index + 2);
+            args.push({ name: argumentName, value });
+            index = endIndex;
+            if (tokens[index] === ',') {
+                index += 1;
+            }
+        }
+        else {
+            index += 1;
+        }
+    }
+    return { arguments: args, endIndex: index };
+}
+function parseSelectionSet(tokens, startIndex, prefix) {
+    const fieldPaths = [];
+    const argumentPaths = [];
+    const argumentValues = {};
+    let index = startIndex + 1;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (token === '}') {
+            return { fieldPaths, argumentPaths, argumentValues, index: index + 1 };
+        }
+        if (token === '...') {
+            index += 1;
+            if (tokens[index] === 'on') {
+                index += 2;
+            }
+            while (index < tokens.length && tokens[index] !== '{' && tokens[index] !== '}') {
+                index += 1;
+            }
+            if (tokens[index] === '{') {
+                const frag = parseSelectionSet(tokens, index, prefix);
+                fieldPaths.push(...frag.fieldPaths);
+                argumentPaths.push(...frag.argumentPaths);
+                for (const [fieldPath, values] of Object.entries(frag.argumentValues)) {
+                    argumentValues[fieldPath] = {
+                        ...(argumentValues[fieldPath] || {}),
+                        ...values,
+                    };
+                }
+                index = frag.index;
+                continue;
+            }
+            continue;
+        }
+        if (/^[A-Za-z_]/.test(token)) {
+            let fieldName = token;
+            if (tokens[index + 1] === ':' && /^[A-Za-z_]/.test(tokens[index + 2] || '')) {
+                fieldName = tokens[index + 2];
+                index += 3;
+            }
+            else {
+                index += 1;
+            }
+            // Parse arguments if present
+            const { arguments: args, endIndex: argsEndIndex } = parseArgumentsFromField(tokens, index);
+            index = argsEndIndex;
+            // Add argument paths for this field
+            const currentFieldPath = [...prefix, fieldName].join('.');
+            for (const arg of args) {
+                argumentPaths.push([...prefix, fieldName, arg.name]);
+                if (!argumentValues[currentFieldPath]) {
+                    argumentValues[currentFieldPath] = {};
+                }
+                argumentValues[currentFieldPath][arg.name] = arg.value;
+            }
+            while (tokens[index] === '@') {
+                index += 2;
+                if (tokens[index] === '(') {
+                    let depth = 1;
+                    index += 1;
+                    while (index < tokens.length && depth > 0) {
+                        if (tokens[index] === '(')
+                            depth += 1;
+                        if (tokens[index] === ')')
+                            depth -= 1;
+                        index += 1;
+                    }
+                }
+            }
+            if (tokens[index] === '{') {
+                const nested = parseSelectionSet(tokens, index, [...prefix, fieldName]);
+                if (nested.fieldPaths.length > 0) {
+                    fieldPaths.push(...nested.fieldPaths);
+                }
+                else {
+                    fieldPaths.push([...prefix, fieldName]);
+                }
+                argumentPaths.push(...nested.argumentPaths);
+                for (const [fieldPath, values] of Object.entries(nested.argumentValues)) {
+                    argumentValues[fieldPath] = {
+                        ...(argumentValues[fieldPath] || {}),
+                        ...values,
+                    };
+                }
+                index = nested.index;
+            }
+            else {
+                fieldPaths.push([...prefix, fieldName]);
+            }
+            continue;
+        }
+        index += 1;
+    }
+    return { fieldPaths, argumentPaths, argumentValues, index };
+}

package/lib/graphQlVariables.d.ts

@@ -0,0 +1,6 @@
+export type GraphQlVariableDefinition = {
+    name: string;
+    type: string;
+};
+export declare function extractGraphQlVariableDefinitions(text: string): GraphQlVariableDefinition[];
+export declare function convertGraphQlVariablesForRequest(queryText: string, rawVariables?: Record<string, string>): Record<string, any>;

package/lib/graphQlVariables.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertGraphQlVariablesForRequest = exports.extractGraphQlVariableDefinitions = void 0;
+function extractGraphQlVariableDefinitions(text) {
+    if (!text)
+        return [];
+    const cleaned = text.replace(/#[^\n]*/g, '');
+    const regex = /\$([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^=,)\n]+)/g;
+    const names = new Set();
+    const definitions = [];
+    let match = null;
+    while ((match = regex.exec(cleaned))) {
+        const name = match[1];
+        if (names.has(name))
+            continue;
+        names.add(name);
+        definitions.push({
+            name,
+            type: match[2].trim(),
+        });
+    }
+    return definitions;
+}
+exports.extractGraphQlVariableDefinitions = extractGraphQlVariableDefinitions;
+function unwrapNonNull(typeText) {
+    let current = (typeText || '').trim();
+    while (current.endsWith('!')) {
+        current = current.slice(0, -1).trim();
+    }
+    return current;
+}
+function isListType(typeText) {
+    const unwrapped = unwrapNonNull(typeText);
+    return unwrapped.startsWith('[') && unwrapped.endsWith(']');
+}
+function getInnerListType(typeText) {
+    const unwrapped = unwrapNonNull(typeText);
+    if (!(unwrapped.startsWith('[') && unwrapped.endsWith(']')))
+        return unwrapped;
+    return unwrapped.slice(1, -1).trim();
+}
+function getBaseType(typeText) {
+    let current = unwrapNonNull(typeText);
+    while (current.startsWith('[') && current.endsWith(']')) {
+        current = current.slice(1, -1).trim();
+        current = unwrapNonNull(current);
+    }
+    return current;
+}
+function parseJsonIfPossible(raw) {
+    const trimmed = (raw || '').trim();
+    if (!trimmed)
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch (_a) {
+        return raw;
+    }
+}
+function toInt(raw) {
+    const trimmed = (raw || '').trim();
+    if (!trimmed)
+        return null;
+    const num = Number(trimmed);
+    if (!Number.isFinite(num))
+        return null;
+    return Math.trunc(num);
+}
+function toFloat(raw) {
+    const trimmed = (raw || '').trim();
+    if (!trimmed)
+        return null;
+    const num = Number(trimmed);
+    if (!Number.isFinite(num))
+        return null;
+    return num;
+}
+function toBoolean(raw) {
+    const lowered = (raw || '').trim().toLowerCase();
+    if (!lowered)
+        return null;
+    if (['true', '1', 'yes', 'y', 'on'].includes(lowered))
+        return true;
+    if (['false', '0', 'no', 'n', 'off'].includes(lowered))
+        return false;
+    return null;
+}
+function convertByGraphQlTypeValue(raw, graphQlType) {
+    if (raw == null)
+        return null;
+    if (isListType(graphQlType)) {
+        const innerType = getInnerListType(graphQlType);
+        const parsed = typeof raw === 'string' ? parseJsonIfPossible(raw) : raw;
+        const arrayValue = Array.isArray(parsed) ? parsed : [parsed];
+        return arrayValue.map(item => convertByGraphQlTypeValue(item, innerType));
+    }
+    const baseType = getBaseType(graphQlType);
+    const stringValue = typeof raw === 'string' ? raw : JSON.stringify(raw);
+    if (baseType === 'Int')
+        return toInt(stringValue);
+    if (baseType === 'Float')
+        return toFloat(stringValue);
+    if (baseType === 'Boolean')
+        return toBoolean(stringValue);
+    if (baseType === 'String' || baseType === 'ID')
+        return String(raw);
+    if (typeof raw === 'string') {
+        return parseJsonIfPossible(raw);
+    }
+    return raw;
+}
+function convertGraphQlVariablesForRequest(queryText, rawVariables = {}) {
+    var _a;
+    const definitions = extractGraphQlVariableDefinitions(queryText || '');
+    const next = {};
+    for (const definition of definitions) {
+        const raw = (_a = rawVariables === null || rawVariables === void 0 ? void 0 : rawVariables[definition.name]) !== null && _a !== void 0 ? _a : '';
+        next[definition.name] = convertByGraphQlTypeValue(raw, definition.type);
+    }
+    return next;
+}
+exports.convertGraphQlVariablesForRequest = convertGraphQlVariablesForRequest;

package/lib/graphqlExplorer.d.ts

@@ -0,0 +1,26 @@
+import type { GraphQLIntrospectionResult } from './graphqlIntrospection';
+export type GraphQLExplorerOperationType = 'query' | 'mutation' | 'subscription';
+export interface GraphQLExplorerFieldNode {
+    name: string;
+    description?: string;
+    typeName: string;
+    typeDisplay: string;
+    isLeaf: boolean;
+    isArgument?: boolean;
+    arguments?: GraphQLExplorerFieldNode[];
+    children?: GraphQLExplorerFieldNode[];
+}
+export interface GraphQLExplorerOperation {
+    operationType: GraphQLExplorerOperationType;
+    rootTypeName: string;
+    fields: GraphQLExplorerFieldNode[];
+}
+interface GraphQLExplorerOptions {
+    maxDepth?: number;
+}
+export declare function buildGraphQlExplorerOperations(introspectionResult: GraphQLIntrospectionResult, options?: GraphQLExplorerOptions): GraphQLExplorerOperation[];
+export declare function buildGraphQlQueryText(operationType: GraphQLExplorerOperationType, selectionPaths: string[], options?: {
+    operationName?: string;
+    indent?: string;
+}): string;
+export {};

package/lib/graphqlExplorer.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraphQlQueryText = exports.buildGraphQlExplorerOperations = void 0;
+const DEFAULT_MAX_DEPTH = 2;
+function getTypeDisplay(typeRef) {
+    if (!typeRef)
+        return 'Unknown';
+    if (typeRef.kind === 'NON_NULL')
+        return `${getTypeDisplay(typeRef.ofType)}!`;
+    if (typeRef.kind === 'LIST')
+        return `[${getTypeDisplay(typeRef.ofType)}]`;
+    return typeRef.name || 'Unknown';
+}
+function unwrapNamedType(typeRef) {
+    if (!typeRef)
+        return null;
+    if (typeRef.kind === 'NON_NULL' || typeRef.kind === 'LIST')
+        return unwrapNamedType(typeRef.ofType);
+    return typeRef;
+}
+function buildTypeMap(types) {
+    return new Map(types.map(type => [type.name, type]));
+}
+function isCompositeType(type) {
+    return (type === null || type === void 0 ? void 0 : type.kind) === 'OBJECT' || (type === null || type === void 0 ? void 0 : type.kind) === 'INTERFACE';
+}
+function buildFieldNode(field, typeMap, depth, maxDepth, visitedTypes) {
+    const namedType = unwrapNamedType(field.type);
+    const typeDef = (namedType === null || namedType === void 0 ? void 0 : namedType.name) ? typeMap.get(namedType.name) : undefined;
+    const composite = isCompositeType(typeDef);
+    const nextVisited = new Set(visitedTypes);
+    if (typeDef === null || typeDef === void 0 ? void 0 : typeDef.name) {
+        nextVisited.add(typeDef.name);
+    }
+    let children;
+    if (composite && depth < maxDepth && (typeDef === null || typeDef === void 0 ? void 0 : typeDef.fields) && !visitedTypes.has(typeDef.name)) {
+        children = typeDef.fields.map(childField => buildFieldNode(childField, typeMap, depth + 1, maxDepth, nextVisited));
+    }
+    return {
+        name: field.name,
+        description: field.description,
+        typeName: (namedType === null || namedType === void 0 ? void 0 : namedType.name) || 'Unknown',
+        typeDisplay: getTypeDisplay(field.type),
+        isLeaf: !composite || !children || children.length === 0,
+        children,
+    };
+}
+function buildOperationFields(rootTypeName, types, maxDepth) {
+    const typeMap = buildTypeMap(types);
+    const rootType = typeMap.get(rootTypeName);
+    if (!(rootType === null || rootType === void 0 ? void 0 : rootType.fields))
+        return [];
+    return rootType.fields.map(field => buildFieldNode(field, typeMap, 1, maxDepth, new Set([rootTypeName])));
+}
+function buildGraphQlExplorerOperations(introspectionResult, options = {}) {
+    var _a, _b, _c, _d;
+    const { __schema } = introspectionResult || {};
+    if (!(__schema === null || __schema === void 0 ? void 0 : __schema.types))
+        return [];
+    const maxDepth = (_a = options.maxDepth) !== null && _a !== void 0 ? _a : DEFAULT_MAX_DEPTH;
+    const operations = [];
+    if ((_b = __schema.queryType) === null || _b === void 0 ? void 0 : _b.name) {
+        operations.push({
+            operationType: 'query',
+            rootTypeName: __schema.queryType.name,
+            fields: buildOperationFields(__schema.queryType.name, __schema.types, maxDepth),
+        });
+    }
+    if ((_c = __schema.mutationType) === null || _c === void 0 ? void 0 : _c.name) {
+        operations.push({
+            operationType: 'mutation',
+            rootTypeName: __schema.mutationType.name,
+            fields: buildOperationFields(__schema.mutationType.name, __schema.types, maxDepth),
+        });
+    }
+    if ((_d = __schema.subscriptionType) === null || _d === void 0 ? void 0 : _d.name) {
+        operations.push({
+            operationType: 'subscription',
+            rootTypeName: __schema.subscriptionType.name,
+            fields: buildOperationFields(__schema.subscriptionType.name, __schema.types, maxDepth),
+        });
+    }
+    return operations;
+}
+exports.buildGraphQlExplorerOperations = buildGraphQlExplorerOperations;
+function buildGraphQlQueryText(operationType, selectionPaths, options = {}) {
+    var _a, _b;
+    const indent = (_a = options.indent) !== null && _a !== void 0 ? _a : '  ';
+    const opName = (_b = options.operationName) === null || _b === void 0 ? void 0 : _b.trim();
+    const tree = new Map();
+    for (const path of selectionPaths) {
+        if (!path)
+            continue;
+        const parts = path.split('.').filter(Boolean);
+        let node = tree;
+        for (const part of parts) {
+            if (!node.has(part)) {
+                node.set(part, new Map());
+            }
+            node = node.get(part);
+        }
+    }
+    const renderTree = (node, level) => {
+        const lines = [];
+        for (const [name, children] of node.entries()) {
+            if (children.size === 0) {
+                lines.push(`${indent.repeat(level)}${name}`);
+            }
+            else {
+                lines.push(`${indent.repeat(level)}${name} {`);
+                lines.push(...renderTree(children, level + 1));
+                lines.push(`${indent.repeat(level)}}`);
+            }
+        }
+        return lines;
+    };
+    const header = opName ? `${operationType} ${opName}` : operationType;
+    const lines = [`${header} {`];
+    if (tree.size > 0) {
+        lines.push(...renderTree(tree, 1));
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+exports.buildGraphQlQueryText = buildGraphQlQueryText;