k_domain 0.0.20 → 0.0.27

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Schema is re-shaped into a format designed for domain modeling
+class Step2DomainModels < KDomain::DomainModel::Step
+  # Map database schema to domain model
+  def call
+    raise 'Rails model path not supplied' if opts[:model_path].nil?
+
+    domain[:models] = database_tables.map { |table| model(table) }
+  end
+
+  def model(table)
+    table_name = table[:name].to_s
+    model_name = table_name.singularize
+
+    model = {
+      name: model_name,
+      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                # will be set in step8_domain_columns
+    }
+
+    attach_columns(model)
+  end
+
+  def primary_key(table)
+    {
+      name: table[:primary_key],
+      type: table[:primary_key_type],
+      exist: !table[:primary_key].nil?
+    }
+  end
+
+  def attach_columns(model)
+    table = find_table_for_model(model)
+    columns = columns(table[:columns])
+    columns = insert_primary_key(model, columns)
+    model[:columns] = columns
+    model
+  end
+
+  def columns(db_columns)
+    db_columns.map do |db_column|
+      column_data(db_column[:name]).merge(
+        type: check_type(db_column[:type]),
+        precision: db_column[:precision],
+        scale: db_column[:scale],
+        default: db_column[:default],
+        null: db_column[:null],
+        limit: db_column[:limit],
+        array: db_column[:array]
+      )
+    end
+  end
+
+  def insert_primary_key(model, columns)
+    return columns unless model[:pk][:exist]
+
+    column = column_data('id').merge(
+      type: check_type(model[:pk][:type])
+    )
+
+    columns.unshift(column)
+    columns
+  end
+
+  def check_type(type)
+    type = type.to_sym if type.is_a?(String)
+
+    return type if %i[string integer bigint bigserial boolean float decimal datetime date hstore text jsonb].include?(type)
+
+    if type.nil?
+      guard('nil type detected for db_column[:type]')
+
+      return :string
+    end
+
+    guard("new type detected for db_column[:type] - #{type}")
+
+    camel.parse(type.to_s).downcase
+  end
+
+  def column_data(name)
+    {
+      name: name,
+      name_plural: name.pluralize,
+      type: nil,
+      precision: nil,
+      scale: nil,
+      default: nil,
+      null: nil,
+      limit: nil,
+      array: nil
+    }
+  end
+
+  # # Location of source code
+  # def location(table_name, model_name)
+  #   file_normal = File.join(opts[:model_path], "#{model_name}.rb")
+  #   file_custom = File.join(opts[:model_path], "#{table_name}.rb")
+  #   file_exist  = true
+  #   state = []
+
+  #   if File.exist?(file_normal)
+  #     file = file_normal
+  #     state.push(:has_ruby_model)
+  #   elsif File.exist?(file_custom)
+  #     file = file_custom
+  #     state.push(:has_ruby_model)
+  #     state.push(:nonconventional_name)
+  #   else
+  #     file = ''
+  #     file_exist = false
+  #   end
+
+  #   {
+  #     file: file,
+  #     exist: file_exist,
+  #     state: state
+  #   }
+  # end
+end

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

@@ -5,7 +5,7 @@ class Step4RailsResourceModels < KDomain::DomainModel::Step
   attr_accessor :ruby_code
 
   def call
-    raise 'ERD path not supplied' if opts[:erd_path].nil?
+    raise 'Model path not supplied' if opts[:model_path].nil?
 
     self.rails_resource_models = domain_models.map do |model|
       locate_rails_model(model[:name], model[:table_name])
@@ -15,8 +15,8 @@ class Step4RailsResourceModels < KDomain::DomainModel::Step
   private
 
   def locate_rails_model(model_name, table_name)
