cquill/changeset

Types

Changeset

A changeset represents a set of changes to be validated and applied. It tracks the original data, changes, and any validation errors.

pub type Changeset {
  Changeset(
    data: option.Option(dict.Dict(String, dynamic.Dynamic)),
    changes: dict.Dict(String, dynamic.Dynamic),
    errors: dict.Dict(String, List(ValidationError)),
    valid: Bool,
    validated_fields: List(String),
  )
}

Constructors

Changeset(
  data: option.Option(dict.Dict(String, dynamic.Dynamic)),
  changes: dict.Dict(String, dynamic.Dynamic),
  errors: dict.Dict(String, List(ValidationError)),
  valid: Bool,
  validated_fields: List(String),
)

Arguments

data: The original data (if updating existing record)
changes: The changes/new values being applied
errors: Validation errors by field name
valid: Whether the changeset is valid (no errors)
validated_fields: Fields that were validated

LengthConstraint

</>

Length constraint details

pub type LengthConstraint {
  MinLength(min: Int)
  MaxLength(max: Int)
  ExactLength(length: Int)
  RangeLength(min: Int, max: Int)
}

Constructors

```
MinLength(min: Int)
```
```
MaxLength(max: Int)
```
```
ExactLength(length: Int)
```
```
RangeLength(min: Int, max: Int)
```

ValidationError

</>

A validation error for a specific field

pub type ValidationError {
  ValidationError(message: String, validation: ValidationType)
}

Constructors

```
ValidationError(message: String, validation: ValidationType)
```
Arguments

message

The error message

validation

The validation type that failed

ValidationType

</>

Types of validations that can fail

pub type ValidationType {
  Required
  Format
  Length(constraint: LengthConstraint)
  Inclusion
  Exclusion
  Range
  Custom(name: String)
  Uniqueness
  Confirmation
  Acceptance
}

Constructors

```
Required
```
Field is required but missing or empty
```
Format
```
Field format doesn’t match pattern
```
Length(constraint: LengthConstraint)
```
Field length is invalid
```
Inclusion
```
Field value is not in allowed list
```
Exclusion
```
Field value is in excluded list
```
Range
```
Numeric value out of range
```
Custom(name: String)
```
Custom validation failed
```
Uniqueness
```
Field must be unique (checked externally)
```
Confirmation
```
Confirmation field doesn’t match
```
Acceptance
```
Field must be accepted (for terms, etc.)

Values

add_error

</>

pub fn add_error(
  changeset: Changeset,
  field: String,
  message: String,
  validation: ValidationType,
) -> Changeset

Add an error to the changeset

all_errors

</>

