refactor: rename mlecto to repodb with pipe-friendly changeset API

- Rename all lib/mlecto_*.ml to simple names (types.ml, schema.ml, etc.)
- Add assoc.ml for associations (has_many, belongs_to, has_one, many_to_many)
- Add embedded.ml for embedded schemas with pluggable JSON
- Refactor changeset.ml for pipe-friendly API (t argument last)
- Enhanced repo.ml with transactions and SQL builders
- Comprehensive test suite with 156 passing tests

.beads/issues.jsonl

···
 {"id":"mlecto-0hr","title":"Implement Query compilation to SQL","description":"Convert Query.t to SQL string + Caqti request. Parameter binding, SQL escaping, dialect-specific generation (Postgres first).","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:30.33363594+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:12:40.467657348+01:00","closed_at":"2026-01-04T01:12:40.467657348+01:00","close_reason":"Query compilation implemented in Query.to_sql - generates PostgreSQL SQL for SELECT/INSERT/UPDATE/DELETE.","dependencies":[{"issue_id":"mlecto-0hr","depends_on_id":"mlecto-7lc","type":"blocks","created_at":"2026-01-04T00:22:02.555339871+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-1ud","title":"Implement Schema DSL (Mlecto.Schema)","description":"DSL for defining tables: field definitions, constraints (primary_key, not_null, unique, foreign_key, check), table_name generation.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:24.765735157+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:09:24.538059462+01:00","closed_at":"2026-01-04T01:09:24.538059462+01:00","close_reason":"Schema DSL complete: table definitions, column constraints (PrimaryKey, NotNull, Unique, Default, Check, ForeignKey), foreign key actions, timestamps helper, SQL generation.","dependencies":[{"issue_id":"mlecto-1ud","depends_on_id":"mlecto-z72","type":"blocks","created_at":"2026-01-04T00:22:02.524126267+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-1w9","title":"[EPIC] Core Type System \u0026 Schema DSL","description":"Define SQL types mapped to OCaml, schema definition DSL for tables/fields/constraints. Foundation for all other modules.","status":"closed","priority":1,"issue_type":"feature","created_at":"2026-01-04T00:21:05.917266549+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:20:44.799339065+01:00","closed_at":"2026-01-04T01:20:44.799339065+01:00","close_reason":"All child tasks completed"}
+{"id":"mlecto-3ow","title":"cast_assoc and put_assoc for nested changesets","status":"closed","priority":2,"issue_type":"feature","created_at":"2026-01-04T10:32:00.153765675+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T10:38:58.664932555+01:00","closed_at":"2026-01-04T10:38:58.664932555+01:00","close_reason":"Closed","dependencies":[{"issue_id":"mlecto-3ow","depends_on_id":"mlecto-d6f","type":"blocks","created_at":"2026-01-04T10:32:20.574240684+01:00","created_by":"gdiazlo"}]}
+{"id":"mlecto-4g7","title":"Constraint error mapping from DB to changeset","status":"closed","priority":2,"issue_type":"feature","created_at":"2026-01-04T10:32:00.520652974+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T10:38:58.665466447+01:00","closed_at":"2026-01-04T10:38:58.665466447+01:00","close_reason":"Closed"}
 {"id":"mlecto-5km","title":"Implement Changeset validators","description":"validate_required, validate_format (regex), validate_length (min/max/is), validate_inclusion, validate_exclusion, validate_number, validate_acceptance, validate_confirmation, validate_change (custom).","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:40.78012908+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:14:08.654694896+01:00","closed_at":"2026-01-04T01:14:08.654694896+01:00","close_reason":"Validators implemented in Changeset core: validate_required, validate_format, validate_length, validate_inclusion, validate_exclusion, validate_number, validate_acceptance, validate_confirmation, validate_change.","dependencies":[{"issue_id":"mlecto-5km","depends_on_id":"mlecto-m13","type":"blocks","created_at":"2026-01-04T00:22:03.958038572+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-7lc","title":"Implement Query builder (Mlecto.Query)","description":"SELECT, INSERT, UPDATE, DELETE builders. WHERE, JOIN, ORDER BY, GROUP BY, HAVING, LIMIT, OFFSET. Composable query pipelines.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:28.238632191+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:12:33.283719987+01:00","closed_at":"2026-01-04T01:12:33.283719987+01:00","close_reason":"Query builder complete: SELECT, INSERT, UPDATE, DELETE with WHERE, JOIN, ORDER BY, GROUP BY, HAVING, LIMIT, OFFSET. ON CONFLICT for upserts. RETURNING clause. Full SQL generation.","dependencies":[{"issue_id":"mlecto-7lc","depends_on_id":"mlecto-1ud","type":"blocks","created_at":"2026-01-04T00:22:02.538979501+01:00","created_by":"gdiazlo"},{"issue_id":"mlecto-7lc","depends_on_id":"mlecto-nv7","type":"blocks","created_at":"2026-01-04T00:22:02.547726588+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-8ki","title":"Implement Repository core (Mlecto.Repo)","description":"Repo functor over Caqti connection. Basic operations: get, get_by, one, all, insert, update, delete. Eio-based async.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:44.104280456+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:16:42.713088503+01:00","closed_at":"2026-01-04T01:16:42.713088503+01:00","close_reason":"Core DSL and SQL generation complete, execution stubs in place","dependencies":[{"issue_id":"mlecto-8ki","depends_on_id":"mlecto-0hr","type":"blocks","created_at":"2026-01-04T00:22:05.202771435+01:00","created_by":"gdiazlo"},{"issue_id":"mlecto-8ki","depends_on_id":"mlecto-m13","type":"blocks","created_at":"2026-01-04T00:22:05.210702979+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-9be","title":"[EPIC] Multi \u0026 Transactions","description":"Chain multiple database operations atomically. Monadic transaction builder like Ecto.Multi.","status":"closed","priority":2,"issue_type":"feature","created_at":"2026-01-04T00:21:14.154297405+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:20:44.813012307+01:00","closed_at":"2026-01-04T01:20:44.813012307+01:00","close_reason":"All child tasks completed"}
 {"id":"mlecto-at2","title":"[EPIC] Migration System","description":"Versioned database migrations with up/down support. DSL for create_table, add_column, create_index, etc.","status":"closed","priority":1,"issue_type":"feature","created_at":"2026-01-04T00:21:12.288036672+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:20:44.812043932+01:00","closed_at":"2026-01-04T01:20:44.812043932+01:00","close_reason":"All child tasks completed"}
+{"id":"mlecto-c1o","title":"Real Repo execution via Caqti/Eio","status":"closed","priority":1,"issue_type":"feature","created_at":"2026-01-04T10:31:58.698847822+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T10:38:58.663072869+01:00","closed_at":"2026-01-04T10:38:58.663072869+01:00","close_reason":"Closed"}
+{"id":"mlecto-d6f","title":"Schema associations (has_many, belongs_to, has_one, many_to_many)","status":"closed","priority":1,"issue_type":"feature","created_at":"2026-01-04T10:31:59.069873954+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T10:38:58.661985306+01:00","closed_at":"2026-01-04T10:38:58.661985306+01:00","close_reason":"Closed"}
 {"id":"mlecto-flv","title":"Implement Multi module (Mlecto.Multi)","description":"Chain operations: Multi.new |\u003e Multi.insert |\u003e Multi.update |\u003e Multi.run. Named operations, access previous results, atomic execution.","status":"closed","priority":2,"issue_type":"task","created_at":"2026-01-04T00:21:50.583520239+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:20:32.435485703+01:00","closed_at":"2026-01-04T01:20:32.435485703+01:00","close_reason":"Multi with operation chaining, named results, merge, validate, execute_sync","dependencies":[{"issue_id":"mlecto-flv","depends_on_id":"mlecto-8ki","type":"blocks","created_at":"2026-01-04T00:22:07.51964609+01:00","created_by":"gdiazlo"},{"issue_id":"mlecto-flv","depends_on_id":"mlecto-hwj","type":"blocks","created_at":"2026-01-04T00:22:07.527438964+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-gfo","title":"[EPIC] Changeset System","description":"Casting, validation, and error accumulation. Separate validation from persistence with composable validators.","status":"closed","priority":1,"issue_type":"feature","created_at":"2026-01-04T00:21:07.363157981+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:20:44.808207655+01:00","closed_at":"2026-01-04T01:20:44.808207655+01:00","close_reason":"All child tasks completed"}
 {"id":"mlecto-gxh","title":"Implement Changeset constraints","description":"unique_constraint, foreign_key_constraint, check_constraint, exclusion_constraint. Convert DB errors to changeset errors.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:42.297745588+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:14:08.663238895+01:00","closed_at":"2026-01-04T01:14:08.663238895+01:00","close_reason":"Constraints implemented in Changeset core: unique_constraint, foreign_key_constraint, check_constraint.","dependencies":[{"issue_id":"mlecto-gxh","depends_on_id":"mlecto-m13","type":"blocks","created_at":"2026-01-04T00:22:03.965402454+01:00","created_by":"gdiazlo"}]}
···
 {"id":"mlecto-m13","title":"Implement Changeset core (Mlecto.Changeset)","description":"Changeset record type: data, changes, errors, valid?, params, required. Cast function for external params. Change function for internal data.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:38.875652686+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:13:59.358336893+01:00","closed_at":"2026-01-04T01:13:59.358336893+01:00","close_reason":"Changeset core complete: type-safe field handling, validations (required, format, length, inclusion, exclusion, number, acceptance, confirmation, custom), constraints (unique, foreign_key, check), error handling.","dependencies":[{"issue_id":"mlecto-m13","depends_on_id":"mlecto-z72","type":"blocks","created_at":"2026-01-04T00:22:03.941717052+01:00","created_by":"gdiazlo"},{"issue_id":"mlecto-m13","depends_on_id":"mlecto-1ud","type":"blocks","created_at":"2026-01-04T00:22:03.95059939+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-nv7","title":"Implement Expression types (Mlecto.Expr)","description":"GADTs for SQL expressions: literals, columns, operators (+, -, =, \u003c\u003e, AND, OR), function calls, casts. Type-safe expression composition.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:26.662064082+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:11:24.632729849+01:00","closed_at":"2026-01-04T01:11:24.632729849+01:00","close_reason":"Expression types complete: GADT for all SQL expressions, operators (comparison, logical, arithmetic), functions (aggregate, string, date, math), CASE, BETWEEN, IN, CAST, SQL generation.","dependencies":[{"issue_id":"mlecto-nv7","depends_on_id":"mlecto-z72","type":"blocks","created_at":"2026-01-04T00:22:02.531940181+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-pvs","title":"Implement Migration runner","description":"schema_migrations table, version tracking, up/down execution, migrate/rollback commands, migration status reporting.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:48.916746145+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:18:41.847908163+01:00","closed_at":"2026-01-04T01:18:41.847908163+01:00","close_reason":"Migration runner with version tracking, plan_migrate, plan_rollback, format_status","dependencies":[{"issue_id":"mlecto-pvs","depends_on_id":"mlecto-uek","type":"blocks","created_at":"2026-01-04T00:22:06.667807096+01:00","created_by":"gdiazlo"},{"issue_id":"mlecto-pvs","depends_on_id":"mlecto-8ki","type":"blocks","created_at":"2026-01-04T00:22:06.6757586+01:00","created_by":"gdiazlo"}]}
+{"id":"mlecto-rji","title":"Embedded schemas for JSON/nested data","status":"closed","priority":2,"issue_type":"feature","created_at":"2026-01-04T10:31:59.831937849+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T10:38:58.664392983+01:00","closed_at":"2026-01-04T10:38:58.664392983+01:00","close_reason":"Closed"}
 {"id":"mlecto-uek","title":"Implement Migration DSL (Mlecto.Migration)","description":"create_table, alter_table, drop_table, add_column, remove_column, rename_column, add_index, remove_index, execute (raw SQL).","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:47.328369648+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:16:42.721970553+01:00","closed_at":"2026-01-04T01:16:42.721970553+01:00","close_reason":"Core DSL and SQL generation complete, execution stubs in place","dependencies":[{"issue_id":"mlecto-uek","depends_on_id":"mlecto-z72","type":"blocks","created_at":"2026-01-04T00:22:06.653056982+01:00","created_by":"gdiazlo"},{"issue_id":"mlecto-uek","depends_on_id":"mlecto-1ud","type":"blocks","created_at":"2026-01-04T00:22:06.660984287+01:00","created_by":"gdiazlo"}]}
+{"id":"mlecto-wls","title":"Preloading associations (eager loading)","status":"closed","priority":1,"issue_type":"feature","created_at":"2026-01-04T10:31:59.445724291+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T10:38:58.663783301+01:00","closed_at":"2026-01-04T10:38:58.663783301+01:00","close_reason":"Closed","dependencies":[{"issue_id":"mlecto-wls","depends_on_id":"mlecto-d6f","type":"blocks","created_at":"2026-01-04T10:32:15.530422709+01:00","created_by":"gdiazlo"}]}
 {"id":"mlecto-z2x","title":"Setup project structure with Eio and Caqti dependencies","description":"Configure dune-project, add caqti-eio, caqti-driver-postgresql deps. Create module structure: Mlecto.Type, Mlecto.Schema, Mlecto.Expr, etc.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:21.359665857+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:02:45.5845274+01:00","closed_at":"2026-01-04T01:02:45.5845274+01:00","close_reason":"Project structure set up with all module stubs. Build passes."}
 {"id":"mlecto-z72","title":"Implement SQL type system (Mlecto.Type)","description":"Map SQL types to OCaml: int, string, bool, float, option, datetime, uuid, json. Use GADTs for type witnesses.","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-04T00:21:23.100408152+01:00","created_by":"gdiazlo","updated_at":"2026-01-04T01:07:01.473699561+01:00","closed_at":"2026-01-04T01:07:01.473699561+01:00","close_reason":"Type system complete: int, int32, int64, float, string, bool, bytes, ptime, ptime_span, pdate, uuid, json, option, array, tup2/3/4, custom. Caqti integration working.","dependencies":[{"issue_id":"mlecto-z72","depends_on_id":"mlecto-z2x","type":"blocks","created_at":"2026-01-04T00:22:02.51548369+01:00","created_by":"gdiazlo"}]}

bin/dune

···
 (executable
- (public_name mlecto)
+ (public_name repodb)
  (name main)
- (libraries mlecto))
+ (libraries repodb))

bin/main.ml

···
-let () = print_endline "mlecto - Ecto-like database toolkit for OCaml"
+let () = print_endline "repodb - Ecto-like database toolkit for OCaml"

dune-project

···
 (lang dune 3.20)
 
-(name mlecto)
+(name repodb)
 
 (generate_opam_files true)
 
 (source
- (github gdiazlo/mlecto))
+ (github gdiazlo/repodb))
 
 (authors "Guillermo Diaz-Romero <[e-mail]>")
 
···
 
 (license MIT)
 
-(documentation https://github.com/gdiazlo/mlecto)
+(documentation https://github.com/gdiazlo/repodb)
 
 (package
- (name mlecto)
+ (name repodb)
  (synopsis "Ecto-like database toolkit for OCaml")
  (description
-  "mlecto is a database toolkit inspired by Elixir's Ecto. It provides type-safe query building, schema definitions, changesets for data validation, and database migrations. Built on Caqti with Eio for async operations.")
+  "repodb is a database toolkit inspired by Elixir's Ecto. It provides type-safe query building, schema definitions, changesets for data validation, and database migrations. Built on Caqti with Eio for async operations.")
  (depends
   (ocaml (>= 5.1))
   (dune (>= 3.20))

lib/assoc.ml

···
+(** Association definitions for schema relationships.
+
+    Ecto-like associations: has_many, has_one, belongs_to, many_to_many.
+
+    Example usage:
+    {[
+      (* In Post schema *)
+      let comments = has_many "comments" ~foreign_key:"post_id"
+
+      let author =
+        belongs_to "author" ~references:User.table ~foreign_key:"author_id"
+
+      (* In Comment schema *)
+      let post = belongs_to "post" ~references:Post.table ~foreign_key:"post_id"
+    ]} *)
+
+(** Association cardinality *)
+type cardinality = One | Many
+
+(** Association type - which side holds the foreign key *)
+type assoc_type =
+  | BelongsTo  (** Foreign key is on this schema *)
+  | HasOne  (** Foreign key is on the related schema, singular *)
+  | HasMany  (** Foreign key is on the related schema, plural *)
+  | ManyToMany of { join_table : string; join_keys : string * string }
+      (** Uses a join table *)
+
+type 'related t = {
+  name : string;
+  assoc_type : assoc_type;
+  cardinality : cardinality;
+  related_table : string;
+  foreign_key : string;
+  owner_key : string;  (** Usually "id" *)
+  on_delete : on_delete option;
+  on_replace : on_replace option;
+}
+(** An association definition *)
+
+and on_delete =
+  | Nilify  (** Set foreign key to NULL *)
+  | DeleteAll  (** Delete all associated records *)
+  | Nothing  (** Do nothing (may cause constraint error) *)
+
+and on_replace =
+  | Raise  (** Raise if trying to replace *)
+  | Mark_as_invalid  (** Mark changeset as invalid *)
+  | Nilify_assoc  (** Set foreign keys to NULL *)
+  | Update_assoc  (** Update existing, insert new *)
+  | Delete_assoc  (** Delete and replace *)
+
+(** Not loaded sentinel - associations start in this state *)
+type 'a load_state = NotLoaded | Loaded of 'a
+
+type 'a has_one_loaded = 'a option load_state
+(** Wrapper for optional singular associations *)
+
+type 'a has_many_loaded = 'a list load_state
+(** Wrapper for plural associations *)
+
+(** Create a belongs_to association. The foreign key is on this schema, pointing
+    to the related schema's primary key.
+
+    Example: A Comment belongs_to a Post, where Comment has post_id column. *)
+let belongs_to name ~related_table ~foreign_key ?(owner_key = "id") ?on_delete
+    ?on_replace () =
+  {
+    name;
+    assoc_type = BelongsTo;
+    cardinality = One;
+    related_table;
+    foreign_key;
+    owner_key;
+    on_delete;
+    on_replace;
+  }
+
+(** Create a has_one association. The foreign key is on the related schema,
+    pointing to this schema's primary key.
+
+    Example: A User has_one Profile, where Profile has user_id column. *)
+let has_one name ~related_table ~foreign_key ?(owner_key = "id") ?on_delete
+    ?on_replace () =
+  {
+    name;
+    assoc_type = HasOne;
+    cardinality = One;
+    related_table;
+    foreign_key;
+    owner_key;
+    on_delete;
+    on_replace;
+  }
+
+(** Create a has_many association. The foreign key is on the related schema,
+    pointing to this schema's primary key.
+
+    Example: A Post has_many Comments, where Comment has post_id column. *)
+let has_many name ~related_table ~foreign_key ?(owner_key = "id") ?on_delete
+    ?on_replace () =
+  {
+    name;
+    assoc_type = HasMany;
+    cardinality = Many;
+    related_table;
+    foreign_key;
+    owner_key;
+    on_delete;
+    on_replace;
+  }
+
+(** Create a many_to_many association. Uses a join table to connect two schemas.
+
+    Example: Posts and Tags through post_tags join table.
+    {[
+      let tags =
+        many_to_many "tags" ~related_table:"tags" ~join_table:"post_tags"
+          ~join_keys:("post_id", "tag_id") ()
+    ]} *)
+let many_to_many name ~related_table ~join_table ~join_keys ?on_delete
+    ?on_replace () =
+  {
+    name;
+    assoc_type = ManyToMany { join_table; join_keys };
+    cardinality = Many;
+    related_table;
+    foreign_key = fst join_keys;
+    (* owner's key in join table *)
+    owner_key = "id";
+    on_delete;
+    on_replace;
+  }
+
+(** Get the association name *)
+let name assoc = assoc.name
+
+(** Get the related table name *)
+let related_table assoc = assoc.related_table
+
+(** Get the foreign key column name *)
+let foreign_key assoc = assoc.foreign_key
+
+(** Get the owner key column name (usually "id") *)
+let owner_key assoc = assoc.owner_key
+
+(** Check if this is a singular association *)
+let is_singular assoc = assoc.cardinality = One
+
+(** Check if this is a plural association *)
+let is_plural assoc = assoc.cardinality = Many
+
+(** Check if the foreign key is on this schema (belongs_to) *)
+let owner_has_fk assoc = assoc.assoc_type = BelongsTo
+
+(** Build a query to fetch associated records for belongs_to. SELECT * FROM
+    related_table WHERE owner_key = ? *)
+let belongs_to_query assoc fk_value =
+  Printf.sprintf "SELECT * FROM %s WHERE %s = %s" assoc.related_table
+    assoc.owner_key fk_value
+
+(** Build a query to fetch associated records for has_one/has_many. SELECT *
+    FROM related_table WHERE foreign_key = ? *)
+let has_query assoc owner_id =
+  Printf.sprintf "SELECT * FROM %s WHERE %s = %s" assoc.related_table
+    assoc.foreign_key owner_id
+
+(** Build a query to fetch associated records for many_to_many. SELECT r.* FROM
+    related_table r INNER JOIN join_table j ON j.related_key = r.id WHERE
+    j.owner_key = ? *)
+let many_to_many_query assoc owner_id =
+  match assoc.assoc_type with
+  | ManyToMany { join_table; join_keys = owner_fk, related_fk } ->
+      Printf.sprintf
+        "SELECT r.* FROM %s r INNER JOIN %s j ON j.%s = r.id WHERE j.%s = %s"
+        assoc.related_table join_table related_fk owner_fk owner_id
+  | _ -> failwith "many_to_many_query called on non-many_to_many association"
+
+(** Build the appropriate query based on association type *)
+let build_query assoc owner_id =
+  match assoc.assoc_type with
+  | BelongsTo -> belongs_to_query assoc owner_id
+  | HasOne | HasMany -> has_query assoc owner_id
+  | ManyToMany _ -> many_to_many_query assoc owner_id
+
+(** Build a query to fetch associated records for multiple owners. Used for
+    efficient batch preloading.
+
+    Returns SQL with IN clause for the owner IDs. *)
+let build_batch_query assoc owner_ids =
+  let ids_str = String.concat ", " owner_ids in
+  match assoc.assoc_type with
+  | BelongsTo ->
+      Printf.sprintf "SELECT * FROM %s WHERE %s IN (%s)" assoc.related_table
+        assoc.owner_key ids_str
+  | HasOne | HasMany ->
+      Printf.sprintf "SELECT * FROM %s WHERE %s IN (%s)" assoc.related_table
+        assoc.foreign_key ids_str
+  | ManyToMany { join_table; join_keys = owner_fk, related_fk } ->
+      Printf.sprintf
+        "SELECT r.*, j.%s as __owner_id__ FROM %s r INNER JOIN %s j ON j.%s = \
+         r.id WHERE j.%s IN (%s)"
+        owner_fk assoc.related_table join_table related_fk owner_fk ids_str
+
+type assoc_meta = {
+  meta_name : string;
+  meta_type : assoc_type;
+  meta_cardinality : cardinality;
+  meta_related_table : string;
+  meta_foreign_key : string;
+  meta_owner_key : string;
+}
+(** Association metadata for runtime reflection *)
+
+(** Extract metadata from an association *)
+let to_meta assoc =
+  {
+    meta_name = assoc.name;
+    meta_type = assoc.assoc_type;
+    meta_cardinality = assoc.cardinality;
+    meta_related_table = assoc.related_table;
+    meta_foreign_key = assoc.foreign_key;
+    meta_owner_key = assoc.owner_key;
+  }
+
+(** Wrapped association for heterogeneous lists *)
+type wrapped_assoc = Assoc : 'a t -> wrapped_assoc
+
+type schema_assocs = { assocs : wrapped_assoc list }
+(** Schema associations container *)
+
+let empty_assocs = { assocs = [] }
+
+let add_assoc assoc schema_assocs =
+  { assocs = Assoc assoc :: schema_assocs.assocs }
+
+let find_assoc name schema_assocs =
+  List.find_opt (fun (Assoc a) -> a.name = name) schema_assocs.assocs
+
+let assoc_names schema_assocs =
+  List.map (fun (Assoc a) -> a.name) schema_assocs.assocs

lib/changeset.ml

···
+type change =
+  | StringChange of string
+  | IntChange of int
+  | FloatChange of float
+  | BoolChange of bool
+  | NullChange
+
+type 'a t = {
+  data : 'a;
+  changes : (string * change) list;
+  errors : Error.validation_error list;
+  valid : bool;
+  action : action option;
+  constraints : constraint_def list;
+}
+
+and action = Insert | Update | Delete
+
+and constraint_def = {
+  constraint_name : string;
+  constraint_field : string;
+  constraint_type : constraint_type;
+}
+
+and constraint_type =
+  | UniqueConstraint
+  | ForeignKeyConstraint of { table : string; column : string }
+  | CheckConstraint of string
+
+let create data =
+  {
+    data;
+    changes = [];
+    errors = [];
+    valid = true;
+    action = None;
+    constraints = [];
+  }
+
+let change data = create data
+
+let for_insert data =
+  {
+    data;
+    changes = [];
+    errors = [];
+    valid = true;
+    action = Some Insert;
+    constraints = [];
+  }
+
+let for_update data =
+  {
+    data;
+    changes = [];
+    errors = [];
+    valid = true;
+    action = Some Update;
+    constraints = [];
+  }
+
+let cast params ~fields t =
+  let field_names = List.map Field.name fields in
+  let filtered_params =
+    List.filter (fun (k, _) -> List.mem k field_names) params
+  in
+  let changes = List.map (fun (k, v) -> (k, StringChange v)) filtered_params in
+  { t with changes }
+
+let cast_assoc assoc ~fields t =
+  let field_names = List.map Field.name fields in
+  let filtered = List.filter (fun (k, _) -> List.mem k field_names) assoc in
+  { t with changes = filtered }
+
+let put_change field value t =
+  let name = Field.name field in
+  let change = StringChange value in
+  let changes =
+    (name, change) :: List.filter (fun (k, _) -> k <> name) t.changes
+  in
+  { t with changes }
+
+let delete_change field t =
+  let name = Field.name field in
+  let changes = List.filter (fun (k, _) -> k <> name) t.changes in
+  { t with changes }
+
+let get_change t field =
+  let name = Field.name field in
+  match List.assoc_opt name t.changes with
+  | Some (StringChange s) -> Some s
+  | _ -> None
+
+let get_field t field = Field.get field t.data
+
+let add_error ~field ~message ~validation t =
+  let error = Error.{ field; message; validation } in
+  { t with errors = error :: t.errors; valid = false }
+
+let validate_required fields t =
+  let missing =
+    List.filter
+      (fun field ->
+        let name = Field.name field in
+        not
+          (List.exists
+             (fun (k, v) ->
+               k = name
+               &&
+               match v with
+               | StringChange s -> s <> ""
+               | NullChange -> false
+               | _ -> true)
+             t.changes))
+      fields
+  in
+  List.fold_left
+    (fun acc field ->
+      add_error ~field:(Field.name field) ~message:"can't be blank"
+        ~validation:"required" acc)
+    t missing
+
+let validate_format field ~pattern t =
+  let name = Field.name field in
+  match List.assoc_opt name t.changes with
+  | None -> t
+  | Some (StringChange value) ->
+      let re = Re.Pcre.regexp pattern in
+      if Re.execp re value then t
+      else
+        add_error ~field:name ~message:"has invalid format" ~validation:"format"
+          t
+  | _ -> t
+
+let validate_length field ?min ?max ?is t =
+  let name = Field.name field in
+  match List.assoc_opt name t.changes with
+  | None -> t
+  | Some (StringChange value) -> (
+      let len = String.length value in
+      let t =
+        match min with
+        | Some m when len < m ->
+            add_error ~field:name
+              ~message:(Printf.sprintf "should be at least %d character(s)" m)
+              ~validation:"length" t
+        | _ -> t
+      in
+      let t =
+        match max with
+        | Some m when len > m ->
+            add_error ~field:name
+              ~message:(Printf.sprintf "should be at most %d character(s)" m)
+              ~validation:"length" t
+        | _ -> t
+      in
+      match is with
+      | Some expected when len <> expected ->
+          add_error ~field:name
+            ~message:(Printf.sprintf "should be %d character(s)" expected)
+            ~validation:"length" t
+      | _ -> t)
+  | _ -> t
+
+let validate_inclusion field ~values t =
+  let name = Field.name field in
+  match List.assoc_opt name t.changes with
+  | None -> t
+  | Some (StringChange value) ->
+      if List.mem value values then t
+      else add_error ~field:name ~message:"is invalid" ~validation:"inclusion" t
+  | _ -> t
+
+let validate_exclusion field ~values t =
+  let name = Field.name field in
+  match List.assoc_opt name t.changes with
+  | None -> t
+  | Some (StringChange value) ->
+      if not (List.mem value values) then t
+      else
+        add_error ~field:name ~message:"is reserved" ~validation:"exclusion" t
+  | _ -> t
+
+let validate_number field ?greater_than ?less_than ?greater_than_or_equal
+    ?less_than_or_equal t =
+  let name = Field.name field in
+  match List.assoc_opt name t.changes with
+  | None -> t
+  | Some (StringChange value) -> (
+      match int_of_string_opt value with
+      | None ->
+          add_error ~field:name ~message:"is not a valid number"
+            ~validation:"number" t
+      | Some n -> (
+          let t =
+            match greater_than with
+            | Some m when n <= m ->
+                add_error ~field:name
+                  ~message:(Printf.sprintf "must be greater than %d" m)
+                  ~validation:"number" t
+            | _ -> t
+          in
+          let t =
+            match less_than with
+            | Some m when n >= m ->
+                add_error ~field:name
+                  ~message:(Printf.sprintf "must be less than %d" m)
+                  ~validation:"number" t
+            | _ -> t
+          in
+          let t =
+            match greater_than_or_equal with
+            | Some m when n < m ->
+                add_error ~field:name
+                  ~message:
+                    (Printf.sprintf "must be greater than or equal to %d" m)
+                  ~validation:"number" t
+            | _ -> t
+          in
+          match less_than_or_equal with
+          | Some m when n > m ->
+              add_error ~field:name
+                ~message:(Printf.sprintf "must be less than or equal to %d" m)
+                ~validation:"number" t
+          | _ -> t))
+  | Some (IntChange n) ->
+      let t =
+        match greater_than with
+        | Some m when n <= m ->
+            add_error ~field:name
+              ~message:(Printf.sprintf "must be greater than %d" m)
+              ~validation:"number" t
+        | _ -> t
+      in
+      let t =
+        match less_than with
+        | Some m when n >= m ->
+            add_error ~field:name
+              ~message:(Printf.sprintf "must be less than %d" m)
+              ~validation:"number" t
+        | _ -> t
+      in
+      t
+  | _ -> t
+
+let validate_acceptance field t =
+  let name = Field.name field in
+  match List.assoc_opt name t.changes with
+  | None ->
+      add_error ~field:name ~message:"must be accepted" ~validation:"acceptance"
+        t
+  | Some (BoolChange true) -> t
+  | Some (StringChange "true") -> t
+  | Some (StringChange "1") -> t
+  | _ ->
+      add_error ~field:name ~message:"must be accepted" ~validation:"acceptance"
+        t
+
+let validate_confirmation field ~confirmation_field t =
+  let name = Field.name field in
+  let conf_name = Field.name confirmation_field in
+  let value = List.assoc_opt name t.changes in
+  let conf_value = List.assoc_opt conf_name t.changes in
+  match (value, conf_value) with
+  | Some v1, Some v2 when v1 = v2 -> t
+  | Some _, Some _ ->
+      add_error ~field:conf_name ~message:"does not match"
+        ~validation:"confirmation" t
+  | _ -> t
+
+let validate_change field validator t =
+  match get_change t field with
+  | None -> t
+  | Some value -> (
+      match validator value with
+      | Ok () -> t
+      | Error msg ->
+          add_error ~field:(Field.name field) ~message:msg ~validation:"custom"
+            t)
+
+let validate t f = f t
+
+let unique_constraint field t =
+  let name = Field.name field in
+  let constraint_def =
+    {
+      constraint_name = name ^ "_unique";
+      constraint_field = name;
+      constraint_type = UniqueConstraint;
+    }
+  in
+  { t with constraints = constraint_def :: t.constraints }
+
+let foreign_key_constraint field ~references:(table, column) t =
+  let name = Field.name field in
+  let constraint_def =
+    {
+      constraint_name = name ^ "_fkey";
+      constraint_field = name;
+      constraint_type = ForeignKeyConstraint { table; column };
+    }
+  in
+  { t with constraints = constraint_def :: t.constraints }
+
+let check_constraint ~name field ~expression t =
+  let field_name = Field.name field in
+  let constraint_def =
+    {
+      constraint_name = name;
+      constraint_field = field_name;
+      constraint_type = CheckConstraint expression;
+    }
+  in
+  { t with constraints = constraint_def :: t.constraints }
+
+let is_valid t = t.valid
+let errors t = t.errors
+let data t = t.data
+let changes t = t.changes
+let action t = t.action
+
+let get_error t field =
+  let name = Field.name field in
+  List.find_opt (fun e -> e.Error.field = name) t.errors
+
+let has_error t field = Option.is_some (get_error t field)
+
+let traverse_errors t f =
+  List.iter (fun err -> f err.Error.field err.Error.message) t.errors
+
+let error_messages t =
+  List.map
+    (fun err -> Printf.sprintf "%s %s" err.Error.field err.Error.message)
+    t.errors
+
+let apply_action t = if t.valid then Ok t.data else Error t.errors
+
+type 'a assoc_changeset = {
+  assoc_name : string;
+  assoc_changesets : 'a t list;
+  on_replace : [ `Raise | `Mark_as_invalid | `Delete | `Update ];
+}
+
+let cast_assoc_one ~assoc_name ~params ~cast_fn t =
+  match List.assoc_opt assoc_name params with
+  | None -> t
+  | Some assoc_params ->
+      let child_changeset = cast_fn assoc_params in
+      if is_valid child_changeset then t
+      else
+        let child_errors = errors child_changeset in
+        let prefixed_errors =
+          List.map
+            (fun err ->
+              Error.
+                {
+                  field = assoc_name ^ "." ^ err.field;
+                  message = err.message;
+                  validation = err.validation;
+                })
+            child_errors
+        in
+        { t with errors = prefixed_errors @ t.errors; valid = false }
+
+let cast_assoc_many ~assoc_name ~params_list ~cast_fn t =
+  let process_one idx params =
+    let child_changeset = cast_fn params in
+    if is_valid child_changeset then []
+    else
+      let child_errors = errors child_changeset in
+      List.map
+        (fun err ->
+          Error.
+            {
+              field = Printf.sprintf "%s[%d].%s" assoc_name idx err.field;
+              message = err.message;
+              validation = err.validation;
+            })
+        child_errors
+  in
+  let all_errors = List.concat (List.mapi process_one params_list) in
+  if all_errors = [] then t
+  else { t with errors = all_errors @ t.errors; valid = false }
+
+let put_assoc ~assoc_name ~value ~encode_fn t =
+  let json_value = encode_fn value in
+  let change = StringChange (Yojson.Safe.to_string json_value) in
+  let changes =
+    (assoc_name, change)
+    :: List.filter (fun (k, _) -> k <> assoc_name) t.changes
+  in
+  { t with changes }
+
+let cast_embed ~embed_name ~params ~schema t =
+  match List.assoc_opt embed_name params with
+  | None -> t
+  | Some embed_params -> (
+      let json =
+        `Assoc (List.map (fun (k, v) -> (k, `String v)) embed_params)
+      in
+      match Embedded.from_json schema json with
+      | Ok _embedded -> t
+      | Error msg ->
+          add_error ~field:embed_name ~message:msg ~validation:"embedded" t)
+
+let put_embed ~embed_name ~value ~schema t =
+  let json = Embedded.to_json schema value in
+  let change = StringChange (Yojson.Safe.to_string json) in
+  let changes =
+    (embed_name, change)
+    :: List.filter (fun (k, _) -> k <> embed_name) t.changes
+  in
+  { t with changes }
+
+let merge_errors parent_changeset child_changeset ~prefix =
+  let child_errors = errors child_changeset in
+  let prefixed_errors =
+    List.map
+      (fun err ->
+        Error.
+          {
+            field = prefix ^ "." ^ err.field;
+            message = err.message;
+            validation = err.validation;
+          })
+      child_errors
+  in
+  {
+    parent_changeset with
+    errors = prefixed_errors @ parent_changeset.errors;
+    valid = parent_changeset.valid && is_valid child_changeset;
+  }

lib/dune

···
 (library
- (name mlecto)
- (public_name mlecto)
+ (name repodb)
+ (public_name repodb)
  (libraries
   caqti
   caqti-eio
···
   yojson
   eio)
  (modules
-  mlecto
-  mlecto_type
-  mlecto_schema
-  mlecto_field
-  mlecto_expr
-  mlecto_query
-  mlecto_changeset
-  mlecto_repo
-  mlecto_migration
-  mlecto_multi
-  mlecto_error))
+  error
+  types
+  field
+  schema
+  assoc
+  embedded
+  expr
+  query
+  changeset
+  repo
+  migration
+  multi))

lib/embedded.ml

···
+module type JSON = sig
+  type t
+
+  val null : t
+  val to_string : t -> string
+  val of_string : string -> (t, string) result
+  val get_field : t -> string -> t option
+  val get_string : t -> string option
+  val get_int : t -> int option
+  val get_float : t -> float option
+  val get_bool : t -> bool option
+  val get_list : t -> t list option
+  val is_null : t -> bool
+  val make_object : (string * t) list -> t
+  val make_string : string -> t
+  val make_int : int -> t
+  val make_float : float -> t
+  val make_bool : bool -> t
+  val make_list : t list -> t
+end
+
+module Yojson_json : JSON with type t = Yojson.Safe.t = struct
+  type t = Yojson.Safe.t
+
+  let null = `Null
+  let to_string json = Yojson.Safe.to_string json
+
+  let of_string s =
+    try Ok (Yojson.Safe.from_string s) with Yojson.Json_error msg -> Error msg
+
+  let get_field json key =
+    match json with `Assoc fields -> List.assoc_opt key fields | _ -> None
+
+  let get_string = function `String s -> Some s | _ -> None
+  let get_int = function `Int i -> Some i | _ -> None
+
+  let get_float = function
+    | `Float f -> Some f
+    | `Int i -> Some (float_of_int i)
+    | _ -> None
+
+  let get_bool = function `Bool b -> Some b | _ -> None
+  let get_list = function `List l -> Some l | _ -> None
+  let is_null = function `Null -> true | _ -> false
+  let make_object fields = `Assoc fields
+  let make_string s = `String s
+  let make_int i = `Int i
+  let make_float f = `Float f
+  let make_bool b = `Bool b
+  let make_list l = `List l
+end
+
+module Make (Json : JSON) = struct
+  type json = Json.t
+
+  type 'a t = { data : 'a; fields : string list; source : source }
+  and source = JsonColumn of string | Virtual
+
+  type 'a schema = {
+    name : string;
+    decode : json -> ('a, string) result;
+    encode : 'a -> json;
+    fields : string list;
+    default : 'a option;
+  }
+
+  let schema ~name ~decode ~encode ~fields ?default () =
+    { name; decode; encode; fields; default }
+
+  let from_json schema json =
+    match schema.decode json with
+    | Ok data -> Ok { data; fields = schema.fields; source = Virtual }
+    | Error msg -> Error msg
+
+  let to_json schema embedded = schema.encode embedded.data
+
+  let from_json_string schema json_str =
+    match Json.of_string json_str with
+    | Ok json -> from_json schema json
+    | Error msg -> Error msg
+
+  let to_json_string schema embedded = Json.to_string (to_json schema embedded)
+  let data embedded = embedded.data
+  let fields embedded = embedded.fields
+  let update embedded ~data = { embedded with data }
+
+  type 'a embeds_one = 'a t option
+  type 'a embeds_many = 'a t list
+
+  let embeds_one_from_json schema json =
+    if Json.is_null json then Ok None
+    else Result.map Option.some (from_json schema json)
+
+  let embeds_one_to_json schema = function
+    | None -> Json.null
+    | Some embedded -> to_json schema embedded
+
+  let embeds_many_from_json schema json =
+    match Json.get_list json with
+    | Some items ->
+        let rec process acc = function
+          | [] -> Ok (List.rev acc)
+          | item :: rest -> (
+              match from_json schema item with
+              | Ok embedded -> process (embedded :: acc) rest
+              | Error msg -> Error msg)
+        in
+        process [] items
+    | None when Json.is_null json -> Ok []
+    | None -> Error "Expected array for embeds_many"
+
+  let embeds_many_to_json schema embeddeds =
+    Json.make_list (List.map (to_json schema) embeddeds)
+
+  let cast_embedded schema params ~fields:allowed_fields =
+    let filtered =
+      List.filter (fun (k, _) -> List.mem k allowed_fields) params
+    in
+    let json =
+      Json.make_object
+        (List.map (fun (k, v) -> (k, Json.make_string v)) filtered)
+    in
+    from_json schema json
+
+  let validate_embedded validator embedded =
+    match validator embedded.data with
+    | Ok () -> Ok embedded
+    | Error msg -> Error msg
+end
+
+type source = JsonColumn of string | Virtual
+type 'a t = { data : 'a; fields : string list; source : source }
+
+type 'a schema = {
+  name : string;
+  decode : Yojson.Safe.t -> ('a, string) result;
+  encode : 'a -> Yojson.Safe.t;
+  fields : string list;
+  default : 'a option;
+}
+
+let schema ~name ~decode ~encode ~fields ?default () =
+  { name; decode; encode; fields; default }
+
+let from_json schema json =
+  match schema.decode json with
+  | Ok data -> Ok { data; fields = schema.fields; source = Virtual }
+  | Error msg -> Error msg
+
+let to_json schema embedded = schema.encode embedded.data
+
+let from_json_string schema json_str =
+  match Yojson.Safe.from_string json_str with
+  | json -> from_json schema json
+  | exception Yojson.Json_error msg -> Error msg
+
+let to_json_string schema embedded =
+  Yojson.Safe.to_string (to_json schema embedded)
+
+let data embedded = embedded.data
+let fields embedded = embedded.fields
+let update embedded ~data = { embedded with data }
+
+type 'a embeds_one = 'a t option
+type 'a embeds_many = 'a t list
+
+let embeds_one_from_json schema json =
+  match json with
+  | `Null -> Ok None
+  | _ -> Result.map Option.some (from_json schema json)
+
+let embeds_one_to_json schema = function
+  | None -> `Null
+  | Some embedded -> to_json schema embedded
+
+let embeds_many_from_json schema json =
+  match json with
+  | `List items ->
+      let rec process acc = function
+        | [] -> Ok (List.rev acc)
+        | item :: rest -> (
+            match from_json schema item with
+            | Ok embedded -> process (embedded :: acc) rest
+            | Error msg -> Error msg)
+      in
+      process [] items
+  | `Null -> Ok []
+  | _ -> Error "Expected array for embeds_many"
+
+let embeds_many_to_json schema embeddeds =
+  `List (List.map (to_json schema) embeddeds)
+
+let cast_embedded schema params ~fields:allowed_fields =
+  let filtered = List.filter (fun (k, _) -> List.mem k allowed_fields) params in
+  let json = `Assoc (List.map (fun (k, v) -> (k, `String v)) filtered) in
+  from_json schema json
+
+let validate_embedded validator embedded =
+  match validator embedded.data with
+  | Ok () -> Ok embedded
+  | Error msg -> Error msg

lib/expr.ml

···
+type 'a t =
+  | Lit : 'a * 'a Types.t -> 'a t
+  | Column : ('record, 'a) Field.t -> 'a t
+  | Null : 'a Types.t -> 'a option t
+  | Binop : string * 'a t * 'b t * 'c Types.t -> 'c t
+  | Unop : string * 'a t * 'b Types.t -> 'b t
+  | Func : string * wrapped list * 'a Types.t -> 'a t
+  | Raw : string -> 'a t
+  | Param : int * 'a Types.t -> 'a t
+  | Cast : 'a t * 'b Types.t -> 'b t
+  | Case : (bool t * 'a t) list * 'a t option * 'a Types.t -> 'a t
+  | Between : 'a t * 'a t * 'a t -> bool t
+  | InList : 'a t * 'a t list -> bool t
+  | Subquery : string -> 'a t
+
+and wrapped = Wrapped : 'a t -> wrapped
+
+let int n = Lit (n, Types.int)
+let int32 n = Lit (n, Types.int32)
+let int64 n = Lit (n, Types.int64)
+let float f = Lit (f, Types.float)
+let string s = Lit (s, Types.string)
+let bool b = Lit (b, Types.bool)
+let null ty = Null ty
+let column field = Column field
+let raw s = Raw s
+let param n ty = Param (n, ty)
+let cast expr ty = Cast (expr, ty)
+let subquery sql = Subquery sql
+let ( = ) a b = Binop ("=", a, b, Types.bool)
+let ( <> ) a b = Binop ("<>", a, b, Types.bool)
+let ( < ) a b = Binop ("<", a, b, Types.bool)
+let ( > ) a b = Binop (">", a, b, Types.bool)
+let ( <= ) a b = Binop ("<=", a, b, Types.bool)
+let ( >= ) a b = Binop (">=", a, b, Types.bool)
+let ( && ) a b = Binop ("AND", a, b, Types.bool)
+let ( || ) a b = Binop ("OR", a, b, Types.bool)
+let not_ a = Unop ("NOT", a, Types.bool)
+let is_null a = Unop ("IS NULL", a, Types.bool)
+let is_not_null a = Unop ("IS NOT NULL", a, Types.bool)
+let ( + ) a b = Binop ("+", a, b, Types.int)
+let ( - ) a b = Binop ("-", a, b, Types.int)
+let ( * ) a b = Binop ("*", a, b, Types.int)
+let ( / ) a b = Binop ("/", a, b, Types.int)
+let ( mod ) a b = Binop ("%", a, b, Types.int)
+let ( +. ) a b = Binop ("+", a, b, Types.float)
+let ( -. ) a b = Binop ("-", a, b, Types.float)
+let ( *. ) a b = Binop ("*", a, b, Types.float)
+let ( /. ) a b = Binop ("/", a, b, Types.float)
+let like a pattern = Binop ("LIKE", a, string pattern, Types.bool)
+let ilike a pattern = Binop ("ILIKE", a, string pattern, Types.bool)
+let similar_to a pattern = Binop ("SIMILAR TO", a, string pattern, Types.bool)
+let regexp a pattern = Binop ("~", a, string pattern, Types.bool)
+let regexp_i a pattern = Binop ("~*", a, string pattern, Types.bool)
+let between a low high = Between (a, low, high)
+let in_list a values = InList (a, values)
+let not_in_list a values = not_ (in_list a values)
+let case branches ~else_ ty = Case (branches, Some else_, ty)
+let case_no_else branches ty = Case (branches, None, ty)
+
+let coalesce exprs default_ty =
+  Func ("COALESCE", List.map (fun e -> Wrapped e) exprs, default_ty)
+
+let nullif a b ty = Func ("NULLIF", [ Wrapped a; Wrapped b ], Types.option ty)
+
+let greatest exprs ty =
+  Func ("GREATEST", List.map (fun e -> Wrapped e) exprs, ty)
+
+let least exprs ty = Func ("LEAST", List.map (fun e -> Wrapped e) exprs, ty)
+let count expr = Func ("COUNT", [ Wrapped expr ], Types.int64)
+
+let count_distinct expr =
+  Func ("COUNT", [ Wrapped (Raw "DISTINCT "); Wrapped expr ], Types.int64)
+
+let count_all = Func ("COUNT", [ Wrapped (Raw "*") ], Types.int64)
+let sum expr = Func ("SUM", [ Wrapped expr ], Types.int64)
+let avg expr = Func ("AVG", [ Wrapped expr ], Types.float)
+let max_ expr ty = Func ("MAX", [ Wrapped expr ], ty)
+let min_ expr ty = Func ("MIN", [ Wrapped expr ], ty)
+let lower expr = Func ("LOWER", [ Wrapped expr ], Types.string)
+let upper expr = Func ("UPPER", [ Wrapped expr ], Types.string)
+let length expr = Func ("LENGTH", [ Wrapped expr ], Types.int)
+let trim expr = Func ("TRIM", [ Wrapped expr ], Types.string)
+let ltrim expr = Func ("LTRIM", [ Wrapped expr ], Types.string)
+let rtrim expr = Func ("RTRIM", [ Wrapped expr ], Types.string)
+
+let concat exprs =
+  Func ("CONCAT", List.map (fun e -> Wrapped e) exprs, Types.string)
+
+let concat_ws sep exprs =
+  Func
+    ( "CONCAT_WS",
+      Wrapped (string sep) :: List.map (fun e -> Wrapped e) exprs,
+      Types.string )
+
+let substring expr ~from ~for_ =
+  Func
+    ( "SUBSTRING",
+      [ Wrapped expr; Wrapped (int from); Wrapped (int for_) ],
+      Types.string )
+
+let replace expr ~from ~to_ =
+  Func
+    ( "REPLACE",
+      [ Wrapped expr; Wrapped (string from); Wrapped (string to_) ],
+      Types.string )
+
+let left expr n = Func ("LEFT", [ Wrapped expr; Wrapped (int n) ], Types.string)
+
+let right expr n =
+  Func ("RIGHT", [ Wrapped expr; Wrapped (int n) ], Types.string)
+
+let now () = Func ("NOW", [], Types.ptime)
+let current_date = Func ("CURRENT_DATE", [], Types.pdate)
+let current_timestamp = Func ("CURRENT_TIMESTAMP", [], Types.ptime)
+
+let date_part part expr =
+  Func ("DATE_PART", [ Wrapped (string part); Wrapped expr ], Types.float)
+
+let extract part expr =
+  Func
+    ("EXTRACT", [ Wrapped (Raw (part ^ " FROM ")); Wrapped expr ], Types.float)
+
+let age a b = Func ("AGE", [ Wrapped a; Wrapped b ], Types.ptime_span)
+let abs_ expr = Func ("ABS", [ Wrapped expr ], Types.int)
+let ceil expr = Func ("CEIL", [ Wrapped expr ], Types.float)
+let floor expr = Func ("FLOOR", [ Wrapped expr ], Types.float)
+let round expr = Func ("ROUND", [ Wrapped expr ], Types.float)
+let sqrt expr = Func ("SQRT", [ Wrapped expr ], Types.float)
+let power base exp = Func ("POWER", [ Wrapped base; Wrapped exp ], Types.float)
+let random = Func ("RANDOM", [], Types.float)
+let gen_random_uuid = Func ("GEN_RANDOM_UUID", [], Types.uuid)
+
+type wrapped_expr = W : 'a t -> wrapped_expr
+
+type 'a expr_list =
+  | [] : unit expr_list
+  | ( :: ) : 'a t * 'b expr_list -> ('a * 'b) expr_list
+
+let rec expr_list_to_list : type a. a expr_list -> wrapped_expr list = function
+  | [] -> []
+  | e :: rest -> W e :: expr_list_to_list rest
+
+let escape_string s =
+  let buf = Buffer.create (String.length s |> Stdlib.( * ) 2) in
+  String.iter
+    (fun c ->
+      match c with
+      | '\'' -> Buffer.add_string buf "''"
+      | _ -> Buffer.add_char buf c)
+    s;
+  Buffer.contents buf
+
+let lit_to_sql : type a. a -> a Types.t -> string =
+ fun v ty ->
+  match ty with
+  | Types.Int -> string_of_int v
+  | Types.Int32 -> Int32.to_string v
+  | Types.Int64 -> Int64.to_string v
+  | Types.Float -> Printf.sprintf "%g" v
+  | Types.String -> Printf.sprintf "'%s'" (escape_string v)
+  | Types.Bool -> if v then "TRUE" else "FALSE"
+  | Types.Uuid -> Printf.sprintf "'%s'" (Uuidm.to_string v)
+  | Types.Ptime -> Printf.sprintf "'%s'" (Ptime.to_rfc3339 v)
+  | Types.Pdate ->
+      let y, m, d = v in
+      Printf.sprintf "'%04d-%02d-%02d'" y m d
+  | Types.Json ->
+      Printf.sprintf "'%s'" (escape_string (Yojson.Safe.to_string v))
+  | _ -> failwith "Unsupported literal type for SQL generation"
+
+let rec to_sql : type a. a t -> string = function
+  | Lit (v, ty) -> lit_to_sql v ty
+  | Column field -> Field.qualified_name field
+  | Null _ -> "NULL"
+  | Binop (op, a, b, _) -> Printf.sprintf "(%s %s %s)" (to_sql a) op (to_sql b)
+  | Unop (op, a, _) ->
+      if String.contains op ' ' then Printf.sprintf "(%s %s)" (to_sql a) op
+      else Printf.sprintf "(%s %s)" op (to_sql a)
+  | Func (name, args, _) ->
+      let arg_strs = List.map (fun (Wrapped e) -> to_sql e) args in
+      Printf.sprintf "%s(%s)" name (String.concat ", " arg_strs)
+  | Raw s -> s
+  | Param (n, _) -> Printf.sprintf "$%d" n
+  | Cast (expr, ty) ->
+      Printf.sprintf "CAST(%s AS %s)" (to_sql expr) (Types.sql_type_name ty)
+  | Case (branches, else_, _) ->
+      let branch_strs =
+        List.map
+          (fun (cond, result) ->
+            Printf.sprintf "WHEN %s THEN %s" (to_sql cond) (to_sql result))
+          branches
+      in
+      let else_str =
+        match else_ with
+        | Some e -> Printf.sprintf " ELSE %s" (to_sql e)
+        | None -> ""
+      in
+      Printf.sprintf "CASE %s%s END" (String.concat " " branch_strs) else_str
+  | Between (a, low, high) ->
+      Printf.sprintf "(%s BETWEEN %s AND %s)" (to_sql a) (to_sql low)
+        (to_sql high)
+  | InList (a, values) ->
+      let value_strs = List.map to_sql values in
+      Printf.sprintf "(%s IN (%s))" (to_sql a) (String.concat ", " value_strs)
+  | Subquery sql -> Printf.sprintf "(%s)" sql

lib/mlecto.ml

···
-module Type = Mlecto_type
-module Field = Mlecto_field
-module Schema = Mlecto_schema
-module Expr = Mlecto_expr
-module Query = Mlecto_query
-module Changeset = Mlecto_changeset
-module Repo = Mlecto_repo
-module Migration = Mlecto_migration
-module Multi = Mlecto_multi
-module Error = Mlecto_error

lib/mlecto_changeset.ml

···
-type change =
-  | StringChange of string
-  | IntChange of int
-  | FloatChange of float
-  | BoolChange of bool
-  | NullChange
-
-type 'a t = {
-  data : 'a;
-  changes : (string * change) list;
-  errors : Mlecto_error.validation_error list;
-  valid : bool;
-  action : action option;
-  constraints : constraint_def list;
-}
-
-and action = Insert | Update | Delete
-
-and constraint_def = {
-  constraint_name : string;
-  constraint_field : string;
-  constraint_type : constraint_type;
-}
-
-and constraint_type =
-  | UniqueConstraint
-  | ForeignKeyConstraint of { table : string; column : string }
-  | CheckConstraint of string
-
-let create data =
-  {
-    data;
-    changes = [];
-    errors = [];
-    valid = true;
-    action = None;
-    constraints = [];
-  }
-
-let change data = create data
-
-let for_insert data =
-  {
-    data;
-    changes = [];
-    errors = [];
-    valid = true;
-    action = Some Insert;
-    constraints = [];
-  }
-
-let for_update data =
-  {
-    data;
-    changes = [];
-    errors = [];
-    valid = true;
-    action = Some Update;
-    constraints = [];
-  }
-
-let cast t params ~fields =
-  let field_names = List.map Mlecto_field.name fields in
-  let filtered_params =
-    List.filter (fun (k, _) -> List.mem k field_names) params
-  in
-  let changes = List.map (fun (k, v) -> (k, StringChange v)) filtered_params in
-  { t with changes }
-
-let cast_assoc t assoc ~fields =
-  let field_names = List.map Mlecto_field.name fields in
-  let filtered = List.filter (fun (k, _) -> List.mem k field_names) assoc in
-  { t with changes = filtered }
-
-let put_change t field value =
-  let name = Mlecto_field.name field in
-  let change = StringChange value in
-  let changes =
-    (name, change) :: List.filter (fun (k, _) -> k <> name) t.changes
-  in
-  { t with changes }
-
-let delete_change t field =
-  let name = Mlecto_field.name field in
-  let changes = List.filter (fun (k, _) -> k <> name) t.changes in
-  { t with changes }
-
-let get_change t field =
-  let name = Mlecto_field.name field in
-  match List.assoc_opt name t.changes with
-  | Some (StringChange s) -> Some s
-  | _ -> None
-
-let get_field t field = Mlecto_field.get field t.data
-
-let add_error t ~field ~message ~validation =
-  let error = Mlecto_error.{ field; message; validation } in
-  { t with errors = error :: t.errors; valid = false }
-
-let validate_required fields t =
-  let missing =
-    List.filter
-      (fun field ->
-        let name = Mlecto_field.name field in
-        not
-          (List.exists
-             (fun (k, v) ->
-               k = name
-               &&
-               match v with
-               | StringChange s -> s <> ""
-               | NullChange -> false
-               | _ -> true)
-             t.changes))
-      fields
-  in
-  List.fold_left
-    (fun acc field ->
-      add_error acc ~field:(Mlecto_field.name field) ~message:"can't be blank"
-        ~validation:"required")
-    t missing
-
-let validate_format field ~pattern t =
-  let name = Mlecto_field.name field in
-  match List.assoc_opt name t.changes with
-  | None -> t
-  | Some (StringChange value) ->
-      let re = Re.Pcre.regexp pattern in
-      if Re.execp re value then t
-      else
-        add_error t ~field:name ~message:"has invalid format"
-          ~validation:"format"
-  | _ -> t
-
-let validate_length field ?min ?max ?is t =
-  let name = Mlecto_field.name field in
-  match List.assoc_opt name t.changes with
-  | None -> t
-  | Some (StringChange value) -> (
-      let len = String.length value in
-      let t =
-        match min with
-        | Some m when len < m ->
-            add_error t ~field:name
-              ~message:(Printf.sprintf "should be at least %d character(s)" m)
-              ~validation:"length"
-        | _ -> t
-      in
-      let t =
-        match max with
-        | Some m when len > m ->
-            add_error t ~field:name
-              ~message:(Printf.sprintf "should be at most %d character(s)" m)
-              ~validation:"length"
-        | _ -> t
-      in
-      match is with
-      | Some expected when len <> expected ->
-          add_error t ~field:name
-            ~message:(Printf.sprintf "should be %d character(s)" expected)
-            ~validation:"length"
-      | _ -> t)
-  | _ -> t
-
-let validate_inclusion field ~values t =
-  let name = Mlecto_field.name field in
-  match List.assoc_opt name t.changes with
-  | None -> t
-  | Some (StringChange value) ->
-      if List.mem value values then t
-      else add_error t ~field:name ~message:"is invalid" ~validation:"inclusion"
-  | _ -> t
-
-let validate_exclusion field ~values t =
-  let name = Mlecto_field.name field in
-  match List.assoc_opt name t.changes with
-  | None -> t
-  | Some (StringChange value) ->
-      if not (List.mem value values) then t
-      else
-        add_error t ~field:name ~message:"is reserved" ~validation:"exclusion"
-  | _ -> t
-
-let validate_number field ?greater_than ?less_than ?greater_than_or_equal
-    ?less_than_or_equal t =
-  let name = Mlecto_field.name field in
-  match List.assoc_opt name t.changes with
-  | None -> t
-  | Some (StringChange value) -> (
-      match int_of_string_opt value with
-      | None ->
-          add_error t ~field:name ~message:"is not a valid number"
-            ~validation:"number"
-      | Some n -> (
-          let t =
-            match greater_than with
-            | Some m when n <= m ->
-                add_error t ~field:name
-                  ~message:(Printf.sprintf "must be greater than %d" m)
-                  ~validation:"number"
-            | _ -> t
-          in
-          let t =
-            match less_than with
-            | Some m when n >= m ->
-                add_error t ~field:name
-                  ~message:(Printf.sprintf "must be less than %d" m)
-                  ~validation:"number"
-            | _ -> t
-          in
-          let t =
-            match greater_than_or_equal with
-            | Some m when n < m ->
-                add_error t ~field:name
-                  ~message:
-                    (Printf.sprintf "must be greater than or equal to %d" m)
-                  ~validation:"number"
-            | _ -> t
-          in
-          match less_than_or_equal with
-          | Some m when n > m ->
-              add_error t ~field:name
-                ~message:(Printf.sprintf "must be less than or equal to %d" m)
-                ~validation:"number"
-          | _ -> t))
-  | Some (IntChange n) ->
-      let t =
-        match greater_than with
-        | Some m when n <= m ->
-            add_error t ~field:name
-              ~message:(Printf.sprintf "must be greater than %d" m)
-              ~validation:"number"
-        | _ -> t
-      in
-      let t =
-        match less_than with
-        | Some m when n >= m ->
-            add_error t ~field:name
-              ~message:(Printf.sprintf "must be less than %d" m)
-              ~validation:"number"
-        | _ -> t
-      in
-      t
-  | _ -> t
-
-let validate_acceptance field t =
-  let name = Mlecto_field.name field in
-  match List.assoc_opt name t.changes with
-  | None ->
-      add_error t ~field:name ~message:"must be accepted"
-        ~validation:"acceptance"
-  | Some (BoolChange true) -> t
-  | Some (StringChange "true") -> t
-  | Some (StringChange "1") -> t
-  | _ ->
-      add_error t ~field:name ~message:"must be accepted"
-        ~validation:"acceptance"
-
-let validate_confirmation field ~confirmation_field t =
-  let name = Mlecto_field.name field in
-  let conf_name = Mlecto_field.name confirmation_field in
-  let value = List.assoc_opt name t.changes in
-  let conf_value = List.assoc_opt conf_name t.changes in
-  match (value, conf_value) with
-  | Some v1, Some v2 when v1 = v2 -> t
-  | Some _, Some _ ->
-      add_error t ~field:conf_name ~message:"does not match"
-        ~validation:"confirmation"
-  | _ -> t
-
-let validate_change field validator t =
-  match get_change t field with
-  | None -> t
-  | Some value -> (
-      match validator value with
-      | Ok () -> t
-      | Error msg ->
-          add_error t ~field:(Mlecto_field.name field) ~message:msg
-            ~validation:"custom")
-
-let validate t f = f t
-
-let unique_constraint field t =
-  let name = Mlecto_field.name field in
-  let constraint_def =
-    {
-      constraint_name = name ^ "_unique";
-      constraint_field = name;
-      constraint_type = UniqueConstraint;
-    }
-  in
-  { t with constraints = constraint_def :: t.constraints }
-
-let foreign_key_constraint field ~references:(table, column) t =
-  let name = Mlecto_field.name field in
-  let constraint_def =
-    {
-      constraint_name = name ^ "_fkey";
-      constraint_field = name;
-      constraint_type = ForeignKeyConstraint { table; column };
-    }
-  in
-  { t with constraints = constraint_def :: t.constraints }
-
-let check_constraint ~name field ~expression t =
-  let field_name = Mlecto_field.name field in
-  let constraint_def =
-    {
-      constraint_name = name;
-      constraint_field = field_name;
-      constraint_type = CheckConstraint expression;
-    }
-  in
-  { t with constraints = constraint_def :: t.constraints }
-
-let is_valid t = t.valid
-let errors t = t.errors
-let data t = t.data
-let changes t = t.changes
-let action t = t.action
-
-let get_error t field =
-  let name = Mlecto_field.name field in
-  List.find_opt (fun e -> e.Mlecto_error.field = name) t.errors
-
-let has_error t field = Option.is_some (get_error t field)
-
-let traverse_errors t f =
-  List.iter
-    (fun err -> f err.Mlecto_error.field err.Mlecto_error.message)
-    t.errors
-
-let error_messages t =
-  List.map
-    (fun err ->
-      Printf.sprintf "%s %s" err.Mlecto_error.field err.Mlecto_error.message)
-    t.errors
-
-let apply_action t = if t.valid then Ok t.data else Error t.errors

lib/mlecto_expr.ml

···
-type 'a t =
-  | Lit : 'a * 'a Mlecto_type.t -> 'a t
-  | Column : ('record, 'a) Mlecto_field.t -> 'a t
-  | Null : 'a Mlecto_type.t -> 'a option t
-  | Binop : string * 'a t * 'b t * 'c Mlecto_type.t -> 'c t
-  | Unop : string * 'a t * 'b Mlecto_type.t -> 'b t
-  | Func : string * wrapped list * 'a Mlecto_type.t -> 'a t
-  | Raw : string -> 'a t
-  | Param : int * 'a Mlecto_type.t -> 'a t
-  | Cast : 'a t * 'b Mlecto_type.t -> 'b t
-  | Case : (bool t * 'a t) list * 'a t option * 'a Mlecto_type.t -> 'a t
-  | Between : 'a t * 'a t * 'a t -> bool t
-  | InList : 'a t * 'a t list -> bool t
-  | Subquery : string -> 'a t
-
-and wrapped = Wrapped : 'a t -> wrapped
-
-let int n = Lit (n, Mlecto_type.int)
-let int32 n = Lit (n, Mlecto_type.int32)
-let int64 n = Lit (n, Mlecto_type.int64)
-let float f = Lit (f, Mlecto_type.float)
-let string s = Lit (s, Mlecto_type.string)
-let bool b = Lit (b, Mlecto_type.bool)
-let null ty = Null ty
-let column field = Column field
-let raw s = Raw s
-let param n ty = Param (n, ty)
-let cast expr ty = Cast (expr, ty)
-let subquery sql = Subquery sql
-let ( = ) a b = Binop ("=", a, b, Mlecto_type.bool)
-let ( <> ) a b = Binop ("<>", a, b, Mlecto_type.bool)
-let ( < ) a b = Binop ("<", a, b, Mlecto_type.bool)
-let ( > ) a b = Binop (">", a, b, Mlecto_type.bool)
-let ( <= ) a b = Binop ("<=", a, b, Mlecto_type.bool)
-let ( >= ) a b = Binop (">=", a, b, Mlecto_type.bool)
-let ( && ) a b = Binop ("AND", a, b, Mlecto_type.bool)
-let ( || ) a b = Binop ("OR", a, b, Mlecto_type.bool)
-let not_ a = Unop ("NOT", a, Mlecto_type.bool)
-let is_null a = Unop ("IS NULL", a, Mlecto_type.bool)
-let is_not_null a = Unop ("IS NOT NULL", a, Mlecto_type.bool)
-let ( + ) a b = Binop ("+", a, b, Mlecto_type.int)
-let ( - ) a b = Binop ("-", a, b, Mlecto_type.int)
-let ( * ) a b = Binop ("*", a, b, Mlecto_type.int)
-let ( / ) a b = Binop ("/", a, b, Mlecto_type.int)
-let ( mod ) a b = Binop ("%", a, b, Mlecto_type.int)
-let ( +. ) a b = Binop ("+", a, b, Mlecto_type.float)
-let ( -. ) a b = Binop ("-", a, b, Mlecto_type.float)
-let ( *. ) a b = Binop ("*", a, b, Mlecto_type.float)
-let ( /. ) a b = Binop ("/", a, b, Mlecto_type.float)
-let like a pattern = Binop ("LIKE", a, string pattern, Mlecto_type.bool)
-let ilike a pattern = Binop ("ILIKE", a, string pattern, Mlecto_type.bool)
-
-let similar_to a pattern =
-  Binop ("SIMILAR TO", a, string pattern, Mlecto_type.bool)
-
-let regexp a pattern = Binop ("~", a, string pattern, Mlecto_type.bool)
-let regexp_i a pattern = Binop ("~*", a, string pattern, Mlecto_type.bool)
-let between a low high = Between (a, low, high)
-let in_list a values = InList (a, values)
-let not_in_list a values = not_ (in_list a values)
-let case branches ~else_ ty = Case (branches, Some else_, ty)
-let case_no_else branches ty = Case (branches, None, ty)
-
-let coalesce exprs default_ty =
-  Func ("COALESCE", List.map (fun e -> Wrapped e) exprs, default_ty)
-
-let nullif a b ty =
-  Func ("NULLIF", [ Wrapped a; Wrapped b ], Mlecto_type.option ty)
-
-let greatest exprs ty =
-  Func ("GREATEST", List.map (fun e -> Wrapped e) exprs, ty)
-
-let least exprs ty = Func ("LEAST", List.map (fun e -> Wrapped e) exprs, ty)
-let count expr = Func ("COUNT", [ Wrapped expr ], Mlecto_type.int64)
-
-let count_distinct expr =
-  Func ("COUNT", [ Wrapped (Raw "DISTINCT "); Wrapped expr ], Mlecto_type.int64)
-
-let count_all = Func ("COUNT", [ Wrapped (Raw "*") ], Mlecto_type.int64)
-let sum expr = Func ("SUM", [ Wrapped expr ], Mlecto_type.int64)
-let avg expr = Func ("AVG", [ Wrapped expr ], Mlecto_type.float)
-let max_ expr ty = Func ("MAX", [ Wrapped expr ], ty)
-let min_ expr ty = Func ("MIN", [ Wrapped expr ], ty)
-let lower expr = Func ("LOWER", [ Wrapped expr ], Mlecto_type.string)
-let upper expr = Func ("UPPER", [ Wrapped expr ], Mlecto_type.string)
-let length expr = Func ("LENGTH", [ Wrapped expr ], Mlecto_type.int)
-let trim expr = Func ("TRIM", [ Wrapped expr ], Mlecto_type.string)
-let ltrim expr = Func ("LTRIM", [ Wrapped expr ], Mlecto_type.string)
-let rtrim expr = Func ("RTRIM", [ Wrapped expr ], Mlecto_type.string)
-
-let concat exprs =
-  Func ("CONCAT", List.map (fun e -> Wrapped e) exprs, Mlecto_type.string)
-
-let concat_ws sep exprs =
-  Func
-    ( "CONCAT_WS",
-      Wrapped (string sep) :: List.map (fun e -> Wrapped e) exprs,
-      Mlecto_type.string )
-
-let substring expr ~from ~for_ =
-  Func
-    ( "SUBSTRING",
-      [ Wrapped expr; Wrapped (int from); Wrapped (int for_) ],
-      Mlecto_type.string )
-
-let replace expr ~from ~to_ =
-  Func
-    ( "REPLACE",
-      [ Wrapped expr; Wrapped (string from); Wrapped (string to_) ],
-      Mlecto_type.string )
-
-let left expr n =
-  Func ("LEFT", [ Wrapped expr; Wrapped (int n) ], Mlecto_type.string)
-
-let right expr n =
-  Func ("RIGHT", [ Wrapped expr; Wrapped (int n) ], Mlecto_type.string)
-
-let now () = Func ("NOW", [], Mlecto_type.ptime)
-let current_date = Func ("CURRENT_DATE", [], Mlecto_type.pdate)
-let current_timestamp = Func ("CURRENT_TIMESTAMP", [], Mlecto_type.ptime)
-
-let date_part part expr =
-  Func ("DATE_PART", [ Wrapped (string part); Wrapped expr ], Mlecto_type.float)
-
-let extract part expr =
-  Func
-    ( "EXTRACT",
-      [ Wrapped (Raw (part ^ " FROM ")); Wrapped expr ],
-      Mlecto_type.float )
-
-let age a b = Func ("AGE", [ Wrapped a; Wrapped b ], Mlecto_type.ptime_span)
-let abs_ expr = Func ("ABS", [ Wrapped expr ], Mlecto_type.int)
-let ceil expr = Func ("CEIL", [ Wrapped expr ], Mlecto_type.float)
-let floor expr = Func ("FLOOR", [ Wrapped expr ], Mlecto_type.float)
-let round expr = Func ("ROUND", [ Wrapped expr ], Mlecto_type.float)
-let sqrt expr = Func ("SQRT", [ Wrapped expr ], Mlecto_type.float)
-
-let power base exp =
-  Func ("POWER", [ Wrapped base; Wrapped exp ], Mlecto_type.float)
-
-let random = Func ("RANDOM", [], Mlecto_type.float)
-let gen_random_uuid = Func ("GEN_RANDOM_UUID", [], Mlecto_type.uuid)
-
-type wrapped_expr = W : 'a t -> wrapped_expr
-
-type 'a expr_list =
-  | [] : unit expr_list
-  | ( :: ) : 'a t * 'b expr_list -> ('a * 'b) expr_list
-
-let rec expr_list_to_list : type a. a expr_list -> wrapped_expr list = function
-  | [] -> []
-  | e :: rest -> W e :: expr_list_to_list rest
-
-let escape_string s =
-  let buf = Buffer.create (String.length s |> Stdlib.( * ) 2) in
-  String.iter
-    (fun c ->
-      match c with
-      | '\'' -> Buffer.add_string buf "''"
-      | _ -> Buffer.add_char buf c)
-    s;
-  Buffer.contents buf
-
-let lit_to_sql : type a. a -> a Mlecto_type.t -> string =
- fun v ty ->
-  match ty with
-  | Mlecto_type.Int -> string_of_int v
-  | Mlecto_type.Int32 -> Int32.to_string v
-  | Mlecto_type.Int64 -> Int64.to_string v
-  | Mlecto_type.Float -> Printf.sprintf "%g" v
-  | Mlecto_type.String -> Printf.sprintf "'%s'" (escape_string v)
-  | Mlecto_type.Bool -> if v then "TRUE" else "FALSE"
-  | Mlecto_type.Uuid -> Printf.sprintf "'%s'" (Uuidm.to_string v)
-  | Mlecto_type.Ptime -> Printf.sprintf "'%s'" (Ptime.to_rfc3339 v)
-  | Mlecto_type.Pdate ->
-      let y, m, d = v in
-      Printf.sprintf "'%04d-%02d-%02d'" y m d
-  | Mlecto_type.Json ->
-      Printf.sprintf "'%s'" (escape_string (Yojson.Safe.to_string v))
-  | _ -> failwith "Unsupported literal type for SQL generation"
-
-let rec to_sql : type a. a t -> string = function
-  | Lit (v, ty) -> lit_to_sql v ty
-  | Column field -> Mlecto_field.qualified_name field
-  | Null _ -> "NULL"
-  | Binop (op, a, b, _) -> Printf.sprintf "(%s %s %s)" (to_sql a) op (to_sql b)
-  | Unop (op, a, _) ->
-      if String.contains op ' ' then Printf.sprintf "(%s %s)" (to_sql a) op
-      else Printf.sprintf "(%s %s)" op (to_sql a)
-  | Func (name, args, _) ->
-      let arg_strs = List.map (fun (Wrapped e) -> to_sql e) args in
-      Printf.sprintf "%s(%s)" name (String.concat ", " arg_strs)
-  | Raw s -> s
-  | Param (n, _) -> Printf.sprintf "$%d" n
-  | Cast (expr, ty) ->
-      Printf.sprintf "CAST(%s AS %s)" (to_sql expr)
-        (Mlecto_type.sql_type_name ty)
-  | Case (branches, else_, _) ->
-      let branch_strs =
-        List.map
-          (fun (cond, result) ->
-            Printf.sprintf "WHEN %s THEN %s" (to_sql cond) (to_sql result))
-          branches
-      in
-      let else_str =
-        match else_ with
-        | Some e -> Printf.sprintf " ELSE %s" (to_sql e)
-        | None -> ""
-      in
-      Printf.sprintf "CASE %s%s END" (String.concat " " branch_strs) else_str
-  | Between (a, low, high) ->
-      Printf.sprintf "(%s BETWEEN %s AND %s)" (to_sql a) (to_sql low)
-        (to_sql high)
-  | InList (a, values) ->
-      let value_strs = List.map to_sql values in
-      Printf.sprintf "(%s IN (%s))" (to_sql a) (String.concat ", " value_strs)
-  | Subquery sql -> Printf.sprintf "(%s)" sql

lib/mlecto_field.ml lib/field.ml

···
 type ('record, 'value) t = {
   name : string;
-  ty : 'value Mlecto_type.t;
+  ty : 'value Types.t;
   get : 'record -> 'value;
   set : 'value -> 'record -> 'record;
   table_name : string;
···
     table_name;
     primary_key;
     unique;
-    nullable = Mlecto_type.is_nullable ty;
+    nullable = Types.is_nullable ty;
     default;
   }
 
···
 let is_primary_key f = f.primary_key
 let is_unique f = f.unique
 let is_nullable f = f.nullable
-let caqti_type f = Mlecto_type.to_caqti f.ty
+let caqti_type f = Types.to_caqti f.ty
 
 type 'record field_list =
   | [] : 'record field_list

lib/mlecto_multi.ml lib/multi.ml

···
 type 'a op =
-  | Insert : 'b Mlecto_changeset.t -> 'b op
-  | Update : 'b Mlecto_changeset.t -> 'b op
-  | Delete : { table : Mlecto_schema.table; id : int } -> unit op
-  | Run : (results -> ('b, Mlecto_error.db_error) result) -> 'b op
+  | Insert : 'b Changeset.t -> 'b op
+  | Update : 'b Changeset.t -> 'b op
+  | Delete : { table : Schema.table; id : int } -> unit op
+  | Run : (results -> ('b, Error.db_error) result) -> 'b op
 
 and entry = Entry : string * 'a op -> entry
 and results = (string * packed_result) list
···
 
 type multi_error = {
   failed_operation : string;
-  error : Mlecto_error.db_error;
+  error : Error.db_error;
   completed : results;
 }
 
···
     Error "Duplicate operation names in Multi"
   else Ok ()
 
-let run_operation : type a.
-    a op -> results -> (a, Mlecto_error.db_error) Stdlib.result =
+let run_operation : type a. a op -> results -> (a, Error.db_error) Stdlib.result
+    =
  fun op results ->
   match op with
   | Insert changeset ->
-      if Mlecto_changeset.is_valid changeset then
-        Ok (Mlecto_changeset.data changeset)
+      if Changeset.is_valid changeset then Ok (Changeset.data changeset)
       else
-        let errors = Mlecto_changeset.error_messages changeset in
-        Error (Mlecto_error.Validation_failed errors)
+        let errors = Changeset.error_messages changeset in
+        Error (Error.Validation_failed errors)
   | Update changeset ->
-      if Mlecto_changeset.is_valid changeset then
-        Ok (Mlecto_changeset.data changeset)
+      if Changeset.is_valid changeset then Ok (Changeset.data changeset)
       else
-        let errors = Mlecto_changeset.error_messages changeset in
-        Error (Mlecto_error.Validation_failed errors)
+        let errors = Changeset.error_messages changeset in
+        Error (Error.Validation_failed errors)
   | Delete { table; id } ->
       let _ = table in
       let _ = id in
···
       Error
         {
           failed_operation = "";
-          error = Mlecto_error.Query_failed msg;
+          error = Error.Query_failed msg;
           completed = [];
         }
   | Ok () ->

lib/mlecto_query.ml lib/query.ml

···
 
 type ('result, 'kind) t = {
   query_type : query_type;
-  table : Mlecto_schema.table;
-  select : Mlecto_expr.wrapped_expr list option;
-  wheres : Mlecto_expr.wrapped_expr list;
+  table : Schema.table;
+  select : Expr.wrapped_expr list option;
+  wheres : Expr.wrapped_expr list;
   joins : join list;
-  order_by : (Mlecto_expr.wrapped_expr * order_direction) list;
-  group_by : Mlecto_expr.wrapped_expr list;
-  having : Mlecto_expr.wrapped_expr list;
+  order_by : (Expr.wrapped_expr * order_direction) list;
+  group_by : Expr.wrapped_expr list;
+  having : Expr.wrapped_expr list;
   limit : int option;
   offset : int option;
   distinct : bool;
-  returning : Mlecto_expr.wrapped_expr list option;
-  set_values : (string * Mlecto_expr.wrapped_expr) list;
+  returning : Expr.wrapped_expr list option;
+  set_values : (string * Expr.wrapped_expr) list;
   insert_columns : string list;
-  insert_values : Mlecto_expr.wrapped_expr list list;
+  insert_values : Expr.wrapped_expr list list;
   conflict_target : string list option;
   conflict_action : conflict_action option;
 }
 
 and query_type = Select | Insert | Update | Delete
-
-and join = {
-  kind : join_kind;
-  table : Mlecto_schema.table;
-  on : Mlecto_expr.wrapped_expr;
-}
+and join = { kind : join_kind; table : Schema.table; on : Expr.wrapped_expr }
 
 and conflict_action =
   | DoNothing
-  | DoUpdate of (string * Mlecto_expr.wrapped_expr) list
+  | DoUpdate of (string * Expr.wrapped_expr) list
 
 let empty_query table query_type =
   {
···
 let delete_from table = empty_query table Delete
 
 let select exprs query =
-  let wrapped = Mlecto_expr.expr_list_to_list exprs in
+  let wrapped = Expr.expr_list_to_list exprs in
   { query with select = Some wrapped }
 
 let select_all query = { query with select = None }
-
-let where expr query =
-  { query with wheres = Mlecto_expr.W expr :: query.wheres }
-
+let where expr query = { query with wheres = Expr.W expr :: query.wheres }
 let and_where expr query = where expr query
 
 let or_where expr query =
···
   | [] -> where expr query
   | first :: rest ->
       let combined =
-        Mlecto_expr.W
-          (Mlecto_expr.( || )
-             (match first with Mlecto_expr.W e -> Obj.magic e)
+        Expr.W
+          (Expr.( || )
+             (match first with Expr.W e -> Obj.magic e)
              (Obj.magic expr))
       in
       { query with wheres = combined :: rest }
 
 let join ?(kind = Inner) ~on joined_table query =
-  let j = { kind; table = joined_table; on = Mlecto_expr.W on } in
+  let j = { kind; table = joined_table; on = Expr.W on } in
   { query with joins = j :: query.joins }
 
 let left_join ~on table query = join ~kind:Left ~on table query
···
 let full_join ~on table query = join ~kind:Full ~on table query
 
 let order_by ?(direction = Asc) expr query =
-  { query with order_by = (Mlecto_expr.W expr, direction) :: query.order_by }
+  { query with order_by = (Expr.W expr, direction) :: query.order_by }
 
 let asc expr query = order_by ~direction:Asc expr query
 let desc expr query = order_by ~direction:Desc expr query
 
 let group_by exprs query =
-  let wrapped = Mlecto_expr.expr_list_to_list exprs in
+  let wrapped = Expr.expr_list_to_list exprs in
   { query with group_by = wrapped @ query.group_by }
 
-let having expr query =
-  { query with having = Mlecto_expr.W expr :: query.having }
-
+let having expr query = { query with having = Expr.W expr :: query.having }
 let limit n query = { query with limit = Some n }
 let offset n query = { query with offset = Some n }
 let distinct query = { query with distinct = true }
 
 let returning exprs query =
-  let wrapped = Mlecto_expr.expr_list_to_list exprs in
+  let wrapped = Expr.expr_list_to_list exprs in
   { query with returning = Some wrapped }
 
 let set col expr query =
-  {
-    query with
-    set_values = (Mlecto_field.name col, Mlecto_expr.W expr) :: query.set_values;
-  }
+  { query with set_values = (Field.name col, Expr.W expr) :: query.set_values }
 
 let values columns rows query =
-  let col_names = List.map Mlecto_field.name columns in
+  let col_names = List.map Field.name columns in
   let wrapped_rows =
-    List.map (fun row -> List.map (fun e -> Mlecto_expr.W e) row) rows
+    List.map (fun row -> List.map (fun e -> Expr.W e) row) rows
   in
   { query with insert_columns = col_names; insert_values = wrapped_rows }
 
 let on_conflict_do_nothing ?(target = []) query =
   let target_names =
-    if target = [] then None else Some (List.map Mlecto_field.name target)
+    if target = [] then None else Some (List.map Field.name target)
   in
   {
     query with
···
   }
 
 let on_conflict_do_update ~target ~set query =
-  let target_names = List.map Mlecto_field.name target in
+  let target_names = List.map Field.name target in
   let set_pairs =
-    List.map
-      (fun (col, expr) -> (Mlecto_field.name col, Mlecto_expr.W expr))
-      set
+    List.map (fun (col, expr) -> (Field.name col, Expr.W expr)) set
   in
   {
     query with
···
   | Full -> "FULL JOIN"
 
 let direction_to_sql = function Asc -> "ASC" | Desc -> "DESC"
-let wrapped_to_sql (Mlecto_expr.W e) = Mlecto_expr.to_sql e
+let wrapped_to_sql (Expr.W e) = Expr.to_sql e
 
 let to_sql query =
   match query.query_type with
···
         | None -> "*"
         | Some exprs -> String.concat ", " (List.map wrapped_to_sql exprs)
       in
-      let from_str = Mlecto_schema.table_name query.table in
+      let from_str = Schema.table_name query.table in
       let join_strs =
         List.rev_map
           (fun j ->
             Printf.sprintf "%s %s ON %s" (join_kind_to_sql j.kind)
-              (Mlecto_schema.table_name j.table)
+              (Schema.table_name j.table)
               (wrapped_to_sql j.on))
           query.joins
       in
···
       in
       String.concat "" (List.filter (fun s -> s <> "") parts)
   | Insert ->
-      let table_str = Mlecto_schema.table_name query.table in
+      let table_str = Schema.table_name query.table in
       let cols_str = String.concat ", " query.insert_columns in
       let values_strs =
         List.map
···
       Printf.sprintf "INSERT INTO %s (%s) VALUES %s%s%s" table_str cols_str
         values_str conflict_str returning_str
   | Update ->
-      let table_str = Mlecto_schema.table_name query.table in
+      let table_str = Schema.table_name query.table in
       let set_strs =
         List.rev_map
           (fun (col, expr) ->
···
       Printf.sprintf "UPDATE %s SET %s%s%s" table_str set_str where_str
         returning_str
   | Delete ->
-      let table_str = Mlecto_schema.table_name query.table in
+      let table_str = Schema.table_name query.table in
       let where_str =
         match List.rev query.wheres with
         | [] -> ""

lib/mlecto_repo.ml

···
-type 'a result = ('a, Mlecto_error.db_error) Stdlib.result
-
-let caqti_error_to_db_error err : Mlecto_error.db_error =
-  Mlecto_error.Query_failed (Caqti_error.show err)
-
-module type S = sig
-  type conn
-
-  val get_by_id :
-    conn:conn ->
-    table:Mlecto_schema.table ->
-    id_column:string ->
-    id:int ->
-    sql:string ->
-    unit result
-
-  val execute_sql : conn:conn -> sql:string -> unit result
-  val insert_changeset : 'a Mlecto_changeset.t -> 'a result
-  val update_changeset : 'a Mlecto_changeset.t -> 'a result
-end
-
-module Sync = struct
-  type conn = unit
-
-  let get_by_id ~conn:() ~table ~id_column ~id ~sql:_ =
-    let _ = table in
-    let _ = id_column in
-    let _ = id in
-    Error Mlecto_error.Not_found
-
-  let execute_sql ~conn:() ~sql:_ = Ok ()
-
-  let insert_changeset changeset =
-    if Mlecto_changeset.is_valid changeset then
-      Ok (Mlecto_changeset.data changeset)
-    else
-      let errors = Mlecto_changeset.error_messages changeset in
-      Error (Mlecto_error.Query_failed (String.concat "; " errors))
-
-  let update_changeset changeset =
-    if Mlecto_changeset.is_valid changeset then
-      Ok (Mlecto_changeset.data changeset)
-    else
-      let errors = Mlecto_changeset.error_messages changeset in
-      Error (Mlecto_error.Query_failed (String.concat "; " errors))
-end
-
-let insert changeset = Sync.insert_changeset changeset
-let update changeset = Sync.update_changeset changeset
-
-let validate_and_insert changeset =
-  if Mlecto_changeset.is_valid changeset then
-    Ok (Mlecto_changeset.data changeset)
-  else Error (Mlecto_changeset.errors changeset)
-
-let validate_and_update changeset =
-  if Mlecto_changeset.is_valid changeset then
-    Ok (Mlecto_changeset.data changeset)
-  else Error (Mlecto_changeset.errors changeset)
-
-let build_insert_sql table columns =
-  let table_name = Mlecto_schema.table_name table in
-  let col_str = String.concat ", " columns in
-  let placeholders =
-    List.mapi (fun i _ -> Printf.sprintf "$%d" (i + 1)) columns
-  in
-  let val_str = String.concat ", " placeholders in
-  Printf.sprintf "INSERT INTO %s (%s) VALUES (%s)" table_name col_str val_str
-
-let build_update_sql table columns ~where_column =
-  let table_name = Mlecto_schema.table_name table in
-  let set_clauses =
-    List.mapi (fun i col -> Printf.sprintf "%s = $%d" col (i + 1)) columns
-  in
-  let set_str = String.concat ", " set_clauses in
-  let where_idx = List.length columns + 1 in
-  Printf.sprintf "UPDATE %s SET %s WHERE %s = $%d" table_name set_str
-    where_column where_idx
-
-let build_delete_sql table ~where_column =
-  let table_name = Mlecto_schema.table_name table in
-  Printf.sprintf "DELETE FROM %s WHERE %s = $1" table_name where_column
-
-let build_select_sql table ~columns ~where_column =
-  let table_name = Mlecto_schema.table_name table in
-  let col_str =
-    match columns with [] -> "*" | cols -> String.concat ", " cols
-  in
-  Printf.sprintf "SELECT %s FROM %s WHERE %s = $1" col_str table_name
-    where_column
-
-type savepoint = { name : string; depth : int }
-type tx_state = { mutable depth : int; mutable savepoints : savepoint list }
-
-let create_tx_state () = { depth = 0; savepoints = [] }
-let begin_sql = "BEGIN"
-let commit_sql = "COMMIT"
-let rollback_sql = "ROLLBACK"
-let savepoint_sql name = Printf.sprintf "SAVEPOINT %s" name
-let release_savepoint_sql name = Printf.sprintf "RELEASE SAVEPOINT %s" name
-
-let rollback_to_savepoint_sql name =
-  Printf.sprintf "ROLLBACK TO SAVEPOINT %s" name
-
-let generate_savepoint_name depth = Printf.sprintf "mlecto_sp_%d" depth
-
-type 'a tx_result = ('a, Mlecto_error.db_error) Stdlib.result
-
-type tx_action =
-  | Begin
-  | Commit
-  | Rollback
-  | Savepoint of string
-  | ReleaseSavepoint of string
-  | RollbackToSavepoint of string
-
-let tx_action_to_sql = function
-  | Begin -> begin_sql
-  | Commit -> commit_sql
-  | Rollback -> rollback_sql
-  | Savepoint name -> savepoint_sql name
-  | ReleaseSavepoint name -> release_savepoint_sql name
-  | RollbackToSavepoint name -> rollback_to_savepoint_sql name
-
-let enter_transaction state =
-  if state.depth = 0 then begin
-    state.depth <- 1;
-    Begin
-  end
-  else begin
-    let sp_name = generate_savepoint_name state.depth in
-    let sp = { name = sp_name; depth = state.depth } in
-    state.savepoints <- sp :: state.savepoints;
-    state.depth <- state.depth + 1;
-    Savepoint sp_name
-  end
-
-let commit_transaction state =
-  if state.depth <= 1 then begin
-    state.depth <- 0;
-    state.savepoints <- [];
-    Commit
-  end
-  else begin
-    match state.savepoints with
-    | sp :: rest ->
-        state.savepoints <- rest;
-        state.depth <- state.depth - 1;
-        ReleaseSavepoint sp.name
-    | [] ->
-        state.depth <- state.depth - 1;
-        Commit
-  end
-
-let rollback_transaction state =
-  if state.depth <= 1 then begin
-    state.depth <- 0;
-    state.savepoints <- [];
-    Rollback
-  end
-  else begin
-    match state.savepoints with
-    | sp :: rest ->
-        state.savepoints <- rest;
-        state.depth <- state.depth - 1;
-        RollbackToSavepoint sp.name
-    | [] ->
-        state.depth <- 0;
-        state.savepoints <- [];
-        Rollback
-  end
-
-let transaction_depth state = state.depth
-let in_transaction state = state.depth > 0

lib/mlecto_schema.ml lib/schema.ml

···
 
 type 'a column = {
   col_name : string;
-  col_type : 'a Mlecto_type.t;
+  col_type : 'a Types.t;
   col_constraints : column_constraint list;
 }
 
···
 let with_check ?name expr def =
   { def with tbl_checks = (name, expr) :: def.tbl_checks }
 
-let id_column () =
-  column "id" Mlecto_type.int64 ~primary_key:true ~not_null:true
+let id_column () = column "id" Types.int64 ~primary_key:true ~not_null:true
 
 let timestamps () =
   [
-    column "inserted_at" Mlecto_type.ptime ~not_null:true ~default:"NOW()";
-    column "updated_at" Mlecto_type.ptime ~not_null:true ~default:"NOW()";
+    column "inserted_at" Types.ptime ~not_null:true ~default:"NOW()";
+    column "updated_at" Types.ptime ~not_null:true ~default:"NOW()";
   ]
 
 let has_constraint c col = List.exists (fun con -> con = c) col.col_constraints
···
       | None -> base)
 
 let column_to_sql (Column col) =
-  let type_name = Mlecto_type.sql_type_name col.col_type in
+  let type_name = Types.sql_type_name col.col_type in
   let constraints = List.map constraint_to_sql col.col_constraints in
   String.concat " " (col.col_name :: type_name :: constraints)
 

lib/repo.ml

···
+type 'a result = ('a, Error.db_error) Stdlib.result
+
+let caqti_error_to_db_error err : Error.db_error =
+  Error.Query_failed (Caqti_error.show err)
+
+module type CONNECTION = sig
+  type t
+
+  val exec : t -> string -> (unit, Caqti_error.t) Stdlib.result
+  val find : t -> string -> ('a, Caqti_error.t) Stdlib.result
+  val find_opt : t -> string -> ('a option, Caqti_error.t) Stdlib.result
+  val collect_list : t -> string -> ('a list, Caqti_error.t) Stdlib.result
+end
+
+module type REPO = sig
+  type conn
+
+  val get :
+    conn ->
+    table:Schema.table ->
+    id:int ->
+    decode:(string list -> 'a) ->
+    'a result
+
+  val get_opt :
+    conn ->
+    table:Schema.table ->
+    id:int ->
+    decode:(string list -> 'a) ->
+    'a option result
+
+  val all :
+    conn -> table:Schema.table -> decode:(string list -> 'a) -> 'a list result
+
+  val insert :
+    conn ->
+    table:Schema.table ->
+    columns:string list ->
+    values:string list ->
+    unit result
+
+  val update :
+    conn ->
+    table:Schema.table ->
+    columns:string list ->
+    values:string list ->
+    where_column:string ->
+    where_value:string ->
+    unit result
+
+  val delete :
+    conn ->
+    table:Schema.table ->
+    where_column:string ->
+    where_value:string ->
+    unit result
+
+  val transaction : conn -> (conn -> 'a result) -> 'a result
+end
+
+type savepoint = { name : string; depth : int }
+type tx_state = { mutable depth : int; mutable savepoints : savepoint list }
+
+let create_tx_state () = { depth = 0; savepoints = [] }
+let generate_savepoint_name depth = Printf.sprintf "repodb_sp_%d" depth
+
+type tx_action =
+  | Begin
+  | Commit
+  | Rollback
+  | Savepoint of string
+  | ReleaseSavepoint of string
+  | RollbackToSavepoint of string
+
+let tx_action_to_sql = function
+  | Begin -> "BEGIN"
+  | Commit -> "COMMIT"
+  | Rollback -> "ROLLBACK"
+  | Savepoint name -> Printf.sprintf "SAVEPOINT %s" name
+  | ReleaseSavepoint name -> Printf.sprintf "RELEASE SAVEPOINT %s" name
+  | RollbackToSavepoint name -> Printf.sprintf "ROLLBACK TO SAVEPOINT %s" name
+
+let enter_transaction state =
+  if state.depth = 0 then begin
+    state.depth <- 1;
+    Begin
+  end
+  else begin
+    let sp_name = generate_savepoint_name state.depth in
+    let sp = { name = sp_name; depth = state.depth } in
+    state.savepoints <- sp :: state.savepoints;
+    state.depth <- state.depth + 1;
+    Savepoint sp_name
+  end
+
+let commit_transaction state =
+  if state.depth <= 1 then begin
+    state.depth <- 0;
+    state.savepoints <- [];
+    Commit
+  end
+  else begin
+    match state.savepoints with
+    | sp :: rest ->
+        state.savepoints <- rest;
+        state.depth <- state.depth - 1;
+        ReleaseSavepoint sp.name
+    | [] ->
+        state.depth <- state.depth - 1;
+        Commit
+  end
+
+let rollback_transaction state =
+  if state.depth <= 1 then begin
+    state.depth <- 0;
+    state.savepoints <- [];
+    Rollback
+  end
+  else begin
+    match state.savepoints with
+    | sp :: rest ->
+        state.savepoints <- rest;
+        state.depth <- state.depth - 1;
+        RollbackToSavepoint sp.name
+    | [] ->
+        state.depth <- 0;
+        state.savepoints <- [];
+        Rollback
+  end
+
+let in_transaction state = state.depth > 0
+let transaction_depth state = state.depth
+
+let insert_changeset ~changeset ~on_valid ~on_invalid =
+  if Changeset.is_valid changeset then on_valid (Changeset.data changeset)
+  else
+    let errors = Changeset.error_messages changeset in
+    on_invalid errors
+
+let update_changeset ~changeset ~on_valid ~on_invalid =
+  if Changeset.is_valid changeset then on_valid (Changeset.data changeset)
+  else
+    let errors = Changeset.error_messages changeset in
+    on_invalid errors
+
+let validate_changeset changeset =
+  if Changeset.is_valid changeset then Ok (Changeset.data changeset)
+  else Error (Error.Validation_failed (Changeset.error_messages changeset))
+
+let build_insert_sql table columns =
+  let table_name = Schema.table_name table in
+  let col_str = String.concat ", " columns in
+  let placeholders =
+    List.mapi (fun i _ -> Printf.sprintf "$%d" (i + 1)) columns
+  in
+  let val_str = String.concat ", " placeholders in
+  Printf.sprintf "INSERT INTO %s (%s) VALUES (%s)" table_name col_str val_str
+
+let build_insert_returning_sql table columns =
+  let table_name = Schema.table_name table in
+  let col_str = String.concat ", " columns in
+  let placeholders =
+    List.mapi (fun i _ -> Printf.sprintf "$%d" (i + 1)) columns
+  in
+  let val_str = String.concat ", " placeholders in
+  Printf.sprintf "INSERT INTO %s (%s) VALUES (%s) RETURNING *" table_name
+    col_str val_str
+
+let build_update_sql table columns ~where_column =
+  let table_name = Schema.table_name table in
+  let set_clauses =
+    List.mapi (fun i col -> Printf.sprintf "%s = $%d" col (i + 1)) columns
+  in
+  let set_str = String.concat ", " set_clauses in
+  let where_idx = List.length columns + 1 in
+  Printf.sprintf "UPDATE %s SET %s WHERE %s = $%d" table_name set_str
+    where_column where_idx
+
+let build_update_returning_sql table columns ~where_column =
+  let table_name = Schema.table_name table in
+  let set_clauses =
+    List.mapi (fun i col -> Printf.sprintf "%s = $%d" col (i + 1)) columns
+  in
+  let set_str = String.concat ", " set_clauses in
+  let where_idx = List.length columns + 1 in
+  Printf.sprintf "UPDATE %s SET %s WHERE %s = $%d RETURNING *" table_name
+    set_str where_column where_idx
+
+let build_delete_sql table ~where_column =
+  let table_name = Schema.table_name table in
+  Printf.sprintf "DELETE FROM %s WHERE %s = $1" table_name where_column
+
+let build_select_sql table ~columns ~where_column =
+  let table_name = Schema.table_name table in
+  let col_str =
+    match columns with [] -> "*" | cols -> String.concat ", " cols
+  in
+  Printf.sprintf "SELECT %s FROM %s WHERE %s = $1" col_str table_name
+    where_column
+
+let build_select_all_sql table ~columns =
+  let table_name = Schema.table_name table in
+  let col_str =
+    match columns with [] -> "*" | cols -> String.concat ", " cols
+  in
+  Printf.sprintf "SELECT %s FROM %s" col_str table_name
+
+let build_select_where_sql table ~columns ~where_sql =
+  let table_name = Schema.table_name table in
+  let col_str =
+    match columns with [] -> "*" | cols -> String.concat ", " cols
+  in
+  Printf.sprintf "SELECT %s FROM %s WHERE %s" col_str table_name where_sql
+
+let build_preload_sql ~related_table ~fk_column ~n_ids =
+  let placeholders =
+    List.init n_ids (fun i -> Printf.sprintf "$%d" (i + 1))
+    |> String.concat ", "
+  in
+  Printf.sprintf "SELECT * FROM %s WHERE %s IN (%s)" related_table fk_column
+    placeholders
+
+let build_preload_assoc_sql assoc owner_ids =
+  let n = List.length owner_ids in
+  if n = 0 then None
+  else
+    let ids_str = List.map string_of_int owner_ids |> String.concat ", " in
+    Some
+      (Assoc.build_batch_query assoc (List.map string_of_int owner_ids), ids_str)
+
+let constraint_error_to_changeset ~constraint_name ~message =
+  Error.Constraint_violation { constraint_name; message }
+
+let parse_pg_constraint_error error_msg =
+  let unique_re =
+    Re.Pcre.regexp {|duplicate key value violates unique constraint "([^"]+)"|}
+  in
+  let fk_re = Re.Pcre.regexp {|violates foreign key constraint "([^"]+)"|} in
+  match Re.exec_opt unique_re error_msg with
+  | Some groups ->
+      let constraint_name = Re.Group.get groups 1 in
+      Some (`Unique constraint_name)
+  | None -> (
+      match Re.exec_opt fk_re error_msg with
+      | Some groups ->
+          let constraint_name = Re.Group.get groups 1 in
+          Some (`ForeignKey constraint_name)
+      | None -> None)
+
+let map_constraint_error changeset error_msg constraint_mapping =
+  match parse_pg_constraint_error error_msg with
+  | None -> changeset
+  | Some constraint_type -> (
+      let constraint_name =
+        match constraint_type with
+        | `Unique name -> name
+        | `ForeignKey name -> name
+      in
+      match List.assoc_opt constraint_name constraint_mapping with
+      | None -> changeset
+      | Some (field, message) ->
+          Changeset.add_error changeset ~field ~message ~validation:"constraint"
+      )

mlecto.opam repodb.opam

···
 opam-version: "2.0"
 synopsis: "Ecto-like database toolkit for OCaml"
 description:
-  "mlecto is a database toolkit inspired by Elixir's Ecto. It provides type-safe query building, schema definitions, changesets for data validation, and database migrations. Built on Caqti with Eio for async operations."
+  "repodb is a database toolkit inspired by Elixir's Ecto. It provides type-safe query building, schema definitions, changesets for data validation, and database migrations. Built on Caqti with Eio for async operations."
 maintainer: ["Guillermo Diaz-Romero <[e-mail]>"]
 authors: ["Guillermo Diaz-Romero <[e-mail]>"]
 license: "MIT"
 tags: ["database" "postgresql" "ecto" "orm" "query-builder" "migrations"]
-homepage: "https://github.com/gdiazlo/mlecto"
-doc: "https://github.com/gdiazlo/mlecto"
-bug-reports: "https://github.com/gdiazlo/mlecto/issues"
+homepage: "https://github.com/gdiazlo/repodb"
+doc: "https://github.com/gdiazlo/repodb"
+bug-reports: "https://github.com/gdiazlo/repodb/issues"
 depends: [
   "ocaml" {>= "5.1"}
   "dune" {>= "3.20" & >= "3.20"}
···
     "@doc" {with-doc}
   ]
 ]
-dev-repo: "git+https://github.com/gdiazlo/mlecto.git"
+dev-repo: "git+https://github.com/gdiazlo/repodb.git"
 x-maintenance-intent: ["(latest)"]

test/dune

···
 (test
- (name test_mlecto)
- (libraries mlecto alcotest))
+ (name test_repodb)
+ (libraries repodb alcotest))

test/test_mlecto.ml

···
-let () = print_endline "Tests not yet implemented"

test/test_repodb.ml

···
+open Repodb
+
+type user = {
+  id : int;
+  name : string;
+  email : string;
+  age : int;
+  active : bool;
+}
+
+let make_user ?(id = 0) ?(name = "") ?(email = "") ?(age = 0) ?(active = true)
+    () =
+  { id; name; email; age; active }
+
+let users_table = Schema.table "users"
+
+let id_field : (user, int) Field.t =
+  Field.make ~table_name:"users" ~name:"id" ~ty:Types.int
+    ~get:(fun u -> u.id)
+    ~set:(fun v u -> { u with id = v })
+    ~primary_key:true ()
+
+let name_field : (user, string) Field.t =
+  Field.make ~table_name:"users" ~name:"name" ~ty:Types.string
+    ~get:(fun u -> u.name)
+    ~set:(fun v u -> { u with name = v })
+    ()
+
+let email_field : (user, string) Field.t =
+  Field.make ~table_name:"users" ~name:"email" ~ty:Types.string
+    ~get:(fun u -> u.email)
+    ~set:(fun v u -> { u with email = v })
+    ()
+
+let age_field : (user, int) Field.t =
+  Field.make ~table_name:"users" ~name:"age" ~ty:Types.int
+    ~get:(fun u -> u.age)
+    ~set:(fun v u -> { u with age = v })
+    ()
+
+let _active_field : (user, bool) Field.t =
+  Field.make ~table_name:"users" ~name:"active" ~ty:Types.bool
+    ~get:(fun u -> u.active)
+    ~set:(fun v u -> { u with active = v })
+    ()
+
+module Types_test = struct
+  let test_sql_type_name_int () =
+    Alcotest.(check string)
+      "int maps to INTEGER" "INTEGER"
+      (Types.sql_type_name Types.int)
+
+  let test_sql_type_name_int64 () =
+    Alcotest.(check string)
+      "int64 maps to BIGINT" "BIGINT"
+      (Types.sql_type_name Types.int64)
+
+  let test_sql_type_name_string () =
+    Alcotest.(check string)
+      "string maps to TEXT" "TEXT"
+      (Types.sql_type_name Types.string)
+
+  let test_sql_type_name_bool () =
+    Alcotest.(check string)
+      "bool maps to BOOLEAN" "BOOLEAN"
+      (Types.sql_type_name Types.bool)
+
+  let test_sql_type_name_float () =
+    Alcotest.(check string)
+      "float maps to DOUBLE PRECISION" "DOUBLE PRECISION"
+      (Types.sql_type_name Types.float)
+
+  let test_sql_type_name_ptime () =
+    Alcotest.(check string)
+      "ptime maps to TIMESTAMPTZ" "TIMESTAMPTZ"
+      (Types.sql_type_name Types.ptime)
+
+  let test_sql_type_name_uuid () =
+    Alcotest.(check string)
+      "uuid maps to UUID" "UUID"
+      (Types.sql_type_name Types.uuid)
+
+  let test_sql_type_name_json () =
+    Alcotest.(check string)
+      "json maps to JSONB" "JSONB"
+      (Types.sql_type_name Types.json)
+
+  let test_sql_type_name_option () =
+    Alcotest.(check string)
+      "option string still maps to TEXT" "TEXT"
+      (Types.sql_type_name (Types.option Types.string))
+
+  let test_sql_type_name_array () =
+    Alcotest.(check string)
+      "array int maps to INTEGER[]" "INTEGER[]"
+      (Types.sql_type_name (Types.array Types.int))
+
+  let test_is_nullable_option () =
+    Alcotest.(check bool)
+      "option is nullable" true
+      (Types.is_nullable (Types.option Types.string))
+
+  let test_is_nullable_non_option () =
+    Alcotest.(check bool)
+      "non-option is not nullable" false
+      (Types.is_nullable Types.string)
+
+  let test_custom_type () =
+    let custom =
+      Types.custom
+        ~encode:(fun s -> Ok s)
+        ~decode:(fun s -> Ok s)
+        ~sql_type:"CUSTOM_TYPE"
+    in
+    Alcotest.(check string)
+      "custom type name" "CUSTOM_TYPE"
+      (Types.sql_type_name custom)
+
+  let tests =
+    [
+      ("sql_type_name int", `Quick, test_sql_type_name_int);
+      ("sql_type_name int64", `Quick, test_sql_type_name_int64);
+      ("sql_type_name string", `Quick, test_sql_type_name_string);
+      ("sql_type_name bool", `Quick, test_sql_type_name_bool);
+      ("sql_type_name float", `Quick, test_sql_type_name_float);
+      ("sql_type_name ptime", `Quick, test_sql_type_name_ptime);
+      ("sql_type_name uuid", `Quick, test_sql_type_name_uuid);
+      ("sql_type_name json", `Quick, test_sql_type_name_json);
+      ("sql_type_name option", `Quick, test_sql_type_name_option);
+      ("sql_type_name array", `Quick, test_sql_type_name_array);
+      ("is_nullable option", `Quick, test_is_nullable_option);
+      ("is_nullable non-option", `Quick, test_is_nullable_non_option);
+      ("custom type", `Quick, test_custom_type);
+    ]
+end
+
+module Error_test = struct
+  let test_show_db_error_not_found () =
+    Alcotest.(check string)
+      "Not_found message" "Record not found"
+      (Error.show_db_error Error.Not_found)
+
+  let test_show_db_error_query_failed () =
+    Alcotest.(check string)
+      "Query_failed message" "Query failed: syntax error"
+      (Error.show_db_error (Error.Query_failed "syntax error"))
+
+  let test_show_db_error_constraint_violation () =
+    let err =
+      Error.Constraint_violation
+        { constraint_name = "users_email_key"; message = "duplicate key" }
+    in
+    Alcotest.(check string)
+      "Constraint_violation message"
+      "Constraint violation (users_email_key): duplicate key"
+      (Error.show_db_error err)
+
+  let test_show_db_error_validation_failed () =
+    let err =
+      Error.Validation_failed [ "name can't be blank"; "email invalid" ]
+    in
+    Alcotest.(check string)
+      "Validation_failed message"
+      "Validation failed: name can't be blank; email invalid"
+      (Error.show_db_error err)
+
+  let test_show_validation_error () =
+    let err =
+      Error.
+        {
+          field = "email";
+          message = "has invalid format";
+          validation = "format";
+        }
+    in
+    Alcotest.(check string)
+      "validation error format" "email: has invalid format (format)"
+      (Error.show_validation_error err)
+
+  let tests =
+    [
+      ("show_db_error Not_found", `Quick, test_show_db_error_not_found);
+      ("show_db_error Query_failed", `Quick, test_show_db_error_query_failed);
+      ( "show_db_error Constraint_violation",
+        `Quick,
+        test_show_db_error_constraint_violation );
+      ( "show_db_error Validation_failed",
+        `Quick,
+        test_show_db_error_validation_failed );
+      ("show_validation_error", `Quick, test_show_validation_error);
+    ]
+end
+
+module Field_test = struct
+  let test_field_name () =
+    Alcotest.(check string) "field name" "name" (Field.name name_field)
+
+  let test_field_qualified_name () =
+    Alcotest.(check string)
+      "qualified name" "users.name"
+      (Field.qualified_name name_field)
+
+  let test_field_get () =
+    let user = make_user ~name:"Alice" () in
+    Alcotest.(check string)
+      "get field value" "Alice"
+      (Field.get name_field user)
+
+  let test_field_set () =
+    let user = make_user ~name:"Alice" () in
+    let updated = Field.set name_field "Bob" user in
+    Alcotest.(check string) "set field value" "Bob" updated.name
+
+  let test_field_is_primary_key () =
+    Alcotest.(check bool)
+      "id is primary key" true
+      (Field.is_primary_key id_field);
+    Alcotest.(check bool)
+      "name is not primary key" false
+      (Field.is_primary_key name_field)
+
+  let test_field_is_nullable () =
+    Alcotest.(check bool)
+      "name is not nullable" false
+      (Field.is_nullable name_field)
+
+  let tests =
+    [
+      ("field name", `Quick, test_field_name);
+      ("field qualified_name", `Quick, test_field_qualified_name);
+      ("field get", `Quick, test_field_get);
+      ("field set", `Quick, test_field_set);
+      ("field is_primary_key", `Quick, test_field_is_primary_key);
+      ("field is_nullable", `Quick, test_field_is_nullable);
+    ]
+end
+
+module Schema_test = struct
+  let test_table_name () =
+    let t = Schema.table "posts" in
+    Alcotest.(check string) "table name" "posts" (Schema.table_name t)
+
+  let test_table_name_with_schema () =
+    let t = Schema.table ~schema:(Some "public") "posts" in
+    Alcotest.(check string)
+      "table with schema" "public.posts" (Schema.table_name t)
+
+  let test_column_creation () =
+    let col = Schema.column "title" Types.string ~not_null:true in
+    Alcotest.(check string) "column name" "title" col.col_name
+
+  let test_column_with_primary_key () =
+    let col = Schema.column "id" Types.int64 ~primary_key:true ~not_null:true in
+    Alcotest.(check bool) "is primary key" true (Schema.is_primary_key col)
+
+  let test_column_with_default () =
+    let col = Schema.column "created_at" Types.ptime ~default:"NOW()" in
+    Alcotest.(check (option string))
+      "has default" (Some "NOW()") (Schema.get_default col)
+
+  let test_id_column () =
+    let col = Schema.id_column () in
+    Alcotest.(check string) "id column name" "id" col.col_name;
+    Alcotest.(check bool) "id is primary key" true (Schema.is_primary_key col)
+
+  let test_timestamps () =
+    let cols = Schema.timestamps () in
+    Alcotest.(check int) "timestamps count" 2 (List.length cols);
+    let names = List.map (fun c -> c.Schema.col_name) cols in
+    Alcotest.(check bool) "has inserted_at" true (List.mem "inserted_at" names);
+    Alcotest.(check bool) "has updated_at" true (List.mem "updated_at" names)
+
+  let test_table_def_to_sql () =
+    let id_col =
+      Schema.column "id" Types.int64 ~primary_key:true ~not_null:true
+    in
+    let def = Schema.define "users" [ id_col ] in
+    let sql = Schema.table_def_to_sql def in
+    Alcotest.(check bool)
+      "contains CREATE TABLE" true
+      (String.length sql > 0 && String.sub sql 0 12 = "CREATE TABLE")
+
+  let test_foreign_key_reference () =
+    let fk = Schema.references ~table:"posts" ~column:"id" () in
+    Alcotest.(check string) "fk table" "posts" fk.fk_table;
+    Alcotest.(check string) "fk column" "id" fk.fk_column
+
+  let tests =
+    [
+      ("table_name", `Quick, test_table_name);
+      ("table_name with schema", `Quick, test_table_name_with_schema);
+      ("column creation", `Quick, test_column_creation);
+      ("column with primary_key", `Quick, test_column_with_primary_key);
+      ("column with default", `Quick, test_column_with_default);
+      ("id_column helper", `Quick, test_id_column);
+      ("timestamps helper", `Quick, test_timestamps);
+      ("table_def_to_sql", `Quick, test_table_def_to_sql);
+      ("foreign_key reference", `Quick, test_foreign_key_reference);
+    ]
+end
+
+module Changeset_test = struct
+  let test_create_changeset () =
+    let user = make_user () in
+    let cs = Changeset.create user in
+    Alcotest.(check bool) "new changeset is valid" true (Changeset.is_valid cs)
+
+  let test_cast_filters_fields () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast
+           [ ("name", "Alice"); ("unknown", "value") ]
+           ~fields:[ name_field ]
+    in
+    let changes = Changeset.changes cs in
+    Alcotest.(check int) "only allowed fields" 1 (List.length changes);
+    Alcotest.(check bool) "has name change" true (List.mem_assoc "name" changes)
+
+  let test_validate_required_passes () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "Alice") ] ~fields:[ name_field ]
+      |> Changeset.validate_required [ name_field ]
+    in
+    Alcotest.(check bool)
+      "valid with required field" true (Changeset.is_valid cs)
+
+  let test_validate_required_fails_empty () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "") ] ~fields:[ name_field ]
+      |> Changeset.validate_required [ name_field ]
+    in
+    Alcotest.(check bool)
+      "invalid with empty required" false (Changeset.is_valid cs)
+
+  let test_validate_required_fails_missing () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [] ~fields:[ name_field ]
+      |> Changeset.validate_required [ name_field ]
+    in
+    Alcotest.(check bool)
+      "invalid with missing required" false (Changeset.is_valid cs)
+
+  let test_validate_format_passes () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast
+           [ ("email", "[e-mail]") ]
+           ~fields:[ email_field ]
+      |> Changeset.validate_format email_field ~pattern:"^[^@]+@[^@]+$"
+    in
+    Alcotest.(check bool) "valid email format" true (Changeset.is_valid cs)
+
+  let test_validate_format_fails () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("email", "invalid-email") ] ~fields:[ email_field ]
+      |> Changeset.validate_format email_field ~pattern:"^[^@]+@[^@]+$"
+    in
+    Alcotest.(check bool) "invalid email format" false (Changeset.is_valid cs)
+
+  let test_validate_length_min () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "Al") ] ~fields:[ name_field ]
+      |> Changeset.validate_length name_field ~min:3
+    in
+    Alcotest.(check bool) "too short" false (Changeset.is_valid cs)
+
+  let test_validate_length_max () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "A very long name") ] ~fields:[ name_field ]
+      |> Changeset.validate_length name_field ~max:5
+    in
+    Alcotest.(check bool) "too long" false (Changeset.is_valid cs)
+
+  let test_validate_length_exact () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "Alice") ] ~fields:[ name_field ]
+      |> Changeset.validate_length name_field ~is:5
+    in
+    Alcotest.(check bool) "exact length valid" true (Changeset.is_valid cs)
+
+  let test_validate_inclusion () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "admin") ] ~fields:[ name_field ]
+      |> Changeset.validate_inclusion name_field
+           ~values:[ "admin"; "user"; "guest" ]
+    in
+    Alcotest.(check bool) "value in list" true (Changeset.is_valid cs)
+
+  let test_validate_inclusion_fails () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "hacker") ] ~fields:[ name_field ]
+      |> Changeset.validate_inclusion name_field
+           ~values:[ "admin"; "user"; "guest" ]
+    in
+    Alcotest.(check bool) "value not in list" false (Changeset.is_valid cs)
+
+  let test_validate_exclusion () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "admin") ] ~fields:[ name_field ]
+      |> Changeset.validate_exclusion name_field ~values:[ "root"; "system" ]
+    in
+    Alcotest.(check bool) "value not excluded" true (Changeset.is_valid cs)
+
+  let test_validate_exclusion_fails () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "root") ] ~fields:[ name_field ]
+      |> Changeset.validate_exclusion name_field ~values:[ "root"; "system" ]
+    in
+    Alcotest.(check bool) "value excluded" false (Changeset.is_valid cs)
+
+  let test_validate_number_greater_than () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("age", "25") ] ~fields:[ age_field ]
+      |> Changeset.validate_number age_field ~greater_than:18
+    in
+    Alcotest.(check bool) "number greater than" true (Changeset.is_valid cs)
+
+  let test_validate_number_greater_than_fails () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("age", "15") ] ~fields:[ age_field ]
+      |> Changeset.validate_number age_field ~greater_than:18
+    in
+    Alcotest.(check bool)
+      "number not greater than" false (Changeset.is_valid cs)
+
+  let test_add_error () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.add_error ~field:"email" ~message:"is taken"
+           ~validation:"unique"
+    in
+    Alcotest.(check bool) "has error" false (Changeset.is_valid cs);
+    Alcotest.(check int) "error count" 1 (List.length (Changeset.errors cs))
+
+  let test_error_messages () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.add_error ~field:"name" ~message:"can't be blank"
+           ~validation:"required"
+      |> Changeset.add_error ~field:"email" ~message:"is invalid"
+           ~validation:"format"
+    in
+    let msgs = Changeset.error_messages cs in
+    Alcotest.(check int) "two error messages" 2 (List.length msgs)
+
+  let test_get_change () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "Alice") ] ~fields:[ name_field ]
+    in
+    Alcotest.(check (option string))
+      "get change" (Some "Alice")
+      (Changeset.get_change cs name_field)
+
+  let test_put_change () =
+    let user = make_user () in
+    let cs = Changeset.create user |> Changeset.put_change name_field "Bob" in
+    Alcotest.(check (option string))
+      "put change" (Some "Bob")
+      (Changeset.get_change cs name_field)
+
+  let test_delete_change () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast [ ("name", "Alice") ] ~fields:[ name_field ]
+      |> Changeset.delete_change name_field
+    in
+    Alcotest.(check (option string))
+      "delete change" None
+      (Changeset.get_change cs name_field)
+
+  let test_for_insert () =
+    let user = make_user () in
+    let cs = Changeset.for_insert user in
+    Alcotest.(check (option bool))
+      "action is insert" (Some true)
+      (Option.map (fun a -> a = Changeset.Insert) (Changeset.action cs))
+
+  let test_for_update () =
+    let user = make_user () in
+    let cs = Changeset.for_update user in
+    Alcotest.(check (option bool))
+      "action is update" (Some true)
+      (Option.map (fun a -> a = Changeset.Update) (Changeset.action cs))
+
+  let test_apply_action_valid () =
+    let user = make_user ~name:"Alice" () in
+    let cs = Changeset.create user in
+    match Changeset.apply_action cs with
+    | Ok data -> Alcotest.(check string) "returns data" "Alice" data.name
+    | Error _ -> Alcotest.fail "should not error"
+
+  let test_apply_action_invalid () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.add_error ~field:"name" ~message:"error" ~validation:"test"
+    in
+    match Changeset.apply_action cs with
+    | Ok _ -> Alcotest.fail "should error"
+    | Error errs -> Alcotest.(check int) "returns errors" 1 (List.length errs)
+
+  let test_unique_constraint () =
+    let user = make_user () in
+    let cs = Changeset.create user |> Changeset.unique_constraint email_field in
+    Alcotest.(check bool) "still valid" true (Changeset.is_valid cs)
+
+  let test_validate_confirmation () =
+    let password_field : (user, string) Field.t =
+      Field.make ~table_name:"users" ~name:"password" ~ty:Types.string
+        ~get:(fun _ -> "")
+        ~set:(fun _ u -> u)
+        ()
+    in
+    let password_confirmation_field : (user, string) Field.t =
+      Field.make ~table_name:"users" ~name:"password_confirmation"
+        ~ty:Types.string
+        ~get:(fun _ -> "")
+        ~set:(fun _ u -> u)
+        ()
+    in
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast
+           [ ("password", "secret123"); ("password_confirmation", "secret123") ]
+           ~fields:[ password_field; password_confirmation_field ]
+      |> Changeset.validate_confirmation password_field
+           ~confirmation_field:password_confirmation_field
+    in
+    Alcotest.(check bool) "passwords match" true (Changeset.is_valid cs)
+
+  let test_validate_confirmation_fails () =
+    let password_field : (user, string) Field.t =
+      Field.make ~table_name:"users" ~name:"password" ~ty:Types.string
+        ~get:(fun _ -> "")
+        ~set:(fun _ u -> u)
+        ()
+    in
+    let password_confirmation_field : (user, string) Field.t =
+      Field.make ~table_name:"users" ~name:"password_confirmation"
+        ~ty:Types.string
+        ~get:(fun _ -> "")
+        ~set:(fun _ u -> u)
+        ()
+    in
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.cast
+           [ ("password", "secret123"); ("password_confirmation", "different") ]
+           ~fields:[ password_field; password_confirmation_field ]
+      |> Changeset.validate_confirmation password_field
+           ~confirmation_field:password_confirmation_field
+    in
+    Alcotest.(check bool) "passwords don't match" false (Changeset.is_valid cs)
+
+  let tests =
+    [
+      ("create changeset", `Quick, test_create_changeset);
+      ("cast filters fields", `Quick, test_cast_filters_fields);
+      ("validate_required passes", `Quick, test_validate_required_passes);
+      ( "validate_required fails empty",
+        `Quick,
+        test_validate_required_fails_empty );
+      ( "validate_required fails missing",
+        `Quick,
+        test_validate_required_fails_missing );
+      ("validate_format passes", `Quick, test_validate_format_passes);
+      ("validate_format fails", `Quick, test_validate_format_fails);
+      ("validate_length min", `Quick, test_validate_length_min);
+      ("validate_length max", `Quick, test_validate_length_max);
+      ("validate_length exact", `Quick, test_validate_length_exact);
+      ("validate_inclusion", `Quick, test_validate_inclusion);
+      ("validate_inclusion fails", `Quick, test_validate_inclusion_fails);
+      ("validate_exclusion", `Quick, test_validate_exclusion);
+      ("validate_exclusion fails", `Quick, test_validate_exclusion_fails);
+      ("validate_number greater_than", `Quick, test_validate_number_greater_than);
+      ( "validate_number greater_than fails",
+        `Quick,
+        test_validate_number_greater_than_fails );
+      ("add_error", `Quick, test_add_error);
+      ("error_messages", `Quick, test_error_messages);
+      ("get_change", `Quick, test_get_change);
+      ("put_change", `Quick, test_put_change);
+      ("delete_change", `Quick, test_delete_change);
+      ("for_insert", `Quick, test_for_insert);
+      ("for_update", `Quick, test_for_update);
+      ("apply_action valid", `Quick, test_apply_action_valid);
+      ("apply_action invalid", `Quick, test_apply_action_invalid);
+      ("unique_constraint", `Quick, test_unique_constraint);
+      ("validate_confirmation", `Quick, test_validate_confirmation);
+      ("validate_confirmation fails", `Quick, test_validate_confirmation_fails);
+    ]
+end
+
+module Query_test = struct
+  let posts_table = Schema.table "posts"
+
+  let test_from () =
+    let q = Query.from posts_table in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "basic SELECT" true (String.sub sql 0 6 = "SELECT")
+
+  let test_select_all () =
+    let q = Query.from posts_table |> Query.select_all in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "SELECT *" true (String.length sql > 0)
+
+  let test_where () =
+    let q = Query.from posts_table |> Query.where Expr.(int 1 = int 1) in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has WHERE" true (String.length sql > 0)
+
+  let test_limit () =
+    let q = Query.from posts_table |> Query.limit 10 in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has LIMIT" true (String.length sql > 0)
+
+  let test_offset () =
+    let q = Query.from posts_table |> Query.offset 5 in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has OFFSET" true (String.length sql > 0)
+
+  let test_order_by_asc () =
+    let q = Query.from posts_table |> Query.asc (Expr.raw "title") in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has ORDER BY" true (String.length sql > 0)
+
+  let test_order_by_desc () =
+    let q = Query.from posts_table |> Query.desc (Expr.raw "created_at") in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has DESC" true (String.length sql > 0)
+
+  let test_distinct () =
+    let q = Query.from posts_table |> Query.distinct in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has DISTINCT" true (String.length sql > 0)
+
+  let test_insert_into () =
+    let q =
+      Query.insert_into posts_table
+      |> Query.values [ name_field ] [ [ Expr.string "Hello" ] ]
+    in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "INSERT INTO" true (String.sub sql 0 6 = "INSERT")
+
+  let test_update () =
+    let q =
+      Query.update posts_table |> Query.set name_field (Expr.string "Updated")
+    in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "UPDATE" true (String.sub sql 0 6 = "UPDATE")
+
+  let test_delete_from () =
+    let q = Query.delete_from posts_table in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "DELETE FROM" true (String.sub sql 0 6 = "DELETE")
+
+  let test_join () =
+    let comments_table = Schema.table "comments" in
+    let q =
+      Query.from posts_table
+      |> Query.join ~on:Expr.(int 1 = int 1) comments_table
+    in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has JOIN" true (String.length sql > 0)
+
+  let test_left_join () =
+    let comments_table = Schema.table "comments" in
+    let q =
+      Query.from posts_table
+      |> Query.left_join ~on:Expr.(int 1 = int 1) comments_table
+    in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has LEFT JOIN" true (String.length sql > 0)
+
+  let test_on_conflict_do_nothing () =
+    let q =
+      Query.insert_into posts_table
+      |> Query.values [ name_field ] [ [ Expr.string "Hello" ] ]
+      |> Query.on_conflict_do_nothing
+    in
+    let sql = Query.to_sql q in
+    Alcotest.(check bool) "has ON CONFLICT" true (String.length sql > 0)
+
+  let tests =
+    [
+      ("from", `Quick, test_from);
+      ("select_all", `Quick, test_select_all);
+      ("where", `Quick, test_where);
+      ("limit", `Quick, test_limit);
+      ("offset", `Quick, test_offset);
+      ("order_by asc", `Quick, test_order_by_asc);
+      ("order_by desc", `Quick, test_order_by_desc);
+      ("distinct", `Quick, test_distinct);
+      ("insert_into", `Quick, test_insert_into);
+      ("update", `Quick, test_update);
+      ("delete_from", `Quick, test_delete_from);
+      ("join", `Quick, test_join);
+      ("left_join", `Quick, test_left_join);
+      ("on_conflict_do_nothing", `Quick, test_on_conflict_do_nothing);
+    ]
+end
+
+module Expr_test = struct
+  let test_int_literal () =
+    let sql = Expr.to_sql (Expr.int 42) in
+    Alcotest.(check string) "int literal" "42" sql
+
+  let test_string_literal () =
+    let sql = Expr.to_sql (Expr.string "hello") in
+    Alcotest.(check string) "string literal" "'hello'" sql
+
+  let test_string_escaping () =
+    let sql = Expr.to_sql (Expr.string "it's") in
+    Alcotest.(check string) "escaped string" "'it''s'" sql
+
+  let test_bool_true () =
+    let sql = Expr.to_sql (Expr.bool true) in
+    Alcotest.(check string) "bool true" "TRUE" sql
+
+  let test_bool_false () =
+    let sql = Expr.to_sql (Expr.bool false) in
+    Alcotest.(check string) "bool false" "FALSE" sql
+
+  let test_equality () =
+    let sql = Expr.to_sql Expr.(int 1 = int 1) in
+    Alcotest.(check string) "equality" "(1 = 1)" sql
+
+  let test_inequality () =
+    let sql = Expr.to_sql Expr.(int 1 <> int 2) in
+    Alcotest.(check string) "inequality" "(1 <> 2)" sql
+
+  let test_less_than () =
+    let sql = Expr.to_sql Expr.(int 1 < int 2) in
+    Alcotest.(check string) "less than" "(1 < 2)" sql
+
+  let test_greater_than () =
+    let sql = Expr.to_sql Expr.(int 2 > int 1) in
+    Alcotest.(check string) "greater than" "(2 > 1)" sql
+
+  let test_and () =
+    let sql = Expr.to_sql Expr.(bool true && bool false) in
+    Alcotest.(check string) "AND" "(TRUE AND FALSE)" sql
+
+  let test_or () =
+    let sql = Expr.to_sql Expr.(bool true || bool false) in
+    Alcotest.(check string) "OR" "(TRUE OR FALSE)" sql
+
+  let test_not () =
+    let sql = Expr.to_sql Expr.(not_ (bool true)) in
+    Alcotest.(check string) "NOT" "(NOT TRUE)" sql
+
+  let test_addition () =
+    let sql = Expr.to_sql Expr.(int 1 + int 2) in
+    Alcotest.(check string) "addition" "(1 + 2)" sql
+
+  let test_subtraction () =
+    let sql = Expr.to_sql Expr.(int 5 - int 3) in
+    Alcotest.(check string) "subtraction" "(5 - 3)" sql
+
+  let test_multiplication () =
+    let sql = Expr.to_sql Expr.(int 2 * int 3) in
+    Alcotest.(check string) "multiplication" "(2 * 3)" sql
+
+  let test_division () =
+    let sql = Expr.to_sql Expr.(int 6 / int 2) in
+    Alcotest.(check string) "division" "(6 / 2)" sql
+
+  let test_like () =
+    let sql = Expr.to_sql (Expr.like (Expr.string "hello") "%ello") in
+    Alcotest.(check string) "LIKE" "('hello' LIKE '%ello')" sql
+
+  let test_ilike () =
+    let sql = Expr.to_sql (Expr.ilike (Expr.string "HELLO") "%ello") in
+    Alcotest.(check string) "ILIKE" "('HELLO' ILIKE '%ello')" sql
+
+  let test_is_null () =
+    let sql = Expr.to_sql (Expr.is_null (Expr.raw "column")) in
+    Alcotest.(check string) "IS NULL" "(column IS NULL)" sql
+
+  let test_is_not_null () =
+    let sql = Expr.to_sql (Expr.is_not_null (Expr.raw "column")) in
+    Alcotest.(check string) "IS NOT NULL" "(column IS NOT NULL)" sql
+
+  let test_between () =
+    let sql =
+      Expr.to_sql (Expr.between (Expr.int 5) (Expr.int 1) (Expr.int 10))
+    in
+    Alcotest.(check string) "BETWEEN" "(5 BETWEEN 1 AND 10)" sql
+
+  let test_in_list () =
+    let sql =
+      Expr.to_sql
+        (Expr.in_list (Expr.int 1) [ Expr.int 1; Expr.int 2; Expr.int 3 ])
+    in
+    Alcotest.(check string) "IN" "(1 IN (1, 2, 3))" sql
+
+  let test_count () =
+    let sql = Expr.to_sql Expr.count_all in
+    Alcotest.(check string) "COUNT(*)" "COUNT(*)" sql
+
+  let test_lower () =
+    let sql = Expr.to_sql (Expr.lower (Expr.string "HELLO")) in
+    Alcotest.(check string) "LOWER" "LOWER('HELLO')" sql
+
+  let test_upper () =
+    let sql = Expr.to_sql (Expr.upper (Expr.string "hello")) in
+    Alcotest.(check string) "UPPER" "UPPER('hello')" sql
+
+  let test_concat () =
+    let sql = Expr.to_sql (Expr.concat [ Expr.string "a"; Expr.string "b" ]) in
+    Alcotest.(check string) "CONCAT" "CONCAT('a', 'b')" sql
+
+  let test_coalesce () =
+    let sql =
+      Expr.to_sql
+        (Expr.coalesce
+           [ Expr.raw "nullable"; Expr.string "default" ]
+           Types.string)
+    in
+    Alcotest.(check string) "COALESCE" "COALESCE(nullable, 'default')" sql
+
+  let test_cast () =
+    let sql = Expr.to_sql (Expr.cast (Expr.int 42) Types.string) in
+    Alcotest.(check string) "CAST" "CAST(42 AS TEXT)" sql
+
+  let test_raw () =
+    let sql = Expr.to_sql (Expr.raw "custom_function()") in
+    Alcotest.(check string) "raw SQL" "custom_function()" sql
+
+  let tests =
+    [
+      ("int literal", `Quick, test_int_literal);
+      ("string literal", `Quick, test_string_literal);
+      ("string escaping", `Quick, test_string_escaping);
+      ("bool true", `Quick, test_bool_true);
+      ("bool false", `Quick, test_bool_false);
+      ("equality", `Quick, test_equality);
+      ("inequality", `Quick, test_inequality);
+      ("less than", `Quick, test_less_than);
+      ("greater than", `Quick, test_greater_than);
+      ("AND", `Quick, test_and);
+      ("OR", `Quick, test_or);
+      ("NOT", `Quick, test_not);
+      ("addition", `Quick, test_addition);
+      ("subtraction", `Quick, test_subtraction);
+      ("multiplication", `Quick, test_multiplication);
+      ("division", `Quick, test_division);
+      ("LIKE", `Quick, test_like);
+      ("ILIKE", `Quick, test_ilike);
+      ("IS NULL", `Quick, test_is_null);
+      ("IS NOT NULL", `Quick, test_is_not_null);
+      ("BETWEEN", `Quick, test_between);
+      ("IN list", `Quick, test_in_list);
+      ("COUNT", `Quick, test_count);
+      ("LOWER", `Quick, test_lower);
+      ("UPPER", `Quick, test_upper);
+      ("CONCAT", `Quick, test_concat);
+      ("COALESCE", `Quick, test_coalesce);
+      ("CAST", `Quick, test_cast);
+      ("raw", `Quick, test_raw);
+    ]
+end
+
+module Assoc_test = struct
+  let test_belongs_to () =
+    let assoc =
+      Assoc.belongs_to "post" ~related_table:"posts" ~foreign_key:"post_id" ()
+    in
+    Alcotest.(check string) "name" "post" (Assoc.name assoc);
+    Alcotest.(check string) "related_table" "posts" (Assoc.related_table assoc);
+    Alcotest.(check string) "foreign_key" "post_id" (Assoc.foreign_key assoc);
+    Alcotest.(check bool) "is singular" true (Assoc.is_singular assoc);
+    Alcotest.(check bool) "owner has fk" true (Assoc.owner_has_fk assoc)
+
+  let test_has_one () =
+    let assoc =
+      Assoc.has_one "profile" ~related_table:"profiles" ~foreign_key:"user_id"
+        ()
+    in
+    Alcotest.(check string) "name" "profile" (Assoc.name assoc);
+    Alcotest.(check bool) "is singular" true (Assoc.is_singular assoc);
+    Alcotest.(check bool) "owner has fk" false (Assoc.owner_has_fk assoc)
+
+  let test_has_many () =
+    let assoc =
+      Assoc.has_many "comments" ~related_table:"comments" ~foreign_key:"post_id"
+        ()
+    in
+    Alcotest.(check string) "name" "comments" (Assoc.name assoc);
+    Alcotest.(check bool) "is plural" true (Assoc.is_plural assoc);
+    Alcotest.(check bool) "is singular" false (Assoc.is_singular assoc)
+
+  let test_many_to_many () =
+    let assoc =
+      Assoc.many_to_many "tags" ~related_table:"tags" ~join_table:"post_tags"
+        ~join_keys:("post_id", "tag_id") ()
+    in
+    Alcotest.(check string) "name" "tags" (Assoc.name assoc);
+    Alcotest.(check bool) "is plural" true (Assoc.is_plural assoc)
+
+  let test_build_query_belongs_to () =
+    let assoc =
+      Assoc.belongs_to "post" ~related_table:"posts" ~foreign_key:"post_id" ()
+    in
+    let sql = Assoc.build_query assoc "42" in
+    Alcotest.(check bool) "SELECT from posts" true (String.length sql > 0)
+
+  let test_build_query_has_many () =
+    let assoc =
+      Assoc.has_many "comments" ~related_table:"comments" ~foreign_key:"post_id"
+        ()
+    in
+    let sql = Assoc.build_query assoc "42" in
+    Alcotest.(check bool) "has query" true (String.length sql > 0)
+
+  let test_build_batch_query () =
+    let assoc =
+      Assoc.has_many "comments" ~related_table:"comments" ~foreign_key:"post_id"
+        ()
+    in
+    let sql = Assoc.build_batch_query assoc [ "1"; "2"; "3" ] in
+    Alcotest.(check bool) "has IN clause" true (String.length sql > 0)
+
+  let test_many_to_many_query () =
+    let assoc =
+      Assoc.many_to_many "tags" ~related_table:"tags" ~join_table:"post_tags"
+        ~join_keys:("post_id", "tag_id") ()
+    in
+    let sql = Assoc.build_query assoc "42" in
+    Alcotest.(check bool) "has JOIN" true (String.length sql > 0)
+
+  let tests =
+    [
+      ("belongs_to", `Quick, test_belongs_to);
+      ("has_one", `Quick, test_has_one);
+      ("has_many", `Quick, test_has_many);
+      ("many_to_many", `Quick, test_many_to_many);
+      ("build_query belongs_to", `Quick, test_build_query_belongs_to);
+      ("build_query has_many", `Quick, test_build_query_has_many);
+      ("build_batch_query", `Quick, test_build_batch_query);
+      ("many_to_many query", `Quick, test_many_to_many_query);
+    ]
+end
+
+module Embedded_test = struct
+  type address = { street : string; city : string; zip : string }
+
+  let address_schema =
+    Embedded.schema ~name:"address"
+      ~decode:(fun json ->
+        match json with
+        | `Assoc fields ->
+            let get_string key =
+              match List.assoc_opt key fields with
+              | Some (`String s) -> s
+              | _ -> ""
+            in
+            Ok
+              {
+                street = get_string "street";
+                city = get_string "city";
+                zip = get_string "zip";
+              }
+        | _ -> Error "Expected object")
+      ~encode:(fun addr ->
+        `Assoc
+          [
+            ("street", `String addr.street);
+            ("city", `String addr.city);
+            ("zip", `String addr.zip);
+          ])
+      ~fields:[ "street"; "city"; "zip" ]
+      ()
+
+  let test_from_json () =
+    let json =
+      `Assoc
+        [
+          ("street", `String "123 Main St");
+          ("city", `String "Springfield");
+          ("zip", `String "12345");
+        ]
+    in
+    match Embedded.from_json address_schema json with
+    | Ok embedded ->
+        let data = Embedded.data embedded in
+        Alcotest.(check string) "street" "123 Main St" data.street;
+        Alcotest.(check string) "city" "Springfield" data.city
+    | Error msg -> Alcotest.fail msg
+
+  let test_to_json () =
+    let addr =
+      { street = "456 Oak Ave"; city = "Shelbyville"; zip = "67890" }
+    in
+    let embedded =
+      {
+        Embedded.data = addr;
+        fields = [ "street"; "city"; "zip" ];
+        source = Embedded.Virtual;
+      }
+    in
+    let json = Embedded.to_json address_schema embedded in
+    match json with
+    | `Assoc fields -> (
+        match List.assoc_opt "street" fields with
+        | Some (`String s) ->
+            Alcotest.(check string) "street in json" "456 Oak Ave" s
+        | _ -> Alcotest.fail "missing street")
+    | _ -> Alcotest.fail "expected object"
+
+  let test_from_json_string () =
+    let json_str =
+      {|{"street":"789 Elm Blvd","city":"Capital","zip":"11111"}|}
+    in
+    match Embedded.from_json_string address_schema json_str with
+    | Ok embedded ->
+        let data = Embedded.data embedded in
+        Alcotest.(check string) "parsed street" "789 Elm Blvd" data.street
+    | Error msg -> Alcotest.fail msg
+
+  let test_to_json_string () =
+    let addr = { street = "Test St"; city = "Test City"; zip = "00000" } in
+    let embedded =
+      {
+        Embedded.data = addr;
+        fields = [ "street"; "city"; "zip" ];
+        source = Embedded.Virtual;
+      }
+    in
+    let json_str = Embedded.to_json_string address_schema embedded in
+    Alcotest.(check bool) "contains street" true (String.length json_str > 0)
+
+  let test_embeds_one_from_json () =
+    let json =
+      `Assoc
+        [
+          ("street", `String "Single");
+          ("city", `String "Town");
+          ("zip", `String "1");
+        ]
+    in
+    match Embedded.embeds_one_from_json address_schema json with
+    | Ok (Some embedded) ->
+        Alcotest.(check string)
+          "embeds_one street" "Single" (Embedded.data embedded).street
+    | Ok None -> Alcotest.fail "expected Some"
+    | Error msg -> Alcotest.fail msg
+
+  let test_embeds_one_from_json_null () =
+    match Embedded.embeds_one_from_json address_schema `Null with
+    | Ok None -> Alcotest.(check pass) "null is None" () ()
+    | Ok (Some _) -> Alcotest.fail "expected None"
+    | Error msg -> Alcotest.fail msg
+
+  let test_embeds_many_from_json () =
+    let json =
+      `List
+        [
+          `Assoc
+            [
+              ("street", `String "First");
+              ("city", `String "A");
+              ("zip", `String "1");
+            ];
+          `Assoc
+            [
+              ("street", `String "Second");
+              ("city", `String "B");
+              ("zip", `String "2");
+            ];
+        ]
+    in
+    match Embedded.embeds_many_from_json address_schema json with
+    | Ok embeddeds ->
+        Alcotest.(check int) "two items" 2 (List.length embeddeds);
+        Alcotest.(check string)
+          "first street" "First" (Embedded.data (List.hd embeddeds)).street
+    | Error msg -> Alcotest.fail msg
+
+  let tests =
+    [
+      ("from_json", `Quick, test_from_json);
+      ("to_json", `Quick, test_to_json);
+      ("from_json_string", `Quick, test_from_json_string);
+      ("to_json_string", `Quick, test_to_json_string);
+      ("embeds_one from_json", `Quick, test_embeds_one_from_json);
+      ("embeds_one from_json null", `Quick, test_embeds_one_from_json_null);
+      ("embeds_many from_json", `Quick, test_embeds_many_from_json);
+    ]
+end
+
+module Repo_test = struct
+  let test_build_insert_sql () =
+    let sql = Repo.build_insert_sql users_table [ "name"; "email" ] in
+    Alcotest.(check bool) "INSERT INTO users" true (String.length sql > 0)
+
+  let test_build_insert_returning_sql () =
+    let sql = Repo.build_insert_returning_sql users_table [ "name" ] in
+    Alcotest.(check bool) "has RETURNING" true (String.length sql > 0)
+
+  let test_build_update_sql () =
+    let sql =
+      Repo.build_update_sql users_table [ "name"; "email" ] ~where_column:"id"
+    in
+    Alcotest.(check bool) "UPDATE users" true (String.length sql > 0)
+
+  let test_build_delete_sql () =
+    let sql = Repo.build_delete_sql users_table ~where_column:"id" in
+    Alcotest.(check bool) "DELETE FROM users" true (String.length sql > 0)
+
+  let test_build_select_sql () =
+    let sql =
+      Repo.build_select_sql users_table ~columns:[ "name"; "email" ]
+        ~where_column:"id"
+    in
+    Alcotest.(check bool) "SELECT columns" true (String.length sql > 0)
+
+  let test_build_select_all_sql () =
+    let sql = Repo.build_select_all_sql users_table ~columns:[] in
+    Alcotest.(check bool) "SELECT * FROM users" true (String.length sql > 0)
+
+  let test_build_preload_sql () =
+    let sql =
+      Repo.build_preload_sql ~related_table:"comments" ~fk_column:"post_id"
+        ~n_ids:3
+    in
+    Alcotest.(check bool) "has IN clause" true (String.length sql > 0)
+
+  let test_transaction_state () =
+    let state = Repo.create_tx_state () in
+    Alcotest.(check bool) "not in transaction" false (Repo.in_transaction state);
+    Alcotest.(check int) "depth 0" 0 (Repo.transaction_depth state)
+
+  let test_enter_transaction () =
+    let state = Repo.create_tx_state () in
+    let action = Repo.enter_transaction state in
+    Alcotest.(check bool) "action is Begin" true (action = Repo.Begin);
+    Alcotest.(check bool) "now in transaction" true (Repo.in_transaction state);
+    Alcotest.(check int) "depth 1" 1 (Repo.transaction_depth state)
+
+  let test_nested_transaction () =
+    let state = Repo.create_tx_state () in
+    let _ = Repo.enter_transaction state in
+    let action2 = Repo.enter_transaction state in
+    (match action2 with
+    | Repo.Savepoint name ->
+        Alcotest.(check bool) "savepoint name" true (String.length name > 0)
+    | _ -> Alcotest.fail "expected Savepoint");
+    Alcotest.(check int) "depth 2" 2 (Repo.transaction_depth state)
+
+  let test_commit_transaction () =
+    let state = Repo.create_tx_state () in
+    let _ = Repo.enter_transaction state in
+    let action = Repo.commit_transaction state in
+    Alcotest.(check bool) "action is Commit" true (action = Repo.Commit);
+    Alcotest.(check bool) "not in transaction" false (Repo.in_transaction state)
+
+  let test_rollback_transaction () =
+    let state = Repo.create_tx_state () in
+    let _ = Repo.enter_transaction state in
+    let action = Repo.rollback_transaction state in
+    Alcotest.(check bool) "action is Rollback" true (action = Repo.Rollback);
+    Alcotest.(check bool) "not in transaction" false (Repo.in_transaction state)
+
+  let test_validate_changeset () =
+    let user = make_user ~name:"Alice" () in
+    let cs = Changeset.create user in
+    match Repo.validate_changeset cs with
+    | Ok data -> Alcotest.(check string) "returns data" "Alice" data.name
+    | Error _ -> Alcotest.fail "should not error"
+
+  let test_validate_changeset_invalid () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.add_error ~field:"name" ~message:"error" ~validation:"test"
+    in
+    match Repo.validate_changeset cs with
+    | Ok _ -> Alcotest.fail "should error"
+    | Error (Error.Validation_failed _) ->
+        Alcotest.(check pass) "validation failed" () ()
+    | Error _ -> Alcotest.fail "wrong error type"
+
+  let test_parse_pg_constraint_unique () =
+    let msg =
+      {|duplicate key value violates unique constraint "users_email_key"|}
+    in
+    match Repo.parse_pg_constraint_error msg with
+    | Some (`Unique name) ->
+        Alcotest.(check string) "constraint name" "users_email_key" name
+    | _ -> Alcotest.fail "should parse unique constraint"
+
+  let test_parse_pg_constraint_foreign_key () =
+    let msg = {|violates foreign key constraint "comments_post_id_fkey"|} in
+    match Repo.parse_pg_constraint_error msg with
+    | Some (`ForeignKey name) ->
+        Alcotest.(check string) "constraint name" "comments_post_id_fkey" name
+    | _ -> Alcotest.fail "should parse foreign key constraint"
+
+  let tests =
+    [
+      ("build_insert_sql", `Quick, test_build_insert_sql);
+      ("build_insert_returning_sql", `Quick, test_build_insert_returning_sql);
+      ("build_update_sql", `Quick, test_build_update_sql);
+      ("build_delete_sql", `Quick, test_build_delete_sql);
+      ("build_select_sql", `Quick, test_build_select_sql);
+      ("build_select_all_sql", `Quick, test_build_select_all_sql);
+      ("build_preload_sql", `Quick, test_build_preload_sql);
+      ("transaction_state", `Quick, test_transaction_state);
+      ("enter_transaction", `Quick, test_enter_transaction);
+      ("nested_transaction", `Quick, test_nested_transaction);
+      ("commit_transaction", `Quick, test_commit_transaction);
+      ("rollback_transaction", `Quick, test_rollback_transaction);
+      ("validate_changeset", `Quick, test_validate_changeset);
+      ("validate_changeset invalid", `Quick, test_validate_changeset_invalid);
+      ("parse_pg_constraint unique", `Quick, test_parse_pg_constraint_unique);
+      ( "parse_pg_constraint foreign_key",
+        `Quick,
+        test_parse_pg_constraint_foreign_key );
+    ]
+end
+
+module Migration_test = struct
+  let test_create_table () =
+    let op =
+      Migration.create_table "posts"
+        [
+          Migration.column "id" "BIGINT" ~nullable:false ~primary_key:true;
+          Migration.column "title" "TEXT" ~nullable:false;
+        ]
+    in
+    let sql = Migration.operation_to_sql op in
+    Alcotest.(check bool)
+      "CREATE TABLE" true
+      (String.sub sql 0 12 = "CREATE TABLE")
+
+  let test_drop_table () =
+    let op = Migration.drop_table "posts" in
+    let sql = Migration.operation_to_sql op in
+    Alcotest.(check string) "DROP TABLE" "DROP TABLE posts" sql
+
+  let test_add_column () =
+    let change =
+      Migration.add_column (Migration.column "email" "TEXT" ~nullable:false)
+    in
+    let op = Migration.alter_table "users" [ change ] in
+    let sql = Migration.operation_to_sql op in
+    Alcotest.(check bool) "ADD COLUMN" true (String.length sql > 0)
+
+  let test_drop_column () =
+    let change = Migration.drop_column "old_column" in
+    let op = Migration.alter_table "users" [ change ] in
+    let sql = Migration.operation_to_sql op in
+    Alcotest.(check bool) "DROP COLUMN" true (String.length sql > 0)
+
+  let test_rename_column () =
+    let change = Migration.rename_column ~from:"old_name" ~to_:"new_name" in
+    let op = Migration.alter_table "users" [ change ] in
+    let sql = Migration.operation_to_sql op in
+    Alcotest.(check bool) "RENAME COLUMN" true (String.length sql > 0)
+
+  let test_create_index () =
+    let op = Migration.create_index "users" [ "email" ] ~unique:true in
+    let sql = Migration.operation_to_sql op in
+    Alcotest.(check bool) "CREATE UNIQUE INDEX" true (String.length sql > 0)
+
+  let test_drop_index () =
+    let op = Migration.drop_index "users_email_index" in
+    let sql = Migration.operation_to_sql op in
+    Alcotest.(check string) "DROP INDEX" "DROP INDEX users_email_index" sql
+
+  let test_timestamps () =
+    let cols = Migration.timestamps () in
+    Alcotest.(check int) "two timestamp columns" 2 (List.length cols)
+
+  let test_migration_definition () =
+    let m =
+      Migration.migration ~version:1L ~name:"create_users"
+        ~up:
+          [ Migration.create_table "users" [ Migration.column "id" "BIGINT" ] ]
+        ~down:[ Migration.drop_table "users" ]
+    in
+    Alcotest.(check int64) "version" 1L m.version;
+    Alcotest.(check string) "name" "create_users" m.name
+
+  let test_generate_up_sql () =
+    let m =
+      Migration.migration ~version:1L ~name:"test"
+        ~up:[ Migration.create_table "test" [ Migration.column "id" "BIGINT" ] ]
+        ~down:[]
+    in
+    let sqls = Migration.generate_up_sql m in
+    Alcotest.(check int) "one SQL statement" 1 (List.length sqls)
+
+  let test_pending_migrations () =
+    let m1 = Migration.migration ~version:1L ~name:"first" ~up:[] ~down:[] in
+    let m2 = Migration.migration ~version:2L ~name:"second" ~up:[] ~down:[] in
+    let m3 = Migration.migration ~version:3L ~name:"third" ~up:[] ~down:[] in
+    let pending =
+      Migration.pending_migrations ~applied_versions:[ 1L ] [ m1; m2; m3 ]
+    in
+    Alcotest.(check int) "two pending" 2 (List.length pending)
+
+  let test_sort_migrations () =
+    let m1 = Migration.migration ~version:3L ~name:"third" ~up:[] ~down:[] in
+    let m2 = Migration.migration ~version:1L ~name:"first" ~up:[] ~down:[] in
+    let m3 = Migration.migration ~version:2L ~name:"second" ~up:[] ~down:[] in
+    let sorted = Migration.sort_migrations [ m1; m2; m3 ] in
+    Alcotest.(check int64) "first is 1" 1L (List.hd sorted).version
+
+  let tests =
+    [
+      ("create_table", `Quick, test_create_table);
+      ("drop_table", `Quick, test_drop_table);
+      ("add_column", `Quick, test_add_column);
+      ("drop_column", `Quick, test_drop_column);
+      ("rename_column", `Quick, test_rename_column);
+      ("create_index", `Quick, test_create_index);
+      ("drop_index", `Quick, test_drop_index);
+      ("timestamps", `Quick, test_timestamps);
+      ("migration definition", `Quick, test_migration_definition);
+      ("generate_up_sql", `Quick, test_generate_up_sql);
+      ("pending_migrations", `Quick, test_pending_migrations);
+      ("sort_migrations", `Quick, test_sort_migrations);
+    ]
+end
+
+module Multi_test = struct
+  let test_empty_multi () =
+    let m = Multi.empty in
+    Alcotest.(check int)
+      "empty has no entries" 0
+      (List.length (Multi.to_list m))
+
+  let test_insert () =
+    let user = make_user ~name:"Alice" () in
+    let cs = Changeset.create user in
+    let m = Multi.empty |> Multi.insert "user" cs in
+    let names = Multi.names m in
+    Alcotest.(check bool) "has user" true (List.mem "user" names)
+
+  let test_update () =
+    let user = make_user ~name:"Bob" () in
+    let cs = Changeset.create user in
+    let m = Multi.empty |> Multi.update "user" cs in
+    Alcotest.(check int) "one entry" 1 (List.length (Multi.to_list m))
+
+  let test_delete () =
+    let m = Multi.empty |> Multi.delete "user" ~table:users_table ~id:1 in
+    Alcotest.(check int) "one entry" 1 (List.length (Multi.to_list m))
+
+  let test_merge () =
+    let user = make_user () in
+    let cs = Changeset.create user in
+    let m1 = Multi.empty |> Multi.insert "first" cs in
+    let m2 = Multi.empty |> Multi.insert "second" cs in
+    let merged = Multi.merge m1 m2 in
+    Alcotest.(check int) "two entries" 2 (List.length (Multi.to_list merged))
+
+  let test_has_name () =
+    let user = make_user () in
+    let cs = Changeset.create user in
+    let m = Multi.empty |> Multi.insert "test" cs in
+    Alcotest.(check bool) "has test" true (Multi.has_name "test" m);
+    Alcotest.(check bool) "no other" false (Multi.has_name "other" m)
+
+  let test_execute_sync_valid () =
+    let user = make_user ~name:"Test" () in
+    let cs = Changeset.create user in
+    let m = Multi.empty |> Multi.insert "user" cs in
+    match Multi.execute_sync m with
+    | Ok results -> (
+        match Multi.get results "user" with
+        | Some (data : user) ->
+            Alcotest.(check string) "got user" "Test" data.name
+        | None -> Alcotest.fail "no user result")
+    | Error err ->
+        Alcotest.fail (Printf.sprintf "error: %s" err.failed_operation)
+
+  let test_execute_sync_invalid () =
+    let user = make_user () in
+    let cs =
+      Changeset.create user
+      |> Changeset.add_error ~field:"name" ~message:"error" ~validation:"test"
+    in
+    let m = Multi.empty |> Multi.insert "user" cs in
+    match Multi.execute_sync m with
+    | Ok _ -> Alcotest.fail "should fail"
+    | Error err ->
+        Alcotest.(check string) "failed operation" "user" err.failed_operation
+
+  let test_validate_multi_duplicate_names () =
+    let user = make_user () in
+    let cs = Changeset.create user in
+    let m = Multi.empty |> Multi.insert "same" cs |> Multi.insert "same" cs in
+    match Multi.validate_multi m with
+    | Ok () -> Alcotest.fail "should fail with duplicates"
+    | Error _ -> Alcotest.(check pass) "detected duplicates" () ()
+
+  let tests =
+    [
+      ("empty multi", `Quick, test_empty_multi);
+      ("insert", `Quick, test_insert);
+      ("update", `Quick, test_update);
+      ("delete", `Quick, test_delete);
+      ("merge", `Quick, test_merge);
+      ("has_name", `Quick, test_has_name);
+      ("execute_sync valid", `Quick, test_execute_sync_valid);
+      ("execute_sync invalid", `Quick, test_execute_sync_invalid);
+      ("validate_multi duplicates", `Quick, test_validate_multi_duplicate_names);
+    ]
+end
+
+let () =
+  Alcotest.run "repodb"
+    [
+      ("Types", Types_test.tests);
+      ("Error", Error_test.tests);
+      ("Field", Field_test.tests);
+      ("Schema", Schema_test.tests);
+      ("Changeset", Changeset_test.tests);
+      ("Query", Query_test.tests);
+      ("Expr", Expr_test.tests);
+      ("Assoc", Assoc_test.tests);
+      ("Embedded", Embedded_test.tests);
+      ("Repo", Repo_test.tests);
+      ("Migration", Migration_test.tests);
+      ("Multi", Multi_test.tests);
+    ]