pggraphql 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1e6b2c6fed6ff27d8df6c047a1a7a00da92d82b
-  data.tar.gz: fae12d3c2d83579341ca9d9703bef24c89db4808
+  metadata.gz: 6b77f4fa17f6d73f558fa894e56b662a4226c5ea
+  data.tar.gz: 66fcd016a628c740e127968d054dd0bbeec29ce3
 SHA512:
-  metadata.gz: fee51a6659a3b61afb46cb3f435450214c1b7a878dc625362b8a1f0196e1e14a7f1d402f1a458fe9625279518bdf4aef6ff45e30287a431c15e96d75c769b571
-  data.tar.gz: e8bd53a6028edf19f10a4db5524cc03a2f3fcef3acf027260abb0e97b49b8cbc02956b7dd5bf41ed17ced8bbe325b4bc5fdd8633beb1fe0a22e71c2d6681fc96
+  metadata.gz: 52e5bdbdd564c508160e4688e87b66ef9e3fa9cb74fe9d21c977ca2ff9436fcb25c5e94768b346ffe4540b71a61e500ca50c17a4358f12e66e5e3587aaf39746
+  data.tar.gz: 437d33d4175c3ac772eae462e65d3ec08156a266f30f479264a47cfdc3e1303aa6efbf80aef8a62ad6fbb8edb31886c5da1bb71fbe9df1379d2ecc0890f5f5c1

data/.gitignore

@@ -32,3 +32,4 @@ build/
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+.DS_Store

data/lib/pggraphql/version.rb

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

data/lib/pggraphql.rb

@@ -1,126 +1,146 @@
-require "json"
 require "active_support/all"
 require "pggraphql/version"
 
 module PgGraphQl
 
   class Schema
-    attr_accessor :roots
-
+    attr_reader :types, :roots
     def initialize
-      @roots = {}
       @types = {}
+      @roots = []
       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
+      @roots = @roots.map{|r| @types[r]}
     end
 
-    def root(name, opts={})
-      opts[:type] = name.to_s.singularize.to_sym unless opts[:type]
-      @roots[name] = opts
+    def root(name)
+      @roots << name
     end
 
-    def type(name, opts={}, &block)
-      opts[:block] = block
-      @types[name] = opts
+    def type(name, opts={})
+      type = @types[name] = Type.new(self, name)
+      opts.each_pair{|key, val| type.send(:"#{key}=", val) }
+      yield(type) if block_given?
     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}
+    def to_sql(query, level=0, parent=nil, link_name=nil)
+      if level > 0
+        query.map do |e|
+          link = parent ? parent.links[link_name] : nil
+          type = link ? link.type : self.types[e[0].to_s.singularize.to_sym]
+          ids = e[1][:id]
 
-      sql = requested_type.sql
+          columns = e[1].map do |f|
+            column_name = f[0]
 
-      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
+            raise "unknown field #{column_name.inspect} on type #{type.name.inspect}" if !f[1].is_a?(Hash) && !type.fields.include?(column_name)
+            raise "unknown link #{column_name.inspect} on type #{type.name.inspect}" if f[1].is_a?(Hash) && !type.links.include?(column_name)
 
-      requested_columns = query[1..-1].map do |field|
+            (f[1].is_a?(Hash) ? "(" + to_sql([f].to_h, level + 1, type, column_name) + ") as #{column_name}" : column_name.to_s)
+          end.join(",")
 
-        if field.is_a?(Symbol)
-          raise "unknown field" unless requested_type.fields.include?(field)
-          field.to_s
-        elsif field.is_a?(Array)
+          is_many = (link && link.many?) || !ids || ids.is_a?(Array)
+          order_by = link.try(:order_by) || type.try(:order_by)
 
-          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]]
+          wheres = []
 
-          requested_link_query = field.each_with_index.map do |e2, idx|
-            idx == 0 ? [requested_link_type.name, requested_link_ids] : e2
+          if ids && ids.to_s != "id"
+            if ids.is_a?(Array)
+              wheres << "id in (#{ids.join(',')})" unless ids.empty?
+            else
+              wheres << "id = #{ids}"
+            end
           end
 
-          "(" + self.query(requested_link_query, level + 1, requested_link, requested_type) + ") as #{requested_link_field}"
-        else
-          raise "unsupported"
-        end
+          wheres << ("(" + type.filter + ")") if type.filter
 
-      end
+          if link
+            wheres << if link.invert
+              "id = #{parent.table}.#{link.fk}"
+            else
+              "#{link.fk} = #{parent.table}.id"
+            end
 
-      is_many = parent_type && parent_type.links[parent_link[:name]][0] == :many
+            wheres << ("(" + link.filter + ")") if link.filter
+          end
 
