jade-sql 0.7.0 → 0.9.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.9.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
@@ -11,29 +12,92 @@ require_relative 'jade-sql/uuid_runtime'
 # across the port boundary, and by anyone stubbing the ports in tests.
 module JadeSql
   module SqlErrors
-    NOT_FOUND  = ["NotFound"].freeze
-    NOT_UNIQUE = ["NotUnique"].freeze
+    NOT_FOUND = ["NotFound"].freeze
+    TOO_MANY_ROWS = ["TooManyRows"].freeze
+    DEADLOCK = ["Deadlock"].freeze
+    SERIALIZATION_FAILURE = ["SerializationFailure"].freeze
+    STATEMENT_TIMEOUT = ["StatementTimeout"].freeze
+    LOCK_TIMEOUT = ["LockTimeout"].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.db_error(msg)
+      ["DbError", msg]
+    end
+
+    def self.not_found
+      NOT_FOUND
+    end
+
+    def self.too_many_rows
+      TOO_MANY_ROWS
+    end
+
+    def self.unique_violation(name)
+      ["UniqueViolation", name]
+    end
+
+    def self.foreign_key_violation(name)
+      ["ForeignKeyViolation", name]
+    end
+
+    def self.check_violation(name)
+      ["CheckViolation", name]
+    end
+
+    def self.exclusion_violation(name)
+      ["ExclusionViolation", name]
+    end
+
+    def self.not_null_violation(column)
+      ["NotNullViolation", column]
+    end
+
+    def self.deadlock
+      DEADLOCK
+    end
+
+    def self.serialization_failure
+      SERIALIZATION_FAILURE
+    end
+
+    def self.statement_timeout
+      STATEMENT_TIMEOUT
+    end
+
+    def self.lock_timeout
+      LOCK_TIMEOUT
+    end
   end
 end
 
 module Sql
   module Errors
     class Error < StandardError; end
-    class DbError   < Error; end
-    class NotFound  < Error; end
-    class NotUnique < Error; end
-    class Conflict  < Error; end
+    class DbError < Error; end
+    class NotFound < Error; end
+    class TooManyRows < Error; end
+    class UniqueViolation < Error; end
+    class ForeignKeyViolation < Error; end
+    class CheckViolation < Error; end
+    class ExclusionViolation < Error; end
+    class NotNullViolation < Error; end
+    class Deadlock < Error; end
+    class SerializationFailure < Error; end
+    class StatementTimeout < Error; end
+    class LockTimeout < Error; end
 
     BY_TAG = {
-      "DbError"   => DbError,
-      "NotFound"  => NotFound,
-      "NotUnique" => NotUnique,
-      "Conflict"  => Conflict,
+      "DbError" => DbError,
+      "NotFound" => NotFound,
+      "TooManyRows" => TooManyRows,
+      "UniqueViolation" => UniqueViolation,
+      "ForeignKeyViolation" => ForeignKeyViolation,
+      "CheckViolation" => CheckViolation,
+      "ExclusionViolation" => ExclusionViolation,
+      "NotNullViolation" => NotNullViolation,
+      "Deadlock" => Deadlock,
+      "SerializationFailure" => SerializationFailure,
+      "StatementTimeout" => StatementTimeout,
+      "LockTimeout" => LockTimeout,
     }.freeze
   end
 
@@ -42,4 +106,18 @@ module Sql
     klass = Errors::BY_TAG.fetch(type, Errors::Error)
     raise klass, message
   end
+
+  # The boundary hands back `["ok", value]` or `["err", encoded]`, and the
+  # generated `fn!` raises `Jade::Interop::TaskError` for every failure alike.
+  # A controller cannot route that: `rescue_from Sql::Errors::NotFound` needs
+  # the variant. This raises the variant instead, so one `rescue_from` turns a
+  # missing row into a 404 the way `ActiveRecord::RecordNotFound` does.
+  #
+  #   patient = Sql.unwrap!(App.find(id))
+  def self.unwrap!(result)
+    case result
+    in ["ok", value] then value
+    in ["err", encoded] then raise_typed!(encoded)
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-sql
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - agustin
 bindir: exe
 cert_chain: []
-date: 2026-08-14 00:00:00.000000000 Z
+date: 2026-09-17 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.12.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.12.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,19 @@ 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/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