field.go

package fmt

// FieldType represents the abstract storage type of a struct field.
type FieldType int

const (
	FieldText   FieldType = iota // Any string
	FieldInt                     // Any integer
	FieldFloat                   // Any float
	FieldBool                    // Boolean
	FieldBlob                    // Binary data ([]byte)
	FieldStruct                  // Nested struct (implements Fielder)
)

var fieldTypeNames = []string{"text", "int", "float", "bool", "blob", "struct"}

func (ft FieldType) String() string {
	if int(ft) >= 0 && int(ft) < len(fieldTypeNames) {
		return fieldTypeNames[ft]
	}
	return "unknown"
}

// Field describes a single field in a struct's schema.
// It provides type metadata, constraint flags, and validation rules
// used by database (orm), transport (json), UI (form), and validation layers.
//
// Validation rules are embedded via Permitted. When a field has validation
// configured, Field.Validate(value) checks the value against all rules.
// Fields without validation rules pass any value.
type Field struct {
	Name      string
	Type      FieldType
	PK        bool
	Unique    bool
	NotNull   bool
	AutoInc   bool
	OmitEmpty bool // omit from JSON when zero value
	Permitted      // embedded: validation rules (characters, min/max)
}

// Validate checks a string value against this field's constraints.
// Checks NotNull first, then delegates to embedded Permitted.
func (f Field) Validate(value string) error {
	if f.NotNull && value == "" {
		return Err(f.Name, "required")
	}
	if value == "" {
		return nil // empty + not required = ok
	}
	// Only run Permitted validation if any rule is configured
	if f.hasPermittedRules() {
		return f.Permitted.Validate(f.Name, value)
	}
	return nil
}

// hasPermittedRules returns true if any Permitted field is non-zero.
func (f Field) hasPermittedRules() bool {
	return f.Letters || f.Tilde || f.Numbers || f.Spaces ||
		f.BreakLine || f.Tab || len(f.Extra) > 0 ||
		len(f.NotAllowed) > 0 || f.Minimum > 0 || f.Maximum > 0 ||
		f.StartWith != nil
}

// Fielder describes any type that can expose its schema and
// writable pointers. It is the shared contract between orm (database),
// form (UI), and json layers, replacing runtime reflection.
//
// Implementations are generated by code generators — never written by hand.
//
// Contract:
//   - Schema() and Pointers() MUST return slices of the same length.
//   - The i-th element in each slice corresponds to the same struct field.
//   - Pointers() returns pointers to fields for reading (dereference) and writing (scan/sync).
type Fielder interface {
	Schema() []Field
	Pointers() []any
}

// Validator is implemented by types that can self-validate.
// Generated by ormc: func (m *X) Validate(action byte) error { if err := fmt.ValidateFields(action, m); err != nil { return err }; return form.ValidateStructFormats(m) }
// Used by form, json.Decode, and orm pre-insert to enforce data integrity.
type Validator interface {
	Validate(action byte) error
}

// Model describes a resource with a schema and a name.
// Standard interface used by DB, Form, and API layers.
type Model interface {
	Fielder
	ModelName() string
}

// SafeFields combines schema access with validation.
// Handlers that receive user input should accept SafeFields
// to enforce compile-time validation guarantees.
type SafeFields interface {
	Fielder
	Validator
}

