groovestack-base 0.1.5

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Types
+        class BaseArgument < ::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
+
+        class BaseField < ::GraphQL::Schema::Field
+          argument_class ::Groovestack::Base::GraphQL::Types::BaseArgument
+
+          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
+
+        class BaseObject < ::GraphQL::Schema::Object
+          field_class ::Groovestack::Base::GraphQL::Types::BaseField
+        end
+
+        class SubscriptionPayload < ::Groovestack::Base::GraphQL::Types::BaseObject
+          field :event, ::GraphQL::Types::JSON, null: false
+          field :subscription, String, null: false
+          field :subscription_args, ::GraphQL::Types::JSON, null: false
+        end
+
+        class Currency < ::Groovestack::Base::GraphQL::Types::BaseObject
+          description 'A currency object'
+
+          field :code, String, null: false, description: 'currency code', method: :iso_code
+          field :symbol, String, null: false, description: 'currency symbol'
+        end
+
+        class Money < ::Groovestack::Base::GraphQL::Types::BaseObject
+          description 'A money object'
+
+          field :amount, String, null: false, description: 'amount in decimal'
+          field :currency, ::Groovestack::Base::GraphQL::Types::Currency, null: false, description: 'currency metadata'
+          field :formatted_amount, String, null: false,
+                                           description: 'amount in decimal formatted with currency symbol',
+                                           method: :format
+
+          def amount
+            object.amount.to_s
+          end
+        end
+
+        # AUTHORIZATION
+
+        class AuthorizedBaseField < BaseField
+          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
+
+        class AuthorizedBaseObject < BaseObject
+          field_class ::Groovestack::Base::GraphQL::Types::AuthorizedBaseField
+        end
+
+        class VisibleBaseField < BaseField
+          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/listeners.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module Listener
+      extend ::ActiveSupport::Concern
+
+      CORE_LISTENER = true
+
+      module ClassMethods
+        def init(_throttle_seconds: 0)
+          raise 'listener must define class method init'
+        end
+
+        def throttle(seconds)
+          wait = false
+
+          proc do |&block|
+            unless wait
+              wait = true
+
+              Thread.new do
+                block.call
+
+                sleep(seconds)
+
+                wait = false
+              end
+            end
+          end
+        end
+      end
+    end
+
+    module Listeners
+      class InitAll
+        def self.run(throttle_seconds: 0)
+          core_listeners = ObjectSpace.each_object(Class).select do |klass|
+            klass.const_defined?(:CORE_LISTENER) && klass.const_get(:CORE_LISTENER)
+          end
+          core_listeners.map { |listener| listener.init(throttle_seconds: throttle_seconds) }.flatten
+        end
+      end
+
+      class Database
+        attr_accessor :db_channel, :connection, :connection_instance
+
+        def initialize(db_channel)
+          @db_channel = db_channel
+          @connection = nil
+          @connection_instance = nil
+        end
+
+        def listen
+          Rails.logger.info "Listening to #{db_channel}"
+          ::ActiveRecord::Base.connection_pool.with_connection do |connection|
+            @connection = connection
+
+            @connection_instance = connection.instance_variable_get(:@connection)
+
+            begin
+              connection_instance.async_exec "LISTEN #{db_channel}"
+
+              loop do
+                connection_instance.wait_for_notify do |_channel, _pid, payload|
+                  yield payload if block_given?
+                end
+              end
+            ensure
+              unlisten
+            end
+          end
+        end
+
+        def unlisten
+          connection_instance.async_exec "UNLISTEN #{db_channel}"
+        end
+
+        def disconnect
+          ::ActiveRecord::Base.connection_pool.checkin(connection)
+        end
+      end
+    end
+  end
+end

data/lib/groovestack/base/pub_sub.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module PubSub
+      class GraphQLPublisher
+        include Wisper::Publisher
+
+        def trigger_event(subscription, args, event, **kwargs)
+          publish(:graphql_trigger_event, subscription, args, event, kwargs)
+        end
+      end
+
+      class GraphQLSubscriber
+        def graphql_trigger_event(subscription, args, event, kwargs)
+          ::Groovestack::Base::GraphQL::Subscriptions::EventHandler.trigger(subscription, args, event, kwargs)
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:after_initialize) do
+  ::Groovestack::Base::PubSub::GraphQLPublisher.subscribe(::Groovestack::Base::PubSub::GraphQLSubscriber.new)
+end

