groovestack-base 0.1.7 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13693c2f0b6254d0533ca66741511c0cfa6e15e016f702418935c7bfc18dd33c
-  data.tar.gz: bdba5c1495e4649ceddeb8dcddf04c58a894b0e4eb40c7219bb2c10adb7cd80a
+  metadata.gz: 1a311efec7ea663cb5f48572a3a47455355153e81f34c7a4335b57a0b6e7bcd1
+  data.tar.gz: e7271df5eccd6fb19e6554b81bff4bffa682e383898fc7792307092aeae262be
 SHA512:
-  metadata.gz: c959010a77e946af6e2095090458cba3fa87c77bc19639ce326e59313a25761184303347e18d89e423b480dc06b767b3c8473a5bbf97a6c24c501fdfae575739
-  data.tar.gz: e51d27bafed2bfd965752acd9d0a213c14bd233839df923153f38f15149e1308193e0c85a6ee9b0ab42cc5335ef6e05e072b80a55d54f4eddfc6f1dc30383f8b
+  metadata.gz: 798cfee3f783ab9724cc13833e04b23be4bad6988be974edbbee76e16888746e85a08d758768ff55a901cbc897fc8e9a9494fa8787000d2065737dc50faf3c27
+  data.tar.gz: d713e07a8b1260dd326d8f94d987a20216abf69b5eb44462cf91221a31e68ac09a89cece41c4c980f16f0d9990fccb70f3d14316d483fff0cf325174f76f4f9e

data/.rubocop.yml

@@ -1,4 +1,4 @@
-require:
+plugins:
   - rubocop-graphql
   - rubocop-rails
 

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-## [0.1.5] - 2025-05-06
+## [0.1.8] - 2025-04-10
+
+- Refactor GraphQL namespaces and file structure
+
+## [0.1.5] - 2025-04-06
 
 - Add CHANGELOG
 - Update gemspec to new `groovestack` namespace

data/Gemfile

@@ -5,6 +5,10 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in groovestack-base.gemspec
 gemspec
 
+group :test do
+  gem 'rails'
+  gem 'rspec'
+  gem 'wisper'
+end
 gem 'rake', '~> 12.0'
-gem 'rspec'
 gem 'rubocop', require: false

data/config/initializers/graphql.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# TODO: add specs
+
 module GraphQL
   class Schema
     class Member

data/groovestack-base.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = 'Groovestack::Base defines reusable extensions for the CORE Platform.'
   spec.post_install_message = 'Groovestack::Base installed'
 
-  spec.homepage = 'https://github.com/talysto/groovestack-core/'
+  spec.homepage = 'https://talysto.com/tech/groovestack/'
   spec.required_ruby_version = '>= 3.1.0'
 
   spec.metadata['allowed_push_host'] = 'https://rubygems.org'

