jade-sql 0.1.0

data/exe/jade-sql

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'optparse'
+require 'jade-sql/version'
+
+def run_schema(args)
+  require 'fileutils'
+  require 'jade-sql'
+  require 'jade-sql/bin/generate_schema'
+
+  opts = {
+    input: 'db/structure.sql',
+    output: 'app/jade/schema.jd',
+    module_name: 'Schema',
+    tables: nil,
+  }
+
+  OptionParser.new do |o|
+    o.banner = 'Usage: jade-sql schema [options]'
+    o.on('-i', '--input PATH', 'source DDL (default: db/structure.sql)') { opts[:input] = it }
+    o.on('-o', '--output PATH', 'destination .jd (default: app/jade/schema.jd)') { opts[:output] = it }
+    o.on('-t', '--tables a,b,c', 'comma-separated table whitelist') {
+      opts[:tables] = it.split(',').map(&:strip).reject(&:empty?)
+    }
+    o.on('-m', '--module NAME', 'module name (default: Schema)') { opts[:module_name] = it }
+  end.parse!(args)
+
+  generated = JadeSql::SchemaGenerator.generate(
+    File.read(opts[:input]),
+    tables: opts[:tables],
+    module_name: opts[:module_name],
+  )
+
+  FileUtils.mkdir_p(File.dirname(opts[:output]))
+  File.write(opts[:output], generated)
+  puts "wrote #{opts[:output]}"
+end
+
+HELP = <<~USAGE
+  jade-sql #{JadeSql::VERSION} — type-safe SQL for Jade
+
+  Usage: jade-sql <command> [options]
+
+  Commands:
+    schema     Generate schema.jd from a SQL structure dump
+    version    Print the version
+    help       Show this message
+
+  Run `jade-sql schema --help` for schema options.
+USAGE
+
+case (command = ARGV.shift)
+in 'schema'
+  run_schema(ARGV)
+
+in 'version' | '-v' | '--version'
+  puts JadeSql::VERSION
+
+in nil | 'help' | '-h' | '--help'
+  puts HELP
+
+else
+  warn "jade-sql: unknown command '#{command}' (try `jade-sql help`)"
+  exit 1
+end

data/lib/jade-sql/bin/generate_schema.rb