-      inner_sql = sql.gsub("*", requested_columns.join(", "))
+          sql = "select to_json("
+          sql += "coalesce(json_agg(" if is_many
+          sql += "x.*"
+          sql += "), '[]'::json)" if is_many
+          sql += ") from (select #{columns} from #{type.table}"
+          sql += " where #{wheres.join(' and ')}" unless wheres.empty?
+          sql += " order by #{order_by}" if order_by
+          sql += " limit 1" if !is_many
+          sql += ") x"
+
+        end.join
+      else
+        wrap_root(query.map do |e|
+          sql = to_sql([e].to_h, 1)
+          "select '#{e[0]}'::text as key, (#{sql}) as value"
+        end.join("\nunion all\n"))
+      end
+    end
 
-      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
+    def wrap_root(sql)
+      "select ('{'||string_agg(to_json(t1.key)||':'||coalesce(to_json(t1.value), 'null'), ',')||'}')::json res from (\n" + sql + ") t1"
+    end
 
-      unless where_conditions.empty?
-        inner_sql += " where"
-        inner_sql += where_conditions.join(" and ")
+    class Type
+      attr_accessor :name, :table, :filter, :links, :order_by, :fields
+      attr_reader :schema
+      def initialize(schema, name)
+        @schema = schema
+        @name = name
+        @table = name.to_s.pluralize.to_sym
+        @fields = [:id]
+        @filter = nil
+        @order_by = nil
+        @links = {}
       end
+      def one(name, opts={})
+        create_link(name, false, opts)
+      end
+      def many(name, opts={})
+        create_link(name, true, opts)
+      end
+      def create_link(name, many, opts)
+        link = @links[name] = Link.new(self, name, many)
+        opts.each_pair do |key, val| 
+          link.send(:"#{key}=", val)
+        end
+        link
+      end
+    end
 
-      inner_sql += (is_many ? "" : " limit 1")
-
-      "select to_json(" + (is_many ? "coalesce(json_agg(x.*), '[]'::json)" : "x.*" ) + ") res from (#{inner_sql}) x"
+    class Link
+      attr_accessor :name, :invert, :filter, :order_by
+      def initialize(owner, name, many)
+        @owner = owner
+        @name = name
+        @many = many
+        @invert = false
+        @order_by = nil
+      end
+      def fk=(_fk)
+        @_fk = fk
+      end
+      def fk
+        @invert ? "#{@name.to_s.singularize}_id" : "#{@owner.name}_id"
+      end
+      def type=(_type)
+        @_type = _type
+      end
+      def type
+        @owner.schema.types[@_type||@name.to_s.singularize.to_sym]
+      end
+      def many?
+        !!@many
+      end
     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/test/test_pggraphql.rb

@@ -9,154 +9,491 @@ module PgGraphQl
       sql.strip.split(" ").map{|e| e.strip}.reject{|e| e.empty?}
     end
 
-    def query(*args, &block)
-      Schema.new(&block).query(*args)
+    def to_sql(query, print_sql=nil, &block)
+      s = Schema.new(&block)
+      s.class.send(:define_method, :wrap_root) do |unwrapped_sql|
+        unwrapped_sql
+      end
+      
+      sql = s.to_sql(query)
+      puts sql if print_sql
+      sql
     end
 
-    # schema
+    def test_simple
+      res = to_sql({user: {id: 1, email: "email"}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email]
+      end
 
-    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]
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email
+                from users
+                where id = 1 limit 1) x) as value      
+      SQL
+      ), token(res)
     end
 
-    # type
+    def test_simple_pk_array_empty
+      res = to_sql({user: {id: [], email: "email"}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email]
+      end
 
-    def test_pk_prefixed_by_as
-      assert_equal :"sometypes.id", Type.new(:sometype).pk!
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(coalesce(json_agg(x.*), '[]'::json))
+            from (select id,
+                  email
+                from users) x) as value      
+      SQL
+      ), token(res)
     end
 
-    # type - defaults
+    def test_simple_pk_array_one
+      res = to_sql({user: {id: [1], email: "email"}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email]
+      end
 
-    def test_type_default_fields
-      assert_equal [:id], Type.new(:sometype).fields
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(coalesce(json_agg(x.*), '[]'::json))
+            from (select id,
+                  email
+                from users where id in (1)) x) as value      
+      SQL
+      ), token(res)
     end
 
-    def test_type_default_as
-      assert_equal :sometypes, Type.new(:sometype).as
-      assert_equal :people, Type.new(:person).as
-    end
+    def test_simple_pk_array_multiple
+      res = to_sql({user: {id: [1,2], email: "email"}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email]
+      end
 
-    def test_type_default_sql
-      assert_equal "select * from houses", Type.new(:house).sql
-      assert_equal "select * from people", Type.new(:person).sql
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(coalesce(json_agg(x.*), '[]'::json))
+            from (select id,
+                  email
+                from users where id in (1,2)) x) as value      
+      SQL
+      ), token(res)
     end
 
