k_domain 0.0.23 → 0.0.28

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/queries/_.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative './base_query'
+require_relative './domain_model_query'

data/lib/k_domain/queries/base_query.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KDomain
+  module Queries
+    class BaseQuery
+      attr_reader :domain_model
+
+      def initialize(domain_model)
+        @domain_model = domain_model
+      end
+    end
+  end
+end

data/lib/k_domain/queries/domain_model_query.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module KDomain
+  module Queries
+    # Query models found on the domain model
+    # by
+    #   has ruby file
+    #   has primary key
+    #   column count
+    #   data column count
+    #   foreign key column count
+    #   has timestamp (created_at, updated_at) columns
+    #   has created_at
+    #   has updated_at
+    #   has deleted_at
+    #   has polymorphic foreign keys
+    #   has virtual columns
+    #   virtual column filters (token, encrypted_password, etc)
+    class DomainModelQuery < BaseQuery
+      def all
+        domain_model.domain.models
+      end
+
+      def query(**filters)
+        @query = all.clone
+
+        filters.each do |key, value|
+          send("filter_#{key}", value)
+        end
+
+        @query
+      end
+
+      private
+
+      def filter_ruby(value)
+        @query.select! { |model| model.ruby? == value }
+      end
+
+      def filter_pk(value)
+        @query.select! { |model| model.pk.exist? == value }
+      end
+
+      def filter_column_count(block)
+        @query.select! { |model| block.call(model.columns.count) }
+      end
+
+      def filter_data_column_count(block)
+        @query.select! { |model| block.call(model.columns_data.count) }
+      end
+
+      def filter_foreign_key_column_count(block)
+        @query.select! { |model| block.call(model.columns_foreign_key.count) }
+      end
+      alias filter_fk_column_count filter_foreign_key_column_count
+      alias filter_fk_count filter_foreign_key_column_count
+
+      def filter_polymorphic_foreign_key_column_count(block)
+        @query.select! { |model| block.call(model.columns_foreign_type.count) }
+      end
+      alias filter_poly_fk_column_count filter_polymorphic_foreign_key_column_count
+      alias filter_poly_fk_count filter_polymorphic_foreign_key_column_count
+
+      def filter_timestamp(value)
+        @query.select! { |model| (model.columns_timestamp.count == 2) == value }
+      end
+
+      def filter_created_at(value)
+        @query.select! { |model| (model.columns.any? { |column| column.name == 'created_at' } == value) }
+      end
+
+      def filter_updated_at(value)
+        @query.select! { |model| (model.columns.any? { |column| column.name == 'updated_at' } == value) }
+      end
+
+      def filter_deleted_at(value)
+        @query.select! { |model| (model.columns.any? { |column| column.name == 'deleted_at' } == value) }
+      end
+      #   has virtual columns
+      #   virtual column filters (token, encrypted_password, etc)
+
+      # # HELP: this filter affects table rows, eg. if a table has less the 2 columns then include the table
+      # low_column:           -> (model) { model.columns.length < 5 },
+      # suspected_m2m:       -> (model) { model.columns_foreign.length == 2 && model.columns_data.length < 3 },
+      # invalid_types:        -> (model) { model.columns.any? { |c| [c.db_type, c.csharp_type, c.ruby_type].include?('******') } },
+    end
+  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/rails_code_extractor/shim_loader.rb

@@ -18,8 +18,10 @@ module KDomain
       end
 
       def call
-        # puts shim_files.map { |sf| sf[:file] }
-        shim_files.select { |sf| sf[:exist] }.each { |sf| require sf[:file] }
+        shim_files.select { |sf| sf[:exist] }.each do |sf|
+          require sf[:file]
+        end
+        nil
       end
 
       def register(name, file)

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 'main_dataset'
 
-require_relative './domain_model'
+# require_relative './domain_model'

data/lib/k_domain/schemas/domain/erd_file.rb

@@ -1,82 +1,83 @@
 # frozen_string_literal: true
+# # frozen_string_literal: true
 
-# Domain class holds a list of the entities
-module KDomain
-  module DomainModel
-    # rubocop:disable Metrics/BlockLength
-    class ErdFile < Dry::Struct
-      attribute :name                         , Types::Strict::String
-      attribute :name_plural                  , Types::Strict::String
-      attribute :dsl_file                     , Types::Strict::String
+# # Domain class holds a list of the entities
+# module KDomain
+#   module DomainModel
+#
+#     class ErdFile < Dry::Struct
+#       attribute :name                         , Types::Strict::String
+#       attribute :name_plural                  , Types::Strict::String
+#       attribute :dsl_file                     , Types::Strict::String
 
-      attribute? :source                      , Dry::Struct.optional.default(nil) do
-        attribute :ruby                       , Types::Strict::String
-        attribute :public                     , Types::Strict::String.optional.default(nil)
-        attribute :private                    , Types::Strict::String.optional.default(nil)
+#       attribute? :source                      , Dry::Struct.optional.default(nil) do
+#         attribute :ruby                       , Types::Strict::String
+#         attribute :public                     , Types::Strict::String.optional.default(nil)
+#         attribute :private                    , Types::Strict::String.optional.default(nil)
 
