motor-admin 0.1.37 → 0.1.43

data/lib/motor/build_schema.rb

@@ -58,11 +58,11 @@ module Motor
 
     module_function
 
-    def call
+    def call(cache_keys = {})
       schema = LoadFromRails.call
-      schema = MergeSchemaConfigs.call(schema)
+      schema = MergeSchemaConfigs.call(schema, cache_keys)
 
-      ReorderSchema.call(schema)
+      ReorderSchema.call(schema, cache_keys)
     end
   end
 end

data/lib/motor/build_schema/find_display_column.rb

@@ -3,35 +3,38 @@
 module Motor
   module BuildSchema
     module FindDisplayColumn
-      DISPLAY_NAMES = %w[
-        name
-        full_name
-        fullname
-        last_name
-        lastname
-        first_name
-        firstname
-        fname
-        lname
-        sname
-        phone
-        phone_number
-        email
-        domain
-        phone
-        company
-        filename
-        file_name
-        title
-        url
-        make
-        brand
-        manufacturer
-        model
-        address
-      ].freeze
-
-      DISPLAY_NAME_REGEXP = Regexp.new(Regexp.union(DISPLAY_NAMES).source, Regexp::IGNORECASE)
+      DISPLAY_NAMES = Set.new(
+        %w[
+          name
+          full_name
+          fullname
+          last_name
+          lastname
+          first_name
+          firstname
+          fname
+          lname
+          sname
+          company
+          domain
+          website
+          title
+          phone
+          phone_number
+          email
+          phone
+          filename
+          file_name
+          url
+          make
+          brand
+          manufacturer
+          model
+          address
+        ]
+      ).freeze
+
+      DISPLAY_NAME_REGEXP = Regexp.new(Regexp.union(DISPLAY_NAMES.to_a).source, Regexp::IGNORECASE)
 
       module_function
 

data/lib/motor/build_schema/load_from_rails.rb

@@ -4,6 +4,7 @@ module Motor
   module BuildSchema
     module LoadFromRails
       MUTEX = Mutex.new
+      UNIFIED_TYPES = ActiveRecordUtils::Types::UNIFIED_TYPES
 
       module_function
 
@@ -20,8 +21,7 @@ module Motor
       def models
         eager_load_models!
 
-        models = load_descendants(ActiveRecord::Base).uniq
-        models = models.reject(&:abstract_class)
+        models = ActiveRecord::Base.descendants.reject(&:abstract_class)
 
         models -= Motor::ApplicationRecord.descendants
         models -= [Motor::Audit]
@@ -32,12 +32,6 @@ module Motor
         models
       end
 
-      def load_descendants(model)
-        model.descendants + model.descendants.flat_map do |klass|
-          load_descendants(klass)
-        end
-      end
-
       def build_model_schema(model)
         model_name = model.name
 
@@ -92,10 +86,13 @@ module Motor
       end
 
       def build_table_column(column, model, default_attrs)
+        is_enum = model.defined_enums[column.name]
+
         {
           name: column.name,
           display_name: column.name.humanize,
-          column_type: ActiveRecordUtils::Types::UNIFIED_TYPES[column.type.to_s] || column.type.to_s,
+          column_type: is_enum ? 'string' : UNIFIED_TYPES[column.type.to_s] || column.type.to_s,
+          is_array: column.array?,
           access_type: COLUMN_NAME_ACCESS_TYPES.fetch(column.name, ColumnAccessTypes::READ_WRITE),
           default_value: default_attrs[column.name],
           validators: fetch_validators(model, column.name),
@@ -136,17 +133,24 @@ module Motor
           default_value: default_attrs[column_name],
           validators: fetch_validators(model, column_name, ref),
           format: {},
-          reference: {
-            name: name,
-            model_name: ref.klass.name.underscore,
-            reference_type: ref.belongs_to? ? 'belongs_to' : 'has_one',
-            foreign_key: ref.foreign_key,
-            polymorphic: ref.polymorphic? || is_attachment
-          },
+          reference: build_reference(name, ref),
           virtual: false
         }
       end
 
