jav 2.55.4

data/lib/jav/hosts/resource_record_host.rb

@@ -0,0 +1,7 @@
+module Jav
+  module Hosts
+    class ResourceRecordHost < RecordHost
+      option :resource
+    end
+  end
+end

data/lib/jav/hosts/resource_view_record_host.rb

@@ -0,0 +1,7 @@
+module Jav
+  module Hosts
+    class ResourceViewRecordHost < ViewRecordHost
+      option :resource
+    end
+  end
+end

data/lib/jav/hosts/search_scope_host.rb

@@ -0,0 +1,7 @@
+module Jav
+  module Hosts
+    class SearchScopeHost < BaseHost
+      option :scope
+    end
+  end
+end

data/lib/jav/hosts/view_record_host.rb

@@ -0,0 +1,7 @@
+module Jav
+  module Hosts
+    class ViewRecordHost < RecordHost
+      option :view
+    end
+  end
+end

data/lib/jav/hosts/visibility_host.rb

@@ -0,0 +1,12 @@
+module Jav
+  module Hosts
+    class VisibilityHost < BaseHost
+      option :parent_resource
+      option :resource
+      option :arguments
+
+      # View is optional because in filter context the view is always :index
+      option :view, optional: true
+    end
+  end
+end

data/lib/jav/html/builder.rb

@@ -0,0 +1,119 @@
+class Jav::HTML::Builder
+  class << self
+    def parse_block(record: nil, resource: nil, &block)
+      Docile.dsl_eval(Jav::HTML::Builder.new(record: record, resource: resource), &block).build
+    end
+  end
+
+  attr_accessor :wrapper_stack, :data_stack, :style_stack, :classes_stack, :show_stack, :edit_stack, :index_stack, :input_stack, :label_stack, :content_stack, :record, :resource
+
+  delegate :root_path, to: Jav::App
+  delegate :params, to: Jav::App
+  delegate :current_user, to: Jav::App
+
+  def initialize(record: nil, resource: nil)
+    @wrapper_stack = {}
+    @data_stack = {}
+    @style_stack = ""
+    @classes_stack = ""
+    @show_stack = {}
+    @edit_stack = {}
+    @index_stack = {}
+    @input_stack = {}
+    @label_stack = {}
+    @content_stack = {}
+
+    @record = record
+    @resource = resource
+  end
+
+  def get_stack(name = nil)
+    # We don't have an edit component for new so we should use edit
+    name = :edit if name == :new
+
+    send :"#{name}_stack"
+  end
+
+  def dig_stack(*names)
+    value = get_stack names.shift
+
+    if value.is_a? self.class
+      value.dig_stack(*names)
+    else
+      value
+    end
+  end
+
+  # payload or block
+  def data(payload = nil, &block)
+    assign_property :data, payload, &block
+  end
+
+  # payload or block
+  def style(payload = nil, &block)
+    assign_property :style, payload, &block
+  end
+
+  # payload or block
+  def classes(payload = nil, &block)
+    assign_property :classes, payload, &block
+  end
+
+  # Takes a block
+  def wrapper(&block)
+    capture_block :wrapper, &block
+  end
+
+  # Takes a block
+  def input(&block)
+    capture_block :input, &block
+  end
+
+  # Takes a block
+  def label(&block)
+    capture_block :label, &block
+  end
+
+  # Takes a block
+  def content(&block)
+    capture_block :content, &block
+  end
+
+  # Takes a block
+  def show(&block)
+    capture_block :show, &block
+  end
+
+  # Takes a block
+  def edit(&block)
+    capture_block :edit, &block
+  end
+
+  # Takes a block
+  def index(&block)
+    capture_block :index, &block
+  end
+
+  # Fetch the menu
+  def build
+    self
+  end
+
+  protected
+
+  # Capture and parse the blocks for the nested structure
+  def capture_block(property = nil, &block)
+    send(:"#{property}_stack=", self.class.parse_block(record: record, resource: resource, &block).build)
+  end
+
+  # Parse the properties and assign them to the blocks
+  def assign_property(property = :data, payload = nil, &block)
+    value = if block.present?
+              Jav::Hosts::RecordHost.new(block: block, record: record).handle
+            else
+              payload
+            end
+
+    send(:"#{property}_stack=", value)
+  end
+end

data/lib/jav/items_holder.rb

