refactor: rename package errors to zerrors (#7039)

* chore: rename package errors to zerrors

* rename package errors to gerrors

* fix error related linting issues

* fix zitadel error assertion

* fix gosimple linting issues

* fix deprecated linting issues

* resolve gci linting issues

* fix import structure

---------

Co-authored-by: Elio Bischof <elio@zitadel.com>

internal/zerrors/already_exists.go

@@ -0,0 +1,44 @@
+package zerrors
+
+import "fmt"
+
+var (
+	_ AlreadyExists = (*AlreadyExistsError)(nil)
+	_ Error         = (*AlreadyExistsError)(nil)
+)
+
+type AlreadyExists interface {
+	error
+	IsAlreadyExists()
+}
+
+type AlreadyExistsError struct {
+	*ZitadelError
+}
+
+func ThrowAlreadyExists(parent error, id, message string) error {
+	return &AlreadyExistsError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowAlreadyExistsf(parent error, id, format string, a ...interface{}) error {
+	return &AlreadyExistsError{CreateZitadelError(parent, id, fmt.Sprintf(format, a...))}
+}
+
+func (err *AlreadyExistsError) IsAlreadyExists() {}
+
+func (err *AlreadyExistsError) Is(target error) bool {
+	t, ok := target.(*AlreadyExistsError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func IsErrorAlreadyExists(err error) bool {
+	_, ok := err.(AlreadyExists)
+	return ok
+}
+
+func (err *AlreadyExistsError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/already_exists_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestAlreadyExistsError(t *testing.T) {
+	var alreadyExistsError interface{} = new(zerrors.AlreadyExistsError)
+	_, ok := alreadyExistsError.(zerrors.AlreadyExists)
+	assert.True(t, ok)
+}
+
+func TestThrowAlreadyExistsf(t *testing.T) {
+	err := zerrors.ThrowAlreadyExistsf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.AlreadyExistsError)
+	assert.True(t, ok)
+}
+
+func TestIsErrorAlreadyExists(t *testing.T) {
+	err := zerrors.ThrowAlreadyExists(nil, "id", "msg")
+	ok := zerrors.IsErrorAlreadyExists(err)
+	assert.True(t, ok)
+
+	err = errors.New("Already Exists!")
+	ok = zerrors.IsErrorAlreadyExists(err)
+	assert.False(t, ok)
+}

internal/zerrors/deadline_exceeded.go

@@ -0,0 +1,46 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ DeadlineExceeded = (*DeadlineExceededError)(nil)
+	_ Error            = (*DeadlineExceededError)(nil)
+)
+
+type DeadlineExceeded interface {
+	error
+	IsDeadlineExceeded()
+}
+
+type DeadlineExceededError struct {
+	*ZitadelError
+}
+
+func ThrowDeadlineExceeded(parent error, id, message string) error {
+	return &DeadlineExceededError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowDeadlineExceededf(parent error, id, format string, a ...interface{}) error {
+	return ThrowDeadlineExceeded(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *DeadlineExceededError) IsDeadlineExceeded() {}
+
+func IsDeadlineExceeded(err error) bool {
+	_, ok := err.(DeadlineExceeded)
+	return ok
+}
+
+func (err *DeadlineExceededError) Is(target error) bool {
+	t, ok := target.(*DeadlineExceededError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *DeadlineExceededError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/deadline_exceeded_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestDeadlineExceededError(t *testing.T) {
+	var err interface{} = new(zerrors.DeadlineExceededError)
+	_, ok := err.(zerrors.DeadlineExceeded)
+	assert.True(t, ok)
+}
+
+func TestThrowDeadlineExceededf(t *testing.T) {
+	err := zerrors.ThrowDeadlineExceededf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.DeadlineExceededError)
+	assert.True(t, ok)
+}
+
+func TestIsDeadlineExceeded(t *testing.T) {
+	err := zerrors.ThrowDeadlineExceeded(nil, "id", "msg")
+	ok := zerrors.IsDeadlineExceeded(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsDeadlineExceeded(err)
+	assert.False(t, ok)
+}

internal/zerrors/error.go

@@ -0,0 +1,19 @@
+package zerrors
+
+import (
+	"strings"
+)
+
+// Error is a stdlib error extension.
+// It contains parameters to identify errors through all application layers
+type Error interface {
+	GetParent() error
+	GetMessage() string
+	SetMessage(string)
+	GetID() string
+}
+
+// Contains compares the error message with needle
+func Contains(err error, needle string) bool {
+	return err != nil && strings.Contains(err.Error(), needle)
+}

internal/zerrors/error_test.go

@@ -0,0 +1,19 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestContains(t *testing.T) {
+	err := errors.New("hello world")
+	world := zerrors.Contains(err, "hello")
+	assert.True(t, world)
+
+	mars := zerrors.Contains(err, "mars")
+	assert.False(t, mars)
+}

internal/zerrors/generate/error.go.tmpl

@@ -0,0 +1,34 @@
+package errors
+
+import (
+	"fmt"
+)
+
+var (
+	_ {{.ErrorName}} = (*{{.ErrorName}}Error)(nil)
+	_ Error    = (*{{.ErrorName}}Error)(nil)
+)
+
+type {{.ErrorName}} interface {
+	error
+	Is{{.ErrorName}}()
+}
+
+type {{.ErrorName}}Error struct {
+	*CaosError
+}
+
+func Throw{{.ErrorName}}(parent error, id, message string) error {
+	return &{{.ErrorName}}Error{CreateCaosError(parent, id, message)}
+}
+
+func Throw{{.ErrorName}}f(parent error, id, format string, a ...interface{}) error {
+	return Throw{{.ErrorName}}(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *{{.ErrorName}}Error) Is{{.ErrorName}}() {}
+
+func Is{{.ErrorName}}(err error) bool {
+	_, ok := err.({{.ErrorName}})
+	return ok
+}

internal/zerrors/generate/error_creator.go

@@ -0,0 +1,75 @@
+// go generate
+package main
+
+import (
+	"flag"
+	"fmt"
+	"html/template"
+	"log"
+	"os"
+	"strings"
+)
+
+func main() {
+	errorName := readErrorName()
+	errorName = validateErrorName(errorName)
+
+	data := &Data{
+		ErrorName: errorName,
+	}
+
+	errorFile := data.createFile("error.go.tmpl")
+	data.createTemplate("error.go.tmpl", errorFile)
+	if err := errorFile.Close(); err != nil {
+		log.Fatal(err)
+	}
+
+	testFile := data.createFile("error_test.go.tmpl")
+	data.createTemplate("error_test.go.tmpl", testFile)
+	if err := testFile.Close(); err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Print(`
+!!!!!
+  Add status mapping in internal/api/grpc/zerrors.go	
+!!!!!`)
+}
+
+type Data struct {
+	ErrorName string
+}
+
+func (data *Data) createFile(tmplName string) *os.File {
+	filename := strings.Replace(tmplName, "error", strings.ToLower(data.ErrorName), 1)
+	filename = filename[:len(filename)-5]
+	filePath := fmt.Sprintf("../%s", filename)
+	file, err := os.Create(filePath)
+	if err != nil {
+		log.Fatalf("unable to create file (%s): %v", filePath, err)
+	}
+	return file
+}
+
+func (data *Data) createTemplate(templateName string, file *os.File) {
+	tmpl := template.Must(template.New(templateName).ParseFiles(templateName))
+	if err := tmpl.Execute(file, data); err != nil {
+		log.Fatal("unable to execute tmpl: ", err)
+	}
+}
+
+func readErrorName() (errorName string) {
+	flag.StringVar(&errorName, "Name", "", "KeyType of the error (e.g. Internal)")
+	flag.Parse()
+	return errorName
+}
+
+func validateErrorName(errorName string) string {
+	if errorName == "" {
+		log.Fatal("pass argument name")
+	}
+	if strings.Contains(errorName, " ") || strings.Contains(errorName, ".") {
+		log.Fatal("name cannot contain spaces or points")
+	}
+	return strings.Title(errorName)
+}

internal/zerrors/generate/error_interface.go.tmpl

@@ -0,0 +1,5 @@
+
+type {{.ErrorName}} interface {
+	error
+	Is{{.ErrorName}}()
+}

internal/zerrors/generate/error_test.go.tmpl

@@ -0,0 +1,33 @@
+package errors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func Test{{.ErrorName}}Error(t *testing.T) {
+	var err interface{}
+	err = new(zerrors.{{.ErrorName}}Error)
+	_, ok := err.(*zerrors.{{.ErrorName}})
+	assert.True(t, ok)
+}
+
+func TestThrow{{.ErrorName}}f(t *testing.T) {
+	err := zerrors.Throw{{.ErrorName}}f(nil, "id", "msg")
+	_, ok := err.(*zerrors.{{.ErrorName}}Error)
+	assert.True(t, ok)
+}
+
+func TestIs{{.ErrorName}}(t *testing.T) {
+	err := zerrors.Throw{{.ErrorName}}(nil, "id", "msg")
+	ok := zerrors.Is{{.ErrorName}}(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.Is{{.ErrorName}}(err)
+	assert.False(t, ok)
+}

internal/zerrors/internal.go

@@ -0,0 +1,46 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ Internal = (*InternalError)(nil)
+	_ Error    = (*InternalError)(nil)
+)
+
+type Internal interface {
+	error
+	IsInternal()
+}
+
+type InternalError struct {
+	*ZitadelError
+}
+
+func ThrowInternal(parent error, id, message string) error {
+	return &InternalError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowInternalf(parent error, id, format string, a ...interface{}) error {
+	return ThrowInternal(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *InternalError) IsInternal() {}
+
+func IsInternal(err error) bool {
+	_, ok := err.(Internal)
+	return ok
+}
+
+func (err *InternalError) Is(target error) bool {
+	t, ok := target.(*InternalError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *InternalError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/internal_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestInternalError(t *testing.T) {
+	var err interface{} = new(zerrors.InternalError)
+	_, ok := err.(zerrors.Internal)
+	assert.True(t, ok)
+}
+
+func TestThrowInternalf(t *testing.T) {
+	err := zerrors.ThrowInternalf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.InternalError)
+	assert.True(t, ok)
+}
+
+func TestIsInternal(t *testing.T) {
+	err := zerrors.ThrowInternal(nil, "id", "msg")
+	ok := zerrors.IsInternal(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsInternal(err)
+	assert.False(t, ok)
+}

internal/zerrors/invalid_argument.go

@@ -0,0 +1,44 @@
+package zerrors
+
+import "fmt"
+
+var (
+	_ InvalidArgument = (*InvalidArgumentError)(nil)
+	_ Error           = (*InvalidArgumentError)(nil)
+)
+
+type InvalidArgument interface {
+	error
+	IsInvalidArgument()
+}
+
+type InvalidArgumentError struct {
+	*ZitadelError
+}
+
+func ThrowInvalidArgument(parent error, id, message string) error {
+	return &InvalidArgumentError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowInvalidArgumentf(parent error, id, format string, a ...interface{}) error {
+	return ThrowInvalidArgument(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *InvalidArgumentError) IsInvalidArgument() {}
+
+func IsErrorInvalidArgument(err error) bool {
+	_, ok := err.(InvalidArgument)
+	return ok
+}
+
+func (err *InvalidArgumentError) Is(target error) bool {
+	t, ok := target.(*InvalidArgumentError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *InvalidArgumentError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/invalid_argument_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestInvalidArgumentError(t *testing.T) {
+	var invalidArgumentError interface{} = new(zerrors.InvalidArgumentError)
+	_, ok := invalidArgumentError.(zerrors.InvalidArgument)
+	assert.True(t, ok)
+}
+
+func TestThrowInvalidArgumentf(t *testing.T) {
+	err := zerrors.ThrowInvalidArgumentf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.InvalidArgumentError)
+	assert.True(t, ok)
+}
+
+func TestIsErrorInvalidArgument(t *testing.T) {
+	err := zerrors.ThrowInvalidArgument(nil, "id", "msg")
+	ok := zerrors.IsErrorInvalidArgument(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am invalid!")
+	ok = zerrors.IsErrorInvalidArgument(err)
+	assert.False(t, ok)
+}

internal/zerrors/not_found.go

@@ -0,0 +1,39 @@
+package zerrors
+
+import "fmt"
+
+type NotFound interface {
+	error
+	IsNotFound()
+}
+
+type NotFoundError struct {
+	*ZitadelError
+}
+
+func ThrowNotFound(parent error, id, message string) error {
+	return &NotFoundError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowNotFoundf(parent error, id, format string, a ...interface{}) error {
+	return ThrowNotFound(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *NotFoundError) IsNotFound() {}
+
+func IsNotFound(err error) bool {
+	_, ok := err.(NotFound)
+	return ok
+}
+
+func (err *NotFoundError) Is(target error) bool {
+	t, ok := target.(*NotFoundError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *NotFoundError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/not_found_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestNotFoundError(t *testing.T) {
+	var notFoundError interface{} = new(zerrors.NotFoundError)
+	_, ok := notFoundError.(zerrors.NotFound)
+	assert.True(t, ok)
+}
+
+func TestThrowNotFoundf(t *testing.T) {
+	err := zerrors.ThrowNotFoundf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.NotFoundError)
+	assert.True(t, ok)
+}
+
+func TestIsNotFound(t *testing.T) {
+	err := zerrors.ThrowNotFound(nil, "id", "msg")
+	ok := zerrors.IsNotFound(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsNotFound(err)
+	assert.False(t, ok)
+}

internal/zerrors/permission_denied.go

@@ -0,0 +1,46 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ PermissionDenied = (*PermissionDeniedError)(nil)
+	_ Error            = (*PermissionDeniedError)(nil)
+)
+
+type PermissionDenied interface {
+	error
+	IsPermissionDenied()
+}
+
+type PermissionDeniedError struct {
+	*ZitadelError
+}
+
+func ThrowPermissionDenied(parent error, id, message string) error {
+	return &PermissionDeniedError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowPermissionDeniedf(parent error, id, format string, a ...interface{}) error {
+	return ThrowPermissionDenied(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *PermissionDeniedError) IsPermissionDenied() {}
+
+func IsPermissionDenied(err error) bool {
+	_, ok := err.(PermissionDenied)
+	return ok
+}
+
+func (err *PermissionDeniedError) Is(target error) bool {
+	t, ok := target.(*PermissionDeniedError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *PermissionDeniedError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/permission_denied_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestPermissionDeniedError(t *testing.T) {
+	var err interface{} = new(zerrors.PermissionDeniedError)
+	_, ok := err.(zerrors.PermissionDenied)
+	assert.True(t, ok)
+}
+
+func TestThrowPermissionDeniedf(t *testing.T) {
+	err := zerrors.ThrowPermissionDeniedf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.PermissionDeniedError)
+	assert.True(t, ok)
+}
+
+func TestIsPermissionDenied(t *testing.T) {
+	err := zerrors.ThrowPermissionDenied(nil, "id", "msg")
+	ok := zerrors.IsPermissionDenied(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsPermissionDenied(err)
+	assert.False(t, ok)
+}

internal/zerrors/precondition_failed.go

@@ -0,0 +1,46 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ PreconditionFailed = (*PreconditionFailedError)(nil)
+	_ Error              = (*PreconditionFailedError)(nil)
+)
+
+type PreconditionFailed interface {
+	error
+	IsPreconditionFailed()
+}
+
+type PreconditionFailedError struct {
+	*ZitadelError
+}
+
+func ThrowPreconditionFailed(parent error, id, message string) error {
+	return &PreconditionFailedError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowPreconditionFailedf(parent error, id, format string, a ...interface{}) error {
+	return ThrowPreconditionFailed(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *PreconditionFailedError) IsPreconditionFailed() {}
+
+func IsPreconditionFailed(err error) bool {
+	_, ok := err.(PreconditionFailed)
+	return ok
+}
+
+func (err *PreconditionFailedError) Is(target error) bool {
+	t, ok := target.(*PreconditionFailedError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *PreconditionFailedError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/precondition_failed_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestPreconditionFailedError(t *testing.T) {
+	var err interface{} = new(zerrors.PreconditionFailedError)
+	_, ok := err.(zerrors.PreconditionFailed)
+	assert.True(t, ok)
+}
+
+func TestThrowPreconditionFailedf(t *testing.T) {
+	err := zerrors.ThrowPreconditionFailedf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.PreconditionFailedError)
+	assert.True(t, ok)
+}
+
+func TestIsPreconditionFailed(t *testing.T) {
+	err := zerrors.ThrowPreconditionFailed(nil, "id", "msg")
+	ok := zerrors.IsPreconditionFailed(err)
+	assert.True(t, ok)
+
+	err = errors.New("Precondition failed!")
+	ok = zerrors.IsPreconditionFailed(err)
+	assert.False(t, ok)
+}

internal/zerrors/resource_exhausted.go

@@ -0,0 +1,48 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ ResourceExhausted = (*ResourceExhaustedError)(nil)
+	_ Error             = (*ResourceExhaustedError)(nil)
+)
+
+type ResourceExhausted interface {
+	error
+	IsResourceExhausted()
+}
+
+type ResourceExhaustedError struct {
+	*ZitadelError
+}
+
+func ThrowResourceExhausted(parent error, id, message string) error {
+	return &ResourceExhaustedError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowResourceExhaustedf(parent error, id, format string, a ...interface{}) error {
+	return ThrowResourceExhausted(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *ResourceExhaustedError) IsResourceExhausted() {}
+
+func IsResourceExhausted(err error) bool {
+	//nolint:errorlint
+	_, ok := err.(ResourceExhausted)
+	return ok
+}
+
+func (err *ResourceExhaustedError) Is(target error) bool {
+	//nolint:errorlint
+	t, ok := target.(*ResourceExhaustedError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *ResourceExhaustedError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/resource_exhausted_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestResourceExhaustedError(t *testing.T) {
+	var err interface{} = new(zerrors.ResourceExhaustedError)
+	_, ok := err.(zerrors.ResourceExhausted)
+	assert.True(t, ok)
+}
+
+func TestThrowResourceExhaustedf(t *testing.T) {
+	err := zerrors.ThrowResourceExhaustedf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.ResourceExhaustedError)
+	assert.True(t, ok)
+}
+
+func TestIsResourceExhausted(t *testing.T) {
+	err := zerrors.ThrowResourceExhausted(nil, "id", "msg")
+	ok := zerrors.IsResourceExhausted(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsResourceExhausted(err)
+	assert.False(t, ok)
+}

internal/zerrors/unauthenticated.go

@@ -0,0 +1,46 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ Unauthenticated = (*UnauthenticatedError)(nil)
+	_ Error           = (*UnauthenticatedError)(nil)
+)
+
+type Unauthenticated interface {
+	error
+	IsUnauthenticated()
+}
+
+type UnauthenticatedError struct {
+	*ZitadelError
+}
+
+func ThrowUnauthenticated(parent error, id, message string) error {
+	return &UnauthenticatedError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowUnauthenticatedf(parent error, id, format string, a ...interface{}) error {
+	return ThrowUnauthenticated(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *UnauthenticatedError) IsUnauthenticated() {}
+
+func IsUnauthenticated(err error) bool {
+	_, ok := err.(Unauthenticated)
+	return ok
+}
+
+func (err *UnauthenticatedError) Is(target error) bool {
+	t, ok := target.(*UnauthenticatedError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *UnauthenticatedError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/unauthenticated_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestUnauthenticatedError(t *testing.T) {
+	var err interface{} = new(zerrors.UnauthenticatedError)
+	_, ok := err.(zerrors.Unauthenticated)
+	assert.True(t, ok)
+}
+
+func TestThrowUnauthenticatedf(t *testing.T) {
+	err := zerrors.ThrowUnauthenticatedf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.UnauthenticatedError)
+	assert.True(t, ok)
+}
+
+func TestIsUnauthenticated(t *testing.T) {
+	err := zerrors.ThrowUnauthenticated(nil, "id", "msg")
+	ok := zerrors.IsUnauthenticated(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsUnauthenticated(err)
+	assert.False(t, ok)
+}

internal/zerrors/unavailable.go

@@ -0,0 +1,46 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ Unavailable = (*UnavailableError)(nil)
+	_ Error       = (*UnavailableError)(nil)
+)
+
+type Unavailable interface {
+	error
+	IsUnavailable()
+}
+
+type UnavailableError struct {
+	*ZitadelError
+}
+
+func ThrowUnavailable(parent error, id, message string) error {
+	return &UnavailableError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowUnavailablef(parent error, id, format string, a ...interface{}) error {
+	return ThrowUnavailable(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *UnavailableError) IsUnavailable() {}
+
+func IsUnavailable(err error) bool {
+	_, ok := err.(Unavailable)
+	return ok
+}
+
+func (err *UnavailableError) Is(target error) bool {
+	t, ok := target.(*UnavailableError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *UnavailableError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/unavailable_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestUnavailableError(t *testing.T) {
+	var err interface{} = new(zerrors.UnavailableError)
+	_, ok := err.(zerrors.Unavailable)
+	assert.True(t, ok)
+}
+
+func TestThrowUnavailablef(t *testing.T) {
+	err := zerrors.ThrowUnavailablef(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.UnavailableError)
+	assert.True(t, ok)
+}
+
+func TestIsUnavailable(t *testing.T) {
+	err := zerrors.ThrowUnavailable(nil, "id", "msg")
+	ok := zerrors.IsUnavailable(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsUnavailable(err)
+	assert.False(t, ok)
+}

internal/zerrors/unimplemented.go

@@ -0,0 +1,46 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ Unimplemented = (*UnimplementedError)(nil)
+	_ Error         = (*UnimplementedError)(nil)
+)
+
+type Unimplemented interface {
+	error
+	IsUnimplemented()
+}
+
+type UnimplementedError struct {
+	*ZitadelError
+}
+
+func ThrowUnimplemented(parent error, id, message string) error {
+	return &UnimplementedError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowUnimplementedf(parent error, id, format string, a ...interface{}) error {
+	return ThrowUnimplemented(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *UnimplementedError) IsUnimplemented() {}
+
+func IsUnimplemented(err error) bool {
+	_, ok := err.(Unimplemented)
+	return ok
+}
+
+func (err *UnimplementedError) Is(target error) bool {
+	t, ok := target.(*UnimplementedError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *UnimplementedError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/unimplemented_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestUnimplementedError(t *testing.T) {
+	var unimplementedError interface{} = new(zerrors.UnimplementedError)
+	_, ok := unimplementedError.(zerrors.Unimplemented)
+	assert.True(t, ok)
+}
+
+func TestThrowUnimplementedf(t *testing.T) {
+	err := zerrors.ThrowUnimplementedf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.UnimplementedError)
+	assert.True(t, ok)
+}
+
+func TestIsUnimplemented(t *testing.T) {
+	err := zerrors.ThrowUnimplemented(nil, "id", "msg")
+	ok := zerrors.IsUnimplemented(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsUnimplemented(err)
+	assert.False(t, ok)
+}

internal/zerrors/unknown.go

@@ -0,0 +1,46 @@
+package zerrors
+
+import (
+	"fmt"
+)
+
+var (
+	_ Unknown = (*UnknownError)(nil)
+	_ Error   = (*UnknownError)(nil)
+)
+
+type Unknown interface {
+	error
+	IsUnknown()
+}
+
+type UnknownError struct {
+	*ZitadelError
+}
+
+func ThrowUnknown(parent error, id, message string) error {
+	return &UnknownError{CreateZitadelError(parent, id, message)}
+}
+
+func ThrowUnknownf(parent error, id, format string, a ...interface{}) error {
+	return ThrowUnknown(parent, id, fmt.Sprintf(format, a...))
+}
+
+func (err *UnknownError) IsUnknown() {}
+
+func IsUnknown(err error) bool {
+	_, ok := err.(Unknown)
+	return ok
+}
+
+func (err *UnknownError) Is(target error) bool {
+	t, ok := target.(*UnknownError)
+	if !ok {
+		return false
+	}
+	return err.ZitadelError.Is(t.ZitadelError)
+}
+
+func (err *UnknownError) Unwrap() error {
+	return err.ZitadelError
+}

internal/zerrors/unknown_test.go

@@ -0,0 +1,33 @@
+package zerrors_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestUnknownError(t *testing.T) {
+	var err interface{} = new(zerrors.UnknownError)
+	_, ok := err.(zerrors.Unknown)
+	assert.True(t, ok)
+}
+
+func TestThrowUnknownf(t *testing.T) {
+	err := zerrors.ThrowUnknownf(nil, "id", "msg")
+	//nolint:errorlint
+	_, ok := err.(*zerrors.UnknownError)
+	assert.True(t, ok)
+}
+
+func TestIsUnknown(t *testing.T) {
+	err := zerrors.ThrowUnknown(nil, "id", "msg")
+	ok := zerrors.IsUnknown(err)
+	assert.True(t, ok)
+
+	err = errors.New("I am found!")
+	ok = zerrors.IsUnknown(err)
+	assert.False(t, ok)
+}

internal/zerrors/zerror.go

@@ -0,0 +1,81 @@
+package zerrors
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+var _ Error = (*ZitadelError)(nil)
+
+type ZitadelError struct {
+	Parent  error
+	Message string
+	ID      string
+}
+
+func ThrowError(parent error, id, message string) error {
+	return CreateZitadelError(parent, id, message)
+}
+
+func CreateZitadelError(parent error, id, message string) *ZitadelError {
+	return &ZitadelError{
+		Parent:  parent,
+		ID:      id,
+		Message: message,
+	}
+}
+
+func (err *ZitadelError) Error() string {
+	if err.Parent != nil {
+		return fmt.Sprintf("ID=%s Message=%s Parent=(%v)", err.ID, err.Message, err.Parent)
+	}
+	return fmt.Sprintf("ID=%s Message=%s", err.ID, err.Message)
+}
+
+func (err *ZitadelError) Unwrap() error {
+	return err.GetParent()
+}
+
+func (err *ZitadelError) GetParent() error {
+	return err.Parent
+}
+
+func (err *ZitadelError) GetMessage() string {
+	return err.Message
+}
+
+func (err *ZitadelError) SetMessage(msg string) {
+	err.Message = msg
+}
+
+func (err *ZitadelError) GetID() string {
+	return err.ID
+}
+
+func (err *ZitadelError) Is(target error) bool {
+	t, ok := target.(*ZitadelError)
+	if !ok {
+		return false
+	}
+	if t.ID != "" && t.ID != err.ID {
+		return false
+	}
+	if t.Message != "" && t.Message != err.Message {
+		return false
+	}
+	if t.Parent != nil && !errors.Is(err.Parent, t.Parent) {
+		return false
+	}
+
+	return true
+}
+
+func (err *ZitadelError) As(target interface{}) bool {
+	_, ok := target.(**ZitadelError)
+	if !ok {
+		return false
+	}
+	reflect.Indirect(reflect.ValueOf(target)).Set(reflect.ValueOf(err))
+	return true
+}

internal/zerrors/zerror_test.go

@@ -0,0 +1,18 @@
+package zerrors_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestErrorMethod(t *testing.T) {
+	err := zerrors.ThrowError(nil, "id", "msg")
+	expected := "ID=id Message=msg"
+	assert.Equal(t, expected, err.Error())
+
+	err = zerrors.ThrowError(err, "subID", "subMsg")
+	subExptected := "ID=subID Message=subMsg Parent=(ID=id Message=msg)"
+	assert.Equal(t, subExptected, err.Error())
+}