+      def build_reference(name, reflection)
+        is_attachment = reflection.klass.name == 'ActiveStorage::Attachment'
+
+        {
+          name: name,
+          display_name: name.humanize,
+          model_name: reflection.klass.name.underscore,
+          reference_type: reflection.belongs_to? ? 'belongs_to' : 'has_one',
+          foreign_key: reflection.foreign_key,
+          polymorphic: reflection.polymorphic? || is_attachment
+        }
+      end
+
       def fetch_associations(model)
         model.reflections.map do |name, ref|
           next if ref.has_one? || ref.belongs_to?
@@ -181,6 +185,10 @@ module Motor
             []
           end
 
+        enum = model.defined_enums[column_name]
+
+        validators += [{ includes: enum.keys }] if enum
+
         validators += model.validators_on(column_name).map do |validator|
           build_validator_hash(validator)
         end.compact
@@ -210,6 +218,14 @@ module Motor
           else
             Rails.application.eager_load!
           end
+
+          ActiveRecord::Base.descendants.each do |model|
+            model.reflections.each do |_, ref|
+              ref.klass
+            rescue StandardError
+              next
+            end
+          end
         end
       end
     end

data/lib/motor/build_schema/merge_schema_configs.rb

@@ -12,9 +12,10 @@ module Motor
       module_function
 
       # @param schema [Array<HashWithIndifferentAccess>]
+      # @param cache_keys [Hash]
       # @return [Array<HashWithIndifferentAccess>]
-      def call(schema)
-        configs = load_configs
+      def call(schema, cache_keys = {})
+        configs = load_configs(cache_keys)
 
         schema.map do |model|
           merge_model(model, configs.fetch(model[:name], {}))
@@ -120,9 +121,12 @@ module Motor
         end.compact
       end
 
+      # @param cache_keys [Hash]
       # @return [HashWithIndifferentAccess<String, HashWithIndifferentAccess>]
-      def load_configs
-        Motor::Resource.all.each_with_object(HashWithIndifferentAccess.new) do |resource, acc|
+      def load_configs(cache_keys)
+        resources = Motor::Configs::LoadFromCache.load_resources(cache_key: cache_keys[:resources])
+
+        resources.each_with_object(HashWithIndifferentAccess.new) do |resource, acc|
           acc[resource.name] = resource.preferences
         end
       end

data/lib/motor/build_schema/reorder_schema.rb

@@ -16,10 +16,11 @@ module Motor
 
     module_function
 
+    # @param cache_keys [Hash]
     # @param schema [Array<HashWithIndifferentAccess>]
     # @return [Array<HashWithIndifferentAccess>]
-    def call(schema)
-      configs = load_configs
+    def call(schema, cache_keys = {})
+      configs = load_configs(cache_keys)
 
       schema = sort_by_name(schema, configs['resources.order'])
 
@@ -64,6 +65,8 @@ module Motor
       end
     end
 
+    # @param columns [Array<HashWithIndifferentAccess>]
+    # @return [Array<HashWithIndifferentAccess>]
     def sort_columns(columns)
       columns.each_with_object([]) do |column, acc|
         weight = COLUMNS_DEFAULT_ORDER_WEIGHTS.fetch(column[:name], COLUMNS_DEFAULT_ORDER_WEIGHT)
@@ -72,9 +75,12 @@ module Motor
       end.flatten.compact
     end
 
+    # @param cache_keys [Hash]
     # @return [Hash<String, HashWithIndifferentAccess>]
-    def load_configs
-      Motor::Config.all.each_with_object({}) do |config, acc|
+    def load_configs(cache_keys = {})
+      configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_keys[:configs])
+
+      configs.each_with_object({}) do |config, acc|
         acc[config.key] = config.value
       end
     end

