hai 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2055a088c784b6ffa1ef52d9ce4bdcfd41c024742bb070f4776c67ae125e4cdb
-  data.tar.gz: 81d7c516af333b982b74511b466232cd922e69d892d6577316f8cd5f9842be0c
+  metadata.gz: dd1e9a5e790765b1b2030e4384048a2ad08f420e2078b5d883e2bffd2d8dc8eb
+  data.tar.gz: 4da9e653d8c708d2e01135aa8cbf70234ec73100a0c158cb3dbd1583a47add28
 SHA512:
-  metadata.gz: 244f6fa084d19a44b84d7530708928ba219f9204e3102b59c19c8917368193f02bb7099eb1238f8b870f44839b8d48bb4f0147df134ff3050be9db45133754dd
-  data.tar.gz: f1e925b0e23c14d019e58a302dffa2bee6b56313757af5540419e370aef8edd0fc08c269d693de10173f1631421a32d787fc43c85bd3f2320fcaab2d2b69ba74
+  metadata.gz: dda8bcf71ee7a008b7fac3c6ad0f83b25e3d4fb3c50078b7cae6e1d9d896fa1d3d88b18eacced38fe7ce2e7e6c1efd55c02dc6187934376ab03e7f28f7ed7af4
+  data.tar.gz: f125a58684eeba263730397623dd1f3fa58b1168423960c88cb5a0d4f815f6312c18d470d558c8cb8f9a992d542b60637c2086dd4487b0b8737ea48db0c19015

data/Gemfile

@@ -10,6 +10,6 @@ gem "rake", "~> 13.0"
 gem "minitest", "~> 5.0"
 
 gem "factory_bot"
-gem "graphql"
 gem "pry"
 gem "rubocop", "~> 1.21"
+gem "ruby-lsp"

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    hai (0.0.1)
+    hai (0.0.2)
       activerecord (~> 7.0)
+      graphql (~> 2.0)
       pg (~> 1.3.5)
 
 GEM
@@ -26,12 +27,14 @@ GEM
     graphql (2.0.9)
     i18n (1.10.0)
       concurrent-ruby (~> 1.0)
+    language_server-protocol (3.16.0.3)
     method_source (1.0.0)
     minitest (5.16.0)
     parallel (1.21.0)
     parser (3.1.1.0)
       ast (~> 2.4.1)
     pg (1.3.5)
+    prettier_print (0.1.0)
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
@@ -50,23 +53,32 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.16.0)
       parser (>= 3.1.1.0)
+    ruby-lsp (0.1.0)
+      language_server-protocol
+      rubocop (>= 1.0)
+      sorbet-runtime
+      syntax_tree (>= 2.4)
     ruby-progressbar (1.11.0)
+    sorbet-runtime (0.5.10139)
+    syntax_tree (2.8.0)
+      prettier_print
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.1.0)
 
 PLATFORMS
   x86_64-darwin-21
+  x86_64-linux
 
 DEPENDENCIES
   activesupport (~> 7.0)
   factory_bot
-  graphql
   hai!
   minitest (~> 5.0)
   pry
   rake (~> 13.0)
   rubocop (~> 1.21)
+  ruby-lsp
 
 BUNDLED WITH
    2.3.5

data/README.md

