dbgate-rest 7.1.3-alpha.2

package/lib/graphqlIntrospection.d.ts

@@ -0,0 +1,56 @@
+import type { RestApiDefinition } from './restApiDef';
+import type { AxiosInstance } from 'axios';
+export interface GraphQLTypeRef {
+    kind: string;
+    name?: string;
+    ofType?: GraphQLTypeRef | null;
+}
+export interface GraphQLInputValue {
+    name: string;
+    description?: string;
+    type: GraphQLTypeRef;
+    defaultValue?: string;
+}
+export interface GraphQLField {
+    name: string;
+    description?: string;
+    type: GraphQLTypeRef;
+    args?: GraphQLInputValue[];
+}
+export interface GraphQLType {
+    kind: string;
+    name: string;
+    description?: string;
+    fields?: GraphQLField[];
+    inputFields?: GraphQLField[];
+    possibleTypes?: GraphQLTypeRef[];
+}
+export interface GraphQLIntrospectionResult {
+    __schema: {
+        types: GraphQLType[];
+        queryType?: {
+            name: string;
+        };
+        mutationType?: {
+            name: string;
+        };
+        subscriptionType?: {
+            name: string;
+        };
+    };
+}
+export declare function scoreFieldName(name: string): number;
+export declare function chooseUsefulNodeAttributes(nodeType: GraphQLType | undefined, typeMap: Map<string, GraphQLType>): string[];
+export declare function buildFirstTenArgs(field: GraphQLField, filterParamName?: string | null, filterValue?: string): string;
+export type GraphQLConnectionProjection = {
+    kind: 'edges';
+    nodeTypeName: string;
+    hasPageInfo: boolean;
+} | {
+    kind: 'listField';
+    listFieldName: string;
+    nodeTypeName: string;
+};
+export declare function detectConnectionProjection(field: GraphQLField, typeMap: Map<string, GraphQLType>): GraphQLConnectionProjection | null;
+export declare function extractRestApiDefinitionFromGraphQlIntrospectionResult(introspectionResult: GraphQLIntrospectionResult): RestApiDefinition;
+export declare function fetchGraphQLSchema(url: string, headers: Record<string, string>, axios: AxiosInstance, maxDepth?: number): Promise<GraphQLIntrospectionResult>;