data/lib/groovestack/base/graphql/authorization/authorized_field.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Authorization
+        class AuthorizedField < ::Groovestack::Base::GraphQL::Base::Field
+          def authorized?(obj, args, ctx)
+            authorized_fields = begin
+              obj.authorized_fields_for_serialization(ctx[:current_user])
+            rescue StandardError
+              []
+            end
+
+            super && authorized_fields.include?(name.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/authorization/authorized_object.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Authorization
+        class AuthorizedObject < ::Groovestack::Base::GraphQL::Base::Object
+          field_class ::Groovestack::Base::GraphQL::Authorization::AuthorizedField
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/authorization/visible_field.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Authorization
+        class VisibleField < ::Groovestack::Base::GraphQL::Base::Field
+          def visible?(context)
+            return super unless @visibility_permission
+
+            # visibility profile are the visibility levels the
+            # current user is authorized for
+            visibility_profile = context.schema.visibility_profile_for_context(context).map(&:to_sym)
+
+            return super unless visibility_profile
+
+            super && visibility_profile.include?(@visibility_permission.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/base/argument.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Base
+        class Argument < ::GraphQL::Schema::Argument
+          def initialize(*args, camelize: ::Groovestack::Base.config.graphql.camelize, **kwargs, &block)
+            # Then, call super _without_ any args, where Ruby will take
+            # _all_ the args originally passed to this method and pass it to the super method.
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/base/field.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Base
+        class Field < ::GraphQL::Schema::Field
+          argument_class ::Groovestack::Base::GraphQL::Base::Argument
+
+          attr_accessor :authenticate, :visibility_permission
+
+          # rubocop:disable Metrics/ParameterLists
+          def initialize(
+            *args,
+            authenticate: nil,
+            visibility_permission: nil,
+            null: false,
+            camelize: ::Groovestack::Base.config.graphql.camelize,
+            **kwargs, &block
+          )
+            # Then, call super _without_ any args, where Ruby will take
+            # _all_ the args originally passed to this method and pass it to the super method.
+            @authenticate = authenticate
+            @visibility_permission = visibility_permission
+            super(*args, null: null, camelize: camelize, **kwargs, &block)
+          end
+          # rubocop:enable Metrics/ParameterLists
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/base/input_object.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Base
+        class InputObject < ::GraphQL::Schema::InputObject
+          argument_class ::Groovestack::Base::GraphQL::Base::Argument
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/base/mutation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Base
+        class Mutation < ::GraphQL::Schema::Mutation
+          argument_class ::Groovestack::Base::GraphQL::Base::Argument
+
+          def resolve(**args)
+            perform(**args)
+          rescue StandardError => e
+            Groovestack::Base.notify_error(self.class, e)
+
+            raise e
+          end
+
+          def perform(**args)
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/base/object.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Base
+        class Object < ::GraphQL::Schema::Object
+          field_class ::Groovestack::Base::GraphQL::Base::Field
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/base/subscription.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Base
+        class Subscription < ::GraphQL::Schema::Subscription
+          argument_class ::Groovestack::Base::GraphQL::Base::Argument
+          field_class ::Groovestack::Base::GraphQL::Base::Field
+          object_class ::Groovestack::Base::GraphQL::Base::Object
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/controllers/graphql_controller.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Controllers
+        module GraphQLController
+          extend ActiveSupport::Concern
+
+          included do # rubocop:disable Metrics/BlockLength
+            private
+
+            def operation_name
+              params[:operationName]
+            end
+
+            def query
+              params[:query]
+            end
+
+            def variables
+              prepare_variables(params[:variables])
+            end
+
+            # Handle variables in form data, JSON body, or a blank value
+            def prepare_variables(variables_param)
+              case variables_param
+              when String
+                if variables_param.present?
+                  JSON.parse(variables_param) || {}
+                else
+                  {}
+                end
+              when Hash
+                variables_param
+              when ActionController::Parameters
+                variables_param.to_unsafe_hash # GraphQL-Ruby will validate name and type of incoming variables.
+              when nil
+                {}
+              else
+                raise ArgumentError, "Unexpected parameter: #{variables_param}"
+              end
+            end
+
+            def handle_error_in_development(err)
+              logger.error err.message
+              logger.error err.backtrace.join('\/n')
+
+              render json: { errors: [{ message: err.message, backtrace: err.backtrace }], data: {} },
+                     status: :internal_server_error
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/{documentation.rb → documentation/arguments.rb}

@@ -15,13 +15,6 @@ module Groovestack
                                      sort_order: 'order with which to sort the results (i.e. ASC, DESC)',
                                      filter: 'hash of parameters by which to filter the results (i.e. { ids: [1,2,3] })'
                                    })
-        Fields = OpenStruct.new({
-                                  created_at: 'time of record creation',
-                                  id: 'a unique record identifier',
-                                  relation_count: 'total number of records in a given scope',
-                                  updated_at: 'time of last record update'
-                                })
-
         # rubocop:enable Style/OpenStructUse
       end
     end

