k_domain 0.0.23 → 0.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbbddfe9857696b7a3a02fc370c51205d584fd08aaad5f8b8605dccebab02bc1
-  data.tar.gz: c37fee293561e73b3ed4b4e31f9def8c13848217ee9c4d14efdcfc67a46d42ea
+  metadata.gz: 86f877b2fd5644c7ebd211c662cb4cd1ff63213dcc3cc588d3485f698a2bc7b9
+  data.tar.gz: 9999ee5fa153fa7c1833cd21a0a5a145cbee4a97cd11284c1bb4440157ae6d0a
 SHA512:
-  metadata.gz: 12d58c761198fe6fa8336871ab5a3475c0a1caf358c09af2005e8bab3192c82b864663b867b3f2a39d8ba7c20e58258a8981ddd6339dbdb4edec73e37bca4652
-  data.tar.gz: 0bfd25819a3425f2932ba751d9e4413b41ae2c617416751855ced16a7fc74f68eff64d87a92138c73b85b0df175f38b8b299f5912f67f8a78970926ff83a4df8
+  metadata.gz: 013e1f7524e395b9766831786cd1f4052eb6000fd35105c58bfb51869f9d1b93151f3fbc3e8fe349f59dd6819daf7d27e22a05ae5f95fba6826bf61af06eb235
+  data.tar.gz: c56d291ba618e70863e334bca9c1e817da700d6d0769e92ac5fb7d267b1f02068f6d4275e423264147066389d45dca831d3b3878eef45662d0f4ef8457d99e20

data/.builders/boot.rb

@@ -0,0 +1,40 @@
+# Boot Sequence
+
+include KLog::Logging
+
+CONFIG_KEY = :k_domain
+
+log.kv 'working folder', Dir.pwd
+
+Handlebars::Helpers.configure do |config|
+  config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_helpers.json')
+  config.helper_config_file = config_file
+
+  string_config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_string_formatters.json')
+  config.string_formatter_config_file = string_config_file
+end
+
+def builder
+  @builder ||= KBuilder::BaseBuilder.init(KConfig.configuration(CONFIG_KEY))
+end
+
+KConfig.configure(CONFIG_KEY) do |config|
+  global_template = File.expand_path('~/dev/kgems/k_templates/templates')
+  config.target_folders.add(:app, File.expand_path('../', Dir.pwd))
+  config.target_folders.add(:lib_config, :app, 'lib/k_domain/config')
+  config.template_folders.add(:global_template, global_template)
+  config.template_folders.add(:app_template, File.expand_path('.templates', Dir.pwd))
+end
+
+KConfig.configuration(CONFIG_KEY).debug
+
+area = KManager.add_area(CONFIG_KEY)
+resource_manager = area.resource_manager
+resource_manager.add_resource('https://raw.githubusercontent.com/klueless-io/k_playground/main/ruby/components/configuration/.builders/configuration_director.rb', content_type: :ruby)
+resource_manager
+  .fileset
+  .glob('*.rb', exclude: ['boot.rb'])
+  .glob('generators/**/*.rb')
+resource_manager.add_resources
+
+KManager.boot

data/.builders/generators/configuration_generator.rb

@@ -0,0 +1,22 @@
+KManager.action do
+  def on_action
+    puts '-' * 70
+    builder.cd(:lib_config)
+    director = ConfigurationDirector
+      .init(builder, on_exist: :compare)
+      .style(:single)
+      .name('Domain Configuration')
+      .main_namespace('KDomain', 'Config')
+      .add_config_key(:default_main_key, "nil")
+      .add_config_key(:default_traits, "%i[trait1 trait2 trait3]")
+      .add_config_key(:fallback_keys, "%i[]")
+      .add_config_key(:entities, "[]")
+      # .logit
+
+    # dom = director.dom
+    # data = director.data
+
+    director.add_config
+    # director.add_configuration
+  end
+end

data/.builders/run.rb

@@ -0,0 +1,16 @@
+# Run
+
+KManager.action do
+  def on_action
+  end
+end
+
+KManager.opts.app_name                    = 'KDomain Generator'
+KManager.opts.sleep                       = 5
+KManager.opts.reboot_on_kill              = 0
+KManager.opts.reboot_sleep                = 4
+KManager.opts.exception_style             = :short
+KManager.opts.show.time_taken             = true
+KManager.opts.show.finished               = true
+KManager.opts.show.finished_message       = 'FINISHED :)'
+

data/lib/k_domain/config/_.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative './config'
+require_relative './configuration'

