postgrest 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31d776cb72c9cb40561438468b582974966fbff3a1d48923a20f701f98ef61d8
-  data.tar.gz: 6461befd87bde10d825c5973a91d070772ba9366e6019fa85815a7c6f0607a98
+  metadata.gz: 047e65fe75ff575aebb1d38597b1de103609c19daff24efc97ab0f3d8f162f11
+  data.tar.gz: fb1e60e8d2e299faec971a00e5dc86a1dbb816d925de5695f7e0cf7bc7b4b814
 SHA512:
-  metadata.gz: 3e1296d2329496e118ef1d01a6e8cb198b114a6b9633fb78ee595fc64eedc537321ba546c713ae2f17e23bd4295cdf44a2f73500746c3985f94c235d31c5fb96
-  data.tar.gz: 6dbafc5fb71f17e5f6409fee5182c8a85f1f262378e0aeddd47482883f4376f55e64e5ca42e07634730e41df9d551845c6a17e4393d7689de13a9bf0f22dd30e
+  metadata.gz: 9d8e89bc085fdd6383608941e1b00d6a9aab78bbd677d7b9f8392417be71754148879a9260627865b829a096531ee2dbb6452df03b55b90a9480b953d1286e47
+  data.tar.gz: c43e1fd2180a7202f3c59acf224d0ff5dd190feebe23cb05efc02e5d6690329511c44e1ac984a6c2382cdcca58086097b56307c55d95a03b2616c54001bdaa39

data/.github/workflows/workflow.yml

@@ -0,0 +1,35 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/.rubocop.yml

@@ -1,3 +1,6 @@
+inherit_mode:
+  merge:
+    - Exclude
 AllCops:
   SuggestExtensions: false
   Exclude:
@@ -5,9 +8,7 @@ AllCops:
     - 'bin/**/*'
 Style/Documentation:
   Enabled: false
-Style/HashEachMethods:
+Style/MissingRespondToMissing:
   Enabled: false
-Lint/MissingSuper:
+Naming/MethodParameterName:
   Enabled: false
-Lint/UriEscapeUnescape:
-  Enabled: false

data/.travis.yml

@@ -10,6 +10,7 @@ before_script:
   - ./cc-test-reporter before-build
   - gem install bundler:2.1.4
 script:
+  - bundle exec rubocop
   - bundle exec rspec
 after_script:
   - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    postgrest (0.2.0)