package/lib/graphqlIntrospection.js

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchGraphQLSchema = exports.extractRestApiDefinitionFromGraphQlIntrospectionResult = exports.detectConnectionProjection = exports.buildFirstTenArgs = exports.chooseUsefulNodeAttributes = exports.scoreFieldName = void 0;
+const DEFAULT_INTROSPECTION_DEPTH = 6;
+function buildTypeRefSelection(depth) {
+    if (depth <= 0) {
+        return `
+            kind
+            name
+          `;
+    }
+    return `
+            kind
+            name
+            ofType {
+${buildTypeRefSelection(depth - 1)}
+            }
+          `;
+}
+function buildIntrospectionQuery(maxDepth) {
+    const typeRefSelection = buildTypeRefSelection(maxDepth);
+    return `
+  query IntrospectionQuery {
+    __schema {
+      types {
+        kind
+        name
+        description
+        fields {
+          name
+          description
+          type {
+${typeRefSelection}
+          }
+          args {
+            name
+            description
+            type {
+${typeRefSelection}
+            }
+            defaultValue
+          }
+        }
+        inputFields {
+          name
+          description
+          type {
+${typeRefSelection}
+          }
+        }
+      }
+      queryType {
+        name
+      }
+      mutationType {
+        name
+      }
+      subscriptionType {
+        name
+      }
+    }
+  }
+`;
+}
+function getTypeString(type) {
+    if (!type)
+        return 'Unknown';
+    if (type.kind === 'NON_NULL')
+        return getTypeString(type.ofType) + '!';
+    if (type.kind === 'LIST')
+        return '[' + getTypeString(type.ofType) + ']';
+    return type.name || 'Unknown';
+}
+function findType(types, name) {
+    return types.find(t => t.name === name);
+}
+function unwrapNamedTypeRef(typeRef) {
+    if (!typeRef)
+        return null;
+    if (typeRef.kind === 'NON_NULL' || typeRef.kind === 'LIST')
+        return unwrapNamedTypeRef(typeRef.ofType);
+    return typeRef;
+}
+function unwrapListTypeRef(typeRef) {
+    if (!typeRef)
+        return null;
+    if (typeRef.kind === 'NON_NULL')
+        return unwrapListTypeRef(typeRef.ofType);
+    if (typeRef.kind === 'LIST')
+        return unwrapNamedTypeRef(typeRef.ofType);
+    return null;
+}
+function buildTypeMap(types) {
+    return new Map((types || []).map(type => [type.name, type]));
+}
+function isScalarLikeField(field, typeMap) {
+    const namedType = unwrapNamedTypeRef(field.type);
+    if (!(namedType === null || namedType === void 0 ? void 0 : namedType.name))
+        return false;
+    const type = typeMap.get(namedType.name);
+    if (!type)
+        return namedType.kind === 'SCALAR' || namedType.kind === 'ENUM';
+    return type.kind === 'SCALAR' || type.kind === 'ENUM';
+}
+function scoreFieldName(name) {
+    const lowerName = (name || '').toLowerCase();
+    const exactOrder = [
+        'id',
+        'name',
+        'title',
+        'email',
+        'username',
+        'status',
+        'createdat',
+        'updatedat',
+        'type',
+        'code',
+        'key',
+    ];
+    const exactIndex = exactOrder.indexOf(lowerName);
+    if (exactIndex >= 0) {
+        return 500 - exactIndex;
+    }
+    if (lowerName.endsWith('id'))
+        return 300;
+    if (lowerName.includes('name'))
+        return 280;
+    if (lowerName.includes('title'))
+        return 260;
+    if (lowerName.includes('email'))
+        return 240;
+    if (lowerName.includes('status'))
+        return 220;
+    if (lowerName.includes('date') || lowerName.endsWith('at'))
+        return 200;
+    return 100;
+}
+exports.scoreFieldName = scoreFieldName;
+function chooseUsefulNodeAttributes(nodeType, typeMap) {
+    var _a;
+    if (!((_a = nodeType === null || nodeType === void 0 ? void 0 : nodeType.fields) === null || _a === void 0 ? void 0 : _a.length))
+        return ['__typename'];
+    const scalarFields = nodeType.fields.filter(field => isScalarLikeField(field, typeMap));
+    if (scalarFields.length === 0)
+        return ['__typename'];
+    return scalarFields
+        .map((field, index) => ({
+        field,
+        score: scoreFieldName(field.name),
+        index,
+    }))
+        .sort((left, right) => {
+        if (right.score !== left.score)
+            return right.score - left.score;
+        return left.index - right.index;
+    })
+        .slice(0, 10)
+        .map(item => item.field.name);
+}
+exports.chooseUsefulNodeAttributes = chooseUsefulNodeAttributes;
+function stringifyArgumentValue(argumentTypeRef, value) {
+    const namedType = unwrapNamedTypeRef(argumentTypeRef);
+    if (!(namedType === null || namedType === void 0 ? void 0 : namedType.name)) {
+        // Fallback: safely stringify as a JSON string literal
+        return JSON.stringify(String(value));
+    }
+    const typeName = namedType.name.toLowerCase();
+    if (typeName === 'int' || typeName === 'float') {
+        const numValue = typeof value === 'number' ? value : Number(value);
+        if (Number.isFinite(numValue)) {
+            return String(numValue);
+        }
+        // If the value cannot be parsed as a valid number, fall back to a quoted string
+        return JSON.stringify(String(value));
+    }
+    // For non-numeric types, safely serialize as a JSON string literal
+    return JSON.stringify(String(value));
+}
+function buildFirstTenArgs(field, filterParamName, filterValue) {
+    const args = field.args || [];
+    if (args.length === 0)
+        return '';
+    const argPairs = [];
+    // Add pagination argument
+    const candidates = ['first', 'limit', 'pagesize', 'perpage', 'take', 'size', 'count', 'maxresults'];
+    const paginationArg = args.find(item => candidates.includes((item.name || '').toLowerCase()));
+    if (paginationArg) {
+        argPairs.push(`${paginationArg.name}: ${stringifyArgumentValue(paginationArg.type, 10)}`);
+    }
+    // Add filter argument if provided
+    if (filterParamName && filterValue) {
+        const filterArg = args.find(item => item.name === filterParamName);
+        if (filterArg) {
+            argPairs.push(`${filterParamName}: ${stringifyArgumentValue(filterArg.type, filterValue)}`);
+        }
+    }
+    if (argPairs.length === 0)
+        return '';
+    return `(${argPairs.join(', ')})`;
+}
+exports.buildFirstTenArgs = buildFirstTenArgs;
+function detectConnectionProjection(field, typeMap) {
+    var _a, _b;
+    const fieldTypeRef = unwrapNamedTypeRef(field.type);
+    if (!(fieldTypeRef === null || fieldTypeRef === void 0 ? void 0 : fieldTypeRef.name))
+        return null;
+    const returnType = typeMap.get(fieldTypeRef.name);
+    if (!returnType || returnType.kind !== 'OBJECT' || !((_a = returnType.fields) === null || _a === void 0 ? void 0 : _a.length))
+        return null;
+    const edgesField = returnType.fields.find(item => item.name === 'edges');
+    if (edgesField) {
+        const edgeTypeRef = unwrapListTypeRef(edgesField.type);
+        if (edgeTypeRef === null || edgeTypeRef === void 0 ? void 0 : edgeTypeRef.name) {
+            const edgeType = typeMap.get(edgeTypeRef.name);
+            const nodeField = (_b = edgeType === null || edgeType === void 0 ? void 0 : edgeType.fields) === null || _b === void 0 ? void 0 : _b.find(item => item.name === 'node');
+            const nodeTypeRef = unwrapNamedTypeRef(nodeField === null || nodeField === void 0 ? void 0 : nodeField.type);
+            if (nodeTypeRef === null || nodeTypeRef === void 0 ? void 0 : nodeTypeRef.name) {
+                const hasPageInfo = !!returnType.fields.find(item => item.name === 'pageInfo');
+                return {
+                    kind: 'edges',
+                    nodeTypeName: nodeTypeRef.name,
+                    hasPageInfo,
+                };
+            }
+        }
+    }
+    const listFieldNames = ['nodes', 'items', 'results', 'data'];
+    for (const listFieldName of listFieldNames) {
+        const listField = returnType.fields.find(item => item.name === listFieldName);
+        if (!listField)
+            continue;
+        const listItemTypeRef = unwrapListTypeRef(listField.type);
+        if (!(listItemTypeRef === null || listItemTypeRef === void 0 ? void 0 : listItemTypeRef.name))
+            continue;
+        return {
+            kind: 'listField',
+            listFieldName,
+            nodeTypeName: listItemTypeRef.name,
+        };
+    }
+    return null;
+}
+exports.detectConnectionProjection = detectConnectionProjection;
+function buildConnectionQuery(field, typeMap) {
+    const projection = detectConnectionProjection(field, typeMap);
+    if (!projection)
+        return null;
+    const nodeType = typeMap.get(projection.nodeTypeName);
+    const selectedAttributes = chooseUsefulNodeAttributes(nodeType, typeMap);
+    const argsString = buildFirstTenArgs(field);
+    const attributeBlock = selectedAttributes.map(attr => `      ${attr}`).join('\n');
+    if (projection.kind === 'edges') {
+        const pageInfoBlock = projection.hasPageInfo
+            ? `
+    pageInfo {
+      hasNextPage
+      endCursor
+    }`
+            : '';
+        return `query {
+  ${field.name}${argsString} {
+    edges {
+      node {
+${attributeBlock}
+      }
+    }${pageInfoBlock}
+  }
+}`;
+    }
+    return `query {
+  ${field.name}${argsString} {
+    ${projection.listFieldName} {
+${attributeBlock}
+    }
+  }
+}`;
+}
+function buildConnectionEndpoints(types, rootTypeName) {
+    var _a;
+    if (!rootTypeName)
+        return [];
+    const rootType = findType(types, rootTypeName);
+    if (!((_a = rootType === null || rootType === void 0 ? void 0 : rootType.fields) === null || _a === void 0 ? void 0 : _a.length))
+        return [];
+    const typeMap = buildTypeMap(types);
+    const connectionEndpoints = [];
+    for (const field of rootType.fields) {
+        const connectionQuery = buildConnectionQuery(field, typeMap);
+        if (!connectionQuery)
+            continue;
+        connectionEndpoints.push({
+            name: field.name,
+            description: field.description || '',
+            fields: field.description,
+            connectionQuery,
+        });
+    }
+    return connectionEndpoints;
+}
+function buildOperationEndpoints(types, operationType, rootTypeName) {
+    if (!rootTypeName)
+        return [];
+    const rootType = findType(types, rootTypeName);
+    if (!rootType || !rootType.fields)
+        return [];
+    return rootType.fields.map(field => ({
+        name: field.name,
+        description: field.description || '',
+        fields: field.description,
+    }));
+}
+function extractRestApiDefinitionFromGraphQlIntrospectionResult(introspectionResult) {
+    var _a, _b, _c, _d;
+    const { __schema } = introspectionResult;
+    const categories = [];
+    // Connections (query fields returning connection-like payloads)
+    if ((_a = __schema.queryType) === null || _a === void 0 ? void 0 : _a.name) {
+        const connectionEndpoints = buildConnectionEndpoints(__schema.types, __schema.queryType.name);
+        if (connectionEndpoints.length > 0) {
+            categories.push({
+                name: 'Connections',
+                endpoints: connectionEndpoints.map(connection => ({
+                    method: 'POST',
+                    path: connection.name,
+                    summary: connection.description,
+                    description: connection.fields,
+                    parameters: [],
+                    connectionQuery: connection.connectionQuery,
+                })),
+            });
+        }
+    }
+    // Queries
+    if ((_b = __schema.queryType) === null || _b === void 0 ? void 0 : _b.name) {
+        const queryEndpoints = buildOperationEndpoints(__schema.types, 'OBJECT', __schema.queryType.name);
+        if (queryEndpoints.length > 0) {
+            categories.push({
+                name: 'Queries',
+                endpoints: queryEndpoints.map(q => ({
+                    method: 'POST',
+                    path: q.name,
+                    summary: q.description,
+                    description: q.fields,
+                    parameters: [],
+                })),
+            });
+        }
+    }
+    // Mutations
+    if ((_c = __schema.mutationType) === null || _c === void 0 ? void 0 : _c.name) {
+        const mutationEndpoints = buildOperationEndpoints(__schema.types, 'OBJECT', __schema.mutationType.name);
+        if (mutationEndpoints.length > 0) {
+            categories.push({
+                name: 'Mutations',
+                endpoints: mutationEndpoints.map(m => ({
+                    method: 'POST',
+                    path: m.name,
+                    summary: m.description,
+                    description: m.fields,
+                    parameters: [],
+                })),
+            });
+        }
+    }
+    // Subscriptions
+    if ((_d = __schema.subscriptionType) === null || _d === void 0 ? void 0 : _d.name) {
+        const subscriptionEndpoints = buildOperationEndpoints(__schema.types, 'OBJECT', __schema.subscriptionType.name);
+        if (subscriptionEndpoints.length > 0) {
+            categories.push({
+                name: 'Subscriptions',
+                endpoints: subscriptionEndpoints.map(s => ({
+                    method: 'POST',
+                    path: s.name,
+                    summary: s.description,
+                    description: s.fields,
+                    parameters: [],
+                })),
+            });
+        }
+    }
+    return {
+        categories,
+        servers: [],
+    };
+}
+exports.extractRestApiDefinitionFromGraphQlIntrospectionResult = extractRestApiDefinitionFromGraphQlIntrospectionResult;
+async function fetchGraphQLSchema(url, headers, axios, maxDepth = DEFAULT_INTROSPECTION_DEPTH) {
+    try {
+        const query = buildIntrospectionQuery(maxDepth);
+        const response = await axios.post(url, { query }, {
+            timeout: 10000,
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers,
+            },
+        });
+        if (response.data.errors) {
+            throw new Error(`GraphQL introspection error: ${JSON.stringify(response.data.errors)}`);
+        }
+        if (!response.data.data) {
+            throw new Error('Invalid introspection response: no data field');
+        }
+        return response.data.data;
+    }
+    catch (err) {
+        throw new Error(`DBGM-00312 Could not fetch GraphQL schema: ${err.message}`);
+    }
+}
+exports.fetchGraphQLSchema = fetchGraphQLSchema;

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+export * from './openApiDriver';
+export * from './oDataDriver';
+export * from './graphQlDriver';
+export * from './openApiAdapter';
+export * from './oDataAdapter';
+export * from './oDataMetadataParser';
+export * from './restApiExecutor';
+export * from './arrayify';
+export * from './graphqlIntrospection';
+export * from './graphqlExplorer';
+export * from './graphQlQueryParser';
+export * from './graphQlVariables';
+export * from './restAuthTools';

