feat: add administrator role permission table (#11817)

This update introduces a new table for managing administrator role
permissions, along with the necessary repository and projection logic to
handle adding and removing permissions. It also includes tests to ensure
the correct functionality of the permission management system.

closes https://github.com/zitadel/zitadel/issues/10219

---------

Co-authored-by: Marco Ardizzone <[email protected]>
This commit is contained in:
Silvan
2026-04-14 06:01:52 +00:00
committed by GitHub
co-authored by Marco Ardizzone
parent bb3b52dda3
commit 7b9d2b7d17
11 changed files with 944 additions and 0 deletions
@@ -0,0 +1,16 @@
package migration
import (
_ "embed"
)
var (
//go:embed 018_administrator_role_permissions_table/up.sql
up018AdministratorRolePermissionsTable string
//go:embed 018_administrator_role_permissions_table/down.sql
down018AdministratorRolePermissionsTable string
)
func init() {
registerSQLMigration(18, up018AdministratorRolePermissionsTable, down018AdministratorRolePermissionsTable)
}
@@ -0,0 +1 @@
DROP TABLE IF EXISTS zitadel.administrator_role_permissions;
@@ -0,0 +1,8 @@
CREATE TABLE zitadel.administrator_role_permissions(
instance_id TEXT NOT NULL
, role_name TEXT NOT NULL CHECK (role_name <> '')
, permission TEXT NOT NULL CHECK (permission <> '')
, PRIMARY KEY (instance_id, permission, role_name)
, FOREIGN KEY (instance_id) REFERENCES zitadel.instances(id) ON DELETE CASCADE
);
@@ -0,0 +1,97 @@
package repository
import (
"context"
"github.com/zitadel/zitadel/backend/v3/domain"
"github.com/zitadel/zitadel/backend/v3/storage/database"
)
var _ domain.AdministratorRoleRepository = (*administratorRole)(nil)
type administratorRole struct{}
func AdministratorRoleRepository() domain.AdministratorRoleRepository {
return new(administratorRole)
}
func (administratorRole) unqualifiedTableName() string {
return "administrator_role_permissions"
}
func (a administratorRole) qualifiedTableName() string {
return "zitadel." + a.unqualifiedTableName()
}
// AddPermission implements [domain.AdministratorRoleRepository].
func (a administratorRole) AddPermissions(ctx context.Context, client database.QueryExecutor, instanceID, role string, permissions ...string) (int64, error) {
if len(permissions) == 0 {
return 0, database.ErrNoChanges
}
builder := database.NewStatementBuilder(
"INSERT INTO zitadel.administrator_role_permissions (instance_id, role_name, permission)"+
" SELECT $1::text, $2::text, unnest($3::text[])"+
" ON CONFLICT (instance_id, permission, role_name) DO NOTHING", instanceID, role, permissions,
)
return client.Exec(ctx, builder.String(), builder.Args()...)
}
// RemovePermissions implements [domain.AdministratorRoleRepository].
func (a administratorRole) RemovePermissions(ctx context.Context, client database.QueryExecutor, instanceID, role string, permissionsToRemove ...string) (int64, error) {
if len(permissionsToRemove) == 0 {
return 0, database.ErrNoChanges
}
builder := database.NewStatementBuilder(
"DELETE FROM zitadel.administrator_role_permissions"+
" WHERE instance_id = $1 AND role_name = $2 AND permission = ANY($3::text[])", instanceID, role, permissionsToRemove,
)
return client.Exec(ctx, builder.String(), builder.Args()...)
}
// PrimaryKeyCondition implements [domain.AdministratorRoleRepository].
func (a administratorRole) PrimaryKeyCondition(instanceID, roleName, permission string) database.Condition {
return database.And(
a.InstanceIDCondition(instanceID),
a.RoleNameCondition(database.TextOperationEqual, roleName),
a.PermissionCondition(database.TextOperationEqual, permission),
)
}
// InstanceIDCondition implements [domain.AdministratorRoleRepository].
func (a administratorRole) InstanceIDCondition(instanceID string) database.Condition {
return database.NewTextCondition(a.InstanceIDColumn(), database.TextOperationEqual, instanceID)
}
// RoleNameCondition implements [domain.AdministratorRoleRepository].
func (a administratorRole) RoleNameCondition(op database.TextOperation, name string) database.Condition {
return database.NewTextCondition(a.RoleNameColumn(), op, name)
}
// PermissionCondition implements [domain.AdministratorRoleRepository].
func (a administratorRole) PermissionCondition(op database.TextOperation, permission string) database.Condition {
return database.NewTextCondition(a.PermissionColumn(), op, permission)
}
// PrimaryKeyColumns implements [domain.AdministratorRoleRepository].
func (a administratorRole) PrimaryKeyColumns() []database.Column {
return []database.Column{
a.InstanceIDColumn(),
a.PermissionColumn(),
a.RoleNameColumn(),
}
}
// RoleNameColumn implements [domain.AdministratorRoleRepository].
func (a administratorRole) RoleNameColumn() database.Column {
return database.NewColumn(a.unqualifiedTableName(), "role_name")
}
// PermissionColumn implements [domain.AdministratorRoleRepository].
func (a administratorRole) PermissionColumn() database.Column {
return database.NewColumn(a.unqualifiedTableName(), "permission")
}
// InstanceIDColumn implements [domain.AdministratorRoleRepository].
func (a administratorRole) InstanceIDColumn() database.Column {
return database.NewColumn(a.unqualifiedTableName(), "instance_id")
}
@@ -0,0 +1,200 @@
package repository_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/zitadel/zitadel/backend/v3/storage/database"
"github.com/zitadel/zitadel/backend/v3/storage/database/repository"
)
type administratorRolePermissionRow struct {
InstanceID string `db:"instance_id"`
RoleName string `db:"role_name"`
Permission string `db:"permission"`
}
func TestAdministratorRoleRepository_AddPermissions(t *testing.T) {
tx, rollback := transactionForRollback(t)
defer rollback()
instanceID := createInstance(t, tx)
repo := repository.AdministratorRoleRepository()
tests := []struct {
name string
role string
permissions []string
wantRows []administratorRolePermissionRow
wantErr error
wantCount int64
}{
{
name: "add deduplicated permissions",
role: "ORG_OWNER",
permissions: []string{"org.read", "org.write", "org.read"},
wantCount: 2,
wantRows: []administratorRolePermissionRow{
{InstanceID: instanceID, RoleName: "ORG_OWNER", Permission: "org.read"},
{InstanceID: instanceID, RoleName: "ORG_OWNER", Permission: "org.write"},
},
},
{
name: "no permissions",
role: "ORG_OWNER",
wantErr: database.ErrNoChanges,
wantCount: 0,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
savepoint, rollbackSavepoint := savepointForRollback(t, tx)
defer rollbackSavepoint()
count, err := repo.AddPermissions(t.Context(), savepoint, instanceID, tt.role, tt.permissions...)
require.ErrorIs(t, err, tt.wantErr)
assert.Equal(t, tt.wantCount, count)
if tt.wantErr == nil {
assert.Equal(t,
tt.wantRows,
listAdministratorRolePermissions(t, savepoint, repo.RoleNameCondition(database.TextOperationEqual, tt.role)),
)
}
})
}
}
func TestAdministratorRoleRepository_RemovePermissions(t *testing.T) {
tx, rollback := transactionForRollback(t)
defer rollback()
instanceID := createInstance(t, tx)
repo := repository.AdministratorRoleRepository()
count, err := repo.AddPermissions(t.Context(), tx, instanceID, "INSTANCE_OWNER", "instance.read", "instance.write")
require.NoError(t, err)
assert.Equal(t, int64(2), count)
tests := []struct {
name string
role string
permissions []string
wantRows []administratorRolePermissionRow
wantErr error
wantCount int64
}{
{
name: "no permissions",
role: "INSTANCE_OWNER",
wantErr: database.ErrNoChanges,
},
{
name: "remove permissions",
role: "INSTANCE_OWNER",
permissions: []string{"instance.read"},
wantCount: 1,
wantRows: []administratorRolePermissionRow{
{InstanceID: instanceID, RoleName: "INSTANCE_OWNER", Permission: "instance.write"},
},
},
{
name: "remove exact pair and missing values",
role: "INSTANCE_OWNER",
permissions: []string{"instance.write", "missing"},
wantCount: 1,
wantRows: []administratorRolePermissionRow{{InstanceID: instanceID, RoleName: "INSTANCE_OWNER", Permission: "instance.read"}},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
savepoint, rollbackSavepoint := savepointForRollback(t, tx)
defer rollbackSavepoint()
count, err = repo.RemovePermissions(t.Context(), savepoint, instanceID, tt.role, tt.permissions...)
require.ErrorIs(t, err, tt.wantErr)
assert.Equal(t, tt.wantCount, count)
if tt.wantErr == nil {
assert.Equal(t,
tt.wantRows,
listAdministratorRolePermissions(t, savepoint, repo.RoleNameCondition(database.TextOperationEqual, "INSTANCE_OWNER")),
)
}
})
}
}
func TestAdministratorRoleRepository_AddAndRemoveAcrossCalls(t *testing.T) {
tx, rollback := transactionForRollback(t)
defer rollback()
instanceID := createInstance(t, tx)
repo := repository.AdministratorRoleRepository()
count, err := repo.AddPermissions(t.Context(), tx, instanceID, "INSTANCE_OWNER", "instance.read", "instance.write")
require.NoError(t, err)
assert.Equal(t, int64(2), count)
count, err = repo.AddPermissions(t.Context(), tx, instanceID, "INSTANCE_OWNER", "instance.manage", "instance.audit", "instance.write")
require.NoError(t, err)
assert.Equal(t, int64(2), count)
count, err = repo.RemovePermissions(t.Context(), tx, instanceID, "INSTANCE_OWNER", "instance.read")
require.NoError(t, err)
assert.Equal(t, int64(1), count)
assert.Equal(t,
[]administratorRolePermissionRow{
{InstanceID: instanceID, RoleName: "INSTANCE_OWNER", Permission: "instance.audit"},
{InstanceID: instanceID, RoleName: "INSTANCE_OWNER", Permission: "instance.manage"},
{InstanceID: instanceID, RoleName: "INSTANCE_OWNER", Permission: "instance.write"},
},
listAdministratorRolePermissions(t, tx, repo.RoleNameCondition(database.TextOperationEqual, "INSTANCE_OWNER")),
)
}
func TestAdministratorRoleRepository_PrimaryKeyCondition(t *testing.T) {
tx, rollback := transactionForRollback(t)
defer rollback()
instanceID := createInstance(t, tx)
repo := repository.AdministratorRoleRepository()
count, err := repo.AddPermissions(t.Context(), tx, instanceID, "PROJECT_OWNER", "project.read", "project.write")
require.NoError(t, err)
assert.Equal(t, int64(2), count)
rows := listAdministratorRolePermissions(t, tx, repo.PrimaryKeyCondition(instanceID, "PROJECT_OWNER", "project.read"))
assert.Equal(t,
[]administratorRolePermissionRow{{InstanceID: instanceID, RoleName: "PROJECT_OWNER", Permission: "project.read"}},
rows,
)
}
func listAdministratorRolePermissions(t *testing.T, tx database.QueryExecutor, condition database.Condition) []administratorRolePermissionRow {
t.Helper()
builder := database.NewStatementBuilder(`SELECT instance_id, role_name, permission FROM zitadel.administrator_role_permissions`)
if condition != nil {
builder.WriteString(" WHERE ")
condition.Write(builder)
}
builder.WriteString(" ORDER BY instance_id, role_name, permission")
rows, err := tx.Query(t.Context(), builder.String(), builder.Args()...)
require.NoError(t, err)
var result []*administratorRolePermissionRow
require.NoError(t, rows.(database.CollectableRows).Collect(&result))
out := make([]administratorRolePermissionRow, len(result))
for i, row := range result {
out[i] = *row
}
return out
}