!functions

Implementation Reference

• src/index.ts:189-218 (handler)

  The handler function for the '!functions' tool. It checks if a database is connected, calls dbService.getFunctions() to retrieve functions, stringifies the result as JSON, and handles errors.

  server.tool(
    "!functions",
    {},
    async () => {
      if (!dbService) {
        return {
          content: [{ type: "text", text: "You must connect to a database first!" }],
          isError: true,
        };
      }
  
      try {
        const functions = await dbService.getFunctions();
        return {
          content: [
            {
              type: "text",
              text: JSON.stringify(functions, null, 2),
            },
          ],
        };
      } catch (error: unknown) {
        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
        return {
          content: [{ type: "text", text: `Failed to get function information: ${errorMessage}` }],
          isError: true,
        };
      }
    }
  );

• src/services/database.ts:129-176 (helper)

  Core implementation in DatabaseService.getFunctions() that executes database-specific queries to retrieve stored functions from PostgreSQL, MySQL, or returns empty for Firestore.

  async getFunctions(): Promise<FunctionInfo[]> {
      switch (this.config.type) {
          case 'postgres': {
              const query = `
                  SELECT 
                      p.proname as name,
                      l.lanname as language,
                      pg_get_function_result(p.oid) as "returnType",
                      pg_get_function_arguments(p.oid) as arguments,
                      pg_get_functiondef(p.oid) as definition
                  FROM pg_proc p
                  JOIN pg_namespace n ON p.pronamespace = n.oid
                  JOIN pg_language l ON p.prolang = l.oid
                  WHERE n.nspname = 'public';
              `;
              const result = await this.postgresClient!.query(query);
              return result.rows;
          }
          case 'mysql': {
              const [rows] = await this.mysqlConnection!.query(`
                  SELECT 
                      ROUTINE_NAME as name,
                      'SQL' as language,
                      DTD_IDENTIFIER as returnType,
                      CONCAT_WS(', ', 
                          GROUP_CONCAT(
                              CONCAT(PARAMETER_NAME, ' ', DATA_TYPE)
                              ORDER BY ORDINAL_POSITION
                          )
                      ) as arguments,
                      ROUTINE_DEFINITION as definition
                  FROM information_schema.ROUTINES r
                  LEFT JOIN information_schema.PARAMETERS p
                      ON r.SPECIFIC_NAME = p.SPECIFIC_NAME
                  WHERE r.ROUTINE_SCHEMA = DATABASE()
                      AND r.ROUTINE_TYPE = 'FUNCTION'
                  GROUP BY r.SPECIFIC_NAME;
              `);
              return rows;
          }
          case 'firestore': {
              // Firestore does not support stored functions
              return [];
          }
          default:
              return [];
      }
  }

• src/types/database.ts:39-45 (schema)

  TypeScript interface defining the structure of function information returned by the tool.

  export interface FunctionInfo {
      name: string;
      language: string;
      returnType: string;
      arguments: string;
      definition: string;
  } 

• src/index.ts:189-218 (registration)

  Registration of the '!functions' tool on the MCP server using server.tool() with empty input schema.

  server.tool(
    "!functions",
    {},
    async () => {
      if (!dbService) {
        return {
          content: [{ type: "text", text: "You must connect to a database first!" }],
          isError: true,
        };
      }
  
      try {
        const functions = await dbService.getFunctions();
        return {
          content: [
            {
              type: "text",
              text: JSON.stringify(functions, null, 2),
            },
          ],
        };
      } catch (error: unknown) {
        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
        return {
          content: [{ type: "text", text: `Failed to get function information: ${errorMessage}` }],
          isError: true,
        };
      }
    }
  );