Fix quote method to use database adapter for MySQL compatibility

The quote method was hardcoding double quotes (") which only works for
PostgreSQL/SQLite. MySQL requires backticks (`). This change delegates
to the Rails connection adapter's quote_column_name method to use the
correct quoting style for each database.

Changes:
- Fix quote() to use _model_class.connection.quote_column_name()
- Add unit tests for quote method with mock MySQL adapter
- Add MySQL and PostgreSQL services to docker-compose for testing
- Add mysql2 gem to Gemfile

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: takaokouji

Dockerfile.ruby3.1

@@ -4,7 +4,7 @@ FROM ruby:3.1.5
 
 # Install dependencies
 RUN apt-get update -qq && \
-    apt-get install -y build-essential libpq-dev nodejs && \
+    apt-get install -y build-essential libpq-dev default-libmysqlclient-dev nodejs && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 

Gemfile

@@ -10,6 +10,7 @@ version = ENV['RAILS_VERSION'] || 'default'
 
 platforms :ruby do
   gem 'pg'
+  gem 'mysql2'
 
   if version.start_with?('4.2', '5.0')
     gem 'sqlite3', '~> 1.3.13'

docker-compose.yml

@@ -115,7 +115,91 @@ services:
       - RAILS_VERSION=${RAILS_VERSION:-8.1.2}
     command: /bin/bash
 
+  # Database services
+  mysql:
+    image: mysql:8.0
+    container_name: jsonapi-mysql
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: jsonapi_test
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql-data:/var/lib/mysql
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  postgres:
+    image: postgres:14
+    container_name: jsonapi-postgres
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: jsonapi_test
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  # Rails 6.1 with MySQL
+  rails-6.1-mysql:
+    <<: *test-base
+    container_name: jsonapi-rails-6.1-mysql
+    depends_on:
+      mysql:
+        condition: service_healthy
+    environment:
+      - RAILS_VERSION=6.1.7.10
+      - DATABASE_URL=mysql2://root:root@mysql:3306/jsonapi_test
+    command: bash -c "rm -f Gemfile.lock && /usr/local/bin/bundler _2.4.14_ install && /usr/local/bin/bundler _2.4.14_ exec rake test"
+
+  # Rails 6.1 with PostgreSQL
+  rails-6.1-postgres:
+    <<: *test-base
+    container_name: jsonapi-rails-6.1-postgres
+    depends_on:
+      postgres:
+        condition: service_healthy
+    environment:
+      - RAILS_VERSION=6.1.7.10
+      - DATABASE_URL=postgresql://postgres:postgres@postgres:5432/jsonapi_test
+    command: bash -c "rm -f Gemfile.lock && /usr/local/bin/bundler _2.4.14_ install && /usr/local/bin/bundler _2.4.14_ exec rake test"
+
+  # Rails 7.0 with MySQL
+  rails-7.0-mysql:
+    <<: *test-base
+    container_name: jsonapi-rails-7.0-mysql
+    depends_on:
+      mysql:
+        condition: service_healthy
+    environment:
+      - RAILS_VERSION=7.0.10
+      - DATABASE_URL=mysql2://root:root@mysql:3306/jsonapi_test
+    command: bash -c "rm -f Gemfile.lock && /usr/local/bin/bundler _2.4.14_ install && /usr/local/bin/bundler _2.4.14_ exec rake test"
+
+  # Rails 7.0 with PostgreSQL
+  rails-7.0-postgres:
+    <<: *test-base
+    container_name: jsonapi-rails-7.0-postgres
+    depends_on:
+      postgres:
+        condition: service_healthy
+    environment:
+      - RAILS_VERSION=7.0.10
+      - DATABASE_URL=postgresql://postgres:postgres@postgres:5432/jsonapi_test
+    command: bash -c "rm -f Gemfile.lock && /usr/local/bin/bundler _2.4.14_ install && /usr/local/bin/bundler _2.4.14_ exec rake test"
+
 volumes:
   bundle-cache-ruby31:
   bundle-cache-ruby27:
   bundle-cache-ruby34:
+  mysql-data:
+  postgres-data:

lib/jsonapi/active_relation_resource.rb

@@ -847,7 +847,7 @@ def alias_table_field(table, field, quoted = false)
       end
 
       def quote(field)
-        "\"#{field.to_s}\""
+        _model_class.connection.quote_column_name(field.to_s)
       end
 
       def apply_filters(records, filters, options = {})

test/unit/resource/quote_method_test.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+class QuoteMethodTest < ActiveSupport::TestCase
+  def test_quote_method_does_not_hardcode_double_quotes
+    # The quote method should NOT hardcode double quotes
+    # It should delegate to the database adapter's quote_column_name
+    # This test verifies the implementation uses the adapter, not hardcoded quotes
+    field_name = 'test_field'
+
+    # Get the actual implementation's result
+    actual = PostResource.send(:quote, field_name)
+
+    # The implementation should use connection.quote_column_name, not hardcode "\"#{field}\""
+    # We verify this by checking if the method delegates to the connection
+    connection = PostResource._model_class.connection
+    expected = connection.quote_column_name(field_name)
+
+    assert_equal expected, actual,
+      "quote method should delegate to connection.quote_column_name, not hardcode double quotes"
+  end
+
+  def test_quote_uses_mysql_style_backticks_with_mysql_adapter
+    # This test verifies the quote method respects the database adapter's quoting style
+    # MySQL uses backticks, PostgreSQL/SQLite use double quotes
+
+    field_name = 'test_field'
+
+    # Create a mock connection that uses MySQL-style backticks
+    mock_connection = Minitest::Mock.new
+    mock_connection.expect(:quote_column_name, "`#{field_name}`", [field_name.to_s])
+
+    # Stub the connection method to return our mock
+    PostResource._model_class.stub(:connection, mock_connection) do
+      actual = PostResource.send(:quote, field_name)
+      assert_equal "`#{field_name}`", actual,
+        "quote method should use backticks when MySQL adapter is used"
+    end
+
+    mock_connection.verify
+  end
+
+  def test_quote_uses_connection_adapter
+    # The quote method should delegate to the database adapter's quote_column_name
+    # This ensures proper quoting for different databases:
+    # - SQLite/PostgreSQL: double quotes (")
+    # - MySQL: backticks (`)
+    field_name = 'test_field'
+    expected = PostResource._model_class.connection.quote_column_name(field_name)
+    actual = PostResource.send(:quote, field_name)
+
+    assert_equal expected, actual,
+      "quote method should use connection adapter's quote_column_name"
+  end
+
+  def test_quote_with_symbol_field
+    field_name = :test_field
+    expected = PostResource._model_class.connection.quote_column_name(field_name.to_s)
+    actual = PostResource.send(:quote, field_name)
+
+    assert_equal expected, actual,
+      "quote method should handle symbol field names"
+  end
+
+  def test_concat_table_field_quoted
+    table = 'posts'
+    field = 'title'
+    connection = PostResource._model_class.connection
+    expected = "#{connection.quote_column_name(table)}.#{connection.quote_column_name(field)}"
+    actual = PostResource.send(:concat_table_field, table, field, true)
+
+    assert_equal expected, actual,
+      "concat_table_field with quoted=true should use proper database quoting"
+  end
+
+  def test_alias_table_field_quoted
+    table = 'posts'
+    field = 'title'
+    connection = PostResource._model_class.connection
+    expected = connection.quote_column_name("#{table}_#{field}")
+    actual = PostResource.send(:alias_table_field, table, field, true)
+
+    assert_equal expected, actual,
+      "alias_table_field with quoted=true should use proper database quoting"
+  end
+
+  def test_sql_field_with_alias_uses_proper_quoting
+    table = 'posts'
+    field = 'title'
+    connection = PostResource._model_class.connection
+    quoted_table_field = "#{connection.quote_column_name(table)}.#{connection.quote_column_name(field)}"
+    quoted_alias = connection.quote_column_name("#{table}_#{field}")
+    expected_sql = "#{quoted_table_field} AS #{quoted_alias}"
+
+    actual = PostResource.send(:sql_field_with_alias, table, field, true)
+
+    assert actual.is_a?(Arel::Nodes::SqlLiteral),
+      "sql_field_with_alias should return an Arel::Nodes::SqlLiteral"
+    assert_equal expected_sql, actual.to_s,
+      "sql_field_with_alias should use proper database quoting"
+  end
+end