@@ -0,0 +1,81 @@
+module Jav
+  class ItemsHolder
+    attr_reader :tools
+    attr_accessor :items, :invalid_fields
+
+    def initialize
+      @items = []
+      @items_index = 0
+      @invalid_fields = []
+    end
+
+    # Adds a field to the bag
+    def field(field_name, **args, &block)
+      field_parser = Jav::Dsl::FieldParser.new(id: field_name, order_index: @items_index, **args, &block).parse
+
+      if field_parser.invalid?
+        as = args.fetch(:as, nil)
+
+        # End execution ehre and add the field to the invalid_fileds payload so we know to wanr the developer about that.
+        # @todo: Make sure this warning is still active
+        return add_invalid_field({
+                                   name: field_name,
+                                   as: as,
+                                   # resource: resource_class.name,
+                                   message: "There's an invalid field configuration for this resource. <br/> <code class='px-1 py-px rounded-sm bg-red-600'>field :#{field_name}, as: #{as}</code>"
+                                 })
+      end
+
+      add_item field_parser.instance
+    end
+
+    def tabs(instance)
+      add_item instance
+    end
+
+    def tab(name, **args, &block)
+      add_item Jav::TabBuilder.parse_block(name: name, **args, &block)
+    end
+
+    def row(**args, &block)
+      add_item Jav::RowBuilder.parse_block(**args, &block)
+    end
+
+    def tool(klass, **args)
+      instance = klass.new(**args)
+      add_item instance
+    end
+
+    def panel(panel_name = nil, **args, &block)
+      panel = Jav::PanelBuilder.parse_block(name: panel_name, **args, &block)
+
+      add_item panel
+    end
+
+    def heading(body = nil, **args, &block)
+      field = Jav::Fields::HeadingField.new(body, **args)
+
+      add_item field
+    end
+
+    def sidebar(instance)
+      add_item instance
+    end
+
+    def add_item(instance)
+      @items << instance
+
+      increment_order_index
+    end
+
+    private
+
+    def add_invalid_field(payload)
+      @invalid_fields << payload
+    end
+
+    def increment_order_index
+      @items_index += 1
+    end
+  end
+end

data/lib/jav/licensing/community_license.rb

@@ -0,0 +1,6 @@
+module Jav
+  module Licensing
+    class CommunityLicense < License
+    end
+  end
+end

data/lib/jav/licensing/h_q.rb