// ValidateFields validates all fields of a Fielder based on the action ('c', 'u', 'd').
// For each FieldText field, reads the string value and calls Field.Validate.
// For non-text fields with NotNull, checks against zero value.
//
// This is the single validation entry point — ormc-generated Validate()
// methods call this function first.
func ValidateFields(action byte, f Fielder) error {
	schema := f.Schema()
	ptrs := f.Pointers()
	for i, field := range schema {
		// 'd' delete: only PK required, skip everything else
		if action == 'd' {
			if field.PK {
				switch field.Type {
				case FieldText:
					val, _ := ReadStringPtr(ptrs[i])
					if val == "" {
						return Err(field.Name, "required")
					}
				default:
					if isZeroPtr(ptrs[i], field.Type) {
						return Err(field.Name, "required")
					}
				}
			}
			continue
		}

		// 'c' create: skip PK+AutoInc (DB assigns it)
		if action == 'c' && field.PK && field.AutoInc {
			continue
		}

		switch field.Type {
		case FieldText:
			val, _ := ReadStringPtr(ptrs[i])

			// PK always required (in 'c' without AutoInc, in 'u', and any other)
			if field.PK && val == "" {
				return Err(field.Name, "required")
			}

			if err := field.Validate(val); err != nil {
				return err
			}

		case FieldStruct:
			// Recursive validation for nested structs
			if validator, ok := ptrs[i].(Validator); ok {
				if err := validator.Validate(action); err != nil {
					return err
				}
			} else if fielder, ok := ptrs[i].(Fielder); ok {
				if err := ValidateFields(action, fielder); err != nil {
					return err
				}
			}

		default:
			// PK always required
			if field.PK && isZeroPtr(ptrs[i], field.Type) {
				return Err(field.Name, "required")
			}
			// Non-text fields: only check NotNull (zero value check)
			if field.NotNull && isZeroPtr(ptrs[i], field.Type) {
				return Err(field.Name, "required")
			}
		}
	}
	return nil
}

// isZeroPtr checks if a pointer points to a zero value.
func isZeroPtr(ptr any, ft FieldType) bool {
	switch ft {
	case FieldInt:
		switch p := ptr.(type) {
		case *int64:
			return *p == 0
		case *int:
			return *p == 0
		case *int32:
			return *p == 0
		case *uint:
			return *p == 0
		case *uint32:
			return *p == 0
		case *uint64:
			return *p == 0
		}
	case FieldFloat:
		switch p := ptr.(type) {
		case *float64:
			return *p == 0
		case *float32:
			return *p == 0
		}
	case FieldBool:
		if p, ok := ptr.(*bool); ok {
			return !*p
		}
	case FieldBlob:
		if p, ok := ptr.(*[]byte); ok {
			return len(*p) == 0
		}
	}
	return false
}

// ReadValues reads field values through Pointers by dereferencing based on FieldType.
// Used by consumers that need []any (e.g., orm for SQL args).
// Hot-path consumers (json, form) should read through Pointers directly to avoid boxing.
func ReadValues(schema []Field, ptrs []any) []any {
	vals := make([]any, len(schema))
	for i, f := range schema {
		if ptrs[i] == nil {
			continue
		}
		switch f.Type {
		case FieldText:
			if p, ok := ptrs[i].(*string); ok && p != nil {
				vals[i] = *p
			}
		case FieldInt:
			switch p := ptrs[i].(type) {
			case *int64:
				if p != nil {
					vals[i] = *p
				}
			case *int:
				if p != nil {
					vals[i] = *p
				}
			case *int32:
				if p != nil {
					vals[i] = *p
				}
			case *uint:
				if p != nil {
					vals[i] = *p
				}
			case *uint32:
				if p != nil {
					vals[i] = *p
				}
			case *uint64:
				if p != nil {
					vals[i] = *p
				}
			}
		case FieldFloat:
			switch p := ptrs[i].(type) {
			case *float64:
				if p != nil {
					vals[i] = *p
				}
			case *float32:
				if p != nil {
					vals[i] = *p
				}
			}
		case FieldBool:
			if p, ok := ptrs[i].(*bool); ok && p != nil {
				vals[i] = *p
			}
		case FieldBlob:
			if p, ok := ptrs[i].(*[]byte); ok && p != nil {
				vals[i] = *p
			}
		case FieldStruct:
			vals[i] = ptrs[i] // pointer to nested struct IS the Fielder
		}
	}
	return vals
}

// ReadStringPtr reads a string from a typed pointer.
// Returns the string value and true if the pointer is *string, or ("", false) otherwise.
func ReadStringPtr(ptr any) (string, bool) {
	if p, ok := ptr.(*string); ok && p != nil {
		return *p, true
	}
	return "", false
}