validate_connector

Instructions

Implementation Reference

• src/tools/solutionTools.ts:350-408 (handler)

  Handler for the validate_connector tool. Parses connector JSON, validates required fields (id, title), extracts tables using extractTablesFromConnector, and returns validation result with errors, warnings, and extracted tables.

  export const validateConnectorTool = {
    name: 'validate_connector',
    description: 'Validate a connector JSON definition and extract tables',
    inputSchema: z.object({
      connector_json: z.string().describe('Connector JSON content to validate'),
    }),
    execute: async (args: { connector_json: string }): Promise<ValidationResult> => {
      const errors: string[] = [];
      const warnings: string[] = [];
      const extractedTables: string[] = [];
  
      // Try to parse JSON
      const parseResult = parseJsonTolerant(args.connector_json);
  
      if (parseResult.error || !parseResult.data) {
        errors.push(parseResult.error || 'Failed to parse JSON');
        return { isValid: false, errors, warnings, extractedTables };
      }
  
      const connector = parseResult.data;
  
      // Validate required fields
      if (!connector.id) {
        errors.push('Missing required field: id');
      }
  
      if (!connector.title) {
        warnings.push('Missing recommended field: title');
      }
  
      // Extract tables
      try {
        const extraction = extractTablesFromConnector(connector);
  
        extraction.tables.forEach((_, tableName) => {
          extractedTables.push(tableName);
        });
  
        if (extractedTables.length === 0 && extraction.parserReferences.size === 0) {
          warnings.push('No table references found in connector definition');
        }
  
        if (extraction.parserReferences.size > 0) {
          warnings.push(
            `Parser references found (not resolved): ${Array.from(extraction.parserReferences).join(', ')}`
          );
        }
      } catch (error) {
        errors.push(`Error extracting tables: ${error}`);
      }
  
      return {
        isValid: errors.length === 0,
        errors,
        warnings,
        extractedTables,
      };
    },
  };

• src/types/index.ts:158-163 (schema)

  Type definition for the validation result returned by validate_connector tool.

  export interface ValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    extractedTables: string[];
  }

• src/tools/solutionTools.ts:410-417 (registration)

  Registration of validateConnectorTool in the solutionTools array.

  export const solutionTools = [
    analyzeSolutionsTool,
    getConnectorTablesTool,
    searchSolutionsTool,
    getSolutionDetailsTool,
    listTablesTool,
    validateConnectorTool,
  ];

• src/loaders/jsonParser.ts:14-51 (helper)

  Helper used by validate_connector to parse connector JSON with tolerance for comments and trailing commas.

  export function parseJsonTolerant<T = any>(content: string): JsonParseResult<T> {
    // Strategy 1: Standard JSON.parse
    try {
      const data = JSON.parse(content);
      return { data };
    } catch (error) {
      // Continue to fallback strategies
    }
  
    // Strategy 2: Strip JavaScript-style comments (preserving URLs)
    try {
      const withoutComments = stripComments(content);
      const data = JSON.parse(withoutComments);
      return { data };
    } catch (error) {
      // Continue to fallback strategies
    }
  
    // Strategy 3: Remove trailing commas
    try {
      const withoutTrailingCommas = removeTrailingCommas(content);
      const data = JSON.parse(withoutTrailingCommas);
      return { data };
    } catch (error) {
      // Continue to fallback strategies
    }
  
    // Strategy 4: Combined - strip comments AND remove trailing commas
    try {
      const cleaned = removeTrailingCommas(stripComments(content));
      const data = JSON.parse(cleaned);
      return { data };
    } catch (error) {
      return {
        error: `Failed to parse JSON after all attempts: ${error}`,
      };
    }
  }

• src/loaders/tableExtractor.ts:23-107 (helper)

  Helper used by validate_connector to extract tables from the connector definition using 6 detection methods.

  export function extractTablesFromConnector(
    connector: ConnectorDefinition
  ): ExtractionResult {
    const tables = new Map<string, string>();
    const parserReferences = new Set<string>();
    const variables: Record<string, string> = {};
  
    // Extract ARM template variables first
    extractVariables(connector, variables);
  
    // Method 1: graphQueries.{index}.baseQuery
    if (connector.graphQueries) {
      connector.graphQueries.forEach((query, index) => {
        if (query.baseQuery) {
          const extracted = extractTablesFromQuery(query.baseQuery, variables);
          extracted.forEach((table) => {
            const method = `graphQueries.${index}.baseQuery`;
            recordTable(tables, table, method, parserReferences);
          });
        }
      });
    }
  
    // Method 2: sampleQueries.{index}.query
    if (connector.sampleQueries) {
      connector.sampleQueries.forEach((query, index) => {
        if (query.query) {
          const extracted = extractTablesFromQuery(query.query, variables);
          extracted.forEach((table) => {
            const method = `sampleQueries.${index}.query`;
            recordTable(tables, table, method, parserReferences);
          });
        }
      });
    }
  
    // Method 3: dataTypes.{index}.lastDataReceivedQuery
    if (connector.dataTypes) {
      connector.dataTypes.forEach((dataType, index) => {
        if (dataType.lastDataReceivedQuery) {
          const extracted = extractTablesFromQuery(
            dataType.lastDataReceivedQuery,
            variables
          );
          extracted.forEach((table) => {
            const method = `dataTypes.${index}.lastDataReceivedQuery`;
            recordTable(tables, table, method, parserReferences);
          });
        }
      });
    }
  
    // Method 4: connectivityCriterias.{index}.value
    if (connector.connectivityCriterias) {
      connector.connectivityCriterias.forEach((criteria, index) => {
        if (criteria.value) {
          const values = Array.isArray(criteria.value)
            ? criteria.value
            : [criteria.value];
  
          values.forEach((value) => {
            if (typeof value === 'string') {
              const extracted = extractTablesFromQuery(value, variables);
              extracted.forEach((table) => {
                const method = `connectivityCriterias.${index}.value`;
                recordTable(tables, table, method, parserReferences);
              });
            }
          });
        }
      });
    }
  
    // Method 5: ARM template logAnalyticsTableId variable
    if (variables.logAnalyticsTableId) {
      const method = 'variables.logAnalyticsTableId';
      recordTable(tables, variables.logAnalyticsTableId, method, parserReferences);
    }
  
    // Method 6: Parser function references
    // Note: Actual parser resolution happens in parserResolver.ts
    // Here we just identify potential parser references
  
    return { tables, parserReferences, variables };
  }