Add files using upload-large-folder tool

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/anonymous/middleware.go

@@ -0,0 +1,94 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package anonymous
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/go-openapi/runtime"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+// Client for anonymous access
+type Client struct {
+	config        config.AnonymousAccess
+	apiKeyEnabled bool
+	oidcEnabled   bool
+}
+
+// New anonymous access client. Client.Middleware can be used as a regular
+// golang http-middleware
+func New(cfg config.Config) *Client {
+	return &Client{config: cfg.Authentication.AnonymousAccess, apiKeyEnabled: cfg.Authentication.AnyApiKeyAvailable(), oidcEnabled: cfg.Authentication.OIDC.Enabled}
+}
+
+// Middleware will fail unauthenticated requests if anonymous access is
+// disabled. This middleware should run after all previous middlewares.
+func (c *Client) Middleware(next http.Handler) http.Handler {
+	if c.config.Enabled {
+		// Anonymous Access is allowed, this means we don't have to validate any
+		// further, let's just return the original middleware stack
+
+		return next
+	}
+
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if hasBearerAuth(r) {
+			// if an OIDC-Header is present we can be sure that the OIDC
+			// Authenticator has already validated the token, so we don't have to do
+			// anything and can call the next handler.
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		w.WriteHeader(401)
+		var authSchemas []string
+		if c.apiKeyEnabled {
+			authSchemas = append(authSchemas, "API-keys")
+		}
+		if c.oidcEnabled {
+			authSchemas = append(authSchemas, "OIDC")
+		}
+
+		w.Write([]byte(
+			fmt.Sprintf(
+				`{"code":401,"message": "anonymous access not enabled. Please authenticate through one of the available methods: [%s]" }`, strings.Join(authSchemas, ", "),
+			),
+		))
+	})
+}
+
+func hasBearerAuth(r *http.Request) bool {
+	// The following logic to decide whether OIDC information is set is taken
+	// straight from go-swagger to make sure the decision matches:
+	// https://github.com/go-openapi/runtime/blob/109737172424d8a656fd1199e28c9f5cc89b0cca/security/authenticator.go#L208-L225
+	const prefix = "Bearer "
+	var token string
+	hdr := r.Header.Get("Authorization")
+	if strings.HasPrefix(hdr, prefix) {
+		token = strings.TrimPrefix(hdr, prefix)
+	}
+	if token == "" {
+		qs := r.URL.Query()
+		token = qs.Get("access_token")
+	}
+	//#nosec
+	ct, _, _ := runtime.ContentType(r.Header)
+	if token == "" && (ct == "application/x-www-form-urlencoded" || ct == "multipart/form-data") {
+		token = r.FormValue("access_token")
+	}
+	// End of go-swagger logic
+
+	return token != ""
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/anonymous/middleware_test.go

@@ -0,0 +1,102 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package anonymous
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func Test_AnonymousMiddleware_Enabled(t *testing.T) {
+	// when anonymous access is enabled, we don't need to do anything and can
+	// safely call the next next handler
+
+	r := httptest.NewRequest("GET", "/foo", nil)
+	w := httptest.NewRecorder()
+
+	next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(900)
+	})
+
+	cfg := config.Config{
+		Authentication: config.Authentication{
+			AnonymousAccess: config.AnonymousAccess{
+				Enabled: true,
+			},
+		},
+	}
+
+	New(cfg).Middleware(next).ServeHTTP(w, r)
+	response := w.Result()
+	defer response.Body.Close()
+
+	assert.Equal(t, response.StatusCode, 900)
+}
+
+func Test_AnonymousMiddleware_Disabled(t *testing.T) {
+	t.Run("when OIDC is enabled, but no token provided", func(t *testing.T) {
+		r := httptest.NewRequest("GET", "/foo", nil)
+		w := httptest.NewRecorder()
+
+		next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(900)
+		})
+
+		cfg := config.Config{
+			Authentication: config.Authentication{
+				AnonymousAccess: config.AnonymousAccess{
+					Enabled: false,
+				},
+				OIDC: config.OIDC{
+					Enabled: true,
+				},
+			},
+		}
+
+		New(cfg).Middleware(next).ServeHTTP(w, r)
+		response := w.Result()
+		defer response.Body.Close()
+
+		assert.Equal(t, response.StatusCode, 401)
+	})
+
+	t.Run("when OIDC is enabled, and a Bearer Header provided", func(t *testing.T) {
+		r := httptest.NewRequest("GET", "/foo", nil)
+		r.Header.Add("Authorization", "Bearer foo")
+		w := httptest.NewRecorder()
+
+		next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(900)
+		})
+
+		cfg := config.Config{
+			Authentication: config.Authentication{
+				AnonymousAccess: config.AnonymousAccess{
+					Enabled: false,
+				},
+				OIDC: config.OIDC{
+					Enabled: true,
+				},
+			},
+		}
+
+		New(cfg).Middleware(next).ServeHTTP(w, r)
+		response := w.Result()
+		defer response.Body.Close()
+
+		assert.Equal(t, response.StatusCode, 900)
+	})
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/client.go

@@ -0,0 +1,112 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package apikey
+
+import (
+	"crypto/sha256"
+	"crypto/subtle"
+	"fmt"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+type StaticApiKey struct {
+	config         config.StaticAPIKey
+	weakKeyStorage [][sha256.Size]byte
+}
+
+func NewStatic(cfg config.Config) (*StaticApiKey, error) {
+	c := &StaticApiKey{
+		config: cfg.Authentication.APIKey,
+	}
+
+	if err := c.validateConfig(); err != nil {
+		return nil, fmt.Errorf("invalid apikey config: %w", err)
+	}
+
+	c.parseKeys()
+
+	return c, nil
+}
+
+func (c *StaticApiKey) parseKeys() {
+	c.weakKeyStorage = make([][sha256.Size]byte, len(c.config.AllowedKeys))
+	for i, rawKey := range c.config.AllowedKeys {
+		c.weakKeyStorage[i] = sha256.Sum256([]byte(rawKey))
+	}
+}
+
+func (c *StaticApiKey) validateConfig() error {
+	if !c.config.Enabled {
+		// don't validate if this scheme isn't used
+		return nil
+	}
+
+	if len(c.config.AllowedKeys) < 1 {
+		return fmt.Errorf("need at least one valid allowed key")
+	}
+
+	for _, key := range c.config.AllowedKeys {
+		if len(key) == 0 {
+			return fmt.Errorf("keys cannot have length 0")
+		}
+	}
+
+	if len(c.config.Users) < 1 {
+		return fmt.Errorf("need at least one user")
+	}
+
+	for _, key := range c.config.Users {
+		if len(key) == 0 {
+			return fmt.Errorf("users cannot have length 0")
+		}
+	}
+
+	if len(c.config.Users) > 1 && len(c.config.Users) != len(c.config.AllowedKeys) {
+		return fmt.Errorf("length of users and keys must match, alternatively provide single user for all keys")
+	}
+
+	return nil
+}
+
+func (c *StaticApiKey) ValidateAndExtract(token string, scopes []string) (*models.Principal, error) {
+	tokenPos, ok := c.isTokenAllowed(token)
+	if !ok {
+		return nil, fmt.Errorf("invalid api key")
+	}
+
+	return &models.Principal{
+		Username: c.getUser(tokenPos), UserType: models.UserTypeInputDb,
+	}, nil
+}
+
+func (c *StaticApiKey) isTokenAllowed(token string) (int, bool) {
+	tokenHash := sha256.Sum256([]byte(token))
+
+	for i, allowed := range c.weakKeyStorage {
+		if subtle.ConstantTimeCompare(tokenHash[:], allowed[:]) == 1 {
+			return i, true
+		}
+	}
+
+	return -1, false
+}
+
+func (c *StaticApiKey) getUser(pos int) string {
+	// passed validation guarantees that one of those options will work
+	if pos >= len(c.config.Users) {
+		return c.config.Users[0]
+	}
+
+	return c.config.Users[pos]
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/client_test.go

@@ -0,0 +1,186 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package apikey
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func Test_APIKeyClient(t *testing.T) {
+	type test struct {
+		name               string
+		config             config.StaticAPIKey
+		expectConfigErr    bool
+		expectConfigErrMsg string
+		validate           func(t *testing.T, c *StaticApiKey)
+	}
+
+	tests := []test{
+		{
+			name: "not enabled",
+			config: config.StaticAPIKey{
+				Enabled: false,
+			},
+			expectConfigErr: false,
+		},
+		{
+			name: "key, but no user",
+			config: config.StaticAPIKey{
+				Enabled:     true,
+				AllowedKeys: []string{"secret-key"},
+				Users:       []string{},
+			},
+			expectConfigErr:    true,
+			expectConfigErrMsg: "need at least one user",
+		},
+		{
+			name: "zero length key",
+			config: config.StaticAPIKey{
+				Enabled:     true,
+				AllowedKeys: []string{""},
+				Users:       []string{"gooduser"},
+			},
+			expectConfigErr:    true,
+			expectConfigErrMsg: "keys cannot have length 0",
+		},
+		{
+			name: "user, but no key",
+			config: config.StaticAPIKey{
+				Enabled:     true,
+				AllowedKeys: []string{},
+				Users:       []string{"johnnyBeAllowed"},
+			},
+			expectConfigErr:    true,
+			expectConfigErrMsg: "need at least one valid allowed key",
+		},
+		{
+			name: "zero length user",
+			config: config.StaticAPIKey{
+				Enabled:     true,
+				AllowedKeys: []string{"secret-key"},
+				Users:       []string{""},
+			},
+			expectConfigErr:    true,
+			expectConfigErrMsg: "users cannot have length 0",
+		},
+		{
+			name: "one user, one key",
+			config: config.StaticAPIKey{
+				Enabled:     true,
+				AllowedKeys: []string{"secret-key"},
+				Users:       []string{"mrRoboto"},
+			},
+			expectConfigErr: false,
+			validate: func(t *testing.T, c *StaticApiKey) {
+				p, err := c.ValidateAndExtract("secret-key", nil)
+				require.Nil(t, err)
+				assert.Equal(t, "mrRoboto", p.Username)
+
+				_, err = c.ValidateAndExtract("", nil)
+				require.NotNil(t, err)
+				_, err = c.ValidateAndExtract("other-key", nil)
+				require.NotNil(t, err)
+			},
+		},
+		{
+			// this is allowed, this means that all keys point to the same user for
+			// authZ purposes
+			name: "one user, multiple keys",
+			config: config.StaticAPIKey{
+				Enabled:     true,
+				AllowedKeys: []string{"secret-key", "another-secret-key", "third-key"},
+				Users:       []string{"jane"},
+			},
+			expectConfigErr: false,
+			validate: func(t *testing.T, c *StaticApiKey) {
+				p, err := c.ValidateAndExtract("secret-key", nil)
+				require.Nil(t, err)
+				assert.Equal(t, "jane", p.Username)
+
+				p, err = c.ValidateAndExtract("another-secret-key", nil)
+				require.Nil(t, err)
+				assert.Equal(t, "jane", p.Username)
+
+				p, err = c.ValidateAndExtract("third-key", nil)
+				require.Nil(t, err)
+				assert.Equal(t, "jane", p.Username)
+
+				_, err = c.ValidateAndExtract("", nil)
+				require.NotNil(t, err)
+				_, err = c.ValidateAndExtract("other-key", nil)
+				require.NotNil(t, err)
+			},
+		},
+		{
+			// this is allowed, this means that each key at pos i points to user at
+			// pos i for authZ purposes
+			name: "multiple user, multiple keys",
+			config: config.StaticAPIKey{
+				Enabled:     true,
+				AllowedKeys: []string{"secret-key", "another-secret-key", "third-key"},
+				Users:       []string{"jane", "jessica", "jennifer"},
+			},
+			expectConfigErr: false,
+			validate: func(t *testing.T, c *StaticApiKey) {
+				p, err := c.ValidateAndExtract("secret-key", nil)
+				require.Nil(t, err)
+				assert.Equal(t, "jane", p.Username)
+
+				p, err = c.ValidateAndExtract("another-secret-key", nil)
+				require.Nil(t, err)
+				assert.Equal(t, "jessica", p.Username)
+
+				p, err = c.ValidateAndExtract("third-key", nil)
+				require.Nil(t, err)
+				assert.Equal(t, "jennifer", p.Username)
+
+				_, err = c.ValidateAndExtract("", nil)
+				require.NotNil(t, err)
+				_, err = c.ValidateAndExtract("other-key", nil)
+				require.NotNil(t, err)
+			},
+		},
+		{
+			// this is invalid, the keys cannot be mapped to the users
+			name: "2 users, 3 keys",
+			config: config.StaticAPIKey{
+				Enabled:     true,
+				AllowedKeys: []string{"secret-key", "another-secret-key", "third-key"},
+				Users:       []string{"jane", "jessica"},
+			},
+			expectConfigErr:    true,
+			expectConfigErrMsg: "length of users and keys must match, alternatively provide single user for all keys",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			c, err := NewStatic(config.Config{
+				Authentication: config.Authentication{APIKey: test.config},
+			})
+
+			if test.expectConfigErr {
+				require.NotNil(t, err)
+				assert.Contains(t, err.Error(), test.expectConfigErrMsg)
+				return
+			}
+
+			if test.validate != nil {
+				test.validate(t, c)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/db_user_test.go

@@ -0,0 +1,457 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package apikey
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/weaviate/weaviate/entities/models"
+
+	"github.com/sirupsen/logrus/hooks/test"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication/apikey/keys"
+
+	"github.com/stretchr/testify/require"
+)
+
+var log, _ = test.NewNullLogger()
+
+func TestDynUserConcurrency(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+
+	numUsers := 10
+
+	wg := sync.WaitGroup{}
+	wg.Add(numUsers)
+
+	userNames := make([]string, 0, numUsers)
+	for i := 0; i < numUsers; i++ {
+		userName := fmt.Sprintf("user%v", i)
+		go func() {
+			err := dynUsers.CreateUser(userName, "something", userName, "", time.Now())
+			require.NoError(t, err)
+			wg.Done()
+		}()
+		userNames = append(userNames, userName)
+	}
+	wg.Wait()
+
+	users, err := dynUsers.GetUsers(userNames...)
+	require.NoError(t, err)
+	require.Equal(t, len(userNames), len(users))
+}
+
+func TestConcurrentValidate(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	userId1 := "id"
+	userId2 := "id2"
+
+	apiKey, hash, identifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	require.NoError(t, dynUsers.CreateUser(userId1, hash, identifier, "", time.Now()))
+
+	apiKey2, hash2, identifier2, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	require.NoError(t, dynUsers.CreateUser(userId2, hash2, identifier2, "", time.Now()))
+
+	randomKey, _, err := keys.DecodeApiKey(apiKey)
+	require.NoError(t, err)
+	randomKey2, _, err := keys.DecodeApiKey(apiKey2)
+	require.NoError(t, err)
+	start := time.Now()
+	wg := sync.WaitGroup{}
+	for i := 0; i < 10; i++ {
+		wg.Add(2)
+		go func() {
+			_, err := dynUsers.ValidateAndExtract(randomKey, identifier)
+			require.NoError(t, err)
+			wg.Done()
+		}()
+
+		go func() {
+			_, err := dynUsers.ValidateAndExtract(randomKey2, identifier2)
+			require.NoError(t, err)
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+
+	users, err := dynUsers.GetUsers(userId1)
+	require.NoError(t, err)
+	user := users[userId1]
+	require.Less(t, start, user.LastUsedAt)
+}
+
+func TestDynUserTestSlowAfterWeakHash(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	userId := "id"
+
+	apiKey, hash, identifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	require.NoError(t, dynUsers.CreateUser(userId, hash, identifier, "", time.Now()))
+
+	randomKey, _, err := keys.DecodeApiKey(apiKey)
+	require.NoError(t, err)
+
+	_, ok := dynUsers.memoryOnlyData.weakKeyStorageById[userId]
+	require.False(t, ok)
+
+	startSlow := time.Now()
+	_, err = dynUsers.ValidateAndExtract(randomKey, identifier)
+	require.NoError(t, err)
+	tookSlow := time.Since(startSlow)
+
+	_, ok = dynUsers.memoryOnlyData.weakKeyStorageById[userId]
+	require.True(t, ok)
+
+	startFast := time.Now()
+	_, err = dynUsers.ValidateAndExtract(randomKey, identifier)
+	require.NoError(t, err)
+	tookFast := time.Since(startFast)
+	require.Less(t, tookFast, tookSlow)
+}
+
+func TestUpdateUser(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	userId := "id"
+
+	apiKey, hash, oldIdentifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	require.NoError(t, dynUsers.CreateUser(userId, hash, oldIdentifier, "", time.Now()))
+
+	// login works
+	randomKeyOld, _, err := keys.DecodeApiKey(apiKey)
+	require.NoError(t, err)
+
+	principal, err := dynUsers.ValidateAndExtract(randomKeyOld, oldIdentifier)
+	require.NoError(t, err)
+	require.NotNil(t, principal)
+
+	// update key and check that original key does not work, but new one does
+	apiKeyNew, hashNew, newIdentifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+	require.NoError(t, dynUsers.RotateKey(userId, apiKeyNew[:3], hashNew, oldIdentifier, newIdentifier))
+
+	randomKeyNew, _, err := keys.DecodeApiKey(apiKeyNew)
+	require.NoError(t, err)
+
+	principal, err = dynUsers.ValidateAndExtract(randomKeyOld, oldIdentifier)
+	require.Error(t, err)
+	require.Nil(t, principal)
+
+	// first login with new key is slow again, second is fast
+	startSlow := time.Now()
+	principal, err = dynUsers.ValidateAndExtract(randomKeyNew, newIdentifier)
+	require.NoError(t, err)
+	require.NotNil(t, principal)
+	tookSlow := time.Since(startSlow)
+
+	startFast := time.Now()
+	_, err = dynUsers.ValidateAndExtract(randomKeyNew, newIdentifier)
+	require.NoError(t, err)
+	tookFast := time.Since(startFast)
+	require.Less(t, tookFast, tookSlow)
+}
+
+func TestSnapShotAndRestore(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+
+	userId1 := "id-1"
+	userId2 := "id-2"
+
+	apiKey, hash, identifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	require.NoError(t, dynUsers.CreateUser(userId1, hash, identifier, "", time.Now()))
+	login1, _, err := keys.DecodeApiKey(apiKey)
+	require.NoError(t, err)
+
+	apiKey2, hash2, identifier2, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+	require.NoError(t, dynUsers.CreateUser(userId2, hash2, identifier2, "", time.Now()))
+	login2, _, err := keys.DecodeApiKey(apiKey2)
+	require.NoError(t, err)
+
+	// first login is slow, second is fast
+	startSlow := time.Now()
+	principal, err := dynUsers.ValidateAndExtract(login1, identifier)
+	require.NoError(t, err)
+	require.NotNil(t, principal)
+	tookSlow := time.Since(startSlow)
+
+	startFast := time.Now()
+	_, err = dynUsers.ValidateAndExtract(login1, identifier)
+	require.NoError(t, err)
+	tookFast := time.Since(startFast)
+	require.Less(t, tookFast, tookSlow)
+
+	principal2, err := dynUsers.ValidateAndExtract(login2, identifier2)
+	require.NoError(t, err)
+	require.NotNil(t, principal2)
+
+	require.NoError(t, dynUsers.DeactivateUser(userId2, true))
+
+	// create snapshot and restore to an empty new DBUser struct
+	snapShot, err := dynUsers.Snapshot()
+	require.NoError(t, err)
+
+	dynUsers2, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	require.NoError(t, dynUsers2.Restore(snapShot))
+
+	// content should be identical:
+	// - all users and their status present
+	// - taking a new snapshot should be identical
+	// - only weak hash is missing => first login should be slow again
+	snapshot2, err := dynUsers2.Snapshot()
+	require.NoError(t, err)
+	require.Equal(t, snapShot, snapshot2)
+
+	startAfterRestoreSlow := time.Now()
+	_, err = dynUsers2.ValidateAndExtract(login1, identifier)
+	require.NoError(t, err)
+	tookAfterRestore := time.Since(startAfterRestoreSlow)
+	require.Less(t, tookFast, tookAfterRestore)
+
+	_, err = dynUsers2.ValidateAndExtract(login2, identifier2)
+	require.Error(t, err)
+
+	apiKey3, hash3, identifier3, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+	require.NoError(t, dynUsers2.RotateKey(userId2, apiKey3[:3], hash3, identifier2, identifier3))
+
+	login3, _, err := keys.DecodeApiKey(apiKey3)
+	require.NoError(t, err)
+	_, err = dynUsers2.ValidateAndExtract(login3, identifier3)
+	require.Error(t, err)
+}
+
+func TestSuspendAfterDelete(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	userId := "id"
+
+	_, hash, identifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	require.NoError(t, dynUsers.CreateUser(userId, hash, identifier, "", time.Now()))
+
+	users, err := dynUsers.GetUsers(userId)
+	require.NoError(t, err)
+	require.Contains(t, users, userId)
+	require.Len(t, users, 1)
+
+	require.NoError(t, dynUsers.DeleteUser(userId))
+
+	require.Error(t, dynUsers.DeactivateUser(userId, false))
+	require.Error(t, dynUsers.ActivateUser(userId))
+	require.Error(t, dynUsers.RotateKey(userId, "", "", "", ""))
+	require.Error(t, dynUsers.ActivateUser(userId))
+}
+
+func TestLastUsedTime(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	userId := "user"
+
+	start := time.Now()
+
+	apiKey, hash, identifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	require.NoError(t, dynUsers.CreateUser(userId, hash, identifier, "", time.Now()))
+
+	user, err := dynUsers.GetUsers(userId)
+	require.NoError(t, err)
+	require.Less(t, user[userId].LastUsedAt, start) // no usage yet
+
+	login, _, err := keys.DecodeApiKey(apiKey)
+	require.NoError(t, err)
+	_, err = dynUsers.ValidateAndExtract(login, identifier)
+	require.NoError(t, err)
+
+	user, err = dynUsers.GetUsers(userId)
+	require.NoError(t, err)
+	require.Less(t, start, user[userId].LastUsedAt) // was just used
+	require.Less(t, user[userId].LastUsedAt, time.Now())
+	lastUsedTime := user[userId].LastUsedAt
+
+	// try to update with older timestamp => no effect
+	dynUsers.UpdateLastUsedTimestamp(map[string]time.Time{userId: start})
+	user, err = dynUsers.GetUsers(userId)
+	require.NoError(t, err)
+
+	require.Equal(t, user[userId].LastUsedAt, lastUsedTime)
+
+	// update with newer timestamp (that another node has seen)
+	updateTime := time.Now()
+	dynUsers.UpdateLastUsedTimestamp(map[string]time.Time{userId: updateTime})
+	user, err = dynUsers.GetUsers(userId)
+	require.NoError(t, err)
+
+	require.Equal(t, user[userId].LastUsedAt, updateTime)
+}
+
+func TestImportingAndSuspendingStaticKeys(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+
+	createdAt := time.Now()
+	userId := "user"
+	importedApiKey := "importedApiKey"
+	require.NoError(t, dynUsers.CreateUserWithKey(userId, importedApiKey[:3], sha256.Sum256([]byte(importedApiKey)), createdAt))
+
+	principal, err := dynUsers.ValidateImportedKey(importedApiKey)
+	require.NoError(t, err)
+	require.NotNil(t, principal)
+	require.Equal(t, userId, principal.Username)
+
+	require.NoError(t, dynUsers.DeactivateUser(userId, true))
+
+	principal, err = dynUsers.ValidateImportedKey(importedApiKey)
+	require.Error(t, err)
+	require.Nil(t, principal)
+
+	require.NoError(t, dynUsers.ActivateUser(userId))
+	principal, err = dynUsers.ValidateImportedKey(importedApiKey)
+	require.Error(t, err)
+	require.Nil(t, principal)
+
+	apiKey, hash, identifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+	require.NoError(t, dynUsers.RotateKey(userId, apiKey[:3], hash, "imported_"+userId, identifier))
+
+	login, _, err := keys.DecodeApiKey(apiKey)
+	require.NoError(t, err)
+	_, err = dynUsers.ValidateAndExtract(login, identifier)
+	require.NoError(t, err)
+
+	principal, err = dynUsers.ValidateImportedKey(importedApiKey)
+	require.NoError(t, err) // error is only returned if key is deactivated
+	require.Nil(t, principal)
+}
+
+func TestImportingStaticKeys(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	createdAt := time.Now()
+	for i := 0; i < 10; i++ {
+		userId := "user" + strconv.Itoa(i)
+		importedApiKey := "importedApiKey" + strconv.Itoa(i)
+		require.NoError(t, dynUsers.CreateUserWithKey(userId, importedApiKey[:3], sha256.Sum256([]byte(importedApiKey)), createdAt))
+
+		principal, err := dynUsers.ValidateImportedKey(importedApiKey)
+		require.NoError(t, err)
+		require.NotNil(t, principal)
+		require.Equal(t, userId, principal.Username)
+		require.Equal(t, principal.UserType, models.UserTypeInputDb)
+
+		require.True(t, dynUsers.IsBlockedKey(importedApiKey))
+	}
+
+	for i := 0; i < 10; i++ {
+		userId := "user" + strconv.Itoa(i)
+		importedApiKey := "importedApiKey" + strconv.Itoa(i)
+
+		users, err := dynUsers.GetUsers(userId)
+		require.NoError(t, err)
+		require.Len(t, users, 1)
+		user, ok := users[userId]
+		require.True(t, ok)
+		require.Equal(t, user.Id, userId)
+		require.Equal(t, user.InternalIdentifier, "imported_"+userId)
+		require.Equal(t, user.CreatedAt, createdAt)
+		require.True(t, user.ImportedWithKey)
+
+		apiKey, hash, identifier, err := keys.CreateApiKeyAndHash()
+		require.NoError(t, err)
+		require.NoError(t, dynUsers.RotateKey(userId, apiKey[:3], hash, "imported_"+userId, identifier))
+
+		login, _, err := keys.DecodeApiKey(apiKey)
+		require.NoError(t, err)
+		_, err = dynUsers.ValidateAndExtract(login, identifier)
+		require.NoError(t, err)
+
+		users, err = dynUsers.GetUsers(userId)
+		require.NoError(t, err)
+		require.Len(t, users, 1)
+		user, ok = users[userId]
+		require.True(t, ok)
+		require.Equal(t, user.Id, userId)
+		require.Equal(t, user.InternalIdentifier, identifier)
+		require.Equal(t, user.CreatedAt, createdAt)
+		require.False(t, user.ImportedWithKey)
+
+		require.True(t, dynUsers.IsBlockedKey(importedApiKey))
+
+	}
+}
+
+func TestImportingStaticKeysWithTime(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	createdAt := time.Now().Add(-time.Hour)
+
+	importedApiKey := "importedApiKey"
+	userId := "user"
+	require.NoError(t, dynUsers.CreateUserWithKey(userId, importedApiKey[:3], sha256.Sum256([]byte(importedApiKey)), createdAt))
+
+	users, err := dynUsers.GetUsers(userId)
+	require.NoError(t, err)
+	require.Len(t, users, 1)
+	user, ok := users[userId]
+	require.True(t, ok)
+	require.Equal(t, user.CreatedAt, createdAt)
+}
+
+func TestSnapshotRestoreEmpty(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+	userId := "user"
+
+	_, hash, identifier, err := keys.CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	require.NoError(t, dynUsers.CreateUser(userId, hash, identifier, "", time.Now()))
+	user, err := dynUsers.GetUsers(userId)
+	require.NoError(t, err)
+	require.Equal(t, user[userId].Id, userId)
+
+	err = dynUsers.Restore([]byte{})
+	require.NoError(t, err)
+
+	// nothing overwritten
+	user, err = dynUsers.GetUsers(userId)
+	require.NoError(t, err)
+	require.Equal(t, user[userId].Id, userId)
+}
+
+func TestRestoreInvalidData(t *testing.T) {
+	dynUsers, err := NewDBUser(t.TempDir(), true, log)
+	require.NoError(t, err)
+
+	require.Error(t, dynUsers.Restore([]byte("invalid json")))
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/db_users.go

@@ -0,0 +1,550 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package apikey
+
+import (
+	"crypto/sha256"
+	"crypto/subtle"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	enterrors "github.com/weaviate/weaviate/entities/errors"
+
+	"github.com/alexedwards/argon2id"
+
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+const (
+	SnapshotVersion   = 0
+	FileName          = "users.json"
+	UserNameMaxLength = 128
+	UserNameRegexCore = `[A-Za-z][-_0-9A-Za-z@.]{0,128}`
+)
+
+type DBUsers interface {
+	CreateUser(userId, secureHash, userIdentifier, apiKeyFirstLetters string, createdAt time.Time) error
+	CreateUserWithKey(userId, apiKeyFirstLetters string, weakHash [sha256.Size]byte, createdAt time.Time) error
+	DeleteUser(userId string) error
+	ActivateUser(userId string) error
+	DeactivateUser(userId string, revokeKey bool) error
+	GetUsers(userIds ...string) (map[string]*User, error)
+	RotateKey(userId, apiKeyFirstLetters, secureHash, oldIdentifier, newIdentifier string) error
+	CheckUserIdentifierExists(userIdentifier string) (bool, error)
+}
+
+type User struct {
+	sync.RWMutex
+	Id                 string
+	Active             bool
+	InternalIdentifier string
+	ApiKeyFirstLetters string
+	CreatedAt          time.Time
+	LastUsedAt         time.Time
+	ImportedWithKey    bool
+}
+
+type DBUser struct {
+	lock           *sync.RWMutex
+	weakHashLock   *sync.RWMutex
+	data           dbUserdata
+	memoryOnlyData memoryOnlyData
+	path           string
+	enabled        bool
+}
+
+type DBUserSnapshot struct {
+	Data    dbUserdata
+	Version int
+}
+
+type dbUserdata struct {
+	SecureKeyStorageById    map[string]string
+	IdentifierToId          map[string]string
+	IdToIdentifier          map[string]string
+	Users                   map[string]*User
+	UserKeyRevoked          map[string]struct{}
+	ImportedApiKeysWeakHash map[string][sha256.Size]byte
+}
+
+type memoryOnlyData struct {
+	weakKeyStorageById map[string][sha256.Size]byte
+	// imported keys from static users should not work after key rotation, eg the following scenario
+	// - import user with "key"
+	// - login works when using "key" through dynamic users
+	// - key rotation "key" => "new-key"
+	// - login works when using "new-key" through dynamic users
+	// - login using "key" is blocked and does not reach static user config where the old key is still present
+	//
+	// Note that this will NOT be persisted and we expect that the static user configuration does not contain "key" anymore
+	// on the next restart
+	importedApiKeysBlocked [][sha256.Size]byte
+}
+
+func NewDBUser(path string, enabled bool, logger logrus.FieldLogger) (*DBUser, error) {
+	fullpath := fmt.Sprintf("%s/raft/db_users/", path)
+	err := createStorage(fullpath + FileName)
+	if err != nil {
+		return nil, err
+	}
+	existingData, err := ReadFile(fullpath + FileName)
+	if err != nil {
+		return nil, err
+	}
+	snapshot := DBUserSnapshot{}
+	if len(existingData) > 0 {
+		if err := json.Unmarshal(existingData, &snapshot); err != nil {
+			return nil, err
+		}
+	}
+
+	if snapshot.Data.SecureKeyStorageById == nil {
+		snapshot.Data.SecureKeyStorageById = make(map[string]string)
+	}
+	if snapshot.Data.IdentifierToId == nil {
+		snapshot.Data.IdentifierToId = make(map[string]string)
+	}
+	if snapshot.Data.IdToIdentifier == nil {
+		snapshot.Data.IdToIdentifier = make(map[string]string)
+	}
+	if snapshot.Data.Users == nil {
+		snapshot.Data.Users = make(map[string]*User)
+	}
+	if snapshot.Data.UserKeyRevoked == nil {
+		snapshot.Data.UserKeyRevoked = make(map[string]struct{})
+	}
+
+	if snapshot.Data.ImportedApiKeysWeakHash == nil {
+		snapshot.Data.ImportedApiKeysWeakHash = make(map[string][sha256.Size]byte)
+	}
+
+	dbUsers := &DBUser{
+		path:         fullpath,
+		lock:         &sync.RWMutex{},
+		weakHashLock: &sync.RWMutex{},
+		data:         snapshot.Data,
+		memoryOnlyData: memoryOnlyData{
+			weakKeyStorageById:     make(map[string][sha256.Size]byte),
+			importedApiKeysBlocked: make([][sha256.Size]byte, 0),
+		},
+		enabled: enabled,
+	}
+
+	// we save every change to file after a request is done, EXCEPT the lastUsedAt time as we do not want to write to a
+	// file with every request.
+	// This information is not terribly important (besides WCD UX), so it does not matter much if we very rarely loose
+	// some information here. This info will also be written on shutdown so the only loss of information occurs with
+	// OOM or similar.
+	if enabled {
+		enterrors.GoWrapper(func() {
+			ticker := time.NewTicker(1 * time.Minute)
+			for range ticker.C {
+				func() {
+					dbUsers.lock.RLock()
+					defer dbUsers.lock.RUnlock()
+					err := dbUsers.storeToFile()
+					if err != nil {
+						logger.WithField("action", "db_users_write_to_file").
+							WithField("error", err).
+							Warn("db users file not written")
+					}
+				}()
+			}
+		}, logger)
+	}
+
+	return dbUsers, nil
+}
+
+func (c *DBUser) CreateUser(userId, secureHash, userIdentifier, apiKeyFirstLetters string, createdAt time.Time) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if len(apiKeyFirstLetters) > 3 {
+		return errors.New("api key first letters too long")
+	}
+
+	c.data.SecureKeyStorageById[userId] = secureHash
+	c.data.IdentifierToId[userIdentifier] = userId
+	c.data.IdToIdentifier[userId] = userIdentifier
+	c.data.Users[userId] = &User{Id: userId, Active: true, InternalIdentifier: userIdentifier, CreatedAt: createdAt, ApiKeyFirstLetters: apiKeyFirstLetters}
+	return c.storeToFile()
+}
+
+func (c *DBUser) CreateUserWithKey(userId, apiKeyFirstLetters string, weakHash [sha256.Size]byte, createdAt time.Time) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if len(apiKeyFirstLetters) > 3 {
+		return errors.New("api key first letters too long")
+	}
+
+	c.data.ImportedApiKeysWeakHash[userId] = weakHash
+	c.memoryOnlyData.importedApiKeysBlocked = append(c.memoryOnlyData.importedApiKeysBlocked, weakHash)
+	c.data.Users[userId] = &User{
+		Id:                 userId,
+		Active:             true,
+		InternalIdentifier: "imported_" + userId,
+		CreatedAt:          createdAt,
+		ApiKeyFirstLetters: apiKeyFirstLetters,
+		ImportedWithKey:    true,
+	}
+	return c.storeToFile()
+}
+
+func (c *DBUser) RotateKey(userId, apiKeyFirstLetters, secureHash, oldIdentifier, newIdentifier string) error {
+	if len(apiKeyFirstLetters) > 3 {
+		return errors.New("api key first letters too long")
+	}
+
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if _, ok := c.data.Users[userId]; !ok {
+		return fmt.Errorf("user %s does not exist", userId)
+	}
+
+	// replay of old raft commands can have these be ""
+	if oldIdentifier != "" && newIdentifier != "" {
+		c.data.IdToIdentifier[userId] = newIdentifier
+		delete(c.data.IdentifierToId, oldIdentifier)
+		c.data.IdentifierToId[newIdentifier] = userId
+		c.data.Users[userId].InternalIdentifier = newIdentifier
+	}
+	if c.data.Users[userId].ImportedWithKey {
+		c.data.Users[userId].ImportedWithKey = false
+		delete(c.data.ImportedApiKeysWeakHash, userId)
+
+	}
+
+	c.data.Users[userId].ApiKeyFirstLetters = apiKeyFirstLetters
+	c.data.SecureKeyStorageById[userId] = secureHash
+	delete(c.memoryOnlyData.weakKeyStorageById, userId)
+	delete(c.data.UserKeyRevoked, userId)
+	return c.storeToFile()
+}
+
+func (c *DBUser) DeleteUser(userId string) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	delete(c.data.SecureKeyStorageById, userId)
+	delete(c.data.IdentifierToId, c.data.IdToIdentifier[userId])
+	delete(c.data.IdToIdentifier, userId)
+	delete(c.data.Users, userId)
+	delete(c.memoryOnlyData.weakKeyStorageById, userId)
+	delete(c.data.UserKeyRevoked, userId)
+	delete(c.data.ImportedApiKeysWeakHash, userId)
+	return c.storeToFile()
+}
+
+func (c *DBUser) ActivateUser(userId string) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if _, ok := c.data.Users[userId]; !ok {
+		return fmt.Errorf("user %s does not exist", userId)
+	}
+
+	c.data.Users[userId].Active = true
+	return c.storeToFile()
+}
+
+func (c *DBUser) DeactivateUser(userId string, revokeKey bool) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	if _, ok := c.data.Users[userId]; !ok {
+		return fmt.Errorf("user %s does not exist", userId)
+	}
+	if revokeKey {
+		c.data.UserKeyRevoked[userId] = struct{}{}
+	}
+	c.data.Users[userId].Active = false
+
+	return c.storeToFile()
+}
+
+func (c *DBUser) GetUsers(userIds ...string) (map[string]*User, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+
+	if len(userIds) == 0 {
+		return c.data.Users, nil
+	}
+
+	users := make(map[string]*User, len(userIds))
+	for _, id := range userIds {
+		user, ok := c.data.Users[id]
+		if ok {
+			users[id] = user
+		}
+	}
+	return users, nil
+}
+
+func (c *DBUser) CheckUserIdentifierExists(userIdentifier string) (bool, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+
+	_, ok := c.data.Users[userIdentifier]
+	return ok, nil
+}
+
+func (c *DBUser) UpdateLastUsedTimestamp(users map[string]time.Time) {
+	// RLock is fine here, we only want to avoid that c.data.Users is being changed. LastUsed has its own
+	// locking mechanism
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+
+	for userID, lastUsed := range users {
+		if c.data.Users[userID].LastUsedAt.Before(lastUsed) {
+			c.data.Users[userID].Lock()
+			c.data.Users[userID].LastUsedAt = lastUsed
+			c.data.Users[userID].Unlock()
+		}
+	}
+}
+
+func (c *DBUser) ValidateImportedKey(token string) (*models.Principal, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+
+	keyHashGiven := sha256.Sum256([]byte(token))
+	for userId, keyHashStored := range c.data.ImportedApiKeysWeakHash {
+		if subtle.ConstantTimeCompare(keyHashGiven[:], keyHashStored[:]) != 1 {
+			continue
+		}
+		if c.data.Users[userId] != nil && !c.data.Users[userId].Active {
+			return nil, fmt.Errorf("user deactivated")
+		}
+
+		if _, ok := c.data.UserKeyRevoked[userId]; ok {
+			return nil, fmt.Errorf("key is revoked")
+		}
+
+		// Last used time does not have to be exact. If we have multiple concurrent requests for the same
+		// user, only recording one of them is good enough
+		if c.data.Users[userId].TryLock() {
+			c.data.Users[userId].LastUsedAt = time.Now()
+			c.data.Users[userId].Unlock()
+		}
+
+		return &models.Principal{Username: userId, UserType: models.UserTypeInputDb}, nil
+	}
+
+	return nil, nil
+}
+
+func (c *DBUser) IsBlockedKey(token string) bool {
+	keyHashGiven := sha256.Sum256([]byte(token))
+	for _, keyHashStored := range c.memoryOnlyData.importedApiKeysBlocked {
+		if subtle.ConstantTimeCompare(keyHashGiven[:], keyHashStored[:]) == 1 {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *DBUser) ValidateAndExtract(key, userIdentifier string) (*models.Principal, error) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+
+	userId, ok := c.data.IdentifierToId[userIdentifier]
+	if !ok {
+		return nil, fmt.Errorf("invalid token")
+	}
+
+	secureHash, ok := c.data.SecureKeyStorageById[userId]
+	if !ok {
+		return nil, fmt.Errorf("invalid token")
+	}
+	c.weakHashLock.RLock()
+	weakHash, ok := c.memoryOnlyData.weakKeyStorageById[userId]
+	c.weakHashLock.RUnlock()
+	if ok {
+		// use the secureHash as salt for the computation of the weaker in-memory
+		if err := c.validateWeakHash([]byte(key+secureHash), weakHash); err != nil {
+			return nil, err
+		}
+	} else {
+		if err := c.validateStrongHash(key, secureHash, userId); err != nil {
+			return nil, err
+		}
+	}
+
+	if c.data.Users[userId] != nil && !c.data.Users[userId].Active {
+		return nil, fmt.Errorf("user deactivated")
+	}
+	if _, ok := c.data.UserKeyRevoked[userId]; ok {
+		return nil, fmt.Errorf("key is revoked")
+	}
+
+	// Last used time does not have to be exact. If we have multiple concurrent requests for the same
+	// user, only recording one of them is good enough
+	if c.data.Users[userId].TryLock() {
+		c.data.Users[userId].LastUsedAt = time.Now()
+		c.data.Users[userId].Unlock()
+	}
+
+	return &models.Principal{Username: userId, UserType: models.UserTypeInputDb}, nil
+}
+
+func (c *DBUser) validateWeakHash(key []byte, weakHash [32]byte) error {
+	keyHash := sha256.Sum256(key)
+	if subtle.ConstantTimeCompare(keyHash[:], weakHash[:]) != 1 {
+		return fmt.Errorf("invalid token")
+	}
+
+	return nil
+}
+
+func (c *DBUser) validateStrongHash(key, secureHash, userId string) error {
+	match, err := argon2id.ComparePasswordAndHash(key, secureHash)
+	if err != nil {
+		return err
+	}
+	if !match {
+		return fmt.Errorf("invalid token")
+	}
+	token := []byte(key + secureHash)
+	// avoid concurrent writes to map
+	weakHash := sha256.Sum256(token)
+
+	c.weakHashLock.Lock()
+	c.memoryOnlyData.weakKeyStorageById[userId] = weakHash
+	c.weakHashLock.Unlock()
+
+	return nil
+}
+
+func (c *DBUser) Snapshot() ([]byte, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	marshal, err := json.Marshal(DBUserSnapshot{Data: c.data, Version: SnapshotVersion})
+	if err != nil {
+		return nil, err
+	}
+	return marshal, nil
+}
+
+func (c *DBUser) Restore(snapshot []byte) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// don't overwrite with empty snapshot to avoid overwriting recovery from file
+	// with a non-existent db user snapshot when coming from old versions
+	if len(snapshot) == 0 {
+		return nil
+	}
+
+	snapshotRestore := DBUserSnapshot{}
+	err := json.Unmarshal(snapshot, &snapshotRestore)
+	if err != nil {
+		return err
+	}
+
+	if snapshotRestore.Version != SnapshotVersion {
+		return fmt.Errorf("invalid snapshot version")
+	}
+	c.data = snapshotRestore.Data
+
+	return nil
+}
+
+func (c *DBUser) storeToFile() error {
+	data, err := json.Marshal(DBUserSnapshot{Data: c.data, Version: SnapshotVersion})
+	if err != nil {
+		return err
+	}
+
+	tmpFile, err := os.CreateTemp(c.path, "temp-*.tmp")
+	if err != nil {
+		return err
+	}
+	tempFilename := tmpFile.Name()
+
+	defer func() {
+		tmpFile.Close()
+		os.Remove(tempFilename) // Remove temp file if it still exists
+	}()
+
+	// Write data to temp file, flush and close
+	if _, err := tmpFile.Write(data); err != nil {
+		return err
+	}
+	if err := tmpFile.Sync(); err != nil {
+		return err
+	}
+	if err := tmpFile.Close(); err != nil {
+		return err
+	}
+
+	// Atomically rename the temp file to the target filename to not leave garbage when it crashes
+	return os.Rename(tempFilename, c.path+"/"+FileName)
+}
+
+func (c *DBUser) Close() error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	return c.storeToFile()
+}
+
+func createStorage(filePath string) error {
+	if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
+		return fmt.Errorf("failed to create directories: %w", err)
+	}
+
+	_, err := os.Stat(filePath)
+	if err == nil { // file exists
+		return nil
+	}
+
+	if os.IsNotExist(err) {
+		file, err := os.Create(filePath)
+		if err != nil {
+			return fmt.Errorf("failed to create file: %w", err)
+		}
+		defer file.Close()
+		return nil
+	}
+
+	return err
+}
+
+func ReadFile(filename string) ([]byte, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	fileInfo, err := file.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	data := make([]byte, fileInfo.Size())
+
+	_, err = file.Read(data)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/keys/key_generation.go

@@ -0,0 +1,118 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package keys
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"strings"
+
+	"github.com/alexedwards/argon2id"
+)
+
+const (
+	DynUserIdentifier               = "v200" // has to be 4 chars so full key is divisible by 3 and Base64Encoding does not end in "="
+	RandomBytesLength               = 32
+	RandomBytesBase64Length         = 44
+	UserIdentifierBytesLength       = 12
+	UserIdentifierBytesBase64Length = 16
+)
+
+// second recommendation from the RFC: https://www.rfc-editor.org/rfc/rfc9106.html#name-parameter-choice
+// Changing ANY of these parameters will change the output and make previously generated keys invalid.
+var argonParameters = &argon2id.Params{
+	Memory:      64 * 1024,
+	Parallelism: 2,
+	Iterations:  3,
+	SaltLength:  16,
+	KeyLength:   32,
+}
+
+// CreateApiKeyAndHash creates an api key that has three parts:
+// 1) an argon hash of a random key with length 32 bytes (Base64 encoded)
+// 2) a random user identifier with length 10 bytes (Base64 encoded)
+//   - this identifier can be used to fetch the hash later
+//
+// 3) a version string to identify the type of api key
+//
+// The different parts have "_" as separator (which is not part of Base64) and the combined string is encoded again as
+// Base64 to be returned to the user. The apiKey length is divisible by 3 so the Base64Encoding does not end in "=".
+//
+// To verify that a user provides the correct key the following steps have to be taken:
+//   - decode the key into the 3 parts mentioned above using DecodeApiKey
+//   - fetch the saved hash based on the returned user identifier
+//   - compare the returned randomKey with the fetched hash using argon2id.ComparePasswordAndHash
+func CreateApiKeyAndHash() (string, string, string, error) {
+	randomBytesKey, err := generateRandomBytes(RandomBytesLength)
+	if err != nil {
+		return "", "", "", err
+	}
+	randomKey := base64.StdEncoding.EncodeToString(randomBytesKey)
+
+	randomBytesIdentifier, err := generateRandomBytes(UserIdentifierBytesLength)
+	if err != nil {
+		return "", "", "", err
+	}
+	identifier := base64.StdEncoding.EncodeToString(randomBytesIdentifier)
+
+	fullApiKey := generateApiKey(randomKey, identifier)
+
+	hash, err := argon2id.CreateHash(randomKey, argonParameters)
+
+	return fullApiKey, hash, identifier, err
+}
+
+func generateApiKey(randomKey, userIdentifier string) string {
+	fullString := userIdentifier + "_" + randomKey + "_" + DynUserIdentifier
+	return base64.StdEncoding.EncodeToString([]byte(fullString))
+}
+
+func generateRandomBytes(length int) ([]byte, error) {
+	b := make([]byte, length)
+	_, err := rand.Read(b)
+	// Note that err == nil only if we read len(b) bytes.
+	if err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}
+
+func DecodeApiKey(fullApiKey string) (string, string, error) {
+	decodeString, err := base64.StdEncoding.DecodeString(fullApiKey)
+	if err != nil {
+		return "", "", err
+	}
+
+	parts := strings.Split(string(decodeString), "_")
+	if len(parts) != 3 {
+		return "", "", fmt.Errorf("invalid token")
+	}
+
+	userIdentifier := parts[0]
+	randomKey := parts[1]
+	version := parts[2]
+	if version != DynUserIdentifier {
+		return "", "", fmt.Errorf("invalid token")
+	}
+
+	if len(userIdentifier) != UserIdentifierBytesBase64Length {
+		return "", "", fmt.Errorf("invalid token")
+	}
+
+	if len(randomKey) != RandomBytesBase64Length {
+		return "", "", fmt.Errorf("invalid token")
+	}
+
+	return randomKey, userIdentifier, nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/keys/key_generation_test.go

@@ -0,0 +1,69 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package keys
+
+import (
+	"encoding/base64"
+	"strings"
+	"testing"
+
+	"github.com/alexedwards/argon2id"
+	"github.com/stretchr/testify/require"
+)
+
+func TestKeyGeneration(t *testing.T) {
+	fullApiKey, hash, userIdentifier, err := CreateApiKeyAndHash()
+	require.NoError(t, err)
+
+	randomKey, userIdentifierDecoded, err := DecodeApiKey(fullApiKey)
+	require.NoError(t, err)
+	require.Equal(t, userIdentifier, userIdentifierDecoded)
+
+	match, err := argon2id.ComparePasswordAndHash(randomKey, hash)
+	require.NoError(t, err)
+	require.True(t, match)
+}
+
+func TestInvalidKeys(t *testing.T) {
+	randomKeyDummy := strings.Repeat("A", RandomBytesBase64Length)
+	randomIdentifierDummy := strings.Repeat("A", UserIdentifierBytesBase64Length)
+
+	combiner := func(parts ...string) string {
+		return strings.Join(parts, "_")
+	}
+
+	tests := []struct {
+		name  string
+		key   string
+		error bool
+	}{
+		{name: "valid", key: combiner(randomIdentifierDummy, randomKeyDummy, DynUserIdentifier), error: false},
+		{name: "invalid base64", key: "i am a string that is not base64", error: true},
+		{name: "invalid version", key: combiner(randomIdentifierDummy, randomKeyDummy, "v123"), error: true},
+		{name: "missing part", key: combiner(randomIdentifierDummy, randomKeyDummy), error: true},
+		{name: "invalid randomKey", key: combiner(randomIdentifierDummy, randomKeyDummy[:5], DynUserIdentifier), error: true},
+		{name: "invalid identifier", key: combiner(randomIdentifierDummy[:5], randomKeyDummy, DynUserIdentifier), error: true},
+		{name: "all wrong", key: combiner(randomIdentifierDummy[:5], randomKeyDummy[:5], "v123"), error: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			encodedKey := base64.StdEncoding.EncodeToString([]byte(tt.key))
+			_, _, err := DecodeApiKey(encodedKey)
+			if tt.error {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/remote.go

@@ -0,0 +1,57 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package apikey
+
+import (
+	"context"
+	"time"
+)
+
+type RemoteApiKey struct {
+	apikey *DBUser
+}
+
+func NewRemoteApiKey(apikey *ApiKey) *RemoteApiKey {
+	return &RemoteApiKey{apikey: apikey.Dynamic}
+}
+
+func (r *RemoteApiKey) GetUserStatus(ctx context.Context, users UserStatusRequest) (*UserStatusResponse, error) {
+	r.apikey.UpdateLastUsedTimestamp(users.Users)
+
+	if !users.ReturnStatus {
+		return nil, nil
+	}
+
+	userIds := make([]string, 0, len(users.Users))
+	for userId := range users.Users {
+		userIds = append(userIds, userId)
+	}
+	userReturns, err := r.apikey.GetUsers(userIds...)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := make(map[string]time.Time, len(userReturns))
+	for _, userReturn := range userReturns {
+		ret[userReturn.Id] = userReturn.LastUsedAt
+	}
+	return &UserStatusResponse{Users: ret}, nil
+}
+
+type UserStatusResponse struct {
+	Users map[string]time.Time
+}
+
+type UserStatusRequest struct {
+	Users        map[string]time.Time
+	ReturnStatus bool
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/wrapper.go

@@ -0,0 +1,77 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package apikey
+
+import (
+	"fmt"
+
+	"github.com/go-openapi/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authentication/apikey/keys"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+type ApiKey struct {
+	static  *StaticApiKey
+	Dynamic *DBUser
+}
+
+func New(cfg config.Config, logger logrus.FieldLogger) (*ApiKey, error) {
+	static, err := NewStatic(cfg)
+	if err != nil {
+		return nil, err
+	}
+	dynamic, err := NewDBUser(cfg.Persistence.DataPath, cfg.Authentication.DBUsers.Enabled, logger)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ApiKey{
+		static:  static,
+		Dynamic: dynamic,
+	}, nil
+}
+
+func (a *ApiKey) ValidateAndExtract(token string, scopes []string) (*models.Principal, error) {
+	validate := func(token string, scopes []string) (*models.Principal, error) {
+		if a.Dynamic.enabled {
+			if randomKey, userIdentifier, err := keys.DecodeApiKey(token); err == nil {
+				principal, err := a.Dynamic.ValidateAndExtract(randomKey, userIdentifier)
+				if err != nil {
+					return nil, fmt.Errorf("invalid api key: %w", err)
+				}
+				return principal, nil
+			}
+			principal, err := a.Dynamic.ValidateImportedKey(token)
+			if err != nil {
+				return nil, fmt.Errorf("invalid api key: %w", err)
+			}
+			if principal != nil {
+				return principal, nil
+			} else if a.Dynamic.IsBlockedKey(token) {
+				// make sure static keys do not work after import and key rotation
+				return nil, fmt.Errorf("invalid api key")
+			}
+		}
+		if a.static.config.Enabled {
+			return a.static.ValidateAndExtract(token, scopes)
+		}
+		return nil, fmt.Errorf("invalid api key")
+	}
+
+	principal, err := validate(token, scopes)
+	if err != nil {
+		return nil, errors.New(401, "unauthorized: %v", err)
+	}
+	return principal, nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/apikey/wrapper_test.go

@@ -0,0 +1,148 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package apikey
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/usecases/auth/authentication/apikey/keys"
+	"github.com/weaviate/weaviate/usecases/config"
+
+	"github.com/sirupsen/logrus/hooks/test"
+)
+
+func TestInvalidApiKey(t *testing.T) {
+	t.Parallel()
+
+	logger, _ := test.NewNullLogger()
+
+	testCases := []struct {
+		staticEnabled bool
+		dbEnabled     bool
+	}{
+		{staticEnabled: true, dbEnabled: false},
+		{staticEnabled: false, dbEnabled: true},
+		{staticEnabled: true, dbEnabled: true},
+	}
+
+	for _, testCase := range testCases {
+		t.Run("staticEnabled="+boolToStr(testCase.staticEnabled)+",dbEnabled="+boolToStr(testCase.dbEnabled), func(t *testing.T) {
+			conf := config.Config{
+				Persistence: config.Persistence{DataPath: t.TempDir()},
+				Authentication: config.Authentication{
+					DBUsers: config.DbUsers{Enabled: testCase.dbEnabled},
+					APIKey:  config.StaticAPIKey{Enabled: testCase.staticEnabled, AllowedKeys: []string{"valid-key"}, Users: []string{"user1"}},
+				},
+			}
+			wrapper, err := New(conf, logger)
+			require.NoError(t, err)
+
+			_, err = wrapper.ValidateAndExtract("invalid-key", nil)
+			require.Error(t, err)
+			require.Contains(t, err.Error(), "unauthorized: invalid api key")
+		})
+	}
+}
+
+func TestValidStaticKey(t *testing.T) {
+	t.Parallel()
+
+	logger, _ := test.NewNullLogger()
+
+	testCases := []struct {
+		staticEnabled bool
+		dbEnabled     bool
+		expectError   bool
+	}{
+		{staticEnabled: true, dbEnabled: false, expectError: false},
+		{staticEnabled: false, dbEnabled: true, expectError: true},
+		{staticEnabled: true, dbEnabled: true, expectError: false},
+	}
+
+	for _, testCase := range testCases {
+		t.Run("staticEnabled="+boolToStr(testCase.staticEnabled)+",dbEnabled="+boolToStr(testCase.dbEnabled), func(t *testing.T) {
+			conf := config.Config{
+				Persistence: config.Persistence{DataPath: t.TempDir()},
+				Authentication: config.Authentication{
+					DBUsers: config.DbUsers{Enabled: testCase.dbEnabled},
+					APIKey:  config.StaticAPIKey{Enabled: testCase.staticEnabled, AllowedKeys: []string{"valid-key"}, Users: []string{"user1"}},
+				},
+			}
+			wrapper, err := New(conf, logger)
+			require.NoError(t, err)
+
+			principal, err := wrapper.ValidateAndExtract("valid-key", nil)
+			if testCase.expectError {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "unauthorized: invalid api key")
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, principal)
+			}
+		})
+	}
+}
+
+func TestValidDynamicKey(t *testing.T) {
+	t.Parallel()
+
+	logger, _ := test.NewNullLogger()
+
+	testCases := []struct {
+		staticEnabled bool
+		dbEnabled     bool
+		expectError   bool
+	}{
+		{staticEnabled: true, dbEnabled: false, expectError: true},
+		{staticEnabled: false, dbEnabled: true, expectError: false},
+		{staticEnabled: true, dbEnabled: true, expectError: false},
+	}
+
+	for _, testCase := range testCases {
+		t.Run("staticEnabled="+boolToStr(testCase.staticEnabled)+",dbEnabled="+boolToStr(testCase.dbEnabled), func(t *testing.T) {
+			conf := config.Config{
+				Persistence: config.Persistence{DataPath: t.TempDir()},
+				Authentication: config.Authentication{
+					DBUsers: config.DbUsers{Enabled: testCase.dbEnabled},
+					APIKey:  config.StaticAPIKey{Enabled: testCase.staticEnabled, AllowedKeys: []string{"valid-key"}, Users: []string{"user1"}},
+				},
+			}
+			wrapper, err := New(conf, logger)
+			require.NoError(t, err)
+
+			userId := "id"
+
+			apiKey, hash, identifier, err := keys.CreateApiKeyAndHash()
+			require.NoError(t, err)
+
+			require.NoError(t, wrapper.Dynamic.CreateUser(userId, hash, identifier, "", time.Now()))
+
+			principal, err := wrapper.ValidateAndExtract(apiKey, nil)
+			if testCase.expectError {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "unauthorized: invalid api key")
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, principal)
+			}
+		})
+	}
+}
+
+func boolToStr(enabled bool) string {
+	if enabled {
+		return "true"
+	}
+	return "false"
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/authentication.go

@@ -0,0 +1,19 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package authentication
+
+type AuthType string
+
+const (
+	AuthTypeDb   AuthType = "db"
+	AuthTypeOIDC AuthType = "oidc"
+)

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/composer/token_validation.go

@@ -0,0 +1,61 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package composer
+
+import (
+	"github.com/golang-jwt/jwt/v4"
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+type TokenFunc func(token string, scopes []string) (*models.Principal, error)
+
+// New provides an OpenAPI compatible token validation
+// function that validates the token either as OIDC or as an StaticAPIKey token
+// depending on which is configured. If both are configured, the scheme is
+// figured out at runtime.
+func New(config config.Authentication,
+	apikey authValidator, oidc authValidator,
+) TokenFunc {
+	if config.AnyApiKeyAvailable() && config.OIDC.Enabled {
+		return pickAuthSchemeDynamically(apikey, oidc)
+	}
+
+	if config.AnyApiKeyAvailable() {
+		return apikey.ValidateAndExtract
+	}
+
+	// default to OIDC, even if no scheme is enabled, then it can deal with this
+	// scenario itself. This is the backward-compatible scenario.
+	return oidc.ValidateAndExtract
+}
+
+func pickAuthSchemeDynamically(
+	apiKey authValidator, oidc authValidator,
+) TokenFunc {
+	return func(token string, scopes []string) (*models.Principal, error) {
+		_, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
+			return nil, nil
+		})
+
+		if err != nil && errors.Is(err, jwt.ErrTokenMalformed) {
+			return apiKey.ValidateAndExtract(token, scopes)
+		}
+
+		return oidc.ValidateAndExtract(token, scopes)
+	}
+}
+
+type authValidator interface {
+	ValidateAndExtract(token string, scopes []string) (*models.Principal, error)
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/composer/token_validation_test.go

@@ -0,0 +1,240 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package composer
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func Test_TokenAuthComposer(t *testing.T) {
+	type test struct {
+		name         string
+		token        string
+		config       config.Authentication
+		oidc         TokenFunc
+		apiKey       TokenFunc
+		expectErr    bool
+		expectErrMsg string
+	}
+
+	tests := []test{
+		{
+			name: "everything disabled - pass to oidc provider (backward compat)",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: false,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: false,
+				},
+			},
+			token: "does not matter",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				return nil, nil
+			},
+			expectErr: false,
+		},
+		{
+			name: "everything disabled - pass to oidc provider fail",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: false,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: false,
+				},
+			},
+			token: "does not matter",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				return nil, fmt.Errorf("oidc says nope!")
+			},
+			expectErr:    true,
+			expectErrMsg: "oidc says nope!",
+		},
+		{
+			name: "only oidc enabled, returns success",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: true,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: false,
+				},
+			},
+			token: "does not matter",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				return nil, nil
+			},
+			expectErr: false,
+		},
+		{
+			name: "only oidc enabled, returns no success",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: true,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: false,
+				},
+			},
+			token: "does not matter",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				return nil, fmt.Errorf("thou shalt not pass")
+			},
+			expectErr:    true,
+			expectErrMsg: "thou shalt not pass",
+		},
+		{
+			name: "only apiKey enabled, returns success",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: false,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: true,
+				},
+			},
+			token: "does not matter",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				return nil, nil
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			expectErr: false,
+		},
+		{
+			name: "only apiKey enabled, returns no success",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: false,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: true,
+				},
+			},
+			token: "does not matter",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				return nil, fmt.Errorf("you think I let anyone through?")
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			expectErr:    true,
+			expectErrMsg: "you think I let anyone through?",
+		},
+		{
+			name: "both an enabled, with an 'obvious' api key",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: true,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: true,
+				},
+			},
+			token: "does not matter",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				return nil, fmt.Errorf("it's a pretty key, but not good enough")
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			expectErr:    true,
+			expectErrMsg: "it's a pretty key, but not good enough",
+		},
+		{
+			name: "both an enabled, empty token",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: true,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: true,
+				},
+			},
+			token: "",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				return nil, fmt.Errorf("really? an empty one?")
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			expectErr:    true,
+			expectErrMsg: "empty one",
+		},
+		{
+			name: "both an enabled, jwt token",
+			config: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled: true,
+				},
+				APIKey: config.StaticAPIKey{
+					Enabled: true,
+				},
+			},
+			token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+			apiKey: func(t string, s []string) (*models.Principal, error) {
+				panic("i should never be called")
+			},
+			oidc: func(t string, s []string) (*models.Principal, error) {
+				return nil, fmt.Errorf("john doe ... that sounds like a fake name!")
+			},
+			expectErr:    true,
+			expectErrMsg: "john doe",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			v := New(
+				test.config,
+				fakeValidator{v: test.apiKey},
+				fakeValidator{v: test.oidc},
+			)
+			_, err := v(test.token, nil)
+			if test.expectErr {
+				require.NotNil(t, err)
+				assert.Contains(t, err.Error(), test.expectErrMsg)
+				return
+			}
+
+			require.Nil(t, err)
+		})
+	}
+}
+
+type fakeValidator struct {
+	v TokenFunc
+}
+
+func (v fakeValidator) ValidateAndExtract(t string, s []string) (*models.Principal, error) {
+	return v.v(t, s)
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/oidc/middleware.go

@@ -0,0 +1,298 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package oidc
+
+import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/pem"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/coreos/go-oidc/v3/oidc"
+	errors "github.com/go-openapi/errors"
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+// Client handles the OIDC setup at startup and provides a middleware to be
+// used with the goswagger API
+type Client struct {
+	Config   config.OIDC
+	verifier *oidc.IDTokenVerifier
+	logger   logrus.FieldLogger
+}
+
+// New OIDC Client: It tries to retrieve the JWKs at startup (or fails), it
+// provides a middleware which can be used at runtime with a go-swagger style
+// API
+func New(cfg config.Config, logger logrus.FieldLogger) (*Client, error) {
+	client := &Client{
+		Config: cfg.Authentication.OIDC,
+		logger: logger.WithField("component", "oidc"),
+	}
+
+	if !client.Config.Enabled {
+		// if oidc is not enabled, we are done, no need to setup an actual client.
+		// The "disabled" client is however still valuable to deny any requests
+		// coming in with an OAuth token set.
+		return client, nil
+	}
+
+	if err := client.Init(); err != nil {
+		return nil, fmt.Errorf("oidc init: %w", err)
+	}
+
+	return client, nil
+}
+
+func (c *Client) Init() error {
+	if err := c.validateConfig(); err != nil {
+		return fmt.Errorf("invalid config: %w", err)
+	}
+	c.logger.WithField("action", "oidc_init").Info("validated OIDC configuration")
+
+	ctx := context.Background()
+	if c.Config.Certificate.Get() != "" {
+		client, err := c.useCertificate()
+		if err != nil {
+			return fmt.Errorf("could not setup client with custom certificate: %w", err)
+		}
+		ctx = oidc.ClientContext(ctx, client)
+		c.logger.WithField("action", "oidc_init").Info("configured OIDC client with custom certificate")
+	}
+
+	if c.Config.JWKSUrl.Get() != "" {
+		keySet := oidc.NewRemoteKeySet(ctx, c.Config.JWKSUrl.Get())
+		verifier := oidc.NewVerifier(c.Config.Issuer.Get(), keySet, &oidc.Config{
+			ClientID:          c.Config.ClientID.Get(),
+			SkipClientIDCheck: c.Config.SkipClientIDCheck.Get(),
+		})
+		c.verifier = verifier
+		c.logger.WithField("action", "oidc_init").WithField("jwks_url", c.Config.JWKSUrl.Get()).Info("configured OIDC verifier")
+	} else {
+		provider, err := oidc.NewProvider(ctx, c.Config.Issuer.Get())
+		if err != nil {
+			return fmt.Errorf("could not setup provider: %w", err)
+		}
+		c.logger.WithField("action", "oidc_init").Info("configured OIDC provider")
+
+		// oauth2
+
+		verifier := provider.Verifier(&oidc.Config{
+			ClientID:          c.Config.ClientID.Get(),
+			SkipClientIDCheck: c.Config.SkipClientIDCheck.Get(),
+		})
+		c.verifier = verifier
+		c.logger.WithField("action", "oidc_init").Info("configured OIDC verifier")
+	}
+
+	return nil
+}
+
+func (c *Client) validateConfig() error {
+	var msgs []string
+
+	if c.Config.Issuer.Get() == "" {
+		msgs = append(msgs, "missing required field 'issuer'")
+	}
+
+	if c.Config.UsernameClaim.Get() == "" {
+		msgs = append(msgs, "missing required field 'username_claim'")
+	}
+
+	if !c.Config.SkipClientIDCheck.Get() && c.Config.ClientID.Get() == "" {
+		msgs = append(msgs, "missing required field 'client_id': "+
+			"either set a client_id or explicitly disable the check with 'skip_client_id_check: true'")
+	}
+
+	if len(msgs) == 0 {
+		return nil
+	}
+
+	return fmt.Errorf("%v", strings.Join(msgs, ", "))
+}
+
+// ValidateAndExtract can be used as a middleware for go-swagger
+func (c *Client) ValidateAndExtract(token string, scopes []string) (*models.Principal, error) {
+	if !c.Config.Enabled {
+		return nil, errors.New(401, "oidc auth is not configured, please try another auth scheme or set up weaviate with OIDC configured")
+	}
+
+	parsed, err := c.verifier.Verify(context.Background(), token)
+	if err != nil {
+		return nil, errors.New(401, "unauthorized: %v", err)
+	}
+
+	claims, err := c.extractClaims(parsed)
+	if err != nil {
+		return nil, errors.New(500, "oidc: %v", err)
+	}
+
+	username, err := c.extractUsername(claims)
+	if err != nil {
+		return nil, errors.New(500, "oidc: %v", err)
+	}
+
+	groups := c.extractGroups(claims)
+
+	return &models.Principal{
+		Username: username,
+		Groups:   groups,
+		UserType: models.UserTypeInputOidc,
+	}, nil
+}
+
+func (c *Client) extractClaims(token *oidc.IDToken) (map[string]interface{}, error) {
+	var claims map[string]interface{}
+	if err := token.Claims(&claims); err != nil {
+		return nil, fmt.Errorf("could not extract claims from token: %w", err)
+	}
+
+	return claims, nil
+}
+
+func (c *Client) extractUsername(claims map[string]interface{}) (string, error) {
+	usernameUntyped, ok := claims[c.Config.UsernameClaim.Get()]
+	if !ok {
+		return "", fmt.Errorf("token doesn't contain required claim '%s'", c.Config.UsernameClaim.Get())
+	}
+
+	username, ok := usernameUntyped.(string)
+	if !ok {
+		return "", fmt.Errorf("claim '%s' is not a string, but %T", c.Config.UsernameClaim.Get(), usernameUntyped)
+	}
+
+	return username, nil
+}
+
+// extractGroups never errors, if groups can't be parsed an empty set of groups
+// is returned. This is because groups are not a required standard in the OIDC
+// spec, so we can't error if an OIDC provider does not support them.
+func (c *Client) extractGroups(claims map[string]interface{}) []string {
+	var groups []string
+
+	groupsUntyped, ok := claims[c.Config.GroupsClaim.Get()]
+	if !ok {
+		return groups
+	}
+
+	groupsSlice, ok := groupsUntyped.([]interface{})
+	if !ok {
+		groupAsString, ok := groupsUntyped.(string)
+		if ok {
+			return []string{groupAsString}
+		}
+		return groups
+	}
+
+	for _, untyped := range groupsSlice {
+		if group, ok := untyped.(string); ok {
+			groups = append(groups, group)
+		}
+	}
+
+	return groups
+}
+
+func (c *Client) useCertificate() (*http.Client, error) {
+	var certificate, certificateSource string
+	if strings.HasPrefix(c.Config.Certificate.Get(), "http") {
+		resp, err := http.Get(c.Config.Certificate.Get())
+		if err != nil {
+			return nil, fmt.Errorf("failed to get certificate from %s: %w", c.Config.Certificate.Get(), err)
+		}
+		defer resp.Body.Close()
+		if resp.StatusCode != http.StatusOK {
+			return nil, fmt.Errorf("failed to download certificate from %s: http status: %v", c.Config.Certificate.Get(), resp.StatusCode)
+		}
+		certBytes, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read certificate from %s: %w", c.Config.Certificate.Get(), err)
+		}
+		certificate = string(certBytes)
+		certificateSource = c.Config.Certificate.Get()
+	} else if strings.HasPrefix(c.Config.Certificate.Get(), "s3://") {
+		parts := strings.TrimPrefix(c.Config.Certificate.Get(), "s3://")
+		segments := strings.SplitN(parts, "/", 2)
+		if len(segments) != 2 {
+			return nil, fmt.Errorf("invalid S3 URI, must contain bucket and key: %s", c.Config.Certificate.Get())
+		}
+		region := os.Getenv("AWS_REGION")
+		if region == "" {
+			region = os.Getenv("AWS_DEFAULT_REGION")
+		}
+		creds := credentials.NewIAM("")
+		// check if we are able to get the credentials using AWS IAM
+		if _, err := creds.GetWithContext(nil); err != nil {
+			// if IAM doesn't work, check environment settings for creds, set anonymous access if none found
+			creds = credentials.NewEnvAWS()
+		}
+		bucketName, objectKey := segments[0], segments[1]
+		minioClient, err := minio.New("s3.amazonaws.com", &minio.Options{
+			Creds:  creds,
+			Secure: true,
+			Region: region,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to create S3 client: %w", err)
+		}
+		object, err := minioClient.GetObject(context.Background(), bucketName, objectKey, minio.GetObjectOptions{})
+		if err != nil {
+			return nil, fmt.Errorf("failed to get certificate from: %s: %w", c.Config.Certificate.Get(), err)
+		}
+		defer object.Close()
+		var content bytes.Buffer
+		if _, err := io.Copy(&content, object); err != nil {
+			return nil, fmt.Errorf("failed to read certificate from %s: %w", c.Config.Certificate.Get(), err)
+		}
+		certificate = content.String()
+		certificateSource = c.Config.Certificate.Get()
+	} else {
+		certificate = c.Config.Certificate.Get()
+		certificateSource = "environment variable"
+	}
+
+	certBlock, _ := pem.Decode([]byte(certificate))
+	if certBlock == nil || len(certBlock.Bytes) == 0 {
+		return nil, fmt.Errorf("failed to decode certificate")
+	}
+	cert, err := x509.ParseCertificate(certBlock.Bytes)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse certificate: %w", err)
+	}
+
+	c.logger.WithField("action", "oidc_init").WithField("source", certificateSource).Info("custom certificate is valid")
+
+	certPool := x509.NewCertPool()
+	certPool.AddCert(cert)
+
+	// Create an HTTP client with self signed certificate
+	client := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{
+				RootCAs:    certPool,
+				MinVersion: tls.VersionTLS12,
+			},
+		},
+	}
+
+	return client, nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/oidc/middleware_test.go

@@ -0,0 +1,279 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package oidc
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	errors "github.com/go-openapi/errors"
+	"github.com/golang-jwt/jwt/v4"
+	"github.com/sirupsen/logrus"
+	logrustest "github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/usecases/config"
+	"github.com/weaviate/weaviate/usecases/config/runtime"
+)
+
+func Test_Middleware_NotConfigured(t *testing.T) {
+	cfg := config.Config{
+		Authentication: config.Authentication{
+			OIDC: config.OIDC{
+				Enabled: false,
+			},
+		},
+	}
+	expectedErr := errors.New(401, "oidc auth is not configured, please try another auth scheme or set up weaviate with OIDC configured")
+
+	logger, _ := logrustest.NewNullLogger()
+	client, err := New(cfg, logger)
+	require.Nil(t, err)
+
+	principal, err := client.ValidateAndExtract("token-doesnt-matter", []string{})
+	assert.Nil(t, principal)
+	assert.Equal(t, expectedErr, err)
+}
+
+func Test_Middleware_IncompleteConfiguration(t *testing.T) {
+	cfg := config.Config{
+		Authentication: config.Authentication{
+			OIDC: config.OIDC{
+				Enabled: true,
+			},
+		},
+	}
+	expectedErr := fmt.Errorf("oidc init: invalid config: missing required field 'issuer', " +
+		"missing required field 'username_claim', missing required field 'client_id': either set a client_id or explicitly disable the check with 'skip_client_id_check: true'")
+
+	logger, _ := logrustest.NewNullLogger()
+	_, err := New(cfg, logger)
+	assert.ErrorAs(t, err, &expectedErr)
+}
+
+type claims struct {
+	jwt.StandardClaims
+	Email         string   `json:"email"`
+	Groups        []string `json:"groups"`
+	GroupAsString string   `json:"group_as_string"`
+}
+
+func Test_Middleware_WithValidToken(t *testing.T) {
+	t.Run("without groups set", func(t *testing.T) {
+		server := newOIDCServer(t)
+		defer server.Close()
+
+		cfg := config.Config{
+			Authentication: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled:           true,
+					Issuer:            runtime.NewDynamicValue(server.URL),
+					ClientID:          runtime.NewDynamicValue("best_client"),
+					SkipClientIDCheck: runtime.NewDynamicValue(false),
+					UsernameClaim:     runtime.NewDynamicValue("sub"),
+				},
+			},
+		}
+
+		token := token(t, "best-user", server.URL, "best_client")
+		logger, _ := logrustest.NewNullLogger()
+		client, err := New(cfg, logger)
+		require.Nil(t, err)
+
+		principal, err := client.ValidateAndExtract(token, []string{})
+		require.Nil(t, err)
+		assert.Equal(t, "best-user", principal.Username)
+	})
+
+	t.Run("with a non-standard username claim", func(t *testing.T) {
+		server := newOIDCServer(t)
+		defer server.Close()
+
+		cfg := config.Config{
+			Authentication: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled:           true,
+					Issuer:            runtime.NewDynamicValue(server.URL),
+					ClientID:          runtime.NewDynamicValue("best_client"),
+					SkipClientIDCheck: runtime.NewDynamicValue(false),
+					UsernameClaim:     runtime.NewDynamicValue("email"),
+					GroupsClaim:       runtime.NewDynamicValue("groups"),
+				},
+			},
+		}
+
+		token := tokenWithEmail(t, "best-user", server.URL, "best_client", "foo@bar.com")
+		logger, _ := logrustest.NewNullLogger()
+		client, err := New(cfg, logger)
+		require.Nil(t, err)
+
+		principal, err := client.ValidateAndExtract(token, []string{})
+		require.Nil(t, err)
+		assert.Equal(t, "foo@bar.com", principal.Username)
+	})
+
+	t.Run("with groups claim", func(t *testing.T) {
+		server := newOIDCServer(t)
+		defer server.Close()
+
+		cfg := config.Config{
+			Authentication: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled:           true,
+					Issuer:            runtime.NewDynamicValue(server.URL),
+					ClientID:          runtime.NewDynamicValue("best_client"),
+					SkipClientIDCheck: runtime.NewDynamicValue(false),
+					UsernameClaim:     runtime.NewDynamicValue("sub"),
+					GroupsClaim:       runtime.NewDynamicValue("groups"),
+				},
+			},
+		}
+
+		token := tokenWithGroups(t, "best-user", server.URL, "best_client", []string{"group1", "group2"})
+		logger, _ := logrustest.NewNullLogger()
+		client, err := New(cfg, logger)
+		require.Nil(t, err)
+
+		principal, err := client.ValidateAndExtract(token, []string{})
+		require.Nil(t, err)
+		assert.Equal(t, "best-user", principal.Username)
+		assert.Equal(t, []string{"group1", "group2"}, principal.Groups)
+	})
+
+	t.Run("with a string groups claim", func(t *testing.T) {
+		server := newOIDCServer(t)
+		defer server.Close()
+
+		cfg := config.Config{
+			Authentication: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled:           true,
+					Issuer:            runtime.NewDynamicValue(server.URL),
+					ClientID:          runtime.NewDynamicValue("best_client"),
+					SkipClientIDCheck: runtime.NewDynamicValue(false),
+					UsernameClaim:     runtime.NewDynamicValue("sub"),
+					GroupsClaim:       runtime.NewDynamicValue("group_as_string"),
+				},
+			},
+		}
+
+		token := tokenWithStringGroups(t, "best-user", server.URL, "best_client", "group1")
+		logger, _ := logrustest.NewNullLogger()
+		client, err := New(cfg, logger)
+		require.Nil(t, err)
+
+		principal, err := client.ValidateAndExtract(token, []string{})
+		require.Nil(t, err)
+		assert.Equal(t, "best-user", principal.Username)
+		assert.Equal(t, []string{"group1"}, principal.Groups)
+	})
+}
+
+func token(t *testing.T, subject string, issuer string, aud string) string {
+	return tokenWithEmail(t, subject, issuer, aud, "")
+}
+
+func tokenWithEmail(t *testing.T, subject string, issuer string, aud string, email string) string {
+	claims := claims{
+		Email: email,
+	}
+
+	return tokenWithClaims(t, subject, issuer, aud, claims)
+}
+
+func tokenWithGroups(t *testing.T, subject string, issuer string, aud string, groups []string) string {
+	claims := claims{
+		Groups: groups,
+	}
+
+	return tokenWithClaims(t, subject, issuer, aud, claims)
+}
+
+func tokenWithStringGroups(t *testing.T, subject string, issuer string, aud string, groups string) string {
+	claims := claims{
+		GroupAsString: groups,
+	}
+
+	return tokenWithClaims(t, subject, issuer, aud, claims)
+}
+
+func tokenWithClaims(t *testing.T, subject string, issuer string, aud string, claims claims) string {
+	claims.StandardClaims = jwt.StandardClaims{
+		Subject:   subject,
+		Issuer:    issuer,
+		Audience:  aud,
+		ExpiresAt: time.Now().Add(10 * time.Second).Unix(),
+	}
+
+	token, err := signToken(claims)
+	require.Nil(t, err, "signing token should not error")
+
+	return token
+}
+
+func Test_Middleware_CertificateDownload(t *testing.T) {
+	newClientWithCertificate := func(certificate string) (*Client, *logrustest.Hook) {
+		logger, loggerHook := logrustest.NewNullLogger()
+		logger.SetLevel(logrus.InfoLevel)
+		cfg := config.Config{
+			Authentication: config.Authentication{
+				OIDC: config.OIDC{
+					Enabled:     true,
+					Certificate: runtime.NewDynamicValue(certificate),
+				},
+			},
+		}
+		client := &Client{
+			Config: cfg.Authentication.OIDC,
+			logger: logger.WithField("component", "oidc"),
+		}
+		return client, loggerHook
+	}
+
+	verifyLogs := func(t *testing.T, loggerHook *logrustest.Hook, certificateSource string) {
+		for _, logEntry := range loggerHook.AllEntries() {
+			assert.Contains(t, logEntry.Message, "custom certificate is valid")
+			assert.Contains(t, logEntry.Data["source"], certificateSource)
+			assert.Contains(t, logEntry.Data["action"], "oidc_init")
+			assert.Contains(t, logEntry.Data["component"], "oidc")
+		}
+	}
+
+	t.Run("certificate string", func(t *testing.T) {
+		client, loggerHook := newClientWithCertificate(testingCertificate)
+		clientWithCertificate, err := client.useCertificate()
+		require.NoError(t, err)
+		require.NotNil(t, clientWithCertificate)
+		verifyLogs(t, loggerHook, "environment variable")
+	})
+
+	t.Run("certificate URL", func(t *testing.T) {
+		certificateServer := newServerWithCertificate()
+		defer certificateServer.Close()
+		source := certificateURL(certificateServer)
+		client, loggerHook := newClientWithCertificate(source)
+		clientWithCertificate, err := client.useCertificate()
+		require.NoError(t, err)
+		require.NotNil(t, clientWithCertificate)
+		verifyLogs(t, loggerHook, source)
+	})
+
+	t.Run("unparseable string", func(t *testing.T) {
+		client, _ := newClientWithCertificate("unparseable")
+		clientWithCertificate, err := client.useCertificate()
+		require.Nil(t, clientWithCertificate)
+		require.Error(t, err)
+		assert.ErrorContains(t, err, "failed to decode certificate")
+	})
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/oidc/oidc_server_for_test.go

@@ -0,0 +1,115 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package oidc
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	jose "github.com/go-jose/go-jose/v4"
+	"github.com/golang-jwt/jwt/v4"
+)
+
+func newOIDCServer(t *testing.T) *httptest.Server {
+	// we need to start up with an empty handler
+	s := httptest.NewServer(nil)
+
+	// so that we can configure it once we now the url, this is used to match the
+	// issue field
+	s.Config.Handler = oidcHandler(t, s.URL)
+	return s
+}
+
+type oidcDiscovery struct {
+	Issuer  string `json:"issuer"`
+	JWKSUri string `json:"jwks_uri"`
+}
+
+type jwksResponse struct {
+	Keys []jose.JSONWebKey `json:"keys"`
+}
+
+func oidcHandler(t *testing.T, url string) http.Handler {
+	mux := http.NewServeMux()
+
+	publicKey, err := jwt.ParseRSAPublicKeyFromPEM([]byte(testingPublicKey))
+	if err != nil {
+		t.Fatalf("test server: couldn't parse public key: %v", err)
+	}
+
+	mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Add("Content-Type", "application/json")
+		d := oidcDiscovery{
+			Issuer:  url,
+			JWKSUri: fmt.Sprintf("%v/.well-known/jwks", url),
+		}
+		json.NewEncoder(w).Encode(d)
+	})
+
+	mux.HandleFunc("/.well-known/jwks", func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Add("Content-Type", "application/json")
+		d := jwksResponse{
+			Keys: []jose.JSONWebKey{
+				{
+					Key:       publicKey,
+					Use:       "sig",
+					Algorithm: string(jose.RS256),
+					KeyID:     "my-key",
+				},
+			},
+		}
+		if err := json.NewEncoder(w).Encode(d); err != nil {
+			t.Fatalf("encoding jwks in test server: %v", err)
+		}
+	})
+
+	return mux
+}
+
+// those keys are intended to make it possible to sign our own tokens in tests.
+// Never use these keys for anything outside a test scenario!
+
+var testingPrivateKey = `-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQDFRV9sD1ULVV7q1w9OXCXPTFRcrTYAZAVZwg8X9V1QyBd8eyp5
+OMI4YxuL7sk+Las+PTcS6AdrHitdDZNqUjWFYOo5EQLnVBghIlu3ZWlAnM2SCPo5
+e2jFD8IgAVHtkAHbFUliQtP6a6OOLMRq9GMhIv2ZWf79KyXvh5DFuM7zbwIDAQAB
+AoGAXptEhghcWtEYcjutZYEfyOjsVH3lNg7B2igNIQpVNFahnNtcpUIpMu2k2lks
+Phuc0n59GR4Z4K9ZUIkgN48xhuqDtHevMQLfg6KQaqf0KRwxBw4dIOhUX0aLkvcJ
+WTtUPE+3hYbOuAPuXVBDB6hBZAe5mbvLPYDM3yYyRotbN7ECQQD/S3Y+shEHOMg1
+ve1eQ4tjN+5Fdmq8l2JIbOPpvH6ytiEQSV2Q55u8gL+1x5Tb9vh3rAdg2OJ0LFay
+VTqmCmkDAkEAxdDgvDqk7JwMbM2jxozVEcECoN07eGrshVWlXtnEpJgU4vBN8wAj
+sS94WZCWu4LZRzPHp36dVDiPFS0aqGlCJQJAMGKX/Zf4HDtJzs25YEVC9MIT+bxQ
+zH+QlBN3OsSL6skUCScugZkz7g0kyIoUD4CGZQAIwfU5LjV9FP2MSQ3uCwJAZxS0
+t4F7xcx/cQcry+BBe7HvU7JVNifJvqVlumqSXQ7e+28rv3AYKVHKTinZUjcaUE88
+QBzrkSKz9N3/ITlQfQJBAL25aXdmooBdYQUvXmNu+n10wwDAqCKtoGW75cZBJvjX
+WnBQsDVlzaBcs32lr08XZIAH318OibfmAs5HKHABoFk=
+-----END RSA PRIVATE KEY-----`
+
+var testingPublicKey = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDFRV9sD1ULVV7q1w9OXCXPTFRc
+rTYAZAVZwg8X9V1QyBd8eyp5OMI4YxuL7sk+Las+PTcS6AdrHitdDZNqUjWFYOo5
+EQLnVBghIlu3ZWlAnM2SCPo5e2jFD8IgAVHtkAHbFUliQtP6a6OOLMRq9GMhIv2Z
+Wf79KyXvh5DFuM7zbwIDAQAB
+-----END PUBLIC KEY-----`
+
+func signToken(claims jwt.Claims) (string, error) {
+	token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
+	key, err := jwt.ParseRSAPrivateKeyFromPEM([]byte(testingPrivateKey))
+	if err != nil {
+		return "", err
+	}
+
+	return token.SignedString(key)
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authentication/oidc/oidc_server_with_certificate_for_test.go

@@ -0,0 +1,79 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package oidc
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"time"
+)
+
+const testCertificateFilename = "certificate.crt"
+
+func newServerWithCertificate() *httptest.Server {
+	mux := http.NewServeMux()
+	mux.HandleFunc(fmt.Sprintf("/%s", testCertificateFilename), downloadHandler)
+	s := httptest.NewServer(mux)
+	return s
+}
+
+func certificateURL(s *httptest.Server) string {
+	return fmt.Sprintf("%s/%s", s.URL, testCertificateFilename)
+}
+
+func downloadHandler(w http.ResponseWriter, r *http.Request) {
+	fileName := testCertificateFilename
+	// Create in-memory buffer
+	buffer := bytes.NewBufferString(testingCertificate)
+
+	// Set headers
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", fileName))
+	w.Header().Set("Content-Type", "text/plain")
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", buffer.Len()))
+
+	// Serve file from memory
+	http.ServeContent(w, r, fileName, time.Now(), bytes.NewReader(buffer.Bytes()))
+}
+
+// This certificate is only intended for tests so that certificate parsing step won't fail
+// Never use these certificate for anything outside a test scenario!
+var testingCertificate = `-----BEGIN CERTIFICATE-----
+MIIE8zCCAtugAwIBAgIUXiJ3NER2OjKPD4f4QehH+NRsujIwDQYJKoZIhvcNAQEL
+BQAwFDESMBAGA1UEAwwJbW9jay1vaWRjMB4XDTI1MDYxMzE3MjEyNVoXDTI2MDYx
+MzE3MjEyNVowFDESMBAGA1UEAwwJbW9jay1vaWRjMIICIjANBgkqhkiG9w0BAQEF
+AAOCAg8AMIICCgKCAgEAvJ8n2h7h0ZKNO20MCQuUOn9eyA+VKtkkkoXfZFpsZ/vv
+fvdOe9hNz+X9igJVugfwi9MgKhfPUnGOoWXJB8uwJl4yeHV8lzd5dXYkp3Pi6oCg
+PkGsOwOL7KPQWkCcJDNY8Nj2IsaP+VsdQY2ydCaryztyUBZ8nKs6HWOFsMEPVQUt
+01SDcWT8lBet6GZ+4QxY+JTnBCZCDoQUk9VAOWucstGfJ9lrC8PBNRNjIXtq88dR
+d4e78RRdTrErwZstZgsjXvfoudNuHeAq5RdCBBuc95sCzHvcbsP7qn4JMDCtk1Xn
+y7Jlh2gTAdLEjqj7yZHgmcRuDTv4AGY3jHXgB2dSYu9PXGBJR0x75O9ILfF/Rvgh
+xqsaqTDmC7lFp1Tc7W0LC0joG0qsmD5Co1xhHpeivsydhI0FKcjZGp0tcKLdE8Nr
+O+za2Tl8IDHkMUBNn1Spf0+MXCX5gVvWkqsvegin6+zz++0ncEqSZLJ1vhUywiJO
+NnNRw8N3iYNfpuFKY3SWGOECVfw57Uzl3YD7p5HNBUSRgjIV5oPtJpluWPb9/v1X
+1uYoBmerRQ48GOW/S+OeMHoTNHpGT+yFUYlooStsKUzlVg6qgDgGzciXllvSXlNP
+aIk1el5LRWCQ+7NdxyIDZ7z018d5/Nvq4TGtYMxPJ1q2UslsuT8ma8kRdZDLAmcC
+AwEAAaM9MDswGgYDVR0RBBMwEYIJbW9jay1vaWRjhwR/AAABMB0GA1UdDgQWBBTV
+UEwK/9twnd+iP0B7eZFjR9eB3DANBgkqhkiG9w0BAQsFAAOCAgEAeAImntOcqGnN
+30Y3I36v1tyYC3U109AatLarHvMglhkwmCPjStel0GuyOyxxpnzpbe17vlxSF4Bg
+u/fXoM1PrPn0As/5/MQdbxZs5mDMc1D5ykpo0T+CYlgJNzxBDjCz+lODGf4vH9Ud
+4ZKLWss0QCYCuF7psyOvwM223mWa63SvWgIBI7vBXcHwk5y4nVAb6jGZVTx0D9Xw
+OTDsxeevpfndTuXQdSHQ09hZlmify7alAPC88Ef3oaudli8QjkNasQswAVKp+0V6
+jKYEHe0XUWcdKX3kT0I1jynh7EKcR/eiHePJv9tR2Trn8bAdgnqvmUwgKPx8mOTp
+tXpkz/72v3Rbbp7/mmg3U9XVIe9i7jroa05sRrrnoqW0j1EGft8MEqYw8gspnbEw
+OI0tw+zwMZ0ikkZzxCn4kn+TRuzGEvUQMz32T++v7YiQwZMgRLOSTuCov0G3Co8F
+LIZf11PYTnOSAmwBLDiONbBOP5OJLnvscZc9bYeEBjSUvFnDeuEb7JduvYuDbche
+zGO07I7oRupj0lzXVtFJJ8D/lTjl9usQ6pFXoFEI8WaOKcUA+kFEHUfKQ9QPrJsP
+MtlI4pJn5rg9W195YH0eMj06QXuy4qi/pPZQHLfx4V7UpVydWemWXeYxVpwy0j2j
+9CEbs0CkTGfHn/7DvYbVqIy/QMVxsMU=
+-----END CERTIFICATE-----`

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/adminlist/authorizer.go

@@ -0,0 +1,133 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package adminlist
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/errors"
+)
+
+const AnonymousPrincipalUsername = "anonymous"
+
+// Authorizer provides either full (admin) or no access
+type Authorizer struct {
+	adminUsers     map[string]int
+	readOnlyUsers  map[string]int
+	adminGroups    map[string]int
+	readOnlyGroups map[string]int
+}
+
+// New Authorizer using the AdminList method
+func New(cfg Config) *Authorizer {
+	a := &Authorizer{}
+	a.addAdminUserList(cfg.Users)
+	a.addReadOnlyUserList(cfg.ReadOnlyUsers)
+	a.addAdminGroupList(cfg.Groups)
+	a.addReadOnlyGroupList(cfg.ReadOnlyGroups)
+	return a
+}
+
+// Authorize will give full access (to any resource!) if the user is part of
+// the admin list or no access at all if they are not
+func (a *Authorizer) Authorize(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	if principal == nil {
+		principal = newAnonymousPrincipal()
+	}
+
+	if _, ok := a.adminUsers[principal.Username]; ok {
+		return nil
+	}
+
+	for _, group := range principal.Groups {
+		if _, ok := a.adminGroups[group]; ok {
+			return nil
+		}
+	}
+
+	if verb == "R" {
+		if _, ok := a.readOnlyUsers[principal.Username]; ok {
+			return nil
+		}
+		for _, group := range principal.Groups {
+			if _, ok := a.readOnlyGroups[group]; ok {
+				return nil
+			}
+		}
+	}
+
+	return fmt.Errorf("adminlist: %w", errors.NewForbidden(principal, verb, resources...))
+}
+
+func (a *Authorizer) AuthorizeSilent(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	return a.Authorize(ctx, principal, verb, resources...)
+}
+
+func (a *Authorizer) FilterAuthorizedResources(ctx context.Context, principal *models.Principal, verb string, resources ...string) ([]string, error) {
+	if err := a.Authorize(ctx, principal, verb, resources...); err != nil {
+		return nil, err
+	}
+
+	return resources, nil
+}
+
+func (a *Authorizer) addAdminUserList(users []string) {
+	// build a map for more efficient lookup on long lists
+	if a.adminUsers == nil {
+		a.adminUsers = map[string]int{}
+	}
+
+	for _, user := range users {
+		a.adminUsers[user] = 1
+	}
+}
+
+func (a *Authorizer) addReadOnlyUserList(users []string) {
+	// build a map for more efficient lookup on long lists
+	if a.readOnlyUsers == nil {
+		a.readOnlyUsers = map[string]int{}
+	}
+
+	for _, user := range users {
+		a.readOnlyUsers[user] = 1
+	}
+}
+
+func (a *Authorizer) addAdminGroupList(groups []string) {
+	// build a map for more efficient lookup on long lists
+	if a.adminGroups == nil {
+		a.adminGroups = map[string]int{}
+	}
+
+	for _, group := range groups {
+		a.adminGroups[group] = 1
+	}
+}
+
+func (a *Authorizer) addReadOnlyGroupList(groups []string) {
+	// build a map for more efficient lookup on long lists
+	if a.readOnlyGroups == nil {
+		a.readOnlyGroups = map[string]int{}
+	}
+
+	for _, group := range groups {
+		a.readOnlyGroups[group] = 1
+	}
+}
+
+func newAnonymousPrincipal() *models.Principal {
+	return &models.Principal{
+		Username: AnonymousPrincipalUsername,
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/adminlist/authorizer_test.go

@@ -0,0 +1,449 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package adminlist
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/entities/models"
+	authZErrors "github.com/weaviate/weaviate/usecases/auth/authorization/errors"
+)
+
+func Test_AdminList_Authorizer(t *testing.T) {
+	t.Run("with read requests", func(t *testing.T) {
+		t.Run("with no users configured at all", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users:   []string{},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "johndoe")
+		})
+
+		t.Run("with a nil principal", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users:   []string{},
+			}
+
+			principal := (*models.Principal)(nil)
+			err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "anonymous")
+		})
+
+		t.Run("with a non-configured user, it denies the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users: []string{
+					"alice",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "johndoe")
+		})
+
+		t.Run("with a configured admin user, it allows the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users: []string{
+					"alice",
+					"johndoe",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+			assert.Nil(t, err)
+		})
+
+		t.Run("with a configured read-only user, it allows the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				ReadOnlyUsers: []string{
+					"alice",
+					"johndoe",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+			assert.Nil(t, err)
+		})
+
+		t.Run("with anonymous as read-only user and no principal, it allows the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				ReadOnlyUsers: []string{
+					"anonymous",
+				},
+			}
+
+			principal := (*models.Principal)(nil)
+			err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+			assert.Nil(t, err)
+		})
+	})
+
+	t.Run("with a non-configured group, it denies the request", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Groups: []string{
+				"band",
+			},
+		}
+
+		principal := &models.Principal{
+			Username: "alice",
+			Groups: []string{
+				"posse",
+			},
+		}
+		err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+		assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+		assert.Contains(t, err.Error(), "forbidden")
+		assert.Contains(t, err.Error(), "posse")
+		assert.Contains(t, err.Error(), "alice")
+	})
+
+	t.Run("with a configured admin group, it allows the request", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Groups: []string{
+				"band",
+				"posse",
+			},
+		}
+
+		principal := &models.Principal{
+			Username: "alice",
+			Groups: []string{
+				"posse",
+			},
+		}
+		err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+		assert.Nil(t, err)
+	})
+
+	t.Run("with a configured read-only group, it allows the request", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			ReadOnlyGroups: []string{
+				"band",
+				"posse",
+			},
+		}
+
+		principal := &models.Principal{
+			Username: "johndoe",
+			Groups: []string{
+				"posse",
+			},
+		}
+
+		err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+		assert.Nil(t, err)
+	})
+
+	t.Run("with a configured admin user and non-configured group, it allows the request", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Users: []string{
+				"alice",
+				"johndoe",
+			},
+			Groups: []string{
+				"band",
+			},
+		}
+
+		principal := &models.Principal{
+			Username: "johndoe",
+			Groups: []string{
+				"posse",
+			},
+		}
+
+		err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+		assert.Nil(t, err)
+	})
+
+	t.Run("with a configured read-only user and non-configured read-only group, it allows the request", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			ReadOnlyUsers: []string{
+				"alice",
+				"johndoe",
+			},
+			ReadOnlyGroups: []string{
+				"band",
+			},
+		}
+
+		principal := &models.Principal{
+			Username: "johndoe",
+			Groups: []string{
+				"posse",
+			},
+		}
+
+		err := New(cfg).Authorize(context.Background(), principal, "R", "things")
+		assert.Nil(t, err)
+	})
+
+	t.Run("with write/delete requests", func(t *testing.T) {
+		t.Run("with a nil principal", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users:   []string{},
+			}
+
+			principal := (*models.Principal)(nil)
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "anonymous")
+		})
+
+		t.Run("with no users configured at all", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users:   []string{},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "johndoe")
+		})
+
+		t.Run("with a non-configured user, it denies the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users: []string{
+					"alice",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "johndoe")
+		})
+
+		t.Run("with an empty user, it denies the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users: []string{
+					"alice",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+		})
+
+		t.Run("with a configured admin user, it allows the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users: []string{
+					"alice",
+					"johndoe",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.Nil(t, err)
+		})
+
+		t.Run("with a configured read-only user, it denies the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				ReadOnlyUsers: []string{
+					"alice",
+					"johndoe",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "johndoe")
+		})
+
+		t.Run("with anonymous on the read-only list and a nil principal", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users:   []string{},
+				ReadOnlyUsers: []string{
+					"anonymous",
+				},
+			}
+
+			principal := (*models.Principal)(nil)
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "anonymous")
+		})
+
+		t.Run("with a non-configured group, it denies the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Groups: []string{
+					"band",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+				Groups: []string{
+					"posse",
+				},
+			}
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "posse")
+			assert.Contains(t, err.Error(), "johndoe")
+		})
+
+		t.Run("with an empty group, it denies the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Groups: []string{
+					"band",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+				Groups:   []string{},
+			}
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "johndoe")
+		})
+
+		t.Run("with a configured admin group, it allows the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Groups: []string{
+					"band",
+					"posse",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+				Groups: []string{
+					"band",
+				},
+			}
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.Nil(t, err)
+		})
+
+		t.Run("with a configured read-only group, it denies the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				ReadOnlyGroups: []string{
+					"band",
+					"posse",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+				Groups: []string{
+					"posse",
+				},
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.True(t, errors.As(err, &authZErrors.Forbidden{}))
+			assert.Contains(t, err.Error(), "forbidden")
+			assert.Contains(t, err.Error(), "johndoe")
+			assert.Contains(t, err.Error(), "posse")
+		})
+
+		t.Run("with a configured admin user and non-configured group, it allows the request", func(t *testing.T) {
+			cfg := Config{
+				Enabled: true,
+				Users: []string{
+					"alice",
+					"johndoe",
+				},
+				Groups: []string{
+					"band",
+				},
+			}
+
+			principal := &models.Principal{
+				Username: "johndoe",
+				Groups: []string{
+					"posse",
+				},
+			}
+
+			err := New(cfg).Authorize(context.Background(), principal, "create", "things")
+			assert.Nil(t, err)
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/adminlist/config.go

@@ -0,0 +1,53 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package adminlist
+
+import "fmt"
+
+// Config makes every subject on the list an admin, whereas everyone else
+// has no rights whatsoever
+type Config struct {
+	Enabled        bool     `json:"enabled" yaml:"enabled"`
+	Users          []string `json:"users" yaml:"users"`
+	ReadOnlyUsers  []string `json:"read_only_users" yaml:"read_only_users"`
+	Groups         []string `json:"groups" yaml:"groups"`
+	ReadOnlyGroups []string `json:"read_only_groups" yaml:"read_only_groups"`
+}
+
+// Validate admin list config for viability, can be called from the central
+// config package
+func (c Config) Validate() error {
+	return c.validateOverlap()
+}
+
+// we are expecting both lists to always contain few subjects and know that
+// this comparison is only done once (at startup). We are therefore fine with
+// the O(n^2) complexity of this very primitive overlap search in favor of very
+// simple code.
+func (c Config) validateOverlap() error {
+	for _, a := range c.Users {
+		for _, b := range c.ReadOnlyUsers {
+			if a == b {
+				return fmt.Errorf("admin list: subject '%s' is present on both admin and read-only list", a)
+			}
+		}
+	}
+	for _, a := range c.Groups {
+		for _, b := range c.ReadOnlyGroups {
+			if a == b {
+				return fmt.Errorf("admin list: subject '%s' is present on both admin and read-only list", a)
+			}
+		}
+	}
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/adminlist/config_test.go

@@ -0,0 +1,224 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package adminlist
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_Validation(t *testing.T) {
+	t.Run("with only an admin user list set", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Users: []string{
+				"alice",
+				"johndoe",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with only a read only user list set", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			ReadOnlyUsers: []string{
+				"alice",
+				"johndoe",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with both user lists present, but no overlap", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Users: []string{
+				"alice",
+			},
+			ReadOnlyUsers: []string{
+				"johndoe",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with one subject part of both user lists", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Users: []string{
+				"alice",
+				"johndoe",
+			},
+			ReadOnlyUsers: []string{
+				"johndoe",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Equal(t, err, fmt.Errorf("admin list: subject 'johndoe' is present on both admin and read-only list"))
+	})
+
+	t.Run("with only an admin group list set", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Groups: []string{
+				"band",
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with only a read only group list set", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			ReadOnlyGroups: []string{
+				"band",
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with both group lists present, but no overlap", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Groups: []string{
+				"band",
+			},
+			ReadOnlyGroups: []string{
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with one subject part of both group lists", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Groups: []string{
+				"band",
+				"posse",
+			},
+			ReadOnlyGroups: []string{
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Equal(t, err, fmt.Errorf("admin list: subject 'posse' is present on both admin and read-only list"))
+	})
+
+	t.Run("with both admin user and groups present", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Users: []string{
+				"alice",
+				"johndoe",
+			},
+			Groups: []string{
+				"band",
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with an admin user and read only group set", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Users: []string{
+				"alice",
+				"johndoe",
+			},
+			ReadOnlyGroups: []string{
+				"band",
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with both read only user and groups present", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			ReadOnlyUsers: []string{
+				"alice",
+				"johndoe",
+			},
+			ReadOnlyGroups: []string{
+				"band",
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("with a read only user and admin group set", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			ReadOnlyUsers: []string{
+				"alice",
+				"johndoe",
+			},
+			Groups: []string{
+				"band",
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+
+	t.Run("all user and group attributes present", func(t *testing.T) {
+		cfg := Config{
+			Enabled: true,
+			Users: []string{
+				"alice",
+			},
+			ReadOnlyUsers: []string{
+				"johndoe",
+			},
+			Groups: []string{
+				"band",
+			},
+			ReadOnlyGroups: []string{
+				"posse",
+			},
+		}
+
+		err := cfg.Validate()
+		assert.Nil(t, err)
+	})
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/authorizer.go

@@ -0,0 +1,49 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package authorization
+
+import (
+	"context"
+
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+// Authorizer always makes a yes/no decision on a specific resource. Which
+// authorization technique is used in the background (e.g. RBAC, adminlist,
+// ...) is hidden through this interface
+type Authorizer interface {
+	Authorize(ctx context.Context, principal *models.Principal, verb string, resources ...string) error
+	// AuthorizeSilent Silent authorization without audit logs
+	AuthorizeSilent(ctx context.Context, principal *models.Principal, verb string, resources ...string) error
+	// FilterAuthorizedResources authorize the passed resources with best effort approach, it will return
+	// list of allowed resources, if none, it will return an empty slice
+	FilterAuthorizedResources(ctx context.Context, principal *models.Principal, verb string, resources ...string) ([]string, error)
+}
+
+// DummyAuthorizer is a pluggable Authorizer which can be used if no specific
+// authorizer is configured. It will allow every auth decision, i.e. it is
+// effectively the same as "no authorization at all"
+type DummyAuthorizer struct{}
+
+// Authorize on the DummyAuthorizer will allow any subject access to any
+// resource
+func (d *DummyAuthorizer) Authorize(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	return nil
+}
+
+func (d *DummyAuthorizer) AuthorizeSilent(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	return nil
+}
+
+func (d *DummyAuthorizer) FilterAuthorizedResources(ctx context.Context, principal *models.Principal, verb string, resources ...string) ([]string, error) {
+	return resources, nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/controller.go

@@ -0,0 +1,30 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package authorization
+
+import (
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+)
+
+type Controller interface {
+	UpdateRolesPermissions(roles map[string][]Policy) error
+	CreateRolesPermissions(roles map[string][]Policy) error
+	GetRoles(names ...string) (map[string][]Policy, error)
+	DeleteRoles(roles ...string) error
+	AddRolesForUser(user string, roles []string) error
+	GetRolesForUserOrGroup(user string, authMethod authentication.AuthType, isGroup bool) (map[string][]Policy, error)
+	GetUsersOrGroupForRole(role string, authMethod authentication.AuthType, IsGroup bool) ([]string, error)
+	RevokeRolesForUser(user string, roles ...string) error
+	RemovePermissions(role string, permissions []*Policy) error
+	HasPermission(role string, permission *Policy) (bool, error)
+	GetUsersOrGroupsWithRoles(isGroup bool, authMethod authentication.AuthType) ([]string, error)
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/conv/casbin_converter.go

@@ -0,0 +1,107 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package conv
+
+import (
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+)
+
+func RolesToPolicies(roles ...*models.Role) (map[string][]authorization.Policy, error) {
+	rolesmap := make(map[string][]authorization.Policy)
+	for idx := range roles {
+		rolesmap[*roles[idx].Name] = []authorization.Policy{}
+		for _, permission := range roles[idx].Permissions {
+			policy, err := policy(permission)
+			if err != nil {
+				return rolesmap, fmt.Errorf("policy: %w", err)
+			}
+			rolesmap[*roles[idx].Name] = append(rolesmap[*roles[idx].Name], *policy)
+		}
+	}
+
+	return rolesmap, nil
+}
+
+func PermissionToPolicies(permissions ...*models.Permission) ([]*authorization.Policy, error) {
+	policies := []*authorization.Policy{}
+	for idx := range permissions {
+		policy, err := policy(permissions[idx])
+		if err != nil {
+			return nil, fmt.Errorf("policy: %w", err)
+		}
+		policies = append(policies, policy)
+	}
+
+	return policies, nil
+}
+
+func PathToPermission(verb, path string) (*models.Permission, error) {
+	parts := strings.Split(path, "/")
+	if len(parts) < 1 {
+		return nil, fmt.Errorf("invalid path")
+	}
+
+	return permission([]string{"", path, verb, parts[0]}, false)
+}
+
+func PoliciesToPermission(policies ...authorization.Policy) ([]*models.Permission, error) {
+	permissions := []*models.Permission{}
+	for idx := range policies {
+		// 1st empty string to replace casbin pattern of having policy name as 1st place
+		// e.g.  tester, roles/.*, (C)|(R)|(U)|(D), roles
+		// see newPolicy()
+		perm, err := permission([]string{"", policies[idx].Resource, policies[idx].Verb, policies[idx].Domain}, true)
+		if err != nil {
+			return nil, err
+		}
+		if perm.Action == nil {
+			continue
+		}
+		permissions = append(permissions, perm)
+	}
+	return permissions, nil
+}
+
+func CasbinPolicies(casbinPolicies ...[][]string) (map[string][]authorization.Policy, error) {
+	rolesPermissions := make(map[string][]authorization.Policy)
+	for _, p := range casbinPolicies {
+		for _, policyParts := range p {
+			name := TrimRoleNamePrefix(policyParts[0])
+			if slices.Contains(authorization.BuiltInRoles, name) {
+				perms := authorization.BuiltInPermissions[name]
+				for _, p := range perms {
+					perm, err := policy(p)
+					if err != nil {
+						return nil, fmt.Errorf("policy: %w", err)
+					}
+					rolesPermissions[name] = append(rolesPermissions[name], *perm)
+				}
+			} else {
+				perm, err := permission(policyParts, true)
+				if err != nil {
+					return nil, fmt.Errorf("permission: %w", err)
+				}
+				weaviatePerm, err := policy(perm)
+				if err != nil {
+					return nil, fmt.Errorf("policy: %w", err)
+				}
+				rolesPermissions[name] = append(rolesPermissions[name], *weaviatePerm)
+			}
+		}
+	}
+	return rolesPermissions, nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/mock_authorizer.go

@@ -0,0 +1,249 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+// Code generated by mockery v2.53.2. DO NOT EDIT.
+
+package authorization
+
+import (
+	context "context"
+
+	mock "github.com/stretchr/testify/mock"
+	models "github.com/weaviate/weaviate/entities/models"
+)
+
+// MockAuthorizer is an autogenerated mock type for the Authorizer type
+type MockAuthorizer struct {
+	mock.Mock
+}
+
+type MockAuthorizer_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockAuthorizer) EXPECT() *MockAuthorizer_Expecter {
+	return &MockAuthorizer_Expecter{mock: &_m.Mock}
+}
+
+// Authorize provides a mock function with given fields: ctx, principal, verb, resources
+func (_m *MockAuthorizer) Authorize(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	_va := make([]interface{}, len(resources))
+	for _i := range resources {
+		_va[_i] = resources[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, principal, verb)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Authorize")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, *models.Principal, string, ...string) error); ok {
+		r0 = rf(ctx, principal, verb, resources...)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockAuthorizer_Authorize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Authorize'
+type MockAuthorizer_Authorize_Call struct {
+	*mock.Call
+}
+
+// Authorize is a helper method to define mock.On call
+//   - ctx context.Context
+//   - principal *models.Principal
+//   - verb string
+//   - resources ...string
+func (_e *MockAuthorizer_Expecter) Authorize(ctx interface{}, principal interface{}, verb interface{}, resources ...interface{}) *MockAuthorizer_Authorize_Call {
+	return &MockAuthorizer_Authorize_Call{Call: _e.mock.On("Authorize",
+		append([]interface{}{ctx, principal, verb}, resources...)...)}
+}
+
+func (_c *MockAuthorizer_Authorize_Call) Run(run func(ctx context.Context, principal *models.Principal, verb string, resources ...string)) *MockAuthorizer_Authorize_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-3)
+		for i, a := range args[3:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*models.Principal), args[2].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockAuthorizer_Authorize_Call) Return(_a0 error) *MockAuthorizer_Authorize_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockAuthorizer_Authorize_Call) RunAndReturn(run func(context.Context, *models.Principal, string, ...string) error) *MockAuthorizer_Authorize_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// AuthorizeSilent provides a mock function with given fields: ctx, principal, verb, resources
+func (_m *MockAuthorizer) AuthorizeSilent(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	_va := make([]interface{}, len(resources))
+	for _i := range resources {
+		_va[_i] = resources[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, principal, verb)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AuthorizeSilent")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, *models.Principal, string, ...string) error); ok {
+		r0 = rf(ctx, principal, verb, resources...)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockAuthorizer_AuthorizeSilent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizeSilent'
+type MockAuthorizer_AuthorizeSilent_Call struct {
+	*mock.Call
+}
+
+// AuthorizeSilent is a helper method to define mock.On call
+//   - ctx context.Context
+//   - principal *models.Principal
+//   - verb string
+//   - resources ...string
+func (_e *MockAuthorizer_Expecter) AuthorizeSilent(ctx interface{}, principal interface{}, verb interface{}, resources ...interface{}) *MockAuthorizer_AuthorizeSilent_Call {
+	return &MockAuthorizer_AuthorizeSilent_Call{Call: _e.mock.On("AuthorizeSilent",
+		append([]interface{}{ctx, principal, verb}, resources...)...)}
+}
+
+func (_c *MockAuthorizer_AuthorizeSilent_Call) Run(run func(ctx context.Context, principal *models.Principal, verb string, resources ...string)) *MockAuthorizer_AuthorizeSilent_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-3)
+		for i, a := range args[3:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*models.Principal), args[2].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockAuthorizer_AuthorizeSilent_Call) Return(_a0 error) *MockAuthorizer_AuthorizeSilent_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockAuthorizer_AuthorizeSilent_Call) RunAndReturn(run func(context.Context, *models.Principal, string, ...string) error) *MockAuthorizer_AuthorizeSilent_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FilterAuthorizedResources provides a mock function with given fields: ctx, principal, verb, resources
+func (_m *MockAuthorizer) FilterAuthorizedResources(ctx context.Context, principal *models.Principal, verb string, resources ...string) ([]string, error) {
+	_va := make([]interface{}, len(resources))
+	for _i := range resources {
+		_va[_i] = resources[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, principal, verb)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FilterAuthorizedResources")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *models.Principal, string, ...string) ([]string, error)); ok {
+		return rf(ctx, principal, verb, resources...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *models.Principal, string, ...string) []string); ok {
+		r0 = rf(ctx, principal, verb, resources...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *models.Principal, string, ...string) error); ok {
+		r1 = rf(ctx, principal, verb, resources...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAuthorizer_FilterAuthorizedResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterAuthorizedResources'
+type MockAuthorizer_FilterAuthorizedResources_Call struct {
+	*mock.Call
+}
+
+// FilterAuthorizedResources is a helper method to define mock.On call
+//   - ctx context.Context
+//   - principal *models.Principal
+//   - verb string
+//   - resources ...string
+func (_e *MockAuthorizer_Expecter) FilterAuthorizedResources(ctx interface{}, principal interface{}, verb interface{}, resources ...interface{}) *MockAuthorizer_FilterAuthorizedResources_Call {
+	return &MockAuthorizer_FilterAuthorizedResources_Call{Call: _e.mock.On("FilterAuthorizedResources",
+		append([]interface{}{ctx, principal, verb}, resources...)...)}
+}
+
+func (_c *MockAuthorizer_FilterAuthorizedResources_Call) Run(run func(ctx context.Context, principal *models.Principal, verb string, resources ...string)) *MockAuthorizer_FilterAuthorizedResources_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-3)
+		for i, a := range args[3:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(args[0].(context.Context), args[1].(*models.Principal), args[2].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockAuthorizer_FilterAuthorizedResources_Call) Return(_a0 []string, _a1 error) *MockAuthorizer_FilterAuthorizedResources_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAuthorizer_FilterAuthorizedResources_Call) RunAndReturn(run func(context.Context, *models.Principal, string, ...string) ([]string, error)) *MockAuthorizer_FilterAuthorizedResources_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockAuthorizer creates a new instance of MockAuthorizer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockAuthorizer(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockAuthorizer {
+	mock := &MockAuthorizer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/mock_controller.go

@@ -0,0 +1,659 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+// Code generated by mockery v2.53.2. DO NOT EDIT.
+
+package authorization
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	authentication "github.com/weaviate/weaviate/usecases/auth/authentication"
+)
+
+// MockController is an autogenerated mock type for the Controller type
+type MockController struct {
+	mock.Mock
+}
+
+type MockController_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockController) EXPECT() *MockController_Expecter {
+	return &MockController_Expecter{mock: &_m.Mock}
+}
+
+// AddRolesForUser provides a mock function with given fields: user, roles
+func (_m *MockController) AddRolesForUser(user string, roles []string) error {
+	ret := _m.Called(user, roles)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddRolesForUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
+		r0 = rf(user, roles)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockController_AddRolesForUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRolesForUser'
+type MockController_AddRolesForUser_Call struct {
+	*mock.Call
+}
+
+// AddRolesForUser is a helper method to define mock.On call
+//   - user string
+//   - roles []string
+func (_e *MockController_Expecter) AddRolesForUser(user interface{}, roles interface{}) *MockController_AddRolesForUser_Call {
+	return &MockController_AddRolesForUser_Call{Call: _e.mock.On("AddRolesForUser", user, roles)}
+}
+
+func (_c *MockController_AddRolesForUser_Call) Run(run func(user string, roles []string)) *MockController_AddRolesForUser_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].([]string))
+	})
+	return _c
+}
+
+func (_c *MockController_AddRolesForUser_Call) Return(_a0 error) *MockController_AddRolesForUser_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockController_AddRolesForUser_Call) RunAndReturn(run func(string, []string) error) *MockController_AddRolesForUser_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreateRolesPermissions provides a mock function with given fields: roles
+func (_m *MockController) CreateRolesPermissions(roles map[string][]Policy) error {
+	ret := _m.Called(roles)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreateRolesPermissions")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(map[string][]Policy) error); ok {
+		r0 = rf(roles)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockController_CreateRolesPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRolesPermissions'
+type MockController_CreateRolesPermissions_Call struct {
+	*mock.Call
+}
+
+// CreateRolesPermissions is a helper method to define mock.On call
+//   - roles map[string][]Policy
+func (_e *MockController_Expecter) CreateRolesPermissions(roles interface{}) *MockController_CreateRolesPermissions_Call {
+	return &MockController_CreateRolesPermissions_Call{Call: _e.mock.On("CreateRolesPermissions", roles)}
+}
+
+func (_c *MockController_CreateRolesPermissions_Call) Run(run func(roles map[string][]Policy)) *MockController_CreateRolesPermissions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(map[string][]Policy))
+	})
+	return _c
+}
+
+func (_c *MockController_CreateRolesPermissions_Call) Return(_a0 error) *MockController_CreateRolesPermissions_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockController_CreateRolesPermissions_Call) RunAndReturn(run func(map[string][]Policy) error) *MockController_CreateRolesPermissions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteRoles provides a mock function with given fields: roles
+func (_m *MockController) DeleteRoles(roles ...string) error {
+	_va := make([]interface{}, len(roles))
+	for _i := range roles {
+		_va[_i] = roles[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteRoles")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(...string) error); ok {
+		r0 = rf(roles...)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockController_DeleteRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRoles'
+type MockController_DeleteRoles_Call struct {
+	*mock.Call
+}
+
+// DeleteRoles is a helper method to define mock.On call
+//   - roles ...string
+func (_e *MockController_Expecter) DeleteRoles(roles ...interface{}) *MockController_DeleteRoles_Call {
+	return &MockController_DeleteRoles_Call{Call: _e.mock.On("DeleteRoles",
+		append([]interface{}{}, roles...)...)}
+}
+
+func (_c *MockController_DeleteRoles_Call) Run(run func(roles ...string)) *MockController_DeleteRoles_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockController_DeleteRoles_Call) Return(_a0 error) *MockController_DeleteRoles_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockController_DeleteRoles_Call) RunAndReturn(run func(...string) error) *MockController_DeleteRoles_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetRoles provides a mock function with given fields: names
+func (_m *MockController) GetRoles(names ...string) (map[string][]Policy, error) {
+	_va := make([]interface{}, len(names))
+	for _i := range names {
+		_va[_i] = names[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRoles")
+	}
+
+	var r0 map[string][]Policy
+	var r1 error
+	if rf, ok := ret.Get(0).(func(...string) (map[string][]Policy, error)); ok {
+		return rf(names...)
+	}
+	if rf, ok := ret.Get(0).(func(...string) map[string][]Policy); ok {
+		r0 = rf(names...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string][]Policy)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(...string) error); ok {
+		r1 = rf(names...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockController_GetRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoles'
+type MockController_GetRoles_Call struct {
+	*mock.Call
+}
+
+// GetRoles is a helper method to define mock.On call
+//   - names ...string
+func (_e *MockController_Expecter) GetRoles(names ...interface{}) *MockController_GetRoles_Call {
+	return &MockController_GetRoles_Call{Call: _e.mock.On("GetRoles",
+		append([]interface{}{}, names...)...)}
+}
+
+func (_c *MockController_GetRoles_Call) Run(run func(names ...string)) *MockController_GetRoles_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockController_GetRoles_Call) Return(_a0 map[string][]Policy, _a1 error) *MockController_GetRoles_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockController_GetRoles_Call) RunAndReturn(run func(...string) (map[string][]Policy, error)) *MockController_GetRoles_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetRolesForUserOrGroup provides a mock function with given fields: user, authMethod, isGroup
+func (_m *MockController) GetRolesForUserOrGroup(user string, authMethod authentication.AuthType, isGroup bool) (map[string][]Policy, error) {
+	ret := _m.Called(user, authMethod, isGroup)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRolesForUserOrGroup")
+	}
+
+	var r0 map[string][]Policy
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, authentication.AuthType, bool) (map[string][]Policy, error)); ok {
+		return rf(user, authMethod, isGroup)
+	}
+	if rf, ok := ret.Get(0).(func(string, authentication.AuthType, bool) map[string][]Policy); ok {
+		r0 = rf(user, authMethod, isGroup)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string][]Policy)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, authentication.AuthType, bool) error); ok {
+		r1 = rf(user, authMethod, isGroup)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockController_GetRolesForUserOrGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRolesForUserOrGroup'
+type MockController_GetRolesForUserOrGroup_Call struct {
+	*mock.Call
+}
+
+// GetRolesForUserOrGroup is a helper method to define mock.On call
+//   - user string
+//   - authMethod authentication.AuthType
+//   - isGroup bool
+func (_e *MockController_Expecter) GetRolesForUserOrGroup(user interface{}, authMethod interface{}, isGroup interface{}) *MockController_GetRolesForUserOrGroup_Call {
+	return &MockController_GetRolesForUserOrGroup_Call{Call: _e.mock.On("GetRolesForUserOrGroup", user, authMethod, isGroup)}
+}
+
+func (_c *MockController_GetRolesForUserOrGroup_Call) Run(run func(user string, authMethod authentication.AuthType, isGroup bool)) *MockController_GetRolesForUserOrGroup_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(authentication.AuthType), args[2].(bool))
+	})
+	return _c
+}
+
+func (_c *MockController_GetRolesForUserOrGroup_Call) Return(_a0 map[string][]Policy, _a1 error) *MockController_GetRolesForUserOrGroup_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockController_GetRolesForUserOrGroup_Call) RunAndReturn(run func(string, authentication.AuthType, bool) (map[string][]Policy, error)) *MockController_GetRolesForUserOrGroup_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetUsersOrGroupForRole provides a mock function with given fields: role, authMethod, IsGroup
+func (_m *MockController) GetUsersOrGroupForRole(role string, authMethod authentication.AuthType, IsGroup bool) ([]string, error) {
+	ret := _m.Called(role, authMethod, IsGroup)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUsersOrGroupForRole")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, authentication.AuthType, bool) ([]string, error)); ok {
+		return rf(role, authMethod, IsGroup)
+	}
+	if rf, ok := ret.Get(0).(func(string, authentication.AuthType, bool) []string); ok {
+		r0 = rf(role, authMethod, IsGroup)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, authentication.AuthType, bool) error); ok {
+		r1 = rf(role, authMethod, IsGroup)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockController_GetUsersOrGroupForRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersOrGroupForRole'
+type MockController_GetUsersOrGroupForRole_Call struct {
+	*mock.Call
+}
+
+// GetUsersOrGroupForRole is a helper method to define mock.On call
+//   - role string
+//   - authMethod authentication.AuthType
+//   - IsGroup bool
+func (_e *MockController_Expecter) GetUsersOrGroupForRole(role interface{}, authMethod interface{}, IsGroup interface{}) *MockController_GetUsersOrGroupForRole_Call {
+	return &MockController_GetUsersOrGroupForRole_Call{Call: _e.mock.On("GetUsersOrGroupForRole", role, authMethod, IsGroup)}
+}
+
+func (_c *MockController_GetUsersOrGroupForRole_Call) Run(run func(role string, authMethod authentication.AuthType, IsGroup bool)) *MockController_GetUsersOrGroupForRole_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(authentication.AuthType), args[2].(bool))
+	})
+	return _c
+}
+
+func (_c *MockController_GetUsersOrGroupForRole_Call) Return(_a0 []string, _a1 error) *MockController_GetUsersOrGroupForRole_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockController_GetUsersOrGroupForRole_Call) RunAndReturn(run func(string, authentication.AuthType, bool) ([]string, error)) *MockController_GetUsersOrGroupForRole_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetUsersOrGroupsWithRoles provides a mock function with given fields: isGroup, authMethod
+func (_m *MockController) GetUsersOrGroupsWithRoles(isGroup bool, authMethod authentication.AuthType) ([]string, error) {
+	ret := _m.Called(isGroup, authMethod)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetUsersOrGroupsWithRoles")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(bool, authentication.AuthType) ([]string, error)); ok {
+		return rf(isGroup, authMethod)
+	}
+	if rf, ok := ret.Get(0).(func(bool, authentication.AuthType) []string); ok {
+		r0 = rf(isGroup, authMethod)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(bool, authentication.AuthType) error); ok {
+		r1 = rf(isGroup, authMethod)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockController_GetUsersOrGroupsWithRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersOrGroupsWithRoles'
+type MockController_GetUsersOrGroupsWithRoles_Call struct {
+	*mock.Call
+}
+
+// GetUsersOrGroupsWithRoles is a helper method to define mock.On call
+//   - isGroup bool
+//   - authMethod authentication.AuthType
+func (_e *MockController_Expecter) GetUsersOrGroupsWithRoles(isGroup interface{}, authMethod interface{}) *MockController_GetUsersOrGroupsWithRoles_Call {
+	return &MockController_GetUsersOrGroupsWithRoles_Call{Call: _e.mock.On("GetUsersOrGroupsWithRoles", isGroup, authMethod)}
+}
+
+func (_c *MockController_GetUsersOrGroupsWithRoles_Call) Run(run func(isGroup bool, authMethod authentication.AuthType)) *MockController_GetUsersOrGroupsWithRoles_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool), args[1].(authentication.AuthType))
+	})
+	return _c
+}
+
+func (_c *MockController_GetUsersOrGroupsWithRoles_Call) Return(_a0 []string, _a1 error) *MockController_GetUsersOrGroupsWithRoles_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockController_GetUsersOrGroupsWithRoles_Call) RunAndReturn(run func(bool, authentication.AuthType) ([]string, error)) *MockController_GetUsersOrGroupsWithRoles_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// HasPermission provides a mock function with given fields: role, permission
+func (_m *MockController) HasPermission(role string, permission *Policy) (bool, error) {
+	ret := _m.Called(role, permission)
+
+	if len(ret) == 0 {
+		panic("no return value specified for HasPermission")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, *Policy) (bool, error)); ok {
+		return rf(role, permission)
+	}
+	if rf, ok := ret.Get(0).(func(string, *Policy) bool); ok {
+		r0 = rf(role, permission)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, *Policy) error); ok {
+		r1 = rf(role, permission)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockController_HasPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasPermission'
+type MockController_HasPermission_Call struct {
+	*mock.Call
+}
+
+// HasPermission is a helper method to define mock.On call
+//   - role string
+//   - permission *Policy
+func (_e *MockController_Expecter) HasPermission(role interface{}, permission interface{}) *MockController_HasPermission_Call {
+	return &MockController_HasPermission_Call{Call: _e.mock.On("HasPermission", role, permission)}
+}
+
+func (_c *MockController_HasPermission_Call) Run(run func(role string, permission *Policy)) *MockController_HasPermission_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(*Policy))
+	})
+	return _c
+}
+
+func (_c *MockController_HasPermission_Call) Return(_a0 bool, _a1 error) *MockController_HasPermission_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockController_HasPermission_Call) RunAndReturn(run func(string, *Policy) (bool, error)) *MockController_HasPermission_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RemovePermissions provides a mock function with given fields: role, permissions
+func (_m *MockController) RemovePermissions(role string, permissions []*Policy) error {
+	ret := _m.Called(role, permissions)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemovePermissions")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []*Policy) error); ok {
+		r0 = rf(role, permissions)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockController_RemovePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePermissions'
+type MockController_RemovePermissions_Call struct {
+	*mock.Call
+}
+
+// RemovePermissions is a helper method to define mock.On call
+//   - role string
+//   - permissions []*Policy
+func (_e *MockController_Expecter) RemovePermissions(role interface{}, permissions interface{}) *MockController_RemovePermissions_Call {
+	return &MockController_RemovePermissions_Call{Call: _e.mock.On("RemovePermissions", role, permissions)}
+}
+
+func (_c *MockController_RemovePermissions_Call) Run(run func(role string, permissions []*Policy)) *MockController_RemovePermissions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].([]*Policy))
+	})
+	return _c
+}
+
+func (_c *MockController_RemovePermissions_Call) Return(_a0 error) *MockController_RemovePermissions_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockController_RemovePermissions_Call) RunAndReturn(run func(string, []*Policy) error) *MockController_RemovePermissions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RevokeRolesForUser provides a mock function with given fields: user, roles
+func (_m *MockController) RevokeRolesForUser(user string, roles ...string) error {
+	_va := make([]interface{}, len(roles))
+	for _i := range roles {
+		_va[_i] = roles[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, user)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RevokeRolesForUser")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, ...string) error); ok {
+		r0 = rf(user, roles...)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockController_RevokeRolesForUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeRolesForUser'
+type MockController_RevokeRolesForUser_Call struct {
+	*mock.Call
+}
+
+// RevokeRolesForUser is a helper method to define mock.On call
+//   - user string
+//   - roles ...string
+func (_e *MockController_Expecter) RevokeRolesForUser(user interface{}, roles ...interface{}) *MockController_RevokeRolesForUser_Call {
+	return &MockController_RevokeRolesForUser_Call{Call: _e.mock.On("RevokeRolesForUser",
+		append([]interface{}{user}, roles...)...)}
+}
+
+func (_c *MockController_RevokeRolesForUser_Call) Run(run func(user string, roles ...string)) *MockController_RevokeRolesForUser_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-1)
+		for i, a := range args[1:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(args[0].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockController_RevokeRolesForUser_Call) Return(_a0 error) *MockController_RevokeRolesForUser_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockController_RevokeRolesForUser_Call) RunAndReturn(run func(string, ...string) error) *MockController_RevokeRolesForUser_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UpdateRolesPermissions provides a mock function with given fields: roles
+func (_m *MockController) UpdateRolesPermissions(roles map[string][]Policy) error {
+	ret := _m.Called(roles)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateRolesPermissions")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(map[string][]Policy) error); ok {
+		r0 = rf(roles)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockController_UpdateRolesPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRolesPermissions'
+type MockController_UpdateRolesPermissions_Call struct {
+	*mock.Call
+}
+
+// UpdateRolesPermissions is a helper method to define mock.On call
+//   - roles map[string][]Policy
+func (_e *MockController_Expecter) UpdateRolesPermissions(roles interface{}) *MockController_UpdateRolesPermissions_Call {
+	return &MockController_UpdateRolesPermissions_Call{Call: _e.mock.On("UpdateRolesPermissions", roles)}
+}
+
+func (_c *MockController_UpdateRolesPermissions_Call) Run(run func(roles map[string][]Policy)) *MockController_UpdateRolesPermissions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(map[string][]Policy))
+	})
+	return _c
+}
+
+func (_c *MockController_UpdateRolesPermissions_Call) Return(_a0 error) *MockController_UpdateRolesPermissions_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockController_UpdateRolesPermissions_Call) RunAndReturn(run func(map[string][]Policy) error) *MockController_UpdateRolesPermissions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockController creates a new instance of MockController. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockController(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockController {
+	mock := &MockController{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/types.go

@@ -0,0 +1,606 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package authorization
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/go-openapi/strfmt"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/verbosity"
+)
+
+const (
+	// CREATE Represents the action to create a new resource.
+	CREATE = "C"
+	// READ Represents the action to retrieve a resource.
+	READ = "R"
+	// UPDATE Represents the action to update an existing resource.
+	UPDATE = "U"
+	// DELETE Represents the action to delete a resource.
+	DELETE = "D"
+
+	ROLE_SCOPE_ALL   = "ALL"
+	ROLE_SCOPE_MATCH = "MATCH"
+
+	USER_AND_GROUP_ASSIGN_AND_REVOKE = "A"
+)
+
+const (
+	GroupsDomain      = "groups"
+	UsersDomain       = "users"
+	RolesDomain       = "roles"
+	ClusterDomain     = "cluster"
+	NodesDomain       = "nodes"
+	BackupsDomain     = "backups"
+	SchemaDomain      = "schema"
+	CollectionsDomain = "collections"
+	TenantsDomain     = "tenants"
+	DataDomain        = "data"
+	ReplicateDomain   = "replicate"
+	AliasesDomain     = "aliases"
+)
+
+var (
+	All = String("*")
+
+	AllBackups = &models.PermissionBackups{
+		Collection: All,
+	}
+	AllData = &models.PermissionData{
+		Collection: All,
+		Tenant:     All,
+		Object:     All,
+	}
+	AllTenants = &models.PermissionTenants{
+		Collection: All,
+		Tenant:     All,
+	}
+	AllNodes = &models.PermissionNodes{
+		Verbosity:  String(verbosity.OutputVerbose),
+		Collection: All,
+	}
+	AllOIDCGroups = &models.PermissionGroups{
+		Group:     All,
+		GroupType: models.GroupTypeOidc,
+	}
+	AllRoles = &models.PermissionRoles{
+		Role:  All,
+		Scope: String(models.PermissionRolesScopeAll),
+	}
+	AllUsers = &models.PermissionUsers{
+		Users: All,
+	}
+	AllCollections = &models.PermissionCollections{
+		Collection: All,
+	}
+	AllReplicate = &models.PermissionReplicate{
+		Collection: All,
+		Shard:      All,
+	}
+	AllAliases = &models.PermissionAliases{
+		Collection: All,
+		Alias:      All,
+	}
+
+	ComponentName = "RBAC"
+
+	// Note:  if a new action added, don't forget to add it to availableWeaviateActions
+	// to be added to built in roles
+	// any action has to contain of `{verb}_{domain}` verb: CREATE, READ, UPDATE, DELETE domain: roles, users, cluster, collections, data
+	ReadRoles   = "read_roles"
+	CreateRoles = "create_roles"
+	UpdateRoles = "update_roles"
+	DeleteRoles = "delete_roles"
+
+	ReadCluster = "read_cluster"
+	ReadNodes   = "read_nodes"
+
+	AssignAndRevokeGroups = "assign_and_revoke_groups"
+	ReadGroups            = "read_groups"
+
+	AssignAndRevokeUsers = "assign_and_revoke_users"
+	CreateUsers          = "create_users"
+	ReadUsers            = "read_users"
+	UpdateUsers          = "update_users"
+	DeleteUsers          = "delete_users"
+
+	ManageBackups = "manage_backups"
+
+	CreateCollections = "create_collections"
+	ReadCollections   = "read_collections"
+	UpdateCollections = "update_collections"
+	DeleteCollections = "delete_collections"
+
+	CreateData = "create_data"
+	ReadData   = "read_data"
+	UpdateData = "update_data"
+	DeleteData = "delete_data"
+
+	CreateTenants = "create_tenants"
+	ReadTenants   = "read_tenants"
+	UpdateTenants = "update_tenants"
+	DeleteTenants = "delete_tenants"
+
+	CreateReplicate = "create_replicate"
+	ReadReplicate   = "read_replicate"
+	UpdateReplicate = "update_replicate"
+	DeleteReplicate = "delete_replicate"
+
+	CreateAliases = "create_aliases"
+	ReadAliases   = "read_aliases"
+	UpdateAliases = "update_aliases"
+	DeleteAliases = "delete_aliases"
+
+	availableWeaviateActions = []string{
+		// Roles domain
+		CreateRoles,
+		ReadRoles,
+		UpdateRoles,
+		DeleteRoles,
+
+		// Backups domain
+		ManageBackups,
+
+		// Users domain
+		AssignAndRevokeUsers,
+		CreateUsers,
+		ReadUsers,
+		UpdateUsers,
+		DeleteUsers,
+
+		// Cluster domain
+		ReadCluster,
+
+		// Groups domain
+		AssignAndRevokeGroups,
+		ReadGroups,
+
+		// Nodes domain
+		ReadNodes,
+
+		// Collections domain
+		CreateCollections,
+		ReadCollections,
+		UpdateCollections,
+		DeleteCollections,
+
+		// Data domain
+		CreateData,
+		ReadData,
+		UpdateData,
+		DeleteData,
+
+		// Tenant domain
+		CreateTenants,
+		ReadTenants,
+		UpdateTenants,
+		DeleteTenants,
+
+		// Replicate domain
+		CreateReplicate,
+		ReadReplicate,
+		UpdateReplicate,
+		DeleteReplicate,
+
+		// Aliases domain
+		CreateAliases,
+		ReadAliases,
+		UpdateAliases,
+		DeleteAliases,
+	}
+)
+
+var (
+	// build-in roles that can be assigned via API
+	Viewer = "viewer"
+	Admin  = "admin"
+	// build-in roles that can be assigned via env vars and cannot be changed via APIS
+	Root         = "root"
+	ReadOnly     = "read-only"
+	BuiltInRoles = []string{Viewer, Admin, Root, ReadOnly}
+
+	// viewer : can view everything , roles, users, schema, data
+	// editor : can create/read/update everything , roles, users, schema, data
+	// Admin : aka basically super Admin or root
+	BuiltInPermissions = map[string][]*models.Permission{
+		Viewer:   viewerPermissions(),
+		Admin:    adminPermissions(),
+		Root:     adminPermissions(),
+		ReadOnly: viewerPermissions(),
+	}
+	EnvVarRoles = []string{ReadOnly, Root}
+)
+
+type Policy struct {
+	Resource string
+	Verb     string
+	Domain   string
+}
+
+// Cluster returns a string representing the cluster authorization scope.
+// The returned string is "cluster/*", which can be used to specify that
+// the authorization applies to all resources within the cluster.
+func Cluster() string {
+	return fmt.Sprintf("%s/*", ClusterDomain)
+}
+
+func nodes(verbosity, class string) string {
+	if verbosity == "" {
+		verbosity = "minimal"
+	}
+	if verbosity == "minimal" {
+		return fmt.Sprintf("%s/verbosity/%s", NodesDomain, verbosity)
+	}
+	return fmt.Sprintf("%s/verbosity/%s/collections/%s", NodesDomain, verbosity, class)
+}
+
+func Nodes(verbosity string, classes ...string) []string {
+	classes = schema.UppercaseClassesNames(classes...)
+
+	if len(classes) == 0 || (len(classes) == 1 && (classes[0] == "" || classes[0] == "*")) {
+		return []string{nodes(verbosity, "*")}
+	}
+
+	resources := make([]string, len(classes))
+	for idx := range classes {
+		if classes[idx] == "" {
+			resources[idx] = nodes(verbosity, "*")
+		} else {
+			resources[idx] = nodes(verbosity, classes[idx])
+		}
+	}
+
+	return resources
+}
+
+// Groups generates a list of user resource strings based on the provided group names.
+// If no group names are provided, it returns a default user resource string "groups/*".
+//
+// Parameters:
+//
+//	groups - A variadic parameter representing the group names.
+//
+// Returns:
+//
+//	A slice of strings where each string is a formatted user resource string.
+func Groups(groupType authentication.AuthType, groups ...string) []string {
+	if len(groups) == 0 || (len(groups) == 1 && (groups[0] == "" || groups[0] == "*")) {
+		return []string{
+			fmt.Sprintf("%s/%s/*", GroupsDomain, groupType),
+		}
+	}
+
+	resources := make([]string, len(groups))
+	for idx := range groups {
+		resources[idx] = fmt.Sprintf("%s/%s/%s", GroupsDomain, groupType, groups[idx])
+	}
+
+	return resources
+}
+
+// Users generates a list of user resource strings based on the provided user names.
+// If no user names are provided, it returns a default user resource string "users/*".
+//
+// Parameters:
+//
+//	users - A variadic parameter representing the user names.
+//
+// Returns:
+//
+//	A slice of strings where each string is a formatted user resource string.
+func Users(users ...string) []string {
+	if len(users) == 0 || (len(users) == 1 && (users[0] == "" || users[0] == "*")) {
+		return []string{
+			fmt.Sprintf("%s/*", UsersDomain),
+		}
+	}
+
+	resources := make([]string, len(users))
+	for idx := range users {
+		resources[idx] = fmt.Sprintf("%s/%s", UsersDomain, users[idx])
+	}
+
+	return resources
+}
+
+// Roles generates a list of role resource strings based on the provided role names.
+// If no role names are provided, it returns a default role resource string "roles/*".
+//
+// Parameters:
+//
+//	roles - A variadic parameter representing the role names.
+//
+// Returns:
+//
+//	A slice of strings where each string is a formatted role resource string.
+func Roles(roles ...string) []string {
+	if len(roles) == 0 || (len(roles) == 1 && (roles[0] == "" || roles[0] == "*")) {
+		return []string{
+			fmt.Sprintf("%s/*", RolesDomain),
+		}
+	}
+
+	resources := make([]string, len(roles))
+	for idx := range roles {
+		resources[idx] = fmt.Sprintf("%s/%s", RolesDomain, roles[idx])
+	}
+
+	return resources
+}
+
+// CollectionsMetadata generates a list of resource strings for the given classes.
+// If no classes are provided, it returns a default resource string "collections/*".
+// Each class is formatted as "collection/{class}".
+//
+// Parameters:
+//
+//	classes - a variadic parameter representing the class names.
+//
+// Returns:
+//
+//	A slice of strings representing the resource paths.
+func CollectionsMetadata(classes ...string) []string {
+	classes = schema.UppercaseClassesNames(classes...)
+
+	if len(classes) == 0 || (len(classes) == 1 && (classes[0] == "" || classes[0] == "*")) {
+		return []string{fmt.Sprintf("%s/collections/*/shards/#", SchemaDomain)}
+	}
+
+	resources := make([]string, len(classes))
+	for idx := range classes {
+		if classes[idx] == "" {
+			resources[idx] = fmt.Sprintf("%s/collections/*/shards/#", SchemaDomain)
+		} else {
+			resources[idx] = fmt.Sprintf("%s/collections/%s/shards/#", SchemaDomain, classes[idx])
+		}
+	}
+
+	return resources
+}
+
+func Aliases(class string, aliases ...string) []string {
+	class = schema.UppercaseClassName(class)
+	aliases = schema.UppercaseClassesNames(aliases...)
+
+	if class == "" {
+		class = "*"
+	}
+
+	if len(aliases) == 0 || (len(aliases) == 1 && (aliases[0] == "" || aliases[0] == "*")) {
+		return []string{fmt.Sprintf("%s/collections/%s/aliases/*", AliasesDomain, class)}
+	}
+
+	resources := make([]string, len(aliases))
+	for idx := range aliases {
+		if aliases[idx] == "" {
+			resources[idx] = fmt.Sprintf("%s/collections/%s/aliases/*", AliasesDomain, class)
+		} else {
+			resources[idx] = fmt.Sprintf("%s/collections/%s/aliases/%s", AliasesDomain, class, aliases[idx])
+		}
+	}
+
+	return resources
+}
+
+func CollectionsData(classes ...string) []string {
+	classes = schema.UppercaseClassesNames(classes...)
+
+	if len(classes) == 0 || (len(classes) == 1 && (classes[0] == "" || classes[0] == "*")) {
+		return []string{Objects("*", "*", "*")}
+	}
+
+	var paths []string
+	for _, class := range classes {
+		paths = append(paths, Objects(class, "*", "*"))
+	}
+	return paths
+}
+
+func Collections(classes ...string) []string {
+	classes = schema.UppercaseClassesNames(classes...)
+	return append(CollectionsData(classes...), CollectionsMetadata(classes...)...)
+}
+
+// ShardsMetadata generates a list of shard resource strings for a given class and shards.
+// If the class is an empty string, it defaults to "*". If no shards are provided,
+// it returns a single resource string with a wildcard for shards. If shards are
+// provided, it returns a list of resource strings for each shard.
+//
+// Parameters:
+//   - class: The class name for the resource. If empty, defaults to "*".
+//   - shards: A variadic list of shard names. If empty, it will replace it with '#' to mark it as collection only check
+//
+// Returns:
+//
+//	A slice of strings representing the resource paths for the given class and shards.
+func ShardsMetadata(class string, shards ...string) []string {
+	class = schema.UppercaseClassesNames(class)[0]
+	if class == "" {
+		class = "*"
+	}
+
+	if len(shards) == 0 || (len(shards) == 1 && (shards[0] == "" || shards[0] == "*")) {
+		return []string{fmt.Sprintf("%s/collections/%s/shards/*", SchemaDomain, class)}
+	}
+
+	resources := make([]string, len(shards))
+	for idx := range shards {
+		if shards[idx] == "" {
+			resources[idx] = fmt.Sprintf("%s/collections/%s/shards/*", SchemaDomain, class)
+		} else {
+			resources[idx] = fmt.Sprintf("%s/collections/%s/shards/%s", SchemaDomain, class, shards[idx])
+		}
+	}
+
+	return resources
+}
+
+func ShardsData(class string, shards ...string) []string {
+	class = schema.UppercaseClassesNames(class)[0]
+	var paths []string
+	for _, shard := range shards {
+		paths = append(paths, Objects(class, shard, "*"))
+	}
+	return paths
+}
+
+// Objects generates a string representing a path to objects within a collection and shard.
+// The path format varies based on the provided class, shard, and id parameters.
+//
+// Parameters:
+// - class: the class of the collection (string)
+// - shard: the shard identifier (string)
+// - id: the unique identifier of the object (strfmt.UUID)
+//
+// Returns:
+// - A string representing the path to the objects, with wildcards (*) used for any empty parameters.
+//
+// Example outputs:
+// - "collections/*/shards/*/objects/*" if all parameters are empty
+// - "collections/*/shards/*/objects/{id}" if only id is provided
+// - "collections/{class}/shards/{shard}/objects/{id}" if all parameters are provided
+func Objects(class, shard string, id strfmt.UUID) string {
+	class = schema.UppercaseClassesNames(class)[0]
+	if class == "" {
+		class = "*"
+	}
+	if shard == "" {
+		shard = "*"
+	}
+	if id == "" {
+		id = "*"
+	}
+	return fmt.Sprintf("%s/collections/%s/shards/%s/objects/%s", DataDomain, class, shard, id)
+}
+
+// Backups generates a resource string for the given classes.
+// If the backend is an empty string, it defaults to "*".
+
+// Parameters:
+// - class: the class name (string)
+
+// Returns:
+// - A string representing the resource path for the given classes.
+
+// Example outputs:
+// - "backups/*" if the backend is an empty string
+// - "backups/{backend}" for the provided backend
+func Backups(classes ...string) []string {
+	classes = schema.UppercaseClassesNames(classes...)
+	if len(classes) == 0 || (len(classes) == 1 && (classes[0] == "" || classes[0] == "*")) {
+		return []string{fmt.Sprintf("%s/collections/*", BackupsDomain)}
+	}
+
+	resources := make([]string, len(classes))
+	for idx := range classes {
+		if classes[idx] == "" {
+			resources[idx] = fmt.Sprintf("%s/collections/*", BackupsDomain)
+		} else {
+			resources[idx] = fmt.Sprintf("%s/collections/%s", BackupsDomain, classes[idx])
+		}
+	}
+
+	return resources
+}
+
+// Replications generates a replication resource string for a given class and shard.
+//
+// Parameters:
+//   - class: The class name for the resource. If empty, defaults to "*".
+//   - shard: The shard name for the resource. If empty, defaults to "*".
+//
+// Returns:
+//
+//	A slice of strings representing the resource paths for the given class and shards.
+func Replications(class, shard string) string {
+	class = schema.UppercaseClassName(class)
+	if class == "" {
+		class = "*"
+	}
+	if shard == "" {
+		shard = "*"
+	}
+	return fmt.Sprintf("%s/collections/%s/shards/%s", ReplicateDomain, class, shard)
+}
+
+// WildcardPath returns the appropriate wildcard path based on the domain and original resource path.
+// The domain is expected to be the first part of the resource path.
+func WildcardPath(resource string) string {
+	parts := strings.Split(resource, "/")
+	parts[len(parts)-1] = "*"
+	return strings.Join(parts, "/")
+}
+
+func String(s string) *string {
+	return &s
+}
+
+// viewer : can view everything , roles, users, schema, data
+func viewerPermissions() []*models.Permission {
+	perms := []*models.Permission{}
+	for _, action := range availableWeaviateActions {
+		if strings.ToUpper(action)[0] != READ[0] {
+			continue
+		}
+
+		perms = append(perms, &models.Permission{
+			Action:      &action,
+			Backups:     AllBackups,
+			Data:        AllData,
+			Nodes:       AllNodes,
+			Roles:       AllRoles,
+			Collections: AllCollections,
+			Tenants:     AllTenants,
+			Users:       AllUsers,
+			Aliases:     AllAliases,
+			Groups:      AllOIDCGroups,
+		})
+	}
+
+	return perms
+}
+
+// Admin : aka basically super Admin or root
+func adminPermissions() []*models.Permission {
+	// TODO ignore CRUD if there is manage
+	perms := []*models.Permission{}
+	for _, action := range availableWeaviateActions {
+		perms = append(perms, &models.Permission{
+			Action:      &action,
+			Backups:     AllBackups,
+			Data:        AllData,
+			Nodes:       AllNodes,
+			Roles:       AllRoles,
+			Collections: AllCollections,
+			Tenants:     AllTenants,
+			Users:       AllUsers,
+			Aliases:     AllAliases,
+			Groups:      AllOIDCGroups,
+		})
+	}
+
+	return perms
+}
+
+func VerbWithScope(verb, scope string) string {
+	if strings.Contains(verb, "_") {
+		return verb
+	}
+
+	return fmt.Sprintf("%s_%s", verb, scope)
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/types_test.go

@@ -0,0 +1,287 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package authorization
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUsers(t *testing.T) {
+	tests := []struct {
+		name     string
+		users    []string
+		expected []string
+	}{
+		{"No users", []string{}, []string{fmt.Sprintf("%s/*", UsersDomain)}},
+		{"Single user", []string{"user1"}, []string{fmt.Sprintf("%s/user1", UsersDomain)}},
+		{"Multiple users", []string{"user1", "user2"}, []string{fmt.Sprintf("%s/user1", UsersDomain), fmt.Sprintf("%s/user2", UsersDomain)}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Users(tt.users...)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestGroups(t *testing.T) {
+	tests := []struct {
+		name     string
+		groups   []string
+		expected []string
+	}{
+		{"No groups", []string{}, []string{fmt.Sprintf("%s/%s/*", GroupsDomain, authentication.AuthTypeOIDC)}},
+		{"Single group", []string{"group1"}, []string{fmt.Sprintf("%s/%s/group1", GroupsDomain, authentication.AuthTypeOIDC)}},
+		{"Multiple groups", []string{"group1", "group2"}, []string{fmt.Sprintf("%s/%s/group1", GroupsDomain, authentication.AuthTypeOIDC), fmt.Sprintf("%s/%s/group2", GroupsDomain, authentication.AuthTypeOIDC)}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Groups(authentication.AuthTypeOIDC, tt.groups...)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestRoles(t *testing.T) {
+	tests := []struct {
+		name     string
+		roles    []string
+		expected []string
+	}{
+		{"No roles", []string{}, []string{fmt.Sprintf("%s/*", RolesDomain)}},
+		{"Single role", []string{"admin"}, []string{fmt.Sprintf("%s/admin", RolesDomain)}},
+		{"Multiple roles", []string{"admin", "user"}, []string{fmt.Sprintf("%s/admin", RolesDomain), fmt.Sprintf("%s/user", RolesDomain)}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Roles(tt.roles...)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestCluster(t *testing.T) {
+	expected := "cluster/*"
+	result := Cluster()
+	assert.Equal(t, expected, result)
+}
+
+func TestNodes(t *testing.T) {
+	tests := []struct {
+		name      string
+		verbosity string
+		classes   []string
+		expected  []string
+	}{
+		{"Empty verbosity", "", []string{}, []string{fmt.Sprintf("%s/verbosity/minimal", NodesDomain)}},
+		{"Minimal verbosity", "minimal", []string{}, []string{fmt.Sprintf("%s/verbosity/minimal", NodesDomain)}},
+		{"Minimal verbosity with classes", "minimal", []string{"class1"}, []string{fmt.Sprintf("%s/verbosity/minimal", NodesDomain)}},
+		{"Verbose verbosity with no classes", "verbose", []string{}, []string{fmt.Sprintf("%s/verbosity/verbose/collections/*", NodesDomain)}},
+		{"Verbose verbosity with classes", "verbose", []string{"class1", "class2"}, []string{fmt.Sprintf("%s/verbosity/verbose/collections/Class1", NodesDomain), fmt.Sprintf("%s/verbosity/verbose/collections/Class2", NodesDomain)}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Nodes(tt.verbosity, tt.classes...)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestBackups(t *testing.T) {
+	tests := []struct {
+		name     string
+		backend  string
+		expected []string
+	}{
+		{"No collection", "", []string{fmt.Sprintf("%s/collections/*", BackupsDomain)}},
+		{"Collection", "class1", []string{fmt.Sprintf("%s/collections/Class1", BackupsDomain)}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Backups(tt.backend)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestCollections(t *testing.T) {
+	tests := []struct {
+		name     string
+		classes  []string
+		expected []string
+	}{
+		{"No classes", []string{}, []string{fmt.Sprintf("%s/collections/*/shards/#", SchemaDomain)}},
+		{"Single empty class", []string{""}, []string{fmt.Sprintf("%s/collections/*/shards/#", SchemaDomain)}},
+		{"Single class", []string{"class1"}, []string{fmt.Sprintf("%s/collections/Class1/shards/#", SchemaDomain)}},
+		{"Multiple classes", []string{"class1", "class2"}, []string{fmt.Sprintf("%s/collections/Class1/shards/#", SchemaDomain), fmt.Sprintf("%s/collections/Class2/shards/#", SchemaDomain)}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := CollectionsMetadata(tt.classes...)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestShards(t *testing.T) {
+	tests := []struct {
+		name     string
+		class    string
+		shards   []string
+		expected []string
+	}{
+		{"No class, no shards", "", []string{}, []string{fmt.Sprintf("%s/collections/*/shards/*", SchemaDomain)}},
+		{"Class, no shards", "class1", []string{}, []string{fmt.Sprintf("%s/collections/Class1/shards/*", SchemaDomain)}},
+		{"No class, single shard", "", []string{"shard1"}, []string{fmt.Sprintf("%s/collections/*/shards/shard1", SchemaDomain)}},
+		{"Class, single shard", "class1", []string{"shard1"}, []string{fmt.Sprintf("%s/collections/Class1/shards/shard1", SchemaDomain)}},
+		{"Class, multiple shards", "class1", []string{"shard1", "shard2"}, []string{fmt.Sprintf("%s/collections/Class1/shards/shard1", SchemaDomain), fmt.Sprintf("%s/collections/Class1/shards/shard2", SchemaDomain)}},
+		{"Class, empty shard", "class1", []string{"shard1", ""}, []string{fmt.Sprintf("%s/collections/Class1/shards/shard1", SchemaDomain), fmt.Sprintf("%s/collections/Class1/shards/*", SchemaDomain)}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ShardsMetadata(tt.class, tt.shards...)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestObjects(t *testing.T) {
+	tests := []struct {
+		name     string
+		class    string
+		shard    string
+		id       strfmt.UUID
+		expected string
+	}{
+		{"No class, no shard, no id", "", "", "", fmt.Sprintf("%s/collections/*/shards/*/objects/*", DataDomain)},
+		{"Class, no shard, no id", "class1", "", "", fmt.Sprintf("%s/collections/Class1/shards/*/objects/*", DataDomain)},
+		{"No class, shard, no id", "", "shard1", "", fmt.Sprintf("%s/collections/*/shards/shard1/objects/*", DataDomain)},
+		{"No class, no shard, id", "", "", "id1", fmt.Sprintf("%s/collections/*/shards/*/objects/id1", DataDomain)},
+		{"Class, shard, no id", "class1", "shard1", "", fmt.Sprintf("%s/collections/Class1/shards/shard1/objects/*", DataDomain)},
+		{"Class, no shard, id", "class1", "", "id1", fmt.Sprintf("%s/collections/Class1/shards/*/objects/id1", DataDomain)},
+		{"No class, shard, id", "", "shard1", "id1", fmt.Sprintf("%s/collections/*/shards/shard1/objects/id1", DataDomain)},
+		{"Class, shard, id", "class1", "shard1", "id1", fmt.Sprintf("%s/collections/Class1/shards/shard1/objects/id1", DataDomain)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Objects(tt.class, tt.shard, tt.id)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestTenants(t *testing.T) {
+	tests := []struct {
+		name     string
+		class    string
+		shards   []string
+		expected []string
+	}{
+		{"No class, no tenant", "", []string{}, []string{fmt.Sprintf("%s/collections/*/shards/*", SchemaDomain)}},
+		{"Class, no tenant", "class1", []string{}, []string{fmt.Sprintf("%s/collections/Class1/shards/*", SchemaDomain)}},
+		{"No class, single tenant", "", []string{"tenant1"}, []string{fmt.Sprintf("%s/collections/*/shards/tenant1", SchemaDomain)}},
+		{"Class, single tenants", "class1", []string{"tenant1"}, []string{fmt.Sprintf("%s/collections/Class1/shards/tenant1", SchemaDomain)}},
+		{"Class, multiple tenants", "class1", []string{"tenant1", "tenant2"}, []string{fmt.Sprintf("%s/collections/Class1/shards/tenant1", SchemaDomain), fmt.Sprintf("%s/collections/Class1/shards/tenant2", SchemaDomain)}},
+		{"Class, empty tenant", "class1", []string{"tenant1", ""}, []string{fmt.Sprintf("%s/collections/Class1/shards/tenant1", SchemaDomain), fmt.Sprintf("%s/collections/Class1/shards/*", SchemaDomain)}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ShardsMetadata(tt.class, tt.shards...)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestGetWildcardPath(t *testing.T) {
+	tests := []struct {
+		name     string
+		resource string
+		expected string
+	}{
+		// Data domain tests
+		{
+			name:     "data domain full path",
+			resource: "data/collections/Class1/shards/Tenant1/objects/123",
+			expected: "data/collections/Class1/shards/Tenant1/objects/*",
+		},
+		{
+			name:     "data domain incomplete path",
+			resource: "data/collections/Class1/shards/Tenant1",
+			expected: "data/collections/Class1/shards/*",
+		},
+
+		// Schema domain tests
+		{
+			name:     "schema domain full path",
+			resource: "schema/collections/Class1/shards/Tenant1",
+			expected: "schema/collections/Class1/shards/*",
+		},
+		{
+			name:     "schema domain full path",
+			resource: "schema/collections/Class1/shards/Tenant1",
+			expected: "schema/collections/Class1/shards/*",
+		},
+		{
+			name:     "schema domain incomplete path",
+			resource: "schema/collections/Class1",
+			expected: "schema/collections/*",
+		},
+
+		// Backups domain tests
+		{
+			name:     "backups domain full path",
+			resource: "backups/collections/Class1",
+			expected: "backups/collections/*",
+		},
+		{
+			name:     "backups domain incomplete path",
+			resource: "backups/collections",
+			expected: "backups/*",
+		},
+
+		// Users domain tests
+		{
+			name:     "users domain",
+			resource: "users/user1",
+			expected: "users/*",
+		},
+
+		// Roles domain tests
+		{
+			name:     "roles domain",
+			resource: "roles/role1",
+			expected: "roles/*",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := WildcardPath(tt.resource)
+			assert.Equal(t, tt.expected, result, "WildcardPath(%q) = %q, want %q",
+				tt.resource, result, tt.expected)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/replica/transport.go

@@ -0,0 +1,293 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replica
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/additional"
+	"github.com/weaviate/weaviate/entities/filters"
+	"github.com/weaviate/weaviate/entities/search"
+	"github.com/weaviate/weaviate/entities/storobj"
+	"github.com/weaviate/weaviate/usecases/objects"
+	"github.com/weaviate/weaviate/usecases/replica/hashtree"
+)
+
+const (
+	// RequestKey is used to marshalling request IDs
+	RequestKey       = "request_id"
+	SchemaVersionKey = "schema_version"
+)
+
+// Client is used to read and write objects on replicas
+type Client interface {
+	RClient
+	WClient
+}
+
+// StatusCode is communicate the cause of failure during replication
+type StatusCode int
+
+const (
+	StatusOK            = 0
+	StatusClassNotFound = iota + 200
+	StatusShardNotFound
+	StatusNotFound
+	StatusAlreadyExisted
+	StatusNotReady
+	StatusConflict = iota + 300
+	StatusPreconditionFailed
+	StatusReadOnly
+	StatusObjectNotFound
+)
+
+// Error reports error happening during replication
+type Error struct {
+	Code StatusCode `json:"code"`
+	Msg  string     `json:"msg,omitempty"`
+	Err  error      `json:"-"`
+}
+
+// Empty checks whether e is an empty error which equivalent to e == nil
+func (e *Error) Empty() bool {
+	return e.Code == StatusOK && e.Msg == "" && e.Err == nil
+}
+
+// NewError create new replication error
+func NewError(code StatusCode, msg string) *Error {
+	return &Error{code, msg, nil}
+}
+
+func (e *Error) Clone() *Error {
+	return &Error{Code: e.Code, Msg: e.Msg, Err: e.Err}
+}
+
+// Unwrap underlying error
+func (e *Error) Unwrap() error { return e.Err }
+
+func (e *Error) Error() string {
+	return fmt.Sprintf("%s %q: %v", StatusText(e.Code), e.Msg, e.Err)
+}
+
+func (e *Error) IsStatusCode(sc StatusCode) bool {
+	return e.Code == sc
+}
+
+// StatusText returns a text for the status code. It returns the empty
+// string if the code is unknown.
+func StatusText(code StatusCode) string {
+	switch code {
+	case StatusOK:
+		return "ok"
+	case StatusNotFound:
+		return "not found"
+	case StatusClassNotFound:
+		return "class not found"
+	case StatusShardNotFound:
+		return "shard not found"
+	case StatusConflict:
+		return "conflict"
+	case StatusPreconditionFailed:
+		return "precondition failed"
+	case StatusAlreadyExisted:
+		return "already existed"
+	case StatusNotReady:
+		return "local index not ready"
+	case StatusReadOnly:
+		return "read only"
+	case StatusObjectNotFound:
+		return "object not found"
+	default:
+		return ""
+	}
+}
+
+func (e *Error) Timeout() bool {
+	t, ok := e.Err.(interface {
+		Timeout() bool
+	})
+	return ok && t.Timeout()
+}
+
+type SimpleResponse struct {
+	Errors []Error `json:"errors,omitempty"`
+}
+
+func (r *SimpleResponse) FirstError() error {
+	for i, err := range r.Errors {
+		if !err.Empty() {
+			return &r.Errors[i]
+		}
+	}
+	return nil
+}
+
+// DeleteBatchResponse represents the response returned by DeleteObjects
+type DeleteBatchResponse struct {
+	Batch []UUID2Error `json:"batch,omitempty"`
+}
+
+type UUID2Error struct {
+	UUID  string `json:"uuid,omitempty"`
+	Error Error  `json:"error,omitempty"`
+}
+
+// FirstError returns the first found error
+func (r *DeleteBatchResponse) FirstError() error {
+	for i, ue := range r.Batch {
+		if !ue.Error.Empty() {
+			return &r.Batch[i].Error
+		}
+	}
+	return nil
+}
+
+func fromReplicas(xs []Replica) []*storobj.Object {
+	rs := make([]*storobj.Object, len(xs))
+	for i := range xs {
+		rs[i] = xs[i].Object
+	}
+	return rs
+}
+
+type DigestObjectsInRangeReq struct {
+	InitialUUID strfmt.UUID `json:"initialUUID,omitempty"`
+	FinalUUID   strfmt.UUID `json:"finalUUID,omitempty"`
+	Limit       int         `json:"limit,omitempty"`
+}
+
+type DigestObjectsInRangeResp struct {
+	Digests []types.RepairResponse `json:"digests,omitempty"`
+}
+
+// WClient is the client used to write to replicas
+type WClient interface {
+	PutObject(ctx context.Context, host, index, shard, requestID string,
+		obj *storobj.Object, schemaVersion uint64) (SimpleResponse, error)
+	DeleteObject(ctx context.Context, host, index, shard, requestID string,
+		id strfmt.UUID, deletionTime time.Time, schemaVersion uint64) (SimpleResponse, error)
+	PutObjects(ctx context.Context, host, index, shard, requestID string,
+		objs []*storobj.Object, schemaVersion uint64) (SimpleResponse, error)
+	MergeObject(ctx context.Context, host, index, shard, requestID string,
+		mergeDoc *objects.MergeDocument, schemaVersion uint64) (SimpleResponse, error)
+	DeleteObjects(ctx context.Context, host, index, shard, requestID string,
+		uuids []strfmt.UUID, deletionTime time.Time, dryRun bool, schemaVersion uint64) (SimpleResponse, error)
+	AddReferences(ctx context.Context, host, index, shard, requestID string,
+		refs []objects.BatchReference, schemaVersion uint64) (SimpleResponse, error)
+	Commit(ctx context.Context, host, index, shard, requestID string, resp interface{}) error
+	Abort(ctx context.Context, host, index, shard, requestID string) (SimpleResponse, error)
+}
+
+// RClient is the client used to read from remote replicas
+type RClient interface {
+	// FetchObject fetches one object
+	FetchObject(_ context.Context, host, index, shard string,
+		id strfmt.UUID, props search.SelectProperties,
+		additional additional.Properties, numRetries int) (Replica, error)
+
+	// FetchObjects fetches objects specified in ids list.
+	FetchObjects(_ context.Context, host, index, shard string,
+		ids []strfmt.UUID) ([]Replica, error)
+
+	// OverwriteObjects conditionally updates existing objects.
+	OverwriteObjects(_ context.Context, host, index, shard string,
+		_ []*objects.VObject) ([]types.RepairResponse, error)
+
+	// DigestObjects finds a list of objects and returns a compact representation
+	// of a list of the objects. This is used by the replicator to optimize the
+	// number of bytes transferred over the network when fetching a replicated
+	// object
+	DigestObjects(ctx context.Context, host, index, shard string,
+		ids []strfmt.UUID, numRetries int) ([]types.RepairResponse, error)
+
+	FindUUIDs(ctx context.Context, host, index, shard string,
+		filters *filters.LocalFilter) ([]strfmt.UUID, error)
+
+	DigestObjectsInRange(ctx context.Context, host, index, shard string,
+		initialUUID, finalUUID strfmt.UUID, limit int) ([]types.RepairResponse, error)
+
+	HashTreeLevel(ctx context.Context, host, index, shard string, level int,
+		discriminant *hashtree.Bitset) (digests []hashtree.Digest, err error)
+}
+
+// FinderClient extends RClient with consistency checks
+type FinderClient struct {
+	cl RClient
+}
+
+// FullRead reads full object
+func (fc FinderClient) FullRead(ctx context.Context,
+	host, index, shard string,
+	id strfmt.UUID,
+	props search.SelectProperties,
+	additional additional.Properties,
+	numRetries int,
+) (Replica, error) {
+	return fc.cl.FetchObject(ctx, host, index, shard, id, props, additional, numRetries)
+}
+
+func (fc FinderClient) HashTreeLevel(ctx context.Context,
+	host, index, shard string, level int, discriminant *hashtree.Bitset,
+) (digests []hashtree.Digest, err error) {
+	return fc.cl.HashTreeLevel(ctx, host, index, shard, level, discriminant)
+}
+
+// DigestReads reads digests of all specified objects
+func (fc FinderClient) DigestReads(ctx context.Context,
+	host, index, shard string,
+	ids []strfmt.UUID, numRetries int,
+) ([]types.RepairResponse, error) {
+	n := len(ids)
+	rs, err := fc.cl.DigestObjects(ctx, host, index, shard, ids, numRetries)
+	if err == nil && len(rs) != n {
+		err = fmt.Errorf("malformed digest read response: length expected %d got %d", n, len(rs))
+	}
+	return rs, err
+}
+
+func (fc FinderClient) DigestObjectsInRange(ctx context.Context,
+	host, index, shard string,
+	initialUUID, finalUUID strfmt.UUID, limit int,
+) ([]types.RepairResponse, error) {
+	return fc.cl.DigestObjectsInRange(ctx, host, index, shard, initialUUID, finalUUID, limit)
+}
+
+// FullReads read full objects
+func (fc FinderClient) FullReads(ctx context.Context,
+	host, index, shard string,
+	ids []strfmt.UUID,
+) ([]Replica, error) {
+	n := len(ids)
+	rs, err := fc.cl.FetchObjects(ctx, host, index, shard, ids)
+	if m := len(rs); err == nil && n != m {
+		err = fmt.Errorf("malformed full read response: length expected %d got %d", n, m)
+	}
+	return rs, err
+}
+
+// Overwrite specified object with most recent contents
+func (fc FinderClient) Overwrite(ctx context.Context,
+	host, index, shard string,
+	xs []*objects.VObject,
+) ([]types.RepairResponse, error) {
+	return fc.cl.OverwriteObjects(ctx, host, index, shard, xs)
+}
+
+func (fc FinderClient) FindUUIDs(ctx context.Context,
+	host, class, shard string, filters *filters.LocalFilter,
+) ([]strfmt.UUID, error) {
+	return fc.cl.FindUUIDs(ctx, host, class, shard, filters)
+}

platform/dbops/binaries/weaviate-src/usecases/replica/transport_test.go

@@ -0,0 +1,67 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replica_test
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/weaviate/weaviate/usecases/replica"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/net/context"
+)
+
+func TestReplicationErrorTimeout(t *testing.T) {
+	ctx := context.Background()
+	ctx, cancel := context.WithDeadline(ctx, time.Now())
+	defer cancel()
+	err := &replica.Error{Err: ctx.Err()}
+	assert.True(t, err.Timeout())
+	err = err.Clone()
+	assert.ErrorIs(t, err, context.DeadlineExceeded)
+}
+
+func TestReplicationErrorMarshal(t *testing.T) {
+	rawErr := replica.Error{Code: replica.StatusClassNotFound, Msg: "Article", Err: errors.New("error cannot be marshalled")}
+	bytes, err := json.Marshal(&rawErr)
+	assert.Nil(t, err)
+	got := replica.NewError(0, "")
+	assert.Nil(t, json.Unmarshal(bytes, got))
+	want := &replica.Error{Code: replica.StatusClassNotFound, Msg: "Article"}
+	assert.Equal(t, want, got)
+}
+
+func TestReplicationErrorStatus(t *testing.T) {
+	tests := []struct {
+		code replica.StatusCode
+		desc string
+	}{
+		{-1, ""},
+		{replica.StatusOK, "ok"},
+		{replica.StatusClassNotFound, "class not found"},
+		{replica.StatusShardNotFound, "shard not found"},
+		{replica.StatusNotFound, "not found"},
+		{replica.StatusAlreadyExisted, "already existed"},
+		{replica.StatusConflict, "conflict"},
+		{replica.StatusPreconditionFailed, "precondition failed"},
+		{replica.StatusReadOnly, "read only"},
+	}
+	for _, test := range tests {
+		got := replica.StatusText(test.code)
+		if got != test.desc {
+			t.Errorf("StatusText(%d) want %v got %v", test.code, test.desc, got)
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/schema/alias.go

@@ -0,0 +1,144 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	cschema "github.com/weaviate/weaviate/cluster/schema"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/filter"
+)
+
+func (h *Handler) GetAliases(ctx context.Context, principal *models.Principal, alias, className string) ([]*models.Alias, error) {
+	var class *models.Class
+	if className != "" {
+		name := schema.UppercaseClassName(className)
+		class = h.schemaReader.ReadOnlyClass(name)
+	}
+	aliases, err := h.schemaManager.GetAliases(ctx, alias, class)
+	if err != nil {
+		return nil, err
+	}
+
+	filteredAliases := filter.New[*models.Alias](h.Authorizer, h.config.Authorization.Rbac).Filter(
+		ctx,
+		h.logger,
+		principal,
+		aliases,
+		authorization.READ,
+		func(alias *models.Alias) string {
+			return authorization.Aliases(className, alias.Alias)[0]
+		},
+	)
+
+	return filteredAliases, nil
+}
+
+func (h *Handler) GetAlias(ctx context.Context, principal *models.Principal, alias string) (*models.Alias, error) {
+	alias = schema.UppercaseClassName(alias)
+	// NOTE: We pass empty class, because this endpoint doesn't know what collection the alias belongs to
+	// hence if RBAC is enabled, the user has to have read permission for all the collection for api to go discover
+	// right collection for the alias.
+	if err := h.Authorizer.Authorize(ctx, principal, authorization.READ, authorization.Aliases("", alias)...); err != nil {
+		return nil, err
+	}
+
+	a, err := h.schemaManager.GetAlias(ctx, alias)
+	if err != nil {
+		if errors.Is(err, cschema.ErrAliasNotFound) {
+			return nil, fmt.Errorf("alias %s not found: %w", alias, ErrNotFound)
+		}
+		return nil, err
+	}
+	return a, nil
+}
+
+func (h *Handler) AddAlias(ctx context.Context, principal *models.Principal,
+	alias *models.Alias,
+) (*models.Alias, uint64, error) {
+	alias.Class = schema.UppercaseClassName(alias.Class)
+	alias.Alias = schema.UppercaseClassName(alias.Alias)
+
+	err := h.Authorizer.Authorize(ctx, principal, authorization.CREATE, authorization.Aliases(alias.Class, alias.Alias)...)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	// alias should have same validation as collection.
+	al, err := schema.ValidateAliasName(alias.Alias)
+	if err != nil {
+		return nil, 0, err
+	}
+	alias.Alias = al
+
+	class := h.schemaReader.ReadOnlyClass(alias.Class)
+	version, err := h.schemaManager.CreateAlias(ctx, alias.Alias, class)
+	if err != nil {
+		return nil, 0, err
+	}
+	return &models.Alias{Alias: alias.Alias, Class: class.Class}, version, nil
+}
+
+func (h *Handler) UpdateAlias(ctx context.Context, principal *models.Principal,
+	aliasName, targetClassName string,
+) (*models.Alias, error) {
+	targetClassName = schema.UppercaseClassName(targetClassName)
+	aliasName = schema.UppercaseClassName(aliasName)
+	err := h.Authorizer.Authorize(ctx, principal, authorization.UPDATE, authorization.Aliases(targetClassName, aliasName)...)
+	if err != nil {
+		return nil, err
+	}
+	aliases, err := h.schemaManager.GetAliases(ctx, aliasName, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(aliases) != 1 {
+		return nil, fmt.Errorf("%w, no alias found with name: %s", ErrNotFound, aliasName)
+	}
+
+	alias := aliases[0]
+	targetClass := h.schemaReader.ReadOnlyClass(targetClassName)
+
+	_, err = h.schemaManager.ReplaceAlias(ctx, alias, targetClass)
+	if err != nil {
+		return nil, err
+	}
+
+	return &models.Alias{Alias: alias.Alias, Class: targetClass.Class}, nil
+}
+
+func (h *Handler) DeleteAlias(ctx context.Context, principal *models.Principal, aliasName string) error {
+	aliasName = schema.UppercaseClassName(aliasName)
+	err := h.Authorizer.Authorize(ctx, principal, authorization.DELETE, authorization.Aliases("", aliasName)...)
+	if err != nil {
+		return err
+	}
+
+	aliases, err := h.schemaManager.GetAliases(ctx, aliasName, nil)
+	if err != nil {
+		return err
+	}
+	if len(aliases) == 0 {
+		return fmt.Errorf("alias not found: %w", ErrNotFound)
+	}
+
+	if _, err = h.schemaManager.DeleteAlias(ctx, aliasName); err != nil {
+		return err
+	}
+	return nil
+}

platform/dbops/binaries/weaviate-src/usecases/schema/authorization_test.go

@@ -0,0 +1,241 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/mocks"
+)
+
+// A component-test like test suite that makes sure that every available UC is
+// potentially protected with the Authorization plugin
+func Test_Schema_Authorization(t *testing.T) {
+	type testCase struct {
+		methodName        string
+		additionalArgs    []interface{}
+		expectedVerb      string
+		expectedResources []string
+	}
+
+	tests := []testCase{
+		{
+			methodName:        "GetClass",
+			additionalArgs:    []interface{}{"classname"},
+			expectedVerb:      authorization.READ,
+			expectedResources: authorization.CollectionsMetadata("classname"),
+		},
+		{
+			methodName:        "GetConsistentClass",
+			additionalArgs:    []interface{}{"classname", false},
+			expectedVerb:      authorization.READ,
+			expectedResources: authorization.CollectionsMetadata("classname"),
+		},
+		{
+			methodName:        "GetCachedClass",
+			additionalArgs:    []interface{}{"classname"},
+			expectedVerb:      authorization.READ,
+			expectedResources: authorization.CollectionsMetadata("classname"),
+		},
+		{
+			methodName:        "AddClass",
+			additionalArgs:    []interface{}{&models.Class{Class: "classname"}},
+			expectedVerb:      authorization.CREATE,
+			expectedResources: authorization.CollectionsMetadata("Classname"),
+		},
+		{
+			methodName:        "UpdateClass",
+			additionalArgs:    []interface{}{"class", &models.Class{Class: "class"}},
+			expectedVerb:      authorization.UPDATE,
+			expectedResources: authorization.CollectionsMetadata("class"),
+		},
+		{
+			methodName:        "DeleteClass",
+			additionalArgs:    []interface{}{"somename"},
+			expectedVerb:      authorization.DELETE,
+			expectedResources: authorization.CollectionsMetadata("somename"),
+		},
+		{
+			methodName:        "AddClassProperty",
+			additionalArgs:    []interface{}{&models.Class{Class: "classname"}, "classname", false, &models.Property{}},
+			expectedVerb:      authorization.UPDATE,
+			expectedResources: authorization.CollectionsMetadata("classname"),
+		},
+		{
+			methodName:        "DeleteClassProperty",
+			additionalArgs:    []interface{}{"somename", "someprop"},
+			expectedVerb:      authorization.UPDATE,
+			expectedResources: authorization.CollectionsMetadata("somename"),
+		},
+		{
+			methodName:        "UpdateShardStatus",
+			additionalArgs:    []interface{}{"className", "shardName", "targetStatus"},
+			expectedVerb:      authorization.UPDATE,
+			expectedResources: authorization.ShardsMetadata("className", "shardName"),
+		},
+		{
+			methodName:        "ShardsStatus",
+			additionalArgs:    []interface{}{"className", "tenant"},
+			expectedVerb:      authorization.READ,
+			expectedResources: authorization.ShardsMetadata("className", "tenant"),
+		},
+		{
+			methodName:        "AddTenants",
+			additionalArgs:    []interface{}{"className", []*models.Tenant{{Name: "P1"}}},
+			expectedVerb:      authorization.CREATE,
+			expectedResources: authorization.ShardsMetadata("className", "P1"),
+		},
+		{
+			methodName: "UpdateTenants",
+			additionalArgs: []interface{}{"className", []*models.Tenant{
+				{Name: "P1", ActivityStatus: models.TenantActivityStatusHOT},
+			}},
+			expectedVerb:      authorization.UPDATE,
+			expectedResources: authorization.ShardsMetadata("className", "P1"),
+		},
+		{
+			methodName:        "DeleteTenants",
+			additionalArgs:    []interface{}{"className", []string{"P1"}},
+			expectedVerb:      authorization.DELETE,
+			expectedResources: authorization.ShardsMetadata("className", "P1"),
+		},
+		{
+			methodName:        "ConsistentTenantExists",
+			additionalArgs:    []interface{}{"className", false, "P1"},
+			expectedVerb:      authorization.READ,
+			expectedResources: authorization.ShardsMetadata("className", "P1"),
+		},
+		{
+			methodName:        "AddAlias",
+			additionalArgs:    []interface{}{&models.Alias{Class: "classname", Alias: "aliasName"}},
+			expectedVerb:      authorization.CREATE,
+			expectedResources: authorization.Aliases("Classname", "AliasName"),
+		},
+		{
+			methodName:        "UpdateAlias",
+			additionalArgs:    []interface{}{"aliasName", "class"},
+			expectedVerb:      authorization.UPDATE,
+			expectedResources: authorization.Aliases("class", "aliasName"),
+		},
+		{
+			methodName:        "DeleteAlias",
+			additionalArgs:    []interface{}{"aliasName"},
+			expectedVerb:      authorization.DELETE,
+			expectedResources: authorization.Aliases("", "aliasName"),
+		},
+		{
+			methodName:        "GetAlias",
+			additionalArgs:    []interface{}{"aliasName"},
+			expectedVerb:      authorization.READ,
+			expectedResources: authorization.Aliases("", "aliasName"),
+		},
+	}
+
+	t.Run("verify that a test for every public method exists", func(t *testing.T) {
+		testedMethods := make([]string, len(tests))
+		for i, test := range tests {
+			testedMethods[i] = test.methodName
+		}
+
+		for _, method := range allExportedMethods(&Handler{classGetter: nil}) {
+			switch method {
+			case "RegisterSchemaUpdateCallback",
+				// introduced by sync.Mutex in go 1.18
+				"UpdateMeta", "GetSchemaSkipAuth", "IndexedInverted", "RLock", "RUnlock", "Lock", "Unlock",
+				"TryLock", "RLocker", "TryRLock", "TxManager", "RestoreClass",
+				"ShardOwner", "TenantShard", "ShardFromUUID", "LockGuard", "RLockGuard", "ShardReplicas",
+				"GetCachedClassNoAuth",
+				// internal methods to indicate readiness state
+				"StartServing", "Shutdown", "Statistics",
+				// Cluster/nodes related endpoint
+				"JoinNode", "RemoveNode", "Nodes", "NodeName", "ClusterHealthScore", "ClusterStatus", "ResolveParentNodes",
+				// revert to schema v0 (non raft),
+				"GetConsistentSchema", "GetConsistentTenants", "GetConsistentTenant", "GetAliases",
+				// ignored because it will check if schema has collections otherwise returns nothing
+				"StoreSchemaV1":
+				// don't require auth on methods which are exported because other
+				// packages need to call them for maintenance and other regular jobs,
+				// but aren't user facing
+				continue
+			}
+			assert.Contains(t, testedMethods, method)
+		}
+	})
+
+	t.Run("verify the tested methods require correct permissions from the Authorizer", func(t *testing.T) {
+		principal := &models.Principal{}
+		for _, test := range tests {
+			t.Run(test.methodName, func(t *testing.T) {
+				authorizer := mocks.NewMockAuthorizer()
+				authorizer.SetErr(errors.New("just a test fake"))
+				handler, fakeSchemaManager := newTestHandlerWithCustomAuthorizer(t, &fakeDB{}, authorizer)
+				fakeSchemaManager.On("ReadOnlySchema").Return(models.Schema{})
+				fakeSchemaManager.On("ReadOnlyClass", mock.Anything).Return(models.Class{})
+				fakeSchemaManager.On("GetAliases", mock.Anything, mock.Anything, mock.Anything).Return([]*models.Alias{{}}, nil)
+				fakeSchemaManager.On("GetAlias", mock.Anything, mock.Anything).Return(&models.Alias{}, nil)
+
+				var args []interface{}
+				if test.methodName == "GetSchema" || test.methodName == "GetConsistentSchema" {
+					// no context on this method
+					args = append([]interface{}{principal}, test.additionalArgs...)
+				} else {
+					args = append([]interface{}{context.Background(), principal}, test.additionalArgs...)
+				}
+				out, _ := callFuncByName(handler, test.methodName, args...)
+
+				require.Len(t, authorizer.Calls(), 1, "Authorizer must be called")
+				assert.Equal(t, errors.New("just a test fake"), out[len(out)-1].Interface(),
+					"execution must abort with Authorizer error")
+				assert.Equal(t, mocks.AuthZReq{Principal: principal, Verb: test.expectedVerb, Resources: test.expectedResources},
+					authorizer.Calls()[0], "correct parameters must have been used on Authorizer")
+			})
+		}
+	})
+}
+
+// inspired by https://stackoverflow.com/a/33008200
+func callFuncByName(manager interface{}, funcName string, params ...interface{}) (out []reflect.Value, err error) {
+	managerValue := reflect.ValueOf(manager)
+	m := managerValue.MethodByName(funcName)
+	if !m.IsValid() {
+		return make([]reflect.Value, 0), fmt.Errorf("Method not found \"%s\"", funcName)
+	}
+	in := make([]reflect.Value, len(params))
+	for i, param := range params {
+		in[i] = reflect.ValueOf(param)
+	}
+	out = m.Call(in)
+	return
+}
+
+func allExportedMethods(subject interface{}) []string {
+	var methods []string
+	subjectType := reflect.TypeOf(subject)
+	for i := 0; i < subjectType.NumMethod(); i++ {
+		name := subjectType.Method(i).Name
+		if name[0] >= 'A' && name[0] <= 'Z' {
+			methods = append(methods, name)
+		}
+	}
+
+	return methods
+}

platform/dbops/binaries/weaviate-src/usecases/schema/class.go

@@ -0,0 +1,1009 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/weaviate/weaviate/entities/modelsext"
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/inverted/stopwords"
+	cschema "github.com/weaviate/weaviate/cluster/schema"
+	"github.com/weaviate/weaviate/entities/backup"
+	"github.com/weaviate/weaviate/entities/classcache"
+	entcfg "github.com/weaviate/weaviate/entities/config"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/replication"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/vectorindex"
+	"github.com/weaviate/weaviate/entities/versioned"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/config"
+	configRuntime "github.com/weaviate/weaviate/usecases/config/runtime"
+	"github.com/weaviate/weaviate/usecases/monitoring"
+	"github.com/weaviate/weaviate/usecases/replica"
+	"github.com/weaviate/weaviate/usecases/sharding"
+	shardingcfg "github.com/weaviate/weaviate/usecases/sharding/config"
+)
+
+func (h *Handler) GetClass(ctx context.Context, principal *models.Principal, name string) (*models.Class, error) {
+	if err := h.Authorizer.Authorize(ctx, principal, authorization.READ, authorization.CollectionsMetadata(name)...); err != nil {
+		return nil, err
+	}
+	name = schema.UppercaseClassName(name)
+
+	cl := h.schemaReader.ReadOnlyClass(name)
+	return cl, nil
+}
+
+func (h *Handler) GetConsistentClass(ctx context.Context, principal *models.Principal,
+	name string, consistency bool,
+) (*models.Class, uint64, error) {
+	if err := h.Authorizer.Authorize(ctx, principal, authorization.READ, authorization.CollectionsMetadata(name)...); err != nil {
+		return nil, 0, err
+	}
+
+	name = schema.UppercaseClassName(name)
+
+	if consistency {
+		vclasses, err := h.schemaManager.QueryReadOnlyClasses(name)
+		return vclasses[name].Class, vclasses[name].Version, err
+	}
+	class, err := h.schemaReader.ReadOnlyClassWithVersion(ctx, name, 0)
+	return class, 0, err
+}
+
+// GetCachedClass will return the class from the cache if it exists. Note that the context cache
+// will likely be at the "request" or "operation" level and not be shared between requests.
+// Uses the Handler's getClassMethod to determine how to get the class data.
+func (h *Handler) GetCachedClass(ctxWithClassCache context.Context,
+	principal *models.Principal, names ...string,
+) (map[string]versioned.Class, error) {
+	if err := h.Authorizer.Authorize(ctxWithClassCache, principal, authorization.READ, authorization.CollectionsMetadata(names...)...); err != nil {
+		return nil, err
+	}
+
+	return classcache.ClassesFromContext(ctxWithClassCache, func(names ...string) (map[string]versioned.Class, error) {
+		return h.classGetter.getClasses(names)
+	}, names...)
+}
+
+// GetCachedClassNoAuth will return the class from the cache if it exists. Note that the context cache
+// will likely be at the "request" or "operation" level and not be shared between requests.
+// Uses the Handler's getClassMethod to determine how to get the class data.
+func (h *Handler) GetCachedClassNoAuth(ctxWithClassCache context.Context, names ...string) (map[string]versioned.Class, error) {
+	return classcache.ClassesFromContext(ctxWithClassCache, func(names ...string) (map[string]versioned.Class, error) {
+		return h.classGetter.getClasses(names)
+	}, names...)
+}
+
+// AddClass to the schema
+func (h *Handler) AddClass(ctx context.Context, principal *models.Principal,
+	cls *models.Class,
+) (*models.Class, uint64, error) {
+	cls.Class = schema.UppercaseClassName(cls.Class)
+	cls.Properties = schema.LowercaseAllPropertyNames(cls.Properties)
+
+	err := h.Authorizer.Authorize(ctx, principal, authorization.CREATE, authorization.CollectionsMetadata(cls.Class)...)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	classGetterWithAuth := func(name string) (*models.Class, error) {
+		if err := h.Authorizer.Authorize(ctx, principal, authorization.READ, authorization.CollectionsMetadata(name)...); err != nil {
+			return nil, err
+		}
+		return h.schemaReader.ReadOnlyClass(name), nil
+	}
+
+	if err := h.setNewClassDefaults(cls, h.config.Replication); err != nil {
+		return nil, 0, err
+	}
+
+	if err := h.validateCanAddClass(ctx, cls, classGetterWithAuth, false); err != nil {
+		return nil, 0, err
+	}
+	// migrate only after validation in completed
+	h.migrateClassSettings(cls)
+	if err := h.parser.ParseClass(cls); err != nil {
+		return nil, 0, err
+	}
+
+	err = h.invertedConfigValidator(cls.InvertedIndexConfig)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	existingCollectionsCount, err := h.schemaManager.QueryCollectionsCount()
+	if err != nil {
+		h.logger.WithField("error", err).Error("could not query the collections count")
+	}
+
+	limit := h.schemaConfig.MaximumAllowedCollectionsCount.Get()
+
+	if limit != config.DefaultMaximumAllowedCollectionsCount && existingCollectionsCount >= limit {
+		return nil, 0, fmt.Errorf(
+			"cannot create collection: maximum number of collections (%d) reached - "+
+				"please consider switching to multi-tenancy or increasing the collection count limit - "+
+				"see https://weaviate.io/collections-count-limit to learn about available options and best practices "+
+				"when working with multiple collections and tenants",
+			limit)
+	}
+
+	shardState, err := sharding.InitState(cls.Class,
+		cls.ShardingConfig.(shardingcfg.Config),
+		h.clusterState.LocalName(), h.schemaManager.StorageCandidates(), cls.ReplicationConfig.Factor,
+		schema.MultiTenancyEnabled(cls))
+	if err != nil {
+		return nil, 0, errors.Wrap(err, "init sharding state")
+	}
+
+	defaultQuantization := h.config.DefaultQuantization
+	h.enableQuantization(cls, defaultQuantization)
+
+	version, err := h.schemaManager.AddClass(ctx, cls, shardState)
+	if err != nil {
+		return nil, 0, err
+	}
+	return cls, version, err
+}
+
+func (h *Handler) enableQuantization(class *models.Class, defaultQuantization *configRuntime.DynamicValue[string]) {
+	compression := defaultQuantization.Get()
+	if !hasTargetVectors(class) || class.VectorIndexType != "" {
+		class.VectorIndexConfig = setDefaultQuantization(class.VectorIndexType, class.VectorIndexConfig.(schemaConfig.VectorIndexConfig), compression)
+	}
+
+	for k, vectorConfig := range class.VectorConfig {
+		vectorConfig.VectorIndexConfig = setDefaultQuantization(class.VectorIndexType, vectorConfig.VectorIndexConfig.(schemaConfig.VectorIndexConfig), compression)
+		class.VectorConfig[k] = vectorConfig
+	}
+}
+
+func setDefaultQuantization(vectorIndexType string, vectorIndexConfig schemaConfig.VectorIndexConfig, compression string) schemaConfig.VectorIndexConfig {
+	if len(vectorIndexType) == 0 {
+		vectorIndexType = vectorindex.DefaultVectorIndexType
+	}
+	if vectorIndexType == vectorindex.VectorIndexTypeHNSW && vectorIndexConfig.IndexType() == vectorindex.VectorIndexTypeHNSW {
+		hnswConfig := vectorIndexConfig.(hnsw.UserConfig)
+		pqEnabled := hnswConfig.PQ.Enabled
+		sqEnabled := hnswConfig.SQ.Enabled
+		rqEnabled := hnswConfig.RQ.Enabled
+		bqEnabled := hnswConfig.BQ.Enabled
+		skipDefaultQuantization := hnswConfig.SkipDefaultQuantization
+		hnswConfig.TrackDefaultQuantization = false
+		if pqEnabled || sqEnabled || rqEnabled || bqEnabled {
+			return hnswConfig
+		}
+		if skipDefaultQuantization {
+			return hnswConfig
+		}
+		switch compression {
+		case "pq":
+			hnswConfig.PQ.Enabled = true
+		case "sq":
+			hnswConfig.SQ.Enabled = true
+		case "rq-1":
+			hnswConfig.RQ.Enabled = true
+			hnswConfig.RQ.Bits = 1
+			hnswConfig.RQ.RescoreLimit = hnsw.DefaultBRQRescoreLimit
+		case "rq-8":
+			hnswConfig.RQ.Enabled = true
+			hnswConfig.RQ.Bits = 8
+			hnswConfig.RQ.RescoreLimit = hnsw.DefaultRQRescoreLimit
+		case "bq":
+			hnswConfig.BQ.Enabled = true
+		default:
+			return hnswConfig
+		}
+		hnswConfig.TrackDefaultQuantization = true
+		return hnswConfig
+	}
+	return vectorIndexConfig
+}
+
+func (h *Handler) RestoreClass(ctx context.Context, d *backup.ClassDescriptor, m map[string]string, overwriteAlias bool) error {
+	// get schema and sharding state
+	class := &models.Class{}
+	if err := json.Unmarshal(d.Schema, &class); err != nil {
+		return fmt.Errorf("unmarshal class schema: %w", err)
+	}
+	var shardingState sharding.State
+	if d.ShardingState != nil {
+		err := json.Unmarshal(d.ShardingState, &shardingState)
+		if err != nil {
+			return fmt.Errorf("unmarshal sharding state: %w", err)
+		}
+	}
+
+	aliases := make([]*models.Alias, 0)
+	if d.AliasesIncluded {
+		if err := json.Unmarshal(d.Aliases, &aliases); err != nil {
+			return fmt.Errorf("unmarshal aliases: %w", err)
+		}
+	}
+
+	metric, err := monitoring.GetMetrics().BackupRestoreClassDurations.GetMetricWithLabelValues(class.Class)
+	if err == nil {
+		timer := prometheus.NewTimer(metric)
+		defer timer.ObserveDuration()
+	}
+
+	class.Class = schema.UppercaseClassName(class.Class)
+	class.Properties = schema.LowercaseAllPropertyNames(class.Properties)
+
+	if err := h.setClassDefaults(class, h.config.Replication); err != nil {
+		return err
+	}
+
+	// no validation of reference for restore
+	classGetterWrapper := func(name string) (*models.Class, error) {
+		return h.schemaReader.ReadOnlyClass(name), nil
+	}
+
+	err = h.validateClassInvariants(ctx, class, classGetterWrapper, true)
+	if err != nil {
+		return err
+	}
+	// migrate only after validation in completed
+	h.migrateClassSettings(class)
+
+	if err := h.parser.ParseClass(class); err != nil {
+		return err
+	}
+
+	err = h.invertedConfigValidator(class.InvertedIndexConfig)
+	if err != nil {
+		return err
+	}
+
+	shardingState.MigrateFromOldFormat()
+	err = shardingState.MigrateShardingStateReplicationFactor()
+	if err != nil {
+		return fmt.Errorf("error while migrating replication factor: %w", err)
+	}
+	shardingState.ApplyNodeMapping(m)
+	_, err = h.schemaManager.RestoreClass(ctx, class, &shardingState)
+	if err != nil {
+		return fmt.Errorf("error when trying to restore class: %w", err)
+	}
+
+	for _, alias := range aliases {
+		var err error
+		_, err = h.schemaManager.CreateAlias(ctx, alias.Alias, class)
+		if errors.Is(err, cschema.ErrAliasExists) {
+			// Overwrite if user asks to during restore
+			if overwriteAlias {
+				_, err = h.schemaManager.DeleteAlias(ctx, alias.Alias)
+				if err != nil {
+					return fmt.Errorf("failed to restore alias for class: delete alias failed: %w", err)
+				}
+				// retry again
+				_, err = h.schemaManager.CreateAlias(ctx, alias.Alias, class)
+				if err != nil {
+					return fmt.Errorf("failed to restore alias for class: create alias failed: %w", err)
+				}
+				return nil
+			}
+			// Schema returned alias already exists error. So let user know
+			// that there is a "flag overwrite" if she want's to overwrite alias.
+			return fmt.Errorf("failed to restore alias for class: alias already exists. You can overwrite using `overwrite_alias` param when restoring")
+		}
+
+		if err != nil {
+			return fmt.Errorf("failed to restore alias for class: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// DeleteClass from the schema
+func (h *Handler) DeleteClass(ctx context.Context, principal *models.Principal, class string) error {
+	err := h.Authorizer.Authorize(ctx, principal, authorization.DELETE, authorization.CollectionsMetadata(class)...)
+	if err != nil {
+		return err
+	}
+
+	class = schema.UppercaseClassName(class)
+
+	if _, err = h.schemaManager.DeleteClass(ctx, class); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (h *Handler) UpdateClass(ctx context.Context, principal *models.Principal,
+	className string, updated *models.Class,
+) error {
+	err := h.Authorizer.Authorize(ctx, principal, authorization.UPDATE, authorization.CollectionsMetadata(className)...)
+	if err != nil || updated == nil {
+		return err
+	}
+
+	return UpdateClassInternal(h, ctx, className, updated)
+}
+
+// bypass the auth check for internal class update requests
+func UpdateClassInternal(h *Handler, ctx context.Context, className string, updated *models.Class,
+) error {
+	// make sure unset optionals on 'updated' don't lead to an error, as all
+	// optionals would have been set with defaults on the initial already
+	if err := h.setClassDefaults(updated, h.config.Replication); err != nil {
+		return err
+	}
+
+	if err := h.parser.ParseClass(updated); err != nil {
+		return err
+	}
+
+	// ideally, these calls would be encapsulated in ParseClass but ParseClass is
+	// used in many different areas of the codebase that may cause BC issues with the
+	// new validation logic. Issue ref: gh-5860
+	// As our testing becomes more comprehensive, we can move these calls into ParseClass
+	if err := h.parser.parseModuleConfig(updated); err != nil {
+		return fmt.Errorf("parse module config: %w", err)
+	}
+
+	if err := h.parser.parseVectorConfig(updated); err != nil {
+		return fmt.Errorf("parse vector config: %w", err)
+	}
+
+	if err := h.validateVectorSettings(updated); err != nil {
+		return err
+	}
+
+	if initial := h.schemaReader.ReadOnlyClass(className); initial != nil {
+		if err := validateImmutableFields(initial, updated); err != nil {
+			return err
+		}
+	}
+	// A nil sharding state means that the sharding state will not be updated.
+	_, err := h.schemaManager.UpdateClass(ctx, updated, nil)
+	return err
+}
+
+func (m *Handler) setNewClassDefaults(class *models.Class, globalCfg replication.GlobalConfig) error {
+	if class.ShardingConfig != nil && schema.MultiTenancyEnabled(class) {
+		return fmt.Errorf("cannot have both shardingConfig and multiTenancyConfig")
+	} else if class.MultiTenancyConfig == nil {
+		class.MultiTenancyConfig = &models.MultiTenancyConfig{}
+	} else if class.MultiTenancyConfig.Enabled {
+		class.ShardingConfig = shardingcfg.Config{DesiredCount: 0} // tenant shards will be created dynamically
+	}
+
+	if err := m.setClassDefaults(class, globalCfg); err != nil {
+		return err
+	}
+
+	if class.ReplicationConfig == nil {
+		class.ReplicationConfig = &models.ReplicationConfig{
+			Factor:           int64(m.config.Replication.MinimumFactor),
+			DeletionStrategy: models.ReplicationConfigDeletionStrategyNoAutomatedResolution,
+		}
+		return nil
+	}
+
+	if class.ReplicationConfig.DeletionStrategy == "" {
+		class.ReplicationConfig.DeletionStrategy = models.ReplicationConfigDeletionStrategyNoAutomatedResolution
+	}
+	return nil
+}
+
+func (h *Handler) setClassDefaults(class *models.Class, globalCfg replication.GlobalConfig) error {
+	// set legacy vector index defaults only when:
+	// 	- no target vectors are configured
+	//  - OR, there are target vectors configured AND there is a legacy vector configured
+	if !hasTargetVectors(class) || modelsext.ClassHasLegacyVectorIndex(class) {
+		if class.Vectorizer == "" {
+			class.Vectorizer = h.config.DefaultVectorizerModule
+		}
+
+		if class.VectorIndexType == "" {
+			class.VectorIndexType = vectorindex.DefaultVectorIndexType
+		}
+
+		if h.config.DefaultVectorDistanceMetric != "" {
+			if class.VectorIndexConfig == nil {
+				class.VectorIndexConfig = map[string]interface{}{"distance": h.config.DefaultVectorDistanceMetric}
+			} else if vIdxCfgMap, ok := class.VectorIndexConfig.(map[string]interface{}); ok && vIdxCfgMap["distance"] == nil {
+				class.VectorIndexConfig.(map[string]interface{})["distance"] = h.config.DefaultVectorDistanceMetric
+			}
+		}
+	}
+
+	setInvertedConfigDefaults(class)
+	for _, prop := range class.Properties {
+		setPropertyDefaults(prop)
+	}
+
+	if class.ReplicationConfig == nil {
+		class.ReplicationConfig = &models.ReplicationConfig{Factor: int64(globalCfg.MinimumFactor)}
+	}
+
+	if class.ReplicationConfig.Factor > 0 && class.ReplicationConfig.Factor < int64(globalCfg.MinimumFactor) {
+		return fmt.Errorf("invalid replication factor: setup requires a minimum replication factor of %d: got %d",
+			globalCfg.MinimumFactor, class.ReplicationConfig.Factor)
+	}
+
+	if class.ReplicationConfig.Factor < 1 {
+		class.ReplicationConfig.Factor = int64(globalCfg.MinimumFactor)
+	}
+
+	h.moduleConfig.SetClassDefaults(class)
+	return nil
+}
+
+func setPropertyDefaults(props ...*models.Property) {
+	setPropertyDefaultTokenization(props...)
+	setPropertyDefaultIndexing(props...)
+	for _, prop := range props {
+		setNestedPropertiesDefaults(prop.NestedProperties)
+	}
+}
+
+func setPropertyDefaultTokenization(props ...*models.Property) {
+	for _, prop := range props {
+		switch dataType, _ := schema.AsPrimitive(prop.DataType); dataType {
+		case schema.DataTypeString, schema.DataTypeStringArray:
+			// deprecated as of v1.19, default tokenization was word
+			// which will be migrated to text+whitespace
+			if prop.Tokenization == "" {
+				prop.Tokenization = models.PropertyTokenizationWord
+			}
+		case schema.DataTypeText, schema.DataTypeTextArray:
+			if prop.Tokenization == "" {
+				if os.Getenv("DEFAULT_TOKENIZATION") != "" {
+					prop.Tokenization = os.Getenv("DEFAULT_TOKENIZATION")
+				} else {
+					prop.Tokenization = models.PropertyTokenizationWord
+				}
+			}
+		default:
+			// tokenization not supported for other data types
+		}
+	}
+}
+
+func setPropertyDefaultIndexing(props ...*models.Property) {
+	for _, prop := range props {
+		// if IndexInverted is set but IndexFilterable and IndexSearchable are not
+		// migrate IndexInverted later.
+		if prop.IndexInverted != nil &&
+			prop.IndexFilterable == nil &&
+			prop.IndexSearchable == nil &&
+			prop.IndexRangeFilters == nil {
+			continue
+		}
+
+		vTrue := true
+		vFalse := false
+		if prop.IndexFilterable == nil {
+			prop.IndexFilterable = &vTrue
+		}
+		if prop.IndexSearchable == nil {
+			switch dataType, _ := schema.AsPrimitive(prop.DataType); dataType {
+			case schema.DataTypeString, schema.DataTypeStringArray:
+				// string/string[] are migrated to text/text[] later,
+				// at this point they are still valid data types, therefore should be handled here
+				prop.IndexSearchable = &vTrue
+			case schema.DataTypeText, schema.DataTypeTextArray:
+				prop.IndexSearchable = &vTrue
+			default:
+				prop.IndexSearchable = &vFalse
+			}
+		}
+		if prop.IndexRangeFilters == nil {
+			prop.IndexRangeFilters = &vFalse
+		}
+	}
+}
+
+func setNestedPropertiesDefaults(properties []*models.NestedProperty) {
+	for _, property := range properties {
+		primitiveDataType, isPrimitive := schema.AsPrimitive(property.DataType)
+		nestedDataType, isNested := schema.AsNested(property.DataType)
+
+		setNestedPropertyDefaultTokenization(property, primitiveDataType, nestedDataType, isPrimitive, isNested)
+		setNestedPropertyDefaultIndexing(property, primitiveDataType, nestedDataType, isPrimitive, isNested)
+
+		if isNested {
+			setNestedPropertiesDefaults(property.NestedProperties)
+		}
+	}
+}
+
+func setNestedPropertyDefaultTokenization(property *models.NestedProperty,
+	primitiveDataType, nestedDataType schema.DataType,
+	isPrimitive, isNested bool,
+) {
+	if property.Tokenization == "" && isPrimitive {
+		switch primitiveDataType {
+		case schema.DataTypeText, schema.DataTypeTextArray:
+			property.Tokenization = models.NestedPropertyTokenizationWord
+		default:
+			// do nothing
+		}
+	}
+}
+
+func setNestedPropertyDefaultIndexing(property *models.NestedProperty,
+	primitiveDataType, nestedDataType schema.DataType,
+	isPrimitive, isNested bool,
+) {
+	vTrue := true
+	vFalse := false
+
+	if property.IndexFilterable == nil {
+		property.IndexFilterable = &vTrue
+
+		if isPrimitive && primitiveDataType == schema.DataTypeBlob {
+			property.IndexFilterable = &vFalse
+		}
+	}
+
+	if property.IndexSearchable == nil {
+		property.IndexSearchable = &vFalse
+
+		if isPrimitive {
+			switch primitiveDataType {
+			case schema.DataTypeText, schema.DataTypeTextArray:
+				property.IndexSearchable = &vTrue
+			default:
+				// do nothing
+			}
+		}
+	}
+
+	if property.IndexRangeFilters == nil {
+		property.IndexRangeFilters = &vFalse
+	}
+}
+
+func (h *Handler) migrateClassSettings(class *models.Class) {
+	for _, prop := range class.Properties {
+		migratePropertySettings(prop)
+	}
+}
+
+func migratePropertySettings(props ...*models.Property) {
+	migratePropertyDataTypeAndTokenization(props...)
+	migratePropertyIndexInverted(props...)
+}
+
+// as of v1.19 DataTypeString and DataTypeStringArray are deprecated
+// here both are changed to Text/TextArray
+// and proper, backward compatible tokenization
+func migratePropertyDataTypeAndTokenization(props ...*models.Property) {
+	for _, prop := range props {
+		switch dataType, _ := schema.AsPrimitive(prop.DataType); dataType {
+		case schema.DataTypeString:
+			prop.DataType = schema.DataTypeText.PropString()
+		case schema.DataTypeStringArray:
+			prop.DataType = schema.DataTypeTextArray.PropString()
+		default:
+			// other types need no migration and do not support tokenization
+			continue
+		}
+
+		switch prop.Tokenization {
+		case models.PropertyTokenizationWord:
+			prop.Tokenization = models.PropertyTokenizationWhitespace
+		case models.PropertyTokenizationField:
+			// stays field
+		}
+	}
+}
+
+// as of v1.19 IndexInverted is deprecated and replaced with
+// IndexFilterable (set inverted index)
+// and IndexSearchable (map inverted index with term frequencies;
+// therefore applicable only to text/text[] data types)
+func migratePropertyIndexInverted(props ...*models.Property) {
+	vFalse := false
+
+	for _, prop := range props {
+		// if none of new options is set, use inverted settings
+		if prop.IndexInverted != nil &&
+			prop.IndexFilterable == nil &&
+			prop.IndexSearchable == nil &&
+			prop.IndexRangeFilters == nil {
+			prop.IndexFilterable = prop.IndexInverted
+			switch dataType, _ := schema.AsPrimitive(prop.DataType); dataType {
+			// string/string[] are already migrated into text/text[], can be skipped here
+			case schema.DataTypeText, schema.DataTypeTextArray:
+				prop.IndexSearchable = prop.IndexInverted
+			default:
+				prop.IndexSearchable = &vFalse
+			}
+			prop.IndexRangeFilters = &vFalse
+		}
+		// new options have precedence so inverted can be reset
+		prop.IndexInverted = nil
+	}
+}
+
+func (h *Handler) validateProperty(
+	class *models.Class, existingPropertyNames map[string]bool,
+	relaxCrossRefValidation bool, classGetterWithAuth func(string) (*models.Class, error), props ...*models.Property,
+) error {
+	for _, property := range props {
+		if _, err := schema.ValidatePropertyName(property.Name); err != nil {
+			return err
+		}
+
+		if err := schema.ValidateReservedPropertyName(property.Name); err != nil {
+			return err
+		}
+
+		if existingPropertyNames[strings.ToLower(property.Name)] {
+			return fmt.Errorf("class %q: conflict for property %q: already in use or provided multiple times", class.Class, property.Name)
+		}
+
+		// Validate data type of property.
+		propertyDataType, err := schema.FindPropertyDataTypeWithRefsAndAuth(classGetterWithAuth, property.DataType,
+			relaxCrossRefValidation, schema.ClassName(class.Class))
+		if err != nil {
+			return fmt.Errorf("property '%s': invalid dataType: %v: %w", property.Name, property.DataType, err)
+		}
+
+		if propertyDataType.IsNested() {
+			if err := validateNestedProperties(property.NestedProperties, property.Name); err != nil {
+				return err
+			}
+		} else {
+			if len(property.NestedProperties) > 0 {
+				return fmt.Errorf("property '%s': nestedProperties not allowed for data types other than object/object[]",
+					property.Name)
+			}
+		}
+
+		if err := h.validatePropertyTokenization(property.Tokenization, propertyDataType); err != nil {
+			return err
+		}
+
+		if err := h.validatePropertyIndexing(property); err != nil {
+			return err
+		}
+
+		if err := h.validatePropModuleConfig(class, property); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func setInvertedConfigDefaults(class *models.Class) {
+	if class.InvertedIndexConfig == nil {
+		class.InvertedIndexConfig = &models.InvertedIndexConfig{
+			UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+		}
+	}
+
+	if class.InvertedIndexConfig.CleanupIntervalSeconds == 0 {
+		class.InvertedIndexConfig.CleanupIntervalSeconds = config.DefaultCleanupIntervalSeconds
+	}
+
+	if class.InvertedIndexConfig.Bm25 == nil {
+		class.InvertedIndexConfig.Bm25 = &models.BM25Config{
+			K1: config.DefaultBM25k1,
+			B:  config.DefaultBM25b,
+		}
+	}
+
+	if class.InvertedIndexConfig.Stopwords == nil {
+		class.InvertedIndexConfig.Stopwords = &models.StopwordConfig{
+			Preset: stopwords.EnglishPreset,
+		}
+	}
+}
+
+func (h *Handler) validateCanAddClass(ctx context.Context, class *models.Class, classGetterWithAuth func(string) (*models.Class, error),
+	relaxCrossRefValidation bool,
+) error {
+	if modelsext.ClassHasLegacyVectorIndex(class) && len(class.VectorConfig) > 0 {
+		return fmt.Errorf("creating a class with both a class level vector index and named vectors is forbidden")
+	}
+
+	return h.validateClassInvariants(ctx, class, classGetterWithAuth, relaxCrossRefValidation)
+}
+
+func (h *Handler) validateClassInvariants(
+	ctx context.Context, class *models.Class, classGetterWithAuth func(string) (*models.Class, error),
+	relaxCrossRefValidation bool,
+) error {
+	if _, err := schema.ValidateClassName(class.Class); err != nil {
+		return err
+	}
+
+	existingPropertyNames := map[string]bool{}
+	for _, property := range class.Properties {
+		if err := h.validateProperty(class, existingPropertyNames, relaxCrossRefValidation, classGetterWithAuth, property); err != nil {
+			return err
+		}
+		existingPropertyNames[strings.ToLower(property.Name)] = true
+	}
+
+	if err := h.validateVectorSettings(class); err != nil {
+		return err
+	}
+
+	if err := h.moduleConfig.ValidateClass(ctx, class); err != nil {
+		return err
+	}
+
+	if err := validateMT(class); err != nil {
+		return err
+	}
+
+	if err := replica.ValidateConfig(class, h.config.Replication); err != nil {
+		return err
+	}
+
+	// all is fine!
+	return nil
+}
+
+func (h *Handler) validatePropertyTokenization(tokenization string, propertyDataType schema.PropertyDataType) error {
+	if propertyDataType.IsPrimitive() {
+		primitiveDataType := propertyDataType.AsPrimitive()
+
+		switch primitiveDataType {
+		case schema.DataTypeString, schema.DataTypeStringArray:
+			// deprecated as of v1.19, will be migrated to DataTypeText/DataTypeTextArray
+			switch tokenization {
+			case models.PropertyTokenizationField, models.PropertyTokenizationWord:
+				return nil
+			}
+		case schema.DataTypeText, schema.DataTypeTextArray:
+			switch tokenization {
+			case models.PropertyTokenizationField, models.PropertyTokenizationWord,
+				models.PropertyTokenizationWhitespace, models.PropertyTokenizationLowercase,
+				models.PropertyTokenizationTrigram:
+				return nil
+			case models.PropertyTokenizationGse:
+				if !entcfg.Enabled(os.Getenv("USE_GSE")) && !entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_GSE")) {
+					return fmt.Errorf("the GSE tokenizer is not enabled; set 'ENABLE_TOKENIZER_GSE' to 'true' to enable")
+				}
+				return nil
+			case models.PropertyTokenizationKagomeKr:
+				if !entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_KAGOME_KR")) {
+					return fmt.Errorf("the Korean tokenizer is not enabled; set 'ENABLE_TOKENIZER_KAGOME_KR' to 'true' to enable")
+				}
+				return nil
+			case models.PropertyTokenizationKagomeJa:
+				if !entcfg.Enabled(os.Getenv("ENABLE_TOKENIZER_KAGOME_JA")) {
+					return fmt.Errorf("the Japanese tokenizer is not enabled; set 'ENABLE_TOKENIZER_KAGOME_JA' to 'true' to enable")
+				}
+				return nil
+			}
+		default:
+			if tokenization == "" {
+				return nil
+			}
+			return fmt.Errorf("tokenization is not allowed for data type '%s'", primitiveDataType)
+		}
+		return fmt.Errorf("tokenization '%s' is not allowed for data type '%s'", tokenization, primitiveDataType)
+	}
+
+	if tokenization == "" {
+		return nil
+	}
+
+	if propertyDataType.IsNested() {
+		return fmt.Errorf("tokenization is not allowed for object/object[] data types")
+	}
+	return fmt.Errorf("tokenization is not allowed for reference data type")
+}
+
+func (h *Handler) validatePropertyIndexing(prop *models.Property) error {
+	if prop.IndexInverted != nil {
+		if prop.IndexFilterable != nil || prop.IndexSearchable != nil || prop.IndexRangeFilters != nil {
+			return fmt.Errorf("`indexInverted` is deprecated and can not be set together with `indexFilterable`, " + "`indexSearchable` or `indexRangeFilters`")
+		}
+	}
+
+	dataType, _ := schema.AsPrimitive(prop.DataType)
+	if prop.IndexSearchable != nil {
+		switch dataType {
+		case schema.DataTypeString, schema.DataTypeStringArray:
+			// string/string[] are migrated to text/text[] later,
+			// at this point they are still valid data types, therefore should be handled here.
+			// true or false allowed
+		case schema.DataTypeText, schema.DataTypeTextArray:
+			// true or false allowed
+		default:
+			if *prop.IndexSearchable {
+				return fmt.Errorf("`indexSearchable` is allowed only for text/text[] data types. " +
+					"For other data types set false or leave empty")
+			}
+		}
+	}
+	if prop.IndexRangeFilters != nil {
+		switch dataType {
+		case schema.DataTypeNumber, schema.DataTypeInt, schema.DataTypeDate:
+			// true or false allowed
+		case schema.DataTypeNumberArray, schema.DataTypeIntArray, schema.DataTypeDateArray:
+			// not supported (yet?)
+			fallthrough
+		default:
+			if *prop.IndexRangeFilters {
+				return fmt.Errorf("`indexRangeFilters` is allowed only for number/int/date data types. " +
+					"For other data types set false or leave empty")
+			}
+		}
+	}
+
+	return nil
+}
+
+func (h *Handler) validateVectorSettings(class *models.Class) error {
+	if modelsext.ClassHasLegacyVectorIndex(class) {
+		if err := h.validateVectorIndexType(class.VectorIndexType); err != nil {
+			return err
+		}
+
+		if err := h.validateVectorizer(class.Vectorizer); err != nil {
+			return err
+		}
+
+		if asMap, ok := class.VectorIndexConfig.(map[string]interface{}); ok && len(asMap) > 0 {
+			parsed, err := h.parser.parseGivenVectorIndexConfig(class.VectorIndexType, class.VectorIndexConfig, h.parser.modules.IsMultiVector(class.Vectorizer), h.config.DefaultQuantization)
+			if err != nil {
+				return fmt.Errorf("class.VectorIndexConfig can not parse: %w", err)
+			}
+			if parsed.IsMultiVector() {
+				return errors.New("class.VectorIndexConfig multi vector type index type is only configurable using named vectors")
+			}
+		}
+	}
+
+	for name, cfg := range class.VectorConfig {
+		// check only if vectorizer correctly configured (map with single key being vectorizer name)
+		// other cases are handled in module config validation
+		if vm, ok := cfg.Vectorizer.(map[string]interface{}); ok && len(vm) == 1 {
+			for vectorizer := range vm {
+				if err := h.validateVectorizer(vectorizer); err != nil {
+					return fmt.Errorf("target vector %q: %w", name, err)
+				}
+			}
+		}
+		if err := h.validateVectorIndexType(cfg.VectorIndexType); err != nil {
+			return fmt.Errorf("target vector %q: %w", name, err)
+		}
+	}
+	return nil
+}
+
+func (h *Handler) validateVectorizer(vectorizer string) error {
+	if vectorizer == config.VectorizerModuleNone {
+		return nil
+	}
+
+	if err := h.vectorizerValidator.ValidateVectorizer(vectorizer); err != nil {
+		return errors.Wrap(err, "vectorizer")
+	}
+
+	return nil
+}
+
+func (h *Handler) validateVectorIndexType(vectorIndexType string) error {
+	switch vectorIndexType {
+	case vectorindex.VectorIndexTypeHNSW, vectorindex.VectorIndexTypeFLAT:
+		return nil
+	case vectorindex.VectorIndexTypeDYNAMIC:
+		if !h.asyncIndexingEnabled {
+			return fmt.Errorf("the dynamic index can only be created under async indexing environment (ASYNC_INDEXING=true)")
+		}
+		return nil
+	default:
+		return errors.Errorf("unrecognized or unsupported vectorIndexType %q",
+			vectorIndexType)
+	}
+}
+
+func validateMT(class *models.Class) error {
+	enabled := schema.MultiTenancyEnabled(class)
+	if !enabled && schema.AutoTenantCreationEnabled(class) {
+		return fmt.Errorf("can't enable autoTenantCreation on a non-multi-tenant class")
+	}
+
+	if !enabled && schema.AutoTenantActivationEnabled(class) {
+		return fmt.Errorf("can't enable autoTenantActivation on a non-multi-tenant class")
+	}
+
+	return nil
+}
+
+// validateUpdatingMT validates toggling MT and returns whether mt is enabled
+func validateUpdatingMT(current, update *models.Class) (enabled bool, err error) {
+	enabled = schema.MultiTenancyEnabled(current)
+	if schema.MultiTenancyEnabled(update) != enabled {
+		if enabled {
+			err = fmt.Errorf("disabling multi-tenancy for an existing class is not supported")
+		} else {
+			err = fmt.Errorf("enabling multi-tenancy for an existing class is not supported")
+		}
+	} else {
+		err = validateMT(update)
+	}
+
+	return
+}
+
+func validateImmutableFields(initial, updated *models.Class) error {
+	immutableFields := []immutableText{
+		{
+			name:     "class name",
+			accessor: func(c *models.Class) string { return c.Class },
+		},
+	}
+
+	if err := validateImmutableTextFields(initial, updated, immutableFields...); err != nil {
+		return err
+	}
+
+	for k, v := range updated.VectorConfig {
+		if _, ok := initial.VectorConfig[k]; !ok {
+			continue
+		}
+
+		if !reflect.DeepEqual(initial.VectorConfig[k].Vectorizer, v.Vectorizer) {
+			return fmt.Errorf("vectorizer config of vector %q is immutable", k)
+		}
+	}
+
+	return nil
+}
+
+type immutableText struct {
+	accessor func(c *models.Class) string
+	name     string
+}
+
+func validateImmutableTextFields(previous, next *models.Class,
+	immutables ...immutableText,
+) error {
+	for _, immutable := range immutables {
+		oldField := immutable.accessor(previous)
+		newField := immutable.accessor(next)
+		if oldField != newField {
+			return errors.Errorf("%s is immutable: attempted change from %q to %q",
+				immutable.name, oldField, newField)
+		}
+	}
+	return nil
+}
+
+func validateLegacyVectorIndexConfigImmutableFields(initial, updated *models.Class) error {
+	return validateImmutableTextFields(initial, updated, []immutableText{
+		{
+			name:     "vectorizer",
+			accessor: func(c *models.Class) string { return c.Vectorizer },
+		},
+		{
+			name:     "vector index type",
+			accessor: func(c *models.Class) string { return c.VectorIndexType },
+		},
+	}...)
+}

platform/dbops/binaries/weaviate-src/usecases/schema/class_test.go

@@ -0,0 +1,2338 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/modelsext"
+	"github.com/weaviate/weaviate/entities/tokenizer"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/inverted/stopwords"
+	"github.com/weaviate/weaviate/entities/backup"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/replication"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+	"github.com/weaviate/weaviate/usecases/cluster/mocks"
+	"github.com/weaviate/weaviate/usecases/config"
+	"github.com/weaviate/weaviate/usecases/config/runtime"
+	"github.com/weaviate/weaviate/usecases/sharding"
+	shardingConfig "github.com/weaviate/weaviate/usecases/sharding/config"
+)
+
+func Test_AddClass(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+
+	t.Run("happy path", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+
+		class := &models.Class{
+			Class: "NewClass",
+			Properties: []*models.Property{
+				{DataType: []string{"text"}, Name: "textProp"},
+				{DataType: []string{"int"}, Name: "intProp"},
+			},
+			Vectorizer:        "none",
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		}
+		fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+		fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+
+		_, _, err := handler.AddClass(ctx, nil, class)
+		assert.Nil(t, err)
+
+		fakeSchemaManager.AssertExpectations(t)
+	})
+
+	t.Run("happy path, named vectors", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+
+		class := &models.Class{
+			Class: "NewClass",
+			Properties: []*models.Property{
+				{DataType: []string{"text"}, Name: "textProp"},
+			},
+			VectorConfig: map[string]models.VectorConfig{
+				"vec1": {
+					VectorIndexType: hnswT,
+					Vectorizer: map[string]interface{}{
+						"text2vec-contextionary": map[string]interface{}{},
+					},
+				},
+			},
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		}
+		fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+		fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+
+		_, _, err := handler.AddClass(ctx, nil, class)
+		require.NoError(t, err)
+
+		fakeSchemaManager.AssertExpectations(t)
+	})
+
+	t.Run("mixed vector schema creation", func(t *testing.T) {
+		handler, _ := newTestHandler(t, &fakeDB{})
+
+		class := &models.Class{
+			Class: "NewClass",
+			Properties: []*models.Property{
+				{DataType: []string{"text"}, Name: "textProp"},
+			},
+			Vectorizer:      "text2vec-contextionary",
+			VectorIndexType: hnswT,
+			VectorConfig: map[string]models.VectorConfig{
+				"vec1": {
+					VectorIndexType: hnswT,
+					Vectorizer: map[string]interface{}{
+						"text2vec-contextionary": map[string]interface{}{},
+					},
+				},
+			},
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		}
+
+		_, _, err := handler.AddClass(ctx, nil, class)
+		require.ErrorContains(t, err, "creating a class with both a class level vector index and named vectors is forbidden")
+	})
+
+	t.Run("with empty class name", func(t *testing.T) {
+		handler, _ := newTestHandler(t, &fakeDB{})
+		class := models.Class{ReplicationConfig: &models.ReplicationConfig{Factor: 1}}
+		_, _, err := handler.AddClass(ctx, nil, &class)
+		assert.EqualError(t, err, "'' is not a valid class name")
+	})
+
+	t.Run("with reserved class name", func(t *testing.T) {
+		handler, _ := newTestHandler(t, &fakeDB{})
+		class := models.Class{Class: config.DefaultRaftDir, ReplicationConfig: &models.ReplicationConfig{Factor: 1}}
+		_, _, err := handler.AddClass(ctx, nil, &class)
+		assert.EqualError(t, err, fmt.Sprintf("parse class name: class name `%s` is reserved", config.DefaultRaftDir))
+
+		class = models.Class{Class: "rAFT", ReplicationConfig: &models.ReplicationConfig{Factor: 1}}
+		_, _, err = handler.AddClass(ctx, nil, &class)
+		assert.EqualError(t, err, fmt.Sprintf("parse class name: class name `%s` is reserved", config.DefaultRaftDir))
+
+		class = models.Class{Class: "rAfT", ReplicationConfig: &models.ReplicationConfig{Factor: 1}}
+		_, _, err = handler.AddClass(ctx, nil, &class)
+		assert.EqualError(t, err, fmt.Sprintf("parse class name: class name `%s` is reserved", config.DefaultRaftDir))
+
+		class = models.Class{Class: "RaFT", ReplicationConfig: &models.ReplicationConfig{Factor: 1}}
+		_, _, err = handler.AddClass(ctx, nil, &class)
+		assert.EqualError(t, err, fmt.Sprintf("parse class name: class name `%s` is reserved", config.DefaultRaftDir))
+
+		class = models.Class{Class: "RAFT", ReplicationConfig: &models.ReplicationConfig{Factor: 1}}
+		_, _, err = handler.AddClass(ctx, nil, &class)
+		assert.EqualError(t, err, fmt.Sprintf("parse class name: class name `%s` is reserved", config.DefaultRaftDir))
+	})
+
+	t.Run("with default params", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+		class := models.Class{
+			Class:             "NewClass",
+			Vectorizer:        "none",
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		}
+
+		expectedBM25Config := &models.BM25Config{
+			K1: config.DefaultBM25k1,
+			B:  config.DefaultBM25b,
+		}
+		expectedStopwordConfig := &models.StopwordConfig{
+			Preset: stopwords.EnglishPreset,
+		}
+		expectedClass := &class
+		expectedClass.InvertedIndexConfig = &models.InvertedIndexConfig{
+			Bm25:                   expectedBM25Config,
+			CleanupIntervalSeconds: 60,
+			Stopwords:              expectedStopwordConfig,
+			UsingBlockMaxWAND:      config.DefaultUsingBlockMaxWAND,
+		}
+		fakeSchemaManager.On("AddClass", expectedClass, mock.Anything).Return(nil)
+		fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+		_, _, err := handler.AddClass(ctx, nil, &class)
+		require.Nil(t, err)
+		fakeSchemaManager.AssertExpectations(t)
+	})
+
+	t.Run("with customized params", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+		expectedBM25Config := &models.BM25Config{
+			K1: 1.88,
+			B:  0.44,
+		}
+		class := models.Class{
+			Class: "NewClass",
+			InvertedIndexConfig: &models.InvertedIndexConfig{
+				Bm25:              expectedBM25Config,
+				UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+			},
+			Vectorizer:        "none",
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		}
+
+		expectedStopwordConfig := &models.StopwordConfig{
+			Preset:    "none",
+			Additions: []string{"monkey", "zebra", "octopus"},
+			Removals:  []string{"are"},
+		}
+		expectedClass := &class
+		expectedClass.InvertedIndexConfig = &models.InvertedIndexConfig{
+			Bm25:                   expectedBM25Config,
+			CleanupIntervalSeconds: 60,
+			Stopwords:              expectedStopwordConfig,
+			UsingBlockMaxWAND:      config.DefaultUsingBlockMaxWAND,
+		}
+		fakeSchemaManager.On("AddClass", expectedClass, mock.Anything).Return(nil)
+		fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+		_, _, err := handler.AddClass(ctx, nil, &class)
+		require.Nil(t, err)
+		fakeSchemaManager.AssertExpectations(t)
+	})
+
+	t.Run("with tokenizations", func(t *testing.T) {
+		type testCase struct {
+			propName       string
+			dataType       []string
+			tokenization   string
+			expectedErrMsg string
+			callReadOnly   bool
+		}
+
+		propName := func(dataType schema.DataType, tokenization string) string {
+			dtStr := strings.ReplaceAll(string(dataType), "[]", "Array")
+			tStr := "empty"
+			if tokenization != "" {
+				tStr = tokenization
+			}
+			return fmt.Sprintf("%s_%s", dtStr, tStr)
+		}
+
+		// These classes are necessary for tests using references
+		classes := map[string]models.Class{
+			"SomeClass":       {Class: "SomeClass", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+			"SomeOtherClass":  {Class: "SomeOtherClass", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+			"YetAnotherClass": {Class: "YetAnotherClass", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+		}
+
+		runTestCases := func(t *testing.T, testCases []testCase) {
+			for i, tc := range testCases {
+				t.Run(tc.propName, func(t *testing.T) {
+					handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+
+					class := &models.Class{
+						Class: fmt.Sprintf("NewClass_%d", i),
+						Properties: []*models.Property{
+							{
+								Name:         tc.propName,
+								DataType:     tc.dataType,
+								Tokenization: tc.tokenization,
+							},
+						},
+						Vectorizer:        "none",
+						ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+					}
+					classes[class.Class] = *class
+
+					if tc.callReadOnly {
+						call := fakeSchemaManager.On("ReadOnlyClass", mock.Anything, mock.Anything).Return(nil)
+						call.RunFn = func(a mock.Arguments) {
+							existedClass := classes[a.Get(0).(string)]
+							call.ReturnArguments = mock.Arguments{&existedClass}
+						}
+					}
+
+					// fakeSchemaManager.On("ReadOnlyClass", mock.Anything).Return(&models.Class{Class: classes[tc.dataType[0]].Class, Vectorizer: classes[tc.dataType[0]].Vectorizer})
+					if tc.expectedErrMsg == "" {
+						fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+						fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+					}
+
+					_, _, err := handler.AddClass(context.Background(), nil, class)
+					if tc.expectedErrMsg == "" {
+						require.Nil(t, err)
+					} else {
+						require.EqualError(t, err, tc.expectedErrMsg)
+					}
+					fakeSchemaManager.AssertExpectations(t)
+				})
+			}
+		}
+
+		t.Run("text/textArray and all tokenizations", func(t *testing.T) {
+			var testCases []testCase
+			for _, dataType := range []schema.DataType{
+				schema.DataTypeText, schema.DataTypeTextArray,
+			} {
+				for _, tokenization := range append(tokenizer.Tokenizations, "") {
+					testCases = append(testCases, testCase{
+						propName:       propName(dataType, tokenization),
+						dataType:       dataType.PropString(),
+						tokenization:   tokenization,
+						expectedErrMsg: "",
+					})
+				}
+
+				tokenization := "non_existing"
+				testCases = append(testCases, testCase{
+					propName:       propName(dataType, tokenization),
+					dataType:       dataType.PropString(),
+					tokenization:   tokenization,
+					expectedErrMsg: fmt.Sprintf("tokenization '%s' is not allowed for data type '%s'", tokenization, dataType),
+				})
+			}
+
+			runTestCases(t, testCases)
+		})
+
+		t.Run("non text/textArray and all tokenizations", func(t *testing.T) {
+			var testCases []testCase
+			for _, dataType := range schema.PrimitiveDataTypes {
+				switch dataType {
+				case schema.DataTypeText, schema.DataTypeTextArray:
+					continue
+				default:
+					tokenization := ""
+					testCases = append(testCases, testCase{
+						propName:       propName(dataType, tokenization),
+						dataType:       dataType.PropString(),
+						tokenization:   tokenization,
+						expectedErrMsg: "",
+					})
+
+					for _, tokenization := range append(tokenizer.Tokenizations, "non_existing") {
+						testCases = append(testCases, testCase{
+							propName:       propName(dataType, tokenization),
+							dataType:       dataType.PropString(),
+							tokenization:   tokenization,
+							expectedErrMsg: fmt.Sprintf("tokenization is not allowed for data type '%s'", dataType),
+						})
+					}
+				}
+			}
+
+			runTestCases(t, testCases)
+		})
+
+		t.Run("non text/textArray and all tokenizations", func(t *testing.T) {
+			var testCases []testCase
+			for i, dataType := range [][]string{
+				{"SomeClass"},
+				{"SomeOtherClass", "YetAnotherClass"},
+			} {
+				testCases = append(testCases, testCase{
+					propName:       fmt.Sprintf("RefProp_%d_empty", i),
+					dataType:       dataType,
+					tokenization:   "",
+					expectedErrMsg: "",
+					callReadOnly:   true,
+				})
+
+				for _, tokenization := range append(tokenizer.Tokenizations, "non_existing") {
+					testCases = append(testCases, testCase{
+						propName:       fmt.Sprintf("RefProp_%d_%s", i, tokenization),
+						dataType:       dataType,
+						tokenization:   tokenization,
+						expectedErrMsg: "tokenization is not allowed for reference data type",
+						callReadOnly:   true,
+					})
+				}
+			}
+
+			runTestCases(t, testCases)
+		})
+
+		t.Run("[deprecated string] string/stringArray and all tokenizations", func(t *testing.T) {
+			var testCases []testCase
+			for _, dataType := range []schema.DataType{
+				schema.DataTypeString, schema.DataTypeStringArray,
+			} {
+				for _, tokenization := range []string{
+					models.PropertyTokenizationWord, models.PropertyTokenizationField, "",
+				} {
+					testCases = append(testCases, testCase{
+						propName:       propName(dataType, tokenization),
+						dataType:       dataType.PropString(),
+						tokenization:   tokenization,
+						expectedErrMsg: "",
+					})
+				}
+
+				for _, tokenization := range append(tokenizer.Tokenizations, "non_existing") {
+					switch tokenization {
+					case models.PropertyTokenizationWord, models.PropertyTokenizationField:
+						continue
+					default:
+						testCases = append(testCases, testCase{
+							propName:       propName(dataType, tokenization),
+							dataType:       dataType.PropString(),
+							tokenization:   tokenization,
+							expectedErrMsg: fmt.Sprintf("tokenization '%s' is not allowed for data type '%s'", tokenization, dataType),
+						})
+					}
+				}
+			}
+
+			runTestCases(t, testCases)
+		})
+	})
+
+	t.Run("with invalid settings", func(t *testing.T) {
+		handler, _ := newTestHandler(t, &fakeDB{})
+
+		_, _, err := handler.AddClass(ctx, nil, &models.Class{
+			Class:             "NewClass",
+			VectorIndexType:   "invalid",
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		})
+		assert.EqualError(t, err, `unrecognized or unsupported vectorIndexType "invalid"`)
+
+		// VectorConfig is invalid VectorIndexType
+		_, _, err = handler.AddClass(ctx, nil, &models.Class{
+			Class: "NewClass",
+			VectorConfig: map[string]models.VectorConfig{
+				"custom": {
+					VectorIndexType:   "invalid",
+					VectorIndexConfig: hnsw.UserConfig{},
+					Vectorizer:        map[string]interface{}{"none": map[string]interface{}{}},
+				},
+			},
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		})
+		assert.EqualError(t, err, `target vector "custom": unrecognized or unsupported vectorIndexType "invalid"`)
+
+		// VectorConfig is invalid Vectorizer
+		_, _, err = handler.AddClass(ctx, nil, &models.Class{
+			Class: "NewClass",
+			VectorConfig: map[string]models.VectorConfig{
+				"custom": {
+					VectorIndexType:   "flat",
+					VectorIndexConfig: hnsw.UserConfig{},
+					Vectorizer:        map[string]interface{}{"invalid": nil},
+				},
+			},
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		})
+		assert.EqualError(t, err, `target vector "custom": vectorizer: invalid vectorizer "invalid"`)
+	})
+}
+
+func Test_AddClassWithLimits(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+
+	t.Run("with max collections limit", func(t *testing.T) {
+		tests := []struct {
+			name          string
+			existingCount int
+			maxAllowed    int
+			expectedError error
+		}{
+			{
+				name:          "under the limit",
+				existingCount: 5,
+				maxAllowed:    10,
+				expectedError: nil,
+			},
+			{
+				name:          "at the limit",
+				existingCount: 10,
+				maxAllowed:    10,
+				expectedError: fmt.Errorf("maximum number of collections (10) reached"),
+			},
+			{
+				name:          "over the limit",
+				existingCount: 11,
+				maxAllowed:    10,
+				expectedError: fmt.Errorf("maximum number of collections (10) reached"),
+			},
+			{
+				name:          "no limit set",
+				existingCount: 100,
+				maxAllowed:    -1,
+				expectedError: nil,
+			},
+		}
+
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+
+				// Mock the schema count
+				fakeSchemaManager.On("QueryCollectionsCount").Return(tt.existingCount, nil)
+
+				// Set the max collections limit in config
+				handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(tt.maxAllowed)
+
+				class := &models.Class{
+					Class:             "NewClass",
+					Vectorizer:        "none",
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				}
+
+				if tt.expectedError == nil {
+					fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+					fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+				}
+
+				_, _, err := handler.AddClass(ctx, nil, class)
+				if tt.expectedError != nil {
+					require.NotNil(t, err)
+					assert.Contains(t, err.Error(), tt.expectedError.Error())
+				} else {
+					require.Nil(t, err)
+				}
+				fakeSchemaManager.AssertExpectations(t)
+			})
+		}
+	})
+
+	t.Run("adding dynamic index", func(t *testing.T) {
+		for _, tt := range []struct {
+			name                 string
+			asyncIndexingEnabled bool
+
+			expectError string
+		}{
+			{
+				name:                 "async indexing disabled",
+				asyncIndexingEnabled: false,
+
+				expectError: "the dynamic index can only be created under async indexing environment (ASYNC_INDEXING=true)",
+			},
+			{
+				name:                 "async indexing enabled",
+				asyncIndexingEnabled: true,
+			},
+		} {
+			t.Run(tt.name, func(t *testing.T) {
+				handler, schemaManager := newTestHandler(t, &fakeDB{})
+				handler.asyncIndexingEnabled = tt.asyncIndexingEnabled
+
+				if tt.expectError == "" {
+					schemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+					schemaManager.On("QueryCollectionsCount").Return(0, nil)
+					defer schemaManager.AssertExpectations(t)
+				}
+
+				assertError := func(err error) {
+					if tt.expectError != "" {
+						require.ErrorContains(t, err, tt.expectError)
+					} else {
+						require.NoError(t, err)
+					}
+				}
+
+				_, _, err := handler.AddClass(ctx, nil, &models.Class{
+					Class:             "NewClass",
+					VectorIndexType:   "dynamic",
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				})
+				assertError(err)
+
+				_, _, err = handler.AddClass(ctx, nil, &models.Class{
+					Class: "NewClass",
+					VectorConfig: map[string]models.VectorConfig{
+						"vec1": {
+							VectorIndexType: "dynamic",
+							Vectorizer:      map[string]any{"text2vec-contextionary": map[string]any{}},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				})
+				assertError(err)
+			})
+		}
+	})
+}
+
+func Test_AddClass_DefaultsAndMigration(t *testing.T) {
+	t.Parallel()
+
+	t.Run("set defaults and migrate string|stringArray datatype and tokenization", func(t *testing.T) {
+		type testCase struct {
+			propName     string
+			dataType     schema.DataType
+			tokenization string
+
+			expectedDataType     schema.DataType
+			expectedTokenization string
+		}
+
+		propName := func(dataType schema.DataType, tokenization string) string {
+			return strings.ReplaceAll(fmt.Sprintf("%s_%s", dataType, tokenization), "[]", "Array")
+		}
+
+		ctx := context.Background()
+		className := "MigrationClass"
+
+		var testCases []testCase
+		for _, dataType := range []schema.DataType{
+			schema.DataTypeText, schema.DataTypeTextArray,
+		} {
+			for _, tokenization := range tokenizer.Tokenizations {
+				testCases = append(testCases, testCase{
+					propName:             propName(dataType, tokenization),
+					dataType:             dataType,
+					tokenization:         tokenization,
+					expectedDataType:     dataType,
+					expectedTokenization: tokenization,
+				})
+			}
+			tokenization := ""
+			testCases = append(testCases, testCase{
+				propName:             propName(dataType, tokenization),
+				dataType:             dataType,
+				tokenization:         tokenization,
+				expectedDataType:     dataType,
+				expectedTokenization: models.PropertyTokenizationWord,
+			})
+		}
+		for _, dataType := range []schema.DataType{
+			schema.DataTypeString, schema.DataTypeStringArray,
+		} {
+			for _, tokenization := range []string{
+				models.PropertyTokenizationWord, models.PropertyTokenizationField, "",
+			} {
+				var expectedDataType schema.DataType
+				switch dataType {
+				case schema.DataTypeStringArray:
+					expectedDataType = schema.DataTypeTextArray
+				default:
+					expectedDataType = schema.DataTypeText
+				}
+
+				var expectedTokenization string
+				switch tokenization {
+				case models.PropertyTokenizationField:
+					expectedTokenization = models.PropertyTokenizationField
+				default:
+					expectedTokenization = models.PropertyTokenizationWhitespace
+				}
+
+				testCases = append(testCases, testCase{
+					propName:             propName(dataType, tokenization),
+					dataType:             dataType,
+					tokenization:         tokenization,
+					expectedDataType:     expectedDataType,
+					expectedTokenization: expectedTokenization,
+				})
+			}
+		}
+
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+		var properties []*models.Property
+		for _, tc := range testCases {
+			properties = append(properties, &models.Property{
+				Name:         "created_" + tc.propName,
+				DataType:     tc.dataType.PropString(),
+				Tokenization: tc.tokenization,
+			})
+		}
+
+		class := models.Class{
+			Class:             className,
+			Properties:        properties,
+			Vectorizer:        "none",
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		}
+
+		t.Run("create class with all properties", func(t *testing.T) {
+			fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+			fakeSchemaManager.On("ReadOnlyClass", mock.Anything, mock.Anything).Return(nil)
+			fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+			handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+			_, _, err := handler.AddClass(ctx, nil, &class)
+			require.Nil(t, err)
+		})
+
+		t.Run("add properties to existing class", func(t *testing.T) {
+			for _, tc := range testCases {
+				fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+				fakeSchemaManager.On("ReadOnlyClass", mock.Anything, mock.Anything).Return(&class)
+				fakeSchemaManager.On("AddProperty", mock.Anything, mock.Anything).Return(nil)
+				t.Run("added_"+tc.propName, func(t *testing.T) {
+					_, _, err := handler.AddClassProperty(ctx, nil, &class, class.Class, false, &models.Property{
+						Name:         "added_" + tc.propName,
+						DataType:     tc.dataType.PropString(),
+						Tokenization: tc.tokenization,
+					})
+
+					require.Nil(t, err)
+				})
+			}
+		})
+	})
+
+	t.Run("set defaults and migrate IndexInverted to IndexFilterable + IndexSearchable", func(t *testing.T) {
+		vFalse := false
+		vTrue := true
+		allBoolPtrs := []*bool{nil, &vFalse, &vTrue}
+
+		type testCase struct {
+			propName        string
+			dataType        schema.DataType
+			indexInverted   *bool
+			indexFilterable *bool
+			indexSearchable *bool
+
+			expectedInverted   *bool
+			expectedFilterable *bool
+			expectedSearchable *bool
+		}
+
+		boolPtrToStr := func(ptr *bool) string {
+			if ptr == nil {
+				return "nil"
+			}
+			return fmt.Sprintf("%v", *ptr)
+		}
+		propName := func(dt schema.DataType, inverted, filterable, searchable *bool) string {
+			return fmt.Sprintf("%s_inverted_%s_filterable_%s_searchable_%s",
+				dt.String(), boolPtrToStr(inverted), boolPtrToStr(filterable), boolPtrToStr(searchable))
+		}
+
+		ctx := context.Background()
+		className := "MigrationClass"
+
+		var testCases []testCase
+
+		for _, dataType := range []schema.DataType{schema.DataTypeText, schema.DataTypeInt} {
+			for _, inverted := range allBoolPtrs {
+				for _, filterable := range allBoolPtrs {
+					for _, searchable := range allBoolPtrs {
+						if inverted != nil {
+							if filterable != nil || searchable != nil {
+								// invalid combination, indexInverted can not be set
+								// together with indexFilterable or indexSearchable
+								continue
+							}
+						}
+
+						if searchable != nil && *searchable {
+							if dataType != schema.DataTypeText {
+								// invalid combination, indexSearchable can not be enabled
+								// for non text/text[] data type
+								continue
+							}
+						}
+
+						switch dataType {
+						case schema.DataTypeText:
+							if inverted != nil {
+								testCases = append(testCases, testCase{
+									propName:           propName(dataType, inverted, filterable, searchable),
+									dataType:           dataType,
+									indexInverted:      inverted,
+									indexFilterable:    filterable,
+									indexSearchable:    searchable,
+									expectedInverted:   nil,
+									expectedFilterable: inverted,
+									expectedSearchable: inverted,
+								})
+							} else {
+								expectedFilterable := filterable
+								if filterable == nil {
+									expectedFilterable = &vTrue
+								}
+								expectedSearchable := searchable
+								if searchable == nil {
+									expectedSearchable = &vTrue
+								}
+								testCases = append(testCases, testCase{
+									propName:           propName(dataType, inverted, filterable, searchable),
+									dataType:           dataType,
+									indexInverted:      inverted,
+									indexFilterable:    filterable,
+									indexSearchable:    searchable,
+									expectedInverted:   nil,
+									expectedFilterable: expectedFilterable,
+									expectedSearchable: expectedSearchable,
+								})
+							}
+						default:
+							if inverted != nil {
+								testCases = append(testCases, testCase{
+									propName:           propName(dataType, inverted, filterable, searchable),
+									dataType:           dataType,
+									indexInverted:      inverted,
+									indexFilterable:    filterable,
+									indexSearchable:    searchable,
+									expectedInverted:   nil,
+									expectedFilterable: inverted,
+									expectedSearchable: &vFalse,
+								})
+							} else {
+								expectedFilterable := filterable
+								if filterable == nil {
+									expectedFilterable = &vTrue
+								}
+								expectedSearchable := searchable
+								if searchable == nil {
+									expectedSearchable = &vFalse
+								}
+								testCases = append(testCases, testCase{
+									propName:           propName(dataType, inverted, filterable, searchable),
+									dataType:           dataType,
+									indexInverted:      inverted,
+									indexFilterable:    filterable,
+									indexSearchable:    searchable,
+									expectedInverted:   nil,
+									expectedFilterable: expectedFilterable,
+									expectedSearchable: expectedSearchable,
+								})
+							}
+						}
+					}
+				}
+			}
+		}
+
+		var properties []*models.Property
+		for _, tc := range testCases {
+			properties = append(properties, &models.Property{
+				Name:            "created_" + tc.propName,
+				DataType:        tc.dataType.PropString(),
+				IndexInverted:   tc.indexInverted,
+				IndexFilterable: tc.indexFilterable,
+				IndexSearchable: tc.indexSearchable,
+			})
+		}
+
+		class := models.Class{
+			Class:             className,
+			Properties:        properties,
+			Vectorizer:        "none",
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		}
+		t.Run("create class with all properties", func(t *testing.T) {
+			handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+			fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+			fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+			_, _, err := handler.AddClass(ctx, nil, &class)
+			require.Nil(t, err)
+			fakeSchemaManager.AssertExpectations(t)
+		})
+
+		t.Run("add properties to existing class", func(t *testing.T) {
+			handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+			for _, tc := range testCases {
+				t.Run("added_"+tc.propName, func(t *testing.T) {
+					prop := &models.Property{
+						Name:            "added_" + tc.propName,
+						DataType:        tc.dataType.PropString(),
+						IndexInverted:   tc.indexInverted,
+						IndexFilterable: tc.indexFilterable,
+						IndexSearchable: tc.indexSearchable,
+					}
+					fakeSchemaManager.On("AddProperty", className, []*models.Property{prop}).Return(nil)
+					_, _, err := handler.AddClassProperty(ctx, nil, &class, class.Class, false, prop)
+
+					require.Nil(t, err)
+				})
+			}
+			fakeSchemaManager.AssertExpectations(t)
+		})
+	})
+}
+
+func Test_Defaults_NestedProperties(t *testing.T) {
+	t.Parallel()
+
+	for _, pdt := range schema.PrimitiveDataTypes {
+		t.Run(pdt.String(), func(t *testing.T) {
+			nestedProperties := []*models.NestedProperty{
+				{
+					Name:     "nested_" + pdt.String(),
+					DataType: pdt.PropString(),
+				},
+			}
+
+			for _, ndt := range schema.NestedDataTypes {
+				t.Run(ndt.String(), func(t *testing.T) {
+					propPrimitives := &models.Property{
+						Name:             "objectProp",
+						DataType:         ndt.PropString(),
+						NestedProperties: nestedProperties,
+					}
+					propLvl2Primitives := &models.Property{
+						Name:     "objectPropLvl2",
+						DataType: ndt.PropString(),
+						NestedProperties: []*models.NestedProperty{
+							{
+								Name:             "nested_object",
+								DataType:         ndt.PropString(),
+								NestedProperties: nestedProperties,
+							},
+						},
+					}
+
+					setPropertyDefaults(propPrimitives)
+					setPropertyDefaults(propLvl2Primitives)
+
+					t.Run("primitive data types", func(t *testing.T) {
+						for _, np := range []*models.NestedProperty{
+							propPrimitives.NestedProperties[0],
+							propLvl2Primitives.NestedProperties[0].NestedProperties[0],
+						} {
+							switch pdt {
+							case schema.DataTypeText, schema.DataTypeTextArray:
+								require.NotNil(t, np.IndexFilterable)
+								assert.True(t, *np.IndexFilterable)
+								require.NotNil(t, np.IndexSearchable)
+								assert.True(t, *np.IndexSearchable)
+								assert.Equal(t, models.PropertyTokenizationWord, np.Tokenization)
+							case schema.DataTypeBlob:
+								require.NotNil(t, np.IndexFilterable)
+								assert.False(t, *np.IndexFilterable)
+								require.NotNil(t, np.IndexSearchable)
+								assert.False(t, *np.IndexSearchable)
+								assert.Equal(t, "", np.Tokenization)
+							default:
+								require.NotNil(t, np.IndexFilterable)
+								assert.True(t, *np.IndexFilterable)
+								require.NotNil(t, np.IndexSearchable)
+								assert.False(t, *np.IndexSearchable)
+								assert.Equal(t, "", np.Tokenization)
+							}
+						}
+					})
+
+					t.Run("nested data types", func(t *testing.T) {
+						for _, indexFilterable := range []*bool{
+							propPrimitives.IndexFilterable,
+							propLvl2Primitives.IndexFilterable,
+							propLvl2Primitives.NestedProperties[0].IndexFilterable,
+						} {
+							require.NotNil(t, indexFilterable)
+							assert.True(t, *indexFilterable)
+						}
+						for _, indexSearchable := range []*bool{
+							propPrimitives.IndexSearchable,
+							propLvl2Primitives.IndexSearchable,
+							propLvl2Primitives.NestedProperties[0].IndexSearchable,
+						} {
+							require.NotNil(t, indexSearchable)
+							assert.False(t, *indexSearchable)
+						}
+						for _, tokenization := range []string{
+							propPrimitives.Tokenization,
+							propLvl2Primitives.Tokenization,
+							propLvl2Primitives.NestedProperties[0].Tokenization,
+						} {
+							assert.Equal(t, "", tokenization)
+						}
+					})
+				})
+			}
+		})
+	}
+}
+
+func Test_Validation_ClassNames(t *testing.T) {
+	t.Parallel()
+
+	type testCase struct {
+		input    string
+		valid    bool
+		storedAs string
+		name     string
+	}
+
+	// all inputs represent class names (!)
+	tests := []testCase{
+		// valid names
+		{
+			name:     "Single uppercase word",
+			input:    "Car",
+			valid:    true,
+			storedAs: "Car",
+		},
+		{
+			name:     "Single lowercase word, stored as uppercase",
+			input:    "car",
+			valid:    true,
+			storedAs: "Car",
+		},
+		{
+			name:  "empty class",
+			input: "",
+			valid: false,
+		},
+	}
+
+	t.Run("adding a class", func(t *testing.T) {
+		t.Run("different class names without keywords or properties", func(t *testing.T) {
+			for _, test := range tests {
+				t.Run(test.name+" as thing class", func(t *testing.T) {
+					handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+					class := &models.Class{
+						Vectorizer:        "none",
+						Class:             test.input,
+						ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+					}
+
+					if test.valid {
+						fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+						fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+					}
+					_, _, err := handler.AddClass(context.Background(), nil, class)
+					t.Log(err)
+					assert.Equal(t, test.valid, err == nil)
+					fakeSchemaManager.AssertExpectations(t)
+				})
+			}
+		})
+
+		t.Run("different class names with valid keywords", func(t *testing.T) {
+			for _, test := range tests {
+				t.Run(test.name+" as thing class", func(t *testing.T) {
+					handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+					class := &models.Class{
+						Vectorizer:        "none",
+						Class:             test.input,
+						ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+					}
+
+					if test.valid {
+						fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+						fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+					}
+					_, _, err := handler.AddClass(context.Background(), nil, class)
+					t.Log(err)
+					assert.Equal(t, test.valid, err == nil)
+					fakeSchemaManager.AssertExpectations(t)
+				})
+			}
+		})
+	})
+}
+
+func Test_Validation_PropertyNames(t *testing.T) {
+	t.Parallel()
+	type testCase struct {
+		input    string
+		valid    bool
+		storedAs string
+		name     string
+	}
+
+	// for all test cases keep in mind that the word "carrot" is not present in
+	// the fake c11y, but every other word is
+	//
+	// all inputs represent property names (!)
+	tests := []testCase{
+		// valid names
+		{
+			name:     "Single uppercase word, stored as lowercase",
+			input:    "Brand",
+			valid:    true,
+			storedAs: "brand",
+		},
+		{
+			name:     "Single lowercase word",
+			input:    "brand",
+			valid:    true,
+			storedAs: "brand",
+		},
+		{
+			name:     "Property with underscores",
+			input:    "property_name",
+			valid:    true,
+			storedAs: "property_name",
+		},
+		{
+			name:     "Property with underscores and numbers",
+			input:    "property_name_2",
+			valid:    true,
+			storedAs: "property_name_2",
+		},
+		{
+			name:     "Property starting with underscores",
+			input:    "_property_name",
+			valid:    true,
+			storedAs: "_property_name",
+		},
+		{
+			name:  "empty prop name",
+			input: "",
+			valid: false,
+		},
+		{
+			name:  "reserved prop name: id",
+			input: "id",
+			valid: false,
+		},
+		{
+			name:  "reserved prop name: _id",
+			input: "_id",
+			valid: false,
+		},
+		{
+			name:  "reserved prop name: _additional",
+			input: "_additional",
+			valid: false,
+		},
+	}
+
+	ctx := context.Background()
+
+	t.Run("when adding a new class", func(t *testing.T) {
+		t.Run("different property names without keywords for the prop", func(t *testing.T) {
+			for _, test := range tests {
+				t.Run(test.name+" as thing class", func(t *testing.T) {
+					handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+					class := &models.Class{
+						Vectorizer: "none",
+						Class:      "ValidName",
+						Properties: []*models.Property{{
+							DataType: schema.DataTypeText.PropString(),
+							Name:     test.input,
+						}},
+						ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+					}
+
+					if test.valid {
+						fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+						fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+					}
+					handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+					_, _, err := handler.AddClass(context.Background(), nil, class)
+					assert.Equal(t, test.valid, err == nil)
+					fakeSchemaManager.AssertExpectations(t)
+				})
+			}
+		})
+
+		t.Run("different property names  with valid keywords for the prop", func(t *testing.T) {
+			for _, test := range tests {
+				t.Run(test.name+" as thing class", func(t *testing.T) {
+					handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+					class := &models.Class{
+						Vectorizer: "none",
+						Class:      "ValidName",
+						Properties: []*models.Property{{
+							DataType: schema.DataTypeText.PropString(),
+							Name:     test.input,
+						}},
+						ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+					}
+
+					if test.valid {
+						fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+						fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+					}
+					_, _, err := handler.AddClass(context.Background(), nil, class)
+					t.Log(err)
+					assert.Equal(t, test.valid, err == nil)
+					fakeSchemaManager.AssertExpectations(t)
+				})
+			}
+		})
+	})
+
+	t.Run("when updating an existing class with a new property", func(t *testing.T) {
+		t.Run("different property names without keywords for the prop", func(t *testing.T) {
+			for _, test := range tests {
+				t.Run(test.name+" as thing class", func(t *testing.T) {
+					handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+					class := &models.Class{
+						Vectorizer: "none",
+						Class:      "ValidName",
+						Properties: []*models.Property{
+							{
+								Name:     "dummyPropSoWeDontRunIntoAllNoindexedError",
+								DataType: schema.DataTypeText.PropString(),
+							},
+						},
+						ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+					}
+
+					fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+					fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+					_, _, err := handler.AddClass(context.Background(), nil, class)
+					require.Nil(t, err)
+
+					property := &models.Property{
+						DataType: schema.DataTypeText.PropString(),
+						Name:     test.input,
+					}
+					if test.valid {
+						fakeSchemaManager.On("AddProperty", class.Class, []*models.Property{property}).Return(nil)
+					}
+					_, _, err = handler.AddClassProperty(context.Background(), nil, class, class.Class, false, property)
+					t.Log(err)
+					require.Equal(t, test.valid, err == nil)
+					fakeSchemaManager.AssertExpectations(t)
+				})
+			}
+		})
+
+		t.Run("different property names  with valid keywords for the prop", func(t *testing.T) {
+			for _, test := range tests {
+				t.Run(test.name+" as thing class", func(t *testing.T) {
+					handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+					class := &models.Class{
+						Vectorizer: "none",
+						Class:      "ValidName",
+						Properties: []*models.Property{{
+							DataType: schema.DataTypeText.PropString(),
+							Name:     test.input,
+						}},
+						ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+					}
+
+					if test.valid {
+						fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+						fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+					}
+					_, _, err := handler.AddClass(ctx, nil, class)
+					t.Log(err)
+					assert.Equal(t, test.valid, err == nil)
+					fakeSchemaManager.AssertExpectations(t)
+				})
+			}
+		})
+	})
+}
+
+// As of now, most class settings are immutable, but we need to allow some
+// specific updates, such as the vector index config
+func Test_UpdateClass(t *testing.T) {
+	t.Run("class not found", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+		fakeSchemaManager.On("ReadOnlyClass", "WrongClass", mock.Anything).Return(nil)
+		fakeSchemaManager.On("UpdateClass", mock.Anything, mock.Anything).Return(ErrNotFound)
+
+		err := handler.UpdateClass(context.Background(), nil, "WrongClass", &models.Class{ReplicationConfig: &models.ReplicationConfig{Factor: 1}})
+		require.ErrorIs(t, err, ErrNotFound)
+		fakeSchemaManager.AssertExpectations(t)
+	})
+
+	t.Run("fields validation", func(t *testing.T) {
+		tests := []struct {
+			name          string
+			initial       *models.Class
+			update        *models.Class
+			expectedError error
+		}{
+			{
+				name:    "ChangeName",
+				initial: &models.Class{Class: "InitialName", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				update:  &models.Class{Class: "UpdatedName", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				expectedError: fmt.Errorf(
+					"class name is immutable: " +
+						"attempted change from \"InitialName\" to \"UpdatedName\""),
+			},
+			{
+				name:    "ModifyVectorizer",
+				initial: &models.Class{Class: "InitialName", Vectorizer: "model1", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				update:  &models.Class{Class: "InitialName", Vectorizer: "model2", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				expectedError: fmt.Errorf(
+					"vectorizer is immutable: " +
+						"attempted change from \"model1\" to \"model2\""),
+			},
+			{
+				name:    "ModifyVectorIndexType",
+				initial: &models.Class{Class: "InitialName", VectorIndexType: "hnsw", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				update:  &models.Class{Class: "InitialName", VectorIndexType: "flat", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				expectedError: fmt.Errorf(
+					"vector index type is immutable: " +
+						"attempted change from \"hnsw\" to \"flat\""),
+			},
+			{
+				name:          "UnsupportedVectorIndex",
+				initial:       &models.Class{Class: "InitialName", VectorIndexType: "hnsw", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				update:        &models.Class{Class: "InitialName", VectorIndexType: "lsh", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				expectedError: fmt.Errorf("unsupported vector"),
+			},
+			{
+				name:    "add property to an empty class",
+				initial: &models.Class{Class: "InitialName", Vectorizer: "none", ReplicationConfig: &models.ReplicationConfig{Factor: 1}},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name: "newProp",
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: errPropertiesUpdatedInClassUpdate,
+			},
+			{
+				name: "updating second property",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "prop1",
+							DataType: schema.DataTypeText.PropString(),
+						},
+						{
+							Name:     "prop2",
+							DataType: schema.DataTypeText.PropString(),
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "prop1",
+							DataType: schema.DataTypeText.PropString(),
+						},
+						{
+							Name:     "prop2",
+							DataType: schema.DataTypeInt.PropString(),
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: errPropertiesUpdatedInClassUpdate,
+			},
+			{
+				name: "properties order should not matter",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "prop1",
+							DataType: schema.DataTypeText.PropString(),
+						},
+						{
+							Name:     "prop2",
+							DataType: schema.DataTypeInt.PropString(),
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "prop2",
+							DataType: schema.DataTypeInt.PropString(),
+						},
+						{
+							Name:     "prop1",
+							DataType: schema.DataTypeText.PropString(),
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: nil,
+			},
+			{
+				name: "leaving properties unchanged",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "aProp",
+							DataType: schema.DataTypeText.PropString(),
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "aProp",
+							DataType: schema.DataTypeText.PropString(),
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: nil,
+			},
+			{
+				name: "attempting to rename a property",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "aProp",
+							DataType: schema.DataTypeText.PropString(),
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "changedProp",
+							DataType: schema.DataTypeText.PropString(),
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: fmt.Errorf(
+					"property fields other than description cannot be updated through updating the class. Use the add " +
+						"property feature (e.g. \"POST /v1/schema/{className}/properties\") " +
+						"to add additional properties"),
+			},
+			{
+				name: "attempting to update the inverted index cleanup interval",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					InvertedIndexConfig: &models.InvertedIndexConfig{
+						CleanupIntervalSeconds: 17,
+						UsingBlockMaxWAND:      config.DefaultUsingBlockMaxWAND,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					InvertedIndexConfig: &models.InvertedIndexConfig{
+						CleanupIntervalSeconds: 18,
+						Bm25: &models.BM25Config{
+							K1: config.DefaultBM25k1,
+							B:  config.DefaultBM25b,
+						},
+						UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+			},
+			{
+				name: "attempting to update the inverted index BM25 config",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					InvertedIndexConfig: &models.InvertedIndexConfig{
+						CleanupIntervalSeconds: 18,
+						Bm25: &models.BM25Config{
+							K1: 1.012,
+							B:  0.125,
+						},
+						UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					InvertedIndexConfig: &models.InvertedIndexConfig{
+						CleanupIntervalSeconds: 18,
+						Bm25: &models.BM25Config{
+							K1: 1.012,
+							B:  0.125,
+						},
+						UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+			},
+			{
+				name: "attempting to update the inverted index Stopwords config",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					InvertedIndexConfig: &models.InvertedIndexConfig{
+						CleanupIntervalSeconds: 18,
+						Stopwords: &models.StopwordConfig{
+							Preset: "en",
+						},
+						UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					InvertedIndexConfig: &models.InvertedIndexConfig{
+						CleanupIntervalSeconds: 18,
+						Stopwords: &models.StopwordConfig{
+							Preset:    "none",
+							Additions: []string{"banana", "passionfruit", "kiwi"},
+							Removals:  []string{"a", "the"},
+						},
+						UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+			},
+			{
+				name: "attempting to update module config",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					ModuleConfig: map[string]interface{}{
+						"my-module1": map[string]interface{}{
+							"my-setting": "some-value",
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					ModuleConfig: map[string]interface{}{
+						"my-module1": map[string]interface{}{
+							"my-setting": "updated-value",
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: fmt.Errorf("can only update generative and reranker module configs"),
+			},
+			{
+				name: "adding new module configuration",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					ModuleConfig: map[string]interface{}{
+						"my-module1": map[string]interface{}{
+							"my-setting": "some-value",
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					ModuleConfig: map[string]interface{}{
+						"my-module1": map[string]interface{}{
+							"my-setting": "some-value",
+						},
+						"my-module2": map[string]interface{}{
+							"my-setting": "some-value",
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: nil,
+			},
+			{
+				name: "adding new module configuration for a property",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "text",
+							DataType: schema.DataTypeText.PropString(),
+							ModuleConfig: map[string]interface{}{
+								"my-module1": map[string]interface{}{
+									"my-setting": "some-value",
+								},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "text",
+							DataType: schema.DataTypeText.PropString(),
+							ModuleConfig: map[string]interface{}{
+								"my-module1": map[string]interface{}{
+									"my-setting": "some-value",
+								},
+								"my-module2": map[string]interface{}{
+									"my-setting": "some-value",
+								},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: nil,
+			},
+			{
+				name: "updating existing module configuration for a property",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "text",
+							DataType: schema.DataTypeText.PropString(),
+							ModuleConfig: map[string]interface{}{
+								"my-module1": map[string]interface{}{
+									"my-setting": "some-value",
+								},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "text",
+							DataType: schema.DataTypeText.PropString(),
+							ModuleConfig: map[string]interface{}{
+								"my-module1": map[string]interface{}{
+									"my-setting": "new-value",
+								},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: errors.New(`module "my-module1" configuration cannot be updated`),
+			},
+			{
+				name: "removing existing module configuration for a property",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "text",
+							DataType: schema.DataTypeText.PropString(),
+							ModuleConfig: map[string]interface{}{
+								"my-module1": map[string]interface{}{
+									"my-setting": "some-value",
+								},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					Properties: []*models.Property{
+						{
+							Name:     "text",
+							DataType: schema.DataTypeText.PropString(),
+							ModuleConfig: map[string]interface{}{
+								"my-module2": map[string]interface{}{
+									"my-setting": "new-value",
+								},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: errors.New(`module "my-module1" configuration was removed`),
+			},
+			{
+				name: "updating vector index config",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					VectorIndexConfig: map[string]interface{}{
+						"some-setting": "old-value",
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					VectorIndexConfig: map[string]interface{}{
+						"some-setting": "new-value",
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: nil,
+			},
+			{
+				name: "try to turn MT on when it was previously off",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					MultiTenancyConfig: &models.MultiTenancyConfig{
+						Enabled: false,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					MultiTenancyConfig: &models.MultiTenancyConfig{
+						Enabled: true,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: fmt.Errorf("enabling multi-tenancy for an existing class is not supported"),
+			},
+			{
+				name: "try to turn MT off when it was previously on",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					MultiTenancyConfig: &models.MultiTenancyConfig{
+						Enabled: true,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					MultiTenancyConfig: &models.MultiTenancyConfig{
+						Enabled: false,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: fmt.Errorf("disabling multi-tenancy for an existing class is not supported"),
+			},
+			{
+				name: "change auto tenant creation after creating the class",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					MultiTenancyConfig: &models.MultiTenancyConfig{
+						Enabled: true,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					MultiTenancyConfig: &models.MultiTenancyConfig{
+						Enabled:            true,
+						AutoTenantCreation: true,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: nil,
+			},
+			{
+				name: "change auto tenant activation after creating the class",
+				initial: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					MultiTenancyConfig: &models.MultiTenancyConfig{
+						Enabled: true,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:      "InitialName",
+					Vectorizer: "none",
+					MultiTenancyConfig: &models.MultiTenancyConfig{
+						Enabled:              true,
+						AutoTenantActivation: true,
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: nil,
+			},
+			{
+				name: "adding named vector on a class with legacy index",
+				initial: &models.Class{
+					Class:             "InitialName",
+					Vectorizer:        "text2vec-contextionary",
+					VectorIndexType:   hnswT,
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:           "InitialName",
+					Vectorizer:      "text2vec-contextionary",
+					VectorIndexType: hnswT,
+					VectorConfig: map[string]models.VectorConfig{
+						"vec1": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: nil,
+			},
+			{
+				name: "adding new vector to a class with named vectors",
+				initial: &models.Class{
+					Class: "InitialName",
+					VectorConfig: map[string]models.VectorConfig{
+						"initial": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class: "InitialName",
+					VectorConfig: map[string]models.VectorConfig{
+						"initial": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+						"new": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+			},
+			{
+				name: "adding legacy vector to a class with named vectors",
+				initial: &models.Class{
+					Class: "InitialName",
+					VectorConfig: map[string]models.VectorConfig{
+						"initial": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:           "InitialName",
+					Vectorizer:      "text2vec-contextionary",
+					VectorIndexType: hnswT,
+					VectorConfig: map[string]models.VectorConfig{
+						"initial": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: fmt.Errorf("vectorizer is immutable"),
+			},
+			{
+				name: "removing existing named vector",
+				initial: &models.Class{
+					Class: "InitialName",
+					VectorConfig: map[string]models.VectorConfig{
+						"first": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+						"second": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class: "InitialName",
+					VectorConfig: map[string]models.VectorConfig{
+						"first": {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: fmt.Errorf(`missing config for vector "second"`),
+			},
+			{
+				name: "removing existing legacy vector",
+				initial: &models.Class{
+					Class:             "InitialName",
+					Vectorizer:        "text2vec-contextionary",
+					VectorIndexType:   hnswT,
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:             "InitialName",
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: fmt.Errorf("vectorizer is immutable"),
+			},
+			{
+				name: "adding named vector with reserved named on a collection with legacy index",
+				initial: &models.Class{
+					Class:             "InitialName",
+					Vectorizer:        "text2vec-contextionary",
+					VectorIndexType:   hnswT,
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				update: &models.Class{
+					Class:           "InitialName",
+					Vectorizer:      "text2vec-contextionary",
+					VectorIndexType: hnswT,
+					VectorConfig: map[string]models.VectorConfig{
+						modelsext.DefaultNamedVectorName: {
+							VectorIndexType: hnswT,
+							Vectorizer: map[string]interface{}{
+								"text2vec-contextionary": map[string]interface{}{},
+							},
+						},
+					},
+					ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+				},
+				expectedError: fmt.Errorf("vector named %s cannot be created when collection level vector index is configured", modelsext.DefaultNamedVectorName),
+			},
+		}
+
+		for _, test := range tests {
+			t.Run(test.name, func(t *testing.T) {
+				handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+				ctx := context.Background()
+
+				store := NewFakeStore()
+				store.parser = handler.parser
+
+				fakeSchemaManager.On("AddClass", test.initial, mock.Anything).Return(nil)
+				fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+				fakeSchemaManager.On("UpdateClass", mock.Anything, mock.Anything).Return(nil)
+				fakeSchemaManager.On("ReadOnlyClass", test.initial.Class, mock.Anything).Return(test.initial)
+				fakeSchemaManager.On("QueryShardingState", mock.Anything).Return(nil, nil)
+				if len(test.initial.Properties) > 0 {
+					fakeSchemaManager.On("ReadOnlyClass", test.initial.Class, mock.Anything).Return(test.initial)
+				}
+				handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+				_, _, err := handler.AddClass(ctx, nil, test.initial)
+				assert.Nil(t, err)
+				store.AddClass(test.initial)
+
+				fakeSchemaManager.On("UpdateClass", mock.Anything, mock.Anything).Return(nil)
+				err = handler.UpdateClass(ctx, nil, test.initial.Class, test.update)
+				if err == nil {
+					err = store.UpdateClass(test.update)
+				}
+
+				if test.expectedError == nil {
+					assert.NoError(t, err)
+				} else {
+					assert.ErrorContains(t, err, test.expectedError.Error())
+				}
+			})
+		}
+	})
+}
+
+func TestRestoreClass_WithCircularRefs(t *testing.T) {
+	// When restoring a class, there could be circular refs between the classes,
+	// thus any validation that checks if linked classes exist would fail on the
+	// first class to import. Since we have no control over the order of imports
+	// when restoring, we need to relax this validation.
+
+	t.Parallel()
+	handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+
+	classes := []*models.Class{
+		{
+			Class: "Class_A",
+			Properties: []*models.Property{{
+				Name:     "to_Class_B",
+				DataType: []string{"Class_B"},
+			}, {
+				Name:     "to_Class_C",
+				DataType: []string{"Class_C"},
+			}},
+			Vectorizer: "none",
+		},
+
+		{
+			Class: "Class_B",
+			Properties: []*models.Property{{
+				Name:     "to_Class_A",
+				DataType: []string{"Class_A"},
+			}, {
+				Name:     "to_Class_C",
+				DataType: []string{"Class_C"},
+			}},
+			Vectorizer: "none",
+		},
+
+		{
+			Class: "Class_C",
+			Properties: []*models.Property{{
+				Name:     "to_Class_A",
+				DataType: []string{"Class_A"},
+			}, {
+				Name:     "to_Class_B",
+				DataType: []string{"Class_B"},
+			}},
+			Vectorizer: "none",
+		},
+	}
+
+	for _, classRaw := range classes {
+		schemaBytes, err := json.Marshal(classRaw)
+		require.Nil(t, err)
+
+		// for this particular test the sharding state does not matter, so we can
+		// initiate any new sharding state
+		shardingConfig, err := shardingConfig.ParseConfig(nil, 1)
+		require.Nil(t, err)
+
+		nodes := mocks.NewMockNodeSelector("node1", "node2")
+		shardingState, err := sharding.InitState(classRaw.Class, shardingConfig, nodes.LocalName(), nodes.StorageCandidates(), 1, false)
+		require.Nil(t, err)
+
+		shardingBytes, err := shardingState.JSON()
+		require.Nil(t, err)
+
+		descriptor := backup.ClassDescriptor{Name: classRaw.Class, Schema: schemaBytes, ShardingState: shardingBytes}
+		fakeSchemaManager.On("RestoreClass", mock.Anything, mock.Anything).Return(nil)
+		err = handler.RestoreClass(context.Background(), &descriptor, map[string]string{}, false)
+		assert.Nil(t, err, "class passes validation")
+		fakeSchemaManager.AssertExpectations(t)
+	}
+}
+
+func TestRestoreClass_WithNodeMapping(t *testing.T) {
+	classes := []*models.Class{{
+		Class:      "Class_A",
+		Vectorizer: "none",
+	}}
+
+	handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+
+	for _, classRaw := range classes {
+		schemaBytes, err := json.Marshal(classRaw)
+		require.Nil(t, err)
+
+		shardingConfig, err := shardingConfig.ParseConfig(nil, 2)
+		require.Nil(t, err)
+
+		nodes := mocks.NewMockNodeSelector("node1", "node2")
+		shardingState, err := sharding.InitState(classRaw.Class, shardingConfig, nodes.LocalName(), nodes.StorageCandidates(), 2, false)
+		require.Nil(t, err)
+
+		shardingBytes, err := shardingState.JSON()
+		require.Nil(t, err)
+
+		descriptor := backup.ClassDescriptor{Name: classRaw.Class, Schema: schemaBytes, ShardingState: shardingBytes}
+		expectedShardingState := shardingState
+		expectedShardingState.ApplyNodeMapping(map[string]string{"node1": "new-node1"})
+		expectedShardingState.SetLocalName("")
+		fakeSchemaManager.On("RestoreClass", mock.Anything, shardingState).Return(nil)
+		err = handler.RestoreClass(context.Background(), &descriptor, map[string]string{"node1": "new-node1"}, false)
+		assert.NoError(t, err)
+	}
+}
+
+func Test_DeleteClass(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+
+	tests := []struct {
+		name          string
+		classToDelete string
+		expErr        bool
+		expErrMsg     string
+		existing      []*models.Class
+		expected      []*models.Class
+	}{
+		{
+			name:          "class exists",
+			classToDelete: "C1",
+			existing: []*models.Class{
+				{Class: "C1", VectorIndexType: "hnsw"},
+				{Class: "OtherClass", VectorIndexType: "hnsw"},
+			},
+			expected: []*models.Class{
+				classWithDefaultsSet(t, "OtherClass"),
+			},
+			expErr: false,
+		},
+		{
+			name:          "class does not exist",
+			classToDelete: "C1",
+			existing: []*models.Class{
+				{Class: "OtherClass", VectorIndexType: "hnsw"},
+			},
+			expected: []*models.Class{
+				classWithDefaultsSet(t, "OtherClass"),
+			},
+			expErr: false,
+		},
+		{
+			name:          "class delete should auto transform to GQL convention",
+			classToDelete: "c1", // all lower case form
+			existing: []*models.Class{
+				{Class: "C1", VectorIndexType: "hnsw"}, // GQL form
+				{Class: "OtherClass", VectorIndexType: "hnsw"},
+			},
+			expected: []*models.Class{
+				classWithDefaultsSet(t, "OtherClass"), // should still delete `C1` class name
+			},
+			expErr: false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+
+			// NOTE: mocking schema manager's `DeleteClass` (not handler's)
+			// underlying schemaManager should still work with canonical class name.
+			canonical := schema.UppercaseClassName(test.classToDelete)
+			fakeSchemaManager.On("DeleteClass", canonical).Return(nil)
+
+			// but layer above like handler's `DeleteClass` should work independent of case sensitivity.
+			err := handler.DeleteClass(ctx, nil, test.classToDelete)
+			if test.expErr {
+				require.NotNil(t, err)
+				assert.Contains(t, err.Error(), test.expErrMsg)
+			} else {
+				require.Nil(t, err)
+			}
+			fakeSchemaManager.AssertExpectations(t)
+		})
+	}
+}
+
+func Test_GetConsistentClass(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+
+	tests := []struct {
+		name       string
+		classToGet string
+		expErr     bool
+		expErrMsg  string
+		existing   []*models.Class
+		expected   *models.Class
+	}{
+		{
+			name:       "class exists",
+			classToGet: "C1",
+			existing: []*models.Class{
+				{Class: "C1", VectorIndexType: "hnsw"},
+				{Class: "OtherClass", VectorIndexType: "hnsw"},
+			},
+			expected: classWithDefaultsSet(t, "C1"),
+			expErr:   false,
+		},
+		{
+			name:       "class does not exist",
+			classToGet: "C1",
+			existing: []*models.Class{
+				{Class: "OtherClass", VectorIndexType: "hnsw"},
+			},
+			expected: &models.Class{}, // empty
+			expErr:   false,
+		},
+		{
+			name:       "class get should auto transform to GQL convention",
+			classToGet: "c1", // lowercase
+			existing: []*models.Class{
+				{Class: "C1", VectorIndexType: "hnsw"}, // original class is GQL form
+				{Class: "OtherClass", VectorIndexType: "hnsw"},
+			},
+			expected: classWithDefaultsSet(t, "C1"),
+			expErr:   false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+
+			// underlying schemaManager should still work with canonical class name.
+			canonical := schema.UppercaseClassName(test.classToGet)
+			fakeSchemaManager.On("ReadOnlyClassWithVersion", mock.Anything, canonical, mock.Anything).Return(test.expected, nil)
+
+			// but layer above like `GetConsistentClass` should work independent of case sensitivity.
+			got, _, err := handler.GetConsistentClass(ctx, nil, test.classToGet, false)
+			if test.expErr {
+				require.NotNil(t, err)
+				assert.Contains(t, err.Error(), test.expErrMsg)
+			} else {
+				require.Nil(t, err)
+				assert.Equal(t, got, test.expected)
+			}
+			fakeSchemaManager.AssertExpectations(t)
+		})
+	}
+}
+
+func classWithDefaultsSet(t *testing.T, name string) *models.Class {
+	class := &models.Class{Class: name, VectorIndexType: "hnsw"}
+
+	sc, err := shardingConfig.ParseConfig(map[string]interface{}{}, 1)
+	require.Nil(t, err)
+
+	class.ShardingConfig = sc
+
+	class.VectorIndexConfig = fakeVectorConfig{}
+	class.ReplicationConfig = &models.ReplicationConfig{Factor: 1}
+
+	return class
+}
+
+func Test_AddClass_MultiTenancy(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("with MT enabled and no optional settings", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+		class := models.Class{
+			MultiTenancyConfig: &models.MultiTenancyConfig{Enabled: true},
+			Class:              "NewClass",
+			Vectorizer:         "none",
+			ReplicationConfig:  &models.ReplicationConfig{Factor: 1},
+		}
+
+		fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+		fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+		handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+		c, _, err := handler.AddClass(ctx, nil, &class)
+		require.Nil(t, err)
+		assert.False(t, schema.AutoTenantCreationEnabled(c))
+		assert.False(t, schema.AutoTenantActivationEnabled(c))
+	})
+
+	t.Run("with MT enabled and all optional settings", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+		class := models.Class{
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled:              true,
+				AutoTenantCreation:   true,
+				AutoTenantActivation: true,
+			},
+			Class:             "NewClass",
+			Vectorizer:        "none",
+			ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+		}
+
+		fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+		fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+		handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+		c, _, err := handler.AddClass(ctx, nil, &class)
+		require.Nil(t, err)
+		assert.True(t, schema.AutoTenantCreationEnabled(c))
+		assert.True(t, schema.AutoTenantActivationEnabled(c))
+	})
+
+	t.Run("with MT disabled, but auto tenant creation on", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+		class := models.Class{
+			MultiTenancyConfig: &models.MultiTenancyConfig{Enabled: false, AutoTenantCreation: true},
+			Class:              "NewClass",
+			Vectorizer:         "none",
+			ReplicationConfig:  &models.ReplicationConfig{Factor: 1},
+		}
+
+		fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+		fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+		handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+		_, _, err := handler.AddClass(ctx, nil, &class)
+		require.NotNil(t, err)
+	})
+
+	t.Run("with MT disabled, but auto tenant activation on", func(t *testing.T) {
+		handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+		class := models.Class{
+			MultiTenancyConfig: &models.MultiTenancyConfig{Enabled: false, AutoTenantActivation: true},
+			Class:              "NewClass",
+			Vectorizer:         "none",
+			ReplicationConfig:  &models.ReplicationConfig{Factor: 1},
+		}
+
+		fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+		fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+		handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+		_, _, err := handler.AddClass(ctx, nil, &class)
+		require.NotNil(t, err)
+	})
+}
+
+func Test_SetClassDefaults(t *testing.T) {
+	globalCfg := replication.GlobalConfig{MinimumFactor: 3}
+	tests := []struct {
+		name           string
+		class          *models.Class
+		expectedError  string
+		expectedFactor int64
+	}{
+		{
+			name:           "ReplicationConfig is nil",
+			class:          &models.Class{},
+			expectedError:  "",
+			expectedFactor: 3,
+		},
+		{
+			name: "ReplicationConfig factor less than MinimumFactor",
+			class: &models.Class{
+				ReplicationConfig: &models.ReplicationConfig{
+					Factor: 2,
+				},
+			},
+			expectedError:  "invalid replication factor: setup requires a minimum replication factor of 3: got 2",
+			expectedFactor: 2,
+		},
+		{
+			name: "ReplicationConfig factor less than 1",
+			class: &models.Class{
+				ReplicationConfig: &models.ReplicationConfig{
+					Factor: 0,
+				},
+			},
+			expectedError:  "",
+			expectedFactor: 3,
+		},
+		{
+			name: "ReplicationConfig factor greater than or equal to MinimumFactor",
+			class: &models.Class{
+				ReplicationConfig: &models.ReplicationConfig{
+					Factor: 4,
+				},
+			},
+			expectedError:  "",
+			expectedFactor: 4,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			handler, _ := newTestHandler(t, &fakeDB{})
+			err := handler.setClassDefaults(tt.class, globalCfg)
+			if tt.expectedError != "" {
+				assert.EqualError(t, err, tt.expectedError)
+			} else {
+				assert.NoError(t, err)
+			}
+			assert.Equal(t, tt.expectedFactor, tt.class.ReplicationConfig.Factor)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/schema/executor.go

@@ -0,0 +1,370 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"runtime"
+	"sync"
+
+	"github.com/sirupsen/logrus"
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"golang.org/x/exp/slices"
+
+	"github.com/weaviate/weaviate/cluster/proto/api"
+	enterrors "github.com/weaviate/weaviate/entities/errors"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+var _NUMCPU = runtime.GOMAXPROCS(0)
+
+type executor struct {
+	schemaReader SchemaReader
+	migrator     Migrator
+
+	callbacksLock sync.RWMutex
+	callbacks     []func(updatedSchema schema.SchemaWithAliases)
+
+	logger          logrus.FieldLogger
+	restoreClassDir func(string) error
+}
+
+// NewManager creates a new manager
+func NewExecutor(migrator Migrator, sr SchemaReader,
+	logger logrus.FieldLogger, classBackupDir func(string) error,
+) *executor {
+	return &executor{
+		migrator:        migrator,
+		logger:          logger,
+		schemaReader:    sr,
+		restoreClassDir: classBackupDir,
+	}
+}
+
+func (e *executor) Open(ctx context.Context) error {
+	return e.migrator.WaitForStartup(ctx)
+}
+
+// ReloadLocalDB reloads the local database using the latest schema.
+func (e *executor) ReloadLocalDB(ctx context.Context, all []api.UpdateClassRequest) error {
+	cs := make([]*models.Class, len(all))
+
+	g, ctx := enterrors.NewErrorGroupWithContextWrapper(e.logger, ctx)
+	g.SetLimit(_NUMCPU * 2)
+
+	var errList error
+	var errMutex sync.Mutex
+
+	for i, u := range all {
+		i, u := i, u
+
+		g.Go(func() error {
+			e.logger.WithField("index", u.Class.Class).Info("reload local index")
+			cs[i] = u.Class
+
+			if err := e.migrator.UpdateIndex(ctx, u.Class, u.State); err != nil {
+				e.logger.WithField("index", u.Class.Class).WithError(err).Error("failed to reload local index")
+				err := fmt.Errorf("failed to reload local index %q: %w", i, err)
+
+				errMutex.Lock()
+				errList = errors.Join(errList, err)
+				errMutex.Unlock()
+			}
+			return nil
+		})
+	}
+
+	if err := g.Wait(); err != nil {
+		return err
+	}
+	return errList
+}
+
+func (e *executor) Close(ctx context.Context) error {
+	return e.migrator.Shutdown(ctx)
+}
+
+func (e *executor) AddClass(pl api.AddClassRequest) error {
+	ctx := context.Background()
+	if err := e.migrator.AddClass(ctx, pl.Class); err != nil {
+		return fmt.Errorf("apply add class: %w", err)
+	}
+	return nil
+}
+
+func (e *executor) AddReplicaToShard(class string, shard string, targetNode string) error {
+	ctx := context.Background()
+	if replicas, err := e.schemaReader.ShardReplicas(class, shard); err != nil {
+		return fmt.Errorf("error reading replicas for collection %s shard %s: %w", class, shard, err)
+	} else if !slices.Contains(replicas, targetNode) {
+		return fmt.Errorf("replica %s does not exists for collection %s shard %s", targetNode, class, shard)
+	}
+	return e.migrator.LoadShard(ctx, class, shard)
+}
+
+func (e *executor) DeleteReplicaFromShard(class string, shard string, targetNode string) error {
+	ctx := context.Background()
+	if replicas, err := e.schemaReader.ShardReplicas(class, shard); err != nil {
+		return fmt.Errorf("error reading replicas for collection %s shard %s: %w", class, shard, err)
+	} else if slices.Contains(replicas, targetNode) {
+		return fmt.Errorf("replica %s exists for collection %s shard %s", targetNode, class, shard)
+	}
+	return e.migrator.DropShard(ctx, class, shard)
+}
+
+func (e *executor) LoadShard(class string, shard string) {
+	ctx := context.Background()
+	if err := e.migrator.LoadShard(ctx, class, shard); err != nil {
+		e.logger.WithFields(logrus.Fields{
+			"action": "load_shard",
+			"class":  class,
+			"shard":  shard,
+		}).WithError(err).Warn("migrator")
+	}
+}
+
+func (e *executor) ShutdownShard(class string, shard string) {
+	ctx := context.Background()
+	if err := e.migrator.ShutdownShard(ctx, class, shard); err != nil {
+		e.logger.WithFields(logrus.Fields{
+			"action": "shutdown_shard",
+			"class":  class,
+			"shard":  shard,
+		}).WithError(err).Warn("migrator")
+	}
+}
+
+func (e *executor) DropShard(class string, shard string) {
+	ctx := context.Background()
+	if err := e.migrator.DropShard(ctx, class, shard); err != nil {
+		e.logger.WithFields(logrus.Fields{
+			"action": "drop_shard",
+			"class":  class,
+			"shard":  shard,
+		}).WithError(err).Warn("migrator")
+	}
+}
+
+// RestoreClassDir restores classes on the filesystem directly from the temporary class backup stored on disk.
+// This function is invoked by the Raft store when a restoration request is sent by the backup coordinator.
+func (e *executor) RestoreClassDir(class string) error {
+	return e.restoreClassDir(class)
+}
+
+func (e *executor) UpdateClass(req api.UpdateClassRequest) error {
+	className := req.Class.Class
+	ctx := context.Background()
+
+	if cfg, ok := req.Class.VectorIndexConfig.(schemaConfig.VectorIndexConfig); ok {
+		if err := e.migrator.UpdateVectorIndexConfig(ctx, className, cfg); err != nil {
+			return fmt.Errorf("vector index config update: %w", err)
+		}
+	}
+
+	if cfgs := asVectorIndexConfigs(req.Class); cfgs != nil {
+		if err := e.migrator.UpdateVectorIndexConfigs(ctx, className, cfgs); err != nil {
+			return fmt.Errorf("vector index configs update: %w", err)
+		}
+	}
+
+	if err := e.migrator.UpdateInvertedIndexConfig(ctx, className,
+		req.Class.InvertedIndexConfig); err != nil {
+		return fmt.Errorf("inverted index config: %w", err)
+	}
+
+	if err := e.migrator.UpdateReplicationConfig(ctx, className, req.Class.ReplicationConfig); err != nil {
+		return fmt.Errorf("update replication config: %w", err)
+	}
+
+	return nil
+}
+
+func (e *executor) UpdateIndex(req api.UpdateClassRequest) error {
+	ctx := context.Background()
+	if err := e.migrator.UpdateIndex(ctx, req.Class, req.State); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (e *executor) DeleteClass(cls string, hasFrozen bool) error {
+	ctx := context.Background()
+	if err := e.migrator.DropClass(ctx, cls, hasFrozen); err != nil {
+		e.logger.WithFields(logrus.Fields{
+			"action": "delete_class",
+			"class":  cls,
+		}).WithError(err).Errorf("migrator")
+	}
+
+	e.logger.WithFields(logrus.Fields{
+		"action": "delete_class",
+		"class":  cls,
+	}).Debug("deleting class")
+
+	return nil
+}
+
+func (e *executor) AddProperty(className string, req api.AddPropertyRequest) error {
+	ctx := context.Background()
+	if err := e.migrator.AddProperty(ctx, className, req.Properties...); err != nil {
+		return err
+	}
+
+	e.logger.WithFields(logrus.Fields{
+		"action": "add_property",
+		"class":  className,
+	}).Debug("adding property")
+	return nil
+}
+
+func (e *executor) AddTenants(class string, req *api.AddTenantsRequest) error {
+	if len(req.Tenants) == 0 {
+		return nil
+	}
+	updates := make([]*CreateTenantPayload, len(req.Tenants))
+	for i, p := range req.Tenants {
+		updates[i] = &CreateTenantPayload{
+			Name:   p.Name,
+			Status: p.Status,
+		}
+	}
+	cls := e.schemaReader.ReadOnlyClass(class)
+	if cls == nil {
+		return fmt.Errorf("class %q: %w", class, ErrNotFound)
+	}
+	ctx := context.Background()
+	if err := e.migrator.NewTenants(ctx, cls, updates); err != nil {
+		return fmt.Errorf("migrator.new_tenants: %w", err)
+	}
+	return nil
+}
+
+func (e *executor) UpdateTenants(class string, req *api.UpdateTenantsRequest) error {
+	ctx := context.Background()
+	cls := e.schemaReader.ReadOnlyClass(class)
+	if cls == nil {
+		return fmt.Errorf("class %q: %w", class, ErrNotFound)
+	}
+
+	updates := make([]*UpdateTenantPayload, 0, len(req.Tenants))
+	for _, tu := range req.Tenants {
+		updates = append(updates, &UpdateTenantPayload{
+			Name:   tu.Name,
+			Status: tu.Status,
+		})
+	}
+
+	if err := e.migrator.UpdateTenants(ctx, cls, updates, req.ImplicitUpdateRequest); err != nil {
+		e.logger.WithFields(logrus.Fields{
+			"action": "update_tenants",
+			"class":  class,
+		}).WithError(err).Error("error updating tenants")
+		return err
+	}
+	return nil
+}
+
+func (e *executor) UpdateTenantsProcess(class string, req *api.TenantProcessRequest) error {
+	ctx := context.Background()
+	cls := e.schemaReader.ReadOnlyClass(class)
+	if cls == nil {
+		return fmt.Errorf("class %q: %w", class, ErrNotFound)
+	}
+	// no error here because that means the process shouldn't be applied to db
+	if req.TenantsProcesses == nil {
+		return nil
+	}
+
+	updates := []*UpdateTenantPayload{}
+	for idx := range req.TenantsProcesses {
+		if req.TenantsProcesses[idx] == nil || req.TenantsProcesses[idx].Tenant == nil {
+			continue
+		}
+		updates = append(updates, &UpdateTenantPayload{
+			Name:   req.TenantsProcesses[idx].Tenant.Name,
+			Status: req.TenantsProcesses[idx].Tenant.Status,
+		})
+	}
+
+	if err := e.migrator.UpdateTenants(ctx, cls, updates, false); err != nil {
+		e.logger.WithFields(logrus.Fields{
+			"action":     "update_tenants_process",
+			"sub-action": "update_tenants",
+			"class":      class,
+		}).WithError(err).Error("error updating tenants")
+		return err
+	}
+	return nil
+}
+
+func (e *executor) DeleteTenants(class string, tenants []*models.Tenant) error {
+	ctx := context.Background()
+	if err := e.migrator.DeleteTenants(ctx, class, tenants); err != nil {
+		e.logger.WithFields(logrus.Fields{
+			"action": "delete_tenants",
+			"class":  class,
+		}).WithError(err).Error("error deleting tenants")
+	}
+
+	return nil
+}
+
+func (e *executor) UpdateShardStatus(req *api.UpdateShardStatusRequest) error {
+	ctx := context.Background()
+	return e.migrator.UpdateShardStatus(ctx, req.Class, req.Shard, req.Status, req.SchemaVersion)
+}
+
+func (e *executor) GetShardsStatus(class, tenant string) (models.ShardStatusList, error) {
+	ctx := context.Background()
+	shardsStatus, err := e.migrator.GetShardsStatus(ctx, class, tenant)
+	if err != nil {
+		return nil, err
+	}
+
+	resp := models.ShardStatusList{}
+
+	for name, status := range shardsStatus {
+		resp = append(resp, &models.ShardStatusGetResponse{
+			Name:   name,
+			Status: status,
+		})
+	}
+
+	return resp, nil
+}
+
+func (e *executor) TriggerSchemaUpdateCallbacks() {
+	e.callbacksLock.RLock()
+	defer e.callbacksLock.RUnlock()
+
+	s := e.schemaReader.ReadOnlySchema()
+	body := schema.SchemaWithAliases{
+		Schema:  schema.Schema{Objects: &s},
+		Aliases: e.schemaReader.Aliases(),
+	}
+	for _, cb := range e.callbacks {
+		cb(body)
+	}
+}
+
+// RegisterSchemaUpdateCallback allows other usecases to register a primitive
+// type update callback. The callbacks will be called any time we persist a
+// schema update
+func (e *executor) RegisterSchemaUpdateCallback(callback func(updatedSchema schema.SchemaWithAliases)) {
+	e.callbacksLock.Lock()
+	defer e.callbacksLock.Unlock()
+
+	e.callbacks = append(e.callbacks, callback)
+}

platform/dbops/binaries/weaviate-src/usecases/schema/executor_test.go

@@ -0,0 +1,218 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+
+	"github.com/weaviate/weaviate/cluster/proto/api"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/vectorindex/flat"
+)
+
+var (
+	Anything = mock.Anything
+	ErrAny   = errors.New("any error")
+)
+
+func newMockExecutor(m *fakeMigrator, s *fakeSchemaManager) *executor {
+	logger, _ := test.NewNullLogger()
+	x := NewExecutor(m, s, logger, func(string) error { return nil })
+	x.RegisterSchemaUpdateCallback(func(updatedSchema schema.SchemaWithAliases) {})
+	return x
+}
+
+func TestExecutor(t *testing.T) {
+	ctx := context.Background()
+	store := &fakeSchemaManager{}
+	cls := &models.Class{
+		Class:             "A",
+		VectorIndexConfig: flat.NewDefaultUserConfig(),
+		ReplicationConfig: &models.ReplicationConfig{
+			Factor: 1,
+		},
+	}
+	store.On("ReadOnlySchema").Return(models.Schema{})
+	store.On("ReadOnlyClass", "A", mock.Anything).Return(cls)
+
+	t.Run("OpenClose", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		migrator.On("WaitForStartup", ctx).Return(nil)
+		migrator.On("Shutdown", ctx).Return(nil)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.Open(ctx))
+		assert.Nil(t, x.Close(ctx))
+	})
+
+	t.Run("AddClass", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		migrator.On("AddClass", Anything, Anything, Anything).Return(nil)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.AddClass(api.AddClassRequest{}))
+	})
+	t.Run("AddClassWithError", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		migrator.On("AddClass", Anything, Anything, Anything).Return(ErrAny)
+		x := newMockExecutor(migrator, store)
+		assert.ErrorIs(t, x.AddClass(api.AddClassRequest{}), ErrAny)
+	})
+
+	t.Run("DropClass", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		migrator.On("DropClass", Anything, Anything).Return(nil)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.DeleteClass("A", false))
+	})
+	t.Run("DropClassWithError", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		migrator.On("DropClass", Anything, Anything).Return(ErrAny)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.DeleteClass("A", false))
+	})
+
+	t.Run("UpdateIndex", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		migrator.On("UpdateVectorIndexConfig", Anything, "A", Anything).Return(nil)
+		migrator.On("UpdateInvertedIndexConfig", Anything, "A", Anything).Return(nil)
+		migrator.On("UpdateReplicationConfig", context.Background(), "A", false).Return(nil)
+
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.UpdateClass(api.UpdateClassRequest{Class: cls}))
+	})
+
+	t.Run("UpdateVectorIndexConfig", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		migrator.On("UpdateVectorIndexConfig", Anything, "A", Anything).Return(ErrAny)
+		migrator.On("UpdateReplicationConfig", context.Background(), "A", false).Return(nil)
+
+		x := newMockExecutor(migrator, store)
+		assert.ErrorIs(t, x.UpdateClass(api.UpdateClassRequest{Class: cls}), ErrAny)
+	})
+	t.Run("UpdateInvertedIndexConfig", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		migrator.On("UpdateVectorIndexConfig", Anything, "A", Anything).Return(nil)
+		migrator.On("UpdateInvertedIndexConfig", Anything, "A", Anything).Return(ErrAny)
+		migrator.On("UpdateReplicationConfig", context.Background(), "A", false).Return(nil)
+
+		x := newMockExecutor(migrator, store)
+		assert.ErrorIs(t, x.UpdateClass(api.UpdateClassRequest{Class: cls}), ErrAny)
+	})
+
+	t.Run("AddProperty", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		req := api.AddPropertyRequest{Properties: []*models.Property{}}
+		migrator.On("AddProperty", Anything, "A", req.Properties).Return(nil)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.AddProperty("A", req))
+	})
+
+	tenants := []*api.Tenant{{Name: "T1"}, {Name: "T2"}}
+
+	t.Run("DeleteTenants", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		tenants := []*models.Tenant{}
+		migrator.On("DeleteTenants", Anything, "A", tenants).Return(nil)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.DeleteTenants("A", tenants))
+	})
+	t.Run("DeleteTenantsWithError", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		tenants := []*models.Tenant{}
+		migrator.On("DeleteTenants", Anything, "A", tenants).Return(ErrAny)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.DeleteTenants("A", tenants))
+	})
+
+	t.Run("UpdateTenants", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		req := &api.UpdateTenantsRequest{Tenants: tenants}
+		migrator.On("UpdateTenants", Anything, cls, Anything).Return(nil)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.UpdateTenants("A", req))
+	})
+
+	t.Run("UpdateTenantsClassNotFound", func(t *testing.T) {
+		store := &fakeSchemaManager{}
+		store.On("ReadOnlyClass", "A", mock.Anything).Return(nil)
+
+		req := &api.UpdateTenantsRequest{Tenants: tenants}
+		x := newMockExecutor(&fakeMigrator{}, store)
+		assert.ErrorIs(t, x.UpdateTenants("A", req), ErrNotFound)
+	})
+
+	t.Run("UpdateTenantsError", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		req := &api.UpdateTenantsRequest{Tenants: tenants}
+		migrator.On("UpdateTenants", Anything, cls, Anything).Return(ErrAny)
+		x := newMockExecutor(migrator, store)
+		assert.ErrorIs(t, x.UpdateTenants("A", req), ErrAny)
+	})
+
+	t.Run("AddTenants", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		req := &api.AddTenantsRequest{Tenants: tenants}
+		migrator.On("NewTenants", Anything, cls, Anything).Return(nil)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.AddTenants("A", req))
+	})
+	t.Run("AddTenantsEmpty", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		req := &api.AddTenantsRequest{Tenants: nil}
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.AddTenants("A", req))
+	})
+	t.Run("AddTenantsError", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		req := &api.AddTenantsRequest{Tenants: tenants}
+		migrator.On("NewTenants", Anything, cls, Anything).Return(ErrAny)
+		x := newMockExecutor(migrator, store)
+		assert.ErrorIs(t, x.AddTenants("A", req), ErrAny)
+	})
+	t.Run("AddTenantsClassNotFound", func(t *testing.T) {
+		store := &fakeSchemaManager{}
+		store.On("ReadOnlyClass", "A", mock.Anything).Return(nil)
+		req := &api.AddTenantsRequest{Tenants: tenants}
+		x := newMockExecutor(&fakeMigrator{}, store)
+		assert.ErrorIs(t, x.AddTenants("A", req), ErrNotFound)
+	})
+
+	t.Run("GetShardsStatus", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		status := map[string]string{"A": "B"}
+		migrator.On("GetShardsStatus", Anything, "A", "").Return(status, nil)
+		x := newMockExecutor(migrator, store)
+		_, err := x.GetShardsStatus("A", "")
+		assert.Nil(t, err)
+	})
+	t.Run("GetShardsStatusError", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		status := map[string]string{"A": "B"}
+		migrator.On("GetShardsStatus", Anything, "A", "").Return(status, ErrAny)
+		x := newMockExecutor(migrator, store)
+		_, err := x.GetShardsStatus("A", "")
+		assert.ErrorIs(t, err, ErrAny)
+	})
+	t.Run("UpdateShardStatus", func(t *testing.T) {
+		migrator := &fakeMigrator{}
+		req := &api.UpdateShardStatusRequest{Class: "A", Shard: "S", Status: "ST", SchemaVersion: 123}
+		migrator.On("UpdateShardStatus", Anything, "A", "S", "ST", uint64(123)).Return(nil)
+		x := newMockExecutor(migrator, store)
+		assert.Nil(t, x.UpdateShardStatus(req))
+	})
+}

platform/dbops/binaries/weaviate-src/usecases/schema/fakes_test.go

@@ -0,0 +1,349 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/stretchr/testify/mock"
+	command "github.com/weaviate/weaviate/cluster/proto/api"
+	clusterSchema "github.com/weaviate/weaviate/cluster/schema"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/versioned"
+	"github.com/weaviate/weaviate/usecases/fakes"
+	"github.com/weaviate/weaviate/usecases/sharding"
+)
+
+type fakeSchemaManager struct {
+	mock.Mock
+	countClassEqual bool
+}
+
+func (f *fakeSchemaManager) AddClass(_ context.Context, cls *models.Class, ss *sharding.State) (uint64, error) {
+	args := f.Called(cls, ss)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) RestoreClass(_ context.Context, cls *models.Class, ss *sharding.State) (uint64, error) {
+	args := f.Called(cls, ss)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) UpdateClass(_ context.Context, cls *models.Class, ss *sharding.State) (uint64, error) {
+	args := f.Called(cls, ss)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) DeleteClass(_ context.Context, name string) (uint64, error) {
+	args := f.Called(name)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) AddProperty(_ context.Context, class string, p ...*models.Property) (uint64, error) {
+	args := f.Called(class, p)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) UpdateShardStatus(c_ context.Context, class, shard, status string) (uint64, error) {
+	args := f.Called(class, shard, status)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) AddTenants(_ context.Context, class string, req *command.AddTenantsRequest) (uint64, error) {
+	args := f.Called(class, req)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) UpdateTenants(_ context.Context, class string, req *command.UpdateTenantsRequest) (uint64, error) {
+	args := f.Called(class, req)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) DeleteTenants(_ context.Context, class string, req *command.DeleteTenantsRequest) (uint64, error) {
+	args := f.Called(class, req)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) ResolveAlias(alias string) string {
+	return ""
+}
+
+func (f *fakeSchemaManager) GetAliasesForClass(class string) []*models.Alias {
+	return nil
+}
+
+func (f *fakeSchemaManager) Join(ctx context.Context, nodeID, raftAddr string, voter bool) error {
+	args := f.Called(ctx, nodeID, raftAddr, voter)
+	return args.Error(0)
+}
+
+func (f *fakeSchemaManager) Remove(ctx context.Context, nodeID string) error {
+	args := f.Called(ctx, nodeID)
+	return args.Error(0)
+}
+
+func (f *fakeSchemaManager) Stats() map[string]any {
+	return map[string]any{}
+}
+
+func (f *fakeSchemaManager) StoreSchemaV1() error {
+	return nil
+}
+
+func (f *fakeSchemaManager) ClassEqual(name string) string {
+	if f.countClassEqual {
+		args := f.Called(name)
+		return args.String(0)
+	}
+	return ""
+}
+
+func (f *fakeSchemaManager) MultiTenancy(class string) models.MultiTenancyConfig {
+	args := f.Called(class)
+	return args.Get(0).(models.MultiTenancyConfig)
+}
+
+func (f *fakeSchemaManager) MultiTenancyWithVersion(ctx context.Context, class string, version uint64) (models.MultiTenancyConfig, error) {
+	args := f.Called(ctx, class, version)
+	return args.Get(0).(models.MultiTenancyConfig), args.Error(1)
+}
+
+func (f *fakeSchemaManager) ClassInfo(class string) (ci clusterSchema.ClassInfo) {
+	args := f.Called(class)
+	return args.Get(0).(clusterSchema.ClassInfo)
+}
+
+func (f *fakeSchemaManager) StorageCandidates() []string {
+	return []string{"node-1"}
+}
+
+func (f *fakeSchemaManager) ClassInfoWithVersion(ctx context.Context, class string, version uint64) (clusterSchema.ClassInfo, error) {
+	args := f.Called(ctx, class, version)
+	return args.Get(0).(clusterSchema.ClassInfo), args.Error(1)
+}
+
+func (f *fakeSchemaManager) QuerySchema() (models.Schema, error) {
+	args := f.Called()
+	return args.Get(0).(models.Schema), args.Error(1)
+}
+
+func (f *fakeSchemaManager) QueryCollectionsCount() (int, error) {
+	args := f.Called()
+	return args.Get(0).(int), args.Error(1)
+}
+
+func (f *fakeSchemaManager) QueryReadOnlyClasses(classes ...string) (map[string]versioned.Class, error) {
+	args := f.Called(classes)
+
+	models := args.Get(0)
+	if models == nil {
+		return nil, args.Error(1)
+	}
+
+	return models.(map[string]versioned.Class), nil
+}
+
+func (f *fakeSchemaManager) QueryClassVersions(classes ...string) (map[string]uint64, error) {
+	args := f.Called(classes)
+
+	models := args.Get(0)
+	if models == nil {
+		return nil, args.Error(1)
+	}
+
+	return models.(map[string]uint64), nil
+}
+
+func (f *fakeSchemaManager) QueryTenants(class string, tenants []string) ([]*models.Tenant, uint64, error) {
+	args := f.Called(class, tenants)
+	return args.Get(0).([]*models.Tenant), 0, args.Error(2)
+}
+
+func (f *fakeSchemaManager) QueryShardOwner(class, shard string) (string, uint64, error) {
+	args := f.Called(class, shard)
+	return args.Get(0).(string), 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) QueryTenantsShards(class string, tenants ...string) (map[string]string, uint64, error) {
+	args := f.Called(class, tenants)
+	res := map[string]string{}
+	for idx := range tenants {
+		res[args.String(idx+1)] = ""
+	}
+	return res, 0, nil
+}
+
+func (f *fakeSchemaManager) QueryShardingState(class string) (*sharding.State, uint64, error) {
+	args := f.Called(class)
+	return args.Get(0).(*sharding.State), 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) ReadOnlyClass(class string) *models.Class {
+	args := f.Called(class)
+	model := args.Get(0)
+	if model == nil {
+		return nil
+	}
+	return model.(*models.Class)
+}
+
+func (f *fakeSchemaManager) ReadOnlyVersionedClass(class string) versioned.Class {
+	args := f.Called(class)
+	model := args.Get(0)
+	return model.(versioned.Class)
+}
+
+func (f *fakeSchemaManager) ReadOnlyClassWithVersion(ctx context.Context, class string, version uint64) (*models.Class, error) {
+	args := f.Called(ctx, class, version)
+	model := args.Get(0)
+	if model == nil {
+		return nil, args.Error(1)
+	}
+	return model.(*models.Class), args.Error(1)
+}
+
+func (f *fakeSchemaManager) ReadOnlySchema() models.Schema {
+	args := f.Called()
+	return args.Get(0).(models.Schema)
+}
+
+func (f *fakeSchemaManager) Aliases() map[string]string {
+	return nil
+}
+
+func (f *fakeSchemaManager) ShardReplicas(class, shard string) ([]string, error) {
+	args := f.Called(class, shard)
+	return args.Get(0).([]string), args.Error(1)
+}
+
+func (f *fakeSchemaManager) ShardReplicasWithVersion(ctx context.Context, class, shard string, version uint64) ([]string, error) {
+	args := f.Called(ctx, class, shard, version)
+	return args.Get(0).([]string), args.Error(1)
+}
+
+func (f *fakeSchemaManager) ShardFromUUID(class string, uuid []byte) string {
+	args := f.Called(class, uuid)
+	return args.String(0)
+}
+
+func (f *fakeSchemaManager) ShardFromUUIDWithVersion(ctx context.Context, class string, uuid []byte, version uint64) (string, error) {
+	args := f.Called(ctx, class, uuid, version)
+	return args.String(0), args.Error(1)
+}
+
+func (f *fakeSchemaManager) ShardOwner(class, shard string) (string, error) {
+	args := f.Called(class, shard)
+	return args.String(0), args.Error(1)
+}
+
+func (f *fakeSchemaManager) ShardOwnerWithVersion(ctx context.Context, class, shard string, version uint64) (string, error) {
+	args := f.Called(ctx, class, shard, version)
+	return args.String(0), args.Error(1)
+}
+
+func (f *fakeSchemaManager) TenantsShardsWithVersion(ctx context.Context, version uint64, class string, tenants ...string) (tenantShards map[string]string, err error) {
+	args := f.Called(ctx, version, class, tenants)
+	return map[string]string{args.String(0): args.String(1)}, args.Error(2)
+}
+
+func (f *fakeSchemaManager) Read(class string, reader func(*models.Class, *sharding.State) error) error {
+	args := f.Called(class, reader)
+	return args.Error(0)
+}
+
+func (f *fakeSchemaManager) Shards(class string) ([]string, error) {
+	args := f.Called(class)
+	return args.Get(0).([]string), args.Error(1)
+}
+
+func (f *fakeSchemaManager) LocalShards(class string) ([]string, error) {
+	args := f.Called(class)
+	return args.Get(0).([]string), args.Error(1)
+}
+
+func (f *fakeSchemaManager) GetShardsStatus(class, tenant string) (models.ShardStatusList, error) {
+	args := f.Called(class, tenant)
+	return args.Get(0).(models.ShardStatusList), args.Error(1)
+}
+
+func (f *fakeSchemaManager) WaitForUpdate(ctx context.Context, schemaVersion uint64) error {
+	return nil
+}
+
+func (f *fakeSchemaManager) CreateAlias(ctx context.Context, alias string, class *models.Class) (uint64, error) {
+	args := f.Called(ctx, alias, class)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) ReplaceAlias(ctx context.Context, alias *models.Alias, newClass *models.Class) (uint64, error) {
+	args := f.Called(ctx, alias, newClass)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) DeleteAlias(ctx context.Context, alias string) (uint64, error) {
+	args := f.Called(ctx, alias)
+	return 0, args.Error(0)
+}
+
+func (f *fakeSchemaManager) GetAlias(ctx context.Context, alias string) (*models.Alias, error) {
+	args := f.Called(ctx, alias)
+	return args.Get(0).(*models.Alias), args.Error(1)
+}
+
+func (f *fakeSchemaManager) GetAliases(ctx context.Context, alias string, class *models.Class) ([]*models.Alias, error) {
+	args := f.Called(ctx, alias, class)
+	return args.Get(0).([]*models.Alias), args.Error(1)
+}
+
+type fakeStore struct {
+	collections map[string]*models.Class
+	parser      Parser
+}
+
+func NewFakeStore() *fakeStore {
+	return &fakeStore{
+		collections: make(map[string]*models.Class),
+		parser:      *NewParser(fakes.NewFakeClusterState(), dummyParseVectorConfig, &fakeValidator{}, fakeModulesProvider{}, nil),
+	}
+}
+
+func (f *fakeStore) AddClass(cls *models.Class) {
+	f.collections[cls.Class] = cls
+}
+
+func (f *fakeStore) UpdateClass(cls *models.Class) error {
+	bytes, err := json.Marshal(cls)
+	if err != nil {
+		return fmt.Errorf("marshal request: %w", err)
+	}
+
+	cls = f.collections[cls.Class]
+	if cls == nil {
+		return ErrNotFound
+	}
+
+	cls2 := &models.Class{}
+	if err := json.Unmarshal(bytes, cls2); err != nil {
+		return fmt.Errorf("unmarshal: %w", err)
+	}
+
+	u, err := f.parser.ParseClassUpdate(cls, cls2)
+	if err != nil {
+		return fmt.Errorf("parse class update: %w", err)
+	}
+
+	cls.VectorIndexConfig = u.VectorIndexConfig
+	cls.InvertedIndexConfig = u.InvertedIndexConfig
+	return nil
+}

platform/dbops/binaries/weaviate-src/usecases/schema/get_class.go

@@ -0,0 +1,174 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/entities/versioned"
+	configRuntime "github.com/weaviate/weaviate/usecases/config/runtime"
+)
+
+type ClassGetter struct {
+	parser        *Parser
+	schemaReader  SchemaReader
+	schemaManager SchemaManager
+	logger        logrus.FieldLogger
+
+	collectionRetrievalStrategy *configRuntime.FeatureFlag[string]
+}
+
+func NewClassGetter(
+	schemaParser *Parser,
+	schemaManager SchemaManager,
+	schemaReader SchemaReader,
+	collectionRetrievalStrategyFF *configRuntime.FeatureFlag[string],
+	logger logrus.FieldLogger,
+) *ClassGetter {
+	return &ClassGetter{
+		parser:                      schemaParser,
+		schemaReader:                schemaReader,
+		schemaManager:               schemaManager,
+		logger:                      logger,
+		collectionRetrievalStrategy: collectionRetrievalStrategyFF,
+	}
+}
+
+func (cg *ClassGetter) getClasses(names []string) (map[string]versioned.Class, error) {
+	switch configRuntime.CollectionRetrievalStrategy(cg.collectionRetrievalStrategy.Get()) {
+	case configRuntime.LeaderOnly:
+		return cg.getClassesLeaderOnly(names)
+	case configRuntime.LeaderOnMismatch:
+		return cg.getClassesLeaderOnMismatch(names)
+	case configRuntime.LocalOnly:
+		return cg.getClassesLocalOnly(names)
+
+		// This can happen if the feature flag gets configured with an invalid strategy
+	default:
+		return cg.getClassesLeaderOnly(names)
+	}
+}
+
+func (cg *ClassGetter) getClassesLeaderOnly(names []string) (map[string]versioned.Class, error) {
+	vclasses, err := cg.schemaManager.QueryReadOnlyClasses(names...)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(vclasses) == 0 {
+		return nil, nil
+	}
+
+	for _, vclass := range vclasses {
+		if err := cg.parser.ParseClass(vclass.Class); err != nil {
+			// remove invalid classes
+			cg.logger.WithFields(logrus.Fields{
+				"class": vclass.Class.Class,
+				"error": err,
+			}).Warn("parsing class error")
+			delete(vclasses, vclass.Class.Class)
+			continue
+		}
+	}
+
+	return vclasses, nil
+}
+
+func (cg *ClassGetter) getClassesLocalOnly(names []string) (map[string]versioned.Class, error) {
+	vclasses := map[string]versioned.Class{}
+	for _, name := range names {
+		vc := cg.schemaReader.ReadOnlyVersionedClass(name)
+		if vc.Class == nil {
+			cg.logger.WithFields(logrus.Fields{
+				"class": name,
+			}).Debug("could not find class in local schema")
+			continue
+		}
+		vclasses[name] = vc
+	}
+
+	// Check if we have all the classes from the local schema
+	if len(vclasses) < len(names) {
+		missingClasses := []string{}
+		for _, name := range names {
+			if _, ok := vclasses[name]; !ok {
+				missingClasses = append(missingClasses, name)
+			}
+		}
+		cg.logger.WithFields(logrus.Fields{
+			"missing":    missingClasses,
+			"suggestion": "This node received a data request for a class that is not present on the local schema on the node. If the class was just updated in the schema and you want to be able to query it immediately consider changing the " + configRuntime.CollectionRetrievalStrategyEnvVariable + " config to \"" + configRuntime.LeaderOnly + "\".",
+		}).Warn("not all classes found locally")
+	}
+	return vclasses, nil
+}
+
+func (cg *ClassGetter) getClassesLeaderOnMismatch(names []string) (map[string]versioned.Class, error) {
+	classVersions, err := cg.schemaManager.QueryClassVersions(names...)
+	if err != nil {
+		return nil, err
+	}
+	versionedClassesToReturn := map[string]versioned.Class{}
+	versionedClassesToQueryFromLeader := []string{}
+	for _, name := range names {
+		localVclass := cg.schemaReader.ReadOnlyVersionedClass(name)
+		// First check if we have the class locally, if not make sure we'll query from leader
+		if localVclass.Class == nil {
+			versionedClassesToQueryFromLeader = append(versionedClassesToQueryFromLeader, name)
+			continue
+		}
+
+		// We have the class locally, compare the version from leader (if any) and add to query to leader if we have to refresh the version
+		leaderClassVersion, ok := classVersions[name]
+		// < leaderClassVersion instead of != because there is some chance that the local version
+		// could be ahead of the version returned by the leader if the response from the leader was
+		// delayed and i don't think it would be helpful to query the leader again in that case as
+		// it would likely return a version that is at least as large as the local version.
+		if !ok || localVclass.Version < leaderClassVersion {
+			versionedClassesToQueryFromLeader = append(versionedClassesToQueryFromLeader, name)
+			continue
+		}
+
+		// We can use the local class version has not changed
+		versionedClassesToReturn[name] = localVclass
+	}
+	if len(versionedClassesToQueryFromLeader) == 0 {
+		return versionedClassesToReturn, nil
+	}
+
+	versionedClassesFromLeader, err := cg.schemaManager.QueryReadOnlyClasses(versionedClassesToQueryFromLeader...)
+	if err != nil || len(versionedClassesFromLeader) == 0 {
+		cg.logger.WithFields(logrus.Fields{
+			"classes":    versionedClassesToQueryFromLeader,
+			"error":      err,
+			"suggestion": "This node received a data request for a class that is not present on the local schema on the node. If the class was just updated in the schema and you want to be able to query it immediately consider changing the " + configRuntime.CollectionRetrievalStrategyEnvVariable + " config to \"" + configRuntime.LeaderOnly + "\".",
+		}).Warn("unable to query classes from leader")
+		// return as many classes as we could get (to match previous behavior of the caller)
+		return versionedClassesToReturn, err
+	}
+
+	// We only need to ParseClass the ones we receive from the leader due to the Class model containing `interface{}` that are broken on
+	// marshall/unmarshall with gRPC.
+	for _, vclass := range versionedClassesFromLeader {
+		if err := cg.parser.ParseClass(vclass.Class); err != nil {
+			// silently remove invalid classes to match previous behavior
+			cg.logger.WithFields(logrus.Fields{
+				"class": vclass.Class.Class,
+				"error": err,
+			}).Warn("parsing class error")
+			delete(versionedClassesFromLeader, vclass.Class.Class)
+			continue
+		}
+		versionedClassesToReturn[vclass.Class.Class] = vclass
+	}
+
+	return versionedClassesToReturn, nil
+}

platform/dbops/binaries/weaviate-src/usecases/schema/get_class_test.go

@@ -0,0 +1,169 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/versioned"
+	configRuntime "github.com/weaviate/weaviate/usecases/config/runtime"
+	shardingCfg "github.com/weaviate/weaviate/usecases/sharding/config"
+)
+
+func TestClassGetterFromSchema(t *testing.T) {
+	testCases := []struct {
+		name          string
+		getFromSchema []string
+		strategy      configRuntime.CollectionRetrievalStrategy
+		schemaExpect  func(*fakeSchemaManager)
+	}{
+		{
+			name:          "Read only from leader",
+			getFromSchema: []string{"class1", "class2", "class3"},
+			strategy:      configRuntime.LeaderOnly,
+			schemaExpect: func(f *fakeSchemaManager) {
+				f.On("QueryReadOnlyClasses", []string{"class1", "class2", "class3"}).Return(map[string]versioned.Class{
+					"class1": {Version: 1, Class: &models.Class{Class: "class1", VectorIndexType: "hnsw", ShardingConfig: make(map[string]interface{})}},
+					"class2": {Version: 2, Class: &models.Class{Class: "class2", VectorIndexType: "hnsw", ShardingConfig: make(map[string]interface{})}},
+					"class3": {Version: 3, Class: &models.Class{Class: "class3", VectorIndexType: "hnsw", ShardingConfig: make(map[string]interface{})}},
+				}, nil)
+			},
+		},
+		{
+			name:          "Read only from local",
+			getFromSchema: []string{"class1", "class2", "class3"},
+			strategy:      configRuntime.LocalOnly,
+			schemaExpect: func(f *fakeSchemaManager) {
+				f.On("ReadOnlyVersionedClass", "class1").Return(versioned.Class{Version: 1, Class: &models.Class{Class: "class1", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class2").Return(versioned.Class{Version: 2, Class: &models.Class{Class: "class2", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class3").Return(versioned.Class{Version: 3, Class: &models.Class{Class: "class3", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+			},
+		},
+		{
+			name:          "Read all from leader if mismatch",
+			getFromSchema: []string{"class1", "class2", "class3"},
+			strategy:      configRuntime.LeaderOnMismatch,
+			schemaExpect: func(f *fakeSchemaManager) {
+				// First we will query the versions from the leader
+				f.On("QueryClassVersions", []string{"class1", "class2", "class3"}).Return(map[string]uint64{
+					"class1": 4,
+					"class2": 5,
+					"class3": 6,
+				}, nil)
+				// Then we check the local version
+				f.On("ReadOnlyVersionedClass", "class1").Return(versioned.Class{Version: 1, Class: &models.Class{Class: "class1", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class2").Return(versioned.Class{Version: 2, Class: &models.Class{Class: "class2", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class3").Return(versioned.Class{Version: 3, Class: &models.Class{Class: "class3", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				// Then we fetch what we need to update
+				f.On("QueryReadOnlyClasses", []string{"class1", "class2", "class3"}).Return(map[string]versioned.Class{
+					"class1": {Version: 1, Class: &models.Class{Class: "class1", VectorIndexType: "hnsw"}},
+					"class2": {Version: 2, Class: &models.Class{Class: "class2", VectorIndexType: "hnsw"}},
+					"class3": {Version: 3, Class: &models.Class{Class: "class3", VectorIndexType: "hnsw"}},
+				}, nil)
+			},
+		},
+		{
+			name:          "Read subset from leader if mismatch",
+			getFromSchema: []string{"class1", "class2", "class3"},
+			strategy:      configRuntime.LeaderOnMismatch,
+			schemaExpect: func(f *fakeSchemaManager) {
+				// First we will query the versions from the leader
+				f.On("QueryClassVersions", []string{"class1", "class2", "class3"}).Return(map[string]uint64{
+					"class1": 1,
+					"class2": 2,
+					"class3": 6,
+				}, nil)
+				// Then we check the local version
+				f.On("ReadOnlyVersionedClass", "class1").Return(versioned.Class{Version: 1, Class: &models.Class{Class: "class1", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class2").Return(versioned.Class{Version: 2, Class: &models.Class{Class: "class2", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class3").Return(versioned.Class{Version: 3, Class: &models.Class{Class: "class3", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				// Then we fetch what we need to update
+				f.On("QueryReadOnlyClasses", []string{"class3"}).Return(map[string]versioned.Class{
+					"class3": {Version: 6, Class: &models.Class{Class: "class3", VectorIndexType: "hnsw"}},
+				}, nil)
+			},
+		},
+		{
+			name:          "Read from leader local equal",
+			getFromSchema: []string{"class1", "class2", "class3"},
+			strategy:      configRuntime.LeaderOnMismatch,
+			schemaExpect: func(f *fakeSchemaManager) {
+				// First we will query the versions from the leader
+				f.On("QueryClassVersions", []string{"class1", "class2", "class3"}).Return(map[string]uint64{
+					"class1": 1,
+					"class2": 2,
+					"class3": 3,
+				}, nil)
+				f.On("ReadOnlyVersionedClass", "class1").Return(versioned.Class{Version: 1, Class: &models.Class{Class: "class1", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class2").Return(versioned.Class{Version: 2, Class: &models.Class{Class: "class2", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class3").Return(versioned.Class{Version: 3, Class: &models.Class{Class: "class3", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+			},
+		},
+		{
+			name:          "Read from leader local ahead",
+			getFromSchema: []string{"class1", "class2", "class3"},
+			strategy:      configRuntime.LeaderOnMismatch,
+			schemaExpect: func(f *fakeSchemaManager) {
+				// First we will query the versions from the leader
+				f.On("QueryClassVersions", []string{"class1", "class2", "class3"}).Return(map[string]uint64{
+					"class1": 1,
+					"class2": 2,
+					"class3": 3,
+				}, nil)
+				// Here we assume a delay between the leader returning the version and a change, so local > leader
+				f.On("ReadOnlyVersionedClass", "class1").Return(versioned.Class{Version: 4, Class: &models.Class{Class: "class1", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class2").Return(versioned.Class{Version: 5, Class: &models.Class{Class: "class2", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+				f.On("ReadOnlyVersionedClass", "class3").Return(versioned.Class{Version: 6, Class: &models.Class{Class: "class3", VectorIndexType: "hnsw", ShardingConfig: shardingCfg.Config{}}})
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		testCase := testCase
+		t.Run(testCase.name, func(t *testing.T) {
+			// Configure test setup
+			handler, fakeSchema := newTestHandler(t, &fakeDB{})
+			log, _ := test.NewNullLogger()
+			classGetter := NewClassGetter(
+				&handler.parser,
+				fakeSchema,
+				fakeSchema,
+				configRuntime.NewFeatureFlag(
+					"fake-key",
+					string(testCase.strategy),
+					nil,
+					"",
+					log,
+				),
+				log,
+			)
+			require.NotNil(t, classGetter)
+
+			// Configure expectation
+			testCase.schemaExpect(fakeSchema)
+
+			// Get class and ensure we receive all classes as expected
+			classes, err := classGetter.getClasses(testCase.getFromSchema)
+			require.NoError(t, err)
+			require.Equal(t, len(testCase.getFromSchema), len(classes))
+			for _, c := range classes {
+				require.Contains(t, testCase.getFromSchema, c.Class.Class)
+			}
+
+			// Assert all the mock happened as expected
+			fakeSchema.AssertExpectations(t)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/schema/handler.go

@@ -0,0 +1,302 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	command "github.com/weaviate/weaviate/cluster/proto/api"
+	clusterSchema "github.com/weaviate/weaviate/cluster/schema"
+	entcfg "github.com/weaviate/weaviate/entities/config"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/modulecapabilities"
+	"github.com/weaviate/weaviate/entities/schema"
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/entities/versioned"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/filter"
+	"github.com/weaviate/weaviate/usecases/config"
+	"github.com/weaviate/weaviate/usecases/sharding"
+)
+
+var (
+	ErrNotFound           = errors.New("not found")
+	ErrUnexpectedMultiple = errors.New("unexpected multiple results")
+)
+
+// SchemaManager is responsible for consistent schema operations.
+// It allows reading and writing the schema while directly talking to the leader, no matter which node it is.
+// It also allows cluster related operations that can only be done on the leader (join/remove/stats/etc...)
+// For details about each endpoint see [github.com/weaviate/weaviate/cluster.Raft].
+// For local schema lookup where eventual consistency is acceptable, see [SchemaReader].
+type SchemaManager interface {
+	// Schema writes operation.
+	AddClass(ctx context.Context, cls *models.Class, ss *sharding.State) (uint64, error)
+	RestoreClass(ctx context.Context, cls *models.Class, ss *sharding.State) (uint64, error)
+	UpdateClass(ctx context.Context, cls *models.Class, ss *sharding.State) (uint64, error)
+	DeleteClass(ctx context.Context, name string) (uint64, error)
+	AddProperty(ctx context.Context, class string, p ...*models.Property) (uint64, error)
+	UpdateShardStatus(ctx context.Context, class, shard, status string) (uint64, error)
+	AddTenants(ctx context.Context, class string, req *command.AddTenantsRequest) (uint64, error)
+	UpdateTenants(ctx context.Context, class string, req *command.UpdateTenantsRequest) (uint64, error)
+	DeleteTenants(ctx context.Context, class string, req *command.DeleteTenantsRequest) (uint64, error)
+
+	// Cluster related operations
+	Join(_ context.Context, nodeID, raftAddr string, voter bool) error
+	Remove(_ context.Context, nodeID string) error
+	Stats() map[string]any
+	StorageCandidates() []string
+	StoreSchemaV1() error
+
+	// Strongly consistent schema read. These endpoints will emit a query to the leader to ensure that the data is read
+	// from an up to date schema.
+	QueryReadOnlyClasses(names ...string) (map[string]versioned.Class, error)
+	QuerySchema() (models.Schema, error)
+	QueryTenants(class string, tenants []string) ([]*models.Tenant, uint64, error)
+	QueryCollectionsCount() (int, error)
+	QueryShardOwner(class, shard string) (string, uint64, error)
+	QueryTenantsShards(class string, tenants ...string) (map[string]string, uint64, error)
+	QueryShardingState(class string) (*sharding.State, uint64, error)
+	QueryClassVersions(names ...string) (map[string]uint64, error)
+
+	// Aliases
+	CreateAlias(ctx context.Context, alias string, class *models.Class) (uint64, error)
+	ReplaceAlias(ctx context.Context, alias *models.Alias, newClass *models.Class) (uint64, error)
+	DeleteAlias(ctx context.Context, alias string) (uint64, error)
+	GetAliases(ctx context.Context, alias string, class *models.Class) ([]*models.Alias, error)
+	GetAlias(ctx context.Context, alias string) (*models.Alias, error)
+}
+
+// SchemaReader allows reading the local schema with or without using a schema version.
+type SchemaReader interface {
+	// WaitForUpdate ensures that the local schema has caught up to version.
+	WaitForUpdate(ctx context.Context, version uint64) error
+
+	// These schema reads function reads the metadata immediately present in the local schema and can be eventually
+	// consistent.
+	// For details about each endpoint see [github.com/weaviate/weaviate/cluster/schema.SchemaReader].
+	ClassEqual(name string) string
+	MultiTenancy(class string) models.MultiTenancyConfig
+	ClassInfo(class string) (ci clusterSchema.ClassInfo)
+	ReadOnlyClass(name string) *models.Class
+	ReadOnlyVersionedClass(name string) versioned.Class
+	ReadOnlySchema() models.Schema
+	Aliases() map[string]string
+	ShardReplicas(class, shard string) ([]string, error)
+	ShardFromUUID(class string, uuid []byte) string
+	ShardOwner(class, shard string) (string, error)
+	Read(class string, reader func(*models.Class, *sharding.State) error) error
+	Shards(class string) ([]string, error)
+	LocalShards(class string) ([]string, error)
+	GetShardsStatus(class, tenant string) (models.ShardStatusList, error)
+	ResolveAlias(alias string) string
+	GetAliasesForClass(class string) []*models.Alias
+
+	// These schema reads function (...WithVersion) return the metadata once the local schema has caught up to the
+	// version parameter. If version is 0 is behaves exactly the same as eventual consistent reads.
+	// For details about each endpoint see [github.com/weaviate/weaviate/cluster/schema.VersionedSchemaReader].
+	ClassInfoWithVersion(ctx context.Context, class string, version uint64) (clusterSchema.ClassInfo, error)
+	MultiTenancyWithVersion(ctx context.Context, class string, version uint64) (models.MultiTenancyConfig, error)
+	ReadOnlyClassWithVersion(ctx context.Context, class string, version uint64) (*models.Class, error)
+	ShardOwnerWithVersion(ctx context.Context, lass, shard string, version uint64) (string, error)
+	ShardFromUUIDWithVersion(ctx context.Context, class string, uuid []byte, version uint64) (string, error)
+	ShardReplicasWithVersion(ctx context.Context, class, shard string, version uint64) ([]string, error)
+	TenantsShardsWithVersion(ctx context.Context, version uint64, class string, tenants ...string) (map[string]string, error)
+}
+
+type validator interface {
+	ValidateVectorIndexConfigUpdate(old, updated schemaConfig.VectorIndexConfig) error
+	ValidateInvertedIndexConfigUpdate(old, updated *models.InvertedIndexConfig) error
+	ValidateVectorIndexConfigsUpdate(old, updated map[string]schemaConfig.VectorIndexConfig) error
+}
+
+// The handler manages API requests for manipulating class schemas.
+// This separation of responsibilities helps decouple these tasks
+// from the Manager class, which combines many unrelated functions.
+// By delegating these clear responsibilities to the handler, it maintains
+// a clean separation from the manager, enhancing code modularity and maintainability.
+type Handler struct {
+	schemaManager SchemaManager
+	schemaReader  SchemaReader
+
+	cloud modulecapabilities.OffloadCloud
+
+	validator validator
+
+	logger                  logrus.FieldLogger
+	Authorizer              authorization.Authorizer
+	schemaConfig            *config.SchemaHandlerConfig
+	config                  config.Config
+	vectorizerValidator     VectorizerValidator
+	moduleConfig            ModuleConfig
+	clusterState            clusterState
+	configParser            VectorConfigParser
+	invertedConfigValidator InvertedConfigValidator
+	parser                  Parser
+	classGetter             *ClassGetter
+
+	asyncIndexingEnabled bool
+}
+
+// NewHandler creates a new handler
+func NewHandler(
+	schemaReader SchemaReader,
+	schemaManager SchemaManager,
+	validator validator,
+	logger logrus.FieldLogger, authorizer authorization.Authorizer, schemaConfig *config.SchemaHandlerConfig,
+	config config.Config,
+	configParser VectorConfigParser, vectorizerValidator VectorizerValidator,
+	invertedConfigValidator InvertedConfigValidator,
+	moduleConfig ModuleConfig, clusterState clusterState,
+	cloud modulecapabilities.OffloadCloud,
+	parser Parser, classGetter *ClassGetter,
+) (Handler, error) {
+	handler := Handler{
+		config:                  config,
+		schemaConfig:            schemaConfig,
+		schemaReader:            schemaReader,
+		schemaManager:           schemaManager,
+		parser:                  parser,
+		validator:               validator,
+		logger:                  logger,
+		Authorizer:              authorizer,
+		configParser:            configParser,
+		vectorizerValidator:     vectorizerValidator,
+		invertedConfigValidator: invertedConfigValidator,
+		moduleConfig:            moduleConfig,
+		clusterState:            clusterState,
+		cloud:                   cloud,
+		classGetter:             classGetter,
+
+		asyncIndexingEnabled: entcfg.Enabled(os.Getenv("ASYNC_INDEXING")),
+	}
+	return handler, nil
+}
+
+// GetSchema retrieves a locally cached copy of the schema
+func (h *Handler) GetConsistentSchema(ctx context.Context, principal *models.Principal, consistency bool) (schema.Schema, error) {
+	var fullSchema schema.Schema
+	if !consistency {
+		fullSchema = h.getSchema()
+	} else {
+		consistentSchema, err := h.schemaManager.QuerySchema()
+		if err != nil {
+			return schema.Schema{}, fmt.Errorf("could not read schema with strong consistency: %w", err)
+		}
+		fullSchema = schema.Schema{
+			Objects: &consistentSchema,
+		}
+	}
+
+	filteredClasses := filter.New[*models.Class](h.Authorizer, h.config.Authorization.Rbac).Filter(
+		ctx,
+		h.logger,
+		principal,
+		fullSchema.Objects.Classes,
+		authorization.READ,
+		func(class *models.Class) string {
+			return authorization.CollectionsMetadata(class.Class)[0]
+		},
+	)
+
+	return schema.Schema{
+		Objects: &models.Schema{
+			Classes: filteredClasses,
+		},
+	}, nil
+}
+
+// GetSchemaSkipAuth can never be used as a response to a user request as it
+// could leak the schema to an unauthorized user, is intended to be used for
+// non-user triggered processes, such as regular updates / maintenance / etc
+func (h *Handler) GetSchemaSkipAuth() schema.Schema { return h.getSchema() }
+
+func (h *Handler) getSchema() schema.Schema {
+	s := h.schemaReader.ReadOnlySchema()
+	return schema.Schema{
+		Objects: &s,
+	}
+}
+
+func (h *Handler) Nodes() []string {
+	return h.clusterState.AllNames()
+}
+
+func (h *Handler) NodeName() string {
+	return h.clusterState.LocalName()
+}
+
+func (h *Handler) UpdateShardStatus(ctx context.Context,
+	principal *models.Principal, class, shard, status string,
+) (uint64, error) {
+	err := h.Authorizer.Authorize(ctx, principal, authorization.UPDATE, authorization.ShardsMetadata(class, shard)...)
+	if err != nil {
+		return 0, err
+	}
+
+	return h.schemaManager.UpdateShardStatus(ctx, class, shard, status)
+}
+
+func (h *Handler) ShardsStatus(ctx context.Context,
+	principal *models.Principal, class, shard string,
+) (models.ShardStatusList, error) {
+	err := h.Authorizer.Authorize(ctx, principal, authorization.READ, authorization.ShardsMetadata(class, shard)...)
+	if err != nil {
+		return nil, err
+	}
+
+	return h.schemaReader.GetShardsStatus(class, shard)
+}
+
+// JoinNode adds the given node to the cluster.
+// Node needs to reachable via memberlist/gossip.
+// If nodePort is an empty string, nodePort will be the default raft port.
+// If the node is not reachable using memberlist, an error is returned
+// If joining the node fails, an error is returned.
+func (h *Handler) JoinNode(ctx context.Context, node string, nodePort string, voter bool) error {
+	nodeAddr, ok := h.clusterState.NodeHostname(node)
+	if !ok {
+		return fmt.Errorf("could not resolve addr for node id %v", node)
+	}
+	nodeAddr = strings.Split(nodeAddr, ":")[0]
+
+	if nodePort == "" {
+		nodePort = fmt.Sprintf("%d", config.DefaultRaftPort)
+	}
+
+	if err := h.schemaManager.Join(ctx, node, nodeAddr+":"+nodePort, voter); err != nil {
+		return fmt.Errorf("node failed to join cluster: %w", err)
+	}
+	return nil
+}
+
+// RemoveNode removes the given node from the cluster.
+func (h *Handler) RemoveNode(ctx context.Context, node string) error {
+	if err := h.schemaManager.Remove(ctx, node); err != nil {
+		return fmt.Errorf("node failed to leave cluster: %w", err)
+	}
+	return nil
+}
+
+// Statistics is used to return a map of various internal stats. This should only be used for informative purposes or debugging.
+func (h *Handler) Statistics() map[string]any {
+	return h.schemaManager.Stats()
+}
+
+func (h *Handler) StoreSchemaV1() error {
+	return h.schemaManager.StoreSchemaV1()
+}

platform/dbops/binaries/weaviate-src/usecases/schema/handler_test.go

@@ -0,0 +1,403 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/usecases/config"
+	"github.com/weaviate/weaviate/usecases/config/runtime"
+)
+
+var schemaTests = []struct {
+	name string
+	fn   func(*testing.T, *Handler, *fakeSchemaManager)
+}{
+	{name: "AddObjectClass", fn: testAddObjectClass},
+	{name: "AddObjectClassWithExplicitVectorizer", fn: testAddObjectClassExplicitVectorizer},
+	{name: "AddObjectClassWithImplicitVectorizer", fn: testAddObjectClassImplicitVectorizer},
+	{name: "AddObjectClassWithWrongVectorizer", fn: testAddObjectClassWrongVectorizer},
+	{name: "AddObjectClassWithWrongIndexType", fn: testAddObjectClassWrongIndexType},
+	{name: "RemoveObjectClass", fn: testRemoveObjectClass},
+	{name: "CantAddSameClassTwice", fn: testCantAddSameClassTwice},
+	{name: "CantAddSameClassTwiceDifferentKind", fn: testCantAddSameClassTwiceDifferentKinds},
+	{name: "AddPropertyDuringCreation", fn: testAddPropertyDuringCreation},
+	{name: "AddPropertyWithTargetVectorConfig", fn: testAddPropertyWithTargetVectorConfig},
+	{name: "AddInvalidPropertyDuringCreation", fn: testAddInvalidPropertyDuringCreation},
+	{name: "AddInvalidPropertyWithEmptyDataTypeDuringCreation", fn: testAddInvalidPropertyWithEmptyDataTypeDuringCreation},
+	{name: "DropProperty", fn: testDropProperty},
+}
+
+func testAddObjectClass(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	class := &models.Class{
+		Class: "Car",
+		Properties: []*models.Property{{
+			DataType:     schema.DataTypeText.PropString(),
+			Tokenization: models.PropertyTokenizationWhitespace,
+			Name:         "dummy",
+		}},
+		Vectorizer:        "model1",
+		VectorIndexConfig: map[string]interface{}{},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	assert.Nil(t, err)
+}
+
+func testAddObjectClassExplicitVectorizer(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	class := &models.Class{
+		Vectorizer:      config.VectorizerModuleText2VecContextionary,
+		VectorIndexType: "hnsw",
+		Class:           "Car",
+		Properties: []*models.Property{{
+			DataType:     schema.DataTypeText.PropString(),
+			Tokenization: models.PropertyTokenizationWhitespace,
+			Name:         "dummy",
+		}},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	assert.Nil(t, err)
+}
+
+func testAddObjectClassImplicitVectorizer(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+	handler.config.DefaultVectorizerModule = config.VectorizerModuleText2VecContextionary
+	class := &models.Class{
+		Class: "Car",
+		Properties: []*models.Property{{
+			DataType:     schema.DataTypeText.PropString(),
+			Tokenization: models.PropertyTokenizationWhitespace,
+			Name:         "dummy",
+		}},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+
+	fakeSchemaManager.On("AddClass", mock.Anything, mock.Anything).Return(nil)
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	assert.Nil(t, err)
+}
+
+func testAddObjectClassWrongVectorizer(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	class := &models.Class{
+		Class:      "Car",
+		Vectorizer: "vectorizer-5000000",
+		Properties: []*models.Property{{
+			DataType:     schema.DataTypeText.PropString(),
+			Tokenization: models.PropertyTokenizationWhitespace,
+			Name:         "dummy",
+		}},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	assert.Error(t, err)
+}
+
+func testAddObjectClassWrongIndexType(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	class := &models.Class{
+		Class:           "Car",
+		VectorIndexType: "vector-index-2-million",
+		Properties: []*models.Property{{
+			DataType:     schema.DataTypeText.PropString(),
+			Tokenization: models.PropertyTokenizationWhitespace,
+			Name:         "dummy",
+		}},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	require.NotNil(t, err)
+	assert.Equal(t, "unrecognized or unsupported vectorIndexType \"vector-index-2-million\"", err.Error())
+}
+
+func testRemoveObjectClass(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	class := &models.Class{
+		Class:      "Car",
+		Vectorizer: "text2vec-contextionary",
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"vectorizeClassName": true,
+			},
+		},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	require.Nil(t, err)
+
+	// Now delete the class
+	fakeSchemaManager.On("DeleteClass", "Car").Return(nil)
+	err = handler.DeleteClass(context.Background(), nil, "Car")
+	assert.Nil(t, err)
+}
+
+func testCantAddSameClassTwice(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	reset := fakeSchemaManager.On("ReadOnlySchema").Return(models.Schema{})
+
+	class := &models.Class{
+		Class:      "Car",
+		Vectorizer: "text2vec-contextionary",
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"vectorizeClassName": true,
+			},
+		},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	assert.Nil(t, err)
+
+	// Reset schema to simulate the class has been added
+	reset.Unset()
+	class = &models.Class{
+		Class:      "Car",
+		Vectorizer: "text2vec-contextionary",
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"vectorizeClassName": true,
+			},
+		},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	fakeSchemaManager.ExpectedCalls = fakeSchemaManager.ExpectedCalls[:0]
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(ErrNotFound)
+
+	// Add it again
+	_, _, err = handler.AddClass(context.Background(), nil, class)
+	assert.NotNil(t, err)
+}
+
+func testCantAddSameClassTwiceDifferentKinds(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+	ctx := context.Background()
+	class := &models.Class{
+		Class:      "Car",
+		Vectorizer: "text2vec-contextionary",
+		ModuleConfig: map[string]interface{}{
+			"text2vec-contextionary": map[string]interface{}{
+				"vectorizeClassName": true,
+			},
+		},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	_, _, err := handler.AddClass(ctx, nil, class)
+	assert.Nil(t, err)
+
+	class.ModuleConfig = map[string]interface{}{
+		"my-module1": map[string]interface{}{
+			"my-setting": "some-value",
+		},
+	}
+
+	// Add it again, but with a different kind.
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	_, _, err = handler.AddClass(context.Background(), nil, class)
+	assert.NotNil(t, err)
+}
+
+func testAddPropertyDuringCreation(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	vFalse := false
+	vTrue := true
+
+	properties := []*models.Property{
+		{
+			Name:         "color",
+			DataType:     schema.DataTypeText.PropString(),
+			Tokenization: models.PropertyTokenizationWhitespace,
+		},
+		{
+			Name:            "colorRaw1",
+			DataType:        schema.DataTypeText.PropString(),
+			Tokenization:    models.PropertyTokenizationWhitespace,
+			IndexFilterable: &vFalse,
+			IndexSearchable: &vFalse,
+		},
+		{
+			Name:            "colorRaw2",
+			DataType:        schema.DataTypeText.PropString(),
+			Tokenization:    models.PropertyTokenizationWhitespace,
+			IndexFilterable: &vTrue,
+			IndexSearchable: &vFalse,
+		},
+		{
+			Name:            "colorRaw3",
+			DataType:        schema.DataTypeText.PropString(),
+			Tokenization:    models.PropertyTokenizationWhitespace,
+			IndexFilterable: &vFalse,
+			IndexSearchable: &vTrue,
+		},
+		{
+			Name:            "colorRaw4",
+			DataType:        schema.DataTypeText.PropString(),
+			Tokenization:    models.PropertyTokenizationWhitespace,
+			IndexFilterable: &vTrue,
+			IndexSearchable: &vTrue,
+		},
+		{
+			Name:         "content",
+			DataType:     schema.DataTypeText.PropString(),
+			Tokenization: models.PropertyTokenizationWhitespace,
+		},
+		{
+			Name:         "allDefault",
+			DataType:     schema.DataTypeText.PropString(),
+			Tokenization: models.PropertyTokenizationWhitespace,
+		},
+	}
+
+	class := &models.Class{
+		Class:             "Car",
+		Properties:        properties,
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	assert.Nil(t, err)
+}
+
+func testAddPropertyWithTargetVectorConfig(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	class := &models.Class{
+		Class: "Car",
+		Properties: []*models.Property{
+			{
+				Name:         "color",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+				ModuleConfig: map[string]interface{}{
+					"text2vec-contextionary": map[string]interface{}{
+						"vectorizePropertyName": true,
+					},
+				},
+			},
+		},
+		VectorConfig: map[string]models.VectorConfig{
+			"vec1": {
+				Vectorizer:      map[string]interface{}{"text2vec-contextionary": map[string]interface{}{}},
+				VectorIndexType: "flat",
+			},
+		},
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	require.NoError(t, err)
+}
+
+func testAddInvalidPropertyDuringCreation(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	properties := []*models.Property{
+		{Name: "color", DataType: []string{"blurp"}},
+	}
+
+	_, _, err := handler.AddClass(context.Background(), nil, &models.Class{
+		Class:             "Car",
+		Properties:        properties,
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	})
+	assert.NotNil(t, err)
+}
+
+func testAddInvalidPropertyWithEmptyDataTypeDuringCreation(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	t.Parallel()
+
+	properties := []*models.Property{
+		{Name: "color", DataType: []string{""}},
+	}
+
+	_, _, err := handler.AddClass(context.Background(), nil, &models.Class{
+		Class:             "Car",
+		Properties:        properties,
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	})
+	assert.NotNil(t, err)
+}
+
+func testDropProperty(t *testing.T, handler *Handler, fakeSchemaManager *fakeSchemaManager) {
+	// TODO: https://github.com/weaviate/weaviate/issues/973
+	// Remove skip
+
+	t.Skip()
+
+	t.Parallel()
+
+	fakeSchemaManager.On("ReadOnlySchema").Return(models.Schema{})
+
+	properties := []*models.Property{
+		{Name: "color", DataType: schema.DataTypeText.PropString(), Tokenization: models.PropertyTokenizationWhitespace},
+	}
+	class := &models.Class{
+		Class:             "Car",
+		Properties:        properties,
+		ReplicationConfig: &models.ReplicationConfig{Factor: 1},
+	}
+	fakeSchemaManager.On("QueryCollectionsCount").Return(0, nil)
+	fakeSchemaManager.On("AddClass", class, mock.Anything).Return(nil)
+	_, _, err := handler.AddClass(context.Background(), nil, class)
+	assert.Nil(t, err)
+
+	// Now drop the property
+	handler.DeleteClassProperty(context.Background(), nil, "Car", "color")
+	// TODO: add the mock necessary to verify that the property is deleted
+}
+
+// This grant parent test setups up the temporary directory needed for the tests.
+func TestSchema(t *testing.T) {
+	t.Run("TestSchema", func(t *testing.T) {
+		for _, testCase := range schemaTests {
+			// Run each test independently with their own handler
+			t.Run(testCase.name, func(t *testing.T) {
+				handler, fakeSchemaManager := newTestHandler(t, &fakeDB{})
+				handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+				defer fakeSchemaManager.AssertExpectations(t)
+				testCase.fn(t, handler, fakeSchemaManager)
+			})
+		}
+	})
+}

platform/dbops/binaries/weaviate-src/usecases/schema/helpers_test.go

@@ -0,0 +1,391 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	command "github.com/weaviate/weaviate/cluster/proto/api"
+	clusterSchema "github.com/weaviate/weaviate/cluster/schema"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/modulecapabilities"
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/entities/vectorindex/common"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/mocks"
+	"github.com/weaviate/weaviate/usecases/config"
+	"github.com/weaviate/weaviate/usecases/config/runtime"
+	"github.com/weaviate/weaviate/usecases/fakes"
+	"github.com/weaviate/weaviate/usecases/sharding"
+)
+
+func newTestHandler(t *testing.T, db clusterSchema.Indexer) (*Handler, *fakeSchemaManager) {
+	schemaManager := &fakeSchemaManager{}
+	logger, _ := test.NewNullLogger()
+	vectorizerValidator := &fakeVectorizerValidator{
+		valid: []string{"text2vec-contextionary", "model1", "model2"},
+	}
+	cfg := config.Config{
+		DefaultVectorizerModule:     config.VectorizerModuleNone,
+		DefaultVectorDistanceMetric: "cosine",
+	}
+	fakeClusterState := fakes.NewFakeClusterState()
+	fakeValidator := &fakeValidator{}
+	schemaParser := NewParser(fakeClusterState, dummyParseVectorConfig, fakeValidator, fakeModulesProvider{}, nil)
+	handler, err := NewHandler(
+		schemaManager, schemaManager, fakeValidator, logger, mocks.NewMockAuthorizer(),
+		&cfg.SchemaHandlerConfig, cfg, dummyParseVectorConfig, vectorizerValidator, dummyValidateInvertedConfig,
+		&fakeModuleConfig{}, fakeClusterState, nil, *schemaParser, nil)
+	require.NoError(t, err)
+	handler.schemaConfig.MaximumAllowedCollectionsCount = runtime.NewDynamicValue(-1)
+	return &handler, schemaManager
+}
+
+func newTestHandlerWithCustomAuthorizer(t *testing.T, db clusterSchema.Indexer, authorizer authorization.Authorizer) (*Handler, *fakeSchemaManager) {
+	cfg := config.Config{}
+	metaHandler := &fakeSchemaManager{}
+	logger, _ := test.NewNullLogger()
+	vectorizerValidator := &fakeVectorizerValidator{
+		valid: []string{
+			"model1", "model2",
+		},
+	}
+	fakeClusterState := fakes.NewFakeClusterState()
+	fakeValidator := &fakeValidator{}
+	schemaParser := NewParser(fakeClusterState, dummyParseVectorConfig, fakeValidator, nil, nil)
+	handler, err := NewHandler(
+		metaHandler, metaHandler, fakeValidator, logger, authorizer,
+		&cfg.SchemaHandlerConfig, cfg, dummyParseVectorConfig, vectorizerValidator, dummyValidateInvertedConfig,
+		&fakeModuleConfig{}, fakeClusterState, nil, *schemaParser, nil)
+	require.Nil(t, err)
+	return &handler, metaHandler
+}
+
+type fakeDB struct {
+	mock.Mock
+}
+
+func (f *fakeDB) Open(context.Context) error {
+	return nil
+}
+
+func (f *fakeDB) Close(context.Context) error {
+	return nil
+}
+
+func (f *fakeDB) AddClass(cmd command.AddClassRequest) error {
+	return nil
+}
+
+func (f *fakeDB) RestoreClassDir(class string) error {
+	return nil
+}
+
+func (f *fakeDB) AddReplicaToShard(class string, shard string, targetNode string) error {
+	return nil
+}
+
+func (f *fakeDB) DeleteReplicaFromShard(class string, shard string, targetNode string) error {
+	return nil
+}
+
+func (f *fakeDB) LoadShard(class string, shard string) {
+}
+
+func (f *fakeDB) DropShard(class string, shard string) {
+}
+
+func (f *fakeDB) ShutdownShard(class string, shard string) {
+}
+
+func (f *fakeDB) UpdateClass(cmd command.UpdateClassRequest) error {
+	return nil
+}
+
+func (f *fakeDB) UpdateIndex(cmd command.UpdateClassRequest) error {
+	return nil
+}
+
+func (f *fakeDB) ReloadLocalDB(ctx context.Context, all []command.UpdateClassRequest) error {
+	return nil
+}
+
+func (f *fakeDB) DeleteClass(class string, hasFrozen bool) error {
+	return nil
+}
+
+func (f *fakeDB) AddProperty(prop string, cmd command.AddPropertyRequest) error {
+	return nil
+}
+
+func (f *fakeDB) AddTenants(class string, cmd *command.AddTenantsRequest) error {
+	return nil
+}
+
+func (f *fakeDB) UpdateTenants(class string, cmd *command.UpdateTenantsRequest) error {
+	return nil
+}
+
+func (f *fakeDB) UpdateTenantsProcess(class string, req *command.TenantProcessRequest) error {
+	return nil
+}
+
+func (f *fakeDB) DeleteTenants(class string, tenants []*models.Tenant) error {
+	return nil
+}
+
+func (f *fakeDB) UpdateShardStatus(cmd *command.UpdateShardStatusRequest) error {
+	return nil
+}
+
+func (f *fakeDB) GetShardsStatus(class, tenant string) (models.ShardStatusList, error) {
+	args := f.Called(class, tenant)
+	return args.Get(0).(models.ShardStatusList), nil
+}
+
+func (f *fakeDB) TriggerSchemaUpdateCallbacks() {
+	f.Called()
+}
+
+type fakeValidator struct{}
+
+func (f fakeValidator) ValidateVectorIndexConfigUpdate(
+	old, updated schemaConfig.VectorIndexConfig,
+) error {
+	return nil
+}
+
+func (f fakeValidator) ValidateInvertedIndexConfigUpdate(
+	old, updated *models.InvertedIndexConfig,
+) error {
+	return nil
+}
+
+func (fakeValidator) ValidateVectorIndexConfigsUpdate(old, updated map[string]schemaConfig.VectorIndexConfig,
+) error {
+	return nil
+}
+
+type fakeModuleConfig struct{}
+
+func (f *fakeModuleConfig) SetClassDefaults(class *models.Class) {
+	defaultConfig := map[string]interface{}{
+		"my-module1": map[string]interface{}{
+			"my-setting": "default-value",
+		},
+	}
+
+	asMap, ok := class.ModuleConfig.(map[string]interface{})
+	if !ok {
+		class.ModuleConfig = defaultConfig
+		return
+	}
+
+	module, ok := asMap["my-module1"]
+	if !ok {
+		class.ModuleConfig = defaultConfig
+		return
+	}
+
+	asMap, ok = module.(map[string]interface{})
+	if !ok {
+		class.ModuleConfig = defaultConfig
+		return
+	}
+
+	if _, ok := asMap["my-setting"]; !ok {
+		asMap["my-setting"] = "default-value"
+		defaultConfig["my-module1"] = asMap
+		class.ModuleConfig = defaultConfig
+	}
+}
+
+func (f *fakeModuleConfig) SetSinglePropertyDefaults(class *models.Class,
+	prop ...*models.Property,
+) {
+}
+
+func (f *fakeModuleConfig) ValidateClass(ctx context.Context, class *models.Class) error {
+	return nil
+}
+
+func (f *fakeModuleConfig) GetByName(name string) modulecapabilities.Module {
+	return nil
+}
+
+func (f *fakeModuleConfig) IsGenerative(moduleName string) bool {
+	return strings.Contains(moduleName, "generative")
+}
+
+func (f *fakeModuleConfig) IsReranker(moduleName string) bool {
+	return strings.Contains(moduleName, "reranker")
+}
+
+func (f *fakeModuleConfig) IsMultiVector(moduleName string) bool {
+	return strings.Contains(moduleName, "colbert")
+}
+
+type fakeVectorizerValidator struct {
+	valid []string
+}
+
+func (f *fakeVectorizerValidator) ValidateVectorizer(moduleName string) error {
+	for _, valid := range f.valid {
+		if moduleName == valid {
+			return nil
+		}
+	}
+
+	return fmt.Errorf("invalid vectorizer %q", moduleName)
+}
+
+type fakeVectorConfig struct {
+	raw interface{}
+}
+
+func (f fakeVectorConfig) IndexType() string {
+	return "fake"
+}
+
+func (f fakeVectorConfig) DistanceName() string {
+	return common.DistanceCosine
+}
+
+func (f fakeVectorConfig) IsMultiVector() bool {
+	return false
+}
+
+func dummyParseVectorConfig(in interface{}, vectorIndexType string, isMultiVector bool) (schemaConfig.VectorIndexConfig, error) {
+	return fakeVectorConfig{raw: in}, nil
+}
+
+func dummyValidateInvertedConfig(in *models.InvertedIndexConfig) error {
+	return nil
+}
+
+type fakeMigrator struct {
+	mock.Mock
+}
+
+func (f *fakeMigrator) GetShardsQueueSize(ctx context.Context, className, tenant string) (map[string]int64, error) {
+	return nil, nil
+}
+
+func (f *fakeMigrator) AddClass(ctx context.Context, cls *models.Class) error {
+	args := f.Called(ctx, cls)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) DropClass(ctx context.Context, className string, hasFrozen bool) error {
+	args := f.Called(ctx, className)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) AddProperty(ctx context.Context, className string, prop ...*models.Property) error {
+	args := f.Called(ctx, className, prop)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) LoadShard(ctx context.Context, class string, shard string) error {
+	args := f.Called(ctx, class, shard)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) DropShard(ctx context.Context, class string, shard string) error {
+	args := f.Called(ctx, class, shard)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) ShutdownShard(ctx context.Context, class string, shard string) error {
+	args := f.Called(ctx, class, shard)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) UpdateProperty(ctx context.Context, className string, propName string, newName *string) error {
+	return nil
+}
+
+func (f *fakeMigrator) NewTenants(ctx context.Context, class *models.Class, creates []*CreateTenantPayload) error {
+	args := f.Called(ctx, class, creates)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) UpdateTenants(ctx context.Context, class *models.Class, updates []*UpdateTenantPayload, implicitUpdate bool) error {
+	args := f.Called(ctx, class, updates)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) DeleteTenants(ctx context.Context, class string, tenants []*models.Tenant) error {
+	args := f.Called(ctx, class, tenants)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) GetShardsStatus(ctx context.Context, className, tenant string) (map[string]string, error) {
+	args := f.Called(ctx, className, tenant)
+	return args.Get(0).(map[string]string), args.Error(1)
+}
+
+func (f *fakeMigrator) UpdateShardStatus(ctx context.Context, className, shardName, targetStatus string, schemaVersion uint64) error {
+	args := f.Called(ctx, className, shardName, targetStatus, schemaVersion)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) UpdateVectorIndexConfig(ctx context.Context, className string, updated schemaConfig.VectorIndexConfig) error {
+	args := f.Called(ctx, className, updated)
+	return args.Error(0)
+}
+
+func (*fakeMigrator) ValidateVectorIndexConfigsUpdate(old, updated map[string]schemaConfig.VectorIndexConfig,
+) error {
+	return nil
+}
+
+func (*fakeMigrator) UpdateVectorIndexConfigs(ctx context.Context, className string,
+	updated map[string]schemaConfig.VectorIndexConfig,
+) error {
+	return nil
+}
+
+func (*fakeMigrator) ValidateInvertedIndexConfigUpdate(old, updated *models.InvertedIndexConfig) error {
+	return nil
+}
+
+func (f *fakeMigrator) UpdateInvertedIndexConfig(ctx context.Context, className string, updated *models.InvertedIndexConfig) error {
+	args := f.Called(ctx, className, updated)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) UpdateReplicationConfig(ctx context.Context, className string, cfg *models.ReplicationConfig) error {
+	return nil
+}
+
+func (f *fakeMigrator) WaitForStartup(ctx context.Context) error {
+	args := f.Called(ctx)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) Shutdown(ctx context.Context) error {
+	args := f.Called(ctx)
+	return args.Error(0)
+}
+
+func (f *fakeMigrator) UpdateIndex(ctx context.Context, class *models.Class, shardingState *sharding.State) error {
+	args := f.Called(class, shardingState)
+	return args.Error(0)
+}

platform/dbops/binaries/weaviate-src/usecases/schema/manager.go

@@ -0,0 +1,449 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+	"sync"
+
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/cluster/proto/api"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/modulecapabilities"
+	"github.com/weaviate/weaviate/entities/schema"
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/cluster"
+	"github.com/weaviate/weaviate/usecases/config"
+	configRuntime "github.com/weaviate/weaviate/usecases/config/runtime"
+	"github.com/weaviate/weaviate/usecases/sharding"
+)
+
+// Manager Manages schema changes at a use-case level, i.e. agnostic of
+// underlying databases or storage providers
+type Manager struct {
+	validator    validator
+	repo         SchemaStore
+	logger       logrus.FieldLogger
+	Authorizer   authorization.Authorizer
+	clusterState clusterState
+
+	sync.RWMutex
+	// The handler is responsible for well-defined tasks and should be decoupled from the manager.
+	// This enables API requests to be directed straight to the handler without the need to pass through the manager.
+	// For more context, refer to the handler's definition.
+	Handler
+
+	SchemaReader
+}
+
+type VectorConfigParser func(in interface{}, vectorIndexType string, isMultiVector bool) (schemaConfig.VectorIndexConfig, error)
+
+type InvertedConfigValidator func(in *models.InvertedIndexConfig) error
+
+type SchemaGetter interface {
+	GetSchemaSkipAuth() schema.Schema
+	ReadOnlyClass(string) *models.Class
+	ResolveAlias(string) string
+	GetAliasesForClass(class string) []*models.Alias
+	Nodes() []string
+	NodeName() string
+	ClusterHealthScore() int
+	ResolveParentNodes(string, string) (map[string]string, error)
+	Statistics() map[string]any
+
+	ShardOwner(class, shard string) (string, error)
+	TenantsShards(ctx context.Context, class string, tenants ...string) (map[string]string, error)
+	OptimisticTenantStatus(ctx context.Context, class string, tenants string) (map[string]string, error)
+	ShardFromUUID(class string, uuid []byte) string
+	ShardReplicas(class, shard string) ([]string, error)
+}
+
+type VectorizerValidator interface {
+	ValidateVectorizer(moduleName string) error
+}
+
+type ModuleConfig interface {
+	SetClassDefaults(class *models.Class)
+	SetSinglePropertyDefaults(class *models.Class, props ...*models.Property)
+	ValidateClass(ctx context.Context, class *models.Class) error
+	GetByName(name string) modulecapabilities.Module
+	IsGenerative(string) bool
+	IsReranker(string) bool
+	IsMultiVector(string) bool
+}
+
+// State is a cached copy of the schema that can also be saved into a remote
+// storage, as specified by Repo
+type State struct {
+	ObjectSchema  *models.Schema `json:"object"`
+	ShardingState map[string]*sharding.State
+}
+
+// NewState returns a new state with room for nClasses classes
+func NewState(nClasses int) State {
+	return State{
+		ObjectSchema: &models.Schema{
+			Classes: make([]*models.Class, 0, nClasses),
+		},
+		ShardingState: make(map[string]*sharding.State, nClasses),
+	}
+}
+
+func (s State) EqualEnough(other *State) bool {
+	// Same number of classes
+	eqClassLen := len(s.ObjectSchema.Classes) == len(other.ObjectSchema.Classes)
+	if !eqClassLen {
+		return false
+	}
+
+	// Same sharding state length
+	eqSSLen := len(s.ShardingState) == len(other.ShardingState)
+	if !eqSSLen {
+		return false
+	}
+
+	for cls, ss1ss := range s.ShardingState {
+		// Same sharding state keys
+		ss2ss, ok := other.ShardingState[cls]
+		if !ok {
+			return false
+		}
+
+		// Same number of physical shards
+		eqPhysLen := len(ss1ss.Physical) == len(ss2ss.Physical)
+		if !eqPhysLen {
+			return false
+		}
+
+		for shard, ss1phys := range ss1ss.Physical {
+			// Same physical shard contents and status
+			ss2phys, ok := ss2ss.Physical[shard]
+			if !ok {
+				return false
+			}
+			eqActivStat := ss1phys.ActivityStatus() == ss2phys.ActivityStatus()
+			if !eqActivStat {
+				return false
+			}
+		}
+	}
+
+	return true
+}
+
+// SchemaStore is responsible for persisting the schema
+// by providing support for both partial and complete schema updates
+// Deprecated: instead schema now is persistent via RAFT
+// see : usecase/schema/handler.go & cluster/store/store.go
+// Load and save are left to support backward compatibility
+type SchemaStore interface {
+	// Save saves the complete schema to the persistent storage
+	Save(ctx context.Context, schema State) error
+
+	// Load loads the complete schema from the persistent storage
+	Load(context.Context) (State, error)
+}
+
+// KeyValuePair is used to serialize shards updates
+type KeyValuePair struct {
+	Key   string
+	Value []byte
+}
+
+// ClassPayload is used to serialize class updates
+type ClassPayload struct {
+	Name          string
+	Metadata      []byte
+	ShardingState []byte
+	Shards        []KeyValuePair
+	ReplaceShards bool
+	Error         error
+}
+
+type clusterState interface {
+	cluster.NodeSelector
+	// Hostnames initializes a broadcast
+	Hostnames() []string
+
+	// AllNames initializes shard distribution across nodes
+	AllNames() []string
+	NodeCount() int
+
+	// ClusterHealthScore gets the whole cluster health, the lower number the better
+	ClusterHealthScore() int
+
+	SchemaSyncIgnored() bool
+	SkipSchemaRepair() bool
+}
+
+// NewManager creates a new manager
+func NewManager(validator validator,
+	schemaManager SchemaManager,
+	schemaReader SchemaReader,
+	repo SchemaStore,
+	logger logrus.FieldLogger, authorizer authorization.Authorizer,
+	schemaConfig *config.SchemaHandlerConfig,
+	config config.Config,
+	configParser VectorConfigParser, vectorizerValidator VectorizerValidator,
+	invertedConfigValidator InvertedConfigValidator,
+	moduleConfig ModuleConfig, clusterState clusterState,
+	cloud modulecapabilities.OffloadCloud,
+	parser Parser,
+	collectionRetrievalStrategyFF *configRuntime.FeatureFlag[string],
+) (*Manager, error) {
+	handler, err := NewHandler(
+		schemaReader,
+		schemaManager,
+		validator,
+		logger, authorizer,
+		schemaConfig,
+		config, configParser, vectorizerValidator, invertedConfigValidator,
+		moduleConfig, clusterState, cloud, parser, NewClassGetter(&parser, schemaManager, schemaReader, collectionRetrievalStrategyFF, logger),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("cannot init handler: %w", err)
+	}
+	m := &Manager{
+		validator:    validator,
+		repo:         repo,
+		logger:       logger,
+		clusterState: clusterState,
+		Handler:      handler,
+		SchemaReader: schemaReader,
+		Authorizer:   authorizer,
+	}
+
+	return m, nil
+}
+
+// func (m *Manager) migrateSchemaIfNecessary(ctx context.Context, localSchema *State) error {
+// 	// introduced when Weaviate started supporting multi-shards per class in v1.8
+// 	if err := m.checkSingleShardMigration(ctx, localSchema); err != nil {
+// 		return errors.Wrap(err, "migrating sharding state from previous version")
+// 	}
+
+// 	// introduced when Weaviate started supporting replication in v1.17
+// 	if err := m.checkShardingStateForReplication(ctx, localSchema); err != nil {
+// 		return errors.Wrap(err, "migrating sharding state from previous version (before replication)")
+// 	}
+
+// 	// if other migrations become necessary in the future, you can add them here.
+// 	return nil
+// }
+
+// func (m *Manager) checkSingleShardMigration(ctx context.Context, localSchema *State) error {
+// 	for _, c := range localSchema.ObjectSchema.Classes {
+// 		if _, ok := localSchema.ShardingState[c.Class]; ok { // there is sharding state for this class. Nothing to do
+// 			continue
+// 		}
+
+// 		m.logger.WithField("className", c.Class).WithField("action", "initialize_schema").
+// 			Warningf("No sharding state found for class %q, initializing new state. "+
+// 				"This is expected behavior if the schema was created with an older Weaviate "+
+// 				"version, prior to supporting multi-shard indices.", c.Class)
+
+// 		// there is no sharding state for this class, let's create the correct
+// 		// config. This class must have been created prior to the sharding feature,
+// 		// so we now that the shardCount==1 - we do not care about any of the other
+// 		// parameters and simply use the defaults for those
+// 		c.ShardingConfig = map[string]interface{}{
+// 			"desiredCount": 1,
+// 		}
+// 		if err := m.praser.parseShardingConfig(c); err != nil {
+// 			return err
+// 		}
+
+// 		if err := replica.ValidateConfig(c, m.config.Replication); err != nil {
+// 			return fmt.Errorf("validate replication config: %w", err)
+// 		}
+// 		shardState, err := sharding.InitState(c.Class,
+// 			c.ShardingConfig.(sharding.Config),
+// 			m.clusterState, c.ReplicationConfig.Factor,
+// 			schema.MultiTenancyEnabled(c))
+// 		if err != nil {
+// 			return errors.Wrap(err, "init sharding state")
+// 		}
+
+// 		if localSchema.ShardingState == nil {
+// 			localSchema.ShardingState = map[string]*sharding.State{}
+// 		}
+// 		localSchema.ShardingState[c.Class] = shardState
+
+// 	}
+
+// 	return nil
+// }
+
+// func (m *Manager) checkShardingStateForReplication(ctx context.Context, localSchema *State) error {
+// 	for _, classState := range localSchema.ShardingState {
+// 		classState.MigrateFromOldFormat()
+// 	}
+// 	return nil
+// }
+
+// func newSchema() *State {
+// 	return &State{
+// 		ObjectSchema: &models.Schema{
+// 			Classes: []*models.Class{},
+// 		},
+// 		ShardingState: map[string]*sharding.State{},
+// 	}
+// }
+
+func (m *Manager) ClusterHealthScore() int {
+	return m.clusterState.ClusterHealthScore()
+}
+
+// ResolveParentNodes gets all replicas for a specific class shard and resolves their names
+//
+// it returns map[node_name] node_address where node_address = "" if can't resolve node_name
+func (m *Manager) ResolveParentNodes(class, shardName string) (map[string]string, error) {
+	nodes, err := m.ShardReplicas(class, shardName)
+	if err != nil {
+		return nil, fmt.Errorf("get replicas from schema: %w", err)
+	}
+
+	if len(nodes) == 0 {
+		return nil, nil
+	}
+
+	name2Addr := make(map[string]string, len(nodes))
+	for _, node := range nodes {
+		if node != "" {
+			host, _ := m.clusterState.NodeHostname(node)
+			name2Addr[node] = host
+		}
+	}
+	return name2Addr, nil
+}
+
+func (m *Manager) TenantsShards(ctx context.Context, class string, tenants ...string) (map[string]string, error) {
+	slices.Sort(tenants)
+	tenants = slices.Compact(tenants)
+	status, _, err := m.schemaManager.QueryTenantsShards(class, tenants...)
+	if !m.AllowImplicitTenantActivation(class) || err != nil {
+		return status, err
+	}
+
+	return m.activateTenantIfInactive(ctx, class, status)
+}
+
+// OptimisticTenantStatus tries to query the local state first. It is
+// optimistic that the state has already propagated correctly. If the state is
+// unexpected, i.e. either the tenant is not found at all or the status is
+// COLD, it will double-check with the leader.
+//
+// This way we accept false positives (for HOT tenants), but guarantee that there will never be
+// false negatives (i.e. tenants labelled as COLD that the leader thinks should
+// be HOT).
+//
+// This means:
+//
+//   - If a tenant is HOT locally (true positive), we proceed normally
+//   - If a tenant is HOT locally, but should be COLD (false positive), we still
+//     proceed. This is a conscious decision to keep the happy path free from
+//     (expensive) leader lookups.
+//   - If a tenant is not found locally, we assume it was recently created, but
+//     the state hasn't propagated yet. To verify, we check with the leader.
+//   - If a tenant is found locally, but is marked as COLD, we assume it was
+//     recently turned HOT, but the state hasn't propagated yet. To verify, we
+//     check with the leader
+//
+// Overall, we keep the (very common) happy path, free from expensive
+// leader-lookups and only fall back to the leader if the local result implies
+// an unhappy path.
+func (m *Manager) OptimisticTenantStatus(ctx context.Context, class string, tenant string) (map[string]string, error) {
+	var foundTenant bool
+	var status string
+	err := m.schemaReader.Read(class, func(_ *models.Class, ss *sharding.State) error {
+		t, ok := ss.Physical[tenant]
+		if !ok {
+			return nil
+		}
+
+		foundTenant = true
+		status = t.Status
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if !foundTenant || status != models.TenantActivityStatusHOT {
+		// either no state at all or state does not imply happy path -> delegate to
+		// leader
+		return m.TenantsShards(ctx, class, tenant)
+	}
+
+	return map[string]string{
+		tenant: status,
+	}, nil
+}
+
+func (m *Manager) activateTenantIfInactive(ctx context.Context, class string,
+	status map[string]string,
+) (map[string]string, error) {
+	req := &api.UpdateTenantsRequest{
+		Tenants:               make([]*api.Tenant, 0, len(status)),
+		ClusterNodes:          m.schemaManager.StorageCandidates(),
+		ImplicitUpdateRequest: true,
+	}
+	for tenant, s := range status {
+		if s != models.TenantActivityStatusHOT {
+			req.Tenants = append(req.Tenants,
+				&api.Tenant{Name: tenant, Status: models.TenantActivityStatusHOT})
+		}
+	}
+
+	if len(req.Tenants) == 0 {
+		// nothing to do, all tenants are already HOT
+		return status, nil
+	}
+
+	_, err := m.schemaManager.UpdateTenants(ctx, class, req)
+	if err != nil {
+		names := make([]string, len(req.Tenants))
+		for i, t := range req.Tenants {
+			names[i] = t.Name
+		}
+
+		return nil, fmt.Errorf("implicit activation of tenants %s: %w", strings.Join(names, ", "), err)
+	}
+
+	for _, t := range req.Tenants {
+		status[t.Name] = models.TenantActivityStatusHOT
+	}
+
+	return status, nil
+}
+
+func (m *Manager) AllowImplicitTenantActivation(class string) bool {
+	allow := false
+	m.schemaReader.Read(class, func(c *models.Class, _ *sharding.State) error {
+		allow = schema.AutoTenantActivationEnabled(c)
+		return nil
+	})
+
+	return allow
+}
+
+func (m *Manager) ShardOwner(class, shard string) (string, error) {
+	owner, _, err := m.schemaManager.QueryShardOwner(class, shard)
+	if err != nil {
+		return "", err
+	}
+	return owner, nil
+}

platform/dbops/binaries/weaviate-src/usecases/schema/migrator.go

@@ -0,0 +1,69 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+// Package migrate provides a simple composer tool, which implements the
+// Migrator interface and can take in any number of migrators which themselves
+// have to implement the interface
+package schema
+
+import (
+	"context"
+
+	"github.com/weaviate/weaviate/entities/models"
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/usecases/sharding"
+)
+
+type CreateTenantPayload struct {
+	Name   string
+	Status string
+}
+
+type UpdateTenantPayload struct {
+	Name   string
+	Status string
+}
+
+// Migrator represents both the input and output interface of the Composer
+type Migrator interface {
+	AddClass(ctx context.Context, class *models.Class) error
+	DropClass(ctx context.Context, className string, hasFrozen bool) error
+	// UpdateClass(ctx context.Context, className string,newClassName *string) error
+	GetShardsQueueSize(ctx context.Context, className, tenant string) (map[string]int64, error)
+	LoadShard(ctx context.Context, class, shard string) error
+	DropShard(ctx context.Context, class, shard string) error
+	ShutdownShard(ctx context.Context, class, shard string) error
+
+	AddProperty(ctx context.Context, className string,
+		props ...*models.Property) error
+	UpdateProperty(ctx context.Context, className string,
+		propName string, newName *string) error
+	UpdateIndex(ctx context.Context, class *models.Class, shardingState *sharding.State) error
+
+	NewTenants(ctx context.Context, class *models.Class, creates []*CreateTenantPayload) error
+	UpdateTenants(ctx context.Context, class *models.Class, updates []*UpdateTenantPayload, implicitUpdate bool) error
+	DeleteTenants(ctx context.Context, class string, tenants []*models.Tenant) error
+
+	GetShardsStatus(ctx context.Context, className, tenant string) (map[string]string, error)
+	UpdateShardStatus(ctx context.Context, className, shardName, targetStatus string, schemaVersion uint64) error
+
+	UpdateVectorIndexConfig(ctx context.Context, className string, updated schemaConfig.VectorIndexConfig) error
+	ValidateVectorIndexConfigsUpdate(old, updated map[string]schemaConfig.VectorIndexConfig) error
+	UpdateVectorIndexConfigs(ctx context.Context, className string,
+		updated map[string]schemaConfig.VectorIndexConfig) error
+	ValidateInvertedIndexConfigUpdate(old, updated *models.InvertedIndexConfig) error
+	UpdateInvertedIndexConfig(ctx context.Context, className string,
+		updated *models.InvertedIndexConfig) error
+	UpdateReplicationConfig(ctx context.Context, className string,
+		updated *models.ReplicationConfig) error
+	WaitForStartup(context.Context) error
+	Shutdown(context.Context) error
+}

platform/dbops/binaries/weaviate-src/usecases/schema/mock_schema_getter.go

@@ -0,0 +1,777 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+// Code generated by mockery v2.53.2. DO NOT EDIT.
+
+package schema
+
+import (
+	context "context"
+
+	mock "github.com/stretchr/testify/mock"
+	entitiesschema "github.com/weaviate/weaviate/entities/schema"
+
+	models "github.com/weaviate/weaviate/entities/models"
+)
+
+// MockSchemaGetter is an autogenerated mock type for the SchemaGetter type
+type MockSchemaGetter struct {
+	mock.Mock
+}
+
+type MockSchemaGetter_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSchemaGetter) EXPECT() *MockSchemaGetter_Expecter {
+	return &MockSchemaGetter_Expecter{mock: &_m.Mock}
+}
+
+// ClusterHealthScore provides a mock function with no fields
+func (_m *MockSchemaGetter) ClusterHealthScore() int {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClusterHealthScore")
+	}
+
+	var r0 int
+	if rf, ok := ret.Get(0).(func() int); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_ClusterHealthScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterHealthScore'
+type MockSchemaGetter_ClusterHealthScore_Call struct {
+	*mock.Call
+}
+
+// ClusterHealthScore is a helper method to define mock.On call
+func (_e *MockSchemaGetter_Expecter) ClusterHealthScore() *MockSchemaGetter_ClusterHealthScore_Call {
+	return &MockSchemaGetter_ClusterHealthScore_Call{Call: _e.mock.On("ClusterHealthScore")}
+}
+
+func (_c *MockSchemaGetter_ClusterHealthScore_Call) Run(run func()) *MockSchemaGetter_ClusterHealthScore_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_ClusterHealthScore_Call) Return(_a0 int) *MockSchemaGetter_ClusterHealthScore_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_ClusterHealthScore_Call) RunAndReturn(run func() int) *MockSchemaGetter_ClusterHealthScore_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetAliasesForClass provides a mock function with given fields: class
+func (_m *MockSchemaGetter) GetAliasesForClass(class string) []*models.Alias {
+	ret := _m.Called(class)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAliasesForClass")
+	}
+
+	var r0 []*models.Alias
+	if rf, ok := ret.Get(0).(func(string) []*models.Alias); ok {
+		r0 = rf(class)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*models.Alias)
+		}
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_GetAliasesForClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAliasesForClass'
+type MockSchemaGetter_GetAliasesForClass_Call struct {
+	*mock.Call
+}
+
+// GetAliasesForClass is a helper method to define mock.On call
+//   - class string
+func (_e *MockSchemaGetter_Expecter) GetAliasesForClass(class interface{}) *MockSchemaGetter_GetAliasesForClass_Call {
+	return &MockSchemaGetter_GetAliasesForClass_Call{Call: _e.mock.On("GetAliasesForClass", class)}
+}
+
+func (_c *MockSchemaGetter_GetAliasesForClass_Call) Run(run func(class string)) *MockSchemaGetter_GetAliasesForClass_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_GetAliasesForClass_Call) Return(_a0 []*models.Alias) *MockSchemaGetter_GetAliasesForClass_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_GetAliasesForClass_Call) RunAndReturn(run func(string) []*models.Alias) *MockSchemaGetter_GetAliasesForClass_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetSchemaSkipAuth provides a mock function with no fields
+func (_m *MockSchemaGetter) GetSchemaSkipAuth() entitiesschema.Schema {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSchemaSkipAuth")
+	}
+
+	var r0 entitiesschema.Schema
+	if rf, ok := ret.Get(0).(func() entitiesschema.Schema); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(entitiesschema.Schema)
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_GetSchemaSkipAuth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSchemaSkipAuth'
+type MockSchemaGetter_GetSchemaSkipAuth_Call struct {
+	*mock.Call
+}
+
+// GetSchemaSkipAuth is a helper method to define mock.On call
+func (_e *MockSchemaGetter_Expecter) GetSchemaSkipAuth() *MockSchemaGetter_GetSchemaSkipAuth_Call {
+	return &MockSchemaGetter_GetSchemaSkipAuth_Call{Call: _e.mock.On("GetSchemaSkipAuth")}
+}
+
+func (_c *MockSchemaGetter_GetSchemaSkipAuth_Call) Run(run func()) *MockSchemaGetter_GetSchemaSkipAuth_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_GetSchemaSkipAuth_Call) Return(_a0 entitiesschema.Schema) *MockSchemaGetter_GetSchemaSkipAuth_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_GetSchemaSkipAuth_Call) RunAndReturn(run func() entitiesschema.Schema) *MockSchemaGetter_GetSchemaSkipAuth_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NodeName provides a mock function with no fields
+func (_m *MockSchemaGetter) NodeName() string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for NodeName")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_NodeName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeName'
+type MockSchemaGetter_NodeName_Call struct {
+	*mock.Call
+}
+
+// NodeName is a helper method to define mock.On call
+func (_e *MockSchemaGetter_Expecter) NodeName() *MockSchemaGetter_NodeName_Call {
+	return &MockSchemaGetter_NodeName_Call{Call: _e.mock.On("NodeName")}
+}
+
+func (_c *MockSchemaGetter_NodeName_Call) Run(run func()) *MockSchemaGetter_NodeName_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_NodeName_Call) Return(_a0 string) *MockSchemaGetter_NodeName_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_NodeName_Call) RunAndReturn(run func() string) *MockSchemaGetter_NodeName_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Nodes provides a mock function with no fields
+func (_m *MockSchemaGetter) Nodes() []string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Nodes")
+	}
+
+	var r0 []string
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_Nodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Nodes'
+type MockSchemaGetter_Nodes_Call struct {
+	*mock.Call
+}
+
+// Nodes is a helper method to define mock.On call
+func (_e *MockSchemaGetter_Expecter) Nodes() *MockSchemaGetter_Nodes_Call {
+	return &MockSchemaGetter_Nodes_Call{Call: _e.mock.On("Nodes")}
+}
+
+func (_c *MockSchemaGetter_Nodes_Call) Run(run func()) *MockSchemaGetter_Nodes_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_Nodes_Call) Return(_a0 []string) *MockSchemaGetter_Nodes_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_Nodes_Call) RunAndReturn(run func() []string) *MockSchemaGetter_Nodes_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OptimisticTenantStatus provides a mock function with given fields: ctx, class, tenants
+func (_m *MockSchemaGetter) OptimisticTenantStatus(ctx context.Context, class string, tenants string) (map[string]string, error) {
+	ret := _m.Called(ctx, class, tenants)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OptimisticTenantStatus")
+	}
+
+	var r0 map[string]string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string) (map[string]string, error)); ok {
+		return rf(ctx, class, tenants)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, string) map[string]string); ok {
+		r0 = rf(ctx, class, tenants)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+		r1 = rf(ctx, class, tenants)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaGetter_OptimisticTenantStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OptimisticTenantStatus'
+type MockSchemaGetter_OptimisticTenantStatus_Call struct {
+	*mock.Call
+}
+
+// OptimisticTenantStatus is a helper method to define mock.On call
+//   - ctx context.Context
+//   - class string
+//   - tenants string
+func (_e *MockSchemaGetter_Expecter) OptimisticTenantStatus(ctx interface{}, class interface{}, tenants interface{}) *MockSchemaGetter_OptimisticTenantStatus_Call {
+	return &MockSchemaGetter_OptimisticTenantStatus_Call{Call: _e.mock.On("OptimisticTenantStatus", ctx, class, tenants)}
+}
+
+func (_c *MockSchemaGetter_OptimisticTenantStatus_Call) Run(run func(ctx context.Context, class string, tenants string)) *MockSchemaGetter_OptimisticTenantStatus_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_OptimisticTenantStatus_Call) Return(_a0 map[string]string, _a1 error) *MockSchemaGetter_OptimisticTenantStatus_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaGetter_OptimisticTenantStatus_Call) RunAndReturn(run func(context.Context, string, string) (map[string]string, error)) *MockSchemaGetter_OptimisticTenantStatus_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReadOnlyClass provides a mock function with given fields: _a0
+func (_m *MockSchemaGetter) ReadOnlyClass(_a0 string) *models.Class {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReadOnlyClass")
+	}
+
+	var r0 *models.Class
+	if rf, ok := ret.Get(0).(func(string) *models.Class); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*models.Class)
+		}
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_ReadOnlyClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOnlyClass'
+type MockSchemaGetter_ReadOnlyClass_Call struct {
+	*mock.Call
+}
+
+// ReadOnlyClass is a helper method to define mock.On call
+//   - _a0 string
+func (_e *MockSchemaGetter_Expecter) ReadOnlyClass(_a0 interface{}) *MockSchemaGetter_ReadOnlyClass_Call {
+	return &MockSchemaGetter_ReadOnlyClass_Call{Call: _e.mock.On("ReadOnlyClass", _a0)}
+}
+
+func (_c *MockSchemaGetter_ReadOnlyClass_Call) Run(run func(_a0 string)) *MockSchemaGetter_ReadOnlyClass_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_ReadOnlyClass_Call) Return(_a0 *models.Class) *MockSchemaGetter_ReadOnlyClass_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_ReadOnlyClass_Call) RunAndReturn(run func(string) *models.Class) *MockSchemaGetter_ReadOnlyClass_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ResolveAlias provides a mock function with given fields: _a0
+func (_m *MockSchemaGetter) ResolveAlias(_a0 string) string {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ResolveAlias")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(string) string); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_ResolveAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveAlias'
+type MockSchemaGetter_ResolveAlias_Call struct {
+	*mock.Call
+}
+
+// ResolveAlias is a helper method to define mock.On call
+//   - _a0 string
+func (_e *MockSchemaGetter_Expecter) ResolveAlias(_a0 interface{}) *MockSchemaGetter_ResolveAlias_Call {
+	return &MockSchemaGetter_ResolveAlias_Call{Call: _e.mock.On("ResolveAlias", _a0)}
+}
+
+func (_c *MockSchemaGetter_ResolveAlias_Call) Run(run func(_a0 string)) *MockSchemaGetter_ResolveAlias_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_ResolveAlias_Call) Return(_a0 string) *MockSchemaGetter_ResolveAlias_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_ResolveAlias_Call) RunAndReturn(run func(string) string) *MockSchemaGetter_ResolveAlias_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ResolveParentNodes provides a mock function with given fields: _a0, _a1
+func (_m *MockSchemaGetter) ResolveParentNodes(_a0 string, _a1 string) (map[string]string, error) {
+	ret := _m.Called(_a0, _a1)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ResolveParentNodes")
+	}
+
+	var r0 map[string]string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (map[string]string, error)); ok {
+		return rf(_a0, _a1)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) map[string]string); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaGetter_ResolveParentNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveParentNodes'
+type MockSchemaGetter_ResolveParentNodes_Call struct {
+	*mock.Call
+}
+
+// ResolveParentNodes is a helper method to define mock.On call
+//   - _a0 string
+//   - _a1 string
+func (_e *MockSchemaGetter_Expecter) ResolveParentNodes(_a0 interface{}, _a1 interface{}) *MockSchemaGetter_ResolveParentNodes_Call {
+	return &MockSchemaGetter_ResolveParentNodes_Call{Call: _e.mock.On("ResolveParentNodes", _a0, _a1)}
+}
+
+func (_c *MockSchemaGetter_ResolveParentNodes_Call) Run(run func(_a0 string, _a1 string)) *MockSchemaGetter_ResolveParentNodes_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_ResolveParentNodes_Call) Return(_a0 map[string]string, _a1 error) *MockSchemaGetter_ResolveParentNodes_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaGetter_ResolveParentNodes_Call) RunAndReturn(run func(string, string) (map[string]string, error)) *MockSchemaGetter_ResolveParentNodes_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardFromUUID provides a mock function with given fields: class, uuid
+func (_m *MockSchemaGetter) ShardFromUUID(class string, uuid []byte) string {
+	ret := _m.Called(class, uuid)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardFromUUID")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(string, []byte) string); ok {
+		r0 = rf(class, uuid)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_ShardFromUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardFromUUID'
+type MockSchemaGetter_ShardFromUUID_Call struct {
+	*mock.Call
+}
+
+// ShardFromUUID is a helper method to define mock.On call
+//   - class string
+//   - uuid []byte
+func (_e *MockSchemaGetter_Expecter) ShardFromUUID(class interface{}, uuid interface{}) *MockSchemaGetter_ShardFromUUID_Call {
+	return &MockSchemaGetter_ShardFromUUID_Call{Call: _e.mock.On("ShardFromUUID", class, uuid)}
+}
+
+func (_c *MockSchemaGetter_ShardFromUUID_Call) Run(run func(class string, uuid []byte)) *MockSchemaGetter_ShardFromUUID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].([]byte))
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_ShardFromUUID_Call) Return(_a0 string) *MockSchemaGetter_ShardFromUUID_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_ShardFromUUID_Call) RunAndReturn(run func(string, []byte) string) *MockSchemaGetter_ShardFromUUID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardOwner provides a mock function with given fields: class, shard
+func (_m *MockSchemaGetter) ShardOwner(class string, shard string) (string, error) {
+	ret := _m.Called(class, shard)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardOwner")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (string, error)); ok {
+		return rf(class, shard)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) string); ok {
+		r0 = rf(class, shard)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(class, shard)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaGetter_ShardOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardOwner'
+type MockSchemaGetter_ShardOwner_Call struct {
+	*mock.Call
+}
+
+// ShardOwner is a helper method to define mock.On call
+//   - class string
+//   - shard string
+func (_e *MockSchemaGetter_Expecter) ShardOwner(class interface{}, shard interface{}) *MockSchemaGetter_ShardOwner_Call {
+	return &MockSchemaGetter_ShardOwner_Call{Call: _e.mock.On("ShardOwner", class, shard)}
+}
+
+func (_c *MockSchemaGetter_ShardOwner_Call) Run(run func(class string, shard string)) *MockSchemaGetter_ShardOwner_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_ShardOwner_Call) Return(_a0 string, _a1 error) *MockSchemaGetter_ShardOwner_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaGetter_ShardOwner_Call) RunAndReturn(run func(string, string) (string, error)) *MockSchemaGetter_ShardOwner_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardReplicas provides a mock function with given fields: class, shard
+func (_m *MockSchemaGetter) ShardReplicas(class string, shard string) ([]string, error) {
+	ret := _m.Called(class, shard)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardReplicas")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) ([]string, error)); ok {
+		return rf(class, shard)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) []string); ok {
+		r0 = rf(class, shard)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(class, shard)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaGetter_ShardReplicas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardReplicas'
+type MockSchemaGetter_ShardReplicas_Call struct {
+	*mock.Call
+}
+
+// ShardReplicas is a helper method to define mock.On call
+//   - class string
+//   - shard string
+func (_e *MockSchemaGetter_Expecter) ShardReplicas(class interface{}, shard interface{}) *MockSchemaGetter_ShardReplicas_Call {
+	return &MockSchemaGetter_ShardReplicas_Call{Call: _e.mock.On("ShardReplicas", class, shard)}
+}
+
+func (_c *MockSchemaGetter_ShardReplicas_Call) Run(run func(class string, shard string)) *MockSchemaGetter_ShardReplicas_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_ShardReplicas_Call) Return(_a0 []string, _a1 error) *MockSchemaGetter_ShardReplicas_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaGetter_ShardReplicas_Call) RunAndReturn(run func(string, string) ([]string, error)) *MockSchemaGetter_ShardReplicas_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Statistics provides a mock function with no fields
+func (_m *MockSchemaGetter) Statistics() map[string]interface{} {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Statistics")
+	}
+
+	var r0 map[string]interface{}
+	if rf, ok := ret.Get(0).(func() map[string]interface{}); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]interface{})
+		}
+	}
+
+	return r0
+}
+
+// MockSchemaGetter_Statistics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Statistics'
+type MockSchemaGetter_Statistics_Call struct {
+	*mock.Call
+}
+
+// Statistics is a helper method to define mock.On call
+func (_e *MockSchemaGetter_Expecter) Statistics() *MockSchemaGetter_Statistics_Call {
+	return &MockSchemaGetter_Statistics_Call{Call: _e.mock.On("Statistics")}
+}
+
+func (_c *MockSchemaGetter_Statistics_Call) Run(run func()) *MockSchemaGetter_Statistics_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_Statistics_Call) Return(_a0 map[string]interface{}) *MockSchemaGetter_Statistics_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaGetter_Statistics_Call) RunAndReturn(run func() map[string]interface{}) *MockSchemaGetter_Statistics_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// TenantsShards provides a mock function with given fields: ctx, class, tenants
+func (_m *MockSchemaGetter) TenantsShards(ctx context.Context, class string, tenants ...string) (map[string]string, error) {
+	_va := make([]interface{}, len(tenants))
+	for _i := range tenants {
+		_va[_i] = tenants[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, class)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for TenantsShards")
+	}
+
+	var r0 map[string]string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, ...string) (map[string]string, error)); ok {
+		return rf(ctx, class, tenants...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, ...string) map[string]string); ok {
+		r0 = rf(ctx, class, tenants...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, ...string) error); ok {
+		r1 = rf(ctx, class, tenants...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaGetter_TenantsShards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TenantsShards'
+type MockSchemaGetter_TenantsShards_Call struct {
+	*mock.Call
+}
+
+// TenantsShards is a helper method to define mock.On call
+//   - ctx context.Context
+//   - class string
+//   - tenants ...string
+func (_e *MockSchemaGetter_Expecter) TenantsShards(ctx interface{}, class interface{}, tenants ...interface{}) *MockSchemaGetter_TenantsShards_Call {
+	return &MockSchemaGetter_TenantsShards_Call{Call: _e.mock.On("TenantsShards",
+		append([]interface{}{ctx, class}, tenants...)...)}
+}
+
+func (_c *MockSchemaGetter_TenantsShards_Call) Run(run func(ctx context.Context, class string, tenants ...string)) *MockSchemaGetter_TenantsShards_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(args[0].(context.Context), args[1].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockSchemaGetter_TenantsShards_Call) Return(_a0 map[string]string, _a1 error) *MockSchemaGetter_TenantsShards_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaGetter_TenantsShards_Call) RunAndReturn(run func(context.Context, string, ...string) (map[string]string, error)) *MockSchemaGetter_TenantsShards_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockSchemaGetter creates a new instance of MockSchemaGetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSchemaGetter(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSchemaGetter {
+	mock := &MockSchemaGetter{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

platform/dbops/binaries/weaviate-src/usecases/schema/mock_schema_reader.go

@@ -0,0 +1,1335 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+// Code generated by mockery v2.53.2. DO NOT EDIT.
+
+package schema
+
+import (
+	context "context"
+
+	clusterschema "github.com/weaviate/weaviate/cluster/schema"
+
+	mock "github.com/stretchr/testify/mock"
+
+	models "github.com/weaviate/weaviate/entities/models"
+
+	sharding "github.com/weaviate/weaviate/usecases/sharding"
+
+	versioned "github.com/weaviate/weaviate/entities/versioned"
+)
+
+// MockSchemaReader is an autogenerated mock type for the SchemaReader type
+type MockSchemaReader struct {
+	mock.Mock
+}
+
+type MockSchemaReader_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSchemaReader) EXPECT() *MockSchemaReader_Expecter {
+	return &MockSchemaReader_Expecter{mock: &_m.Mock}
+}
+
+// Aliases provides a mock function with no fields
+func (_m *MockSchemaReader) Aliases() map[string]string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Aliases")
+	}
+
+	var r0 map[string]string
+	if rf, ok := ret.Get(0).(func() map[string]string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]string)
+		}
+	}
+
+	return r0
+}
+
+// MockSchemaReader_Aliases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Aliases'
+type MockSchemaReader_Aliases_Call struct {
+	*mock.Call
+}
+
+// Aliases is a helper method to define mock.On call
+func (_e *MockSchemaReader_Expecter) Aliases() *MockSchemaReader_Aliases_Call {
+	return &MockSchemaReader_Aliases_Call{Call: _e.mock.On("Aliases")}
+}
+
+func (_c *MockSchemaReader_Aliases_Call) Run(run func()) *MockSchemaReader_Aliases_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_Aliases_Call) Return(_a0 map[string]string) *MockSchemaReader_Aliases_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_Aliases_Call) RunAndReturn(run func() map[string]string) *MockSchemaReader_Aliases_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ClassEqual provides a mock function with given fields: name
+func (_m *MockSchemaReader) ClassEqual(name string) string {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClassEqual")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(string) string); ok {
+		r0 = rf(name)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_ClassEqual_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassEqual'
+type MockSchemaReader_ClassEqual_Call struct {
+	*mock.Call
+}
+
+// ClassEqual is a helper method to define mock.On call
+//   - name string
+func (_e *MockSchemaReader_Expecter) ClassEqual(name interface{}) *MockSchemaReader_ClassEqual_Call {
+	return &MockSchemaReader_ClassEqual_Call{Call: _e.mock.On("ClassEqual", name)}
+}
+
+func (_c *MockSchemaReader_ClassEqual_Call) Run(run func(name string)) *MockSchemaReader_ClassEqual_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ClassEqual_Call) Return(_a0 string) *MockSchemaReader_ClassEqual_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_ClassEqual_Call) RunAndReturn(run func(string) string) *MockSchemaReader_ClassEqual_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ClassInfo provides a mock function with given fields: class
+func (_m *MockSchemaReader) ClassInfo(class string) clusterschema.ClassInfo {
+	ret := _m.Called(class)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClassInfo")
+	}
+
+	var r0 clusterschema.ClassInfo
+	if rf, ok := ret.Get(0).(func(string) clusterschema.ClassInfo); ok {
+		r0 = rf(class)
+	} else {
+		r0 = ret.Get(0).(clusterschema.ClassInfo)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_ClassInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassInfo'
+type MockSchemaReader_ClassInfo_Call struct {
+	*mock.Call
+}
+
+// ClassInfo is a helper method to define mock.On call
+//   - class string
+func (_e *MockSchemaReader_Expecter) ClassInfo(class interface{}) *MockSchemaReader_ClassInfo_Call {
+	return &MockSchemaReader_ClassInfo_Call{Call: _e.mock.On("ClassInfo", class)}
+}
+
+func (_c *MockSchemaReader_ClassInfo_Call) Run(run func(class string)) *MockSchemaReader_ClassInfo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ClassInfo_Call) Return(ci clusterschema.ClassInfo) *MockSchemaReader_ClassInfo_Call {
+	_c.Call.Return(ci)
+	return _c
+}
+
+func (_c *MockSchemaReader_ClassInfo_Call) RunAndReturn(run func(string) clusterschema.ClassInfo) *MockSchemaReader_ClassInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ClassInfoWithVersion provides a mock function with given fields: ctx, class, version
+func (_m *MockSchemaReader) ClassInfoWithVersion(ctx context.Context, class string, version uint64) (clusterschema.ClassInfo, error) {
+	ret := _m.Called(ctx, class, version)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClassInfoWithVersion")
+	}
+
+	var r0 clusterschema.ClassInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, uint64) (clusterschema.ClassInfo, error)); ok {
+		return rf(ctx, class, version)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, uint64) clusterschema.ClassInfo); ok {
+		r0 = rf(ctx, class, version)
+	} else {
+		r0 = ret.Get(0).(clusterschema.ClassInfo)
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, uint64) error); ok {
+		r1 = rf(ctx, class, version)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_ClassInfoWithVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassInfoWithVersion'
+type MockSchemaReader_ClassInfoWithVersion_Call struct {
+	*mock.Call
+}
+
+// ClassInfoWithVersion is a helper method to define mock.On call
+//   - ctx context.Context
+//   - class string
+//   - version uint64
+func (_e *MockSchemaReader_Expecter) ClassInfoWithVersion(ctx interface{}, class interface{}, version interface{}) *MockSchemaReader_ClassInfoWithVersion_Call {
+	return &MockSchemaReader_ClassInfoWithVersion_Call{Call: _e.mock.On("ClassInfoWithVersion", ctx, class, version)}
+}
+
+func (_c *MockSchemaReader_ClassInfoWithVersion_Call) Run(run func(ctx context.Context, class string, version uint64)) *MockSchemaReader_ClassInfoWithVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(uint64))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ClassInfoWithVersion_Call) Return(_a0 clusterschema.ClassInfo, _a1 error) *MockSchemaReader_ClassInfoWithVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_ClassInfoWithVersion_Call) RunAndReturn(run func(context.Context, string, uint64) (clusterschema.ClassInfo, error)) *MockSchemaReader_ClassInfoWithVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetAliasesForClass provides a mock function with given fields: class
+func (_m *MockSchemaReader) GetAliasesForClass(class string) []*models.Alias {
+	ret := _m.Called(class)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAliasesForClass")
+	}
+
+	var r0 []*models.Alias
+	if rf, ok := ret.Get(0).(func(string) []*models.Alias); ok {
+		r0 = rf(class)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*models.Alias)
+		}
+	}
+
+	return r0
+}
+
+// MockSchemaReader_GetAliasesForClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAliasesForClass'
+type MockSchemaReader_GetAliasesForClass_Call struct {
+	*mock.Call
+}
+
+// GetAliasesForClass is a helper method to define mock.On call
+//   - class string
+func (_e *MockSchemaReader_Expecter) GetAliasesForClass(class interface{}) *MockSchemaReader_GetAliasesForClass_Call {
+	return &MockSchemaReader_GetAliasesForClass_Call{Call: _e.mock.On("GetAliasesForClass", class)}
+}
+
+func (_c *MockSchemaReader_GetAliasesForClass_Call) Run(run func(class string)) *MockSchemaReader_GetAliasesForClass_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_GetAliasesForClass_Call) Return(_a0 []*models.Alias) *MockSchemaReader_GetAliasesForClass_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_GetAliasesForClass_Call) RunAndReturn(run func(string) []*models.Alias) *MockSchemaReader_GetAliasesForClass_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetShardsStatus provides a mock function with given fields: class, tenant
+func (_m *MockSchemaReader) GetShardsStatus(class string, tenant string) (models.ShardStatusList, error) {
+	ret := _m.Called(class, tenant)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetShardsStatus")
+	}
+
+	var r0 models.ShardStatusList
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (models.ShardStatusList, error)); ok {
+		return rf(class, tenant)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) models.ShardStatusList); ok {
+		r0 = rf(class, tenant)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(models.ShardStatusList)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(class, tenant)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_GetShardsStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShardsStatus'
+type MockSchemaReader_GetShardsStatus_Call struct {
+	*mock.Call
+}
+
+// GetShardsStatus is a helper method to define mock.On call
+//   - class string
+//   - tenant string
+func (_e *MockSchemaReader_Expecter) GetShardsStatus(class interface{}, tenant interface{}) *MockSchemaReader_GetShardsStatus_Call {
+	return &MockSchemaReader_GetShardsStatus_Call{Call: _e.mock.On("GetShardsStatus", class, tenant)}
+}
+
+func (_c *MockSchemaReader_GetShardsStatus_Call) Run(run func(class string, tenant string)) *MockSchemaReader_GetShardsStatus_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_GetShardsStatus_Call) Return(_a0 models.ShardStatusList, _a1 error) *MockSchemaReader_GetShardsStatus_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_GetShardsStatus_Call) RunAndReturn(run func(string, string) (models.ShardStatusList, error)) *MockSchemaReader_GetShardsStatus_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// LocalShards provides a mock function with given fields: class
+func (_m *MockSchemaReader) LocalShards(class string) ([]string, error) {
+	ret := _m.Called(class)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LocalShards")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]string, error)); ok {
+		return rf(class)
+	}
+	if rf, ok := ret.Get(0).(func(string) []string); ok {
+		r0 = rf(class)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(class)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_LocalShards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LocalShards'
+type MockSchemaReader_LocalShards_Call struct {
+	*mock.Call
+}
+
+// LocalShards is a helper method to define mock.On call
+//   - class string
+func (_e *MockSchemaReader_Expecter) LocalShards(class interface{}) *MockSchemaReader_LocalShards_Call {
+	return &MockSchemaReader_LocalShards_Call{Call: _e.mock.On("LocalShards", class)}
+}
+
+func (_c *MockSchemaReader_LocalShards_Call) Run(run func(class string)) *MockSchemaReader_LocalShards_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_LocalShards_Call) Return(_a0 []string, _a1 error) *MockSchemaReader_LocalShards_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_LocalShards_Call) RunAndReturn(run func(string) ([]string, error)) *MockSchemaReader_LocalShards_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MultiTenancy provides a mock function with given fields: class
+func (_m *MockSchemaReader) MultiTenancy(class string) models.MultiTenancyConfig {
+	ret := _m.Called(class)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MultiTenancy")
+	}
+
+	var r0 models.MultiTenancyConfig
+	if rf, ok := ret.Get(0).(func(string) models.MultiTenancyConfig); ok {
+		r0 = rf(class)
+	} else {
+		r0 = ret.Get(0).(models.MultiTenancyConfig)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_MultiTenancy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiTenancy'
+type MockSchemaReader_MultiTenancy_Call struct {
+	*mock.Call
+}
+
+// MultiTenancy is a helper method to define mock.On call
+//   - class string
+func (_e *MockSchemaReader_Expecter) MultiTenancy(class interface{}) *MockSchemaReader_MultiTenancy_Call {
+	return &MockSchemaReader_MultiTenancy_Call{Call: _e.mock.On("MultiTenancy", class)}
+}
+
+func (_c *MockSchemaReader_MultiTenancy_Call) Run(run func(class string)) *MockSchemaReader_MultiTenancy_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_MultiTenancy_Call) Return(_a0 models.MultiTenancyConfig) *MockSchemaReader_MultiTenancy_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_MultiTenancy_Call) RunAndReturn(run func(string) models.MultiTenancyConfig) *MockSchemaReader_MultiTenancy_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MultiTenancyWithVersion provides a mock function with given fields: ctx, class, version
+func (_m *MockSchemaReader) MultiTenancyWithVersion(ctx context.Context, class string, version uint64) (models.MultiTenancyConfig, error) {
+	ret := _m.Called(ctx, class, version)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MultiTenancyWithVersion")
+	}
+
+	var r0 models.MultiTenancyConfig
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, uint64) (models.MultiTenancyConfig, error)); ok {
+		return rf(ctx, class, version)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, uint64) models.MultiTenancyConfig); ok {
+		r0 = rf(ctx, class, version)
+	} else {
+		r0 = ret.Get(0).(models.MultiTenancyConfig)
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, uint64) error); ok {
+		r1 = rf(ctx, class, version)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_MultiTenancyWithVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiTenancyWithVersion'
+type MockSchemaReader_MultiTenancyWithVersion_Call struct {
+	*mock.Call
+}
+
+// MultiTenancyWithVersion is a helper method to define mock.On call
+//   - ctx context.Context
+//   - class string
+//   - version uint64
+func (_e *MockSchemaReader_Expecter) MultiTenancyWithVersion(ctx interface{}, class interface{}, version interface{}) *MockSchemaReader_MultiTenancyWithVersion_Call {
+	return &MockSchemaReader_MultiTenancyWithVersion_Call{Call: _e.mock.On("MultiTenancyWithVersion", ctx, class, version)}
+}
+
+func (_c *MockSchemaReader_MultiTenancyWithVersion_Call) Run(run func(ctx context.Context, class string, version uint64)) *MockSchemaReader_MultiTenancyWithVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(uint64))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_MultiTenancyWithVersion_Call) Return(_a0 models.MultiTenancyConfig, _a1 error) *MockSchemaReader_MultiTenancyWithVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_MultiTenancyWithVersion_Call) RunAndReturn(run func(context.Context, string, uint64) (models.MultiTenancyConfig, error)) *MockSchemaReader_MultiTenancyWithVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Read provides a mock function with given fields: class, reader
+func (_m *MockSchemaReader) Read(class string, reader func(*models.Class, *sharding.State) error) error {
+	ret := _m.Called(class, reader)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Read")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, func(*models.Class, *sharding.State) error) error); ok {
+		r0 = rf(class, reader)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
+type MockSchemaReader_Read_Call struct {
+	*mock.Call
+}
+
+// Read is a helper method to define mock.On call
+//   - class string
+//   - reader func(*models.Class , *sharding.State) error
+func (_e *MockSchemaReader_Expecter) Read(class interface{}, reader interface{}) *MockSchemaReader_Read_Call {
+	return &MockSchemaReader_Read_Call{Call: _e.mock.On("Read", class, reader)}
+}
+
+func (_c *MockSchemaReader_Read_Call) Run(run func(class string, reader func(*models.Class, *sharding.State) error)) *MockSchemaReader_Read_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(func(*models.Class, *sharding.State) error))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_Read_Call) Return(_a0 error) *MockSchemaReader_Read_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_Read_Call) RunAndReturn(run func(string, func(*models.Class, *sharding.State) error) error) *MockSchemaReader_Read_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReadOnlyClass provides a mock function with given fields: name
+func (_m *MockSchemaReader) ReadOnlyClass(name string) *models.Class {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReadOnlyClass")
+	}
+
+	var r0 *models.Class
+	if rf, ok := ret.Get(0).(func(string) *models.Class); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*models.Class)
+		}
+	}
+
+	return r0
+}
+
+// MockSchemaReader_ReadOnlyClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOnlyClass'
+type MockSchemaReader_ReadOnlyClass_Call struct {
+	*mock.Call
+}
+
+// ReadOnlyClass is a helper method to define mock.On call
+//   - name string
+func (_e *MockSchemaReader_Expecter) ReadOnlyClass(name interface{}) *MockSchemaReader_ReadOnlyClass_Call {
+	return &MockSchemaReader_ReadOnlyClass_Call{Call: _e.mock.On("ReadOnlyClass", name)}
+}
+
+func (_c *MockSchemaReader_ReadOnlyClass_Call) Run(run func(name string)) *MockSchemaReader_ReadOnlyClass_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ReadOnlyClass_Call) Return(_a0 *models.Class) *MockSchemaReader_ReadOnlyClass_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_ReadOnlyClass_Call) RunAndReturn(run func(string) *models.Class) *MockSchemaReader_ReadOnlyClass_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReadOnlyClassWithVersion provides a mock function with given fields: ctx, class, version
+func (_m *MockSchemaReader) ReadOnlyClassWithVersion(ctx context.Context, class string, version uint64) (*models.Class, error) {
+	ret := _m.Called(ctx, class, version)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReadOnlyClassWithVersion")
+	}
+
+	var r0 *models.Class
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, uint64) (*models.Class, error)); ok {
+		return rf(ctx, class, version)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, uint64) *models.Class); ok {
+		r0 = rf(ctx, class, version)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*models.Class)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, uint64) error); ok {
+		r1 = rf(ctx, class, version)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_ReadOnlyClassWithVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOnlyClassWithVersion'
+type MockSchemaReader_ReadOnlyClassWithVersion_Call struct {
+	*mock.Call
+}
+
+// ReadOnlyClassWithVersion is a helper method to define mock.On call
+//   - ctx context.Context
+//   - class string
+//   - version uint64
+func (_e *MockSchemaReader_Expecter) ReadOnlyClassWithVersion(ctx interface{}, class interface{}, version interface{}) *MockSchemaReader_ReadOnlyClassWithVersion_Call {
+	return &MockSchemaReader_ReadOnlyClassWithVersion_Call{Call: _e.mock.On("ReadOnlyClassWithVersion", ctx, class, version)}
+}
+
+func (_c *MockSchemaReader_ReadOnlyClassWithVersion_Call) Run(run func(ctx context.Context, class string, version uint64)) *MockSchemaReader_ReadOnlyClassWithVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(uint64))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ReadOnlyClassWithVersion_Call) Return(_a0 *models.Class, _a1 error) *MockSchemaReader_ReadOnlyClassWithVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_ReadOnlyClassWithVersion_Call) RunAndReturn(run func(context.Context, string, uint64) (*models.Class, error)) *MockSchemaReader_ReadOnlyClassWithVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReadOnlySchema provides a mock function with no fields
+func (_m *MockSchemaReader) ReadOnlySchema() models.Schema {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReadOnlySchema")
+	}
+
+	var r0 models.Schema
+	if rf, ok := ret.Get(0).(func() models.Schema); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(models.Schema)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_ReadOnlySchema_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOnlySchema'
+type MockSchemaReader_ReadOnlySchema_Call struct {
+	*mock.Call
+}
+
+// ReadOnlySchema is a helper method to define mock.On call
+func (_e *MockSchemaReader_Expecter) ReadOnlySchema() *MockSchemaReader_ReadOnlySchema_Call {
+	return &MockSchemaReader_ReadOnlySchema_Call{Call: _e.mock.On("ReadOnlySchema")}
+}
+
+func (_c *MockSchemaReader_ReadOnlySchema_Call) Run(run func()) *MockSchemaReader_ReadOnlySchema_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ReadOnlySchema_Call) Return(_a0 models.Schema) *MockSchemaReader_ReadOnlySchema_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_ReadOnlySchema_Call) RunAndReturn(run func() models.Schema) *MockSchemaReader_ReadOnlySchema_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReadOnlyVersionedClass provides a mock function with given fields: name
+func (_m *MockSchemaReader) ReadOnlyVersionedClass(name string) versioned.Class {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReadOnlyVersionedClass")
+	}
+
+	var r0 versioned.Class
+	if rf, ok := ret.Get(0).(func(string) versioned.Class); ok {
+		r0 = rf(name)
+	} else {
+		r0 = ret.Get(0).(versioned.Class)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_ReadOnlyVersionedClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOnlyVersionedClass'
+type MockSchemaReader_ReadOnlyVersionedClass_Call struct {
+	*mock.Call
+}
+
+// ReadOnlyVersionedClass is a helper method to define mock.On call
+//   - name string
+func (_e *MockSchemaReader_Expecter) ReadOnlyVersionedClass(name interface{}) *MockSchemaReader_ReadOnlyVersionedClass_Call {
+	return &MockSchemaReader_ReadOnlyVersionedClass_Call{Call: _e.mock.On("ReadOnlyVersionedClass", name)}
+}
+
+func (_c *MockSchemaReader_ReadOnlyVersionedClass_Call) Run(run func(name string)) *MockSchemaReader_ReadOnlyVersionedClass_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ReadOnlyVersionedClass_Call) Return(_a0 versioned.Class) *MockSchemaReader_ReadOnlyVersionedClass_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_ReadOnlyVersionedClass_Call) RunAndReturn(run func(string) versioned.Class) *MockSchemaReader_ReadOnlyVersionedClass_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ResolveAlias provides a mock function with given fields: alias
+func (_m *MockSchemaReader) ResolveAlias(alias string) string {
+	ret := _m.Called(alias)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ResolveAlias")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(string) string); ok {
+		r0 = rf(alias)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_ResolveAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveAlias'
+type MockSchemaReader_ResolveAlias_Call struct {
+	*mock.Call
+}
+
+// ResolveAlias is a helper method to define mock.On call
+//   - alias string
+func (_e *MockSchemaReader_Expecter) ResolveAlias(alias interface{}) *MockSchemaReader_ResolveAlias_Call {
+	return &MockSchemaReader_ResolveAlias_Call{Call: _e.mock.On("ResolveAlias", alias)}
+}
+
+func (_c *MockSchemaReader_ResolveAlias_Call) Run(run func(alias string)) *MockSchemaReader_ResolveAlias_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ResolveAlias_Call) Return(_a0 string) *MockSchemaReader_ResolveAlias_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_ResolveAlias_Call) RunAndReturn(run func(string) string) *MockSchemaReader_ResolveAlias_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardFromUUID provides a mock function with given fields: class, uuid
+func (_m *MockSchemaReader) ShardFromUUID(class string, uuid []byte) string {
+	ret := _m.Called(class, uuid)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardFromUUID")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(string, []byte) string); ok {
+		r0 = rf(class, uuid)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_ShardFromUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardFromUUID'
+type MockSchemaReader_ShardFromUUID_Call struct {
+	*mock.Call
+}
+
+// ShardFromUUID is a helper method to define mock.On call
+//   - class string
+//   - uuid []byte
+func (_e *MockSchemaReader_Expecter) ShardFromUUID(class interface{}, uuid interface{}) *MockSchemaReader_ShardFromUUID_Call {
+	return &MockSchemaReader_ShardFromUUID_Call{Call: _e.mock.On("ShardFromUUID", class, uuid)}
+}
+
+func (_c *MockSchemaReader_ShardFromUUID_Call) Run(run func(class string, uuid []byte)) *MockSchemaReader_ShardFromUUID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].([]byte))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardFromUUID_Call) Return(_a0 string) *MockSchemaReader_ShardFromUUID_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardFromUUID_Call) RunAndReturn(run func(string, []byte) string) *MockSchemaReader_ShardFromUUID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardFromUUIDWithVersion provides a mock function with given fields: ctx, class, uuid, version
+func (_m *MockSchemaReader) ShardFromUUIDWithVersion(ctx context.Context, class string, uuid []byte, version uint64) (string, error) {
+	ret := _m.Called(ctx, class, uuid, version)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardFromUUIDWithVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, []byte, uint64) (string, error)); ok {
+		return rf(ctx, class, uuid, version)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, []byte, uint64) string); ok {
+		r0 = rf(ctx, class, uuid, version)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, []byte, uint64) error); ok {
+		r1 = rf(ctx, class, uuid, version)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_ShardFromUUIDWithVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardFromUUIDWithVersion'
+type MockSchemaReader_ShardFromUUIDWithVersion_Call struct {
+	*mock.Call
+}
+
+// ShardFromUUIDWithVersion is a helper method to define mock.On call
+//   - ctx context.Context
+//   - class string
+//   - uuid []byte
+//   - version uint64
+func (_e *MockSchemaReader_Expecter) ShardFromUUIDWithVersion(ctx interface{}, class interface{}, uuid interface{}, version interface{}) *MockSchemaReader_ShardFromUUIDWithVersion_Call {
+	return &MockSchemaReader_ShardFromUUIDWithVersion_Call{Call: _e.mock.On("ShardFromUUIDWithVersion", ctx, class, uuid, version)}
+}
+
+func (_c *MockSchemaReader_ShardFromUUIDWithVersion_Call) Run(run func(ctx context.Context, class string, uuid []byte, version uint64)) *MockSchemaReader_ShardFromUUIDWithVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].([]byte), args[3].(uint64))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardFromUUIDWithVersion_Call) Return(_a0 string, _a1 error) *MockSchemaReader_ShardFromUUIDWithVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardFromUUIDWithVersion_Call) RunAndReturn(run func(context.Context, string, []byte, uint64) (string, error)) *MockSchemaReader_ShardFromUUIDWithVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardOwner provides a mock function with given fields: class, shard
+func (_m *MockSchemaReader) ShardOwner(class string, shard string) (string, error) {
+	ret := _m.Called(class, shard)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardOwner")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (string, error)); ok {
+		return rf(class, shard)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) string); ok {
+		r0 = rf(class, shard)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(class, shard)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_ShardOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardOwner'
+type MockSchemaReader_ShardOwner_Call struct {
+	*mock.Call
+}
+
+// ShardOwner is a helper method to define mock.On call
+//   - class string
+//   - shard string
+func (_e *MockSchemaReader_Expecter) ShardOwner(class interface{}, shard interface{}) *MockSchemaReader_ShardOwner_Call {
+	return &MockSchemaReader_ShardOwner_Call{Call: _e.mock.On("ShardOwner", class, shard)}
+}
+
+func (_c *MockSchemaReader_ShardOwner_Call) Run(run func(class string, shard string)) *MockSchemaReader_ShardOwner_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardOwner_Call) Return(_a0 string, _a1 error) *MockSchemaReader_ShardOwner_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardOwner_Call) RunAndReturn(run func(string, string) (string, error)) *MockSchemaReader_ShardOwner_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardOwnerWithVersion provides a mock function with given fields: ctx, lass, shard, version
+func (_m *MockSchemaReader) ShardOwnerWithVersion(ctx context.Context, lass string, shard string, version uint64) (string, error) {
+	ret := _m.Called(ctx, lass, shard, version)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardOwnerWithVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, uint64) (string, error)); ok {
+		return rf(ctx, lass, shard, version)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, uint64) string); ok {
+		r0 = rf(ctx, lass, shard, version)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, string, uint64) error); ok {
+		r1 = rf(ctx, lass, shard, version)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_ShardOwnerWithVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardOwnerWithVersion'
+type MockSchemaReader_ShardOwnerWithVersion_Call struct {
+	*mock.Call
+}
+
+// ShardOwnerWithVersion is a helper method to define mock.On call
+//   - ctx context.Context
+//   - lass string
+//   - shard string
+//   - version uint64
+func (_e *MockSchemaReader_Expecter) ShardOwnerWithVersion(ctx interface{}, lass interface{}, shard interface{}, version interface{}) *MockSchemaReader_ShardOwnerWithVersion_Call {
+	return &MockSchemaReader_ShardOwnerWithVersion_Call{Call: _e.mock.On("ShardOwnerWithVersion", ctx, lass, shard, version)}
+}
+
+func (_c *MockSchemaReader_ShardOwnerWithVersion_Call) Run(run func(ctx context.Context, lass string, shard string, version uint64)) *MockSchemaReader_ShardOwnerWithVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(uint64))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardOwnerWithVersion_Call) Return(_a0 string, _a1 error) *MockSchemaReader_ShardOwnerWithVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardOwnerWithVersion_Call) RunAndReturn(run func(context.Context, string, string, uint64) (string, error)) *MockSchemaReader_ShardOwnerWithVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardReplicas provides a mock function with given fields: class, shard
+func (_m *MockSchemaReader) ShardReplicas(class string, shard string) ([]string, error) {
+	ret := _m.Called(class, shard)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardReplicas")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) ([]string, error)); ok {
+		return rf(class, shard)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) []string); ok {
+		r0 = rf(class, shard)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(class, shard)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_ShardReplicas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardReplicas'
+type MockSchemaReader_ShardReplicas_Call struct {
+	*mock.Call
+}
+
+// ShardReplicas is a helper method to define mock.On call
+//   - class string
+//   - shard string
+func (_e *MockSchemaReader_Expecter) ShardReplicas(class interface{}, shard interface{}) *MockSchemaReader_ShardReplicas_Call {
+	return &MockSchemaReader_ShardReplicas_Call{Call: _e.mock.On("ShardReplicas", class, shard)}
+}
+
+func (_c *MockSchemaReader_ShardReplicas_Call) Run(run func(class string, shard string)) *MockSchemaReader_ShardReplicas_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardReplicas_Call) Return(_a0 []string, _a1 error) *MockSchemaReader_ShardReplicas_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardReplicas_Call) RunAndReturn(run func(string, string) ([]string, error)) *MockSchemaReader_ShardReplicas_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ShardReplicasWithVersion provides a mock function with given fields: ctx, class, shard, version
+func (_m *MockSchemaReader) ShardReplicasWithVersion(ctx context.Context, class string, shard string, version uint64) ([]string, error) {
+	ret := _m.Called(ctx, class, shard, version)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ShardReplicasWithVersion")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, uint64) ([]string, error)); ok {
+		return rf(ctx, class, shard, version)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, uint64) []string); ok {
+		r0 = rf(ctx, class, shard, version)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, string, uint64) error); ok {
+		r1 = rf(ctx, class, shard, version)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_ShardReplicasWithVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShardReplicasWithVersion'
+type MockSchemaReader_ShardReplicasWithVersion_Call struct {
+	*mock.Call
+}
+
+// ShardReplicasWithVersion is a helper method to define mock.On call
+//   - ctx context.Context
+//   - class string
+//   - shard string
+//   - version uint64
+func (_e *MockSchemaReader_Expecter) ShardReplicasWithVersion(ctx interface{}, class interface{}, shard interface{}, version interface{}) *MockSchemaReader_ShardReplicasWithVersion_Call {
+	return &MockSchemaReader_ShardReplicasWithVersion_Call{Call: _e.mock.On("ShardReplicasWithVersion", ctx, class, shard, version)}
+}
+
+func (_c *MockSchemaReader_ShardReplicasWithVersion_Call) Run(run func(ctx context.Context, class string, shard string, version uint64)) *MockSchemaReader_ShardReplicasWithVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(uint64))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardReplicasWithVersion_Call) Return(_a0 []string, _a1 error) *MockSchemaReader_ShardReplicasWithVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_ShardReplicasWithVersion_Call) RunAndReturn(run func(context.Context, string, string, uint64) ([]string, error)) *MockSchemaReader_ShardReplicasWithVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Shards provides a mock function with given fields: class
+func (_m *MockSchemaReader) Shards(class string) ([]string, error) {
+	ret := _m.Called(class)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Shards")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]string, error)); ok {
+		return rf(class)
+	}
+	if rf, ok := ret.Get(0).(func(string) []string); ok {
+		r0 = rf(class)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(class)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_Shards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shards'
+type MockSchemaReader_Shards_Call struct {
+	*mock.Call
+}
+
+// Shards is a helper method to define mock.On call
+//   - class string
+func (_e *MockSchemaReader_Expecter) Shards(class interface{}) *MockSchemaReader_Shards_Call {
+	return &MockSchemaReader_Shards_Call{Call: _e.mock.On("Shards", class)}
+}
+
+func (_c *MockSchemaReader_Shards_Call) Run(run func(class string)) *MockSchemaReader_Shards_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_Shards_Call) Return(_a0 []string, _a1 error) *MockSchemaReader_Shards_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_Shards_Call) RunAndReturn(run func(string) ([]string, error)) *MockSchemaReader_Shards_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// TenantsShardsWithVersion provides a mock function with given fields: ctx, version, class, tenants
+func (_m *MockSchemaReader) TenantsShardsWithVersion(ctx context.Context, version uint64, class string, tenants ...string) (map[string]string, error) {
+	_va := make([]interface{}, len(tenants))
+	for _i := range tenants {
+		_va[_i] = tenants[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, version, class)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for TenantsShardsWithVersion")
+	}
+
+	var r0 map[string]string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, uint64, string, ...string) (map[string]string, error)); ok {
+		return rf(ctx, version, class, tenants...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, uint64, string, ...string) map[string]string); ok {
+		r0 = rf(ctx, version, class, tenants...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, uint64, string, ...string) error); ok {
+		r1 = rf(ctx, version, class, tenants...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSchemaReader_TenantsShardsWithVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TenantsShardsWithVersion'
+type MockSchemaReader_TenantsShardsWithVersion_Call struct {
+	*mock.Call
+}
+
+// TenantsShardsWithVersion is a helper method to define mock.On call
+//   - ctx context.Context
+//   - version uint64
+//   - class string
+//   - tenants ...string
+func (_e *MockSchemaReader_Expecter) TenantsShardsWithVersion(ctx interface{}, version interface{}, class interface{}, tenants ...interface{}) *MockSchemaReader_TenantsShardsWithVersion_Call {
+	return &MockSchemaReader_TenantsShardsWithVersion_Call{Call: _e.mock.On("TenantsShardsWithVersion",
+		append([]interface{}{ctx, version, class}, tenants...)...)}
+}
+
+func (_c *MockSchemaReader_TenantsShardsWithVersion_Call) Run(run func(ctx context.Context, version uint64, class string, tenants ...string)) *MockSchemaReader_TenantsShardsWithVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-3)
+		for i, a := range args[3:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(args[0].(context.Context), args[1].(uint64), args[2].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_TenantsShardsWithVersion_Call) Return(_a0 map[string]string, _a1 error) *MockSchemaReader_TenantsShardsWithVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSchemaReader_TenantsShardsWithVersion_Call) RunAndReturn(run func(context.Context, uint64, string, ...string) (map[string]string, error)) *MockSchemaReader_TenantsShardsWithVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// WaitForUpdate provides a mock function with given fields: ctx, version
+func (_m *MockSchemaReader) WaitForUpdate(ctx context.Context, version uint64) error {
+	ret := _m.Called(ctx, version)
+
+	if len(ret) == 0 {
+		panic("no return value specified for WaitForUpdate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, uint64) error); ok {
+		r0 = rf(ctx, version)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockSchemaReader_WaitForUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitForUpdate'
+type MockSchemaReader_WaitForUpdate_Call struct {
+	*mock.Call
+}
+
+// WaitForUpdate is a helper method to define mock.On call
+//   - ctx context.Context
+//   - version uint64
+func (_e *MockSchemaReader_Expecter) WaitForUpdate(ctx interface{}, version interface{}) *MockSchemaReader_WaitForUpdate_Call {
+	return &MockSchemaReader_WaitForUpdate_Call{Call: _e.mock.On("WaitForUpdate", ctx, version)}
+}
+
+func (_c *MockSchemaReader_WaitForUpdate_Call) Run(run func(ctx context.Context, version uint64)) *MockSchemaReader_WaitForUpdate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64))
+	})
+	return _c
+}
+
+func (_c *MockSchemaReader_WaitForUpdate_Call) Return(_a0 error) *MockSchemaReader_WaitForUpdate_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSchemaReader_WaitForUpdate_Call) RunAndReturn(run func(context.Context, uint64) error) *MockSchemaReader_WaitForUpdate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockSchemaReader creates a new instance of MockSchemaReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSchemaReader(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSchemaReader {
+	mock := &MockSchemaReader{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

platform/dbops/binaries/weaviate-src/usecases/schema/parser.go

@@ -0,0 +1,581 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/modelsext"
+	"github.com/weaviate/weaviate/entities/schema"
+	schemaConfig "github.com/weaviate/weaviate/entities/schema/config"
+	"github.com/weaviate/weaviate/entities/vectorindex"
+	"github.com/weaviate/weaviate/usecases/config"
+	configRuntime "github.com/weaviate/weaviate/usecases/config/runtime"
+	shardingConfig "github.com/weaviate/weaviate/usecases/sharding/config"
+)
+
+var errPropertiesUpdatedInClassUpdate = errors.Errorf(
+	"property fields other than description cannot be updated through updating the class. Use the add " +
+		"property feature (e.g. \"POST /v1/schema/{className}/properties\") " +
+		"to add additional properties")
+
+type modulesProvider interface {
+	IsGenerative(string) bool
+	IsReranker(string) bool
+	IsMultiVector(string) bool
+}
+
+type Parser struct {
+	clusterState        clusterState
+	configParser        VectorConfigParser
+	validator           validator
+	modules             modulesProvider
+	defaultQuantization *configRuntime.DynamicValue[string]
+}
+
+func NewParser(cs clusterState, vCfg VectorConfigParser, v validator, modules modulesProvider, defaultQuantization *configRuntime.DynamicValue[string]) *Parser {
+	return &Parser{
+		clusterState:        cs,
+		configParser:        vCfg,
+		validator:           v,
+		modules:             modules,
+		defaultQuantization: defaultQuantization,
+	}
+}
+
+func (p *Parser) ParseClass(class *models.Class) error {
+	if class == nil {
+		return fmt.Errorf("class cannot be nil")
+	}
+
+	if strings.EqualFold(class.Class, config.DefaultRaftDir) {
+		return fmt.Errorf("parse class name: %w", fmt.Errorf("class name `raft` is reserved"))
+	}
+
+	if err := p.parseShardingConfig(class); err != nil {
+		return fmt.Errorf("parse sharding config: %w", err)
+	}
+
+	if err := p.parseVectorIndexConfig(class); err != nil {
+		return fmt.Errorf("parse vector index config: %w", err)
+	}
+
+	return nil
+}
+
+func (p *Parser) parseModuleConfig(class *models.Class) error {
+	if class.ModuleConfig == nil {
+		return nil
+	}
+
+	mapMC, ok := class.ModuleConfig.(map[string]any)
+	if !ok {
+		return fmt.Errorf("module config is not a map, got %v", class.ModuleConfig)
+	}
+
+	mc, err := p.moduleConfig(mapMC)
+	if err != nil {
+		return fmt.Errorf("module config: %w", err)
+	}
+	class.ModuleConfig = mc
+
+	return nil
+}
+
+func (p *Parser) parseVectorConfig(class *models.Class) error {
+	if class.VectorConfig == nil {
+		return nil
+	}
+
+	newVC := map[string]models.VectorConfig{}
+	for vector, config := range class.VectorConfig {
+		mapMC, ok := config.Vectorizer.(map[string]any)
+		if !ok {
+			return fmt.Errorf("vectorizer for %s is not a map, got %v", vector, config)
+		}
+
+		mc, err := p.moduleConfig(mapMC)
+		if err != nil {
+			return fmt.Errorf("vectorizer config: %w", err)
+		}
+
+		config.Vectorizer = mc
+		newVC[vector] = config
+	}
+	class.VectorConfig = newVC
+	return nil
+}
+
+func (p *Parser) moduleConfig(moduleConfig map[string]any) (map[string]any, error) {
+	parsedMC := map[string]any{}
+	for module, config := range moduleConfig {
+		if config == nil {
+			parsedMC[module] = nil // nil is allowed, do no further parsing
+			continue
+		}
+		mapC, ok := config.(map[string]any)
+		if !ok {
+			return nil, fmt.Errorf("module config for %s is not a map, got %v", module, config)
+		}
+		parsedC := map[string]any{}
+		// raft interprets all `json.Number` types as float64 when unmarshalling
+		// we parse them explicitly here so that UpdateClass can compare the new class
+		// with the old one read from the raft schema manager
+		for key, value := range mapC {
+			if number, ok := value.(json.Number); ok {
+				if integer, err := number.Int64(); err == nil {
+					parsedC[key] = float64(integer)
+				} else if float, err := number.Float64(); err == nil {
+					parsedC[key] = float
+				} else {
+					parsedC[key] = number.String()
+				}
+				continue
+			}
+			parsedC[key] = value
+		}
+		parsedMC[module] = parsedC
+	}
+	return parsedMC, nil
+}
+
+func (p *Parser) parseVectorIndexConfig(class *models.Class) error {
+	if !hasTargetVectors(class) || class.VectorIndexType != "" {
+		parsed, err := p.parseGivenVectorIndexConfig(class.VectorIndexType, class.VectorIndexConfig, p.modules.IsMultiVector(class.Vectorizer), p.defaultQuantization)
+		if err != nil {
+			return err
+		}
+		if parsed.IsMultiVector() {
+			return fmt.Errorf("class.VectorIndexConfig multi vector type index type is only configurable using named vectors")
+		}
+		class.VectorIndexConfig = parsed
+	}
+
+	if err := p.parseTargetVectorsIndexConfig(class); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (p *Parser) parseShardingConfig(class *models.Class) (err error) {
+	// multiTenancyConfig and shardingConfig are mutually exclusive
+	cfg := shardingConfig.Config{} // cfg is empty in case of MT
+	if !schema.MultiTenancyEnabled(class) {
+		cfg, err = shardingConfig.ParseConfig(class.ShardingConfig, p.clusterState.NodeCount())
+		if err != nil {
+			return err
+		}
+
+	}
+	class.ShardingConfig = cfg
+	return nil
+}
+
+func (p *Parser) parseTargetVectorsIndexConfig(class *models.Class) error {
+	for targetVector, vectorConfig := range class.VectorConfig {
+		isMultiVector := false
+		vectorizerModuleName := ""
+		if vectorizer, ok := vectorConfig.Vectorizer.(map[string]interface{}); ok {
+			for name := range vectorizer {
+				isMultiVector = p.modules.IsMultiVector(name)
+				vectorizerModuleName = name
+			}
+		}
+		parsed, err := p.parseGivenVectorIndexConfig(vectorConfig.VectorIndexType, vectorConfig.VectorIndexConfig, isMultiVector, p.defaultQuantization)
+		if err != nil {
+			return fmt.Errorf("parse vector config for %s: %w", targetVector, err)
+		}
+		if parsed.IsMultiVector() && vectorizerModuleName != "none" && !isMultiVector {
+			return fmt.Errorf("parse vector config for %s: multi vector index configured but vectorizer: %q doesn't support multi vectors", targetVector, vectorizerModuleName)
+		}
+		vectorConfig.VectorIndexConfig = parsed
+		class.VectorConfig[targetVector] = vectorConfig
+	}
+	return nil
+}
+
+func (p *Parser) parseGivenVectorIndexConfig(vectorIndexType string,
+	vectorIndexConfig interface{}, isMultiVector bool, defaultQuantization *configRuntime.DynamicValue[string],
+) (schemaConfig.VectorIndexConfig, error) {
+	if vectorIndexType != vectorindex.VectorIndexTypeHNSW && vectorIndexType != vectorindex.VectorIndexTypeFLAT && vectorIndexType != vectorindex.VectorIndexTypeDYNAMIC {
+		return nil, errors.Errorf(
+			"parse vector index config: unsupported vector index type: %q",
+			vectorIndexType)
+	}
+
+	if vectorIndexType != vectorindex.VectorIndexTypeHNSW && isMultiVector {
+		return nil, errors.Errorf(
+			"parse vector index config: multi vector index is not supported for vector index type: %q, only supported type is hnsw",
+			vectorIndexType)
+	}
+
+	parsed, err := p.configParser(vectorIndexConfig, vectorIndexType, isMultiVector)
+	if err != nil {
+		return nil, errors.Wrap(err, "parse vector index config")
+	}
+	return parsed, nil
+}
+
+// ParseClassUpdate parses a class after unmarshaling by setting concrete types for the fields
+func (p *Parser) ParseClassUpdate(class, update *models.Class) (*models.Class, error) {
+	if err := p.ParseClass(update); err != nil {
+		return nil, err
+	}
+	mtEnabled, err := validateUpdatingMT(class, update)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := validateImmutableFields(class, update); err != nil {
+		return nil, err
+	}
+
+	if err := p.validateModuleConfigsParityAndImmutables(class, update); err != nil {
+		return nil, err
+	}
+
+	// run target vectors validation first, as it will reject classes
+	// where legacy vector was changed to target vectors and vice versa
+	if err = p.validateNamedVectorConfigsParityAndImmutables(class, update); err != nil {
+		return nil, err
+	}
+
+	if err = validateLegacyVectorIndexConfigImmutableFields(class, update); err != nil {
+		return nil, err
+	}
+
+	if class.VectorIndexConfig != nil || update.VectorIndexConfig != nil {
+		vIdxConfig, ok1 := class.VectorIndexConfig.(schemaConfig.VectorIndexConfig)
+		vIdxConfigU, ok2 := update.VectorIndexConfig.(schemaConfig.VectorIndexConfig)
+		if !ok1 || !ok2 {
+			return nil, fmt.Errorf("vector index config wrong type: current=%t new=%t", ok1, ok2)
+		}
+		if err := p.validator.ValidateVectorIndexConfigUpdate(vIdxConfig, vIdxConfigU); err != nil {
+			return nil, fmt.Errorf("validate vector index config: %w", err)
+		}
+	}
+
+	if hasTargetVectors(update) {
+		if err := p.validator.ValidateVectorIndexConfigsUpdate(
+			asVectorIndexConfigs(class), asVectorIndexConfigs(update)); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := validateShardingConfig(class, update, mtEnabled); err != nil {
+		return nil, fmt.Errorf("validate sharding config: %w", err)
+	}
+
+	if err = p.validatePropertiesForUpdate(class.Properties, update.Properties); err != nil {
+		return nil, err
+	}
+
+	if err := p.validator.ValidateInvertedIndexConfigUpdate(
+		class.InvertedIndexConfig,
+		update.InvertedIndexConfig); err != nil {
+		return nil, fmt.Errorf("inverted index config: %w", err)
+	}
+
+	return update, nil
+}
+
+func (p *Parser) validatePropertiesForUpdate(existing []*models.Property, new []*models.Property) error {
+	if len(existing) != len(new) {
+		return errPropertiesUpdatedInClassUpdate
+	}
+
+	sort.Slice(existing, func(i, j int) bool {
+		return existing[i].Name < existing[j].Name
+	})
+
+	sort.Slice(new, func(i, j int) bool {
+		return new[i].Name < new[j].Name
+	})
+
+	for i, prop := range existing {
+		// make a copy of the properties to remove the description field
+		// so that we can compare the rest of the fields
+		if prop == nil {
+			continue
+		}
+		if new[i] == nil {
+			continue
+		}
+
+		if err := p.validatePropertyForUpdate(prop, new[i]); err != nil {
+			return errors.Wrapf(err, "property %q", prop.Name)
+		}
+	}
+
+	return nil
+}
+
+func propertyAsMap(in any) (map[string]any, error) {
+	out := make(map[string]any)
+
+	v := reflect.ValueOf(in)
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+
+	if v.Kind() != reflect.Struct { // Non-structural return error
+		return nil, fmt.Errorf("asMap only accepts struct or struct pointer; got %T", v)
+	}
+
+	t := v.Type()
+	// Traversing structure fields
+	// Specify the tagName value as the key in the map; the field value as the value in the map
+	for i := 0; i < v.NumField(); i++ {
+		tfi := t.Field(i)
+		if tagValue := tfi.Tag.Get("json"); tagValue != "" {
+			key := strings.Split(tagValue, ",")[0]
+			if key == "description" {
+				continue
+			}
+			if key == "nestedProperties" {
+				nps := v.Field(i).Interface().([]*models.NestedProperty)
+				out[key] = make([]map[string]any, 0, len(nps))
+				for _, np := range nps {
+					npm, err := propertyAsMap(np)
+					if err != nil {
+						return nil, err
+					}
+					out[key] = append(out[key].([]map[string]any), npm)
+				}
+				continue
+			}
+			out[key] = v.Field(i).Interface()
+		}
+	}
+	return out, nil
+}
+
+func (p *Parser) validatePropertyForUpdate(existing, new *models.Property) error {
+	e, err := propertyAsMap(existing)
+	if err != nil {
+		return errors.Wrap(err, "converting existing properties to a map")
+	}
+
+	n, err := propertyAsMap(new)
+	if err != nil {
+		return errors.Wrap(err, "converting new properties to a map")
+	}
+
+	var (
+		existingModuleConfig = cutModuleConfig(e)
+		newModuleConfig      = cutModuleConfig(n)
+	)
+
+	for moduleName, existingCfg := range existingModuleConfig {
+		newCfg, ok := newModuleConfig[moduleName]
+		if !ok {
+			return errors.Errorf("module %q configuration was removed", moduleName)
+		}
+
+		if !reflect.DeepEqual(existingCfg, newCfg) {
+			return errors.Errorf("module %q configuration cannot be updated", moduleName)
+		}
+	}
+
+	if !reflect.DeepEqual(e, n) {
+		return errPropertiesUpdatedInClassUpdate
+	}
+
+	return nil
+}
+
+func cutModuleConfig(properties map[string]any) map[string]any {
+	cfg, _ := properties["moduleConfig"].(map[string]any)
+	delete(properties, "moduleConfig")
+	return cfg
+}
+
+func hasTargetVectors(class *models.Class) bool {
+	return len(class.VectorConfig) > 0
+}
+
+func (p *Parser) validateModuleConfigsParityAndImmutables(initial, updated *models.Class) error {
+	if updated.ModuleConfig == nil || reflect.DeepEqual(initial.ModuleConfig, updated.ModuleConfig) {
+		return nil
+	}
+
+	updatedModConf, ok := updated.ModuleConfig.(map[string]any)
+	if !ok {
+		return fmt.Errorf("module config for %s is not a map, got %v", updated.ModuleConfig, updated.ModuleConfig)
+	}
+
+	updatedModConf, err := p.moduleConfig(updatedModConf)
+	if err != nil {
+		return err
+	}
+
+	initialModConf, _ := initial.ModuleConfig.(map[string]any)
+
+	// this part:
+	// - allow adding new modules
+	// - only allows updating generative and rerankers
+	// - only one gen/rerank module can be present. Existing ones will be replaced, updating with more than one is not
+	//   allowed
+	// - other modules will not be changed. They can be present in the update if they have EXACTLY the same settings
+	hasGenerativeUpdate := false
+	hasRerankerUpdate := false
+	for module := range updatedModConf {
+		if p.modules.IsGenerative(module) {
+			if hasGenerativeUpdate {
+				return fmt.Errorf("updated moduleconfig has multiple generative modules: %v", updatedModConf)
+			}
+			hasGenerativeUpdate = true
+			continue
+		}
+
+		if p.modules.IsReranker(module) {
+			if hasRerankerUpdate {
+				return fmt.Errorf("updated moduleconfig has multiple reranker modules: %v", updatedModConf)
+			}
+			hasRerankerUpdate = true
+			continue
+		}
+
+		if _, moduleExisted := initialModConf[module]; !moduleExisted {
+			continue
+		}
+
+		if reflect.DeepEqual(initialModConf[module], updatedModConf[module]) {
+			continue
+		}
+
+		return fmt.Errorf("can only update generative and reranker module configs. Got: %v", module)
+	}
+
+	if initial.ModuleConfig == nil {
+		initial.ModuleConfig = updatedModConf
+		return nil
+	}
+
+	if _, ok := initial.ModuleConfig.(map[string]any); !ok {
+		initial.ModuleConfig = updatedModConf
+		return nil
+	}
+	if hasGenerativeUpdate {
+		// clear out old generative module
+		for module := range initialModConf {
+			if p.modules.IsGenerative(module) {
+				delete(initialModConf, module)
+			}
+		}
+	}
+
+	if hasRerankerUpdate {
+		// clear out old reranker module
+		for module := range initialModConf {
+			if p.modules.IsReranker(module) {
+				delete(initialModConf, module)
+			}
+		}
+	}
+
+	for module := range updatedModConf {
+		initialModConf[module] = updatedModConf[module]
+	}
+	updated.ModuleConfig = initialModConf
+	return nil
+}
+
+func (p *Parser) validateNamedVectorConfigsParityAndImmutables(initial, updated *models.Class) error {
+	if modelsext.ClassHasLegacyVectorIndex(initial) {
+		for targetVector := range updated.VectorConfig {
+			if targetVector == modelsext.DefaultNamedVectorName {
+				return fmt.Errorf("vector named %s cannot be created when collection level vector index is configured", modelsext.DefaultNamedVectorName)
+			}
+		}
+	}
+
+	for vecName, initialCfg := range initial.VectorConfig {
+		updatedCfg, ok := updated.VectorConfig[vecName]
+		if !ok {
+			return fmt.Errorf("missing config for vector %q", vecName)
+		}
+
+		// immutable vector type
+		if initialCfg.VectorIndexType != updatedCfg.VectorIndexType {
+			return fmt.Errorf("vector index type of vector %q is immutable: attempted change from %q to %q",
+				vecName, initialCfg.VectorIndexType, updatedCfg.VectorIndexType)
+		}
+
+		// immutable vectorizer
+		if imap, ok := initialCfg.Vectorizer.(map[string]interface{}); ok && len(imap) == 1 {
+			umap, ok := updatedCfg.Vectorizer.(map[string]interface{})
+			if !ok || len(umap) != 1 {
+				return fmt.Errorf("invalid vectorizer config for vector %q", vecName)
+			}
+
+			ivectorizer := ""
+			for k := range imap {
+				ivectorizer = k
+			}
+			uvectorizer := ""
+			for k := range umap {
+				uvectorizer = k
+			}
+
+			if ivectorizer != uvectorizer {
+				return fmt.Errorf("vectorizer of vector %q is immutable: attempted change from %q to %q",
+					vecName, ivectorizer, uvectorizer)
+			}
+		}
+	}
+	return nil
+}
+
+func asVectorIndexConfigs(c *models.Class) map[string]schemaConfig.VectorIndexConfig {
+	if c.VectorConfig == nil {
+		return nil
+	}
+
+	cfgs := map[string]schemaConfig.VectorIndexConfig{}
+	for vecName := range c.VectorConfig {
+		cfgs[vecName] = c.VectorConfig[vecName].VectorIndexConfig.(schemaConfig.VectorIndexConfig)
+	}
+	return cfgs
+}
+
+func validateShardingConfig(current, update *models.Class, mtEnabled bool) error {
+	if mtEnabled {
+		return nil
+	}
+	first, ok := current.ShardingConfig.(shardingConfig.Config)
+	if !ok {
+		return fmt.Errorf("current config is not well-formed")
+	}
+	second, ok := update.ShardingConfig.(shardingConfig.Config)
+	if !ok {
+		return fmt.Errorf("updated config is not well-formed")
+	}
+	if first.DesiredCount != second.DesiredCount {
+		return fmt.Errorf("re-sharding not supported yet: shard count is immutable: "+
+			"attempted change from \"%d\" to \"%d\"", first.DesiredCount,
+			second.DesiredCount)
+	}
+
+	if first.VirtualPerPhysical != second.VirtualPerPhysical {
+		return fmt.Errorf("virtual shards per physical is immutable: "+
+			"attempted change from \"%d\" to \"%d\"", first.VirtualPerPhysical,
+			second.VirtualPerPhysical)
+	}
+	return nil
+}

platform/dbops/binaries/weaviate-src/usecases/schema/parser_test.go

@@ -0,0 +1,182 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/vectorindex"
+	enthnsw "github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+	"github.com/weaviate/weaviate/usecases/fakes"
+	"github.com/weaviate/weaviate/usecases/sharding/config"
+)
+
+const hnswT = vectorindex.VectorIndexTypeHNSW
+
+func TestParser(t *testing.T) {
+	cs := fakes.NewFakeClusterState()
+	p := NewParser(cs, dummyParseVectorConfig, fakeValidator{}, fakeModulesProvider{}, nil)
+
+	sc := config.Config{DesiredCount: 1, VirtualPerPhysical: 128, ActualCount: 1, DesiredVirtualCount: 128, Key: "_id", Strategy: "hash", Function: "murmur3"}
+	vic := enthnsw.NewDefaultUserConfig()
+	emptyMap := map[string]interface{}{}
+	valueMap := map[string]interface{}{"something": emptyMap}
+
+	testCases := []struct {
+		name     string
+		old      *models.Class
+		update   *models.Class
+		expected *models.Class
+		error    bool
+	}{
+		{
+			name:     "update description",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: enthnsw.NewDefaultUserConfig(), ShardingConfig: sc},
+			update:   &models.Class{Class: "Test", Description: "NEW", VectorIndexType: hnswT, VectorIndexConfig: enthnsw.NewDefaultUserConfig()},
+			expected: &models.Class{Class: "Test", Description: "NEW", VectorIndexType: hnswT, VectorIndexConfig: enthnsw.NewDefaultUserConfig(), ShardingConfig: sc},
+			error:    false,
+		},
+		{
+			name:     "update generative module - previously not configured",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"generative-madeup": emptyMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"generative-madeup": emptyMap}},
+			error:    false,
+		},
+		{
+			name:     "update generative module - previously not configured, other modules present",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"text2vec-random": emptyMap}},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"generative-madeup": emptyMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"generative-madeup": emptyMap, "text2vec-random": emptyMap}},
+			error:    false,
+		},
+		{
+			name:     "update generative module - previously not configured, other generative module present",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"generative-random": emptyMap}},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"generative-madeup": emptyMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"generative-madeup": emptyMap}},
+			error:    false,
+		},
+		{
+			name:     "update reranker module - previously not configured",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"reranker-madeup": emptyMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"reranker-madeup": emptyMap}},
+			error:    false,
+		},
+		{
+			name:     "update reranker module - previously not configured, other modules present",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"text2vec-random": emptyMap}},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"reranker-madeup": emptyMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"reranker-madeup": emptyMap, "text2vec-random": emptyMap}},
+			error:    false,
+		},
+		{
+			name:     "update reranker module - previously not configured, other generative module present",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"reranker-random": emptyMap, "generative-random": emptyMap}},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"reranker-madeup": emptyMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"reranker-madeup": emptyMap, "generative-random": emptyMap}},
+			error:    false,
+		},
+		{
+			name:     "update reranker and generative module - previously not configured, other text2vec module present",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"reranker-random": emptyMap, "generative-random": emptyMap, "text2vec-random": emptyMap}},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"reranker-madeup": emptyMap, "generative-madeup": emptyMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"reranker-madeup": emptyMap, "generative-madeup": emptyMap, "text2vec-random": emptyMap}},
+			error:    false,
+		},
+		{
+			name:     "update text2vec - previously not configured, add a new vector index",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"text2vec-random": emptyMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"text2vec-random": emptyMap}},
+			error:    false,
+		},
+		{
+			name:   "update text2vec - previously differently configured => error",
+			old:    &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"text2vec-random": valueMap}},
+			update: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"text2vec-random": emptyMap}},
+			error:  true,
+		},
+		{
+			name:     "update text2vec - other modules present => error",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"generative-random": valueMap}},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"text2vec-random": emptyMap, "generative-random": valueMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"text2vec-random": emptyMap, "generative-random": valueMap}},
+			error:    false,
+		},
+		{
+			name:     "update with same text2vec config",
+			old:      &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"text2vec-random": valueMap}},
+			update:   &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ModuleConfig: map[string]interface{}{"text2vec-random": valueMap}},
+			expected: &models.Class{Class: "Test", VectorIndexType: hnswT, VectorIndexConfig: vic, ShardingConfig: sc, ModuleConfig: map[string]interface{}{"text2vec-random": valueMap}},
+			error:    false,
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+			update, err := p.ParseClassUpdate(test.old, test.update)
+			if test.error {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected.Description, update.Description)
+				require.Equal(t, test.expected.ModuleConfig, update.ModuleConfig)
+			}
+		})
+	}
+}
+
+func Test_asMap(t *testing.T) {
+	t.Run("not nil", func(t *testing.T) {
+		m, err := propertyAsMap(&models.Property{
+			Name:        "name",
+			Description: "description",
+			DataType:    []string{"object"},
+			NestedProperties: []*models.NestedProperty{{
+				Name:        "nested",
+				Description: "nested description",
+				DataType:    []string{"text"},
+			}},
+		})
+		require.NotNil(t, m)
+		require.Nil(t, err)
+
+		_, ok := m["description"]
+		require.False(t, ok)
+
+		nps, ok := m["nestedProperties"].([]map[string]any)
+		require.True(t, ok)
+		require.Len(t, nps, 1)
+
+		_, ok = nps[0]["description"]
+		require.False(t, ok)
+	})
+}
+
+type fakeModulesProvider struct{}
+
+func (m fakeModulesProvider) IsReranker(name string) bool {
+	return strings.Contains(name, "reranker")
+}
+
+func (m fakeModulesProvider) IsGenerative(name string) bool {
+	return strings.Contains(name, "generative")
+}
+
+func (m fakeModulesProvider) IsMultiVector(name string) bool {
+	return strings.Contains(name, "colbert")
+}

platform/dbops/binaries/weaviate-src/usecases/schema/property.go

@@ -0,0 +1,157 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package schema
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	clusterSchema "github.com/weaviate/weaviate/cluster/schema"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+)
+
+// AddClassProperty it is upsert operation. it adds properties to a class and updates
+// existing properties if the merge bool passed true.
+func (h *Handler) AddClassProperty(ctx context.Context, principal *models.Principal,
+	class *models.Class, className string, merge bool, newProps ...*models.Property,
+) (*models.Class, uint64, error) {
+	if err := h.Authorizer.Authorize(ctx, principal, authorization.UPDATE, authorization.CollectionsMetadata(className)...); err != nil {
+		return nil, 0, err
+	}
+
+	if err := h.Authorizer.Authorize(ctx, principal, authorization.READ, authorization.CollectionsMetadata(className)...); err != nil {
+		return nil, 0, err
+	}
+	classGetterWithAuth := func(name string) (*models.Class, error) {
+		if err := h.Authorizer.Authorize(ctx, principal, authorization.READ, authorization.CollectionsMetadata(name)...); err != nil {
+			return nil, err
+		}
+		return h.schemaReader.ReadOnlyClass(name), nil
+	}
+
+	if class == nil {
+		return nil, 0, fmt.Errorf("class is nil: %w", ErrNotFound)
+	}
+
+	if len(newProps) == 0 {
+		return nil, 0, nil
+	}
+
+	// validate new props
+	for _, prop := range newProps {
+		if prop.Name == "" {
+			return nil, 0, fmt.Errorf("property must contain name")
+		}
+		prop.Name = schema.LowercaseFirstLetter(prop.Name)
+		if prop.DataType == nil {
+			return nil, 0, fmt.Errorf("property must contain dataType")
+		}
+	}
+
+	if err := h.setNewPropDefaults(class, newProps...); err != nil {
+		return nil, 0, err
+	}
+
+	existingNames := make(map[string]bool, len(class.Properties))
+	if !merge {
+		for _, prop := range class.Properties {
+			existingNames[strings.ToLower(prop.Name)] = true
+		}
+	}
+
+	if err := h.validateProperty(class, existingNames, false, classGetterWithAuth, newProps...); err != nil {
+		return nil, 0, err
+	}
+
+	// TODO-RAFT use UpdateProperty() for adding/merging property when index idempotence exists
+	// revisit when index idempotence exists and/or allowing merging properties on index.
+	props := schema.DedupProperties(class.Properties, newProps)
+	if len(props) == 0 {
+		return class, 0, nil
+	}
+
+	migratePropertySettings(props...)
+
+	class.Properties = clusterSchema.MergeProps(class.Properties, props)
+	version, err := h.schemaManager.AddProperty(ctx, class.Class, props...)
+	if err != nil {
+		return nil, 0, err
+	}
+	return class, version, err
+}
+
+// DeleteClassProperty from existing Schema
+func (h *Handler) DeleteClassProperty(ctx context.Context, principal *models.Principal,
+	class string, property string,
+) error {
+	err := h.Authorizer.Authorize(ctx, principal, authorization.UPDATE, authorization.CollectionsMetadata(class)...)
+	if err != nil {
+		return err
+	}
+
+	return fmt.Errorf("deleting a property is currently not supported, see " +
+		"https://github.com/weaviate/weaviate/issues/973 for details")
+	// return h.deleteClassProperty(ctx, class, property, kind.Action)
+}
+
+func (h *Handler) setNewPropDefaults(class *models.Class, props ...*models.Property) error {
+	setPropertyDefaults(props...)
+	h.moduleConfig.SetSinglePropertyDefaults(class, props...)
+	return nil
+}
+
+func (h *Handler) validatePropModuleConfig(class *models.Class, props ...*models.Property) error {
+	configuredVectorizers := map[string]struct{}{}
+	if class.Vectorizer != "" {
+		configuredVectorizers[class.Vectorizer] = struct{}{}
+	}
+
+	for targetVector, cfg := range class.VectorConfig {
+		if vm, ok := cfg.Vectorizer.(map[string]interface{}); ok && len(vm) == 1 {
+			for vectorizer := range vm {
+				configuredVectorizers[vectorizer] = struct{}{}
+			}
+		} else if len(vm) > 1 {
+			return fmt.Errorf("vector index %q has multiple vectorizers", targetVector)
+		}
+	}
+
+	for _, prop := range props {
+		if prop.ModuleConfig == nil {
+			continue
+		}
+
+		modconfig, ok := prop.ModuleConfig.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("%v property config invalid", prop.Name)
+		}
+
+		for vectorizer, cfg := range modconfig {
+			if err := h.vectorizerValidator.ValidateVectorizer(vectorizer); err != nil {
+				continue
+			}
+
+			if _, ok := configuredVectorizers[vectorizer]; !ok {
+				return fmt.Errorf("vectorizer %q not configured for any of target vectors", vectorizer)
+			}
+
+			if _, ok := cfg.(map[string]interface{}); !ok {
+				return fmt.Errorf("vectorizer config for vectorizer %q not of type map[string]interface{}", vectorizer)
+			}
+		}
+	}
+
+	return nil
+}