data/lib/groovestack/base/puma/plugin/core_cron.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'puma/plugin'
+
+# Need to pre-declare Puma::Plugin here - not sure why, but it's innocusous so leave it
+module Puma
+  class Plugin # rubocop:disable Lint/EmptyClass
+  end
+end
+
+Puma::Plugin.create do # rubocop:disable Metrics/BlockLength
+  def production?
+    ENV.fetch('RACK_ENV', 'development') == 'production'
+  end
+
+  def log(msg)
+    if production? && defined?(Rails)
+      Rails.logger.info msg
+    else
+      puts msg
+    end
+  end
+
+  def flush
+    Rails.logger.flush if production? && defined?(Rails)
+  end
+
+  def start(_launcher) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    trap('TERM') do
+      log '[core-cron] Graceful shutdown'
+      exit # rubocop:disable Rails/Exit
+    end
+
+    in_background do
+      log '[core-cron] Starting core-cron worker'
+      log '[core-cron] Waiting for CORE-CRON PGLock'
+
+      loop do
+        begin
+          core_listeners = []
+
+          # hold the command for 30 minutes
+          PgLock.new(name: 'core-cron-commander', ttl: 30.minutes.to_i, attempts: 1).lock do
+            log '[core-cron] Obtained CORE-CRON PGLock'
+
+            core_listeners = ::Groovestack::Base::Listeners::InitAll.run(throttle_seconds: 1)
+          end
+        rescue Timeout::Error
+          # normal behavior - don't do anything when this happens
+
+          # ensure channels closed and connections checked in for listeners
+          core_listeners.each(&:unlisten)
+          core_listeners.each(&:disconnect)
+        end
+
+        puts 'PGLock expired. Taking a breath before attempting to re-aquire.'
+        # Loop and keep checking for CORE-CRON command
+        sleep 14
+      end
+    end
+  end
+end

data/lib/groovestack/base/railtie.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    module CoreRailtie
+      extend ActiveSupport::Concern
+
+      CORE_ENGINE = true
+
+      included do # rubocop:disable Metrics/BlockLength
+        def dx_validations
+          []
+        end
+
+        def module_name
+          self.class.name.deconstantize.demodulize
+        end
+
+        def module_version
+          self.class.name.deconstantize.constantize::VERSION
+        end
+
+        def after_init
+          unless Rails.const_defined?('Console') && (ENV['RAILS_ENV'] || ENV.fetch('RACK_ENV', nil)) == 'development'
+            return
+          end
+
+          puts 'CORE Platform DX Mode'.bold if module_name == 'Base'
+          core_base_dx_validate
+        end
+
+        def append_migrations(app) # rubocop:disable Metrics/AbcSize
+          return if app.root.present? && root.present? && app.root.to_s.match?(root.to_s)
+
+          config.paths['db/migrate'].expanded.each do |expanded_path|
+            app.config.paths['db/migrate'] << expanded_path
+          end
+        end
+
+        def append_initializers(app) # rubocop:disable Metrics/AbcSize
+          return if app.root.present? && root.present? && app.root.to_s.match?(root.to_s)
+
+          config.paths['config/initializers'].expanded.each do |expanded_path|
+            app.config.paths['config/initializers'] << expanded_path
+          end
+        end
+
+        def core_base_dx_validate # rubocop:disable Metrics/AbcSize
+          errors = []
+          dx_validations.each do |v|
+            v[:eval].call
+          rescue StandardError
+            errors << v[:message]
+            break
+          end
+
+          if errors.length.positive?
+            print '⚠️'.brown
+            msg = "  Groovestack::#{module_name}\t#{module_version}"
+            msg += module_description if respond_to?(:module_description)
+            msg += "\t#{errors[0]}"
+          else
+            print '✔'.green
+            msg = "  Groovestack::#{module_name}\t#{module_version}"
+            msg += module_description if respond_to?(:module_description)
+          end
+
+          puts msg
+        end
+      end
+    end
+
+    class Railtie < Rails::Engine
+      include CoreRailtie
+
+      def dx_validations
+        [
+          {
+            eval: proc { require 'pg' },
+            message: "Error: 'pg' gem is required, add it your your gemfile"
+          },
+          {
+            eval: proc { require 'graphql' },
+            message: "Error: 'graphql' gem is required, add it your your gemfile"
+          }
+        ]
+      end
+
+      initializer :append_migrations do |app|
+        append_migrations app
+      end
+
+      initializer :append_initializers do |app|
+        append_initializers app
+      end
+
+      initializer :init_puma do |app|
+        return unless defined?(Puma)
+
+        unless app.root.present? && root.present? && app.root.to_s.match?(root.to_s)
+          config.paths.add('lib/groovestack/base/puma/plugin')
+          app.config.paths.add('app/lib/puma/plugin')
+          config.paths['lib/groovestack/base/puma/plugin'].expanded.each do |expanded_path|
+            app.config.paths['app/lib/puma/plugin'] << expanded_path
+          end
+        end
+      end
+
+      config.after_initialize do
+        after_init
+      end
+    end
+  end
+end