-        attribute? :all_methods               , Dry::Struct.optional.default(nil) do
-          attribute? :klass                   , Types::Strict::Array do
-            attribute :name                   , Types::Strict::String
-            attribute :scope                  , Types::Strict::String # .optional.default(nil)
-            attribute :class_method           , Types::Strict::Bool
-            attribute :arguments              , Types::Strict::String
-          end
-          attribute? :instance                , Types::Strict::Array do
-            attribute :name                   , Types::Strict::String
-            attribute :scope                  , Types::Strict::String # .optional.default(nil)
-            attribute :class_method           , Types::Strict::Bool
-            attribute :arguments              , Types::Strict::String
-          end
-          attribute? :instance_public         , Types::Strict::Array do
-            attribute :name                   , Types::Strict::String
-            attribute :scope                  , Types::Strict::String # .optional.default(nil)
-            attribute :class_method           , Types::Strict::Bool
-            attribute :arguments              , Types::Strict::String
-          end
-          attribute? :instance_private        , Types::Strict::Array do
-            attribute :name                   , Types::Strict::String
-            attribute :scope                  , Types::Strict::String # .optional.default(nil)
-            attribute :class_method           , Types::Strict::Bool
-            attribute :arguments              , Types::Strict::String
-          end
-        end
-      end
-      attribute? :dsl                       , Dry::Struct.optional.default(nil) do
-        attribute :default_scope            , Types::Strict::String.optional.default(nil)
+#         attribute? :all_methods               , Dry::Struct.optional.default(nil) do
+#           attribute? :klass                   , Types::Strict::Array do
+#             attribute :name                   , Types::Strict::String
+#             attribute :scope                  , Types::Strict::String # .optional.default(nil)
+#             attribute :class_method           , Types::Strict::Bool
+#             attribute :arguments              , Types::Strict::String
+#           end
+#           attribute? :instance                , Types::Strict::Array do
+#             attribute :name                   , Types::Strict::String
+#             attribute :scope                  , Types::Strict::String # .optional.default(nil)
+#             attribute :class_method           , Types::Strict::Bool
+#             attribute :arguments              , Types::Strict::String
+#           end
+#           attribute? :instance_public         , Types::Strict::Array do
+#             attribute :name                   , Types::Strict::String
+#             attribute :scope                  , Types::Strict::String # .optional.default(nil)
+#             attribute :class_method           , Types::Strict::Bool
+#             attribute :arguments              , Types::Strict::String
+#           end
+#           attribute? :instance_private        , Types::Strict::Array do
+#             attribute :name                   , Types::Strict::String
+#             attribute :scope                  , Types::Strict::String # .optional.default(nil)
+#             attribute :class_method           , Types::Strict::Bool
+#             attribute :arguments              , Types::Strict::String
+#           end
+#         end
+#       end
+#       attribute? :dsl                       , Dry::Struct.optional.default(nil) do
+#         attribute :default_scope            , Types::Strict::String.optional.default(nil)
 
-        attribute? :scopes                  , Types::Strict::Array do
-          attribute :name                   , Types::Strict::String
-          attribute :scope                  , Types::Strict::String # .optional.default(nil)
-        end
-        attribute? :belongs_to              , Types::Strict::Array do
-          attribute :name                   , Types::Strict::String
-          attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
-          attribute :raw_options            , Types::Strict::String
-        end
-        attribute? :has_one                 , Types::Strict::Array do
-          attribute :name                   , Types::Strict::String
-          attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
-          attribute :raw_options            , Types::Strict::String
-        end
-        attribute? :has_many                , Types::Strict::Array do
-          attribute :name                   , Types::Strict::String
-          attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
-          attribute :raw_options            , Types::Strict::String
-        end
-        attribute? :has_and_belongs_to_many , Types::Strict::Array do
-          attribute :name                   , Types::Strict::String
-          attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
-          attribute :raw_options            , Types::Strict::String
-        end
-        attribute? :validate_on             , Types::Strict::Array do
-          attribute :line                   , Types::Strict::String
-        end
-        attribute? :validates_on            , Types::Strict::Array do
-          attribute :name                   , Types::Strict::String
-          attribute :raw_options            , Types::Strict::String
-        end
-      end
-    end
-    # rubocop:enable Metrics/BlockLength
-  end
-end
+#         attribute? :scopes                  , Types::Strict::Array do
+#           attribute :name                   , Types::Strict::String
+#           attribute :scope                  , Types::Strict::String # .optional.default(nil)
+#         end
+#         attribute? :belongs_to              , Types::Strict::Array do
+#           attribute :name                   , Types::Strict::String
+#           attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
+#           attribute :raw_options            , Types::Strict::String
+#         end
+#         attribute? :has_one                 , Types::Strict::Array do
+#           attribute :name                   , Types::Strict::String
+#           attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
+#           attribute :raw_options            , Types::Strict::String
+#         end
+#         attribute? :has_many                , Types::Strict::Array do
+#           attribute :name                   , Types::Strict::String
+#           attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
+#           attribute :raw_options            , Types::Strict::String
+#         end
+#         attribute? :has_and_belongs_to_many , Types::Strict::Array do
+#           attribute :name                   , Types::Strict::String
+#           attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
+#           attribute :raw_options            , Types::Strict::String
+#         end
+#         attribute? :validate_on             , Types::Strict::Array do
+#           attribute :line                   , Types::Strict::String
+#         end
+#         attribute? :validates_on            , Types::Strict::Array do
+#           attribute :name                   , Types::Strict::String
+#           attribute :raw_options            , Types::Strict::String
+#         end
+#       end
+#     end
+#     # rubocop:enable Metrics/BlockLength
+#   end
+# end