jade-sql 0.7.0 → 0.8.0

data/lib/jade-sql/tasks.rake

@@ -1,4 +1,5 @@
 require 'jade-sql/bin/generate_schema'
+require 'jade-sql/schema_drift'
 
 namespace :jade do
   desc "Generate schema.jd from db/structure.sql (INPUT, OUTPUT, TABLES, COLUMNS, MODULE)"
@@ -9,15 +10,47 @@ namespace :jade do
     columns     = parse_columns_env(ENV['COLUMNS'])
     module_name = ENV['MODULE'] || 'Schema'
 
-    FileUtils.mkdir_p(File.dirname(output))
-    File.write(
-      output,
-      JadeSql::SchemaGenerator.generate(
-        File.read(input), tables:, columns:, module_name:
-      ),
-    )
+    JadeSql::SchemaGenerator
+      .generate(File.read(input), tables:, columns:, module_name:)
+      .map { |name, source| write_module(output, module_name, name, source) }
+      .then { puts "wrote #{it.join(', ')}" }
+  end
+
+  # Every module the generator would write, read back if it is there. A file
+  # left behind for a module no longer generated is not found this way, which
+  # is the lesser problem: a missing one breaks the build, a stale one is dead
+  # code the compiler still reads.
+  def on_disk_modules(generated, root_module, output)
+    generated.keys.to_h do |name|
+      JadeSql::SchemaGenerator
+        .module_path(root_module, name, output)
+        .then { [name, File.exist?(it) ? File.read(it) : nil] }
+    end
+  end
+
+  def write_module(output, root_module, name, source)
+    JadeSql::SchemaGenerator
+      .module_path(root_module, name, output)
+      .tap { FileUtils.mkdir_p(File.dirname(it)) }
+      .tap { File.write(it, source) }
+  end
+
+  namespace :schema do
+    desc "Fail if schema.jd no longer matches db/structure.sql (INPUT, OUTPUT, TABLES, COLUMNS, MODULE)"
+    task :check do
+      input       = ENV['INPUT']  || 'db/structure.sql'
+      output      = ENV['OUTPUT'] || 'app/jade/schema.jd'
+      tables      = ENV['TABLES']&.split(',')&.map(&:strip)&.reject(&:empty?)
+      columns     = parse_columns_env(ENV['COLUMNS'])
+      module_name = ENV['MODULE'] || 'Schema'
+
+      abort "#{output} does not exist. Generate it with `rake jade:schema`." unless File.exist?(output)
 
-    puts "wrote #{output}"
+      JadeSql::SchemaGenerator
+        .generate(File.read(input), tables:, columns:, module_name:)
+        .then { JadeSql::SchemaDrift.between(it, on_disk_modules(it, module_name, output)) }
+        .then { it.any? ? abort(it.to_s) : puts("#{output} matches #{input}.") }
+    end
   end
 
   # COLUMNS="patients:id,age;visits:id,seen_on" — tables separated by `;`,

data/lib/jade-sql/version.rb

@@ -1,3 +1,3 @@
 module JadeSql
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/jade-sql.rb

@@ -4,6 +4,7 @@ require_relative 'jade-sql/version'
 
 Jade.extension(__FILE__)
 
+require_relative 'jade-sql/compiler'
 require_relative 'jade-sql/uuid_runtime'
 
 # Encoded `Sql.SqlError` values (the `[tag, ...args]` shape produced
@@ -12,12 +13,12 @@ require_relative 'jade-sql/uuid_runtime'
 module JadeSql
   module SqlErrors
     NOT_FOUND  = ["NotFound"].freeze
-    NOT_UNIQUE = ["NotUnique"].freeze
+    TOO_MANY_ROWS = ["TooManyRows"].freeze
 
     def self.db_error(msg)  = ["DbError", msg]
     def self.not_found      = NOT_FOUND