data/lib/k_domain/config/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Usage: include KDomain::Config::
+
+module KDomain
+  module Config
+    def configuration
+      @configuration ||= KDomain::Config::Configuration.new
+    end
+
+    def reset
+      @configuration = KDomain::Config::Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/lib/k_domain/config/configuration.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module KDomain
+  module Config
+    # Configuration object for Domain Configuration
+    class Configuration
+      include KLog::Logging
+
+      ConfigModel = Struct.new(:name, :main_key, :traits)
+
+      attr_accessor :default_main_key
+      attr_accessor :default_traits
+      attr_accessor :fallback_keys
+      attr_accessor :models
+
+      def initialize
+        @default_main_key = nil
+        @default_traits = %i[trait1 trait2 trait3]
+        @fallback_keys = %i[]
+        @models = []
+      end
+
+      def model(name, main_key: nil, traits: nil)
+        @models << new_config_model(
+          name,
+          main_key: main_key || default_main_key,
+          traits: traits || default_traits
+        )
+      end
+
+      def find_model(table_name)
+        @find_model ||= Hash.new do |h, key|
+          h[key] = begin
+            entity = models.find { |e| e.name == key }
+            entity ||= new_config_model(key)
+            entity
+          end
+        end
+
+        @find_model[table_name]
+      end
+
+      def fallback_key(columns)
+        column_names = columns.each_with_object({}) do |column, hash|
+          hash[column.name.to_sym] = column.name.to_sym
+        end
+
+        fallback_keys.find { |key| column_names.key?(key) }
+      end
+
+      def debug(heading: 'Domain configuration')
+        log.structure(to_h, title: heading) # , line_width: 150, formatter: formatter)
+        ''
+      end
+
+      def to_h
+        {
+          default_main_key: default_main_key,
+          default_traits: default_traits,
+          fallback_keys: fallback_keys,
+          models: models.map(&:to_h)
+        }
+      end
+
+      private
+
+      def new_config_model(name, main_key: nil, traits: nil)
+        ConfigModel.new(
+          name,
+          main_key || default_main_key,
+          traits || default_traits
+        )
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/load.rb

@@ -23,6 +23,8 @@ module KDomain
         @raw_data = KUtil.data.json_parse(json, as: :hash_symbolized)
 
         @data = KDomain::Schemas::DomainModel.new(@raw_data)
+
+        enrichment
       end
 
       def to_h
@@ -30,6 +32,45 @@ module KDomain
 
         @raw_data
       end
+
+      private
+
+      def enrichment
+        attach_rails_model_to_domain_model
+      end
+
+      def attach_rails_model_to_domain_model
+        @data.domain.models.each do |domain_model|
+          domain_model.rails_model = @data.rails_structure.find_model(domain_model.name)
+
+          if domain_model.rails_model
+            attach_column_relations(domain_model)
+          else
+            log.error("Rails Model not found for #{domain_model.name}") unless domain_model.rails_model
+          end
+        end
+      end
+
+      def attach_column_relations(domain_model)
+        domain_model.columns.each do |column|
+          column.relationships = []
+          add_column_relations(domain_model.rails_model, column, :belongs_to)
+          add_column_relations(domain_model.rails_model, column, :has_one)
+          add_column_relations(domain_model.rails_model, column, :has_many)
+          add_column_relations(domain_model.rails_model, column, :has_and_belongs_to_many)
+        end
+      end
+
+      def add_column_relations(rails_model, column, relation_type)
+        relations = rails_model.behaviours.send(relation_type)
+
+        return if relations.nil?
+
+        relations = relations.map { |relation| { relation_type: relation_type }.merge(relation.to_h) }
+        relations.select { |relation| column[:name] == relation.dig(:opts, :foreign_key) }.each do |relation|
+          column.relationships << KDomain::Schemas::Domain::Model::Relationship.new(relation)
+        end
+      end
     end
   end
 end

data/lib/k_domain/domain_model/transform_steps/step1_db_schema.rb

@@ -8,7 +8,7 @@ module KDomain
         raise 'Schema not supplied' if opts[:db_schema].nil?
 
         self.database = opts[:db_schema].clone
-        database[:tables] = database[:tables] # .slice(156, 1)
+        database[:tables] = database[:tables] # .take(10) # .slice(156, 1)
 
         guard('tables are missing')               if database[:tables].nil?
         guard('indexes are missing')              if database[:indexes].nil?

data/lib/k_domain/domain_model/transform_steps/step2_domain_models.rb

@@ -18,7 +18,7 @@ class Step2DomainModels < KDomain::DomainModel::Step
       name_plural: table_name, # need to check if this is correct as I know it is wrong for account_history_datum
       table_name: table_name,
       pk: primary_key(table),
-      file: nil
+      file: nil                # will be set in step8_domain_columns
     }
 
     attach_columns(model)

data/lib/k_domain/domain_model/transform_steps/step7_rails_structure_controllers.rb

@@ -66,7 +66,7 @@ class Step7RailsStructureControllers < KDomain::DomainModel::Step
       end
       controller[:behaviours] = extract_behavior(controller[:full_file])
       klass_name = controller[:behaviours][:class_name]
