groovestack-base 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21487aa70317a98995fd2f11993f6679972cfbedfb0727e78abe72c8db9b352c
+  data.tar.gz: e673c4e3a53e23f6c16cc4337c7bb38ff3684a74d87b8c6aab3b2b70170039e5
+SHA512:
+  metadata.gz: f7d41d9614e4dba925d3cdee07c0978230538219e0e8caef9ffeb0bfc297f938a9d64f7afb00106c299a7d835a591b724fbd15ddfd3624c225bd2a4feac7053c
+  data.tar.gz: c843c0f90a34b5bd64460fb6e872684d46d1bee0daf0faef9045fe4a791cbfda48c97225bbf815b43fef3d520544c69a630efb15598bcf2b8491e21d1e36537a

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,44 @@
+require:
+  - rubocop-graphql
+  - rubocop-rails
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.1.3
+
+GraphQL/FieldDescription:
+  Enabled: false
+
+GraphQL/ObjectDescription:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+    - '*.gemspec'
+
+Metrics/MethodLength:
+  Max: 20
+
+# TODO: reenable and replace puts / logs with global, configurable logger
+Rails/Output:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/RedundantConstantBase:
+  Enabled: false
+
+
+
+# Style/StringLiterals:
+#   Enabled: true
+#   EnforcedStyle: double_quotes
+
+# Style/StringLiteralsInInterpolation:
+#   Enabled: true
+#   EnforcedStyle: double_quotes
+
+# Layout/LineLength:
+#   Max: 120

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## [0.1.5] - 2025-05-06
+
+- Add CHANGELOG
+- Update gemspec to new `groovestack` namespace

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in groovestack-base.gemspec
+gemspec
+
+gem 'minitest', '~> 5.0'
+gem 'rake', '~> 12.0'
+gem 'rspec'
+gem 'rubocop', require: false

data/config/initializers/graphql.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module BaseDSLMethods
+        def default_graphql_name
+          @default_graphql_name ||= begin
+            if name.nil?
+              raise ::GraphQL::RequiredImplementationMissingError,
+                    'Anonymous class should declare a `graphql_name`'
+            end
+
+            # ex name: "GraphQL::User::Type"
+            # ex name: "GraphQL::Admin::User::Type"
+
+            graphql_name = name.split('GraphQL').last.split('Types::').last.split('::Type').first.gsub('::', '')
+            # TODO: refactor
+            # assumption here that graphql schema has an admin namespace.
+            graphql_name.gsub('Admin', '')
+          end
+        end
+      end
+    end
+  end
+end

data/config.ru

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :development
+
+# Combustion.schema_format = :sql
+# Combustion.initialize!  :active_record
+
+# # Combustion.initialize! :all
+# run Combustion::Application

