pggraphql 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d1e6b2c6fed6ff27d8df6c047a1a7a00da92d82b
+  data.tar.gz: fae12d3c2d83579341ca9d9703bef24c89db4808
+SHA512:
+  metadata.gz: fee51a6659a3b61afb46cb3f435450214c1b7a878dc625362b8a1f0196e1e14a7f1d402f1a458fe9625279518bdf4aef6ff45e30287a431c15e96d75c769b571
+  data.tar.gz: e8bd53a6028edf19f10a4db5524cc03a2f3fcef3acf027260abb0e97b49b8cbc02956b7dd5bf41ed17ced8bbe325b4bc5fdd8633beb1fe0a22e71c2d6681fc96

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pggraphql.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    pggraphql (0.0.1)
+      activesupport
+      json
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.0)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    i18n (0.7.0)
+    json (1.8.2)
+    minitest (5.5.1)
+    power_assert (0.2.2)
+    rake (10.4.2)
+    test-unit (3.0.8)
+      power_assert
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  pggraphql!
+  rake (~> 10.0)
+  test-unit

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jan Zimmek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jan Zimmek
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,2 @@
+# pg_graphql
+A data fetching library build on top of PostgreSQL inspired by Facebook's GraphQL

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+ 
+Rake::TestTask.new do |t|
+  t.libs << 'lib/pggraphql'
+  t.test_files = FileList['test/test_*.rb']
+  t.verbose = true
+end
+ 
+task :default => :test

data/lib/pggraphql/version.rb

@@ -0,0 +1,3 @@
+module Pggraphql
+  VERSION = "0.0.1"
+end

data/lib/pggraphql.rb

@@ -0,0 +1,126 @@
+require "json"
+require "active_support/all"
+require "pggraphql/version"
+
+module PgGraphQl
+
+  class Schema
+    attr_accessor :roots
+
+    def initialize
+      @roots = {}
+      @types = {}
+      yield(self) if block_given?
+
+      @types = @types.inject({}) do |memo, e|
+        t = memo[e[0]] = Type.new(e[0])
+
+        e[1].each_pair do |key, val|
+          t.send("#{key}=", val) unless key == :block
+        end
+
+        e[1][:block].call(t) if e[1][:block]
+        memo
+      end
+    end
+
+    def root(name, opts={})
+      opts[:type] = name.to_s.singularize.to_sym unless opts[:type]
+      @roots[name] = opts
+    end
+
+    def type(name, opts={}, &block)
+      opts[:block] = block
+      @types[name] = opts
+    end
+
+    def query(query, level=0, parent_link=nil, parent_type=nil)
+      requested_type = @types[query[0][0].to_sym]
+      requested_ids = query[0][1].is_a?(Array) ? query[0][1] : [query[0][1]].reject{|e| !e}
+
+      sql = requested_type.sql
+
+      where_conditions = []
+
+      if parent_link
+        if parent_link[:fk].is_a?(Symbol)        
+          where_conditions << (parent_link[:invert] ? " #{requested_type.pk} = #{parent_type.as}.#{parent_link[:fk]}" : " #{parent_link[:fk]} = #{parent_type.pk!}")
+        elsif parent_link[:fk].is_a?(Proc)
+          where_conditions << (" #{requested_type.pk} in (" + parent_link[:fk].call(parent_link) + ")")
+        else
+          raise "unsupported"
+        end
+
+        where_conditions << parent_link[:filter] if parent_link[:filter]
+      end
+
+      requested_columns = query[1..-1].map do |field|
+
+        if field.is_a?(Symbol)
+          raise "unknown field" unless requested_type.fields.include?(field)
+          field.to_s
+        elsif field.is_a?(Array)
+
+          requested_link_field = field[0][0]
+          requested_link = requested_type.links[requested_link_field][1]
+          requested_link_ids = field[0][1]
+          requested_link_type = @types[requested_link[:type]]
+
+          requested_link_query = field.each_with_index.map do |e2, idx|
+            idx == 0 ? [requested_link_type.name, requested_link_ids] : e2
+          end
+
+          "(" + self.query(requested_link_query, level + 1, requested_link, requested_type) + ") as #{requested_link_field}"
+        else
+          raise "unsupported"
+        end
+
+      end
+
+      is_many = parent_type && parent_type.links[parent_link[:name]][0] == :many
+
+      inner_sql = sql.gsub("*", requested_columns.join(", "))
+
+      where_conditions << " #{requested_type.pk} in (#{requested_ids.map(&:to_s).join(',')})" unless requested_ids.empty?
+      where_conditions << (" " + requested_type.filter) if requested_type.filter
+
+      unless where_conditions.empty?
+        inner_sql += " where"
+        inner_sql += where_conditions.join(" and ")
+      end
+
+      inner_sql += (is_many ? "" : " limit 1")
+
+      "select to_json(" + (is_many ? "coalesce(json_agg(x.*), '[]'::json)" : "x.*" ) + ") res from (#{inner_sql}) x"
+    end
+
+  end
+
+  class Type
+    attr_accessor :pk, :sql, :fields, :as, :filter
+    attr_reader :links, :name
+    def initialize(name)
+      @name = name
+      @links = {}
+      @fields = [:id]
+      @as = name.to_s.pluralize.to_sym
+      @sql = "select * from #{name.to_s.pluralize}"
+      @pk = :id
+    end
+    def pk!
+      :"#{@as}.#{@pk}"
+    end
+    def one(name, opts={})
+      opts[:fk] = :"#{@name}_id" unless opts[:fk]
+      opts[:type] = name.to_s.singularize.to_sym unless opts[:type]
+      opts[:name] = name
+      @links[name] = [:one, opts]
+    end
+    def many(name, opts={})
+      opts[:fk] = :"#{@name}_id" unless opts[:fk]
+      opts[:type] = name.to_s.singularize.to_sym unless opts[:type]
+      opts[:name] = name
+      @links[name] = [:many, opts]
+    end
+  end
+end