@@ -0,0 +1,243 @@
+module Jav
+  module Licensing
+    class HQ
+      attr_accessor :current_request, :cache_store
+
+      ENDPOINT = "https://javhq.io/api/v1/licenses/check".freeze unless const_defined?(:ENDPOINT)
+      REQUEST_TIMEOUT = 5 unless const_defined?(:REQUEST_TIMEOUT) # seconds
+      CACHE_TIME = 3600 * 12 unless const_defined?(:CACHE_TIME) # seconds
+
+      class << self
+        def cache_key
+          "jav.hq-#{Jav::VERSION.parameterize}.response"
+        end
+      end
+
+      def initialize(current_request = nil)
+        @current_request = current_request
+        @cache_store = Jav::App.cache_store
+      end
+
+      def response
+        { 'id' => 'pro',
+          'valid' => true,
+          'payload' => {},
+          'expiry' => 3600,
+          'fetched_at' => Time.zone.now,
+          'license' => 'pro',
+          'license_key' => nil }
+        # expire_cache_if_overdue
+        # ::Rails.cache.fetch(self.class.cache_key) do
+        #   { 'id' => 'pro',
+        #     'valid' => true,
+        #     'payload' => {},
+        #     'expiry' => 3600,
+        #     'fetched_at' => Time.zone.now,
+        #     'license' => 'pro',
+        #     'license_key' => nil }
+        # end
+      end
+
+      # Some cache stores don't auto-expire their keys and payloads so we need to do it for them
+      def expire_cache_if_overdue
+        return unless cached_response.present?
+        return unless cached_response["fetched_at"].present?
+
+        allowed_time = 1.hour
+        parsed_time = Time.parse(cached_response["fetched_at"].to_s)
+        time_has_passed = parsed_time < Time.now - allowed_time
+
+        clear_response if time_has_passed
+      end
+
+      def fresh_response
+        clear_response
+
+        make_request
+      end
+
+      def clear_response
+        # cache_store.delete self.class.cache_key
+      end
+
+      def payload
+        result = {
+          license: Jav.configuration.license,
+          license_key: Jav.configuration.license_key,
+          jav_version: Jav::VERSION,
+          rails_version: Rails::VERSION::STRING,
+          ruby_version: RUBY_VERSION,
+          environment: Rails.env,
+          ip: current_request&.ip,
+          host: current_request&.host,
+          port: current_request&.port,
+          app_name: app_name
+        }
+
+        metadata = jav_metadata
+        result[:jav_metadata] = metadata if metadata[:resources_count] != 0
+
+        result
+      end
+
+      def jav_metadata
+        resources = App.resources
+        dashboards = App.dashboards
+        field_definitions = resources.map(&:get_field_definitions)
+        fields_count = field_definitions.map(&:count).sum
+        fields_per_resource = format("%0.01f", fields_count / (resources.count + 0.0))
+
+        field_types = {}
+        custom_fields_count = 0
+        field_definitions.each do |fields|
+          fields.each do |field|
+            field_types[field.type] ||= 0
+            field_types[field.type] += 1
+
+            custom_fields_count += 1 if field.custom?
+          end
+        end
+
+        {
+          resources_count: resources.count,
+          dashboards_count: dashboards.count,
+          fields_count: fields_count,
+          fields_per_resource: fields_per_resource,
+          custom_fields_count: custom_fields_count,
+          field_types: field_types,
+          **other_metadata(:actions),
+          **other_metadata(:filters),
+          main_menu_present: Jav.configuration.main_menu.present?,
+          profile_menu_present: Jav.configuration.profile_menu.present?,
+          cache_store: Jav::App.cache_store&.class&.to_s,
+          **config_metadata
+        }
+      rescue StandardError => e
+        {
+          error: e.message
+        }
+      end
+
+      def cached_response
+        response
+        # cache_store.read self.class.cache_key
+      end
+
+      private
+
+        def make_request
+          return cached_response if has_cached_response
+
+          begin
+            perform_and_cache_request
+          rescue Errno::EHOSTUNREACH => exception
+            cache_and_return_error "HTTP host not reachable error.", exception.message
+          rescue Errno::ECONNRESET => exception
+            cache_and_return_error "HTTP connection reset error.", exception.message
+          rescue Errno::ECONNREFUSED => exception
+            cache_and_return_error "HTTP connection refused error.", exception.message
+          rescue OpenSSL::SSL::SSLError => exception
+            cache_and_return_error "OpenSSL error.", exception.message
+          rescue HTTParty::Error => exception
+            cache_and_return_error "HTTP client error.", exception.message
+          rescue Net::OpenTimeout => exception
+            cache_and_return_error "Request timeout.", exception.message
+          rescue Net::ReadTimeout => exception
+            cache_and_return_error "Request timeout.", exception.message
+          rescue SocketError => exception
+            cache_and_return_error "Connection error.", exception.message
+          end
+        end
+
+        def perform_and_cache_request
+          hq_response = perform_request
+
+          return cache_and_return_error "Jav HQ Internal server error.", hq_response.body if hq_response.code == 500
+
+          return unless hq_response.code == 200
+
+          cache_response response: hq_response.parsed_response
+        end
+
+        def cache_response(response: nil, time: CACHE_TIME)
+          response = normalize_response response
+
+          response.merge!(
+            expiry: time,
+            fetched_at: Time.now,
+            **payload
+          ).stringify_keys!
+
+          # cache_store.write(self.class.cache_key, response, expires_in: time)
+
+          response
+        end
+
+        def normalize_response(response)
+          if response.is_a? Hash
+            response
+          else
+            {
+              normalized_response: JSON.stringify(response)
+            }
+          end
+          response.merge({})
+        rescue StandardError
+          {
+            normalized_response: "rescued"
+          }
+        end
+
+        def perform_request
+          ::Rails.logger.debug "[Jav] Performing request to javhq.io API to check license availability." if Rails.env.development?
+
+          if Rails.env.test?
+            OpenStruct.new({ code: 200, parsed_response: { id: "pro", valid: true } })
+          else
+            HTTParty.post ENDPOINT, body: payload.to_json, headers: { 'Content-type': "application/json" }, timeout: REQUEST_TIMEOUT
+          end
+        end
+
+        def app_name
+          Rails.application.class.to_s.split("::").first
+        rescue StandardError
+          nil
+        end
+
+        def other_metadata(type = :actions)
+          resources = App.resources
+
+          types = resources.map(&:"get_#{type}")
+          type_count = types.flatten.uniq.count
+          type_per_resource = format("%0.01f", types.map(&:count).sum / (resources.count + 0.0))
+
+          {
+            "#{type}_count": type_count,
+            "#{type}_per_resource": type_per_resource
+          }
+        end
+
+        def config_metadata
+          {
+            config: {
+              root_path: Jav.configuration.root_path,
+              app_name: Jav.configuration.app_name
+            }
+          }
+        end
+
+        def cache_and_return_error(error, exception_message = "")
+          cache_response response: {
+            id: Jav.configuration.license,
+            valid: true,
+            error: error,
+            exception_message: exception_message
+          }.stringify_keys, time: 5.minutes.to_i
+        end
+
+        def has_cached_response
+          # cache_store.exist? self.class.cache_key
+        end
+    end
+  end
+end