data/lib/groovestack/base/graphql/documentation/fields.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Documentation
+        # rubocop:disable Style/OpenStructUse
+        Fields = OpenStruct.new({
+                                  created_at: 'time of record creation',
+                                  id: 'a unique record identifier',
+                                  relation_count: 'total number of records in a given scope',
+                                  updated_at: 'time of last record update'
+                                })
+        # rubocop:enable Style/OpenStructUse
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/mutations/aasm_event_trigger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Mutations
+        module AASMEventTrigger
+          def trigger_status_event!(obj:, attrs:, event:, args: nil, authorization_policy: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+            # NOTE: args spread requires keys to be symbols, but by default
+            # they are passed as strings. This is why we use `symbolize_keys` here
+            raise ::GraphQL::ExecutionError, 'event not present' if event.blank?
+
+            event = event.gsub('!', '').to_sym
+
+            if attrs.present?
+              raise ::GraphQL::ExecutionError,
+                    'Cannot update multiple attributes when firing instance methods'
+            end
+            unless obj.aasm.events.map(&:name).include?(event)
+              raise ::GraphQL::ExecutionError,
+                    "#{event.capitalize} unavailable"
+            end
+            unless authorization_policy.nil? || authorization_policy.permitted_aasm_events.include?(event)
+              raise ::GraphQL::ExecutionError,
+                    "Unauthorized not allowed to #{event} this #{obj.class}"
+            end
+
+            event = :"#{event}!"
+
+            if args.present? && args.is_a?(Array)
+              obj.send(event.to_s, *args)
+            elsif args.present? && args.is_a?(Hash)
+              obj.send(event.to_s, **args.symbolize_keys!)
+            else
+              obj.send(event.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/mutations/method_trigger.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Mutations
+        module MethodTrigger
+          def trigger_instance_method!(obj:, attrs:, instance_method:, args: nil, authorization_policy: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+            raise GraphQL::ExecutionError, 'instance_method not present' if instance_method.blank?
+
+            instance_method = instance_method.to_sym
+
+            raise ::GraphQL::ExecutionError, 'instance_method undefined' unless obj.respond_to?(instance_method)
+
+            if attrs.present?
+              raise ::GraphQL::ExecutionError,
+                    'Cannot update multiple attributes when triggering instance method'
+            end
+            unless authorization_policy.nil? || authorization_policy.permitted_instance_methods.include?(instance_method) # rubocop:disable Layout/LineLength
+              raise ::GraphQL::ExecutionError,
+                    "Unauthorized not allowed to trigger #{instance_method} for this #{obj.class}"
+            end
+
+            if args.present? && args.is_a?(Array)
+              obj.send(instance_method.to_s, *args)
+            elsif args.present? && args.is_a?(Hash)
+              obj.send(instance_method.to_s, **args.symbolize_keys!)
+            else
+              obj.send(instance_method.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/providers/react_admin.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength, Metrics/ModuleLength, Metrics/ParameterLists
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Providers
+        module ReactAdmin
+          module Types
+            class RAListMetadata < ::GraphQL::Schema::Object
+              field :count, Int, null: false, description: Documentation::Fields.relation_count
+            end
+          end
+
+          module Resource
+            extend ActiveSupport::Concern
+
+            class_methods do
+              # TODO: make authorize default to true
+
+              def react_admin_resource(entity,
+                                       class_name: nil,
+                                       graphql_path: nil,
+                                       graphql_type: nil,
+                                       graphql_filter: nil,
+                                       authorize: false,
+                                       visibility_permission: nil,
+                                       policy: nil,
+                                       camelize: ::Groovestack::Base.config.graphql.camelize,
+                                       **args)
+                graphql_namespace = graphql_path&.dup&.concat('::')
+                entity_model_name = entity.to_s.classify
+                entity_class = class_name || entity_model_name
+                entity_type = resolve_entity_type(graphql_type, graphql_namespace, entity_model_name)
+                entity_filter_type = resolve_filter_type(graphql_filter, graphql_namespace, entity_model_name)
+                except = args.delete(:except) || []
+                policy ||= "#{entity_class}Policy"
+                base_scope = resolve_base_scope(entity_class)
+
+                define_resolver_methods(entity, entity_model_name, authorize, policy, base_scope, except)
+                define_graphql_fields(entity, entity_model_name, entity_type, entity_filter_type,
+                                      visibility_permission, camelize, except)
+              end
+
+              private
+
+              def resolve_entity_type(graphql_type, graphql_namespace, entity_model_name)
+                type_path = graphql_type || "#{graphql_namespace}#{entity_model_name}::Type"
+                type_path.constantize
+              end
+
+              def resolve_filter_type(graphql_filter, graphql_namespace, entity_model_name)
+                filter_path = graphql_filter || "#{graphql_namespace}#{entity_model_name}::Filter"
+                filter_path.constantize
+              end
+
+              def resolve_base_scope(entity_class)
+                entity_class.constantize.unscoped
+              rescue StandardError
+                nil
+              end
+
+              def define_resolver_methods(entity, entity_model_name, authorize, policy, base_scope, except)
+                unless except.include?(:find)
+                  define_find_resolver(entity, entity_model_name, authorize, policy,
+                                       base_scope)
+                end
+                define_collection_resolver(entity, authorize, policy, base_scope) unless except.include?(:collection)
+                define_meta_resolver(entity, authorize, policy, base_scope) unless except.include?(:collection_meta)
+              end
+
+              def define_find_resolver(_entity, entity_model_name, authorize, policy, base_scope)
+                define_method entity_model_name.to_sym do |id:|
+                  scope = resolve_scope(authorize, policy, :ShowScope, base_scope)
+                  scope.find id
+                end
+              end
+
+              def define_collection_resolver(entity, authorize, policy, base_scope)
+                define_method entity do |page: nil, per_page: nil, **attrs|
+                  scope = resolve_scope(authorize, policy, :IndexScope, base_scope)
+                  scope = send("#{entity}_scope", **attrs, base_scope: scope)
+                  apply_pagination(scope, page, per_page)
+                end
+              end
+
+              def define_meta_resolver(entity, authorize, policy, base_scope)
+                define_method :"#{entity}_meta" do |_page: nil, _per_page: nil, **attrs|
+                  scope = resolve_scope(authorize, policy, :IndexScope, base_scope)
+                  { count: send("#{entity}_scope", **attrs, base_scope: scope).size }
+                end
+              end
+
+              def define_graphql_fields(entity, entity_model_name, entity_type, entity_filter_type,
+                                        visibility_permission, camelize, except)
+                unless except.include?(:find)
+                  define_find_field(entity, entity_model_name, entity_type,
+                                    visibility_permission)
+                end
+                unless except.include?(:collection)
+                  define_collection_field(entity, entity_type, entity_filter_type, visibility_permission,
+                                          camelize)
+                end
+                return if except.include?(:collection_meta)
+
+                define_meta_field(entity, entity_filter_type, visibility_permission,
+                                  camelize)
+              end
+
+              def define_find_field(entity, entity_model_name, entity_type, visibility_permission)
+                field entity_model_name.to_sym, entity_type,
+                      null: true,
+                      visibility_permission: visibility_permission,
+                      resolver_method: entity_model_name.to_sym,
+                      description: "Find #{entity}." do
+                  argument :id, ::GraphQL::Types::ID, required: true, description: Documentation::Arguments.id
+                end
+              end
+
+              def define_collection_field(entity, entity_type, entity_filter_type, visibility_permission, camelize)
+                field :"all_#{entity.to_s.underscore}",
+                      type: [entity_type],
+                      null: false,
+                      camelize: camelize,
+                      visibility_permission: visibility_permission,
+                      resolver_method: entity do
+                  argument :page, ::GraphQL::Types::Int, required: false, description: Documentation::Arguments.page
+                  argument :per_page, ::GraphQL::Types::Int, required: false,
+                                                             description: Documentation::Arguments.per_page
+                  argument :sort_field, ::GraphQL::Types::String, required: false,
+                                                                  description: Documentation::Arguments.sort_field
+                  argument :sort_order, ::GraphQL::Types::String, required: false,
+                                                                  description: Documentation::Arguments.sort_order
+                  argument :filter, entity_filter_type, required: false, description: Documentation::Arguments.filter
+                end
+              end
+
+              def define_meta_field(entity, entity_filter_type, visibility_permission, camelize)
+                field :"_all_#{entity.to_s.underscore}_meta",
+                      type: ::Groovestack::Base::GraphQL::Providers::ReactAdmin::Types::RAListMetadata,
+                      camelize: camelize,
+                      null: true,
+                      visibility_permission: visibility_permission,
+                      resolver_method: :"#{entity}_meta" do
+                  argument :page, ::GraphQL::Types::Int, required: false, description: Documentation::Arguments.page
+                  argument :per_page, ::GraphQL::Types::Int, required: false,
+                                                             description: Documentation::Arguments.per_page
+                  argument :sort_field, ::GraphQL::Types::String, required: false,
+                                                                  description: Documentation::Arguments.sort_field
+                  argument :sort_order, ::GraphQL::Types::String, required: false,
+                                                                  description: Documentation::Arguments.sort_order
+                  argument :filter, entity_filter_type, required: false, description: Documentation::Arguments.filter
+                end
+              end
+            end
+
+            private
+
+            def resolve_scope(authorize, policy, scope_class, base_scope)
+              if authorize
+                policy.constantize.const_get(scope_class).new(context[:current_user], base_scope).resolve
+              else
+                base_scope
+              end
+            end
+
+            def apply_pagination(scope, page, per_page)
+              return scope unless page.present? && scope.respond_to?(:offset)
+
+              scope.offset(page * per_page).limit(per_page)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/BlockLength, Metrics/ModuleLength, Metrics/ParameterLists

data/lib/groovestack/base/graphql/subscriptions/{event_handler.rb → trigger.rb}

@@ -4,7 +4,7 @@ module Groovestack
   module Base
     module GraphQL
       module Subscriptions
-        class EventHandler
+        class Trigger
           def self.trigger(subscription, args, event, kwargs)
             triggered = false