data/lib/groovestack/base/utilities/string.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# rubocop:disable  Style/SingleLineMethods
+class String
+  def black;         "\e[30m#{self}\e[0m" end
+  def red;           "\e[31m#{self}\e[0m" end
+  def green;         "\e[32m#{self}\e[0m" end
+  def brown;         "\e[33m#{self}\e[0m" end
+  def blue;          "\e[34m#{self}\e[0m" end
+  def magenta;       "\e[35m#{self}\e[0m" end
+  def cyan;          "\e[36m#{self}\e[0m" end
+  def gray;          "\e[37m#{self}\e[0m" end
+
+  def bg_black;      "\e[40m#{self}\e[0m" end
+  def bg_red;        "\e[41m#{self}\e[0m" end
+  def bg_green;      "\e[42m#{self}\e[0m" end
+  def bg_brown;      "\e[43m#{self}\e[0m" end
+  def bg_blue;       "\e[44m#{self}\e[0m" end
+  def bg_magenta;    "\e[45m#{self}\e[0m" end
+  def bg_cyan;       "\e[46m#{self}\e[0m" end
+  def bg_gray;       "\e[47m#{self}\e[0m" end
+
+  def bold;          "\e[1m#{self}\e[22m" end
+  def italic;        "\e[3m#{self}\e[23m" end
+  def underline;     "\e[4m#{self}\e[24m" end
+  def blink;         "\e[5m#{self}\e[25m" end
+  def reverse_color; "\e[7m#{self}\e[27m" end
+end
+# rubocop:enable  Style/SingleLineMethods

data/lib/groovestack/base/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Groovestack
+  module Base
+    VERSION = '0.1.5'
+  end
+end

