Step by Step Guide to Building a Monday.com API Integration in Go

Aug 3, 2024 • 6 minute read

Introduction

Hey there, fellow developer! Ready to supercharge your workflow with Monday.com's API? Let's dive into building a slick integration using Go. We'll cover everything you need to know to get up and running quickly.

Prerequisites

Before we jump in, make sure you've got:

Go installed on your machine
A Monday.com account with an API key
Some experience with Go and RESTful APIs

Got all that? Great! Let's get coding.

Setting up the project

First things first, let's set up our Go project:

mkdir monday-api-integration
cd monday-api-integration
go mod init github.com/yourusername/monday-api-integration

Now, let's grab the HTTP client we'll be using:

go get github.com/go-resty/resty/v2

Authentication

Alright, time to get that API key from Monday.com. Head over to your account settings and generate one if you haven't already.

Now, let's set up authentication in our Go code:

package main

import (
    "github.com/go-resty/resty/v2"
)

const apiKey = "your-api-key-here"
const baseURL = "https://api.monday.com/v2"

func main() {
    client := resty.New()
    client.SetHeader("Authorization", apiKey)
    client.SetHeader("Content-Type", "application/json")
    client.SetBaseURL(baseURL)
}

Making API requests

Monday.com's API is GraphQL-based, so we'll be sending all our requests to a single endpoint. Let's create a function to handle our API calls:

func makeRequest(query string, variables map[string]interface{}) ([]byte, error) {
    resp, err := client.R().
        SetBody(map[string]interface{}{
            "query":     query,
            "variables": variables,
        }).
        Post("")

    if err != nil {
        return nil, err
    }

    return resp.Body(), nil
}

Handling responses

Now let's parse those JSON responses:

import "encoding/json"

type Board struct {
    ID   string `json:"id"`
    Name string `json:"name"`
}

func getBoards() ([]Board, error) {
    query := `query { boards { id name } }`
    resp, err := makeRequest(query, nil)
    if err != nil {
        return nil, err
    }

    var result struct {
        Data struct {
            Boards []Board `json:"boards"`
        } `json:"data"`
    }

    err = json.Unmarshal(resp, &result)
    if err != nil {
        return nil, err
    }

    return result.Data.Boards, nil
}

Building core functionalities

Let's implement some key operations:

func createItem(boardID, itemName string) (string, error) {
    query := `mutation ($boardID: ID!, $itemName: String!) {
        create_item (board_id: $boardID, item_name: $itemName) {
            id
        }
    }`
    variables := map[string]interface{}{
        "boardID":  boardID,
        "itemName": itemName,
    }

    resp, err := makeRequest(query, variables)
    if err != nil {
        return "", err
    }

    var result struct {
        Data struct {
            CreateItem struct {
                ID string `json:"id"`
            } `json:"create_item"`
        } `json:"data"`
    }

    err = json.Unmarshal(resp, &result)
    if err != nil {
        return "", err
    }

    return result.Data.CreateItem.ID, nil
}

Testing the integration

Don't forget to test your code! Here's a quick example:

func TestGetBoards(t *testing.T) {
    boards, err := getBoards()
    if err != nil {
        t.Fatalf("Error getting boards: %v", err)
    }
    if len(boards) == 0 {
        t.Fatal("No boards returned")
    }
}

Best practices and optimization

Remember to implement rate limiting to stay within Monday.com's API limits. You might also want to add some caching to improve performance.

Conclusion

And there you have it! You've just built a Monday.com API integration in Go. Pretty cool, right? This is just the beginning - there's so much more you can do with this integration. Why not try implementing more complex queries or setting up webhooks for real-time updates?

Resources

Happy coding, and may your Mondays be ever productive!