fauna 1.3.4 → 2.0.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZjI4NGIwZGEyZWIyYzJiZmY5Y2UxMWMzM2QyZDg2YTNjMjc5NGFmMg==
-  data.tar.gz: !binary |-
-    NTQyNTE5MTdlOGY2YWZmMTFiNTQyYTE4OWZiZDA1YTU3NjYyYzk4NA==
+SHA1:
+  metadata.gz: 9179efc5b2e53c99b6d398de61902fd963fefea7
+  data.tar.gz: cfbee10e91d3cdfe4baabc212b34cfd1ae348ea9
 SHA512:
-  metadata.gz: !binary |-
-    MzE5MTU4NGU0NWJlNzU3ZWE2NjQ2NzI1N2M3NGVjYmViOTNmZmEyN2NkMjll
-    YmM1MGMxOTBhOTNkYWUyNGNkZTJiOTg3YzgxNmUzMWQ0NzU1MWJlZWJkMGI0
-    ZDNjNjM4NDJlNjU0YTQ3MDU5OWVlMDU1Mzc3NGY5Y2IyN2MyZGU=
-  data.tar.gz: !binary |-
-    NDlkYzBmNGY5NWU2YmRiODA0YTE1NGNiZWUyMTgxMjAwYWJlNjNmOWFhZTJm
-    OThlY2JiNjA0YzY0ZTY5OGYzN2M2NWJkNDNjYWZiZDNlNTQ1ZDgyZDZmNzNh
-    NTc1NTMyZDRjMTBmYzk4MDJlYTIzZDllMDg1ZWVlNzI0ZjY0ZWI=
+  metadata.gz: c143182304816bde8ed2b057cfd9e0c0a267e382e810c7c651139d7efcfe2aedee343fdae75c76816a4dfe90a775d6cdf921f295cc94f7c7241038fa06ed2587
+  data.tar.gz: 534a5305cacdc340f870f975435c8a69cd0aa3647ddfbf4324226d3171f3ab0f16f1280e96e4551fc1cde9b6ee01691933a016f122be7ec25ecc658c802ae150

data/CHANGELOG

@@ -1,3 +1,5 @@
+v2.0.0 Complete rewrite for API 2.0. Not backwards compatible with the old client or api.
+
 v1.3.4 Index support.
 
 v1.3.3 Fix #61.

data/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
 gem 'rake'
-gem 'jruby-openssl', :platform => :jruby
+gem 'jruby-openssl', platform: :jruby
 
 gemspec

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2013 Fauna, Inc.
+Copyright 2015 Fauna, Inc.
 
 Licensed under the Mozilla Public License, Version 2.0 (the "License"); you may
 not use this software except in compliance with the License. You may obtain a 

data/README.md

@@ -1,10 +1,10 @@
-# Fauna
+# FaunaDB
 