-    def self.not_unique     = NOT_UNIQUE
-    def self.conflict(name) = ["Conflict", name]
+    def self.too_many_rows     = TOO_MANY_ROWS
+    def self.unique_violation(name) = ["UniqueViolation", name]
   end
 end
 
@@ -26,14 +27,14 @@ module Sql
     class Error < StandardError; end
     class DbError   < Error; end
     class NotFound  < Error; end
-    class NotUnique < Error; end
-    class Conflict  < Error; end
+    class TooManyRows < Error; end
+    class UniqueViolation  < Error; end
 
     BY_TAG = {
       "DbError"   => DbError,
       "NotFound"  => NotFound,
-      "NotUnique" => NotUnique,
-      "Conflict"  => Conflict,
+      "TooManyRows" => TooManyRows,
+      "UniqueViolation"  => UniqueViolation,
     }.freeze
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-sql
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - agustin
 bindir: exe
 cert_chain: []
-date: 2026-08-14 00:00:00.000000000 Z
+date: 2026-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jade-lang
@@ -15,17 +15,17 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
-description: Query and mutation builders, schema generation from db/structure.sql,
-  and an ActiveRecord-backed runtime for the Jade language. Renders typed queries
-  to (String, List(Value)) and decodes rows into Jade structs.
+        version: 0.10.0
+description: Query and write builders, schema generation from db/structure.sql, and
+  an ActiveRecord-backed runtime for the Jade language. Renders typed queries to (String,
+  List(Value)) and decodes rows into Jade structs.
 email:
 - agustincornu@fastmail.com
 executables:
@@ -40,12 +40,20 @@ files:
 - exe/jade-sql
 - lib/jade-sql.rb
 - lib/jade-sql/bin/generate_schema.rb
+- lib/jade-sql/compiler.rb
+- lib/jade-sql/compiler/assignable.rb
+- lib/jade-sql/compiler/columns.rb
+- lib/jade-sql/compiler/errors.rb
+- lib/jade-sql/compiler/selectable.rb
 - lib/jade-sql/runtime.rb
+- lib/jade-sql/schema_drift.rb
 - lib/jade-sql/sql.jd
+- lib/jade-sql/sql/expr.jd
+- lib/jade-sql/sql/json.jd
 - lib/jade-sql/sql/loader.jd
-- lib/jade-sql/sql/mutation.jd
 - lib/jade-sql/sql/query.jd
 - lib/jade-sql/sql/uuid.jd
+- lib/jade-sql/sql/write.jd
 - lib/jade-sql/tasks.rake
 - lib/jade-sql/uuid_runtime.rb
 - lib/jade-sql/version.rb

data/lib/jade-sql/sql/mutation.jd