data/lib/jav/licensing/license.rb

@@ -0,0 +1,69 @@
+module Jav
+  module Licensing
+    class License
+      attr_accessor :id, :response, :valid, :payload
+
+      def initialize(response = {})
+        @response = response
+        @id = response["id"]
+        @valid = response["valid"]
+        @payload = response["payload"]
+      end
+
+      def valid?
+        valid
+      end
+
+      def invalid?
+        !valid?
+      end
+
+      def pro?
+        id == "pro"
+      end
+
+      def error
+        @response["error"]
+      end
+
+      def properties
+        @response.slice("valid", "id", "error").symbolize_keys
+      end
+
+      def abilities
+        []
+      end
+
+      def can(ability)
+        abilities.include? ability
+      end
+
+      def cant(ability)
+        !can ability
+      end
+
+      alias has can
+      alias lacks cant
+
+      # Returns if has ability and if is a valid license or app is in development.
+      def has_with_trial(ability)
+        return can(ability) && valid? if Rails.env.production?
+
+        true
+      end
+
+      # Returns if lacks ability and if is a valid license or app is in development.
+      def lacks_with_trial(ability)
+        !has_with_trial ability
+      end
+
+      def name
+        if id.present?
+          id.humanize
+        else
+          self.class.to_s.split('::').last.underscore.humanize.gsub ' license', ''
+        end
+      end
+    end
+  end
+end

data/lib/jav/licensing/license_manager.rb

@@ -0,0 +1,24 @@
+module Jav
+  module Licensing
+    class LicenseManager
+      def initialize(hq_response)
+        @hq_response = hq_response
+      end
+
+      def license
+        case @hq_response["id"]
+        when "community"
+          CommunityLicense.new @hq_response
+        when "pro"
+          ProLicense.new @hq_response
+        else
+          NilLicense.new @hq_response
+        end
+      end
+
+      def self.refresh_license(request)
+        new(Licensing::HQ.new(request).fresh_response).license
+      end
+    end
+  end
+end

data/lib/jav/licensing/nil_license.rb

@@ -0,0 +1,14 @@
+module Jav
+  module Licensing
+    class NilLicense < License
+      def initialize(response = nil)
+        response ||= {
+          id: "community",
+          valid: true
+        }
+
+        super
+      end
+    end
+  end
+end

data/lib/jav/licensing/pro_license.rb

@@ -0,0 +1,26 @@
+module Jav
+  module Licensing
+    class ProLicense < License
+      def abilities
+        %i[
+          authorization
+          localization
+          custom_tools
+          custom_fields
+          resource_tools
+          global_search
+          enhanced_search_results
+          searchable_associations
+          resource_ordering
+          dashboards
+          menu_editor
+          stimulus_js_integration
+          resource_show_controls
+          branding
+          resource_sidebar
+          advanced_fields
+        ]
+      end
+    end
+  end
+end

data/lib/jav/loaders/actions_loader.rb

@@ -0,0 +1,6 @@
+module Jav
+  module Loaders
+    class ActionsLoader < Loader
+    end
+  end
+end

data/lib/jav/loaders/fields_loader.rb

@@ -0,0 +1,27 @@
+module Jav
+  module Loaders
+    class FieldsLoader < Loader
+      def add_field(field)
+        @bag.push field
+      end
+
+      def method_missing(method, *args, &block)
+        matched_field = Jav::App.fields.find do |field|
+          field[:name].to_s == method.to_s
+        end
+
+        if matched_field.present? && matched_field[:class].present?
+          klass = matched_field[:class]
+
+          field = if block.present?
+            klass.new(args[0], **args[1] || {}, &block)
+          else
+            klass.new(args[0], **args[1] || {})
+          end
+
+          add_field field
+        end
+      end
+    end
+  end
+end

data/lib/jav/loaders/filters_loader.rb

@@ -0,0 +1,6 @@
+module Jav
+  module Loaders
+    class FiltersLoader < Loader
+    end
+  end
+end

data/lib/jav/loaders/loader.rb

@@ -0,0 +1,15 @@
+module Jav
+  module Loaders
+    class Loader
+      attr_accessor :bag
+
+      def initialize
+        @bag = []
+      end
+
+      def use(klass)
+        @bag.push klass
+      end
+    end
+  end
+end

data/lib/jav/main_panel.rb

@@ -0,0 +1,3 @@
+class Jav::MainPanel < Jav::Panel
+  class_attribute :item_type, default: :main_panel
+end