jade-sql 0.7.0 → 0.9.0

data/lib/jade-sql/compiler/assignable.rb

@@ -0,0 +1,146 @@
+module JadeSql
+  module Compiler
+    module Assignable
+      extend self
+      include Helpers
+
+      INTERFACE = 'Sql.Assignable'
+      ASSIGNMENT = 'Sql.Assignment'
+      ASSIGNMENT_FIELDS = %w[col value_sql params].freeze
+
+      def supports?(interface) = interface == INTERFACE
+
+      def derive(constraint, registry, entry_name, &lookup)
+        return failed(constraint, entry_name) unless assignment_matches?(registry)
+
+        case constraint.type
+        in Type::Application(constructor: Type::Constructor(name:), args:)
+          Symbol
+            .type_ref_from_qualified_name(name)
+            .then { registry.lookup(it) }
+            .then { derive_for(constraint, it, args, registry, lookup, entry_name) }
+
+        else
+          failed(constraint, entry_name)
+        end
+      end
+
+      private
+
+      # The interface is matched by name, so some other module called `Sql`
+      # would otherwise be derived against as though it were jade-sql.
+      def assignment_matches?(registry)
+        Symbol
+          .type_ref_from_qualified_name(ASSIGNMENT)
+          .then { registry.lookup(it) }
+          .then do
+            it in Symbol::Struct(record_type: { fields: }) and
+              fields.keys.map(&:to_s) == ASSIGNMENT_FIELDS
+          end
+      end
+
+      def derive_for(constraint, symbol, args, registry, lookup, entry_name)
+        case symbol
+        in Symbol::Union if args.empty? && single_payload?(symbol, registry)
+          derive_union(constraint, symbol, registry, lookup, entry_name)
+
+        in Symbol::Struct
+          derive_struct(constraint, symbol, args, registry, lookup, entry_name)
+
+        else
+          failed(constraint, entry_name)
+        end
+      end
+
+      # One column per variant, so each variant carries exactly the value
+      # that column is set to.
+      def single_payload?(union_sym, registry)
+        variants(union_sym, registry)
+          .then { it.any? && it.all? { it.args.size == 1 } }
+      end
+
+      def derive_union(constraint, union_sym, registry, lookup, entry_name)
+        vs = variants(union_sym, registry)
+
+        vs
+          .map { encodable_dep(it, registry) }
+          .map { lookup.call(it) }
+          .then { Results.sequence(it) }
+          .map { assignable(constraint, union_body(vs), it) }
+      end
+
+      def derive_struct(constraint, struct_sym, args, registry, lookup, entry_name)
+        fields = struct_fields(struct_sym, args, registry)
+
+        fields
+          .map { |_, type| Type.constraint('Encode.Encodable', type, nil) }
+          .map { lookup.call(it) }
+          .then { Results.sequence(it) }
+          .map { assignable(constraint, struct_body(fields), it) }
+      end
+
+      def struct_body(fields)
+        fields
+          .each_with_index
+          .map { |(name, _), idx| field_assignment(name, idx) }
+          .then { [:list, it] }
+      end
+
+      def field_assignment(name, idx)
+        [:call,
+          [:struct_constructor, ASSIGNMENT, 3],
+          [
+            Compiler.column_name(name),
+            '?',
+            [:list,
+              [[:call, [:impl_arg, idx, 'encoder'], [[:access, [:var, 'f'], name.to_s]]]],
+            ],
+          ],
+        ]
+      end
+
+      def encodable_dep(variant, registry)
+        variant
+          .args
+          .first
+          .then { instantiate(it, {}, registry) }
+          .then { Type.constraint('Encode.Encodable', it, nil) }
+      end
+
+      def union_body(variants)
+        variants
+          .each_with_index
+          .map { |v, idx| [[:constructor, v.qualified_name, ['x']], [assignment(v, idx)]] }
+          .then { [:case, [:var, 'f'], it] }
+      end
+
+      def assignment(variant, idx)
+        [:call,
+          [:struct_constructor, ASSIGNMENT, 3],
+          [
+            wire_name(variant),
+            '?',
+            [:list, [[:call, [:impl_arg, idx, 'encoder'], [[:var, 'x']]]]],
+          ],
+        ]
+          .then { [:list, [it]] }
+      end
+
+      def failed(constraint, entry_name)
+        Err[
+          DerivationFailed.new(
+            entry_name, constraint.origin&.range, constraint:, trace: [],
+          )
+        ]
+      end
+
+      def assignable(constraint, body, deps)
+        implementation(
+          constraint,
+          { 'to_assigns' => Symbol::DerivedFunction.new(params: ['f'], body:) },
+          deps:,
+        )
+      end
+    end
+  end
+end

