pggraphql 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b77f4fa17f6d73f558fa894e56b662a4226c5ea
-  data.tar.gz: 66fcd016a628c740e127968d054dd0bbeec29ce3
+  metadata.gz: 310b215ed3294f252ba1a2c446438e1ef2eb36b6
+  data.tar.gz: f9e4f9aa456475b48f65053cff6859018113d8a2
 SHA512:
-  metadata.gz: 52e5bdbdd564c508160e4688e87b66ef9e3fa9cb74fe9d21c977ca2ff9436fcb25c5e94768b346ffe4540b71a61e500ca50c17a4358f12e66e5e3587aaf39746
-  data.tar.gz: 437d33d4175c3ac772eae462e65d3ec08156a266f30f479264a47cfdc3e1303aa6efbf80aef8a62ad6fbb8edb31886c5da1bb71fbe9df1379d2ecc0890f5f5c1
+  metadata.gz: 9ea6027265481e57382bddd85d8cc1c737e8da6e31c9696802bc726ede7cd46e243dbea37b41087e9410cec981de57e32a6c8fdcae1b7aa1f9cca93cd5d7ca29
+  data.tar.gz: 52987c14f1c1427d0a242dbc3826c15815d387fa76617a566aedf161acdf2e40753df529b07590dd60b7edaf3869c6e66f14a819cb24c9448e28954019cc70e1

data/lib/pggraphql/version.rb

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

data/lib/pggraphql.rb

@@ -30,6 +30,8 @@ module PgGraphQl
           type = link ? link.type : self.types[e[0].to_s.singularize.to_sym]
           ids = e[1][:id]
 
+          raise "missing :fk on link #{link.name.inspect}" if link && !link.fk
+
           columns = e[1].map do |f|
             column_name = f[0]
 
@@ -55,12 +57,7 @@ module PgGraphQl
           wheres << ("(" + type.filter + ")") if type.filter
 
           if link
-            wheres << if link.invert
-              "id = #{parent.table}.#{link.fk}"
-            else
-              "#{link.fk} = #{parent.table}.id"
-            end
-
+            wheres << ("(" + link.fk + ")")
             wheres << ("(" + link.filter + ")") if link.filter
           end
 
@@ -115,20 +112,13 @@ module PgGraphQl
     end
 
     class Link
-      attr_accessor :name, :invert, :filter, :order_by
+      attr_accessor :name, :filter, :fk, :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

data/test/test_pggraphql.rb

@@ -125,16 +125,16 @@ module PgGraphQl
       ), token(res)
     end
 
-    #####################
-    # one
-    #####################
+    # #####################
+    # # one
+    # #####################
 
 
     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
+          t.one :address, fk: "id = users.address_id"
         end
         s.type :address
       end
@@ -147,42 +147,31 @@ module PgGraphQl
                   (select to_json(x.*)
                     from (select id
                         from addresses
-                        where user_id = users.id limit 1) x) as address
+                        where (id = users.address_id) limit 1) x) as address
                 from users
                 where id = 1 limit 1) x) as value
       SQL
       ), token(res)
     end
 
-    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
+    def test_link_one_missing_fk
+      assert_raise_message "missing :fk on link :address" do
+        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
-        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      
     end
 
-    def test_link_one_filter
+
+    def test_link_one_fk_sql
       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, filter: "id > 100"
+          t.one :address, fk: "id = (select 100)"
         end
         s.type :address
       end
@@ -195,18 +184,18 @@ module PgGraphQl
                   (select to_json(x.*)
                     from (select id
                         from addresses
-                        where user_id = users.id and (id > 100) limit 1) x) as address
+                        where (id = (select 100)) limit 1) x) as address
                 from users
                 where id = 1 limit 1) x) as value
       SQL
       ), token(res)
     end
 
-    def test_link_one_order_by
+    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, :email] do |t|
-          t.one :address, order_by: "id desc"
+          t.one :address, fk: "user_id = users.id", filter: "id > 100"
         end
         s.type :address
       end
@@ -219,27 +208,20 @@ module PgGraphQl
                   (select to_json(x.*)
                     from (select id
                         from addresses
-                        where user_id = users.id order by id desc limit 1) x) as address
+                        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
 
-    #####################
-    # one-in-one
-    #####################
-
-    def test_link_one_in_one
-      res = to_sql({user: {id: 1, email: "email", address: {id: "id", country: {id: "id"}}}}) 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, :email] do |t|
-          t.one :address
+          t.one :address, fk: "user_id = users.id", order_by: "id desc"
         end
-        s.type :address do |t|
-          t.one :country
-        end
-        s.type :country
+        s.type :address
       end
 
       assert_equal token(<<-SQL
@@ -248,27 +230,27 @@ module PgGraphQl
             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 (select id
                         from addresses
-                        where user_id = users.id limit 1) x) as address
+                        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
 
-    def test_link_one_in_one_invert
+    # #####################
+    # # one-in-one
+    # #####################
+
+    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, :email] do |t|
-          t.one :address
+          t.one :address, fk: "user_id = users.id"
         end
         s.type :address do |t|
-          t.one :country, invert: true
+          t.one :country, fk: "id = addresses.country_id"
         end
         s.type :country
       end
@@ -283,25 +265,25 @@ module PgGraphQl
                           (select to_json(x.*)
                             from (select id
                                 from countries
-                                where id = addresses.country_id limit 1) x) as country
+                                where (id = addresses.country_id) limit 1) x) as country
                         from addresses
-                        where user_id = users.id limit 1) x) as address
+                        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
-    #####################
+    # #####################
+    # # 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
+          t.many :address, fk: "user_id = users.id"
         end
         s.type :address
       end
@@ -314,41 +296,18 @@ module PgGraphQl
                   (select to_json(coalesce(json_agg(x.*), '[]'::json))
                     from (select id
                         from addresses
-                        where user_id = users.id) x) as address
+                        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(<<-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_link_many_filter
       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, filter: "id % 2 = 0"
+          t.many :address, fk: "user_id = users.id", filter: "id % 2 = 0"
         end
         s.type :address
       end
@@ -361,7 +320,7 @@ module PgGraphQl
                   (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
+                        where (user_id = users.id) and (id % 2 = 0)) x) as address
                 from users
                 where id = 1 limit 1) x) as value
       SQL
@@ -372,7 +331,7 @@ module PgGraphQl
       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"
+          t.many :address, fk: "user_id = users.id", order_by: "id desc"
         end
         s.type :address
       end
@@ -385,351 +344,12 @@ module PgGraphQl
                   (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
+                        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
 
-
-    # # 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
-    #     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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pggraphql
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jan Zimmek