-Experimental Ruby client for [Fauna](http://fauna.org).
+Ruby client for [FaunaDB](https://faunadb.com).
 
 ## Installation
 
-The Fauna ruby client is distributed as a gem. Install it via:
+The FaunaDB ruby client is distributed as a gem. Install it via:
 
     $ gem install fauna
 
@@ -18,145 +18,108 @@ And then execute:
 
 ## Compatibility
 
-Tested and compatible with MRI 1.9.3. Other Rubies may also work.
+Tested and compatible with the following ruby versions:
+
+* MRI 1.9.3
+* MRI 2.2.3
+* Jruby 1.7.19
 
 ## Basic Usage
 
 First, require the gem:
 
 ```ruby
-require "rubygems"
-require "fauna"
+require 'fauna'
 ```
 
-### Configuring the API
-
-All API requests start with an instance of `Fauna::Connection`.
+### Creating a Client
 
-Creating a connection requires either a token, a server key, or a
-client key.
+All API requests pass through a `Fauna::Client`. Creating a client
+requires either an admin key, server key, client key, or a token.
 
 ```ruby
 server_key = 'ls8AkXLdakAAAALPAJFy3LvQAAGwDRAS_Prjy6O8VQBfQAlZzwAA'
 ```
-Now we can make a global database-level connection:
-
-```ruby
-$fauna = Fauna::Connection.new(secret: server_key)
-```
 
-You can optionally configure a `logger` on the connection to ease
-debugging:
+Now we can make a database-level client:
 
 ```ruby
-require "logger"
-$fauna = Fauna::Connection.new(
-  secret: server_key,
-  logger: Logger.new(STDERR))
+$fauna = Fauna::Client.new(secret: server_key)
 ```
 
-### Client Contexts
-
-The easiest way to work with a connection is to open up a *client
-context*, and then manipulate resources within that context:
+You can optionally configure an `observer` on the client. To ease
+debugging, we provide a simple logging observer at
+`Fauna::ClientLogger.logger`, which you can configure as such:
 
 ```ruby
-Fauna::Client.context($fauna) do
-  user = Fauna::Resource.create('users', email: "taran@example.com")
-  user.data["name"] = "Taran"
-  user.data["profession"] = "Pigkeeper"
-  user.save
-  user.delete
-end
-```
+require 'logger'
+logger = Logger.new(STDERR)
+observer = Fauna::ClientLogger.logger { |log| logger.debug(log) }
 
-By working within a context, not only are you able to use a more
-convienient, object-oriented API, you also gain the advantage of
-in-process caching.
-
-Within a context block, requests for a resource that has already been
-loaded via a previous request will be returned from the cache and no
-query will be issued. This substantially lowers network overhead,
-since Fauna makes an effort to return related resources as part of
-every response.
+$fauna = Fauna::Client.new(
+  secret: server_key,
+  observer: observer)
+```
 
-### Fauna::Resource
+### Using the Client
 
-All instances of fauna classes have built-in accessors for common
-fields:
+Now that we have a client, we can start performing queries:
 
 ```ruby
-Fauna::Client.context($fauna) do
-  user = Fauna::Resource.create('users', constraints: {"username" => "taran77"})
+# Create a class
+$fauna.query { create ref('classes'), name: 'users' }
 
-  # fields
-  user.ref       # => "users/123"
-  user.ts        # => 2013-01-30 13:02:46 -0800
-  user.deleted?  # => false
-  user.constraints # => {"username" => "taran77"}
-
-  # data and references
-  user.data       # => {}
-  user.references # => {}
-
-  # resource events timeline
-  user.events
+# Create an instance of the class
+taran = $fauna.query do
+  create ref('classes/users'), data: { email: 'taran@example.com' }
 end
-```
 
-Fauna resources must be created and accessed by ref, i.e.
-
-```ruby
-pig = Fauna::Resource.create 'classes/pigs'
-pig.data['name'] = 'Henwen'
-pig.save
-pig.ref # => 'classes/pigs/42471470493859841'
-
-# and later...
-
-pig = Fauna::Resource.find 'classes/pigs/42471470493859841'
-# do something with this pig...
-````
-
-## Rails Usage
-
-Fauna provides a Rails helper that sets up a default context in
-controllers, based on credentials in `config/fauna.yml`:
-
-```yaml
-development:
-  email: taran@example.com
-  password: secret
-  secret: secret_key
-test:
-  email: taran@example.com
-  password: secret
-```
+# Update the instance
+taran = $fauna.query do
+  update taran[:ref], data: {
+    name: 'Taran',
+    profession: 'Pigkeeper'
+  }
+end
 
-(In `config/fauna.yml`, if an existing server key is specified, the
-email and password can be omitted. If a server key is not
-specified, a new one will be created each time the app is started.)
+# Page through a set
+pigkeepers = Fauna::Query.expr { match(ref('indexes/users_by_profession'), 'Pigkeeper') }
+oracles = Fauna::Query.expr { match(ref('indexes/users_by_profession'), 'Oracle') }
 
-Then, in `config/initializers/fauna.rb`:
+$fauna.query { paginate(union(pigkeepers, oracles)) }
 
-```ruby
-require "fauna/rails"
+# Delete the user
+$fauna.query { delete user[:ref] }
 ```
 
 ## Running Tests
 
-You can run tests against Fauna Cloud. Set the `FAUNA_ROOT_KEY` environment variable to your CGI-escaped email and password, joined by a `:`. Then run `rake`:
+You can run tests against FaunaDB Cloud yourself.
+[Create an admin key](https://faunadb.com/account/keys) and set
+`FAUNA_ROOT_KEY` environment variable to it's secret. Then run `rake test`:
 
 ```bash
-export FAUNA_ROOT_KEY="test%40fauna.org:secret"
-rake
+export FAUNA_ROOT_KEY='kqnPAbijGhkgAAC03-36hjCvcTnWf4Pl8w97UE1HeWo'
+rake test
 ```
 
+To run a single test, use e.g. `ruby test/client_test.rb`.
+
+Coverage is automatically run as part of the tests. After running tests, check
+`coverage/index.html` for the coverage report. If using jruby, use
+`JRUBY_OPTS="--debug" bundle exec rake test` to ensure coverage is generated
+correctly.
+
+## Documenting
+
+Use `rake rdoc` to generate documentation.
+
 ## Further Reading
 
-Please see the Fauna REST Documentation for a complete API reference,
-or look in [`/test`](https://github.com/fauna/fauna-ruby/tree/master/test)
-for more examples.
+Please see the [FaunaDB Documentation](https://faunadb.com/documentation) for
+a complete API reference, or look in
+[`/test`](https://github.com/faunadb/faunadb-ruby/tree/master/test) for more
+examples.
 
 ## Contributing
 
@@ -164,7 +127,7 @@ GitHub pull requests are very welcome.
 
 ## LICENSE
 
-Copyright 2013 [Fauna, Inc.](https://fauna.org/)
+Copyright 2016 [Fauna, Inc.](https://faunadb.com/)
 
 Licensed under the Mozilla Public License, Version 2.0 (the
 "License"); you may not use this software except in compliance with

data/Rakefile

@@ -1,22 +1,5 @@
-require 'echoe'
-
-Echoe.new('fauna') do |p|
-  p.author = 'Fauna, Inc.'
-  p.project = 'fauna'
-  p.summary = 'Ruby client for the Fauna distributed database.'
-  p.retain_gemspec = true
-  p.licenses = ['Mozilla Public License, Version 2.0 (MPL2)']
-  p.dependencies = ['faraday ~>0.9.0', 'json ~>1.8.0']
-  p.development_dependencies = ['mocha', 'echoe', 'minitest ~>4.0', 'rubocop']
-end
-
-task :beautify do
-  require 'ruby-beautify'
-  Dir['**/*rb'].each do |filename|
-    s = RBeautify.beautify_string(:ruby, File.read(filename))
-    File.write(filename, s) unless s.empty?
-  end
-end
+require 'rspec/core/rake_task'
+require 'rdoc/task'
 
 begin
   require 'rubocop/rake_task'
@@ -27,4 +10,13 @@ rescue LoadError
   end
 end
 
-task :prerelease => [:manifest, :test, :install]
+RSpec::Core::RakeTask.new(:spec)
+
+RDoc::Task.new do |rdoc|
+  rdoc.main = 'README.md'
+  rdoc.rdoc_dir = 'doc'
+  rdoc.rdoc_files.include('README.md', 'lib/fauna.rb', 'lib/fauna/*.rb')
+end
+
+task prerelease: [:spec, :install]
+task default: :spec

data/fauna.gemspec

@@ -1,50 +1,25 @@
 # -*- encoding: utf-8 -*-
-# stub: fauna 1.3.4 ruby lib
+require './lib/fauna/version'
 
 Gem::Specification.new do |s|
-  s.name = "fauna"
-  s.version = "1.3.4"
+  s.name = 'fauna'
+  s.version = Fauna::VERSION
+  s.author = 'Fauna, Inc.'
+  s.email = 'priority@faunadb.com'
+  s.summary = 'FaunaDB Ruby client'
+  s.description = 'Ruby client for the Fauna distributed database.'
+  s.homepage = 'https://github.com/faunadb/faunadb-ruby'
+  s.license = 'MPL-2.0'
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Fauna, Inc."]
-  s.date = "2015-01-14"
-  s.description = "Ruby client for the Fauna distributed database."
-  s.email = ""
-  s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README.md", "lib/fauna.rb", "lib/fauna/cache.rb", "lib/fauna/client.rb", "lib/fauna/connection.rb", "lib/fauna/named_resource.rb", "lib/fauna/rails.rb", "lib/fauna/resource.rb", "lib/fauna/set.rb", "lib/fauna/util.rb", "lib/tasks/fauna.rake"]
-  s.files = ["CHANGELOG", "Gemfile", "LICENSE", "Manifest", "README.md", "Rakefile", "fauna.gemspec", "lib/fauna.rb", "lib/fauna/cache.rb", "lib/fauna/client.rb", "lib/fauna/connection.rb", "lib/fauna/named_resource.rb", "lib/fauna/rails.rb", "lib/fauna/resource.rb", "lib/fauna/set.rb", "lib/fauna/util.rb", "lib/tasks/fauna.rake", "test/class_test.rb", "test/client_test.rb", "test/connection_test.rb", "test/database_test.rb", "test/query_test.rb", "test/readme_test.rb", "test/set_test.rb", "test/test_helper.rb"]
-  s.homepage = "http://fauna.github.com/fauna/"
-  s.licenses = ["Mozilla Public License, Version 2.0 (MPL2)"]
-  s.rdoc_options = ["--line-numbers", "--title", "Fauna", "--main", "README.md"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = "fauna"
-  s.rubygems_version = "2.1.10"
-  s.summary = "Ruby client for the Fauna distributed database."
-  s.test_files = ["test/class_test.rb", "test/client_test.rb", "test/connection_test.rb", "test/database_test.rb", "test/query_test.rb", "test/readme_test.rb", "test/set_test.rb", "test/test_helper.rb"]
+  s.files = %w(CHANGELOG Gemfile LICENSE README.md Rakefile fauna.gemspec lib/fauna.rb) + Dir.glob('lib/fauna/**') + Dir.glob('spec/**')
+  s.extra_rdoc_files = %w(CHANGELOG LICENSE README.md)
+  s.rdoc_options = %w(--line-numbers --title Fauna --main README.md)
+  s.test_files = Dir.glob('spec/**')
+  s.require_paths = ['lib']
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<faraday>, ["~> 0.9.0"])
-      s.add_runtime_dependency(%q<json>, ["~> 1.8.0"])
-      s.add_development_dependency(%q<mocha>, [">= 0"])
-      s.add_development_dependency(%q<echoe>, [">= 0"])
-      s.add_development_dependency(%q<minitest>, ["~> 4.0"])
-      s.add_development_dependency(%q<rubocop>, [">= 0"])
-    else
-      s.add_dependency(%q<faraday>, ["~> 0.9.0"])
-      s.add_dependency(%q<json>, ["~> 1.8.0"])
-      s.add_dependency(%q<mocha>, [">= 0"])
-      s.add_dependency(%q<echoe>, [">= 0"])
-      s.add_dependency(%q<minitest>, ["~> 4.0"])
-      s.add_dependency(%q<rubocop>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<faraday>, ["~> 0.9.0"])
-    s.add_dependency(%q<json>, ["~> 1.8.0"])
-    s.add_dependency(%q<mocha>, [">= 0"])
-    s.add_dependency(%q<echoe>, [">= 0"])
-    s.add_dependency(%q<minitest>, ["~> 4.0"])
-    s.add_dependency(%q<rubocop>, [">= 0"])
-  end
+  s.add_runtime_dependency 'faraday', '~> 0.9.0'
+  s.add_runtime_dependency 'json', '~> 1.8'
+  s.add_development_dependency 'rspec', '~> 3.4'
+  s.add_development_dependency 'rubocop', '~> 0.35.0'
+  s.add_development_dependency 'coveralls', '~> 0.8.10'
 end

data/lib/fauna.rb

@@ -4,21 +4,19 @@ require 'uri'
 require 'faraday'
 require 'cgi'
 require 'zlib'
+require 'time'
 
-load "#{File.dirname(__FILE__)}/tasks/fauna.rake" if defined?(Rake)
-
-module Fauna
-  class Invalid < RuntimeError
-  end
-
-  class NotFound < RuntimeError
-  end
-end
+##
+# Main namespace for the FaunaDB client.
+module Fauna; end
 
+require 'fauna/version'
+require 'fauna/json'
 require 'fauna/util'
-require 'fauna/connection'
-require 'fauna/cache'
+require 'fauna/errors'
 require 'fauna/client'
-require 'fauna/resource'
-require 'fauna/named_resource'
-require 'fauna/set'
+require 'fauna/client_logger'
+require 'fauna/context'
+require 'fauna/objects'
+require 'fauna/query'
+require 'fauna/request_result'

data/lib/fauna/client.rb

@@ -1,54 +1,252 @@
 module Fauna
+  ##
+  # The Ruby client for FaunaDB.
+  #
+  # All methods return a converted JSON response.
+  # This is a Hash containing Arrays, ints, floats, strings, and other Hashes.
+  # Hash keys are always Symbols.
+  #
+  # Any Ref, SetRef, Time or Date values in it will also be parsed.
+  # (So instead of <code>{ "@ref": "classes/frogs/123" }</code>,
+  # you will get <code>Fauna::Ref.new("classes/frogs/123")</code>).
   class Client
-    def self.context(connection)
-      push_context(connection)
-      yield
-    ensure
-      pop_context
+    # The domain requests will be sent to.
+    attr_reader :domain
+    # Scheme used when sending requests (either +http+ or +https+).
+    attr_reader :scheme
+    # Port used when sending requests.
+    attr_reader :port
+    # An array of the user and pass used for authentication when sending requests.
+    attr_reader :credentials
+    # Read timeout in seconds.
+    attr_reader :read_timeout
+    # Open timeout in seconds.
+    attr_reader :connection_timeout
+    # Callback that will be passed a +RequestResult+ after every completed request.
+    attr_reader :observer
+    # Faraday adapter in use.
+    attr_reader :adapter
+
+    ##
+    # Create a new Client.
+    #
+    # +params+:: A list of parameters to configure the connection with.
+    #            +:domain+:: The domain to send requests to.
+    #            +:scheme+:: Scheme to use when sending requests (either +http+ or +https+).
+    #            +:port+:: Port to use when sending requests.
+    #            +:secret+:: Credentials to use when sending requests. User and pass must be separated by a colon.
+    #            +:read_timeout+:: Read timeout in seconds.
+    #            +:connection_timeout+:: Open timeout in seconds.
+    #            +:observer+:: Callback that will be passed a RequestResult after every completed request.
+    #            +:adapter+:: Faraday[https://github.com/lostisland/faraday] adapter to use. Either can be a symbol for the adapter, or an array of arguments.
+    def initialize(params = {})
+      @domain = params[:domain] || 'rest.faunadb.com'
+      @scheme = params[:scheme] || 'https'
+      @port = params[:port] || (scheme == 'https' ? 443 : 80)
+      @read_timeout = params[:read_timeout] || 60
+      @connection_timeout = params[:connection_timeout] || 60
+      @observer = params[:observer]
+      @adapter = params[:adapter] || Faraday.default_adapter
+      init_credentials(params[:secret])
+
+      init_connection
     end
 
-    def self.push_context(connection)
-      stack.push(Fauna::Cache.new(connection))
+    ##
+    # Create a new client from the existing config with a given secret.
+    #
+    # +:secret+:: Credentials to use when sending requests. User and pass must be separated by a colon.
+    def with_secret(secret)
+      with_dup do |client|
+        client.send(:init_credentials, secret)
+      end
     end
 
-    def self.pop_context
-      stack.pop
+    ##
+    # Issues a query to FaunaDB.
+    #
+    # Queries are built via the Query helpers. See {FaunaDB Query API}[https://faunadb.com/documentation/queries]
+    # for information on constructing queries.
+    #
+    # +expression+:: A query expression
+    # +expr_block+:: May be provided instead of expression. Block is used to build an expression with Fauna.query.
+    #
+    # Example using expression:
+    #
+    # <code>client.query(Fauna::Query.add(1, 2, Fauna::Query.subtract(3, 2)))</code>
+    #
+    # Example using block:
+    #
+    # <code>client.query { add(1, 2, subtract(3, 2)) }</code>
+    #
+    # Reference: {Executing FaunaDB Queries}[https://faunadb.com/documentation#queries]
+    #
+    # :category: Query Methods
+    def query(expression = nil, &expr_block)
+      if expr_block.nil?
+        post '', Fauna::Query::Expr.wrap(expression)
+      else
+        post '', Fauna::Query.expr(&expr_block)
+      end
     end
 
-    def self.reset_context
-      stack = [] # rubocop:disable Lint/UselessAssignment
+    ##
+    # Performs a +GET+ request for a REST endpoint.
+    #
+    # +path+:: Path to +GET+.
+    # +query+:: Query parameters to append to the path.
+    #
+    # Reference: {FaunaDB REST API}[https://faunadb.com/documentation/rest]
+    #
+    # :category: REST Methods
+    def get(path, query = {})
+      execute(:get, path.to_s, query)
     end
 
-    def self.get(ref, query = {}, pagination = {})
-      connection.get(ref, query, pagination)
+    ##
+    # Performs a +POST+ request for a REST endpoint.
+    #
+    # +path+:: Path to +POST+.
+    # +data+:: Data to post as the body. +data+ is automatically converted to JSON.
+    #
+    # Reference: {FaunaDB REST API}[https://faunadb.com/documentation/rest]
+    #
+    # :category: REST Methods
+    def post(path, data = {})
+      execute(:post, path, nil, data)
     end
 
-    def self.post(ref, data = {})
-      connection.post(ref, data)
+    ##
+    # Performs a +PUT+ request for a REST endpoint.
+    #
+    # +path+:: Path to +PUT+.
+    # +data+:: Data to post as the body. +data+ is automatically converted to JSON.
+    #
+    # Reference: {FaunaDB REST API}[https://faunadb.com/documentation/rest]
+    #
+    # :category: REST Methods
+    def put(path, data = {})
+      execute(:put, path, nil, data)
     end
 
-    def self.put(ref, data = {})
-      connection.put(ref, data)
+    ##
+    # Performs a +PATCH+ request for a REST endpoint.
+    #
+    # +path+:: Path to +PATCH+.
+    # +data+:: Data to post as the body. +data+ is automatically converted to JSON.
+    #
+    # Reference: {FaunaDB REST API}[https://faunadb.com/documentation/rest]
+    #
+    # :category: REST Methods
+    def patch(path, data = {})
+      execute(:patch, path, nil, data)
     end
 
-    def self.patch(ref, data = {})
-      connection.patch(ref, data)
+    ##
+    # Performs a +DELETE+ request for a REST endpoint.
+    #
+    # +path+:: Path to +DELETE+.
+    #
+    # Reference: {FaunaDB REST API}[https://faunadb.com/documentation/rest]
+    #
+    # :category: REST Methods
+    def delete(path)
+      execute(:delete, path)
     end
 
-    def self.delete(ref, data = {})
-      connection.delete(ref, data)
+    ##
+    # Ping FaunaDB.
+    #
+    # Reference: {FaunaDB Rest API}[https://faunadb.com/documentation#rest-other].
+    #
+    # :category: REST Methods
+    def ping(params = {})
+      get 'ping', params
     end
 
-    def self.connection
-      stack.last || fail(NoContextError, 'You must be within a Fauna::Client.context block to perform operations.')
+  private
+
+    def with_dup
+      new_client = self.dup
+      yield new_client
+      new_client.send(:init_connection)
+      new_client
     end
 
-    class << self
-    private
+    def init_credentials(secret)
+      @credentials = secret.to_s.split(':', 2)
+    end
 
-      def stack
-        Thread.current[:fauna_context_stack] ||= []
+    def init_connection
+      @connection = Faraday.new(
+        url: "#{scheme}://#{domain}:#{port}/",
+        headers: {
+          'Accept-Encoding' => 'gzip,deflate',
+          'Content-Type' => 'application/json;charset=utf-8',
+          'User-Agent' => "FaunaDB-Ruby/#{Fauna::VERSION}",
+        },
+        request: { timeout: read_timeout, open_timeout: connection_timeout },
+      ) do |conn|
+        # Let us specify arguments so we can set stubs for test adapter
+        conn.adapter(*Array(adapter))
+        conn.basic_auth(credentials[0].to_s, credentials[1].to_s)
+        conn.response :fauna_decode
+      end
+    end
+
+    def execute(action, path, query = nil, data = nil)
+      path = path.to_s
+
+      start_time = Time.now
+      response = perform_request action, path, query, data
+      end_time = Time.now
+
+      response_raw = response.body
+      response_json = FaunaJson.json_load_or_nil response_raw
+      response_content = FaunaJson.deserialize response_json unless response_json.nil?
+
+      request_result = RequestResult.new(self,
+          action, path, query, data,
+          response_raw, response_content, response.status, response.headers,
+          start_time, end_time)
+
+      @observer.call(request_result) unless @observer.nil?
+
+      if response_json.nil?
+        fail UnexpectedError.new('Invalid JSON.', request_result)
+      end
+
+      FaunaError.raise_for_status_code(request_result)
+      UnexpectedError.get_or_raise request_result, response_content, :resource
+    end
+
+    def perform_request(action, path, query, data)
+      @connection.send(action) do |req|
+        req.params = query.delete_if { |_, v| v.nil? } unless query.nil?
+        req.body = FaunaJson.to_json(data) unless data.nil?
+        req.url(path || '')
       end
     end
   end
+
+  # Middleware for decompressing responses
+  class FaunaDecode < Faraday::Middleware # :nodoc:
+    def call(env)
+      @app.call(env).on_complete do |response_env|
+        raw_body = response_env[:body]
+        response_env[:body] =
+            case response_env[:response_headers]['Content-Encoding']
+            when 'gzip'
+              io = StringIO.new raw_body
+              Zlib::GzipReader.new(io, external_encoding: Encoding::UTF_8).read
+            when 'deflate'
+              Zlib::Inflate.inflate raw_body
+            else
+              raw_body
+            end
+      end
+    end
+  end
+
+  Faraday::Response.register_middleware fauna_decode: lambda { FaunaDecode }
 end