data/lib/jade-sql/compiler/columns.rb

@@ -0,0 +1,220 @@
+module JadeSql
+  module Compiler
+    # A struct's fields map onto a table's columns by name, and the mapping
+    # derives, so nothing else ever compares the two — a field the table has
+    # no column for reaches Postgres as invalid SQL. Both types are concrete
+    # at the call site, which is why this is a check and not a constraint.
+    module Columns
+      extend self
+      include Helpers
+
+      TABLE = 'Sql.Table'
+      EXPR = 'Sql.Expr'
+      LIST = 'List.List'
+      TUPLE2 = 'Tuple.Tuple2'
+      ASSIGNABLE = 'Sql.Assignable'
+      STAMPED = 'Sql.Write.Stamped'
+      STAMPS = %w[created_at updated_at].freeze
+
+      # Where the written value is, where the table is, what the value arrives
+      # wrapped in, and whether the row is being created — only then does a
+      # column the database cannot fill have to be written.
+      #
+      # Every write taking a struct of the caller's is here. `update_all` and
+      # `delete_all` are not, because they build their SET and WHERE from the
+      # table's own `c` and `s` — there is no struct to compare.
+      Target = Data.define(:value_at, :table_at, :wrapper, :creates)
+
+      TARGETS = {
+        'Sql.Write.insert' => Target[0, 1, :bare, true],
+        'Sql.Write.insert_all' => Target[0, 1, :list, true],
+        'Sql.Write.update' => Target[0, 1, :bare, false],
+        'Sql.Write.update_many' => Target[0, 1, :keyed_list, false],
+      }.freeze
+
+      def watches = TARGETS.keys
+
+      def check(ctx)
+        TARGETS.fetch(ctx.name).then do |target|
+          table = ctx.arg_types[target.table_at]
+          value, stamps = unstamp(unwrap(ctx.arg_types[target.value_at], target.wrapper))
+
+          next [] if written?(value, ctx.registry)
+
+          compare(value, cols_of(table), ctx) +
+            (target.creates ? missing(value, stamps, table, ctx) : [])
+        end
+      end
+
+      private
+
+      # A field maps to the column of the same name only because the deriver
+      # says so. An author who wrote `to_assigns` by hand has already said
+      # what the columns are — one field may become two, or none — so there
+      # is nothing here to compare against.
+      def written?(value, registry)
+        case implementation(value, registry)
+        in Symbol::Implementation(module_name: String) then true
+        else false
+        end
+      end
+
+      def implementation(value, registry)
+        case value
+        in Type::Application(constructor: Type::Constructor(name:))
+          registry.implementations[[ASSIGNABLE, name]]
+
+        else nil
+        end
+      end
+
+      # `r` names the columns the database will not fill in, so a value that
+      # writes none of them produces a row Postgres rejects. `timestamped` writes
+      # two of them without them being fields, which is why it is carried
+      # alongside the value's own.
+      def missing(value, stamps, table, ctx)
+        case [fields_of(value, ctx.registry), columns_of(required_of(table), ctx.registry)]
+        in [Array => fields, Hash => required]
+          required.keys - fields.map { Compiler.column_name(it.first) } - stamps
+
+        else []
+        end
+          .then do |absent|
+            next [] if absent.empty?
+
+            [Errors::MissingColumns.new(
+              ctx.entry_name, ctx.span,
+              struct: name_of(value), table: name_of(cols_of(table)), missing: absent,
+            )]
+          end
+      end
+
+      # `Table(c, m, k, o, r, s)` — the required columns are its fifth
+      # argument. Matched by position rather than "the last one", so appending
+      # a parameter cannot silently point this at something else.
+      def required_of(table)
+        case table
+        in Type::Application(
+          constructor: Type::Constructor(name: TABLE), args: [_, _, _, _, required, _]
+        )
+          required
+
+        else nil
+        end
+      end
+
+      # `timestamped` writes `created_at` and `updated_at` on a value that has no
+      # such fields, so it answers for them without appearing among them.
+      def unstamp(value)
+        case value
+        in Type::Application(constructor: Type::Constructor(name: STAMPED), args: [inner])
+          [inner, STAMPS]
+
+        else [value, []]
+        end
+      end
+
+      # Either side may be absent — an argument the caller left off, a table
+      # still polymorphic in its columns — and then there is nothing to compare.
+      def compare(value, cols, ctx)
+        case [fields_of(value, ctx.registry), columns_of(cols, ctx.registry)]
+        in [Array => fields, Hash => columns]
+          fields.filter_map { mismatch(it, columns, value, cols, ctx) }
+
+        else []
+        end
+      end
+
+      def mismatch((name, type), columns, value, cols, ctx)
+        column = Compiler.column_name(name)
+
+        case columns[column]
+        in nil
+          Errors::UnknownColumn.new(
+            ctx.entry_name, ctx.span,
+            struct: name_of(value), field: name, table: name_of(cols),
+            columns: columns.keys,
+          )
+
+        in ^type
+          nil
+
+        in found
+          Errors::ColumnTypeMismatch.new(
+            ctx.entry_name, ctx.span,
+            struct: name_of(value), field: name, table: name_of(cols),
+            column:, expected: found, actual: type,
+          )
+        end
+      end
+
+      # `Table(c, m, k, ...)` — the columns are its first argument.
+      def cols_of(table)
+        case table
+        in Type::Application(constructor: Type::Constructor(name: TABLE), args: [cols, *])
+          cols
+
+        else nil
+        end
+      end
+
+      # Each column is an `Expr(t)` whose `t` is what the field has to be.
+      def columns_of(cols, registry)
+        fields_of(cols, registry)
+          &.to_h { |field, type| [Compiler.column_name(field), unwrap_expr(type)] }
+      end
+
+      def fields_of(type, registry)
+        case type
+        in Type::Application(constructor: Type::Constructor(name:), args:)
+          Symbol
+            .type_ref_from_qualified_name(name)
+            .then { registry.lookup(it) }
+            .then { (it in Symbol::Struct) ? struct_fields(it, args, registry) : nil }
+
+        else nil
+        end
+      end
+
+      def unwrap(type, wrapper)
+        case [wrapper, type]
+        in [:list, Type::Application(constructor: Type::Constructor(name: LIST), args: [inner])]
+          inner
+
+        # `update_many` takes the key alongside the value, so the struct is the
+        # second half of each pair rather than the element itself.
+        in [
+          :keyed_list,
+          Type::Application(
+            constructor: Type::Constructor(name: LIST),
+            args: [Type::Application(
+              constructor: Type::Constructor(name: TUPLE2), args: [_, inner]
+            )],
+          )
+        ]
+          inner
+
+        else type
+        end
+      end
+
+      def unwrap_expr(type)
+        case type
+        in Type::Application(constructor: Type::Constructor(name: EXPR), args: [inner])
+          inner
+
+        else type
+        end
+      end
+
+      def name_of(type)
+        case type
+        in Type::Application(constructor: Type::Constructor(name:), args: _)
+          name.split('.').last
+
+        else type.to_s
+        end
+      end
+    end
+  end
+end