data/lib/groovestack/base.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'dry-configurable'
+require 'graphql'
+require 'pg'
+require 'pg_lock'
+
+require 'groovestack/base/version'
+require 'groovestack/base/utilities/string'
+
+module Groovestack
+  module Base
+    module GraphQL
+      module Subscriptions
+        autoload :EventHandler, 'groovestack/base/graphql/subscriptions/event_handler'
+      end
+
+      autoload :Types, 'groovestack/base/graphql/types'
+      autoload :BaseInputObject, 'groovestack/base/graphql/base_input_object'
+      autoload :BaseMutation, 'groovestack/base/graphql/base_mutation'
+      autoload :Documentation, 'groovestack/base/graphql/documentation'
+      autoload :BaseSubscription, 'groovestack/base/graphql/base_subscription'
+      autoload :Helpers, 'groovestack/base/graphql/helpers'
+
+      module Tracers
+        autoload :AtomicMultiplexTransaction, 'groovestack/base/graphql/tracers/atomic_multiplex_transaction'
+      end
+
+      module Providers
+        module ReactAdmin
+          autoload :Resource, 'groovestack/base/graphql/providers/react_admin/resource'
+          autoload :Types, 'groovestack/base/graphql/providers/react_admin/types'
+        end
+      end
+    end
+
+    autoload :ActiveRecord, 'groovestack/base/active_record'
+    autoload :Listener, 'groovestack/base/listeners'
+    autoload :Listeners, 'groovestack/base/listeners'
+
+    autoload :PubSub, 'groovestack/base/pub_sub' if defined?(Wisper)
+    autoload :CoreRailtie, 'groovestack/base/railtie' if defined?(Rails::Railtie)
+
+    extend Dry::Configurable
+
+    DEFAULT_ERROR_MONITOR =  ::Logger.new($stdout)
+
+    # ex:
+    #   /config/initializers/core_base.rb
+
+    #   Groovestack::Base.configure do |config|
+    #     config.error_notifier.handler = Bugsnag
+    #   end
+    setting :error_notifier, reader: true do
+      setting :handler, reader: true
+      setting :notify_method, reader: true, default: :notify
+    end
+
+    setting :graphql do
+      setting :camelize, default: false
+    end
+
+    def self.notify_error(prefix, err)
+      msg = "#{[prefix, 'error'].compact.join(' ')}: #{err}"
+
+      if error_notifier&.handler.present?
+        error_notifier.handler.send(error_notifier.notify_method, msg)
+      else
+        DEFAULT_ERROR_MONITOR.error(msg)
+      end
+    end
+
+    class Error < StandardError; end
+    class WrongSchemaFormat < Groovestack::Base::Error; end
+  end
+end
+
+require 'groovestack/base/puma/plugin/core_cron' if defined?(Puma)
+
+# TODO: remove aliases after all core modules have been updated
+# to reference Groovestack::Base
+module Core
+  module Base
+    module GraphQL
+      module Subscriptions
+        EventHandler = ::Groovestack::Base::GraphQL::Subscriptions::EventHandler
+      end
+
+      Types = ::Groovestack::Base::GraphQL::Types
+      BaseInputObject = ::Groovestack::Base::GraphQL::BaseInputObject
+      BaseMutation = ::Groovestack::Base::GraphQL::BaseMutation
+      Documentation = ::Groovestack::Base::GraphQL::Documentation
+      BaseSubscription = ::Groovestack::Base::GraphQL::BaseSubscription
+      Helpers = ::Groovestack::Base::GraphQL::Helpers
+
+      module Tracers
+        AtomicMultiplexTransaction = ::Groovestack::Base::GraphQL::Tracers::AtomicMultiplexTransaction
+      end
+
+      module Providers
+        module ReactAdmin
+          Resource = ::Groovestack::Base::GraphQL::Providers::ReactAdmin::Resource
+          Types = ::Groovestack::Base::GraphQL::Providers::ReactAdmin::Types
+        end
+      end
+    end
+
+    ActiveRecord = ::Groovestack::Base::ActiveRecord
+    Listener = ::Groovestack::Base::Listener
+    Listeners = ::Groovestack::Base::Listeners
+
+    PubSub = ::Groovestack::Base::PubSub if defined?(Wisper)
+    CoreRailtie = ::Groovestack::Base::CoreRailtie if defined?(Rails::Railtie)
+
+    extend Dry::Configurable
+
+    DEFAULT_ERROR_MONITOR =  ::Logger.new($stdout)
+
+    setting :error_notifier, reader: true do
+      setting :handler, reader: true
+      setting :notify_method, reader: true, default: :notify
+    end
+
+    setting :graphql do
+      setting :camelize, default: false
+    end
+
+    def self.notify_error(prefix, err)
+      msg = "#{[prefix, 'error'].compact.join(' ')}: #{err}"
+
+      if error_notifier&.handler.present?
+        error_notifier.handler.send(error_notifier.notify_method, msg)
+      else
+        DEFAULT_ERROR_MONITOR.error(msg)
+      end
+    end
+
+    Error = ::Groovestack::Base::Error
+    WrongSchemaFormat = ::Groovestack::Base::WrongSchemaFormat
+  end
+end