File size: 4,407 Bytes
cf3ed5d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 | // _ _
// __ _____ __ ___ ___ __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
// \ 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
}
|