data/lib/jade-sql/compiler/errors.rb

@@ -0,0 +1,82 @@
+module JadeSql
+  module Compiler
+    module Errors
+      class UnknownColumn < Jade::Error
+        def initialize(entry, span, struct:, field:, table:, columns:)
+          @struct = struct
+          @field = field
+          @table = table
+          @columns = columns
+          super(entry:, span:)
+        end
+
+        def message
+          "#{@struct}.#{@field} has no column on #{@table}"
+        end
+
+        def label
+          "no column `#{@field}`"
+        end
+
+        def queried_name = @field.to_s
+
+        def candidates = @columns
+      end
+
+      class MissingColumns < Jade::Error
+        STAMPS = %w[created_at updated_at].freeze
+
+        def initialize(entry, span, struct:, table:, missing:)
+          @struct = struct
+          @table = table
+          @missing = missing
+          super(entry:, span:)
+        end
+
+        def message
+          "#{@struct} does not write #{list(@missing)}, " \
+            "which #{@table} requires"
+        end
+
+        def label
+          "missing #{list(@missing)}"
+        end
+
+        def notes
+          return [] unless (@missing - STAMPS).empty?
+
+          [Jade::Diagnostics::Annotation[:help, 'pipe the value through `timestamped`']]
+        end
+
+        private
+
+        def list(names)
+          names.map { "`#{it}`" }.then do |quoted|
+            quoted.length == 1 ? quoted.first : "#{quoted[..-2].join(', ')} and #{quoted.last}"
+          end
+        end
+      end
+
+      class ColumnTypeMismatch < Jade::Error
+        def initialize(entry, span, struct:, field:, table:, column:, expected:, actual:)
+          @struct = struct
+          @field = field
+          @table = table
+          @column = column
+          @expected = expected
+          @actual = actual
+          super(entry:, span:)
+        end
+
+        def message
+          "#{@table}.#{@column} is #{@expected}, " \
+            "but #{@struct}.#{@field} is #{@actual}"
+        end
+
+        def label
+          "column is #{@expected}, field is #{@actual}"
+        end
+      end
+    end
+  end
+end

