Microsoft Graph SDK for Go

Authentication is handled by providing an AuthenticationProvider to a GraphRequestAdapter.

A common method is using the DeviceCodeCredential from the azidentity package, which implements the device code flow.

Important: To use device code flow, you must enable Allow public client flows in your app registration under the Authentication section in the Azure portal.

import (
    azidentity "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "context"
    "fmt"
)

// Example using DeviceCodeCredential
cred, err := azidentity.NewDeviceCodeCredential(&azidentity.DeviceCodeCredentialOptions{
    TenantID: "<the tenant id from your app registration>",
    ClientID: "<the client id from your app registration>",
    UserPrompt: func(ctx context.Context, message azidentity.DeviceCodeMessage) error {
        fmt.Println(message.Message)
        return nil
    },
})

When requesting collections (like Users), the results may be split across multiple pages. To retrieve all items, use the PageIterator from the msgraphcore package. This avoids manual handling of next links.

To use it, you need:

1. The initial collection response.
2. The client's adapter (client.GetAdapter()).
3. A discriminator function to create the collection response from the value (e.g., models.CreateUserCollectionResponseFromDiscriminatorValue).

import (
    msgraphcore "github.com/microsoftgraph/msgraph-sdk-go-core"
    "github.com/microsoftgraph/msgraph-sdk-go/users"
    "github.com/microsoftgraph/msgraph-sdk-go/models"
    "github.com/microsoftgraph/msgraph-sdk-go/models/odataerrors"
)

// 1. Get the initial result
result, err := client.Users().Get(context.Background(), nil)
if err != nil {
    fmt.Printf("Error getting users: %v\n", err)
    return err
}

// 2. Initialize the PageIterator
pageIterator, err := msgraphcore.NewPageIterator[models.Userable](result, client.GetAdapter(), models.CreateUserCollectionResponseFromDiscriminatorValue)

// 3. Iterate through all pages
err = pageIterator.Iterate(context.Background(), func(user models.Userable) bool {
    fmt.Printf("%s\n", *user.GetDisplayName())
    // Return true to continue to the next item/page
    return true
})

Once authenticated, you can navigate the Graph API using the client's fluent API. To retrieve the current user's drive, use client.Me().Drive().Get().

import (
    "context"
    "fmt"
    "github.com/microsoftgraph/msgraph-sdk-go/models/odataerrors"
)

// Retrieve the user's drive
result, err := client.Me().Drive().Get(context.Background(), nil)
if err != nil {
    fmt.Printf("Error getting the drive: %v\n", err)
    printOdataError(err)
}
fmt.Printf("Found Drive : %v\n", *result.GetId())

// Helper to handle OData errors
func printOdataError(err error) {
    switch err.(type) {
    case *odataerrors.ODataError:
        typed := err.(*odataerrors.ODataError)
        fmt.Printf("error:", typed.Error())
        if terr := typed.GetErrorEscaped(); terr != nil {
            fmt.Printf("code: %s", *terr.GetCode())
            fmt.Printf("msg: %s", *terr.GetMessage())
        }
    default:
        fmt.Printf("%T > error: %#v", err, err)
    }
}

The GraphBaseServiceClient acts as the primary entry point for interacting with various Microsoft Graph resources. It provides a set of methods, each returning a specific RequestBuilder (e.g., UsersRequestBuilder, SitesRequestBuilder, TeamsRequestBuilder). These request builders are used to construct and execute API requests against the corresponding Graph endpoints.

Commonly used resource accessors include:

• Users(): Manage user entities.
• Sites(): Manage site entities.
• Teams(): Manage team entities.
• Security(): Manage the security singleton.
• Search(): Manage the searchEntity singleton.
• Organization(): Manage organization entities.
• ServicePrincipals(): Manage service principal entities.

Some methods allow for specific filtering or targeting via parameters, such as UsersWithUserPrincipalName(userPrincipalName *string) or ServicePrincipalsWithAppId(appId *string).

// Example of accessing users and sites via the base service client
// (Assuming 'client' is an initialized *GraphBaseServiceClient)

// Access the users collection
usersRequestBuilder := client.Users()

// Access the sites collection
sitesRequestBuilder := client.Sites()

// Access a specific user collection by User Principal Name
userByUPN := client.UsersWithUserPrincipalName("user@example.com")