-    file_normal = File.join(opts[:erd_path], "#{model_name}.rb")
-    file_custom = File.join(opts[:erd_path], "#{table_name}.rb")
+    file_normal = File.join(opts[:model_path], "#{model_name}.rb")
+    file_custom = File.join(opts[:model_path], "#{table_name}.rb")
     file_exist  = true
     state = []
 

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Locate rails model files
+class Step5RailsResourceRoutes < KDomain::DomainModel::Step
+  def call
+    return warning('Routes .json file not supplied') if opts[:route_path].nil?
+    return warning('Routes .json file not found') unless File.exist?(opts[:route_path])
+
+    warning('Controller path not supplied. Routes will be loaded but not paired with a controller') if opts[:controller_path].nil?
+
+    self.rails_resource_routes = load_routes(opts[:route_path], opts[:controller_path])
+  end
+
+  private
+
+  def load_routes(route_path, controller_path)
+    json = File.read(route_path)
+    root = JSON.parse(json, symbolize_names: true)
+    routes = root[:routes]
+
+    routes.map { |route| map_route(route, controller_path) }
+  end
+
+  def map_route(route, controller_path)
+    return route.merge({ file: '', exist: false }) if controller_path.nil?
+
+    controller_file = File.join(controller_path, route[:controller_file])
+
+    route.merge(
+      {
+        file: controller_file,
+        exist: File.exist?(controller_file)
+      }
+    )
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Locate rails model files
+class Step6RailsStructureModels < KDomain::DomainModel::Step
+  def call
+    raise 'Rails model path not supplied' unless opts[:model_path]
+
+    # THIS IS NOT WORKING YET
+    self.rails_structure_models = rails_resource_models.map do |resource|
+      process_resource(OpenStruct.new(resource))
+    end
+
+    attach_behavior_and_functions
+  end
+
+  private
+
+  def process_resource(resource)
+    {
+      model_name: resource.model_name,
+      table_name: resource.table_name,
+      file: resource.file,
+      exist: resource.exist,
+      state: resource.state,
+      code: resource.exist ? File.read(resource.file) : '',
+      behaviours: {},
+      functions: {}
+    }
+
+    # return @model unless  resource.exist
+
+    # @model[:behaviours] = extract_behavior(resource.file)
+    # @model[:functions] = extract_functions(resource.file)
+
+    # @model
+  end
+
+  def attach_behavior_and_functions
+    rails_structure_models.select { |model| model[:exist] }.each do |model|
+      # puts "model: #{model[:model_name]}"
+      model[:behaviours] = extract_behavior(model[:file])
+      klass_name = model[:behaviours][:class_name]
+      model[:functions] = extract_functions(klass_name)
+    end
+  end
+
+  def extract_behavior(file)
+    extractor.extract(file)
+    extractor.model
+  end
+
+  def extract_functions(klass_name)
+    klass = klass_type(klass_name)
+
+    return {} if klass.nil?
+
+    Peeky.api.build_class_info(klass.new).to_h
+  rescue StandardError => e
+    log.exception(e)
+  end
+
+  def klass_type(klass_name)
+    Module.const_get(klass_name.classify)
+  rescue NameError
+    puts ''
+    puts klass_name
+    puts klass_name.classify
+    puts klass_name.pluralize
+    puts 'Trying the pluralized version: '
+    Module.const_get(klass_name.pluralize)
+  end
+
+  def extractor
+    @extractor ||= KDomain::RailsCodeExtractor::ExtractModel.new(shim_loader)
+  end
+
+  def shim_loader
+    return opts[:shim_loader] if !opts[:shim_loader].nil? && opts[:shim_loader].is_a?(KDomain::RailsCodeExtractor::ShimLoader)
+
+    shim_loader = KDomain::RailsCodeExtractor::ShimLoader.new
+    # Shims to attach generic class_info writers
+    shim_loader.register(:attach_class_info           , KDomain::Gem.resource('templates/ruby_code_extractor/attach_class_info.rb'))
+    shim_loader.register(:behaviour_accessors         , KDomain::Gem.resource('templates/ruby_code_extractor/behaviour_accessors.rb'))
+
+    # Shims to support standard active_record DSL methods
+    shim_loader.register(:active_record               , KDomain::Gem.resource('templates/rails/active_record.rb'))
+
+    # Shims to support application specific [module, class, method] implementations for suppression and exception avoidance
+    shim_loader
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Locate rails controller files
+class Step7RailsStructureControllers < KDomain::DomainModel::Step
+  attr_accessor :controllers
+
+  def call
+    raise 'Rails controller path not supplied' unless opts[:controller_path]
+
+    @controllers = {}
+
+    rails_resource_routes.map do |route|
+      process_route(OpenStruct.new(route))
+    end
+
+    self.rails_structure_controllers = controllers.keys.map { |key| controllers[key] }
+
+    attach_behavior_and_functions
+  end
+
+  private
+
+  def process_route(route)
+    if new_controller?(route)
+      new_controller(route)
+    else
+      controller = @controllers[route[:controller_file]]
+      controller[:actions] << new_action(route)
+    end
+  end
+
+  def new_controller?(route)
+    !controllers.key?(route[:controller_file])
+  end
+
+  def new_controller(route)
+    controllers[route[:controller_file]] = {
+      name: route[:controller_name],
+      path: route[:controller_path],
+      namespace: route[:controller_namespace],
+      file: route[:controller_file],
+      exist: route[:controller_exist],
+      full_file: route[:file],
+      behaviours: {},
+      functions: {},
+      actions: [new_action(route)]
+    }
+  end
+
+  def new_action(route)
+    {
+      route_name: route[:name],
+      action: route[:action],
+      uri_path: route[:uri_path],
+      mime_match: route[:mime_match],
+      verbs: route[:verbs]
+    }
+  end
+
+  def attach_behavior_and_functions
+    rails_structure_controllers.sort_by! { |controller| controller[:full_file] }
+
+    rails_structure_controllers.select { |controller| controller[:exist] }.each do |controller|
+      # puts "controller: #{controller[:full_file]}"
+      unless File.exist?(controller[:full_file])
+        log.error 'Controller apparently exists but no file found, this means that you need re-run rake routes'
+        puts controller[:full_file]
+        next
+      end
+      controller[:behaviours] = extract_behavior(controller[:full_file])
+      klass_name = controller[:behaviours][:class_name]
+      controller[:functions] = extract_functions(klass_name, controller[:full_file])
+    end
+  end
+
+  def extract_behavior(file)
+    # puts file
+    extractor.extract(file)
+    extractor.controller
+  end
+
+  def extractor
+    @extractor ||= KDomain::RailsCodeExtractor::ExtractController.new(shim_loader)
+  end
+
+  def shim_loader
+    return opts[:shim_loader] if !opts[:shim_loader].nil? && opts[:shim_loader].is_a?(KDomain::RailsCodeExtractor::ShimLoader)
+
+    shim_loader = KDomain::RailsCodeExtractor::ShimLoader.new
+    # Shims to attach generic class_info writers
+    shim_loader.register(:attach_class_info           , KDomain::Gem.resource('templates/ruby_code_extractor/attach_class_info.rb'))
+    shim_loader.register(:behaviour_accessors         , KDomain::Gem.resource('templates/ruby_code_extractor/behaviour_accessors.rb'))
+
+    # Shims to support stand rails controller DSL methods
+    shim_loader.register(:action_controller           , KDomain::Gem.resource('templates/rails/action_controller.rb'))
+
+    # Shims to support application specific [module, class, method] implementations for suppression and exception avoidance
+    # shim_loader.register(:app_action_controller       , KDomain::Gem.resource('templates/advanced/action_controller.rb'))
+    # shim_loader.register(:app_controller_interceptors , KDomain::Gem.resource('templates/advanced/controller_interceptors.rb'))
+    shim_loader
+  end
+
+  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.kv 'controller_file', controller_file
+    log.exception(e, style: :short)
+    {}
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+#  columns to models
+class Step8DomainColumns < KDomain::DomainModel::Step
+  attr_reader :domain_model
+  attr_reader :domain_column
+  attr_reader :rails_model
+  attr_reader :column_name
+  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 = enrich_model(model)
+      # this will be nil if there is no rails model code
+
+      # log.warn domain_model[:name]
+      domain_model[:columns].each do |column|
+        @domain_column = column
+        @column_name = column[:name]
+        @column_symbol = column[:name].to_sym
+
+        column[:structure_type] = structure_type
+      end
+    end
+  end
+
+  def enrich_model(model)
+    # NOTE: THIS MAY GET MOVED TO DomainModel::Load#enrichment
+    @rails_model = find_rails_structure_models(model[:name])
+
+    model[:file] = @rails_model[:file]
+
+    log.error "Rails model not found for: #{model[:name]}" unless @rails_model
+
+    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 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 :deleted_at          if column_symbol == :deleted_at
+    return :encrypted_password  if column_symbol == :encrypted_password
+    return :token               if column_name.ends_with?('_token') || column_name.ends_with?('_token_iv')
+
+    :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/_.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative './shim_loader'
+require_relative './extract_model'
+require_relative './extract_controller'

data/lib/k_domain/rails_code_extractor/extract_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Takes a Rails controller and extracts DSL behaviours and custom functions (instance, class and private methods)
+module KDomain
+  module RailsCodeExtractor
+    class ExtractController
+      include KLog::Logging
+
+      attr_reader :shims_loaded
+      attr_reader :controller
+
+      def initialize(load_shim)
+        @load_shim = load_shim
+        @shims_loaded = false
+      end
+
+      def extract(file)
+        load_shims unless shims_loaded
+
+        ActionController.class_info = nil
+        # KDomain::RailsCodeExtractor.reset
+
+        load_retry(file, 10, nil)
+      rescue StandardError => e
+        log.exception(e)
+      end
+
+      private
+
+      def load_shims
+        @load_shim.call
+        @shims_loaded = true
+      end
+
+      # rubocop:disable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize
+      def load_retry(file, times, last_error)
+        return if times.negative?
+
+        # puts file
+        load(file)
+
+        @controller = ActionController::Base.class_info
+        # @controller = KDomain::RailsCodeExtractor.class_info
+
+        # get_method_info(File.base_name(file))
+      rescue StandardError => e
+        log.kv 'times', times
+        # 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
+    end
+  end
+end