data/pggraphql.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pggraphql/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pggraphql"
+  spec.version       = Pggraphql::VERSION
+  spec.authors       = ["Jan Zimmek"]
+  spec.email         = ["jan.zimmek@web.de"]
+  spec.summary       = %q{PG GraphQL}
+  spec.description   = %q{A data fetching library build on top of PostgreSQL inspired by Facebook's GraphQL}
+  spec.homepage      = "https://github.com/jzimmek/pg_graphql"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "json"
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "test-unit"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/test/test_pggraphql.rb

@@ -0,0 +1,346 @@
+require "test-unit"
+require "pggraphql"
+
+module PgGraphQl
+  class PgGraphQlTest < ::Test::Unit::TestCase
+
+    def token(sql)
+      sql = sql.gsub(/\n/, " ").gsub("=", " = ").gsub(/,/, " , ").gsub("(", " ( ").gsub(")", " ) ").gsub(/[ ]+/, " ")
+      sql.strip.split(" ").map{|e| e.strip}.reject{|e| e.empty?}
+    end
+
+    def query(*args, &block)
+      Schema.new(&block).query(*args)
+    end
+
+    # schema
+
+    def test_schema_root_type
+      assert_equal :sometype, Schema.new{|e| e.root(:sometype)}.roots[:sometype][:type]
+      assert_equal :person, Schema.new{|e| e.root(:people)}.roots[:people][:type]
+    end
+
+    # type
+
+    def test_pk_prefixed_by_as
+      assert_equal :"sometypes.id", Type.new(:sometype).pk!
+    end
+
+    # type - defaults
+
+    def test_type_default_fields
+      assert_equal [:id], Type.new(:sometype).fields
+    end
+
+    def test_type_default_as
+      assert_equal :sometypes, Type.new(:sometype).as
+      assert_equal :people, Type.new(:person).as
+    end
+
+    def test_type_default_sql
+      assert_equal "select * from houses", Type.new(:house).sql
+      assert_equal "select * from people", Type.new(:person).sql
+    end
+
+    def test_type_default_pk
+      assert_equal :id, Type.new(:sometype).pk
+    end
+
+    def test_type_link_default_fk
+      assert_equal :sometype_id, Type.new(:sometype).tap{|e| e.one(:somelink) }.links[:somelink][1][:fk]
+      assert_equal :sometype_id, Type.new(:sometype).tap{|e| e.many(:somelink) }.links[:somelink][1][:fk]
+      assert_equal :other_fk, Type.new(:sometype).tap{|e| e.one(:somelink, fk: :other_fk) }.links[:somelink][1][:fk]
+      assert_equal :other_fk, Type.new(:sometype).tap{|e| e.many(:somelink, fk: :other_fk) }.links[:somelink][1][:fk]
+    end
+
+    def test_type_link_default_type
+      assert_equal :somelink, Type.new(:sometype).tap{|e| e.one(:somelink) }.links[:somelink][1][:type]
+      assert_equal :somelink, Type.new(:sometype).tap{|e| e.many(:somelink) }.links[:somelink][1][:type]
+
+      assert_equal :person, Type.new(:sometype).tap{|e| e.one(:people) }.links[:people][1][:type]
+      assert_equal :person, Type.new(:sometype).tap{|e| e.many(:people) }.links[:people][1][:type]
+
+      assert_equal :other_type, Type.new(:sometype).tap{|e| e.one(:somelink, type: :other_type) }.links[:somelink][1][:type]
+      assert_equal :other_type, Type.new(:sometype).tap{|e| e.many(:somelink, type: :other_type) }.links[:somelink][1][:type]
+    end
+
+    def test_unknown_field
+      assert_raise_message "unknown field" do
+        query([[:user, 1], :id, :name]) do |s|
+          s.root :user
+          s.type :user
+        end
+      end
+    end
+
+    def test_simple
+      res = query([[:user, 1], :id, :name]) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :name]
+      end
+
+      assert_equal token("select to_json(x.*) res from (select id, name from users where id in (1) limit 1) x"), token(res)
+    end
+
+    def test_simple_filter
+      res = query([[:user, 1], :id, :name]) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :name], filter: "id % 2 = 0"
+      end
+
+      assert_equal token("select to_json(x.*) res from (select id, name from users where id in (1) and id % 2 = 0 limit 1) x"), token(res)
+
+      res = query([[:user, 1], :id, :name]) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :name], filter: "id % 2 = 0 and id > 10"
+      end
+
+      assert_equal token("select to_json(x.*) res from (select id, name from users where id in (1) and id % 2 = 0 and id > 10 limit 1) x"), token(res)
+    end
+
+    def test_one
+      res = query([[:user, 1], :id, [[:address], :id]]) do |s|
+        s.root :user
+        s.type :user do |t|
+          t.one :address
+        end
+        s.type :address
+      end
+
+      expected = <<-SQL
+        select 
+          to_json(x.*) res 
+        from (
+          select 
+            id, 
+            (select to_json(x.*) res from (select id from addresses where user_id = users.id limit 1) x) as address 
+          from users 
+          where id in (1)
+          limit 1
+        ) x
+      SQL
+
+      assert_equal token(expected), token(res)
+    end
+
+    def test_one_fk_invert
+      res = query([[:user, 1], :id, [[:address], :id]]) do |s|
+        s.root :user
+        s.type :user do |t|
+          t.one :address, fk: :address_id, invert: true
+        end
+        s.type :address
+      end
+
+      expected = <<-SQL
+        select 
+          to_json(x.*) res 
+        from (
+          select 
+            id, 
+            (select to_json(x.*) res from (select id from addresses where id = users.address_id limit 1) x) as address 
+          from users 
+          where id in (1)
+          limit 1
+        ) x
+      SQL
+
+      assert_equal token(expected), token(res)
+    end
+
+    # def test_one_polymorph
+    #   res = query([[:user, 1], :id, [[:address], :id]]) do |s|
+    #     s.root :user
+    #     s.type :user do |t|
+    #       t.one :address, polymorph: [:primary, :secondary]
+    #     end
+    #     s.type :address
+    #     s.type :address_primary
+    #     s.type :address_secondary
+    #   end
+
+    #   expected = <<-SQL
+    #     select 
+    #       to_json(x.*) res 
+    #     from (
+    #       select 
+    #         id, 
+    #         (select to_json(x.*) res from (
+    #           select 'primary' as type, id from addresses join addresses_primary using (id) where user_id = users.id and addresses.type = 'primary'
+    #           union
+    #           select 'secondary' as type, id from addresses join addresses_secondary using (id) where user_id = users.id and addresses.type = 'secondary'
+    #         ) x) as address 
+    #       from users 
+    #       where id in (1)
+    #       limit 1
+    #     ) x
+    #   SQL
+
+    #   assert_equal token(expected), token(res)
+    # end
+
+    def test_one_filter
+      res = query([[:user, 1], :id, [[:address], :id]]) do |s|
+        s.root :user
+        s.type :user do |t|
+          t.one :address, filter: "is_default = true"
+        end
+        s.type :address
+      end
+
+      expected = <<-SQL
+        select 
+          to_json(x.*) res 
+        from (
+          select 
+            id, 
+            (select to_json(x.*) res from (select id from addresses where user_id = users.id and is_default = true limit 1) x) as address 
+          from users 
+          where id in (1)
+          limit 1
+        ) x
+      SQL
+
+      assert_equal token(expected), token(res)
+    end
+
+    def test_one_fk_through
+      res = query([[:user, 1], :id, [[:address], :id]]) do |s|
+        s.root :user
+        s.type :user do |t|
+          t.one :address, fk: ->(l) do
+            "select id from some_address_table where user_id = #{t.pk!}"
+          end
+        end
+        s.type :address
+      end
+
+      expected = <<-SQL
+        select 
+          to_json(x.*) res 
+        from (
+          select 
+            id, 
+            (select to_json(x.*) res from (select id from addresses where id in (select id from some_address_table where user_id = users.id) limit 1) x) as address 
+          from users 
+          where id in (1)
+          limit 1
+        ) x
+      SQL
+
+      assert_equal token(expected), token(res)
+    end
+
+    def test_one_in_one
+      res = query([[:user, 1], :id, [[:address], :id, [[:person], :id]]]) do |s|
+        s.root :user
+        s.type :user do |t|
+          t.one :address
+        end
+        s.type :address do |t|
+          t.one :person
+        end
+        s.type :person
+      end
+
+      expected = <<-SQL
+        select 
+          to_json(x.*) res 
+        from (
+          select 
+            id, 
+            (select to_json(x.*) res from (
+              select 
+                id,
+                (select to_json(x.*) res from (select id from people where address_id = addresses.id limit 1) x) as person
+              from addresses where user_id = users.id limit 1
+            ) x) as address 
+          from users 
+          where id in (1) 
+          limit 1
+        ) x
+      SQL
+
+      assert_equal token(expected), token(res)
+    end
+
+    def test_many
+      res = query([[:user, 1], :id, [[:addresses], :id]]) do |s|
+        s.root :user
+        s.type :user do |t|
+          t.many :addresses
+        end
+        s.type :address
+      end
+
+      expected = <<-SQL
+        select 
+          to_json(x.*) res 
+        from (
+          select id, 
+          (select to_json(coalesce(json_agg(x.*), '[]'::json)) res from (select id from addresses where user_id = users.id) x) as addresses 
+          from users 
+          where id in (1) limit 1
+        ) x
+      SQL
+
+      assert_equal token(expected), token(res)
+    end
+
+    def test_many_with_ids
+      res = query([[:user, 1], :id, [[:addresses, 100], :id]]) do |s|
+        s.root :user
+        s.type :user do |t|
+          t.many :addresses
+        end
+        s.type :address
+      end
+
+      expected = <<-SQL
+        select 
+          to_json(x.*) res 
+        from (
+          select id, 
+          (select to_json(coalesce(json_agg(x.*), '[]'::json)) res from (select id from addresses where user_id = users.id and id in (100)) x) as addresses 
+          from users 
+          where id in (1) limit 1
+        ) x
+      SQL
+
+      assert_equal token(expected), token(res)
+    end
+
+    def test_one_in_many
+      res = query([[:user, 1], :id, [[:addresses], :id, [[:person], :id]]]) do |s|
+        s.root :user
+        s.type :user do |t|
+          t.many :addresses
+        end
+        s.type :address do |t|
+          t.one :person
+        end
+        s.type :person
+      end
+
+      expected = <<-SQL
+        select 
+          to_json(x.*) res 
+        from (
+          select 
+            id, 
+            (select to_json(coalesce(json_agg(x.*), '[]'::json)) res from (
+              select 
+                id,
+                (select to_json(x.*) res from (select id from people where address_id = addresses.id limit 1) x) as person
+              from addresses where user_id = users.id
+            ) x) as addresses 
+          from users 
+          where id in (1) 
+          limit 1
+        ) x
+      SQL
+
+      assert_equal token(expected), token(res)
+    end
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: pggraphql
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jan Zimmek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: A data fetching library build on top of PostgreSQL inspired by Facebook's
+  GraphQL
+email:
+- jan.zimmek@web.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pggraphql.rb
+- lib/pggraphql/version.rb
+- pggraphql.gemspec
+- test/test_pggraphql.rb
+homepage: https://github.com/jzimmek/pg_graphql
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: PG GraphQL
+test_files:
+- test/test_pggraphql.rb