Añade compatibilidad con Directus 11.

client.go

@@ -15,7 +15,10 @@ type Client struct {
 	Collections        *ResourceClient[Collection, string]
 	CustomTranslations *ResourceClient[CustomTranslation, string]
 	Folders            *ResourceClient[Folder, string]
-	Roles              *ResourceClient[Role, string]
+	Roles              *clientRoles
+	rolesV10           *ResourceClient[roleV10, string]
+	rolesV11           *ResourceClient[roleV11, string]
+	Policies           *ResourceClient[Policy, string]
 	Users              *ResourceClient[User, string]
 	Presets            *ResourceClient[Preset, int64]
 	Operations         *ResourceClient[Operation, string]
@@ -65,7 +68,10 @@ func NewClient(instance string, token string, opts ...ClientOption) *Client {
 	client.Collections = NewResourceClient[Collection, string](client, "collections")
 	client.CustomTranslations = NewResourceClient[CustomTranslation, string](client, "translations")
 	client.Folders = NewResourceClient[Folder, string](client, "folders")
-	client.Roles = NewResourceClient[Role, string](client, "roles")
+	client.Roles = &clientRoles{client: client}
+	client.rolesV10 = NewResourceClient[roleV10, string](client, "roles")
+	client.rolesV11 = NewResourceClient[roleV11, string](client, "roles")
+	client.Policies = NewResourceClient[Policy, string](client, "policies")
 	client.Users = NewResourceClient[User, string](client, "users")
 	client.Presets = NewResourceClient[Preset, int64](client, "presets")
 	client.Operations = NewResourceClient[Operation, string](client, "operations")

permissions_test.go

@@ -0,0 +1,24 @@
+package directus
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPermissionst(t *testing.T) {
+
+	permissions, err := initClient(t).Permissions.List(context.Background())
+	require.NoError(t, err)
+	require.NotEmpty(t, permissions)
+
+	for _, permission := range permissions {
+		p, err := json.Marshal(permission)
+		require.NoError(t, err)
+		slog.Info("Permission", slog.Any("permission", p))
+	}
+
+}

policies_test.go

@@ -0,0 +1,33 @@
+package directus
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPoliciesList(t *testing.T) {
+
+	i, err := initClient(t).Server.Info(context.Background())
+	require.NoError(t, err)
+
+	major, err := strconv.Atoi(strings.Split(i.Version, ".")[0])
+	require.NoError(t, err)
+
+	if major < 11 {
+		t.Skip("Policies are only available in Directus 11 and above")
+	}
+
+	policies, err := initClient(t).Policies.List(context.Background())
+	require.NoError(t, err)
+	require.NotEmpty(t, policies)
+
+	for _, policy := range policies {
+		fmt.Printf("%#v\n", policy)
+	}
+
+}

roles.go

@@ -0,0 +1,251 @@
+package directus
+
+import (
+	"context"
+	"fmt"
+	"sync"
+)
+
+type Role interface {
+	PoliciesKeys() ([]string, error)
+	ParentKey() (string, error)
+	ChildrenKeys() ([]string, error)
+	ServerVersion() *ServerInfo
+}
+
+type roleV10 struct {
+	ID          string `json:"id,omitempty"`
+	Icon        Icon   `json:"icon,omitempty"`
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+
+	AdminAccess *bool `json:"admin_access"`
+	AppAccess   *bool `json:"app_access"`
+
+	Users []string `json:"users,omitempty"`
+
+	ServerInfo *ServerInfo
+}
+
+func (r *roleV10) ServerVersion() *ServerInfo {
+	return r.ServerInfo
+}
+
+func (r *roleV10) PoliciesKeys() ([]string, error) {
+	return nil, fmt.Errorf("directus: Policies are not supported in Directus below 11.0.0")
+}
+
+func (r *roleV10) ParentKey() (string, error) {
+	return "", fmt.Errorf("directus: Parent Role is not supported in Directus below 11.0.0")
+}
+
+func (r *roleV10) ChildrenKeys() ([]string, error) {
+	return nil, fmt.Errorf("directus: Children Roles are not supported in Directus below 11.0.0")
+}
+
+type roleV11 struct {
+	ID          string `json:"id,omitempty"`
+	Icon        Icon   `json:"icon,omitempty"`
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+
+	Policies []string `json:"policies,omitempty"`
+	Parent   *string  `json:"parent,omitempty"`
+	Children []string `json:"children,omitempty"`
+
+	Users []string `json:"users,omitempty"`
+
+	ServerInfo *ServerInfo
+}
+
+func (r *roleV11) ServerVersion() *ServerInfo {
+	return r.ServerInfo
+}
+
+func (r *roleV11) PoliciesKeys() ([]string, error) {
+	return r.Policies, nil
+}
+
+func (r *roleV11) ParentKey() (string, error) {
+	if r.Parent == nil {
+		return "", nil
+	}
+	return *r.Parent, nil
+}
+
+func (r *roleV11) ChildrenKeys() ([]string, error) {
+	return r.Children, nil
+}
+
+type clientRoles struct {
+	client *Client
+	mu     sync.Mutex
+}
+
+func (cr *clientRoles) List(ctx context.Context) ([]Role, error) {
+	cr.mu.Lock()
+	defer cr.mu.Unlock()
+
+	inf, err := cr.client.Server.Info(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	// Support for Directus 10.0.X - 10.13.X
+	case inf.VersionMajor == 10 && (inf.VersionMinor >= 0 && inf.VersionMinor <= 13):
+		rolesV10, err := cr.client.rolesV10.List(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("directus: cannot list roles: %w", err)
+		}
+		roles := make([]Role, len(rolesV10))
+		for i, r := range rolesV10 {
+			r.ServerInfo = inf
+			roles[i] = r
+		}
+
+		return roles, nil
+
+	// Support for Directus 11.0.X
+	case inf.VersionMajor == 11 && inf.VersionMinor == 0:
+		rolesV11, err := cr.client.rolesV11.List(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("directus: cannot list roles: %w", err)
+		}
+		roles := make([]Role, len(rolesV11))
+		for i, r := range rolesV11 {
+			r.ServerInfo = inf
+			roles[i] = r
+		}
+		return roles, nil
+
+	default:
+		return nil, fmt.Errorf("directus: unsupported server version: %v", inf)
+	}
+}
+
+func (cr *clientRoles) Get(ctx context.Context, id string) (Role, error) {
+	cr.mu.Lock()
+  defer cr.mu.Unlock()
+
+	inf, err := cr.client.Server.Info(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	// Support for Directus 10.0.X - 10.13.X
+	case inf.VersionMajor == 10 && (inf.VersionMinor >= 0 && inf.VersionMinor <= 13):
+		roleV10, err := cr.client.rolesV10.Get(ctx, id)
+		if err != nil {
+			return nil, fmt.Errorf("directus: cannot get role: %w", err)
+		}
+		roleV10.ServerInfo = inf
+		return roleV10, nil
+
+	// Support for Directus 11.0.X
+	case inf.VersionMajor == 11 && inf.VersionMinor == 0:
+		roleV11, err := cr.client.rolesV11.Get(ctx, id)
+		if err != nil {
+			return nil, fmt.Errorf("directus: cannot get role: %w", err)
+		}
+		roleV11.ServerInfo = inf
+		return roleV11, nil
+
+	default:
+		return nil, fmt.Errorf("directus: unsupported server version: %v", inf)
+	}
+}
+
+func (cr *clientRoles) Create(ctx context.Context, role Role) (Role, error) {
+	cr.mu.Lock()
+  defer cr.mu.Unlock()
+
+	inf, err := cr.client.Server.Info(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	// Support for Directus 10.0.X - 10.13.X
+	case inf.VersionMajor == 10 && (inf.VersionMinor >= 0 && inf.VersionMinor <= 13):
+		roleV10, ok := role.(*roleV10)
+		if !ok {
+			return nil, fmt.Errorf("directus: unsupported role type: %T", role)
+		}
+		return cr.client.rolesV10.Create(ctx, roleV10)
+
+	// Support for Directus 11.0.X
+	case inf.VersionMajor == 11 && inf.VersionMinor == 0:
+		roleV11, ok := role.(*roleV11)
+		if !ok {
+			return nil, fmt.Errorf("directus: unsupported role type: %T", role)
+		}
+		return cr.client.rolesV11.Create(ctx, roleV11)
+
+	default:
+		return nil, fmt.Errorf("directus: unsupported server version: %v", inf)
+	}
+}
+
+func (cr *clientRoles) Delete(ctx context.Context, role Role) error {
+	cr.mu.Lock()
+  defer cr.mu.Unlock()
+
+	inf, err := cr.client.Server.Info(ctx)
+	if err != nil {
+		return err
+	}
+
+	switch {
+	// Support for Directus 10.0.X - 10.13.X
+	case inf.VersionMajor == 10 && (inf.VersionMinor >= 0 && inf.VersionMinor <= 13):
+		roleV10, ok := role.(*roleV10)
+		if !ok {
+			return fmt.Errorf("directus: unsupported role type: %T", role)
+		}
+		return cr.client.rolesV10.Delete(ctx, roleV10.ID)
+
+	// Support for Directus 11.0.X
+	case inf.VersionMajor == 11 && inf.VersionMinor == 0:
+		roleV11, ok := role.(*roleV11)
+		if !ok {
+			return fmt.Errorf("directus: unsupported role type: %T", role)
+		}
+		return cr.client.rolesV11.Delete(ctx, roleV11.ID)
+
+	default:
+		return fmt.Errorf("directus: unsupported server version: %v", inf)
+	}
+}
+
+func (cr *clientRoles) Patch(ctx context.Context, role Role) (Role, error) {
+	cr.mu.Lock()
+  defer cr.mu.Unlock()
+
+	inf, err := cr.client.Server.Info(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	// Support for Directus 10.0.X - 10.13.X
+	case inf.VersionMajor == 10 && (inf.VersionMinor >= 0 && inf.VersionMinor <= 13):
+		roleV10, ok := role.(*roleV10)
+		if !ok {
+			return nil, fmt.Errorf("directus: unsupported role type: %T", role)
+		}
+		return cr.client.rolesV10.Patch(ctx, roleV10.ID, roleV10)
+
+	// Support for Directus 11.0.X
+	case inf.VersionMajor == 11 && inf.VersionMinor == 0:
+		roleV11, ok := role.(*roleV11)
+		if !ok {
+			return nil, fmt.Errorf("directus: unsupported role type: %T", role)
+		}
+		return cr.client.rolesV11.Patch(ctx, roleV11.ID, roleV11)
+
+	default:
+		return nil, fmt.Errorf("directus: unsupported server version: %v", inf)
+	}
+}