@@ -0,0 +1,219 @@
+require 'jade/lexer'
+require 'jade/parsing'
+require 'jade/ast'
+require 'jade/formatter'
+require 'jade/frontend/comment_attacher'
+
+module JadeSql
+  module SchemaGenerator
+    extend self
+
+    # Array variants are listed first because `\b` would otherwise match
+    # the scalar prefix of e.g. `text[]` and map it to "String".
+    TYPE_MAP = {
+      /\Abigint\[\]/ => "List(Int)",
+      /\Ainteger\[\]/ => "List(Int)",
+      /\Asmallint\[\]/ => "List(Int)",
+      /\Acharacter varying\[\]/ => "List(String)",
+      /\Avarchar\[\]/ => "List(String)",
+      /\Atext\[\]/ => "List(String)",
+      /\Aboolean\[\]/ => "List(Bool)",
+      /\Abool\[\]/ => "List(Bool)",
+      /\Ajsonb?\[\]/ => "List(Decode.Value)",
+      /\Adate\[\]/ => "List(Calendar.Date)",
+      /\Atimestamp\[\]/ => "List(Clock.Instant)",
+      /\Auuid\[\]/ => "List(Uuid)",
+
+      /\Abigint\b/ => "Int",
+      /\Ainteger\b/ => "Int",
+      /\Asmallint\b/ => "Int",
+      /\Acharacter varying\b/ => "String",
+      /\Avarchar\b/ => "String",
+      /\Acharacter\b/ => "String",
+      /\Achar\b/ => "String",
+      /\Atext\b/ => "String",
+      /\Aboolean\b/ => "Bool",
+      /\Abool\b/ => "Bool",
+      /\Ajsonb?\b/ => "Decode.Value",
+      /\Adate\b/ => "Calendar.Date",
+      /\Atimestamp\b/ => "Clock.Instant",
+      /\Auuid\b/ => "Uuid",
+    }.freeze
+
+    EXTRA_IMPORTS = {
+      "Calendar.Date" => "import Calendar",
+      "Clock.Instant" => "import Clock",
+      "Decode.Value"  => "import Decode",
+      "Uuid"          => "import Sql.Uuid exposing(Uuid)",
+    }.freeze
+
+    Table = Data.define(:name, :columns, :pk_columns)
+    Column = Data.define(:name, :jade_type, :nullable)
+
+    def generate(sql, tables: nil, module_name: 'Schema')
+      parsed = parse_tables(sql)
+      pks = parse_pks(sql)
+      parsed = parsed.map { |t| t.with(pk_columns: pks[t.name] || []) }
+      parsed = filter_tables(parsed, tables) if tables
+      format(emit(parsed, module_name))
+    end
+
+    # Run jade-fmt over the emitted source so the written schema.jd matches
+    # what the formatter would produce — keeps the generator output stable
+    # across formatter improvements and avoids spurious diffs when users
+    # re-format their tree.
+    def format(text)
+      source = ::Jade::Source.new(uri: '<schema>', text: text)
+      ::Jade::Lexer.tokenize(source)
+        .then { ::Jade::Parsing.parse(it, source:) }
+        .map { |(ast, comments)| ::Jade::Formatter.format(ast, comments:, source:) }
+        .then do
+          case it
+          in ::Jade::Ok(result) then result.end_with?("\n") ? result : "#{result}\n"
+          in ::Jade::Err(_) then text  # parse error — return unformatted; downstream compile will surface it
+          end
+        end
+    end
+
+    private
+
+    def filter_tables(parsed, whitelist)
+      missing = whitelist - parsed.map(&:name)
+      raise "Unknown table(s): #{missing.join(', ')}" if missing.any?
+
+      parsed.select { |t| whitelist.include?(t.name) }
+    end
+
+    def parse_tables(sql)
+      sql
+        .scan(/CREATE TABLE (?:\w+\.)?(\w+)\s*\((.*?)\);/m)
+        .map { |name, body| Table[name, parse_columns(body, name), []] }
+    end
+
+    def parse_columns(body, table_name)
+      body
+        .split("\n")
+        .map(&:strip)
+        .reject(&:empty?)
+        .map { |line| line.sub(/,\s*\z/, '') }
+        .reject { |line| line =~ /\A(CONSTRAINT|PRIMARY KEY|UNIQUE|CHECK|FOREIGN KEY)\b/i }
+        .map { |line| parse_column(line, table_name) }
+    end
+
+    def parse_column(line, table_name)
+      m = line.match(/\A"?(\w+)"?\s+(.+?)(\s+NOT\s+NULL)?\s*\z/i)
+      raise "Cannot parse column: #{line.inspect}" unless m
+
+      name, type_part, not_null = m[1], m[2].strip, !m[3].nil?
+
+      # Strip trailing modifiers we don't care about (DEFAULT ..., COLLATE ...).
+      type_part = type_part.sub(/\s+DEFAULT\s+.+\z/i, '').sub(/\s+COLLATE\s+.+\z/i, '').strip
+
+      jade_type = TYPE_MAP
+        .find { |sql_pat, _| sql_pat.match?(type_part.downcase) }
+        &.last
+
+      raise "Unknown SQL type for #{table_name}.#{name}: #{type_part.inspect}" unless jade_type
+
+      Column[name, jade_type, !not_null]
+    end
+
+    def parse_pks(sql)
+      sql
+        .scan(/ALTER TABLE (?:ONLY\s+)?(?:\w+\.)?(\w+)\s+ADD CONSTRAINT \w+ PRIMARY KEY \(([^)]+)\)/i)
+        .to_h { |name, cols| [name, cols.split(',').map { |c| c.strip.delete('"') }] }
+    end
+
+    def emit(tables, module_name)
+      [
+        emit_header(tables, module_name),
+        *tables.flat_map { |t| [emit_strict_cols(t), emit_maybe_cols(t), emit_row(t), emit_table_fn(t)] },
+      ].join("\n\n") + "\n"
+    end
+
+    def emit_header(tables, module_name)
+      exposed = tables
+        .flat_map { |t| ["#{camel(t.name)}Cols", "Maybe#{camel(t.name)}Cols", "#{camel(t.name)}Row(..)", t.name] }
+        .sort
+        .join(", ")
+
+      imports = ["import Sql exposing(Expr, Table, column, table)", *extra_imports_for(tables)]
+
+      <<~JADE.strip
+        module #{module_name} exposing(#{exposed})
+
+        #{imports.join("\n")}
+      JADE
+    end
+
+    def extra_imports_for(tables)
+      tables
+        .flat_map { |t| t.columns.map(&:jade_type) }
+        .flat_map { |t| [t, t[/\AList\((.*)\)\z/, 1]].compact }
+        .uniq
+        .filter_map { |jade_type| EXTRA_IMPORTS[jade_type] }
+        .uniq
+        .sort
+    end
+
+    def emit_strict_cols(t)
+      fields = t.columns
+        .map { |c| "  #{c.name}: Expr(#{c.nullable ? "Maybe(#{c.jade_type})" : c.jade_type})" }
+        .join(",\n")
+
+      "struct #{camel(t.name)}Cols = {\n#{fields}\n}"
+    end
+
+    def emit_maybe_cols(t)
+      fields = t.columns
+        .map { |c| "  #{c.name}: Expr(Maybe(#{c.jade_type}))" }
+        .join(",\n")
+
+      "struct Maybe#{camel(t.name)}Cols = {\n#{fields}\n}"
+    end
+
+    def emit_row(t)
+      fields = t.columns
+        .map { |c| "  #{c.name}: #{c.nullable ? "Maybe(#{c.jade_type})" : c.jade_type}" }
+        .join(",\n")
+
+      "struct #{camel(t.name)}Row = {\n#{fields}\n}"
+    end
+
+    def emit_table_fn(t)
+      strict_fields = t.columns.map { |c| "column(a, #{c.name.inspect})" }.join(", ")
+      maybe_fields = t.columns.map { |c| "column(a, #{c.name.inspect})" }.join(", ")
+      pk_list = "[#{t.pk_columns.map(&:inspect).join(", ")}]"
+
+      <<~JADE.strip
+        def #{t.name} -> Table(#{camel(t.name)}Cols, Maybe#{camel(t.name)}Cols)
+          table(
+            #{t.name.inspect},
+            #{t.name.inspect},
+            (a) -> { #{camel(t.name)}Cols(#{strict_fields}) },
+            (a) -> { Maybe#{camel(t.name)}Cols(#{maybe_fields}) },
+            #{pk_list},
+          )
+        end
+      JADE
+    end
+
+    def camel(snake)
+      snake.split('_').map(&:capitalize).join
+    end
+  end
+end
+
+if __FILE__ == $0
+  if ARGV.empty?
+    warn "Usage: ruby #{$0} <schema.sql>"
+    warn "       TABLES=a,b  whitelist of tables (default: all)"
+    warn "       MODULE=Name override module name (default: Schema)"
+    exit 1
+  end
+
+  tables = ENV['TABLES']&.split(',')&.map(&:strip)&.reject(&:empty?)
+  module_name = ENV['MODULE'] || 'Schema'
+
+  puts JadeSql::SchemaGenerator.generate(File.read(ARGV[0]), tables: tables, module_name: module_name)
+end

data/lib/jade-sql/runtime.rb

@@ -0,0 +1,193 @@
+require 'date'
+require 'jade/tasks'
+
+# Opt-in runtime: requires ActiveRecord. The Jade-side Sql.Run module
+# declares ports against this. Loaded only when the user explicitly does
+# `require 'jade-sql/runtime'`.
+module JadeSql
+  module Runtime
+    extend Jade::Port
+
+    task :port_execute_count do |t, pair|
+      sql, params = pair._1, pair._2
+      conn = ::ActiveRecord::Base.connection
+      t.ok(conn.exec_update(adapt_sql(sql, conn), "Jade", typed_params(params, conn)))
+    rescue ::ActiveRecord::StatementInvalid => e
+      t.err(JadeSql::SqlErrors.db_error(e.message))
+    end
+
+    task :port_execute_one do |t, pair|
+      sql, params = pair._1, pair._2
+      conn = ::ActiveRecord::Base.connection
+      rows = conn.exec_query(adapt_sql(sql, 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)
+      end
+    rescue ::ActiveRecord::StatementInvalid => e
+      t.err(JadeSql::SqlErrors.db_error(e.message))
+    end
+
+    task :port_execute_many do |t, pair|
+      sql, params = pair._1, pair._2
+      conn = ::ActiveRecord::Base.connection
+      rows = conn.exec_query(adapt_sql(sql, conn), "Jade", typed_params(params, conn)).to_a
+      t.ok(rows.map { |row| coerce_row(row) })
+    rescue ::ActiveRecord::StatementInvalid => e
+      t.err(JadeSql::SqlErrors.db_error(e.message))
+    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.
+    task :port_begin do |t|
+      ::ActiveRecord::Base.connection.begin_db_transaction
+      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
+      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
+      t.ok(true)
+    rescue ::ActiveRecord::StatementInvalid
+      t.ok(true)
+    end
+
+    # AR's PG adapter returns ::Date / ::Time for date/timestamp columns;
+    # Calendar.Date / Clock.Instant decoders expect ISO strings. Coerce
+    # at the boundary so callers don't sprinkle text_cast in every SELECT.
+    #
+    # text[] / int[] / etc. arrive as Postgres array literals (`{a,b,c}`)
+    # when AR's exec_query path doesn't run the OID typecast. Parse them
+    # back to Ruby Arrays so `Decode.list(...)` works the same as for any
+    # other List(a) column.
+    def self.coerce_row(row)
+      row.transform_values { |v| coerce_value(v) }
+    end
+
+    def self.coerce_value(v)
+      case v
+      when ::Date             then v.iso8601
+      when ::Time, ::DateTime then v.iso8601
+      when ::String
+        pg_array_literal?(v) ? parse_pg_array(v) : v
+      else v
+      end
+    end
+
+    # PG arrays render as `{}`, `{a,b,c}`, `{"a,b","c"}`, with NULL as
+    # bare `NULL`. Quoted elements escape `"` and `\` with backslashes.
+    # The JSON-object guard rejects `{"key":...}` shapes — they share the
+    # outer braces but should reach Decode.Value as plain strings (or as
+    # Hash if AR already typecast the column).
+    PG_ARRAY_LITERAL = /\A\{.*\}\z/m
+    JSON_OBJECT_HEAD = /\A\{\s*"[^"]*"\s*:/m
+
+    def self.pg_array_literal?(s)
+      s.match?(PG_ARRAY_LITERAL) && !s.match?(JSON_OBJECT_HEAD)
+    end
+
+    def self.parse_pg_array(s)
+      inner = s[1..-2]
+      return [] if inner.empty?
+
+      elements = []
+      buffer = String.new
+      in_quotes = false
+      i = 0
+      while i < inner.length
+        c = inner[i]
+        if in_quotes
+          if c == '\\' && i + 1 < inner.length
+            buffer << inner[i + 1]
+            i += 2
+            next
+          elsif c == '"'
+            in_quotes = false
+          else
+            buffer << c
+          end
+        else
+          if c == '"'
+            in_quotes = true
+          elsif c == ','
+            elements << decode_element(buffer)
+            buffer = String.new
+          else
+            buffer << c
+          end
+        end
+        i += 1
+      end
+      elements << decode_element(buffer)
+      elements
+    end
+
+    def self.decode_element(raw)
+      raw == "NULL" ? nil : raw
+    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
+    # is a no-op there.
+    #
+    # The alternation matches a whole quoted span first (single-quoted
+    # string with `''` escapes, or double-quoted identifier with `""`
+    # escapes), so a literal `?` inside one is left alone — only bare `?`
+    # outside quotes becomes a placeholder. Dollar-quoted bodies aren't
+    # handled (uncommon in app SQL).
+    QUOTED_OR_PLACEHOLDER = /'(?:[^']|'')*'|"(?:[^"]|"")*"|\?/
+
+    def self.adapt_sql(sql, conn)
+      return sql unless conn.adapter_name =~ /postgres/i
+
+      n = 0
+      sql.gsub(QUOTED_OR_PLACEHOLDER) { |m| m == "?" ? "$#{n += 1}" : m }
+    end
+
+    # AR's exec_query raw path can't bind a Ruby Array — pg's OID type
+    # cast isn't applied to bare values. Wrap arrays in QueryAttribute
+    # with a PG OID::Array so the binding picks the right wire format.
+    # Element type sniffs the first non-nil entry; falls back to text.
+    def self.typed_params(params, conn)
+      return params unless conn.adapter_name =~ /postgres/i
+
+      params.map { |p| typed_param(p) }
+    end
+
+    def self.typed_param(value)
+      case value
+      when ::Array
+        ::ActiveRecord::Relation::QueryAttribute.new(nil, value, array_type_for(value))
+      else
+        value
+      end
+    end
+
+    def self.array_type_for(elements)
+      sample = elements.find { |e| !e.nil? }
+      element_type =
+        case sample
+        when ::Integer            then ::ActiveRecord::Type::Integer.new
+        when ::Float              then ::ActiveRecord::Type::Float.new
+        when true, false          then ::ActiveRecord::Type::Boolean.new
+        else                           ::ActiveRecord::Type::String.new
+        end
+
+      ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(element_type)
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Sql.Loader exposing (
+  group_by,
+  lookup_or_empty,
+)
+
+import Dict exposing (Dict)
+
+
+def group_by(items: List(a), key: a -> k) -> Dict(k, List(a))
+  List.fold(
+    items,
+    Dict.empty,
+    (acc, item) -> {
+      k = key(item)
+
+      case Dict.get(acc, k)
+      in Just(existing) then Dict.insert(acc, k, existing ++ [item])
+      in Nothing then Dict.insert(acc, k, [item])
+      end
+    },
+  )
+end
+
+
+def lookup_or_empty(grouped: Dict(k, List(a)), key: k) -> List(a)
+  case Dict.get(grouped, key)
+  in Just(items) then items
+  in Nothing then []
+  end
+end