k_domain 0.0.20 → 0.0.23

data/lib/k_domain/domain_model/transform_steps/{step3_attach_columns.rb → step8_domain_columns.rb}

@@ -1,67 +1,36 @@
 # frozen_string_literal: true
 
-# Attach columns to models
-class Step3AttachColumns < KDomain::DomainModel::Step
-  attr_accessor :table
+#  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
-    build_columns
+    enrich_columns
   end
 
-  def build_columns
+  def enrich_columns
+    # .select {|m| m[:name] == 'app_user'}
     domain_models.each do |model|
-      @table = find_table_for_model(model)
-      columns = columns(table[:columns])
-      columns = insert_primary_key(model, columns)
-      model[:columns] = columns
-    end
-  end
-
-  def column_data(name)
-    @column_name   = name
-    @column_symbol = name.to_sym
-    {
-      name: name,
-      name_plural: name.pluralize,
-      type: nil,
-      precision: nil,
-      scale: nil,
-      default: nil,
-      null: nil,
-      limit: nil,
-      array: nil
-    }
-  end
-
-  def columns(db_columns)
-    db_columns.map do |db_column|
-      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]
-      )
-
-      expand_column(column)
+      @domain_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|
+        @domain_column = column
+        @column_name = column[:name]
+        @column_symbol = column[:name].to_sym
+
+        attach_foreign_key
+        column[:structure_type] = structure_type
+      end
     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(expand_column(column))
-    columns
-  end
-
   def expand_column(column)
     foreign_table = lookup_foreign_table(column_name)
     is_foreign = !foreign_table.nil?
@@ -76,22 +45,6 @@ class Step3AttachColumns < KDomain::DomainModel::Step
                  })
   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 lookup_foreign_table(column_name)
     foreign_table = find_foreign_table(table[:name], column_name)
 
@@ -104,7 +57,7 @@ class Step3AttachColumns < KDomain::DomainModel::Step
       table_name_plural = table_name.pluralize
 
       if table_name_exist?(table_name_plural.to_s)
