Draft - enforce typed structs and validation rules with draft schema

Your Libraries & OS Mentoring Libraries
, , , , , ,
1

Define typed structs with built-in validation. Draft allows developers to describe the structure of data and enforce constraints when constructing structs, helping ensure that invalid data never enters your domain.

Instead of passing loosely shaped maps through your application, Draft lets you define clear schemas for your data while keeping things lightweight and independent from persistence layers.

Example

defmodule Book do
  use Draft.Schema

  schema required: true do
    field :id, :string
    field :title, :string, min: 1, max: 32
    field :author_id, :string
    field :isbn, :integer
  end
end

Creating a struct:

book = Book.new(%{id: "1", title: "Draft", author_id: "a1", isbn: 1234})
{:ok, book} = Book.cast(%{id: "1", title: "Draft", author_id: "a1", isbn: 1234})
{:error, errors} = Book.cast(%{id: "1", title: "", author_id: "a1"})

Draft validates the data against the schema and returns a properly constructed struct when the input is valid.

When the data is valid:

{:ok, book} = Draft.validate(%Book{id: "1", title: "Draft", author_id: "a1", isbn: 1234})

Why Draft?

Elixir makes it easy to work with maps and structs, but validation and shape guarantees are often left to ad-hoc code or external systems. Draft provides a simple way to:

  • Define data schemas

  • Enforce types and constraints

  • Safely construct validated structs

  • Keep domain models independent of databases or frameworks

  • Cast and validate structured outputs from LLMs before using them in your system

When working with LLMs, responses are often returned as JSON or maps. Draft can be used as a guard layer to ensure the generated data matches the expected structure and constraints before it enters your application logic.

Use cases

Draft is useful in situations where you want validated data structures without introducing database dependencies, such as:

  • Domain models

  • API request/response validation

  • Configuration structures

  • Internal application data

  • Casting and validating LLM outputs (for example, ensuring generated JSON matches the expected schema before it is used)

Status

Draft is currently in active development and feedback from the community is welcome.

Links

Hex: https://hex.pm/packages/draft
Documentation: https://hexdocs.pm/draft

7 Likes
2

Inheritance in Draft (Docs Update)

Draft supports schema inheritance, making it easier to reuse common fields across forms and domain models.A typical pattern is extracting shared fields like id and user_id into a base schema, then extending it across your app.

Base schema

defmodule Entity do
  use Draft.Schema

  schema do
    field :id,         :uuid
    field :user_id,    :uuid
    field :name,       :string
    field :role,       :string
  end
end

Extending for different forms

defmodule User do
  use Draft.Schema

  schema extends: Entity do
    field :email, :string
  end
end

defmodule Agent do
  use Draft.Schema

  schema extends: Entity do    
    field :active, :boolean
  end
end

Both User and Agent now share all base fields while defining their own.

Required fields propagate

defmodule Entity do
  use Draft.Schema

  schema required: true do
    field :id,      :uuid
    field :user_id, :uuid
  end
end

defmodule User do
  use Draft.Schema

  schema extends: Entity do
    field :email, :string, required: true
  end
end

User.new(email: "test@example.com")
# raises — :id and :user_id are required

Multi-level inheritance

defmodule Timestamps do
  use Draft.Schema

  schema do
    field :created_at, :datetime
    field :updated_at, :datetime
  end
end

defmodule Entity do
  use Draft.Schema

  schema extends: Timestamps do
    field :id, :uuid
    field :user_id, :uuid
  end
end

defmodule Agent do
  use Draft.Schema

  schema extends: Entity do
    field :role, :string
  end
end

Multiple inheritance

defmodule SoftDelete do
  use Draft.Schema

  schema do
    field :deleted_at, :datetime
  end
end

defmodule Agent do
  use Draft.Schema

  schema extends: [Entity, SoftDelete] do
    field :role, :string
  end
end

Overwriting inherited fields

defmodule User do
  use Draft.Schema

  schema extends: Entity do
    field :email, :string
  end
end

defmodule Agent do
  use Draft.Schema

  schema extends: User do
    field :email, :string, overwrite: true, format: :email
  end
end

Inheritance lets you define common form fields once and reuse them everywhere. While still allowing specialization, stricter validation, or composition when needed. This keeps your schemas consistent and eliminates duplication across forms, APIs, and internal models.

1 Like
3

You might want to take a look at estructura, e. g. for the inspiration. It supports deeply nested structs, custom types with coercion and validation, andalso data generation for property-based testing.

1 Like