feat(#22): full CHECK narrowing (Tier 1 + Tier 2 + Tier 3) on analyzed-single-truth

[wokalski]

Summary

Reimplements PR #25 — the full three-tier CHECK refinement system — on top of the new analyzed-single-truth internals.

Tier	Predicate shape	Result
1	col = lit, col IN (…), col = ANY (ARRAY[…])	literal union
1	col IS NULL OR <above>	propagates allow_null
2	AND-chain of jsonb_typeof(col) = 'object', col ? 'k' / col ?& array[…], jsonb_typeof(col->'k') = '<type>', col->>'k' = 'lit', key-count idiom	open / closed object shape
3 (col)	OR over AND-chains targeting the same column	discriminated union
3 (row)	num_nonnulls(a, b, …) = 1	row variants — exactly one of the listed columns is non-null per variant
3 (row)	searched-CASE WHEN <disc>='lit' THEN <pred> [ELSE …]	row variants pinning the discriminant + the THEN refinement; ELSE false is exhaustive, true/NULL/missing widens with an Exclude<Base, "lit" | …> catch-all
bail	relational, arithmetic, regex, function calls, two-column compares, anything unfamiliar	base type — partial narrowing is worse than none

What changed

• crates/swell-analyzer/src/checks.rs — full Refinement model:
  Literal, JsonFieldType, ObjectShape, Refinement (LiteralUnion
  / Object / Union), RowVariant, RowRefinement. Reducer dispatches
  on AndExpr (clause accumulator), OrExpr (nullable-literal-set
  idiom OR discriminated-union OR nothing), atoms (AExpr / NullTest).
  Row-level parse_row_check_def recognises num_nonnulls = 1 and
  searched CASE with optional catch-all.
• crates/swell-analyzer/src/query.rs — TableSchema gains
  row_checks: Vec<TableRowCheck>. Each TableRowCheck is one CHECK
  reduced to a Vec<TableRowVariant>.
• crates/swell-analyzer/src/lib.rs::analyze — applies column-level
  refinements to each InferredColumn whose base TS render is
  narrowable (string / number / boolean / Json). Custom
  domain renderings (enums, user types), [types.by_name] overrides,
  alias-suffix overrides (AS "col!: T"), and comment hints all win
  over a CHECK refinement.
• crates/swell-analyzer/src/lib.rs::table_schemas — applies column
  refinements to row-type columns AND populates row_checks from
  checks::fetch_row_refinements.
• crates/swell-codegen/src/lib.rs::render_table_interface — when
  row_checks is non-empty, emits interface FooBase {...} plus
  type Foo = FooBase & (variant | …) & (variant | …) & …, chaining
  one intersection per CHECK so TS computes the joint constraint.
  Disconnected CHECKs collapse cleanly; contradictory branches
  collapse to never automatically. The FooBase ident is
  disambiguated against sibling table names so a literal <x>_base
  table can't silently merge via TS interface merging.

Precedence

Refinements only override types where narrowing is unambiguous
(string, number, boolean, Json). Domain renderings, enums,
[types.by_name] overrides from swell.toml, alias-suffix overrides
(AS \"col!: T\"), and --@swell.type comment hints all take
precedence over a CHECK-derived refinement.

Conflict handling

• Column-level: multiple CHECKs on the same column intersect —
  literal unions set-intersect; object shapes merge field
  requirements; truly disjoint refinements drop the whole column
  (non-deterministic narrowing via HashMap iteration order is the
  worst-of-all-worlds outcome).
• Row-level: each CHECK becomes its own (variant | …) intersection
  — TS computes the joint constraint, contradictory variants collapse
  to never.
• con.convalidated = true filter on both fetch queries — NOT VALID constraints don't actually hold against existing rows, so
  it's unsound to narrow on them.

Test plan

• 19 unit tests in checks.rs covering each shape + bail case
  (equality / IN / ANY / IS NULL OR, qualified column refs,
  cast-around-literal, Tier 2 object with required typed keys,
  Tier 3 OR-discriminated union, relational / function /
  two-column / disjoint-OR bails, intersection of two unions,
  row-level num_nonnulls = 1 + bails, row-level CASE with
  ELSE false, row-level CASE with missing ELSE that produces a
  catch-all).
• Corpus tests in billing.md against live Postgres exercising:
  - Tier 1 IN / ANY / equality / IS NULL OR
  - Tier 2 jsonb object shape (widgets.meta)
  - Tier 3 col-level OR-discriminated jsonb (payloads.payload)
  - Tier 3 row-level num_nonnulls = 1 (contacts.email/phone)
  - Tier 3 row-level CASE (field_configs.field_type/config)
  - meta -> 'width' arrow expression loses table_ref → falls
  back to plain Json
  - SELECT * against a row-variant table preserves the
  Base & (variants) intersection in the result type
• Full workspace cargo test --workspace green.

🤖 Generated with Claude Code