hai 0.0.2 → 0.0.3

data/lib/hai/graphql/types.rb

@@ -5,7 +5,8 @@ require "hai/types/arel/datetime_input_type"
 module Hai
   module GraphQL
     module Types
-      module Arel; end
+      module Arel
+      end
       ALLOWED_TYPES = ::GraphQL::Types.constants - %i[Relay JSON]
 
       def self.included(base)
@@ -13,35 +14,109 @@ module Hai
       end
 
       module ClassMethods
-        def yasashii_type(model)
-          return if const_defined? "Types::#{model}Type"
+        def hai_types(*models)
+          base_types = models.map(&method(:define_base_type))
+          models.each do |model|
+            model.reflections.map(&method(:add_base_type_reflections))
+          end
+
+          models.map(&method(:define_input_object))
+          filter_types = models.map(&method(:define_filter_type))
+          models.each do |model|
+            model.reflections.map(&method(:add_filter_type_reflections))
+          end
+
+          filter_types.each do |filter_type|
+            filter_type.send(
+              :argument,
+              :or,
+              "[#{filter_type}]",
+              required: false
+            )
+          end
+        end
+
+        def name_for_base_type(model)
+          "Types::#{model}Type"
+        end
+
+        def define_base_type(model)
+          return if const_defined? name_for_base_type(model)
 
           klass = Class.new(::Types::BaseObject)
-          model.attribute_types.each do |attr, _type|
-            klass.send(:field, attr, ::GraphQL::Types::String)
+          model.attribute_types.each do |attr, type|
+            klass.send(:field, attr, Hai::GraphQL::TYPE_CAST[type.class])
+          rescue ArgumentError => e
+            binding.pry
           end
 
           ::Types.const_set "#{model}Type", klass
+        end
 
-          model.reflections.each do |name, ref|
-            yasashii_type(ref.klass)
-            if name == ref.plural_name
-              klass.send(:field, name, "[Types::#{ref.klass}Type]")
-            else
-              klass.send(:field, name, "Types::#{ref.klass}Type")
-            end
+        def add_base_type_reflections(name, ref)
+          if name == ref.plural_name
+            name_for_base_type(ref.active_record).constantize.send(
+              :field,
+              name,
+              "[#{name_for_base_type(ref.klass)}]"
+            )
+          else
+            name_for_base_type(ref.active_record).constantize.send(
+              :field,
+              name,
+              name_for_base_type(ref.klass)
+            )
           end
+        rescue NoMethodError => e
+          binding.pry
+        end
 
+        def define_input_object(model)
           # input objects
           klass = Class.new(::Types::BaseInputObject)
           klass.description("Attributes for creating or updating a #{model}.")
           model.attribute_types.each do |attr, type|
             next if %w[id created_at updated_at].include?(attr)
 
-            klass.argument(attr, Hai::GraphQL::TYPE_CAST[type.class], required: false)
+            klass.argument(
+              attr,
+              Hai::GraphQL::TYPE_CAST[type.class],
+              required: false
+            )
           end
           ::Types.const_set "#{model}Attributes", klass
         end
+
+        def name_for_filter_type(model)
+          "#{model}FilterInputType"
+        end
+
+        def define_filter_type(model)
+          # Class Filter
+          filter_klass = Class.new(::GraphQL::Schema::InputObject)
+          model.attribute_types.each do |attr, type|
+            filter_klass.send(
+              :argument,
+              attr,
+              AREL_TYPE_CAST[type.class] ||
+                AREL_TYPE_CAST[type.class.superclass],
+              required: false
+            )
+          end
+
+          Object.const_set name_for_filter_type(model), filter_klass
+        end
+
+        def add_filter_type_reflections(name, ref)
+          name_for_filter_type(ref.active_record).constantize.send(
+            :argument,
+            name,
+            name_for_filter_type(ref.klass),
+            required: false
+          )
+        rescue NoMethodError, RuntimeError => e
+          binding.pry
+        end
       end
     end
   end

data/lib/hai/graphql/update_mutations.rb

@@ -0,0 +1,34 @@
+module Hai
+  module GraphQL
+    class UpdateMutations
+      class << self
+        def add(mutation_type, model)
+          define_resolver(model)
+          add_field(mutation_type, model)
+        end
+
+        def define_resolver(model)
+          klass = Class.new(Hai::GraphQL::Types::BaseCreate)
+          klass.send(:graphql_name, "Update#{model}")
+          klass.description("Mutation to Update #{model}.")
+
+          klass.argument(:attributes, "Types::#{model}Attributes")
+          klass.argument(:id, ::GraphQL::Types::ID)
+
+          klass.field(:result, ::Types.const_get("#{model}Type"))
+
+          klass.define_method(:resolve) do |id:, attributes:|
+            Hai::Update.new(model, context).execute(id: id, attributes: attributes.to_h)
+          end
+
+          Hai::GraphQL::Types.const_set("Update#{model}", klass)
+        end
+
+        def add_field(mutation_type, model)
+          mutation_type.field("update_#{model.name.downcase}",
+                              mutation: Hai::GraphQL::Types.const_get("Update#{model}"))
+        end
+      end
+    end
+  end
+end

