snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/channels/store/errors.go

@@ -0,0 +1,205 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package store
+
+import (
+	"fmt"
+	"strings"
+)
+
+// ErrInvalidInput indicates an error that has occurred due to an invalid input.
+type ErrInvalidInput struct {
+	Entity  string // The entity which was sent as the input.
+	Field   string // The field of the entity which was invalid.
+	Value   any    // The actual value of the field.
+	wrapped error  // The original error
+}
+
+func NewErrInvalidInput(entity, field string, value any) *ErrInvalidInput {
+	return &ErrInvalidInput{
+		Entity: entity,
+		Field:  field,
+		Value:  value,
+	}
+}
+
+func (e *ErrInvalidInput) Error() string {
+	if e.wrapped != nil {
+		return fmt.Sprintf("invalid input: entity: %s field: %s value: %s error: %s", e.Entity, e.Field, e.Value, e.wrapped)
+	}
+
+	return fmt.Sprintf("invalid input: entity: %s field: %s value: %s", e.Entity, e.Field, e.Value)
+}
+
+func (e *ErrInvalidInput) Wrap(err error) *ErrInvalidInput {
+	e.wrapped = err
+	return e
+}
+
+func (e *ErrInvalidInput) Unwrap() error {
+	return e.wrapped
+}
+
+func (e *ErrInvalidInput) InvalidInputInfo() (entity string, field string, value any) {
+	entity = e.Entity
+	field = e.Field
+	value = e.Value
+	return
+}
+
+// ErrLimitExceeded indicates an error that has occurred because some value exceeded a limit.
+type ErrLimitExceeded struct {
+	What  string // What was the object that exceeded.
+	Count int    // The value of the object.
+	meta  string // Any additional metadata.
+}
+
+func NewErrLimitExceeded(what string, count int, meta string) *ErrLimitExceeded {
+	return &ErrLimitExceeded{
+		What:  what,
+		Count: count,
+		meta:  meta,
+	}
+}
+
+func (e *ErrLimitExceeded) Error() string {
+	return fmt.Sprintf("limit exceeded: what: %s count: %d metadata: %s", e.What, e.Count, e.meta)
+}
+
+// ErrConflict indicates a conflict that occurred.
+type ErrConflict struct {
+	Resource string // The resource which created the conflict.
+	err      error  // Internal error.
+	meta     string // Any additional metadata.
+}
+
+func NewErrConflict(resource string, err error, meta string) *ErrConflict {
+	return &ErrConflict{
+		Resource: resource,
+		err:      err,
+		meta:     meta,
+	}
+}
+
+func (e *ErrConflict) Error() string {
+	msg := e.Resource + "exists " + e.meta
+	if e.err != nil {
+		msg += " " + e.err.Error()
+	}
+	return msg
+}
+
+func (e *ErrConflict) Unwrap() error {
+	return e.err
+}
+
+// IsErrConflict allows easy type assertion without adding store as a dependency.
+func (e *ErrConflict) IsErrConflict() bool {
+	return true
+}
+
+// ErrNotFound indicates that a resource was not found
+type ErrNotFound struct {
+	resource string
+	ID       string
+	wrapped  error
+}
+
+func NewErrNotFound(resource, id string) *ErrNotFound {
+	return &ErrNotFound{
+		resource: resource,
+		ID:       id,
+	}
+}
+
+func (e *ErrNotFound) Wrap(err error) *ErrNotFound {
+	e.wrapped = err
+	return e
+}
+
+func (e *ErrNotFound) Error() string {
+	if e.wrapped != nil {
+		return fmt.Sprintf("resource %q not found, id: %s, error: %s", e.resource, e.ID, e.wrapped)
+	}
+
+	return fmt.Sprintf("resource %q not found, id: %s", e.resource, e.ID)
+}
+
+// IsErrNotFound allows easy type assertion without adding store as a dependency.
+func (e *ErrNotFound) IsErrNotFound() bool {
+	return true
+}
+
+// ErrOutOfBounds indicates that the requested total numbers of rows
+// was greater than the allowed limit.
+type ErrOutOfBounds struct {
+	value int
+}
+
+func (e *ErrOutOfBounds) Error() string {
+	return fmt.Sprintf("invalid limit parameter: %d", e.value)
+}
+
+func NewErrOutOfBounds(value int) *ErrOutOfBounds {
+	return &ErrOutOfBounds{value: value}
+}
+
+// ErrNotImplemented indicates that some feature or requirement is not implemented yet.
+type ErrNotImplemented struct {
+	detail string
+}
+
+func (e *ErrNotImplemented) Error() string {
+	return e.detail
+}
+
+func NewErrNotImplemented(detail string) *ErrNotImplemented {
+	return &ErrNotImplemented{detail: detail}
+}
+
+type ErrUniqueConstraint struct {
+	Columns []string
+}
+
+// NewErrUniqueConstraint creates a uniqueness constraint error for the given column(s).
+//
+// Examples:
+//
+//	store.NewErrUniqueConstraint("DisplayName") // single column constraint
+//	store.NewErrUniqueConstraint("Name", "Source") // multi-column constraint
+func NewErrUniqueConstraint(columns ...string) *ErrUniqueConstraint {
+	return &ErrUniqueConstraint{
+		Columns: columns,
+	}
+}
+
+func (e *ErrUniqueConstraint) Error() string {
+	var tmpl string
+	if len(e.Columns) > 1 {
+		tmpl = "unique constraint: (%s)"
+	} else {
+		tmpl = "unique constraint: %s"
+	}
+	return fmt.Sprintf(tmpl, strings.Join(e.Columns, ","))
+}
+
+func IsErrNotFound(err error) bool {
+	_, ok := err.(*ErrNotFound)
+	return ok
+}
+
+// ErrResultsMismatch indicates that a batch lookup returned fewer results
+// than the number of IDs requested, meaning some IDs were not found.
+type ErrResultsMismatch struct {
+	Got      int
+	Expected int
+}
+
+func NewErrResultsMismatch(got, expected int) *ErrResultsMismatch {
+	return &ErrResultsMismatch{Got: got, Expected: expected}
+}
+
+func (e *ErrResultsMismatch) Error() string {
+	return fmt.Sprintf("results mismatch: got %d results of the %d ids passed", e.Got, e.Expected)
+}