feat!: removing field key and invalid type schema panics

any.go

@@ -65,7 +65,8 @@ func (v *AnySchema) process(ctx *p.SchemaCtx) {
 
 	destPtr, ok := ctx.ValPtr.(*any)
 	if !ok {
-		p.Panicf(p.PanicTypeCast, ctx.String(), ctx.DType, ctx.ValPtr)
+		ctx.AddIssue(ctx.IssueFromInvalidType("*any", ctx.ValPtr, "parsing an any schema"))
+		return
 	}
 
 	// Handle default/required for nil values
@@ -129,7 +130,8 @@ func (v *AnySchema) validate(ctx *p.SchemaCtx) {
 
 	valPtr, ok := ctx.ValPtr.(*any)
 	if !ok {
-		p.Panicf(p.PanicTypeCast, ctx.String(), ctx.DType, ctx.ValPtr)
+		ctx.AddIssue(ctx.IssueFromInvalidType("*any", ctx.ValPtr, "validating an any schema"))
+		return
 	}
 
 	// Handle default/required for zero values

boolean_test.go

@@ -3,6 +3,7 @@ package zog
 import (
 	"fmt"
 	"testing"
+	"time"
 
 	p "github.com/Oudwins/zog/pkgs/internals"
 	"github.com/Oudwins/zog/pkgs/internals/tutils"
@@ -505,3 +506,29 @@ func TestBoolGetType(t *testing.T) {
 	s := Bool()
 	assert.Equal(t, zconst.TypeBool, s.getType())
 }
+
+func TestBoolInvalidType(t *testing.T) {
+	var nilString *string
+	cases := []struct {
+		Value any
+	}{
+		{Value: "string"},
+		{Value: 12},
+		{Value: time.Now()},
+		{Value: 12.5},
+		{Value: true},
+		{Value: []string{"hello"}},
+		{Value: nil},
+		{Value: nilString},
+	}
+
+	schema := Bool().Required()
+
+	for _, c := range cases {
+		ctx, errs := tutils.FakeContextFromValue(c.Value, "boolean")
+		schema.process(ctx)
+		assert.NotNil(t, errs.List)
+		assert.Equal(t, errs.List[0].Code, zconst.IssueCodeInvalidType)
+
+	}
+}

boolean_validate_test.go

@@ -3,9 +3,11 @@ package zog
 import (
 	"fmt"
 	"testing"
+	"time"
 
 	p "github.com/Oudwins/zog/pkgs/internals"
 	"github.com/Oudwins/zog/pkgs/internals/tutils"
+	"github.com/Oudwins/zog/zconst"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -375,3 +377,29 @@ func TestBoolValidateCustomTest(t *testing.T) {
 	}
 	assert.Equal(t, true, dest)
 }
+
+func TestBoolValidateInvalidType(t *testing.T) {
+	var nilString *string
+	cases := []struct {
+		Value any
+	}{
+		{Value: "string"},
+		{Value: 12},
+		{Value: time.Now()},
+		{Value: 12.5},
+		{Value: true},
+		{Value: []string{"hello"}},
+		{Value: nil},
+		{Value: nilString},
+	}
+
+	schema := Bool().Required()
+
+	for _, c := range cases {
+		ctx, errs := tutils.FakeContextFromValue(c.Value, "boolean")
+		schema.validate(ctx)
+		assert.NotNil(t, errs.List)
+		assert.Equal(t, errs.List[0].Code, zconst.IssueCodeInvalidType)
+
+	}
+}

custom.go

@@ -51,7 +51,8 @@ func (c *Custom[T]) process(ctx *p.SchemaCtx) {
 	}
 	ptr, ok := ctx.ValPtr.(*T)
 	if !ok {
-		p.Panicf(p.PanicTypeCast, ctx.String(), ctx.DType, ctx.ValPtr)
+		ctx.AddIssue(ctx.IssueFromInvalidType("pointer matching custom schema type", ctx.ValPtr, "parsing a custom schema"))
+		return
 	}
 	*ptr = d
 
@@ -79,7 +80,8 @@ func (c *Custom[T]) validate(ctx *p.SchemaCtx) {
 	ctx.Processor = &c.test
 	ptr, ok := ctx.ValPtr.(*T)
 	if !ok {
-		p.Panicf(p.PanicTypeCast, ctx.String(), ctx.DType, ctx.ValPtr)
+		ctx.AddIssue(ctx.IssueFromInvalidType("pointer matching custom schema type", ctx.ValPtr, "validating a custom schema"))
+		return
 	}
 	c.test.Func(ptr, ctx)
 }

maps.go

@@ -163,10 +163,16 @@ func (v *MapSchema[K, V]) process(ctx *p.SchemaCtx) {
 	}
 
 	// Create destination map
-	destVal := reflect.ValueOf(ctx.ValPtr).Elem()
+	destPtrVal := reflect.ValueOf(ctx.ValPtr)
+	if destPtrVal.Kind() != reflect.Pointer {
+		ctx.AddIssue(ctx.IssueFromInvalidType("pointer to map", ctx.ValPtr, "processing a map schema"))
+		return
+	}
+	destVal := destPtrVal.Elem()
 	destType := destVal.Type()
 	if destType.Kind() != reflect.Map {
-		p.Panicf(p.PanicTypeCast, ctx.String(), ctx.DType, ctx.ValPtr)
+		ctx.AddIssue(ctx.IssueFromInvalidType("map", ctx.ValPtr, "processing a map schema"))
+		return
 	}
 	destMap := reflect.MakeMap(destType)
 

pkgs/internals/Issues.go

@@ -118,13 +118,6 @@ type ZogIssueList = []*ZogIssue
 // Users should migrate to using ZogIssueList and access paths via issue.Path
 type ZogIssueMap = map[string]ZogIssueList
 
-// INTERNAL ONLY: Interface used to add errors during parsing & validation. It represents a group of errors
-type ZogIssues interface {
-	Add(err *ZogIssue)
-	IsEmpty() bool
-	Free()
-}
-
 // ErrsList - internal structure for collecting issues during schema execution
 type ErrsList struct {
 	List ZogIssueList

pkgs/internals/contexts.go

@@ -43,7 +43,7 @@ type Ctx interface {
 	HasErrored() bool
 }
 
-func NewExecCtx(errs ZogIssues, fmter IssueFmtFunc) *ExecCtx {
+func NewExecCtx(errs *ErrsList, fmter IssueFmtFunc) *ExecCtx {
 	c := ExecCtxPool.Get().(*ExecCtx)
 	c.Fmter = fmter
 	c.Errors = errs
@@ -55,7 +55,7 @@ func NewExecCtx(errs ZogIssues, fmter IssueFmtFunc) *ExecCtx {
 
 type ExecCtx struct {
 	Fmter  IssueFmtFunc
-	Errors ZogIssues
+	Errors *ErrsList
 	m      map[string]any
 }
 
@@ -167,6 +167,14 @@ func (c *SchemaCtx) Issue() *ZogIssue {
 	return NewZogIssue().SetPath(c.Path.ToListClone()).SetDType(c.DType).SetValue(c.Data)
 }
 
+func (c *SchemaCtx) IssueFromInvalidType(expected string, received any, operation string) *ZogIssue {
+	return c.Issue().SetCode(zconst.IssueCodeInvalidType).SetError(zconst.ErrorInvalidTypeMessage(expected, received, c.Path.String(), c.DType, c.Data, operation))
+}
+
+func (c *SchemaCtx) IssueFromMissingStructField(fieldName string) *ZogIssue {
+	return c.Issue().SetCode(zconst.IssueCodeMissingField).SetError(zconst.ErrorMissingStructField(fieldName, c.Path.String(), c.DType, c.Data))
+}
+
 // Please don't depend on this method it may change
 func (c *SchemaCtx) IssueFromTest(test TestInterface, val any) *ZogIssue {
 	e := ZogIssuePool.Get().(*ZogIssue)

pkgs/internals/panics.go

@@ -3,10 +3,7 @@ package internals
 import "fmt"
 
 const (
-	PanicTypeCast                        = "Zog Panic: Type Cast Error\n Current context: %s\n Expected valPtr type to correspond with type defined in schema. But it does not. Expected type: *%T, got: %T\nFor more information see: https://zog.dev/panics#type-cast-errors"
-	PanicTypeCastCoercer                 = "Zog Panic: Type Cast Error\n Current context: %s\n Expected coercer return value to correspond with type defined in schema. But it does not. Expected type: *%T, got: %T\nFor more information see: https://zog.dev/panics#type-cast-errors"
-	PanicMissingStructField              = "Zog Panic: Struct Schema Definition Error\n Current context: %s\n Provided struct is missing expected schema key: %s.\n This means you have made a mistake in your schema definition.\nFor more information see: https://zog.dev/panics#schema-definition-errors"
-	PanicInvalidArgumentsExpectedPointer = "Zog Panic: Expected destination value to be a pointer but it was not. This is generally caused by forgetting to pass a pointer to your Validate/Parse function. Do schema.Validate(&myStruct), not schema.Validate(myStruct) "
+	PanicTypeCastCoercer = "Zog Panic: Type Cast Error\n Current context: %s\n Expected coercer return value to correspond with type defined in schema. But it does not. Expected type: *%T, got: %T\nFor more information see: https://zog.dev/panics#type-cast-errors"
 )
 
 func Panicf(format string, args ...any) {

pkgs/internals/tutils/fakeContext.go

@@ -0,0 +1,17 @@
+package tutils
+
+import (
+	"github.com/Oudwins/zog/conf"
+	"github.com/Oudwins/zog/pkgs/internals"
+	"github.com/Oudwins/zog/zconst"
+)
+
+func FakeContextFromValue(val any, schemaType zconst.ZogType) (*internals.SchemaCtx, *internals.ErrsList) {
+	errs := internals.NewErrsList()
+	ctx := internals.NewExecCtx(errs, conf.IssueFormatter)
+
+	path := internals.NewPathBuilder()
+	sctx := ctx.NewSchemaCtx(val, val, path, schemaType)
+
+	return sctx, errs
+}

preprocess.go

@@ -36,7 +36,8 @@ func (s *PreprocessSchema[F, T]) process(ctx *p.SchemaCtx) {
 func (s *PreprocessSchema[F, T]) validate(ctx *p.SchemaCtx) {
 	v, ok := ctx.ValPtr.(F)
 	if !ok {
-		p.Panicf(p.PanicTypeCast, ctx.String(), new(F), ctx.ValPtr)
+		ctx.AddIssue(ctx.IssueFromInvalidType("preprocess input type", ctx.ValPtr, "validating a preprocessed schema"))
+		return
 	}
 	out, err := s.fn(v, ctx)
 	if err != nil {

struct.go

@@ -89,7 +89,8 @@ func (v *StructSchema) process(ctx *p.SchemaCtx) {
 	structRefVal := reflect.ValueOf(ctx.ValPtr)
 	kind := structRefVal.Kind()
 	if kind != reflect.Pointer && kind != reflect.Interface {
-		p.Panicf(p.PanicInvalidArgumentsExpectedPointer)
+		ctx.AddIssue(ctx.IssueFromInvalidType("pointer to struct", ctx.ValPtr, "processing a struct schema"))
+		return
 	}
 	structVal := structRefVal.Elem()
 	subCtx := ctx.NewSchemaCtx(ctx.Data, ctx.ValPtr, ctx.Path, v.getType())
@@ -105,7 +106,8 @@ func (v *StructSchema) process(ctx *p.SchemaCtx) {
 
 		fieldMeta, ok := structVal.Type().FieldByName(key)
 		if !ok {
-			p.Panicf(p.PanicMissingStructField, ctx.String(), key)
+			ctx.AddIssue(ctx.IssueFromMissingStructField(key))
+			continue
 		}
 		destPtr := structVal.FieldByName(key).Addr().Interface()
 

struct_test.go

@@ -289,9 +289,10 @@ func TestStructPanicsOnSchemaMismatch(t *testing.T) {
 		"bol": true,
 		"tim": "2024-08-06T00:00:00Z",
 	}
-	assert.Panics(t, func() {
-		objSchema.Parse(data, &o)
-	})
+
+	errs := objSchema.Parse(data, &o)
+	assert.NotNil(t, errs)
+	assert.Equal(t, zconst.IssueCodeMissingField, errs[0].Code)
 }
 
 func TestStructPostTransforms(t *testing.T) {

struct_validate_test.go

@@ -218,18 +218,3 @@ func TestValidateStructGetType(t *testing.T) {
 	})
 	assert.Equal(t, zconst.TypeStruct, s.getType())
 }
-
-func TestValidateStructInvalidSchema(t *testing.T) {
-	schema := Struct(Shape{
-		"field": String(),
-	})
-
-	type TestStruct struct {
-		Field int
-	}
-
-	var dest TestStruct
-	assert.Panics(t, func() {
-		schema.Validate(&dest)
-	})
-}

zconst/consts.go

@@ -1,5 +1,7 @@
 package zconst
 
+import "fmt"
+
 const (
 	// ISSUE_KEY_ROOT is the key for root-level issues on complex schemas on flattened maps
 	ISSUE_KEY_ROOT = "$root"
@@ -73,6 +75,12 @@ const (
 	ErrCodeCoerce   ZogErrCode   = "coerce" // all
 	IssueCodeCoerce ZogIssueCode = "coerce" // all
 
+	// Invalid type happens when you provide a boolean to a schema that expects something else.
+	IssueCodeInvalidType ZogIssueCode = "invalid_type"
+
+	// Missing field happens when you provide a schema shape with a field that is not present in the underlying data structure (generally a struct)
+	IssueCodeMissingField ZogIssueCode = "missing_field"
+
 	// Deprecated: Use IssueCodeFallback instead
 	// all. Applied when other errror code is not implemented. Required to be implemented for every zog type!
 	ErrCodeFallback ZogErrCode = "fallback"
@@ -219,3 +227,11 @@ const (
 	ZogProcessorTransform ZogProcessor = "transform"
 	ZogProcessorRequired  ZogProcessor = "required"
 )
+
+func ErrorInvalidTypeMessage(expected string, received any, path string, dtype ZogType, value any, operation string) error {
+	return fmt.Errorf("[invalid type] zog expected a different type from what was provided while %s. This is an invariant. Unless you are using union schema it means you have made a mistake in your code.\nPath: %q\nSchema type: %s\nExpected: %s\nReceived: %T\nValue: %v", operation, path, dtype, expected, received, value)
+}
+
+func ErrorMissingStructField(fieldName string, path string, dtype ZogType, value any) error {
+	return fmt.Errorf("[missing structure field] zog expected struct to match schema but it did not. Provided struct is missing expected schema key. If you are not using union schema it means you have made a mistake in your schema definition.\nPath: %q\nSchema type: %s\nMissing field: %s\nValue: %v\nFor more information see: https://zog.dev/panics#schema-definition-errors", path, dtype, fieldName, value)
+}

zogSchema.go

@@ -57,7 +57,8 @@ func primitiveParsing[T p.ZogPrimitive](ctx *p.SchemaCtx, processors []p.ZProces
 
 	destPtr, ok := ctx.ValPtr.(*T)
 	if !ok {
-		p.Panicf(p.PanicTypeCast, ctx.String(), ctx.DType, ctx.ValPtr)
+		ctx.Errors.Add(ctx.IssueFromInvalidType("pointer matching primitive schema type", ctx.ValPtr, "parsing a primitive schema"))
+		return
 	}
 
 	// 2. cast data to string & handle default/required
@@ -114,7 +115,8 @@ func primitiveValidation[T p.ZogPrimitive](ctx *p.SchemaCtx, processors []p.ZPro
 
 	valPtr, ok := ctx.ValPtr.(*T)
 	if !ok {
-		p.Panicf(p.PanicTypeCast, ctx.String(), ctx.DType, ctx.ValPtr)
+		ctx.Errors.Add(ctx.IssueFromInvalidType("pointer matching primitive schema type", ctx.ValPtr, "validating a primitive schema"))
+		return
 	}
 
 	// 2. cast data to string & handle default/required