data/lib/jade-sql/compiler.rb

@@ -0,0 +1,32 @@
+require 'jade'
+
+module JadeSql
+  # jade-sql's half of the compiler: an interface it derives and a check it
+  # runs, both registered through `Jade::Extensions`.
+  module Compiler
+    Type = Jade::Type
+    Symbol = Jade::Symbol
+    Results = Jade::Results
+    Ok = Jade::Ok
+    Err = Jade::Err
+    Lexer = Jade::Lexer
+    Helpers = Jade::Frontend::TypeChecking::Constraints::Deriving::Helpers
+    DerivationFailed = Jade::Frontend::TypeChecking::Error::DerivationFailed
+
+    # The generator renames a column that collides with a jade keyword, so
+    # `type_` maps back to the `type` it came from.
+    def self.column_name(field)
+      field
+        .to_s
+        .then { it.end_with?('_') ? it.delete_suffix('_') : it }
+        .then { Lexer::KEYWORDS.include?(it) ? it : field.to_s }
+    end
+  end
+end
+
+require_relative 'compiler/errors'
+require_relative 'compiler/assignable'
+require_relative 'compiler/columns'
+
+Jade::Extensions.register_deriver('jade-sql', JadeSql::Compiler::Assignable)
+Jade::Extensions.register_check('jade-sql', :call, JadeSql::Compiler::Columns)

data/lib/jade-sql/runtime.rb

@@ -11,59 +11,57 @@ module JadeSql
 
     task :port_execute_count do |t, sql, params|
       conn = ::ActiveRecord::Base.connection