-      controller[:functions] = extract_functions(klass_name)
+      controller[:functions] = extract_functions(klass_name, controller[:full_file])
     end
   end
 
@@ -97,13 +97,15 @@ class Step7RailsStructureControllers < KDomain::DomainModel::Step
     shim_loader
   end
 
-  def extract_functions(klass_name)
+  def extract_functions(klass_name, controller_file)
     klass = Module.const_get(klass_name.classify)
 
     class_info = Peeky.api.build_class_info(klass.new)
 
     class_info.to_h
   rescue StandardError => e
-    log.exception(e)
+    log.kv 'controller_file', controller_file
+    log.exception(e, style: :short)
+    {}
   end
 end

data/lib/k_domain/domain_model/transform_steps/step8_domain_columns.rb

@@ -9,15 +9,15 @@ class Step8DomainColumns < KDomain::DomainModel::Step
   attr_reader :column_symbol
 
   def call
+    @debug = true
     enrich_columns
   end
 
   def enrich_columns
     # .select {|m| m[:name] == 'app_user'}
     domain_models.each do |model|
-      @domain_model = model
+      @domain_model = enrich_model(model)
       # this will be nil if there is no rails model code
-      @rails_model = find_rails_structure_models(domain_model[:name])
 
       # log.warn domain_model[:name]
       domain_model[:columns].each do |column|
@@ -25,75 +25,29 @@ class Step8DomainColumns < KDomain::DomainModel::Step
         @column_name = column[:name]
         @column_symbol = column[:name].to_sym
 
-        attach_foreign_key
         column[:structure_type] = structure_type
       end
     end
   end
 
-  def expand_column(column)
-    foreign_table = lookup_foreign_table(column_name)
-    is_foreign = !foreign_table.nil?
-    # is_foreign = foreign_key?(column_name)
-    structure_type = structure_type(is_foreign)
-
-    column.merge({
-                   structure_type: structure_type,
-                   foreign_key: is_foreign,
-                   foreign_table: (foreign_table || '').singularize,
-                   foreign_table_plural: (foreign_table || '').pluralize
-                 })
-  end
-
-  def lookup_foreign_table(column_name)
-    foreign_table = find_foreign_table(table[:name], column_name)
-
-    return foreign_table if foreign_table
-
-    cn = column_name.to_s
-
-    if cn.ends_with?('_id')
-      table_name = column_name[0..-4]
-      table_name_plural = table_name.pluralize
-
-      if table_name_exist?(table_name_plural.to_s)
-        investigate(step: :step8_columns,
-                    location: :lookup_foreign_table,
-                    key: column_name,
-                    message: "#{@table[:name]}.#{column_name} => #{table_name_plural} - Relationship not found in DB, so have inferred this relationship. You may want to check that this relation is correct")
-
-        return table_name
-      end
-
-      investigate(step: :step8_columns,
-                  location: :lookup_foreign_table,
-                  key: column_name,
-                  message: "#{@table[:name]}.#{column_name} => #{table_name_plural} - Table not found for a column that looks like foreign_key")
-    end
-
-    nil
-  end
+  def enrich_model(model)
+    # NOTE: THIS MAY GET MOVED TO DomainModel::Load#enrichment
+    @rails_model = find_rails_structure_models(model[:name])
 
-  def attach_foreign_key
-    return if rails_model.nil? || rails_model[:behaviours].nil? || rails_model[:behaviours][:belongs_to].nil?
+    model[:file] = @rails_model[:file]
 
-    foreign = rails_model[:behaviours][:belongs_to].find { |belong| belong[:opts][:foreign_key].to_sym == domain_column[:name].to_sym }
+    log.error "Rails model not found for: #{model[:name]}" unless @rails_model
 
-    return unless foreign
-
-    # NEED TO PRE-LOAD the table, table_plural and model
-    domain_column[:foreign_table] = 'xxx1'
-    domain_column[:foreign_table_plural] = 'xxx3'
-    domain_column[:foreign_model] = 'xxx2'
+    model
   end
 
   # Need some configurable data dictionary where by
   # _token can be setup on a project by project basis
   def structure_type
     return :primary_key         if domain_model[:pk][:name] == column_name
-    return :foreign_key         if domain_column[:foreign_table]
+    return :foreign_key         if foreign_relationship?
+    return :foreign_type        if column_symbol == :context_type || column_symbol == :element_type
 
-    return :timestamp           if column_symbol == :created_at || column_symbol == :updated_at
     return :timestamp           if column_symbol == :created_at || column_symbol == :updated_at
     return :deleted_at          if column_symbol == :deleted_at
     return :encrypted_password  if column_symbol == :encrypted_password
@@ -101,4 +55,45 @@ class Step8DomainColumns < KDomain::DomainModel::Step
 
     :data
   end