-    def test_type_default_pk
-      assert_equal :id, Type.new(:sometype).pk
+    def test_simple_filter
+      res = to_sql({user: {id: 1, email: "email"}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email], filter: "id > 100"
+      end
+
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email
+                from users
+                where id = 1 and (id > 100) limit 1) x) as value      
+      SQL
+      ), token(res)
     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]
+    def test_simple_multiple
+      res = to_sql({user: {id: 1, email: "email"}, educator: {id: "id"}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email]
+        s.type :educator
+      end
+
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email
+                from users
+                where id = 1 limit 1) x) as value
+        union all
+        select 'educator'::text as key,
+          (select to_json(x.*)
+            from (select id
+                from educators limit 1) x) as value
+      SQL
+      ), token(res)
     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]
+    #####################
+    # one
+    #####################
 
-      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]
+    def test_link_one
+      res = to_sql({user: {id: 1, email: "email", address: {id: "id"}}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email] do |t|
+          t.one :address
+        end
+        s.type :address
+      end
+
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email,
+                  (select to_json(x.*)
+                    from (select id
+                        from addresses
+                        where user_id = users.id limit 1) x) as address
+                from users
+                where id = 1 limit 1) x) as value
+      SQL
+      ), token(res)
     end
 
-    def test_unknown_field
-      assert_raise_message "unknown field" do
-        query([[:user, 1], :id, :name]) do |s|
-          s.root :user
-          s.type :user
+    def test_link_one_invert
+      res = to_sql({address: {id: 1, user: {id: "id", email: "email"}}}) do |s|
+        s.root :address
+        s.type :address do |t|
+          t.one :user, invert: true
         end
+        s.type :user, fields: [:id, :email] 
       end
+
+      assert_equal token(<<-SQL
+        select 'address'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  (select to_json(x.*)
+                    from (select id,
+                          email
+                        from users
+                        where id = addresses.user_id limit 1) x) as user
+                from addresses
+                where id = 1 limit 1) x) as value
+      SQL
+      ), token(res)
     end
 
-    def test_simple
-      res = query([[:user, 1], :id, :name]) do |s|
+    def test_link_one_filter
+      res = to_sql({user: {id: 1, email: "email", address: {id: "id"}}}) do |s|
         s.root :user
-        s.type :user, fields: [:id, :name]
+        s.type :user, fields: [:id, :email] do |t|
+          t.one :address, filter: "id > 100"
+        end
+        s.type :address
       end
 
-      assert_equal token("select to_json(x.*) res from (select id, name from users where id in (1) limit 1) x"), token(res)
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email,
+                  (select to_json(x.*)
+                    from (select id
+                        from addresses
+                        where user_id = users.id and (id > 100) limit 1) x) as address
+                from users
+                where id = 1 limit 1) x) as value
+      SQL
+      ), token(res)
     end
 
-    def test_simple_filter
-      res = query([[:user, 1], :id, :name]) do |s|
+    def test_link_one_order_by
+      res = to_sql({user: {id: 1, email: "email", address: {id: "id"}}}) do |s|
         s.root :user
-        s.type :user, fields: [:id, :name], filter: "id % 2 = 0"
+        s.type :user, fields: [:id, :email] do |t|
+          t.one :address, order_by: "id desc"
+        end
+        s.type :address
       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)
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email,
+                  (select to_json(x.*)
+                    from (select id
+                        from addresses
+                        where user_id = users.id order by id desc limit 1) x) as address
+                from users
+                where id = 1 limit 1) x) as value
+      SQL
+      ), token(res)
+    end
+
+    #####################
+    # one-in-one
+    #####################
 
-      res = query([[:user, 1], :id, :name]) do |s|
+    def test_link_one_in_one
+      res = to_sql({user: {id: 1, email: "email", address: {id: "id", country: {id: "id"}}}}) do |s|
         s.root :user
-        s.type :user, fields: [:id, :name], filter: "id % 2 = 0 and id > 10"
+        s.type :user, fields: [:id, :email] do |t|
+          t.one :address
+        end
+        s.type :address do |t|
+          t.one :country
+        end
+        s.type :country
       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)
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email,
+                  (select to_json(x.*)
+                    from (select id,
+                          (select to_json(x.*)
+                            from (select id
+                                from countries
+                                where address_id = addresses.id limit 1) x) as country
+                        from addresses
+                        where user_id = users.id limit 1) x) as address
+                from users
+                where id = 1 limit 1) x) as value
+      SQL
+      ), token(res)
     end
 