-      t.ok(conn.exec_update(adapt_sql(fill_now(sql), conn), "Jade", typed_params(params, conn)))
-    rescue ::ActiveRecord::RecordNotUnique => e
-      t.err(JadeSql::SqlErrors.conflict(constraint_name(e)))
+      t.ok(conn.exec_update(statement(sql, params, conn), "Jade", typed_params(params, conn)))
     rescue ::ActiveRecord::StatementInvalid => e
-      t.err(JadeSql::SqlErrors.db_error(e.message))
+      t.err(translate(e))
     end
 
     task :port_execute_one do |t, sql, params|
       conn = ::ActiveRecord::Base.connection
-      rows = conn.exec_query(adapt_sql(fill_now(sql), conn), "Jade", typed_params(params, conn)).to_a
+      rows = conn.exec_query(statement(sql, params, conn), "Jade", typed_params(params, conn)).to_a
       case rows.length
       when 0 then t.err(JadeSql::SqlErrors.not_found)
       when 1 then t.ok(coerce_row(rows.first))
-      else        t.err(JadeSql::SqlErrors.not_unique)
+      else        t.err(JadeSql::SqlErrors.too_many_rows)
       end
-    rescue ::ActiveRecord::RecordNotUnique => e
-      t.err(JadeSql::SqlErrors.conflict(constraint_name(e)))
     rescue ::ActiveRecord::StatementInvalid => e
-      t.err(JadeSql::SqlErrors.db_error(e.message))
+      t.err(translate(e))
     end
 
     task :port_execute_many do |t, sql, params|
       conn = ::ActiveRecord::Base.connection
-      rows = conn.exec_query(adapt_sql(fill_now(sql), conn), "Jade", typed_params(params, conn)).to_a
+      rows = conn.exec_query(statement(sql, params, conn), "Jade", typed_params(params, conn)).to_a
       t.ok(rows.map { |row| coerce_row(row) })
-    rescue ::ActiveRecord::RecordNotUnique => e
-      t.err(JadeSql::SqlErrors.conflict(constraint_name(e)))
     rescue ::ActiveRecord::StatementInvalid => e
-      t.err(JadeSql::SqlErrors.db_error(e.message))
+      t.err(translate(e))
     end
 
     # Transaction control on the shared connection. The execute/fetch ports
     # above use the same `ActiveRecord::Base.connection`, so anything they
     # run between begin and commit/rollback is part of this transaction.
-    # These bypass AR's transaction manager (no savepoints), so they don't
-    # nest — see `Sql.transaction`. Rollback is best-effort: it swallows
-    # adapter errors so the original failure is the one that propagates.
+    #
+    # Not the raw `begin_db_transaction` family: those only emit SQL, so a
+    # second BEGIN is a warning and its COMMIT ends whichever transaction was
+    # already running. The manager issues a SAVEPOINT instead.
+    #
+    # Rollback is best-effort: it swallows adapter errors so the original
+    # failure is the one that propagates.
     task :port_begin do |t|
-      ::ActiveRecord::Base.connection.begin_db_transaction
+      ::ActiveRecord::Base.connection.begin_transaction(joinable: false)
       t.ok(true)
     rescue ::ActiveRecord::StatementInvalid => e
       t.err(JadeSql::SqlErrors.db_error(e.message))
     end
 
     task :port_commit do |t|
-      ::ActiveRecord::Base.connection.commit_db_transaction
+      ::ActiveRecord::Base.connection.commit_transaction
       t.ok(true)
     rescue ::ActiveRecord::StatementInvalid => e
       t.err(JadeSql::SqlErrors.db_error(e.message))
     end
 
     task :port_rollback do |t|
-      ::ActiveRecord::Base.connection.rollback_db_transaction
+      ::ActiveRecord::Base.connection.rollback_transaction
       t.ok(true)
     rescue ::ActiveRecord::StatementInvalid
       t.ok(true)