+
+  def foreign_relationship?
+    return false if rails_model.nil? || rails_model[:behaviours].nil? || rails_model[:behaviours][:belongs_to].nil?
+
+    column_name = domain_column[:name].to_sym
+    rails_model[:behaviours][:belongs_to].any? { |belong| belong[:opts][:foreign_key].to_sym == column_name }
+  end
+
+  # def attach_relationships
+  #   domain_column[:relationships] = []
+  #   return if rails_model.nil? || rails_model[:behaviours].nil? || rails_model[:behaviours][:belongs_to].nil?
+
+  #   column_name = domain_column[:name].to_sym
+
+  #   attach_column_relationships(column_name)
+  # end
+
+  # def select_belongs_to(column_name)
+  #   rails_model[:behaviours][:belongs_to].select { |belong| belong[:opts][:foreign_key].to_sym == column_name.to_sym }
+  # end
+
+  # # this just maps basic relationship information,
+  # # to go deeper you really need to use the Rails Model Behaviours
+  # def attach_column_relationships(column_name)
+  #   select_belongs_to(column_name).each do |belongs_to|
+  #     domain_column[:relationships] << map_belongs_to(belongs_to)
+  #   end
+  # end
+
+  # def map_belongs_to(belongs_to)
+  #   @domain_column[:structure_type] = :foreign_key
+  #   # result = {
+  #   #   type: :belongs_to,
+  #   #   name: belongs_to[:name],
+  #   #   foreign_key: belongs_to.dig(:opts, :foreign_key) || @domain_column[:name],
+  #   # }
+
+  #   # result[:primary_key] = belongs_to.dig(:opts, :primary_key) if belongs_to.dig(:opts, :primary_key)
+  #   # result[:class_name] = belongs_to.dig(:opts, :class_name) if belongs_to.dig(:opts, :class_name)
+  #   result
+  # end
 end

data/lib/k_domain/rails_code_extractor/extract_controller.rb

@@ -48,9 +48,11 @@ module KDomain
         # puts e.message
         if e.is_a?(NameError) && e.message != last_error&.message
           log.kv('add module', e.name)
+          log.kv 'file', file
           eval("module #{e.name}; end")
           return load_retry(file, times - 1, e)
         end
+        log.kv 'file', file
         log.exception(e, style: :short, method_info: method(__callee__))
       end
       # rubocop:enable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize

data/lib/k_domain/rails_code_extractor/extract_model.rb

@@ -58,9 +58,11 @@ module KDomain
         # puts e.message
         if e.is_a?(NameError) && e.message != last_error&.message
           log.kv('add module', e.name)
+          log.kv 'file', file
           eval("module #{e.name}; end")
           return load_retry(file, times - 1, e)
         end
+        log.kv 'file', file
         log.exception(e, style: :short, method_info: method(__callee__))
       end
       # rubocop:enable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize

data/lib/k_domain/raw_db_schema/transform.rb

@@ -7,16 +7,29 @@
 # builds the hash
 module KDomain
   module RawDbSchema
+    # class TransformFilter
+    #   attr_accessor :take
+    #   def initialize(take: :all)
+    #     @take = take
+    #   end
+    # end
+
     class Transform
       include KLog::Logging
 
       attr_reader :source_file
       attr_accessor :template_file
       attr_reader :schema_loader
+      attr_reader :filter
 
-      def initialize(source_file)
+      # @param [String] source_file Rails Schema file
+      # @param [OpenStruct] filter Settings for filtering data before transformation, this is useful during debugging
+      # examples
+      #   filter = os(run: 1, tables: os(offset: 10, limit: 10))
+      def initialize(source_file, filter)
         @source_file = source_file
         @template_file = KDomain::Gem.resource('templates/load_schema.rb')
+        @filter = filter
       end
 
       def call
@@ -73,11 +86,22 @@ module KDomain
 
         loader = LoadSchema.new
         loader.load_schema
-        loader.schema
+
+        apply_filter(loader.schema)
       rescue StandardError => e
         log.exception(e)
       end
       # rubocop:enable Security/Eval
+
+      # rubocop:disable Metrics/AbcSize
+      def apply_filter(schema)
+        return schema unless filter.active == 1
+
+        schema[:tables] = schema[:tables].slice(filter.table.offset, filter.table.limit) || [] if filter.table.offset.is_a?(Integer) && filter.table.limit.is_a?(Integer)
+
+        schema
+      end
+      # rubocop:enable Metrics/AbcSize
     end
   end
 end

data/lib/k_domain/schemas/_.rb

@@ -11,6 +11,8 @@ require_relative 'rails_structure'
 require_relative 'investigate'
 require_relative 'database'
 require_relative 'dictionary'
+require_relative 'domain_types'
 require_relative 'domain'
+require_relative 'domain_model'
 
-require_relative './domain_model'
+# require_relative './domain_model'