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/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)
+}