data/lib/motor/configs.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    FILE_PATH = 'config/motor.yml'
+    SYNC_API_PATH = '/motor_configs_sync'
+    SYNC_ACCESS_KEY = ENV.fetch('MOTOR_SYNC_API_KEY', '')
+  end
+end
+
+require_relative './configs/load_from_cache'
+require_relative './configs/build_ui_app_tag'
+require_relative './configs/build_configs_hash'
+require_relative './configs/write_to_file'
+require_relative './configs/sync_from_hash'
+require_relative './configs/sync_from_file'
+require_relative './configs/sync_with_remote'

data/lib/motor/configs/build_configs_hash.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module BuildConfigsHash
+      module_function
+
+      def call
+        cache_keys = LoadFromCache.load_cache_keys
+
+        normalize_hash(
+          engine_version: Motor::VERSION,
+          file_version: cache_keys.values.compact.max.to_time,
+          resources: build_resources_hash(cache_keys[:resources]),
+          configs: build_configs_hash(cache_keys[:configs]),
+          queries: build_queries_hash(cache_keys[:queries]),
+          dashboards: build_dashboards_hash(cache_keys[:dashboards]),
+          forms: build_forms_hash(cache_keys[:forms]),
+          alerts: build_alerts_hash(cache_keys[:alerts])
+        )
+      end
+
+      def build_queries_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_queries(cache_key: cache_key).sort_by(&:id).map do |query|
+          query.slice(%i[id name sql_body description preferences])
+               .merge(tags: query.tags.map(&:name), updated_at: query.updated_at.to_time)
+        end
+      end
+
+      def build_dashboards_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_dashboards(cache_key: cache_key).sort_by(&:id).map do |dashboard|
+          dashboard.slice(%i[id title description preferences])
+                   .merge(tags: dashboard.tags.map(&:name), updated_at: dashboard.updated_at.to_time)
+        end
+      end
+
+      def build_alerts_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_alerts(cache_key: cache_key).sort_by(&:id).map do |alert|
+          alert.slice(%i[id name query_id to_emails is_enabled description preferences])
+               .merge(tags: alert.tags.map(&:name), updated_at: alert.updated_at.to_time)
+        end
+      end
+
+      def build_forms_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_forms(cache_key: cache_key).sort_by(&:id).map do |form|
+          form.slice(%i[id name http_method api_path description preferences])
+              .merge(tags: form.tags.map(&:name), updated_at: form.updated_at.to_time)
+        end
+      end
+
+      def build_configs_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key).sort_by(&:key).map do |config|
+          {
+            key: config.key,
+            value: config.value,
+            updated_at: config.updated_at.to_time
+          }
+        end
+      end
+
+      def build_resources_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_resources(cache_key: cache_key).sort_by(&:name).map do |resource|
+          {
+            name: resource.name,
+            preferences: resource.preferences,
+            updated_at: resource.updated_at.to_time
+          }
+        end
+      end
+
+      def normalize_hash(value)
+        case value
+        when Hash, HashWithIndifferentAccess
+          value.to_h.stringify_keys.transform_values { |v| normalize_hash(v) }
+        when Array
+          value.map { |e| normalize_hash(e) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/motor/configs/build_ui_app_tag.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module BuildUiAppTag
+      CACHE_STORE =
+        if Motor.development?
+          ActiveSupport::Cache::NullStore.new
+        else
+          ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
+        end
+
+      module_function
+
+      def call
+        cache_keys = LoadFromCache.load_cache_keys
+
+        CACHE_STORE.fetch(cache_keys.hash) do
+          CACHE_STORE.clear
+
+          Motor::ApplicationController.helpers.content_tag(
+            :div, '', id: 'app', data: build_data(cache_keys)
+          )
+        end
+      end
+
+      # @return [Hash]
+      def build_data(cache_keys = {})
+        {
+          base_path: Motor::Admin.routes.url_helpers.motor_path,
+          schema: Motor::BuildSchema.call(cache_keys),
+          header_links: header_links_data_hash(cache_keys[:configs]),
+          queries: queries_data_hash(cache_keys[:queries]),
+          dashboards: dashboards_data_hash(cache_keys[:dashboards]),
+          alerts: alerts_data_hash(cache_keys[:alerts]),
+          forms: forms_data_hash(cache_keys[:forms])
+        }
+      end
+
+      def header_links_data_hash(cache_key = nil)
+        configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key)
+
+        configs.find { |c| c.key == 'header.links' }&.value || []
+      end
+
+      def queries_data_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_queries(cache_key: cache_key)
+                                     .as_json(only: %i[id name updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+
+      def dashboards_data_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_dashboards(cache_key: cache_key)
+                                     .as_json(only: %i[id title updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+
+      def alerts_data_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_alerts(cache_key: cache_key)
+                                     .as_json(only: %i[id name is_enabled updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+
+      def forms_data_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_forms(cache_key: cache_key)
+                                     .as_json(only: %i[id name updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+    end
+  end
+end

data/lib/motor/configs/load_from_cache.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module LoadFromCache
+      CACHE_STORE = ActiveSupport::Cache::MemoryStore.new(size: 10.megabytes)
+
+      module_function
+
+      def call
+        cache_keys = load_cache_keys
+
+        {
+          configs: load_configs(cache_key: cache_keys[:configs]),
+          resources: load_resources(cache_key: cache_keys[:resources]),
+          queries: load_queries(cache_key: cache_keys[:queries]),
+          dashboards: load_dashboards(cache_key: cache_keys[:dashboards]),
+          alerts: load_alerts(cache_key: cache_keys[:alerts]),
+          forms: load_forms(cache_key: cache_keys[:forms])
+        }
+      end
+
+      def load_configs(cache_key: nil)
+        maybe_fetch_from_cache('configs', cache_key) do
+          Motor::Config.all.load
+        end
+      end
+
+      def load_resources(cache_key: nil)
+        maybe_fetch_from_cache('resources', cache_key) do
+          Motor::Resource.all.load
+        end
+      end
+
+      def load_queries(cache_key: nil)
+        maybe_fetch_from_cache('queries', cache_key) do
+          Motor::Query.all.active.preload(:tags).load
+        end
+      end
+
+      def load_dashboards(cache_key: nil)
+        maybe_fetch_from_cache('dashboards', cache_key) do
+          Motor::Dashboard.all.active.preload(:tags).load
+        end
+      end
+
+      def load_alerts(cache_key: nil)
+        maybe_fetch_from_cache('alerts', cache_key) do
+          Motor::Alert.all.active.preload(:tags).load
+        end
+      end
+
+      def load_forms(cache_key: nil)
+        maybe_fetch_from_cache('forms', cache_key) do
+          Motor::Form.all.active.preload(:tags).load
+        end
+      end
+
+      def maybe_fetch_from_cache(type, cache_key, &block)
+        return block.call unless cache_key
+
+        CACHE_STORE.fetch(type + cache_key.to_s, &block)
+      end
+
+      def load_cache_keys
+        ActiveRecord::Base.connection.execute(
+          "(#{
+            [
+              Motor::Config.select("'configs', MAX(updated_at)").to_sql,
+              Motor::Resource.select("'resources', MAX(updated_at)").to_sql,
+              Motor::Dashboard.select("'dashboards', MAX(updated_at)").to_sql,
+              Motor::Alert.select("'alerts', MAX(updated_at)").to_sql,
+              Motor::Query.select("'queries', MAX(updated_at)").to_sql,
+              Motor::Form.select("'forms', MAX(updated_at)").to_sql
+            ].join(') UNION (')
+          })"
+        ).to_a.map(&:values).to_h.with_indifferent_access
+      end
+    end
+  end
+end