+    postgrest (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -3,10 +3,10 @@
 ## Status
 
 [![Build Status](https://api.travis-ci.com/marcelobarreto/postgrest-rb.svg?branch=master)](https://travis-ci.com/marcelobarreto/postgrest-rb)
-[![Code Climate](https://codeclimate.com/github/marcelobarreto/postgrest-rb.svg)](https://codeclimate.com/github/marcelobareto/postgrest-rb)
+[![Code Climate](https://codeclimate.com/github/marcelobarreto/postgrest-rb.svg)](https://codeclimate.com/github/marcelobarreto/postgrest-rb)
 [![Code Climate](https://codeclimate.com/github/marcelobarreto/postgrest-rb/coverage.svg)](https://codeclimate.com/github/marcelobarreto/postgrest-rb)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
-[![RubyGems](http://img.shields.io/gem/dt/postgrest.svg?style=flat)](http://rubygems.org/gems/postgrest)
+[![RubyGems](https://img.shields.io/gem/dt/postgrest.svg?style=flat)](https://rubygems.org/gems/postgrest)
 
 Ruby client for [PostgREST](https://postgrest.org/)
 
@@ -41,51 +41,105 @@ db = Postgrest::Client.new(url: url, headers: headers, schema: schema)
 ```ruby
 # Basic select
 
-db.from('todos').select('*')
+db.from('todos').select('*').execute
+# or just db.from('todos').select
 
-<Postgrest::Response:0x0000556745caa420
-  @body={:select=>"*"},
-  @count=1,
-  @data=[{"id"=>1, "title"=>"Go to the gym", "completed"=>false}],
-  @error=true,
-  @status=200,
-  @status_text="OK">
+#<Postgrest::Responses::GetResponse GET OK data=[{"id"=>1, "title"=>"foo", "completed"=>false}, {"id"=>2, "title"=>"foo", "completed"=>false}]>
 
 # Selecting just one or more fields
+db.from('todos').select(:title).execute
 
-db.from('todos').select('title, completed')
+#<Postgrest::Responses::GetResponse GET OK data=[{"title"=>"foo"}, {"title"=>"foo"}]>
+
+```
+
+#### Renaming a column name
+
+You have the ability to alias the name of the column you want doing as follows:
+
+```ruby
+db.from('todos').select('name:title').eq(id: 112).execute
+#<Postgrest::Responses::GetResponse GET OK data=[{"name"=>"Go to the gym"}]>
+```
+
+### Querying
+
+```ruby
+db.from('todos').select('*').eq(id: 100).execute
+#<Postgrest::Responses::GetResponse GET OK data=[{"id" => 100, "title"=>"foo", "completed" => true}}]>
 
-<Postgrest::Response:0x0000556745590770
-  @body={:select=>"title, completed"},
-  @count=1,
-  @data=[{"title"=>"Go to the gym", "completed"=>false}],
-  @error=true,
-  @status=200,
-  @status_text="OK">
 
+db.from('todos').select('*').neq(id: 100).execute
+#<Postgrest::Responses::GetResponse GET OK data=[{"id" => 101, "title"=>"foo", "completed" => true}}]>
+```
+
+### Ordering
+
+TODO
+
+### Relationships
+
+TODO
+
+### Full query example
+
+```ruby
+db.from('todos').select(:id, :title).owners(:name, as: :owner).workers(:name, as: :worker).in(id: [112, 113]).order(id: :asc).execute
+
+#<Postgrest::Responses::GetResponse GET OK data=[{"id"=>112, "title"=>"Eat something", "owner"=>{"name"=>"Marcelo"}, "worker"=>{"name"=>"Marcelo"}}, {"id"=>113, "title"=>"Go to the gym", "owner"=>{"name"=>"Marcelo"}, "worker"=>nil}]>
 ```
 
 ### Inserting
 
 ```ruby
-db.from('todos').insert({ title: 'Go to the gym', completed: false })
+db.from('todos').insert(title: 'Go to the gym', completed: false).execute
+
+#<Postgrest::Responses::PostResponse POST Created data=[{"id"=>1, "title"=>"Go to the gym", "completed"=>false}]>
 
-<Postgrest::Response:0x00005567458aebf0 @body={:title=>"Go to the gym", :completed=>false}, @count=nil, @data="", @error=false, @status=201, @status_text="Created">
+db.from('todos').upsert(id: 1, title: 'Ok, I wont go to the gym', completed: true).execute
+
+#<Postgrest::Responses::PostResponse POST Created data=[{"id"=>1, "title"=>"Ok, I wont go to the gym", "completed"=>true}]>
 
 # Inserting multiple rows at once
 db.from('todos').insert([
   { title: 'Go to the gym', completed: false },
   { title: 'Walk in the park', completed: true },
-])
+]).execute
+
+#<Postgrest::Responses::PostResponse POST Created data=[{"id"=>110, "title"=>"Go to the gym", "completed"=>false}, {"id"=>111, "title"=>"Walk in the park", "completed"=>true}]>
+
+```
+
+### Updating
+
+```ruby
+
+# Query before update
+
+db.from('todos').update(title: 'foobar').eq(id: 109).execute
+
+#<Postgrest::Responses::PatchResponse PATCH OK data=[{"id"=>106, "title"=>"foo", "completed"=>false}]>
+
+# Update all rows
+
+db.from('todos').update(title: 'foobar').execute
+
+#<Postgrest::Responses::PatchResponse PATCH OK data=[{"id"=>107, "title"=>"foobar", "completed"=>false}, {"id"=>1, "title"=>"foobar", "completed"=>true}, {"id"=>110, "title"=>"foobar", "completed"=>false}, {"id"=>111, "title"=>"foobar", "completed"=>true}, {"id"=>106, "title"=>"foobar", "completed"=>false}]>
+```
+
+### Deleting
+
+```ruby
+# Querying before delete
+
+db.from('todos').delete.eq(id: 109).execute
+#<Postgrest::Responses::DeleteResponse DELETE OK data=[{"id"=>109, "title"=>"Go to the gym", "completed"=>false}]>
+
+# OR deleting everything
 
-<Postgrest::Response:0x0000556745cdd118
-  @body=[{:title=>"Go to the gym", :completed=>false}, {:title=>"Walk in the park", :completed=>true}],
-  @count=nil,
-  @data="",
-  @error=true,
-  @status=201,
-  @status_text="Created">
+db.from('todos').delete.execute
 
+#<Postgrest::Responses::DeleteResponse DELETE OK data=[{"id"=>110, "title"=>"Go to the gym", "completed"=>false}, {"id"=>111, "title"=>"Go to the gym", "completed"=>false}]>
 ```
 
 ## Development

data/lib/postgrest.rb

@@ -1,13 +1,30 @@
 # frozen_string_literal: true
 
+require 'net/http'
+require 'json'
+require 'cgi'
+
 require 'postgrest/version'
+
+# Builders
+require 'postgrest/builders/base_builder'
+require 'postgrest/builders/query_builder'
+require 'postgrest/builders/filter_builder'
+
+# Responses
+require 'postgrest/responses/base_response'
+require 'postgrest/responses/get_response'
+require 'postgrest/responses/post_response'
+require 'postgrest/responses/patch_response'
+require 'postgrest/responses/delete_response'
+
 require 'postgrest/http'
 require 'postgrest/client'
-require 'postgrest/query_builder'
-require 'postgrest/response'
 
 module Postgrest
   class MissingTableError < StandardError; end
 
+  class InvalidHTTPMethod < ArgumentError; end
+
   class RequestError < StandardError; end
 end

data/lib/postgrest/builders/base_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Postgrest
+  module Builders
+    class BaseBuilder
+      def self.before_execute_hooks
+        @before_execute ||= []
+        @before_execute
+      end
+
+      def self.before_execute(*values)
+        @before_execute = values
+      end
+
+      attr_reader :http
+
+      def initialize(http)
+        @http = http
+      end
+
+      def call
+        self.class.before_execute_hooks.each { |method_name| send(method_name) }
+
+        http.call
+      end
+      alias execute call
+    end
+  end
+end

data/lib/postgrest/builders/filter_builder.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Postgrest
+  module Builders
+    class FilterBuilder < BaseBuilder
+      before_execute :set_limit, :set_offset, :update_http_instance
+
+      SIMPLE_MATCHERS = %i[eq neq gt gte lt lte like is ilike fts plfts phfts wfts].freeze
+      RANGE_MATCHERS = %i[sl sr nxr nxl adj].freeze
+
+      def initialize(http)
+        super
+        @inverse_next = false
+      end
+
+      SIMPLE_MATCHERS.each do |method_name|
+        define_method(method_name) do |values|
+          transform_params(method_name: method_name, values: values)
+
+          self
+        end
+      end
+
+      RANGE_MATCHERS.each do |method_name|
+        define_method(method_name) do |values|
+          transform_params(method_name: method_name, values: values) do |key, value|
+            [key, "range=#{method_key(method_name)}.(#{value.join(',')})"]
+          end
+
+          self
+        end
+      end
+
+      def in(values = [])
+        transform_params(method_name: __method__, values: values) do |key, value|
+          [key, "#{method_key(__method__)}.(#{value.join(',')})"]
+        end
+
+        self
+      end
+
+      def order(values)
+        transform_params(method_name: __method__, values: values) do |key, value|
+          asc = value.to_sym != :desc
+          asc = !asc if should_invert?
+
+          [__method__, "#{key}.#{asc ? 'asc' : 'desc'}"]
+        end
+
+        self
+      end
+
+      def method_missing(method_name, *columns, as: nil)
+        decoded_query['select'] += as ? ",#{as}:#{method_name}" : ",#{method_name}"
+        decoded_query['select'] += columns.empty? ? '(*)' : "(#{columns.join(',')})"
+
+        self
+      end
+
+      def query
+        http.uri.query
+      end
+
+      def decoded_query
+        @decoded_query ||= URI.decode_www_form(query).to_h
+      end
+
+      def limit(number = 0)
+        decoded_query['limit'] = number
+        self
+      end
+
+      def offset(number = 0)
+        decoded_query['offset'] = number
+        self
+      end
+
+      def not
+        @inverse_next = !@inverse_next
+        self
+      end
+
+      private
+
+      def should_invert?
+        @inverse_next
+      end
+
+      def transform_params(values:, method_name:)
+        values.each do |k, v|
+          key, value = yield(k, v) if block_given?
+          key ||= k
+          value ||= "#{method_key(method_name)}.#{v}"
+
+          decoded_query[key.to_s] = value
+        end
+
+        @inverse_next = false
+      end
+
+      def method_key(name)
+        should_invert? ? "not.#{name}" : name
+      end
+
+      # Before execute callback
+      def update_http_instance
+        http.update_query_params(decoded_query)
+      end
+    end
+  end
+end

data/lib/postgrest/builders/query_builder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Postgrest
+  module Builders
+    class QueryBuilder
+      attr_reader :uri, :headers, :schema
+
+      def initialize(url:, headers:, schema:)
+        @uri = URI(url)
+        @headers = headers
+        @schema = schema
+      end
+
+      def select(*columns, extra_headers: {})
+        columns.compact!
+        columns = ['*'] if columns.length.zero?
+        request = HTTP.new(uri: uri, query: { select: columns.join(',') }, headers: headers.merge(extra_headers))
+
+        FilterBuilder.new(request)
+      end
+
+      def insert(values)
+        upsert(values, extra_headers: { Prefer: 'return=representation' })
+      end
+
+      def upsert(values, extra_headers: {})
+        extra_headers[:Prefer] ||= 'return=representation,resolution=merge-duplicates'
+        request = HTTP.new(uri: uri, body: values, http_method: :post, headers: headers.merge(extra_headers))
+
+        BaseBuilder.new(request)
+      end
+
+      def update(values, extra_headers: {})
+        extra_headers[:Prefer] ||= 'return=representation'
+        request = HTTP.new(uri: uri, body: values, http_method: :patch, headers: headers.merge(extra_headers))
+
+        FilterBuilder.new(request)
+      end
+
+      def delete(extra_headers: {})
+        extra_headers[:Prefer] ||= 'return=representation'
+        request = HTTP.new(uri: uri, http_method: :delete, headers: headers.merge(extra_headers))
+
+        FilterBuilder.new(request)
+      end
+    end
+  end
+end

data/lib/postgrest/client.rb

@@ -15,7 +15,7 @@ module Postgrest
     def from(table)
       raise MissingTableError if table.nil? || table.empty?
 
-      Postgrest::QueryBuilder.new(url: "#{@url}/#{table}", headers: headers, schema: schema)
+      Builders::QueryBuilder.new(url: "#{url}/#{table}", headers: headers, schema: schema)
     end
   end
 end

data/lib/postgrest/http.rb

@@ -1,87 +1,84 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'json'
-
 module Postgrest
   class HTTP
-    class << self
-      def set_request_headers(request, headers = {})
-        headers.each do |key, value|
-          request[key] = value
-        end
-
-        request['Content-Type'] = 'application/json'
-
-        # count?: null | 'exact' | 'planned' | 'estimated'
-        # returning?: 'minimal' | 'representation'
-
-        prefer = ['return=representation', 'resolution=merge-duplicates', 'count=exact']
-        request['Prefer'] = prefer.join(',')
+    METHODS = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post,
+      patch: Net::HTTP::Patch,
+      put: Net::HTTP::Patch,
+      delete: Net::HTTP::Delete
+    }.freeze
+
+    RESPONSES = {
+      get: Responses::GetResponse,
+      post: Responses::PostResponse,
+      put: Responses::PatchResponse,
+      patch: Responses::PatchResponse,
+      delete: Responses::DeleteResponse,
+      options: Responses::GetResponse # ?
+    }.freeze
+
+    USER_AGENT = 'PostgREST Ruby Client'
+
+    attr_reader :request, :response, :query, :body, :headers, :http_method, :uri
+
+    def initialize(uri:, query: {}, body: {}, headers: {}, http_method: :get)
+      @uri = uri
+      @body = body
+      @headers = headers
+      @http_method = http_method.to_sym
+      @response = nil
+      @request = nil
+      uri.query = decode_query_params(query)
+    end
 
-        nil
-      end
+    def update_query_params(new_value = {})
+      @uri.query = decode_query_params(new_value)
+    rescue NoMethodError
+      @uri.query
+    end
 
-      def get(uri:, query: {}, headers: {})
-        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
-          uri.query = URI.encode_www_form(query)
-          req = Net::HTTP::Get.new(uri)
-          set_request_headers(req, headers)
-          http.request(req)
-        end
+    def call
+      raise InvalidHTTPMethod unless valid_http_method?
 
-        get_response(response: response, body: query)
+      @response = Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl?) do |http|
+        @request = create_request
+        http.request(request)
       end
 
-      def post(uri:, body: {}, headers: {})
-        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
-          req = Net::HTTP::Post.new(uri)
-          req.body = body.to_json
-          req.content_type = 'application/json'
-          set_request_headers(req, headers)
-          http.request(req)
-        end
+      RESPONSES[http_method].new(request, response)
+    end
+    alias execute call
 
-        post_response(response: response, body: body)
-      end
+    private
 
-      private
+    def decode_query_params(query_params)
+      CGI.unescape(URI.encode_www_form(query_params))
+    end
 
-      def response_is_successful?(response)
-        response.class.ancestors.include?(Net::HTTPSuccess)
-      end
+    def create_request
+      request = METHODS[http_method].new(uri)
+      request.body = body.to_json
+      request.content_type = 'application/json'
+      add_headers(request)
 
-      def parse_post_response(response)
-        return unless response_is_successful?(response)
+      request
+    end
 
-        body = response.body.empty? ? '{}' : response.body
+    def use_ssl?
+      uri.scheme == 'https'
+    end
 
-        JSON.parse(body)
-      end
+    def add_headers(request)
+      headers.each { |key, value| request[key] = value }
+      request['User-Agent'] = USER_AGENT
 
-      def get_response(response:, body:)
-        data = response_is_successful?(response) ? JSON.parse(response.body) : []
-
-        Response.new({
-                       error: !response_is_successful?(response),
-                       data: data,
-                       count: data.count,
-                       status: response.code.to_i,
-                       status_text: response.message,
-                       body: body
-                     })
-      end
+      nil
+    end
 
-      def post_response(response:, body:)
-        Response.new({
-                       error: !response_is_successful?(response),
-                       data: parse_post_response(response),
-                       count: nil,
-                       status: response.code.to_i,
-                       status_text: response.message,
-                       body: body
-                     })
-      end
+    def valid_http_method?
+      METHODS.keys.include?(http_method)
     end
   end
 end

data/lib/postgrest/responses/base_response.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Postgrest
+  module Responses
+    class BaseResponse
+      attr_reader :request, :response
+
+      def initialize(request, response)
+        @request = request
+        @response = response
+        @data = data
+      end
+
+      def inspect
+        "\#<#{self.class} #{request.method} #{response.message} data=#{@data}>"
+      end
+
+      def error
+        !response.is_a?(Net::HTTPSuccess)
+      end
+
+      def count
+        data.count
+      end
+
+      def status
+        response.code.to_i
+      end
+
+      def status_text
+        response.message
+      end
+
+      def data
+        error ? [] : safe_json_parse(response.body)
+      end
+      alias as_json data
+
+      def params
+        {
+          query: request.uri.query,
+          body: safe_json_parse(request.body)
+        }
+      end
+
+      private
+
+      def safe_json_parse(json)
+        JSON.parse(json)
+      rescue TypeError, JSON::ParserError
+        {}
+      end
+    end
+  end
+end

data/lib/postgrest/responses/delete_response.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Postgrest
+  module Responses
+    class DeleteResponse < BaseResponse
+    end
+  end
+end

data/lib/postgrest/responses/get_response.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Postgrest
+  module Responses
+    class GetResponse < BaseResponse
+    end
+  end
+end

data/lib/postgrest/responses/patch_response.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Postgrest
+  module Responses
+    class PatchResponse < BaseResponse
+    end
+  end
+end

data/lib/postgrest/responses/post_response.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Postgrest
+  module Responses
+    class PostResponse < BaseResponse
+    end
+  end
+end

data/lib/postgrest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Postgrest
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: postgrest
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Marcelo Barreto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-04 00:00:00.000000000 Z
+date: 2021-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -74,6 +74,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".codeclimate.yml"
+- ".github/workflows/workflow.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -86,10 +87,16 @@ files:
 - bin/console
 - bin/setup
 - lib/postgrest.rb
+- lib/postgrest/builders/base_builder.rb
+- lib/postgrest/builders/filter_builder.rb
+- lib/postgrest/builders/query_builder.rb
 - lib/postgrest/client.rb
 - lib/postgrest/http.rb
-- lib/postgrest/query_builder.rb
-- lib/postgrest/response.rb
+- lib/postgrest/responses/base_response.rb
+- lib/postgrest/responses/delete_response.rb
+- lib/postgrest/responses/get_response.rb
+- lib/postgrest/responses/patch_response.rb
+- lib/postgrest/responses/post_response.rb
 - lib/postgrest/version.rb
 - postgrest.gemspec
 homepage: https://github.com/marcelobarreto/postgrest-rb
@@ -113,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby client for PostgREST

data/lib/postgrest/query_builder.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Postgrest
-  class QueryBuilder
-    attr_accessor :uri, :headers, :schema
-
-    def initialize(url:, headers:, schema:)
-      @uri = URI(url)
-      @headers = headers
-      @schema = schema
-    end
-
-    def select(columns = '*', options = {})
-      # @client.from('todos').select('*', { id: 'gt.35' })
-
-      Postgrest::HTTP.get(uri: uri, query: { select: columns }.merge(options), headers: headers)
-    end
-
-    def insert(values)
-      Postgrest::HTTP.post(uri: uri, body: values, headers: headers)
-    end
-
-    def update(values); end
-
-    def match(values); end
-  end
-end

data/lib/postgrest/response.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Postgrest
-  class Response
-    attr_reader :error, :data, :count, :status, :status_text, :body
-
-    def initialize(params = {})
-      @error = params[:error]
-      @data = params[:data]
-      @count = params[:count]
-      @status = params[:status]
-      @status_text = params[:status_text]
-      @body = params[:body]
-    end
-  end
-end