-    def test_one
-      res = query([[:user, 1], :id, [[:address], :id]]) do |s|
+    def test_link_one_in_one_invert
+      res = to_sql({user: {id: 1, email: "email", address: {id: "id", country: {id: "id"}}}}) do |s|
         s.root :user
-        s.type :user do |t|
+        s.type :user, fields: [:id, :email] do |t|
           t.one :address
         end
+        s.type :address do |t|
+          t.one :country, invert: true
+        end
+        s.type :country
+      end
+
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email,
+                  (select to_json(x.*)
+                    from (select id,
+                          (select to_json(x.*)
+                            from (select id
+                                from countries
+                                where id = addresses.country_id limit 1) x) as country
+                        from addresses
+                        where user_id = users.id limit 1) x) as address
+                from users
+                where id = 1 limit 1) x) as value
+      SQL
+      ), token(res)
+    end
+
+    #####################
+    # many
+    #####################
+
+
+    def test_link_many
+      res = to_sql({user: {id: 1, email: "email", address: {id: "id"}}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email] do |t|
+          t.many :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
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email,
+                  (select to_json(coalesce(json_agg(x.*), '[]'::json))
+                    from (select id
+                        from addresses
+                        where user_id = users.id) x) as address
+                from users
+                where id = 1 limit 1) x) as value
       SQL
+      ), token(res)
+    end
+
+    def test_link_many_invert
+      res = to_sql({address: {id: "id", users: {id: "id", email: "email"}}}) do |s|
+        s.root :address
+        s.type :address do |t|
+          t.many :users, invert: true
+        end
+        s.type :user, fields: [:id, :email]
+      end
 
-      assert_equal token(expected), token(res)
+      assert_equal token(<<-SQL
+        select 'address'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  (select to_json(coalesce(json_agg(x.*), '[]'::json))
+                    from (select id,
+                          email
+                        from users
+                        where id = addresses.user_id) x) as users
+                from addresses limit 1) x) as value
+      SQL
+      ), token(res)
     end
 
-    def test_one_fk_invert
-      res = query([[:user, 1], :id, [[:address], :id]]) do |s|
+    def test_link_many_filter
+      res = to_sql({user: {id: 1, email: "email", address: {id: "id"}}}) do |s|
         s.root :user
-        s.type :user do |t|
-          t.one :address, fk: :address_id, invert: true
+        s.type :user, fields: [:id, :email] do |t|
+          t.many :address, filter: "id % 2 = 0"
         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
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email,
+                  (select to_json(coalesce(json_agg(x.*), '[]'::json))
+                    from (select id
+                        from addresses
+                        where user_id = users.id and (id % 2 = 0)) x) as address
+                from users
+                where id = 1 limit 1) x) as value
       SQL
+      ), token(res)
+    end
 
-      assert_equal token(expected), token(res)
+    def test_link_many_order_by
+      res = to_sql({user: {id: 1, email: "email", address: {id: "id"}}}) do |s|
+        s.root :user
+        s.type :user, fields: [:id, :email] do |t|
+          t.many :address, order_by: "id desc"
+        end
+        s.type :address
+      end
+
+      assert_equal token(<<-SQL
+        select 'user'::text as key,
+          (select to_json(x.*)
+            from (select id,
+                  email,
+                  (select to_json(coalesce(json_agg(x.*), '[]'::json))
+                    from (select id
+                        from addresses
+                        where user_id = users.id order by id desc) x) as address
+                from users
+                where id = 1 limit 1) x) as value
+      SQL
+      ), token(res)
     end
 
-    # def test_one_polymorph
+
+    # # 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], Schema::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_object_query
+    #   res = query({user: [[: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
+    #   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, polymorph: [:primary, :secondary]
+    #       t.one :address
     #     end
     #     s.type :address
-    #     s.type :address_primary
-    #     s.type :address_secondary
     #   end
 
     #   expected = <<-SQL
@@ -165,11 +502,7 @@ module PgGraphQl
     #     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 
+    #         (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
@@ -179,168 +512,224 @@ module PgGraphQl
     #   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
+    # 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 user_id = users.id and is_default = true limit 1) x) as address 
-          from users 
-          where id in (1)
-          limit 1
-        ) x
-      SQL
+    #   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
+    #   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
+    # # 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 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
+    #   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
+    #   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
+    # 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,
-                (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
+    #   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
+    #   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
+    # 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(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
+    #   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
+    #   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
+    # 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 and id in (100)) x) as addresses 
-          from users 
-          where id in (1) limit 1
-        ) x
-      SQL
+    #   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
+    #   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
+    # 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,
-                (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
+    #   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
+    #   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

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pggraphql
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jan Zimmek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-05 00:00:00.000000000 Z
+date: 2015-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json