package/lib/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openApiDriver"), exports);
+__exportStar(require("./oDataDriver"), exports);
+__exportStar(require("./graphQlDriver"), exports);
+__exportStar(require("./openApiAdapter"), exports);
+__exportStar(require("./oDataAdapter"), exports);
+__exportStar(require("./oDataMetadataParser"), exports);
+__exportStar(require("./restApiExecutor"), exports);
+__exportStar(require("./arrayify"), exports);
+__exportStar(require("./graphqlIntrospection"), exports);
+__exportStar(require("./graphqlExplorer"), exports);
+__exportStar(require("./graphQlQueryParser"), exports);
+__exportStar(require("./graphQlVariables"), exports);
+__exportStar(require("./restAuthTools"), exports);

package/lib/oDataAdapter.d.ts

@@ -0,0 +1,33 @@
+import { RestApiDefinition } from './restApiDef';
+export type ODataServiceResource = {
+    name?: string;
+    kind?: string;
+    url?: string;
+};
+export type ODataServiceDocument = {
+    '@odata.context'?: string;
+    value?: ODataServiceResource[];
+};
+export interface ODataMetadataNavigationProperty {
+    name: string;
+    type?: string;
+    containsTarget: boolean;
+    nullable: boolean;
+}
+export interface ODataMetadataEntityType {
+    typeName: string;
+    fullTypeName: string;
+    keyProperties: string[];
+    stringProperties: string[];
+    navigationProperties: ODataMetadataNavigationProperty[];
+}
+export interface ODataMetadataEntitySet {
+    name: string;
+    entityType: string;
+    navigationBindings: Record<string, string>;
+}
+export interface ODataMetadataDocument {
+    entityTypes: Record<string, ODataMetadataEntityType>;
+    entitySets: Record<string, ODataMetadataEntitySet>;
+}
+export declare function analyseODataDefinition(doc: ODataServiceDocument, endpointUrl: string, metadataDocumentXml?: string | null): RestApiDefinition;