@@ -1,8 +1,9 @@
 # Hai
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/hai`. To experiment with that code, run `bin/console` for an interactive prompt.
+The easist way to create a CRUD GraphQL or Rest api with ruby.
+Heavily inspired by [Ash Elixir](https://www.ash-elixir.org/)
 
-TODO: Delete this and the text above, and describe your gem
+Feedback is welcome and appreciated.
 
 ## Installation
 
@@ -16,24 +17,199 @@ And then execute:
 
     $ bundle install
 
-Or install it yourself as:
+## Usage
 
-    $ gem install hai
+Hai is a resource based api and those resources are ActiveRecord models. Keeping with this first principle, let's see how it can be used in your Ruby application.
 
-## Usage
+## Action Modifications
+
+If you want to modify any of the actions, you can add a Actions module to the
+model that you want to modify.
+
+```ruby
+class Post < ApplicationRecord
+  belongs_to :user
+
+  module Actions
+    def self.read(query, context)
+      query.where(user_id: context[:user].id)
+    end
+
+    def self.list(query, context)
+      query.where(user_id: context[:user].id)
+    end
+
+    def self.create(post, context)
+      post.user = context[:user]
+    end
+
+    def self.update(post, context)
+      post.last_updated_by = context[:user]
+    end
+  end
+end
+```
+## Policies
+Policies are handled in the same manner of Action Modifications. We will use the `Policies` module in the model to handle things like authorization.
+
+```ruby
+class Post < ApplicationRecord
+  belongs_to :user
+
+  module Policies
+    def self.read(context)
+      context[:user].can?(:read, context[:model])
+    end
+
+    def self.list(query, context)
+      context[:user].can?(:list, context[:model])
+    end
+
+    # NOTE: create does a create or update
+    def self.create(post, context)
+      if post.persisted?
+        post.user_id == context[:user].id
+      else
+        context[:user].can?(:create, context[:model])
+      end
+    end
+
+    def self.update(post, context)
+      post.user_id == context[:user].id
+    end
+
+    def self.delete(post, context)
+      post.user_id == context[:user].id
+    end
+  end
+end
+```
+
+## Graphql
+
+Hai Graphql depends on `graphql-ruby` so if you don't have that installed and
+boostrapped, head over to [ their repo and do that now ](https://github.com/rmosolgo/graphql-ruby#installation).
+
+First, we have to load the Hai Graphql Types with the following snippet of code in your GraphQL::Schema file. Currently, order of operations matters so this needs to be called before the mutation and query class methods.
+
+```ruby
+class MyAppSchema < GraphQL::Schema
+  include Hai::GraphQL::Types
+  hai_types(User, Post) # comma list of the models you want to expose
+
+  mutation(Types::MutationType)
+  query(Types::QueryType)
+  # ...
+end
+```
+
+Now, if we want to add read operations (`readUser` and `listUsers`) complete with filtering, pagination, & sorting, we just have to declare it in the `Types::QueryType` file like so:
+
+```ruby
+module Types
+  class QueryType < Types::BaseObject
+    # Add `node(id: ID!) and `nodes(ids: [ID!]!)`
+    include GraphQL::Types::Relay::HasNodeField
+    include GraphQL::Types::Relay::HasNodesField
+
+    include Hai::GraphQL
+    hai_query(User)
+  end
+end
+```
+
+Lastly, if you want to add mutations (`createUser`, `updateUser`, & `deleteUser`), you simply declare which models you'd like to expose in the `Types::MutationType` file.
+
+```ruby
+module Types
+  class MutationType < Types::BaseObject
+    include Hai::GraphQL
+    hai_mutation(User)
+  end
+end
+```
+
+## Rest
+
+This is even easier than adding Hai Graphql. Hai Rest is a dynamic engine that can be mounted with any namespace. You just have to mount it in your routes file like this:
+
+```ruby
+Rails.application.routes.draw do
+  mount Hai::Rest::Engine => "/rest"
+end
+```
+
+Example queries for rest.
+#### List all users
+
+Simple use case
+
+`GET <base_url>/rest/users`
+
+You can also filter:
+
+`GET <base_url>/rest/users?filter[name][eq]=bob`
+
+Sort
+
+`GET <base_url>/rest/users?sort[field]=name&sort[direction]=desc`
+
+Paginate
+
+`GET <base_url>/rest/users?limit=10&offset=20`
+
+Or all things combined
+
+`GET <base_url>/rest/users?filter[name][eq]=bob&sort[field]=name&sort[direction]=desc&limit=10&offset=20`
+
+#### Read a specific user
+
+`GET <base_url>/rest/users/1`
+
+#### Create a user
+
+`POST <base_url>/rest/users`
+
+```JSON
+{
+    "user": {
+        "name": "bob"
+    }
+}
+```
+
+#### Update a user
+`PUT <base_url>/rest/users/1`
+
+```JSON
+{
+    "user": {
+        "name": "bob"
+    }
+}
+```
 
-TODO: Write usage instructions here
+#### Delete a user
+`DELETE <base_url>/rest/users/1`
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and the created tag, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/hai.
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/[USERNAME]/hai.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT
+License](https://opensource.org/licenses/MIT).

data/app/controllers/hai/rest_controller.rb

@@ -0,0 +1,65 @@
+module Hai
+  class RestController < ::ApplicationController
+    skip_forgery_protection
+    def index
+      render json:
+               Hai::Read
+                 .new(model_class, context)
+                 .list(
+                   # TODO: this is a security risk, thanks co-pilot
+                   # potenntial use attributes types plus AREL_TYPE_CAST
+                   filter: params[:filter]&.to_unsafe_h,
+                   limit: params[:limit],
+                   offset: params[:offset],
+                   sort: params[:sort]&.to_unsafe_h
+                 )
+                 .to_json
+    end
+
+    def show
+      render json:
+               Hai::Read
+                 .new(model_class, context)
+                 .read(id: { eq: params[:id] })
+                 .to_json
+    end
+
+    def create
+      render json:
+               Hai::Create
+                 .new(model_class, context)
+                 .execute(**params[params[:model].singularize].permit!)
+                 .to_json
+    end
+
+    def update
+      render json:
+               Hai::Update
+                 .new(model_class, context)
+                 .execute(
+                   id: params[:id],
+                   attributes: params[params[:model]].permit!
+                 )
+                 .to_json
+    end
+
+    def destroy
+      render json:
+               Hai::Delete
+                 .new(model_class, context)
+                 .execute(id: params[:id])
+                 .to_json
+    end
+
+    private
+
+    def model_class
+      params[:model].classify.constantize
+    end
+
+    def read_params
+      params.permit! || {}
+      # params.permit(:limit, :offset, sort: { :field , :order},filter: {} )
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,7 @@
+Hai::Rest::Engine.routes.draw do
+  get "/:model", to: "rest#index"
+  get "/:model/:id", to: "rest#show"
+  post "/:model", to: "rest#create"
+  put "/:model/:id", to: "rest#update"
+  delete "/:model/:id", to: "rest#destroy"
+end

data/lib/hai/action_mods.rb

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

data/lib/hai/create.rb

@@ -1,13 +1,51 @@
 module Hai
   class Create
-    attr_accessor :model
+    attr_accessor :model, :context
 
-    def initialize(model)
+    def initialize(model, context)
       @model = model
+      @context = context
+      @context[:model] = model
     end
 
     def execute(**attrs)
-      model.create(**attrs)
+      id = attrs.delete(:id)
+      instance = id ? model.find(id) : model.new
+
+      return unauthorized_error unless check_policy(instance)
+
+      instance.assign_attributes(**attrs)
+
+      run_action_modification(instance)
+
+      if instance.save
+        { errors: [], result: instance }
+      else
+        { errors: instance.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?(:create)
+        model::Policies.create(instance, context)
+      else
+        true
+      end
+    end
+
+    def run_action_modification(instance)
+      if model.const_defined?("Actions") && model::Actions.respond_to?(:create)
+        model::Actions.create(instance, context)
+      else
+        instance
+      end
     end
   end
 end

data/lib/hai/delete.rb

@@ -0,0 +1,17 @@
+module Hai
+  class Delete
+    attr_reader :model, :context
+
+    def initialize(model, context)
+      @model = model
+      @context = context
+    end
+
+    def execute(id:)
+      record = model.find(id)
+      raise UnauthorizedError if record.respond_to?(:check_hai_policy) && record.check_hai_policy(:delete, context)
+
+      record.destroy
+    end
+  end
+end

data/lib/hai/graphql/create_mutations.rb

@@ -1,23 +1,42 @@
+require "hai/types/base_create"
+
 module Hai
   module GraphQL
     class CreateMutations
       class << self
         def add(mutation_type, model)
+          define_resolver(model)
           add_field(mutation_type, model)
-          define_create_method(mutation_type, model)
         end
 
-        def add_field(mutation_type, model)
-          mutation_type.field("create_#{model.name.downcase}", "Types::#{model}Type".constantize) do
-            mutation_type.description("Create a #{model}.")
-            argument(:attributes, "Types::#{model}Attributes")
+        def define_resolver(model)
+          klass = Class.new(Hai::GraphQL::Types::BaseCreate)
+          klass.send(:graphql_name, "Create#{model}")
+          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] ||
+                Hai::GraphQL::TYPE_CAST[type.class.superclass],
+              required: false
+            )
           end
-        end
 
-        def define_create_method(mutation_type, model)
-          mutation_type.define_method("create_#{model.name.downcase}") do |attributes:|
-            Hai::Create.new(model).execute(**attributes.to_h)
+          klass.field(:result, ::Types.const_get("#{model}Type"))
+
+          klass.define_method(:resolve) do |args|
+            Hai::Create.new(model, context).execute(**args)
           end
+          Hai::GraphQL::Types.const_set("Create#{model}", klass)
+        end
+
+        def add_field(mutation_type, model)
+          mutation_type.field(
+            "create_#{model.name.downcase}",
+            mutation: Hai::GraphQL::Types.const_get("Create#{model}")
+          )
         end
       end
     end

data/lib/hai/graphql/delete_mutations.rb

@@ -0,0 +1,25 @@
+module Hai
+  module GraphQL
+    class DeleteMutations
+      class << self
+        def add(mutation_type, model)
+          add_field(mutation_type, model)
+          define_create_method(mutation_type, model)
+        end
+
+        def add_field(mutation_type, model)
+          mutation_type.field("delete_#{model.name.downcase}", "Types::#{model}Type".constantize) do
+            mutation_type.description("Delete a #{model}.")
+            argument(:id, ::GraphQL::Types::ID)
+          end
+        end
+
+        def define_create_method(mutation_type, model)
+          mutation_type.define_method("delete_#{model.name.downcase}") do |id:|
+            Hai::Delete.new(model, context).execute(id: id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hai/graphql/list_queries.rb

@@ -1,33 +1,40 @@
+require "hai/types/sort_input_type"
+
 module Hai
   module GraphQL
     class ListQueries
       class << self
         def add(query_type, model)
-          define_filter_type(model)
           add_field(query_type, model)
           define_list_method(query_type, model)
         end
 
-        def define_filter_type(model)
-          filter_klass = Class.new(::GraphQL::Schema::InputObject)
-          model.attribute_types.each do |attr, type|
-            filter_klass.send(:argument, attr, AREL_TYPE_CAST[type.class], required: false)
-          end
-          Object.const_set "#{model}FilterInputType", filter_klass
-        end
-
         def add_field(query_type, model)
-          query_type.field "list_#{model.name.downcase}", ["Types::#{model}Type".constantize] do
+          query_type.field "list_#{model.name.pluralize.downcase}",
+                           ["Types::#{model}Type".constantize] do
             query_type.description "List of #{model}."
-            argument :filter, "#{model}FilterInputType".constantize, required: false
+            argument :filter,
+                     "#{model}FilterInputType".constantize,
+                     required: false
             argument :limit, ::GraphQL::Types::Int, required: false
             argument :offset, ::GraphQL::Types::Int, required: false
+            argument :sort, Types::SortInputType, required: false
+
+            (model.try(:arguments) || []).each do |name, type, kwargs|
+              argument(name, type, **kwargs)
+            end
           end
         end
 
         def define_list_method(query_type, model)
-          query_type.define_method("list_#{model.name.downcase}") do |**args|
-            Hai::Read.new(model).list(args.transform_values { |v| v.is_a?(Integer) ? v : v.to_h })
+          query_type.define_method(
+            "list_#{model.name.pluralize.downcase}"
+          ) do |**args|
+            Hai::Read.new(model, context).list(
+              **args.transform_values do |v|
+                [Integer, String].include?(v.class) ? v : v.to_h
+              end
+            )
           end
         end
       end

data/lib/hai/graphql/read_queries.rb

@@ -8,17 +8,25 @@ module Hai
         end
 
         def add_field(query_type, model)
-          query_type.field("read_#{model.name.downcase}", "Types::#{model}Type".constantize) do
+          query_type.field(
+            "read_#{model.name.downcase}",
+            "Types::#{model}Type".constantize
+          ) do
             query_type.description("List a single #{model}.")
             model.attribute_types.each do |attr, type|
-              argument(attr, Hai::GraphQL::AREL_TYPE_CAST[type.class], required: false)
+              argument(
+                attr,
+                Hai::GraphQL::AREL_TYPE_CAST[type.class] ||
+                  Hai::GraphQL::Types::Arel::IntInputType,
+                required: false
+              )
             end
           end
         end
 
         def define_read_method(query_type, model)
           query_type.define_method("read_#{model.name.downcase}") do |**args|
-            Hai::Read.new(model).read(args.transform_values(&:to_h))
+            Hai::Read.new(model, context).read(args.transform_values(&:to_h))
           end
         end
       end