data/lib/hai/graphql.rb

@@ -1,34 +1,47 @@
 require "hai/graphql/read_queries"
 require "hai/graphql/list_queries"
 require "hai/graphql/create_mutations"
+require "hai/graphql/update_mutations"
+require "hai/graphql/delete_mutations"
 require "hai/types/arel/int_input_type"
+require "hai/types/arel/float_input_type"
 require "hai/types/arel/string_input_type"
 require "hai/types/arel/datetime_input_type"
+require "hai/types/arel/boolean_input_type"
 
 module Hai
   module GraphQL
     TYPE_CAST = {
       ActiveModel::Type::Integer => ::GraphQL::Types::Int,
+      ActiveModel::Type::Float => ::GraphQL::Types::Float,
       ActiveModel::Type::String => ::GraphQL::Types::String,
-      ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter => ::GraphQL::Types::ISO8601DateTime
+      ActiveModel::Type::Boolean => ::GraphQL::Types::Boolean,
+      ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter =>
+        ::GraphQL::Types::ISO8601DateTime
     }.freeze
     AREL_TYPE_CAST = {
       ActiveModel::Type::Integer => Hai::GraphQL::Types::Arel::IntInputType,
+      ActiveModel::Type::Float => Hai::GraphQL::Types::Arel::FloatInputType,
       ActiveModel::Type::String => Hai::GraphQL::Types::Arel::StringInputType,
-      ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter => Hai::GraphQL::Types::Arel::DateTimeInputType
+      ActiveModel::Type::Boolean => Hai::GraphQL::Types::Arel::BooleanInputType,
+      ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter =>
+        Hai::GraphQL::Types::Arel::DateTimeInputType
     }.freeze
+
     def self.included(base)
       base.extend(ClassMethods)
     end
 
     module ClassMethods
-      def yasashii_query(model)
+      def hai_query(model)
         Hai::GraphQL::ReadQueries.add(self, model)
         Hai::GraphQL::ListQueries.add(self, model)
       end
 
-      def yasashii_mutation(model)
+      def hai_mutation(model)
         Hai::GraphQL::CreateMutations.add(self, model)
+        Hai::GraphQL::UpdateMutations.add(self, model)
+        Hai::GraphQL::DeleteMutations.add(self, model)
       end
     end
   end

data/lib/hai/policies.rb

@@ -0,0 +1,26 @@
+module Hai
+  module Policies
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def check_hai_policy(action, context)
+      return true unless (policy = self.class.policies[action])
+
+      policy.call(self, context)
+    end
+
+    module ClassMethods
+      def policies
+        @policies ||= {}
+      end
+
+      # TODO: validate CRUD actions
+      def policy(action, &block)
+        policies[action] = lambda do |instance, context|
+          block.call(instance, context)
+        end
+      end
+    end
+  end
+end

data/lib/hai/railtie.rb

@@ -0,0 +1,13 @@
+require "hai"
+require "rails"
+
+module Hai
+  class Railtie < Rails::Railtie
+    railtie_name :hai
+
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+    end
+  end
+end

data/lib/hai/read.rb

@@ -1,42 +1,61 @@
 module Hai
   class Read
     attr_accessor :model
-    attr_reader :table
+    attr_reader :table, :context
 
-    def initialize(model)
+    def initialize(model, context)
       @model = model
+      @context = context
+      @context[:model] = model
       @table = model.arel_table
     end
 
     # return [] or ActiveRecord::Relationship
-    def list(query_hash)
-      limit = query_hash.delete(:limit)
-      offset = query_hash.delete(:offset)
-      filter = query_hash.delete(:filter)
-
-      reflection_queries = build_reflection_queries(filter) if filter
-      query = filter.present? ? model.where(build_query(filter)) : model.all
-      if filter
-        reflection_queries.each do |ref, q|
-          query = query.joins(ref).merge(q)
-        end
-      end
+    def list(filter: nil, limit: nil, offset: nil, sort: nil, **extra)
+      check_list_policy(context)
 