pub fn all_errors(
  changeset: Changeset,
) -> List(#(String, ValidationError))

Get all errors as a list of (field, error) tuples

apply

</>

pub fn apply(
  changeset: Changeset,
) -> Result(
  dict.Dict(String, dynamic.Dynamic),
  dict.Dict(String, List(ValidationError)),
)

Apply the changeset and return the result Returns Ok(changes) if valid, Error(errors) if invalid

change

</>

pub fn change(
  existing: dict.Dict(String, dynamic.Dynamic),
  changes: dict.Dict(String, dynamic.Dynamic),
) -> Changeset

Create a changeset for updating existing data

clear_all_errors

</>

pub fn clear_all_errors(changeset: Changeset) -> Changeset

Clear all errors from the changeset

clear_errors

</>

pub fn clear_errors(
  changeset: Changeset,
  field: String,
) -> Changeset

Clear all errors for a specific field

delete_change

</>

pub fn delete_change(
  changeset: Changeset,
  field: String,
) -> Changeset

Delete a change from the changeset

empty

</>

pub fn empty() -> Changeset

Create an empty changeset (useful for forms)

error_count

</>

pub fn error_count(changeset: Changeset) -> Int

Count the total number of validation errors across all fields Returns the sum of all errors on all fields

force_change

</>

pub fn force_change(
  changeset: Changeset,
  field: String,
  value: dynamic.Dynamic,
) -> Changeset

Force a change even if validation would fail Use with caution — this bypasses validation for the field

format_errors

</>

pub fn format_errors(changeset: Changeset) -> String

Format all errors as a human-readable string

format_field_errors

</>

pub fn format_field_errors(
  changeset: Changeset,
  field: String,
) -> String

Format errors for a specific field

get_change

</>

pub fn get_change(
  changeset: Changeset,
  field: String,
) -> option.Option(dynamic.Dynamic)

Get a change value from the changeset

get_changes

</>

pub fn get_changes(
  changeset: Changeset,
) -> dict.Dict(String, dynamic.Dynamic)

Get the changes from the changeset (regardless of validity)

get_data

</>

pub fn get_data(
  changeset: Changeset,
) -> option.Option(dict.Dict(String, dynamic.Dynamic))

Get the original data (if this is an update changeset)

get_errors

</>

pub fn get_errors(
  changeset: Changeset,
  field: String,
) -> List(ValidationError)

Get errors for a specific field

has_error

</>

pub fn has_error(changeset: Changeset, field: String) -> Bool

Check if a specific field has errors

has_errors

</>

pub fn has_errors(changeset: Changeset) -> Bool

Check if the changeset has any validation errors This is a convenience function to check if any field has errors

is_valid

</>

pub fn is_valid(changeset: Changeset) -> Bool

Check if the changeset is valid

merge_changes

</>

pub fn merge_changes(
  changeset: Changeset,
) -> dict.Dict(String, dynamic.Dynamic)

Merge changes from the changeset with the original data For updates, this combines old data with new changes

new

</>

pub fn new(
  changes: dict.Dict(String, dynamic.Dynamic),
) -> Changeset

Create a new changeset from input data (for inserts)

put_change

</>

pub fn put_change(
  changeset: Changeset,
  field: String,
  value: dynamic.Dynamic,
) -> Changeset

Put a change into the changeset

validate_acceptance

</>

pub fn validate_acceptance(
  changeset: Changeset,
  field: String,
) -> Changeset

Validate that a boolean field is true (for accepting terms, etc.)

validate_confirmation

</>

pub fn validate_confirmation(
  changeset: Changeset,
  field: String,
  confirmation_field: String,
) -> Changeset

Validate that a confirmation field matches the original field e.g., password and password_confirmation

validate_custom

</>

pub fn validate_custom(
  changeset: Changeset,
  field: String,
  name: String,
  validator: fn(Changeset) -> Result(Nil, String),
) -> Changeset

Apply a custom validation function The function should return Ok(Nil) if valid, or Error(message) if invalid

validate_exclusion

</>

pub fn validate_exclusion(
  changeset: Changeset,
  field: String,
  excluded: List(String),
) -> Changeset

Validate that a field value is NOT in a list of excluded values

validate_format

</>

pub fn validate_format(
  changeset: Changeset,
  field: String,
  pattern: String,
) -> Changeset

Validate that a string field matches a regex pattern

validate_if_present

</>

pub fn validate_if_present(
  changeset: Changeset,
  field: String,
  validator: fn(Changeset) -> Changeset,
) -> Changeset

Validate a field only if it is present (non-nil) Useful for optional fields that have constraints when provided

validate_inclusion

</>

pub fn validate_inclusion(
  changeset: Changeset,
  field: String,
  allowed: List(String),
) -> Changeset

Validate that a field value is in a list of allowed values

validate_length

</>

pub fn validate_length(
  changeset: Changeset,
  field: String,
  min min: Int,
  max max: Int,
) -> Changeset

Validate string length with min and max constraints

validate_length_exact

</>

pub fn validate_length_exact(
  changeset: Changeset,
  field: String,
  length: Int,
) -> Changeset

Validate string length with exact length constraint

validate_length_max

</>

pub fn validate_length_max(
  changeset: Changeset,
  field: String,
  max: Int,
) -> Changeset

Validate string length with maximum constraint

validate_length_min

</>

pub fn validate_length_min(
  changeset: Changeset,
  field: String,
  min: Int,
) -> Changeset

Validate string length with minimum constraint

validate_number_range

</>

pub fn validate_number_range(
  changeset: Changeset,
  field: String,
  min min: option.Option(Int),
  max max: option.Option(Int),
) -> Changeset

Validate that a numeric field is within a range

validate_required

</>

pub fn validate_required(
  changeset: Changeset,
  fields: List(String),
) -> Changeset

Validate that the specified fields are present and non-empty