@@ -173,9 +171,36 @@ module JadeSql
       raw == "NULL" ? nil : raw
     end
 
-    # The constraint/index name behind a RecordNotUnique, so callers can route
-    # by which unique index was violated. PG reports it in the error's
-    # diagnostics; other adapters (or a missing name) fall back to "".
+    # ActiveRecord already tells these apart by SQLSTATE, and dropping that
+    # into a message is what forced callers to match text.
+    def self.translate(error)
+      case error
+      when ::ActiveRecord::RecordNotUnique
+        JadeSql::SqlErrors.unique_violation(constraint_name(error))
+      when ::ActiveRecord::InvalidForeignKey
+        JadeSql::SqlErrors.foreign_key_violation(constraint_name(error))
+      when ::ActiveRecord::CheckViolation
+        JadeSql::SqlErrors.check_violation(constraint_name(error))
+      when ::ActiveRecord::ExclusionViolation
+        JadeSql::SqlErrors.exclusion_violation(constraint_name(error))
+      when ::ActiveRecord::NotNullViolation
+        JadeSql::SqlErrors.not_null_violation(column_name(error))
+      when ::ActiveRecord::Deadlocked
+        JadeSql::SqlErrors.deadlock
+      when ::ActiveRecord::SerializationFailure
+        JadeSql::SqlErrors.serialization_failure
+      when ::ActiveRecord::LockWaitTimeout
+        JadeSql::SqlErrors.lock_timeout
+      when ::ActiveRecord::QueryCanceled, ::ActiveRecord::StatementTimeout
+        JadeSql::SqlErrors.statement_timeout
+      else
+        JadeSql::SqlErrors.db_error(error.message)
+      end
+    end
+
+    # The constraint/index name behind a violation, so callers can route by
+    # which one it was. PG reports it in the error's diagnostics; other
+    # adapters (or a missing name) fall back to "".
     def self.constraint_name(error)
       cause = error.cause
       return "" unless defined?(::PG::Result) && cause.respond_to?(:result) && cause.result
@@ -185,7 +210,16 @@ module JadeSql
       ""
     end
 
-    # Sql.Mutation.timestamped emits "$JADE_SQL_NOW$" where created_at /
+    def self.column_name(error)
+      cause = error.cause
+      return "" unless defined?(::PG::Result) && cause.respond_to?(:result) && cause.result
+
+      cause.result.error_field(::PG::Result::PG_DIAG_COLUMN_NAME) || ""
+    rescue StandardError
+      ""
+    end
+
+    # Sql.Write.timestamped emits "$JADE_SQL_NOW$" where created_at /
     # updated_at go. Swap it for one UTC timestamp literal per statement,
     # computed here — the app clock, so it moves with travel_to/Timecop
     # (unlike DB now()). The token lives in SQL we generate, never in a
@@ -199,6 +233,23 @@ module JadeSql
       sql.gsub(NOW_TOKEN) { stamp }
     end
 
+    def self.statement(sql, params, conn)
+      fill_now(sql)
+        .tap { refuse_stacked(it) if params.empty? }
+        .then { adapt_sql(it, conn) }
+    end
+
+    def self.refuse_stacked(sql)
+      at = sql.sub(/;\s*\z/, '').index(';')
+      return if at.nil?
+
+      raise ArgumentError,
+        "jade-sql refused a statement with a second one after `;` " \
+        "(at character #{at + 1}). Without bound values, Postgres would run " \
+        "every statement in the string. If a value holds the `;`, bind it " \
+        "with `?`. If you meant two statements, make two calls."
+    end
+
     # Sql renders `?` placeholders uniformly. AR's exec_query/exec_update
     # path on the PG adapter expects `$1, $2, …` — there is no `?`-to-`$n`
     # rewrite at that layer. SQLite and MySQL accept `?` directly, so this