Go SDK (auris-go)

go get github.com/altovar-systems/auris-go

import auris "github.com/altovar-systems/auris-go"
 
client := auris.NewClient("https://auth.yourdomain.com", "your-client-id")

package main
 
import (
    "context"
    "fmt"
    "log"
 
    auris "github.com/altovar-systems/auris-go"
)
 
func main() {
    client := auris.NewClient("https://auth.yourdomain.com", "your-client-id")
 
    result, err := client.Login(context.Background(), "[email protected]", "password")
    if err != nil {
        log.Fatal(err)
    }
 
    fmt.Printf("Logged in as %s\n", result.User.Email)
    fmt.Printf("Access token: %s\n", result.AccessToken)
}

result, err := client.Login(ctx, "[email protected]", "password")
// result.AccessToken  string
// result.RefreshToken string
// result.User         auris.UserInfo

user, err := client.GetUser(ctx)
if err != nil {
    log.Fatal(err)
}
fmt.Println(user.ID, user.Email, user.Roles)

token, err := client.GetAccessToken(ctx)
// Use in Authorization: Bearer <token> headers

result, err := client.RefreshToken(ctx, refreshToken)

token, err := client.GetM2MToken(ctx, "client-secret", []string{"read:users", "manage:roles"})
// token.AccessToken string
// token.ExpiresIn   int

// Send magic link email
err := client.LoginWithMagicLink(ctx, "[email protected]")
 
// Verify the token from the link URL
result, err := client.VerifyMagicLink(ctx, "token-from-url")

err := client.Logout(ctx)

mgmt, err := auris.NewManagementClient(
    ctx,
    "https://auth.yourdomain.com",
    "your-client-id",
    "your-client-secret",
)
if err != nil {
    log.Fatal(err)
}

// List users
users, err := mgmt.ListUsers(ctx)
 
// Get a single user
user, err := mgmt.GetUser(ctx, "user-id")
 
// Create a user
user, err := mgmt.CreateUser(ctx, map[string]interface{}{
    "email": "[email protected]",
    "name":  "New User",
})
 
// Delete a user
err = mgmt.DeleteUser(ctx, "user-id")
 
// Assign roles
err = mgmt.AssignRoles(ctx, "user-id", []string{"role-id-1", "role-id-2"})
 
// Remove roles
err = mgmt.RemoveRoles(ctx, "user-id", []string{"role-id-1"})

// List organizations
orgs, err := mgmt.ListOrganizations(ctx)
 
// Get an organization
org, err := mgmt.GetOrganization(ctx, "org-id")
 
// Create an organization
org, err := mgmt.CreateOrganization(ctx, map[string]interface{}{
    "name": "Acme Corp",
})
 
// Delete an organization
err = mgmt.DeleteOrganization(ctx, "org-id")
 
// List members
members, err := mgmt.ListMembers(ctx, "org-id")
 
// Add a member
err = mgmt.AddMember(ctx, "org-id", "user-id", "member")
 
// Remove a member
err = mgmt.RemoveMember(ctx, "org-id", "user-id")

roles, err := mgmt.ListRoles(ctx)

fga, err := auris.NewFgaClient(
    ctx,
    "https://auth.yourdomain.com",
    "your-client-id",
    "your-client-secret",
)
if err != nil {
    log.Fatal(err)
}

allowed, err := fga.CheckPermission(ctx, "user:alice", "read", "document:budget")
if err != nil {
    log.Fatal(err)
}
fmt.Println("Allowed:", allowed)

checks := []auris.PermissionCheck{
    {User: "user:alice", Relation: "read",  Object: "document:budget"},
    {User: "user:alice", Relation: "write", Object: "document:budget"},
}
results, err := fga.CheckPermissions(ctx, checks)

err = fga.TupleWrite(ctx, []auris.PermissionCheck{
    {User: "user:bob", Relation: "viewer", Object: "document:report"},
})

import (
    "io"
    "net/http"
 
    auris "github.com/altovar-systems/auris-go"
)
 
func webhookHandler(w http.ResponseWriter, r *http.Request) {
    body, err := io.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Bad request", http.StatusBadRequest)
        return
    }
 
    signature := r.Header.Get("X-Auris-Signature")
 
    if !auris.VerifyWebhookSignature(body, signature, "your-webhook-secret") {
        http.Error(w, "Invalid signature", http.StatusUnauthorized)
        return
    }
 
    // Process webhook event...
    w.WriteHeader(http.StatusOK)
}

import (
    "errors"
    "fmt"
 
    auris "github.com/altovar-systems/auris-go"
)
 
result, err := client.Login(ctx, email, password)
if err != nil {
    var aurisErr *auris.AurisError
    if errors.As(err, &aurisErr) {
        fmt.Printf("HTTP %d: %s\n", aurisErr.StatusCode, aurisErr.Message)
    } else {
        fmt.Println("Network error:", err)
    }
}