+      context[:arguments] = extra
+      query = build_filter(filter)
+      query = query.order({ sort.fetch(:field) => sort.fetch(:order) }) if sort
       query = query.limit(limit) if limit
       query = query.offset(offset) if offset
-      query
+      run_action_modification(query)
     end
 
     # return nil or model
     def read(query_hash)
-      model.find_by(build_query(query_hash))
+      build_filter(query_hash).first.tap do |record|
+        if record.respond_to?(:check_hai_policy) &&
+             !record.check_hai_policy(:read, context)
+          raise UnauthorizedError
+        end
+      end
     end
 
     private
 
-    # TODO: prolly can remove this
-    def select_manager
-      @select_manager ||= Arel::SelectManager.new(table)
+    def check_read_policy
+      if model.const_defined?("Policies") && model::Policies.respond_to?(:read)
+        model::Policies.read(context)
+      else
+        true
+      end
+    end
+
+    def check_list_policy
+      if model.const_defined?("Policies") && model::Policies.respond_to?(:list)
+        model::Policies.list(context)
+      else
+        true
+      end
+    end
+
+    def run_action_modification(query)
+      if model.const_defined?("Actions") && model::Actions.respond_to?(:list)
+        model::Actions.list(query, context)
+      else
+        query
+      end
     end
 
     def reflections
@@ -44,21 +63,53 @@ module Hai
     end
 
     def query_reflections(query_hash)
-      reflections.each_with_object({}) do |(ref, _info), acc|
-        acc[ref] = query_hash.delete(ref)
-      end.compact
+      reflections
+        .each_with_object({}) do |(ref, _info), acc|
+          acc[ref] = query_hash.delete(ref)
+        end
+        .compact
     end
 
     def build_reflection_queries(query_hash)
-      reflections.each_with_object({}) do |(ref, info), acc|
-        q_hash = query_hash.delete(ref)
-        acc[ref] = info.klass.where(where_clause(info.klass.arel_table, q_hash)) if q_hash
-      end.compact
+      reflections
+        .each_with_object({}) do |(ref, info), acc|
+          q_hash = query_hash.delete(ref)
+          acc[ref] = info.klass.where(
+            where_clause(info.klass.arel_table, q_hash)
+          ) if q_hash
+        end
+        .compact
     end
 
-    def build_query(query_hash)
-      or_branch = query_hash.delete(:or)
-      query = where_clause(model.arel_table, query_hash)
+    def build_joins(filter_hash)
+      reflections.map do |ref, _|
+        if filter_hash
+             .keys
+             .concat((filter_hash[:or] || []).flat_map(&:keys).uniq)
+             .include?(ref)
+          ref
+        end
+      end
+    end
+
+    def build_filter(filter_hash)
+      return model.all unless filter_hash.present?
+
+      joins = build_joins(filter_hash)
+      reflection_queries = build_reflection_queries(filter_hash)
+      or_branch = filter_hash.delete(:or)
+      # build_reflection_queries mutates the filter_hash
+      query =
+        (
+          if filter_hash.present?
+            model.where(where_clause(model.arel_table, filter_hash))
+          else
+            model.all
+          end
+        )
+
+      joins.compact.each { |ref| query = query.left_joins(ref) }
+      reflection_queries.each { |_ref, q| query = query.merge(q) }
 
       return query unless or_branch
 
@@ -66,7 +117,8 @@ module Hai
     end
 
     def add_sub_query(query, or_branch)
-      query.or(build_query(or_branch))
+      or_branch.each { |q| query = query.or(build_filter(q)) }
+      query
     end
 
     def where_clause(table, query_hash)
@@ -79,19 +131,5 @@ module Hai
         end
       end
     end
-
-    def limit; end
-
-    def offset; end
-
-    def having; end
-
-    def group; end
-
-    def order; end
-
-    def select; end
-
-    def distinct; end
   end
 end

data/lib/hai/tasks/graphql/filter_type.rake

@@ -0,0 +1,8 @@
+namespace :hai do
+  namespace :graphql do
+    desc "Generates filter types for a given model"
+    task :filter_type do
+      puts "Lets freaking go!"
+    end
+  end
+end

data/lib/hai/tasks/hai.rake

@@ -0,0 +1,2 @@
+namespace :hai do
+end

data/lib/hai/types/arel/boolean_input_type.rb

@@ -0,0 +1,11 @@
+module Hai
+  module GraphQL
+    module Types
+      module Arel
+        class BooleanInputType < ::GraphQL::Schema::InputObject
+          argument :eq, ::GraphQL::Types::Boolean
+        end
+      end
+    end
+  end
+end

data/lib/hai/types/arel/float_input_type.rb