data/groovestack-base.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'lib/groovestack/base/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'groovestack-base'
+  spec.version = Groovestack::Base::VERSION
+  spec.authors = ['Darren Rush']
+  spec.email = ['dlrush@gmail.com']
+
+  spec.summary = 'Shared extensions for CORE modules'
+  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.required_ruby_version = '>= 3.1.0'
+
+  spec.metadata['allowed_push_host'] = "https://rubygems.org"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/talysto/groovestack-core/'
+  spec.metadata['changelog_uri'] = 'https://github.com/talysto/groovestack-core/'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', '~> 7.0'
+  spec.add_dependency 'dry-configurable', '~> 1.0'
+  spec.add_dependency 'graphql', '~> 2.5'
+  spec.add_dependency 'pg', '~> 1.0'
+  spec.add_dependency 'pg_lock', '~> 1.0'
+  spec.add_dependency 'puma', '~> 5.0'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/lib/groovestack/base/active_record.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module ActiveRecord
+      module Authorization
+        module FieldsForSerialization
+          extend ActiveSupport::Concern
+
+          # required for memoization during graphql serialization
+          def authorized_fields_for_serialization(user)
+            @authorized_fields_for_serialization ||= Pundit.policy!(user, self).permitted_attributes_for_show
+            @authorized_fields_for_serialization
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      class BaseInputObject < ::GraphQL::Schema::InputObject
+        argument_class ::Groovestack::Base::GraphQL::Types::BaseArgument
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      class BaseMutation < ::GraphQL::Schema::Mutation
+        argument_class ::Groovestack::Base::GraphQL::Types::BaseArgument
+
+        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

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      class BaseSubscription < ::GraphQL::Schema::Subscription
+        argument_class ::Groovestack::Base::GraphQL::Types::BaseArgument
+        field_class ::Groovestack::Base::GraphQL::Types::BaseField
+        object_class ::Groovestack::Base::GraphQL::Types::BaseObject
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Documentation
+        # rubocop:disable Style/OpenStructUse
+        Arguments = OpenStruct.new({
+                                     id: 'a unique record identifier',
+                                     page: 'page number of the paginated results',
+                                     per_page: 'number of records per page of the paginated results',
+                                     sort_field: 'field to sort the results by (i.e. created_at)',
+                                     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
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Helpers
+        module Types
+          module StatusEventVirtualAttributes
+            def all_events
+              object.class.aasm.events.map { |event| event.name.to_s }
+            end
+
+            def permitted_events
+              object.aasm.events(permitted: true).map { |event| event.name.to_s }
+            end
+
+            def status_events
+              all = all_events
+              permitted = permitted_events
+
+              all.map do |event|
+                { name: event.titleize, key: event, enabled: permitted.include?(event) }
+              end
+            end
+          end
+
+          module Typified
+            extend ActiveSupport::Concern
+
+            included do
+              field :type, String, null: true, resolver_method: :object_type
+
+              def object_type
+                object.class.to_s if object.respond_to?(:class)
+              end
+            end
+          end
+        end
+
+        module Mutations
+          module StatusEvents
+            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
+
+          module InstanceMethods
+            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
+
+        module Controller
+          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/providers/react_admin/resource.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# TODO: refactor according to rubocop suggestions
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Providers
+        module ReactAdmin
+          module Resource # rubocop:disable Metrics/ModuleLength
+            extend ActiveSupport::Concern
+
+            class_methods do # rubocop:disable Metrics/BlockLength
+              # TODO: make authorize default to true
+
+              # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+              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)
+                # NOTE: class_name is only required if a custom _base_scope is not defined
+                # NOTE graphql_path is only required to override the default graphql path
+
+                graphql_namespace = graphql_path&.dup&.concat('::')
+                entity_model_name = entity.to_s.classify
+                entity_class = class_name || entity_model_name
+                entity_type = (graphql_type || "#{graphql_namespace}#{entity_model_name}::Type").constantize
+                entity_filter_type = (graphql_filter || "#{graphql_namespace}#{entity_model_name}::Filter").constantize
+                except = args.delete(:except) || []
+                policy ||= "#{entity_class}Policy"
+                base_scope = begin
+                  entity_class.constantize.unscoped
+                rescue StandardError
+                  nil
+                end
+
+                # resolver_method for Record
+
+                unless except.include?(:find)
+                  define_method entity_model_name.to_sym do |id:|
+                    scope = if authorize
+                              policy.constantize::ShowScope.new(context[:current_user],
+                                                                base_scope).resolve
+                            else
+                              base_scope
+                            end
+                    scope.find id
+                  end
+                end
+
+                # resolver_method for Collection
+
+                unless except.include?(:collection)
+                  define_method entity do |page: nil, per_page: nil, **attrs|
+                    scope = if authorize
+                              policy.constantize::IndexScope.new(context[:current_user],
+                                                                 base_scope).resolve
+                            else
+                              base_scope
+                            end
+                    scope = send("#{entity}_scope", **attrs, base_scope: scope)
+                    scope = scope.offset(page * per_page).limit(per_page) if page.present? && scope.respond_to?(:offset)
+                    scope
+                  end
+                end
+
+                # resolver_method for Collection meta
+
+                unless except.include?(:collection_meta)
+                  define_method :"#{entity}_meta" do |page: nil, per_page: nil, **attrs| # rubocop:disable Lint/UnusedBlockArgument
+                    scope = if authorize
+                              policy.constantize::IndexScope.new(context[:current_user],
+                                                                 base_scope).resolve
+                            else
+                              base_scope
+                            end
+                    { count: send("#{entity}_scope", **attrs, base_scope: scope).size }
+                  end
+                end
+
+                # Record
+
+                unless except.include?(:find)
+                  field entity_model_name.to_sym, entity_type,
+                        null: true,
+                        visibility_permission: visibility_permission,
+                        resolver_method: entity_model_name.to_sym,
+                        description: "Find #{entity_class}." do
+                    argument :id, ::GraphQL::Types::ID, required: true, description: Documentation::Arguments.id
+                  end
+                end
+
+                # Collection
+
+                unless except.include?(:collection)
+                  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
+
+                # Collection meta
+
+                return if except.include?(:collection_meta)
+
+                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
+              # rubocop:enable Metrics/ParameterLists, Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/subscriptions/event_handler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Subscriptions
+        class EventHandler
+          def self.trigger(subscription, args, event, kwargs)
+            triggered = false
+
+            ::GraphQL::Schema.descendants.each do |schema|
+              subscription_type = schema.types['Subscription'] || schema.types['SubscriptionType']
+              next if subscription_type.blank?
+              next unless schema.get_fields(subscription_type).keys.include?(subscription.to_s)
+
+              triggered = true
+              schema.subscriptions.trigger(subscription, args, event, **kwargs)
+            end
+
+            puts 'app schema not defined' unless triggered
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/graphql/tracers/atomic_multiplex_transaction.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Tracers
+        # The AtmoicMultiplexTransaction module provides a mechanism to execute GraphQL multiplex queries
+        # within a database transaction. If any of the queries in the multiplex is a mutation, the entire
+        # multiplex is executed within a transaction. If an error occurs during the execution of a mutation,
+        # the transaction is rolled back, and the errors are returned with null data.
+        #
+        # Methods:
+        # - execute_multiplex(multiplex:): Executes the provided multiplex within a transaction if any of the
+        #   queries is a mutation. If an error occurs during the execution of a mutation, the transaction is
+        #   rolled back, and the errors are returned with null data.
+        #
+
+        # NOTE: This module assumes that the multiplex object responds to `queries` and each query
+        # responds to `mutation?`.
+
+        module AtomicMultiplexTransaction
+          # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+          def execute_multiplex(multiplex:)
+            is_mutation = multiplex.queries.any?(&:mutation?)
+
+            return yield unless is_mutation
+
+            results = nil
+            rollback = false
+
+            begin
+              ::ActiveRecord::Base.transaction do
+                results = yield
+
+                rollback = results.any? do |result|
+                  result.is_a?(::GraphQL::Query::Result) && result.to_h['errors'].present?
+                end
+
+                raise ::ActiveRecord::Rollback if rollback
+
+                results
+              end
+            rescue ::ActiveRecord::Rollback
+              rollback = true
+            end
+
+            return results unless rollback
+
+            # IF rollback, extract errors and return null for data
+
+            results.map do |result|
+              ::GraphQL::Query::Result.new(
+                query: result.query,
+                values: result.to_h.merge('data' => nil)
+              )
+            end
+          end
+          # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        end
+      end
+    end
+  end
+end