@@ -1,464 +0,0 @@
-module Sql.Mutation exposing (
-  Mutation,
-  delete,
-  delete_all,
-  insert,
-  insert_all,
-  returning,
-  timestamped,
-  to_sql,
-  update,
-  update_all,
-  update_many,
-)
-
-import Sql exposing (
-  Assignment(..),
-  Expr(..),
-  Renderable,
-  Selector(..),
-  Table,
-  TableRef(..),
-  pk_values,
-  set_,
-  to_assigns,
-)
-import Sql.Query exposing (Q)
-import Decode exposing (Value)
-import Encode
-
-
-type MutationKind
-  = InsertK
-  | UpdateK
-  | DeleteK
-
-
-struct Mutation(ret, c) = {
-  kind: MutationKind,
-  table: TableRef,
-  cols: c,
-  rows: List(List(Assignment)),
-  wheres: List(Expr(Bool)),
-  returning_selector: Selector(ret),
-  from_: Maybe(Expr(Bool))
-}
-
-
-def insert(value: a, t: Table(c, m)) -> Mutation(Int, c)
-  Mutation(
-    InsertK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    [to_assigns(value)],
-    [],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def insert_all(values: List(a), t: Table(c, m)) -> Mutation(Int, c)
-  Mutation(
-    InsertK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    List.map(values, (v) -> { to_assigns(v) }),
-    [],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def update(value: a, t: Table(c, m)) -> Mutation(Int, c)
-  pk_pred = pk_predicate(t.pk_columns, pk_values(value))
-
-  Mutation(
-    UpdateK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    [to_assigns(value)],
-    [pk_pred],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def delete(value: a, t: Table(c, m)) -> Mutation(Int, c)
-  pk_pred = pk_predicate(t.pk_columns, pk_values(value))
-
-  Mutation(
-    DeleteK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    [],
-    [pk_pred],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def update_all(
-  t: Table(c, m),
-  pred_fn: c -> Expr(Bool),
-  build: c -> List(Assignment),
-) -> Mutation(Int, c)
-  cols_ = t.alias_ |> t.cols
-  pred = cols_ |> pred_fn
-
-  Mutation(
-    UpdateK,
-    TableRef(t.name, t.alias_),
-    cols_,
-    [cols_ |> build],
-    [pred],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def update_many(values: List(a), t: Table(c, m)) -> Mutation(Int, c)
-  rows = List.zip(
-    values |> List.map((v) -> { pk_values(v) }),
-    values |> List.map((v) -> { to_assigns(v) }),
-  )
-    |> List.map((p) -> { RowUpdate(Tuple.first(p), Tuple.second(p)) })
-
-  Mutation(
-    UpdateK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    [source_assigns(rows)],
-    [pk_join(t.pk_columns)],
-    Selector([], []),
-    Just(source_of(t.name, t.pk_columns, rows)),
-  )
-end
-
-
-struct RowUpdate = {
-  keys: List(Value),
-  assigns: List(Assignment)
-}
-
-
-# One JSON parameter carries every row, so the statement is the same size
-# for two rows or two hundred. json_populate_recordset gives the record
-# the table's own column types, which is what makes a bare `?` legal in a
-# position Postgres cannot otherwise infer.
-def source_of(
-  name: String,
-  pk_columns: List(String),
-  rows: List(RowUpdate),
-) -> Expr(Bool)
-  Expr(
-    "json_populate_recordset(null::" ++ name ++ ", ?::json) AS jade_src",
-    [Encode.string(Encode.encode_to_string(json_rows(pk_columns, rows)))],
-  )
-end
-
-
-def json_rows(pk_columns: List(String), rows: List(RowUpdate)) -> Value
-  Encode.list(json_row(pk_columns, _), rows)
-end
-
-
-def json_row(pk_columns: List(String), r: RowUpdate) -> Value
-  Encode.object(
-    List.zip(pk_columns, r.keys)
-      ++ (r.assigns |> List.map((a) -> { Tuple.Tuple2(a.col, first_param(a)) })),
-  )
-end
-
-
-def first_param(a: Assignment) -> Value
-  a.params |> List.head |> Maybe.with_default(Encode.null)
-end
-
-
-def source_assigns(rows: List(RowUpdate)) -> List(Assignment)
-  rows
-    |> touched_cols
-    |> List.map((col) -> { Assignment(col, "jade_src." ++ col, []) })
-end
-
-
-def touched_cols(rows: List(RowUpdate)) -> List(String)
-  rows
-    |> List.and_then(.assigns)
-    |> List.map(.col)
-    |> List.fold([], (seen, c) -> { List.member?(seen, c) ? seen : seen ++ [c] })
-end
-
-
-def pk_join(pk_columns: List(String)) -> Expr(Bool)
-  Expr(
-    pk_columns
-      |> List.map((col) -> { "jade_tgt." ++ col ++ " = jade_src." ++ col })
-      |> String.join(" AND "),
-    [],
-  )
-end
-
-
-def delete_all(t: Table(c, m), pred_fn: c -> Expr(Bool)) -> Mutation(Int, c)
-  cols_ = t.alias_ |> t.cols
-  pred = cols_ |> pred_fn
-
-  Mutation(
-    DeleteK,
-    TableRef(t.name, t.alias_),
-    cols_,
-    [],
-    [pred],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def returning(m: Mutation(a, c), build: c -> Q(Selector(b))) -> Mutation(b, c)
-  Mutation(
-    m.kind,
-    m.table,
-    m.cols,
-    m.rows,
-    m.wheres,
-    build(m.cols).result,
-    m.from_,
-  )
-end
-
-
-# Opt-in ActiveRecord-style timestamps: fills created_at + updated_at on
-# insert and updated_at on update, with the app clock at execute time.
-# The "$JADE_SQL_NOW$" token carries no param; the runtime swaps it for a
-# single UTC timestamp literal per statement (so created_at == updated_at).
-# A plain `insert`/`update` without this stays timestamp-free.
-def timestamped(m: Mutation(ret, c)) -> Mutation(ret, c)
-  case m.kind
-  in InsertK then with_rows(m, List.map(m.rows, append_insert_stamps))
-  in UpdateK then with_rows(m, List.map(m.rows, append_update_stamps))
-  in DeleteK then m
-  end
-end
-
-
-def append_insert_stamps(row: List(Assignment)) -> List(Assignment)
-  row ++ [now_assignment("created_at"), now_assignment("updated_at")]
-end
-
-
-def append_update_stamps(row: List(Assignment)) -> List(Assignment)
-  row ++ [now_assignment("updated_at")]
-end
-
-
-def now_assignment(col: String) -> Assignment
-  Assignment(col, "$JADE_SQL_NOW$", [])
-end
-
-
-def with_rows(m: Mutation(ret, c), rows: List(List(Assignment))) -> Mutation(ret, c)
-  { m | rows: rows }
-end
-
-
-def pk_predicate(cols: List(String), values: List(Value)) -> Expr(Bool)
-  sql = cols
-    |> List.map((col) -> { col ++ " = ?" })
-    |> String.join(" AND ")
-
-  Expr(sql, values)
-end
-
-
-def render_row(row: List(Assignment)) -> String
-  cols_part = row
-    |> List.map((a) -> { a.value_sql })
-    |> String.join(", ")
-
-  "(" ++ cols_part ++ ")"
-end
-
-
-def returning_clause(s: Selector(ret)) -> String
-  List.empty?(s.columns_sql) ? "" : " RETURNING " ++ String.join(s.columns_sql, ", ")
-end
-
-
-def insert_cols_str(rows: List(List(Assignment))) -> String
-  case rows
-  in [] then ""
-  in [first | _]
-    "(" ++ String.join(List.map(first, (a) -> { a.col }), ", ") ++ ")"
-  end
-end
-
-
-def insert_params(rows: List(List(Assignment))) -> List(Value)
-  List.fold(
-    rows,
-    [],
-    (acc, row) -> { acc ++ List.fold(row, [], (acc2, a) -> { acc2 ++ a.params }) },
-  )
-end
-
-
-def set_sqls_for(rows: List(List(Assignment))) -> List(String)
-  case rows
-  in [first | _] then List.map(first, (a) -> { a.col ++ " = " ++ a.value_sql })
-  in [] then []
-  end
-end
-
-
-def set_params_for(rows: List(List(Assignment))) -> List(Value)
-  case rows
-  in [first | _] then List.fold(first, [], (acc, a) -> { acc ++ a.params })
-  in [] then []
-  end
-end
-
-
-# A FROM'd UPDATE needs the target aliased: json_populate_recordset gives
-# the source every column the table has, so a bare `id = jade_src.id` is
-# ambiguous.
-def target_ref(m: Mutation(ret, c)) -> String
-  case m.from_
-  in Nothing then m.table.name
-  in Just(_) then m.table.name ++ " AS jade_tgt"
-  end
-end
-
-
-def from_clause(from_: Maybe(Expr(Bool))) -> String
-  case from_
-  in Nothing then ""
-  in Just(e) then " FROM " ++ e.sql
-  end
-end
-
-
-def from_params(from_: Maybe(Expr(Bool))) -> List(Value)
-  case from_
-  in Nothing then []
-  in Just(e) then e.params
-  end
-end
-
-
-def where_sql(wheres: List(Expr(Bool))) -> String
-  List.empty?(wheres)
-    ? ""
-    : " WHERE " ++ String.join(List.map(wheres, (w) -> { w.sql }), " AND ")
-end
-
-
-def where_params(wheres: List(Expr(Bool))) -> List(Value)
-  List.fold(wheres, [], (acc, w) -> { acc ++ w.params })
-end
-
-
-def strip_table_alias(sql: String, alias_: String) -> String
-  String.replace(sql, alias_ ++ ".", "")
-end
-
-
-def render_insert(m: Mutation(ret, c)) -> (String, List(Value))
-  cols_str = insert_cols_str(m.rows)
-  values_str = m.rows
-    |> List.map(render_row)
-    |> String.join(", ")
-  returning_ = strip_table_alias(returning_clause(m.returning_selector), m.table.alias_)
-  sql = "INSERT INTO "
-    ++ m.table.name
-    ++ " "
-    ++ cols_str
-    ++ " VALUES "
-    ++ values_str
-    ++ returning_
-
-  Tuple.Tuple2(sql, insert_params(m.rows) ++ m.returning_selector.params)
-end
-
-
-def render_update(m: Mutation(ret, c)) -> (String, List(Value))
-  sets = set_sqls_for(m.rows)
-
-  List.empty?(sets) ? render_no_op_update(m) : render_update_set(m, sets)
-end
-
-
-def render_no_op_update(m: Mutation(ret, c)) -> (String, List(Value))
-  where = strip_table_alias(where_sql(m.wheres), m.table.alias_)
-  cols = List.empty?(m.returning_selector.columns_sql)
-    ? "1"
-    : strip_table_alias(
-        String.join(m.returning_selector.columns_sql, ", "),
-        m.table.alias_,
-      )
-  sql = "SELECT " ++ cols ++ " FROM " ++ m.table.name ++ where
-
-  Tuple.Tuple2(sql, m.returning_selector.params ++ where_params(m.wheres))
-end
-
-
-def render_update_set(
-  m: Mutation(ret, c),
-  sets: List(String),
-) -> (String, List(Value))
-  set_clause = strip_table_alias(
-    "SET " ++ String.join(sets, ", "),
-    m.table.alias_,
-  )
-  where = strip_table_alias(where_sql(m.wheres), m.table.alias_)
-  returning_ = strip_table_alias(returning_clause(m.returning_selector), m.table.alias_)
-  sql = "UPDATE "
-    ++ target_ref(m)
-    ++ " "
-    ++ set_clause
-    ++ from_clause(m.from_)
-    ++ where
-    ++ returning_
-
-  Tuple.Tuple2(
-    sql,
-    set_params_for(m.rows)
-      ++ from_params(m.from_)
-      ++ where_params(m.wheres)
-      ++ m.returning_selector.params,
-  )
-end
-
-
-
-
-def render_delete(m: Mutation(ret, c)) -> (String, List(Value))
-  where = strip_table_alias(where_sql(m.wheres), m.table.alias_)
-  returning_ = strip_table_alias(returning_clause(m.returning_selector), m.table.alias_)
-  sql = "DELETE FROM "
-    ++ m.table.name
-    ++ where
-    ++ returning_
-
-  Tuple.Tuple2(sql, where_params(m.wheres) ++ m.returning_selector.params)
-end
-
-
-def to_sql(m: Mutation(ret, c)) -> (String, List(Value))
-  case m.kind
-  in InsertK then render_insert(m)
-  in UpdateK then render_update(m)
-  in DeleteK then render_delete(m)
-  end
-end
-
-
-implements Renderable(Mutation(ret, c)) with
-  render: to_sql
-end