-        investigate(step: :step3_attach_columns,
+        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")
@@ -112,7 +65,7 @@ class Step3AttachColumns < KDomain::DomainModel::Step
         return table_name
       end
 
-      investigate(step: :step3_attach_columns,
+      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")
@@ -121,11 +74,25 @@ class Step3AttachColumns < KDomain::DomainModel::Step
     nil
   end
 
+  def attach_foreign_key
+    return if rails_model.nil? || rails_model[:behaviours].nil? || rails_model[:behaviours][:belongs_to].nil?
+
+    foreign = rails_model[:behaviours][:belongs_to].find { |belong| belong[:opts][:foreign_key].to_sym == domain_column[:name].to_sym }
+
+    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'
+  end
+
   # Need some configurable data dictionary where by
   # _token can be setup on a project by project basis
-  def structure_type(is_foreign)
-    return :foreign_key         if is_foreign
-    return :primary_key         if column_symbol == :id
+  def structure_type
+    return :primary_key         if domain_model[:pk][:name] == column_name
+    return :foreign_key         if domain_column[:foreign_table]
+
     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

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,59 @@
+# 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)
+          eval("module #{e.name}; end")
+          return load_retry(file, times - 1, e)
+        end
+        log.exception(e, style: :short, method_info: method(__callee__))
+      end
+      # rubocop:enable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize
+    end
+  end
+end

data/lib/k_domain/rails_code_extractor/extract_model.rb

@@ -19,9 +19,9 @@ module KDomain
       def extract(file)
         load_shims unless shims_loaded
 
-        ActiveRecord.current_class = nil
+        ActiveRecord.class_info = nil
 
-        load_retry(file, 10)
+        load_retry(file, 10, nil)
       rescue StandardError => e
         log.exception(e)
       end
@@ -34,23 +34,34 @@ module KDomain
       end
 
       # rubocop:disable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize
-      def load_retry(file, times)
+      def load_retry(file, times, last_error)
         return if times.negative?
 
         load(file)
 
-        @model = ActiveRecord.current_class
+        @model = ActiveRecord.class_info
+
+        if @model.nil?
+          # puts ''
+          # puts file
+          # puts 'class probably has no DSL methods'
+          @model = {
+            class_name: File.basename(file, File.extname(file)).classify
+          }
+        end
+
         @models << @model
 
         # get_method_info(File.base_name(file))
       rescue StandardError => e
-        puts e.message
-        if e.is_a?(NameError)
+        log.kv 'times', times
+        # puts e.message
+        if e.is_a?(NameError) && e.message != last_error&.message
           log.kv('add module', e.name)
           eval("module #{e.name}; end")
-          return load_retry(path, times - 1)
+          return load_retry(file, times - 1, e)
         end
-        log.exception(e)
+        log.exception(e, style: :short, method_info: method(__callee__))
       end
       # rubocop:enable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize
     end

data/lib/k_domain/rails_code_extractor/shim_loader.rb

@@ -18,6 +18,7 @@ module KDomain
       end
 
       def call
+        # puts shim_files.map { |sf| sf[:file] }
         shim_files.select { |sf| sf[:exist] }.each { |sf| require sf[:file] }
       end
 

data/lib/k_domain/raw_db_schema/load.rb

@@ -22,7 +22,7 @@ module KDomain
         json = File.read(source_file)
         @raw_data = KUtil.data.json_parse(json, as: :hash_symbolized)
 
-        @data = KDomain::Database::Schema.new(@raw_data)
+        @data = KDomain::Schemas::Database.new(@raw_data)
       end
 
       def to_h

data/lib/k_domain/raw_db_schema/transform.rb

@@ -11,7 +11,7 @@ module KDomain
       include KLog::Logging
 
       attr_reader :source_file
-      attr_reader :template_file
+      attr_accessor :template_file
       attr_reader :schema_loader
 
       def initialize(source_file)
@@ -24,6 +24,7 @@ module KDomain
         # log.kv 'template_file', template_file
         # log.kv 'source_file?', File.exist?(source_file)
         # log.kv 'template_file?', File.exist?(template_file)
+
         log.error "Template not found: #{template_file}" unless File.exist?(template_file)
 
         content = File.read(source_file)

data/lib/k_domain/schemas/_.rb

@@ -9,8 +9,8 @@ end
 require_relative 'rails_resource'
 require_relative 'rails_structure'
 require_relative 'investigate'
-require_relative 'database/_'
+require_relative 'database'
 require_relative 'dictionary'
-require_relative 'domain/_'
+require_relative 'domain'
 
 require_relative './domain_model'

data/lib/k_domain/schemas/database.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# KDomain::Schemas::Domain::Column
+# KDomain::Schemas::Domain::Model
+
+module KDomain
+  module Schemas
+    class Database < Dry::Struct
+      class ForeignKey < Dry::Struct
+        attribute :left                 , Types::Strict::String
+        attribute :right                , Types::Strict::String
+        attribute :name?                , Types::Strict::String.optional.default(nil)
+        attribute :on_update?           , Types::Strict::String.optional.default(nil)
+        attribute :on_delete?           , Types::Strict::String.optional.default(nil)
+        attribute :column?              , Types::Strict::String.optional.default(nil)
+      end
+
+      class Index < Dry::Struct
+        attribute :name                 , Types::Strict::String
+        attribute :fields               , Types::Nominal::Any.optional.default('xxxxx1')
+        attribute :using                , Types::Nominal::String
+        attribute :order?               , Types::Nominal::Hash
+        attribute :where?               , Types::Nominal::Any.optional.default(nil)
+        attribute :unique?              , Types::Nominal::Any.optional.default(nil)
+      end
+
+      class View < Dry::Struct
+        attribute :name                 , Types::Strict::String
+        attribute :materialized         , Types::Strict::Bool
+        attribute :sql_definition       , Types::Nominal::String
+      end
+
+      class Table < Dry::Struct
+        class RailsSchema < Dry::Struct
+          attribute :primary_key          , Types::Nominal::Any.optional.default(nil)
+          attribute :id                   , Types::Nominal::Any.optional.default(nil)
+          attribute :force                , Types::Nominal::Any.optional.default(nil)
+        end
+
+        class Column < Dry::Struct
+          attribute :name                 , Types::Strict::String
+          attribute :type                 , Types::Strict::String
+          attribute :precision?           , Types::Strict::Integer.optional.default(nil)
+          attribute :scale?               , Types::Strict::Integer.optional.default(nil)
+          attribute :default?             , Types::Nominal::Any.optional.default(nil)
+          attribute :array?               , Types::Strict::Bool.optional.default(nil)
+          attribute :null?                , Types::Strict::Bool.optional.default(nil)
+          attribute :limit?               , Types::Strict::Integer.optional.default(nil)
+        end
+
+        attribute :name                   , Types::Strict::String
+        attribute :primary_key            , Types::Strict::String.optional.default(nil)
+        attribute :primary_key_type       , Types::Strict::String.optional.default(nil)
+        attribute :id?                    , Types::Nominal::Any.optional.default(nil)
+        attribute :columns                , Types::Strict::Array.of(KDomain::Schemas::Database::Table::Column)
+        attribute :indexes                , Types::Strict::Array.of(KDomain::Schemas::Database::Index)
+        attribute :rails_schema           , KDomain::Schemas::Database::Table::RailsSchema
+      end
+
+      class DbInfo < Dry::Struct
+        attribute :type                 , Types::Strict::String
+        attribute :version              , Types::Nominal::Any.optional.default(nil)
+        attribute :extensions           , Types::Strict::Array
+      end
+
+      class UniqueKey < Dry::Struct
+        attribute :type                 , Types::Strict::String
+        attribute :category             , Types::Strict::String.optional
+        attribute :key                  , Types::Strict::String
+        attribute :keys                 , Types::Strict::Array
+      end
+
+      class Meta < Dry::Struct
+        attribute :rails                , Types::Strict::Integer
+        attribute :db_info              , KDomain::Schemas::Database::DbInfo
+        attribute :unique_keys          , Types::Strict::Array.of(KDomain::Schemas::Database::UniqueKey)
+      end
+
+      attribute :tables               , Types::Strict::Array.of(KDomain::Schemas::Database::Table)
+      attribute :foreign_keys?        , Types::Strict::Array.of(KDomain::Schemas::Database::ForeignKey)
+      attribute :indexes?             , Types::Strict::Array.of(KDomain::Schemas::Database::Index)
+      attribute :views?               , Types::Strict::Array.of(KDomain::Schemas::Database::View)
+      attribute :meta                 , KDomain::Schemas::Database::Meta
+    end
+  end
+end

data/lib/k_domain/schemas/domain.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Domain class holds a list of the entities
+module KDomain
+  module Schemas
+    class Domain < Dry::Struct
+      class Model < Dry::Struct
+        class Column < Dry::Struct
+          attribute :name                 , Types::Strict::String                         #  "source_account_id"
+          attribute :name_plural          , Types::Strict::String                         #  "source_account_ids"
+          attribute :type                 , Types::Coercible::Symbol                      #  "integer"
+          attribute :precision            , Types::Strict::Integer.optional.default(nil)  #  null
+          attribute :scale                , Types::Strict::Integer.optional.default(nil)  #  null
+          attribute :default              , Types::Nominal::Any.optional.default(nil)     #  null
+          attribute :null                 , Types::Nominal::Any.optional.default(nil)     #  null
+          attribute :limit                , Types::Strict::Integer.optional.default(nil)  #  null
+          attribute :array                , Types::Strict::Bool.optional.default(nil)     #  null
+
+          # Calculated value
+          attribute :structure_type       , Types::Coercible::Symbol #
+          # attribute :foreign_key          , Types::Strict::Bool.optional.default(nil)     #
+          # attribute :foreign_table        , Types::Strict::String                         #
+          # attribute :foreign_table_plural , Types::Strict::String                         #
+
+          # def data_column
+          #   @columns_data ||= structure_type?(:data)
+          # end
+
+          # def structure_type?(*structure_types)
+          #   structure_types.include?(column.structure_type)
+          # end
+
+          def db_type
+            return @db_type if defined? @db_type
+
+            @db_type = DB_TYPE[type] || '******'
+          end
+
+          def ruby_type
+            return @ruby_type if defined? @ruby_type
+
+            @ruby_type = RUBY_TYPE[type] || '******'
+          end
+
+          def csharp_type
+            return @csharp_type if defined? @csharp_type
+
+            @csharp_type = CSHARP_TYPE[type] || '******'
+          end
+        end
+
+        class Pk < Dry::Struct
+          attribute :name               , Types::Strict::String.optional.default(nil)
+          attribute :type               , Types::Strict::String.optional.default(nil)
+          attribute :exist              , Types::Strict::Bool
+        end
+
+        attribute :name                 , Types::Strict::String
+        attribute :name_plural          , Types::Strict::String
+        attribute :table_name           , Types::Strict::String
+        # Model type - :entity, :basic_user, :admin_user, possibly: m2m, agg_root
+        attribute :type                 , Types::Strict::Symbol.optional.default(:entity)
+        attribute :pk                   , KDomain::Schemas::Domain::Model::Pk
+        attribute :columns              , Types::Strict::Array.of(KDomain::Schemas::Domain::Model::Column)
+        attribute :file                 , Types::Strict::String.optional.default(nil)
+
+        def ruby?
+          file && File.exist?(file)
+        end
+
+        def pk?
+          pk.exist
+        end
+
+        # If filled in, the model has a main field that is useful for rendering and may be used for unique constraint, may also be called display_name
+        def main_key
+          @main_key ||= MainKey.lookup(name, columns_data)
+        end
+
+        def traits
+          @traits ||= Traits.lookup(name)
+        end
+
+        # def where()
+        # end
+
+        # def columns_where()
+        # end
+
+        # Column filters
+
+        def columns_data
+          @columns_data ||= columns_for_structure_types(:data)
+        end
+
+        # def columns_data_optional
+        #   @columns_data_optional ||= columns_for_structure_types(:data).select { |c| true }
+        # end
+
+        # def columns_data_required
+        #   @columns_data_required ||= columns_for_structure_types(:data).select { |c| false }
+        # end
+
+        def columns_primary
+          @columns_primary ||= columns_for_structure_types(:primary_key)
+        end
+
+        def columns_foreign
+          @columns_foreign ||= columns_for_structure_types(:foreign_key)
+        end
+
+        def columns_timestamp
+          @columns_data_timestamp ||= columns_for_structure_types(:timestamp)
+        end
+
+        def columns_deleted_at
+          @columns_data_deleted_at ||= columns_for_structure_types(:deleted_at)
+        end
+
+        def columns_virtual
+          @columns_virtual ||= columns_for_structure_types(:timestamp, :deleted_at)
+        end
+
+        def columns_data_foreign
+          @columns_data_foreign ||= columns_for_structure_types(:data, :foreign_key)
+        end
+        alias rows_fields_and_fk columns_data_foreign
+
+        def columns_data_primary
+          @columns_data_primary ||= columns_for_structure_types(:data, :primary_key)
+        end
+        alias rows_fields_and_pk columns_data_primary
+
+        def columns_data_virtual
+          @columns_data_virtual ||= columns_for_structure_types(:data, :timestamp, :deleted_at)
+        end
+        alias rows_fields_and_virtual columns_data_virtual
+
+        def columns_data_foreign_virtual
+          @columns_data_foreign_virtual ||= columns_for_structure_types(:data, :foreign_key, :timestamp, :deleted_at)
+        end
+
+        private
+
+        def columns_for_structure_types(*structure_types)
+          columns.select { |column| structure_types.include?(column.structure_type) }
+        end
+      end
+
+      attribute :models , Types::Strict::Array.of(KDomain::Schemas::Domain::Model)
+      # attribute :erd_files            , Types::Strict::Array.of(KDomain::DomainModel::ErdFile)
+    end
+  end
+end

data/lib/k_domain/schemas/domain_model.rb

@@ -4,8 +4,8 @@
 module KDomain
   module Schemas
     class DomainModel < Dry::Struct
-      attribute :domain           , KDomain::DomainModel::Domain
-      attribute :database         , KDomain::Database::Schema
+      attribute :domain           , KDomain::Schemas::Domain
+      attribute :database         , KDomain::Schemas::Database
       attribute :dictionary       , KDomain::Schemas::Dictionary
       attribute :rails_resource   , KDomain::Schemas::RailsResource
       attribute :rails_structure  , KDomain::Schemas::RailsStructure

data/lib/k_domain/schemas/rails_resource.rb

@@ -3,13 +3,50 @@
 # Domain class holds a dictionary entry
 module KDomain
   module Schemas
+    # Route related files
+    module Types
+      include Dry.Types()
+
+      Verb      = Strict::String.enum('', 'GET', 'PATCH', 'POST', 'PUT', 'DELETE')
+    end
+
+    class Route < Dry::Struct
+      attribute :name                 , Types::String
+      attribute :controller_name      , Types::String
+      attribute :controller_path      , Types::String
+      attribute :controller_namespace , Types::String
+      attribute :controller_file      , Types::String
+      attribute :controller_exist     , Types::Bool
+      attribute :action               , Types::String.optional
+      attribute :uri_path             , Types::String
+      attribute :mime_match           , Types::String
+      attribute :verbs                , Types.Array(Types::Verb)
+      attribute :file                 , Types::String
+      attribute :exist                , Types::Bool
+      attribute :duplicate_verb       , Types::Bool
+    end
+
+    # Model related files
+    class Model < Dry::Struct
+      attribute :model_name         , Types::String
+      attribute :table_name         , Types::String
+      attribute :file               , Types::String
+      attribute :exist              , Types::Bool
+      attribute :state              , Types::String
+    end
+
     class RailsResource < Dry::Struct
-      attribute :models               , Types::Strict::Array do
-        attribute :model_name         , Types::Strict::String
-        attribute :table_name         , Types::Strict::String
-        attribute :file               , Types::Strict::String
-        attribute :exist              , Types::Strict::Bool
-        attribute :state              , Types::Strict::String
+      attribute :models, Types.Array(Model)
+      attribute :routes, Types.Array(Route)
+
+      # def find_route(name)
+      #   name = name.to_s
+      #   routes.find { |route| route.name.to_s == name }
+      # end
+
+      def find_model(name)
+        name = name.to_s
+        models.find { |model| model.model_name.to_s == name }
       end
     end
   end