@@ -0,0 +1,10 @@
+module Hai
+  module GraphQL
+    module Types
+      module Arel
+        class FloatInputType < IntInputType
+        end
+      end
+    end
+  end
+end

data/lib/hai/types/arel/sort_input_type.rb

@@ -0,0 +1,13 @@
+
+module Hai
+  module GraphQL
+    module Types
+      module Arel
+        class SortInputType < ::GraphQL::Schema::InputObject
+          argument :field, ::GraphQL::Types::String # TODO: maybe add "types" dynamically?
+          argument :order, ::GraphQL::Types::String # TODO: change to enum DESC||ASC
+        end
+      end
+    end
+  end
+end

data/lib/hai/types/base_create.rb

@@ -0,0 +1,14 @@
+require_relative "./mutation_error_type"
+
+module Hai
+  module GraphQL
+    module Types
+      # TODO: make this base class configurable?
+      class BaseCreate < ::GraphQL::Schema::RelayClassicMutation
+        null true
+
+        field :errors, [String], null: false
+      end
+    end
+  end
+end

data/lib/hai/types/mutation_error_type.rb

@@ -0,0 +1,11 @@
+module Hai
+  module GraphQL
+    module Types
+      class MutationError < ::GraphQL::Schema::Object
+        field :message, String
+        field :code, Integer
+        field :fields, [String], null: false
+      end
+    end
+  end
+end

data/lib/hai/types/sort_input_type.rb

@@ -0,0 +1,10 @@
+module Hai
+  module GraphQL
+    module Types
+      class SortInputType < ::GraphQL::Schema::InputObject
+        argument :field, ::GraphQL::Types::String # TODO: maybe add "types" dynamically?
+        argument :order, ::GraphQL::Types::String # TODO: change to enum DESC||ASC
+      end
+    end
+  end
+end

data/lib/hai/update.rb

@@ -1,15 +1,35 @@
 module Hai
-  class Create
-    attr_accessor :model
-    attr_reader :table
+  class Update
+    attr_reader :model, :context
 
-    def initialize(model)
+    def initialize(model, context)
       @model = model
+      @context = context
     end
 
     def execute(id:, attributes:)
       record = model.find(id)
-      record.update(**attributes)
+      return unauthorized_error unless check_policy(record)
+
+      if record.update(**attributes)
+        { errors: [], result: record }
+      else
+        { errors: record.errors.map(&:full_message), result: nil }
+      end
+    end
+
+    private
+
+    def unauthorized_error
+      { errors: ["UnauthorizedError"], result: nil }
+    end
+
+    def check_policy(instance)
+      if model.const_defined?("Policies") && model::Policies.respond_to?(:update)
+        model::Policies.update(instance, context)
+      else
+        true
+      end
     end
   end
 end

data/lib/hai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hai
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/hai.rb

@@ -1,12 +1,28 @@
 # frozen_string_literal: true
 
+require "active_record"
+# TODO: remove dependency on Graphql
+require "graphql"
+require_relative "hai/graphql"
+require_relative "hai/graphql/types"
+
 require_relative "hai/version"
+
 require_relative "hai/read"
 require_relative "hai/create"
-require_relative "hai/graphql"
-require_relative "hai/graphql/types"
+require_relative "hai/update"
+require_relative "hai/delete"
+
+require_relative "hai/policies"
+require_relative "hai/action_mods"
+require "hai/railtie" if defined?(Rails)
 
 module Hai
-  class Error < StandardError; end
-  # Your code goes here...
+  class Error < StandardError
+  end
+  class Rest
+    class Engine < ::Rails::Engine
+      isolate_namespace Hai
+    end
+  end
 end

data/todo.md

@@ -12,11 +12,11 @@
 - [/] create
   - [/] attributes
   - [] required or not
-- [] update
-  - [] id + attributes
-- [] destroy
-  - [] id
-  - [] authorization [current_user]
+- [/] update
+  - [/] id + attributes
+- [/] destroy
+  - [/] id
+  - [/] authorization [current_user]
 
 ------------------------------------------
 
@@ -29,13 +29,20 @@
     - [/] read
     - [/] list
     - [/] relationships
+    - [] ActiveRecord::RecordNotFound ?
   - [/] create
-    - [ ] callback for current_user/context
-  - [] update
-    - [ ] callback for current_user/context
-  - [] destroy
+    - [/] callback for current_user/context
+    - [] Errors
+  - [/] update
+    - [/] callback for policy
+    - [] Errors
+  - [/] destroy
+    - [] Errors
+  - [] errors
+  - [] subscriptions
 ------
-- [/] gemify
+- [x] gemify
+- [] automate release
 
 ## Post gem
 - [] Multiple or queries