k_domain 0.0.2 → 0.0.5

data/lib/k_domain/domain_model/dtos/rails_model.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    # Rails model represents information that is found the model.rb class in the rails project
+    class RailsModel
+      attr_accessor :name
+      attr_accessor :name_plural
+      attr_accessor :name_original
+      attr_accessor :documentation_rel_path
+      attr_accessor :model_path
+
+      # @param [Symbol] value The value of ID has different meanings
+      # @option value :true Id column exists and it uses an Integer type
+      # @option value :false Id column does not exist
+      # @option value :bigserial Id column exists and it uses a BigSerial type
+      attr_accessor :id
+
+      attr_accessor :force
+      attr_accessor :primary_key
+      attr_accessor :quirks
+
+      attr_accessor :ruby_raw
+      attr_accessor :ruby_code
+      attr_accessor :ruby_frozen
+      attr_accessor :ruby_header
+      attr_accessor :ruby_code_public
+      attr_accessor :ruby_code_private
+
+      attr_accessor :default_scope
+      attr_accessor :scopes
+      attr_accessor :public_class_methods
+      attr_accessor :public_instance_methods
+      attr_accessor :private_instance_methods
+
+      # stats
+      attr_accessor :time_stamp1
+      attr_accessor :time_stamp2
+      attr_accessor :time_stamp3
+
+      def code_length
+        ruby_raw&.length
+      end
+
+      def display_quirks
+        quirks.join(' ')
+      end
+
+      def exists?
+        File.exist?(model_path)
+      end
+
+      def initialize
+        @quirks = []
+      end
+
+      def add_quirk(quirk)
+        @quirks << quirk
+      end
+
+      def to_h
+        {
+          name: name,
+          name_plural: name_plural,
+          name_original: name_original,
+          documentation_rel_path: documentation_rel_path,
+          model_path: model_path,
+          id: id,
+          force: force,
+          primary_key: primary_key,
+          quirks: quirks,
+          ruby_raw: ruby_raw,
+          ruby_code: ruby_code,
+          ruby_frozen: ruby_frozen,
+          ruby_header: ruby_header,
+          ruby_code_public: ruby_code_public,
+          ruby_code_private: ruby_code_private,
+          default_scope: default_scope,
+          scopes: scopes,
+          public_class_methods: public_class_methods,
+          public_instance_methods: public_instance_methods,
+          private_instance_methods: private_instance_methods,
+          time_stamp1: time_stamp1,
+          time_stamp2: time_stamp2,
+          time_stamp3: time_stamp3,
+          code_length: code_length,
+          exists: exists?
+        }
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/dtos/related_entity.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class RelatedEntity
+      # Name of the entity model
+      attr_accessor :name
+      attr_accessor :name_plural
+      attr_accessor :main_key
+
+      attr_accessor :trait1
+      attr_accessor :trait2
+      attr_accessor :trait3
+
+      def initialize(entity)
+        @name        = entity.name
+        @name_plural = entity.name_plural
+        @main_key    = entity.main_key
+        @trait1      = entity.trait1
+        @trait2      = entity.trait2
+        @trait3      = entity.trait3
+      end
+
+      def to_h
+        {
+          name: name,
+          name_plural: name_plural,
+          main_key: main_key,
+          trait1: trait1,
+          trait2: trait2,
+          trait3: trait3
+        }
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/dtos/schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# DomainModel holds the entire domain model including database and ancillary information
+module KDomain
+  module DomainModel
+    class Schema < Dry::Struct
+      attribute :domain         , KDomain::DomainModel::Domain
+      attribute :database       , KDomain::RawDbSchema::Schema
+      attribute :investigate    , KDomain::DomainModel::Investigate
+    end
+  end
+end

data/lib/k_domain/domain_model/dtos/statistics.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# module KDomain
+#   module DomainModel
+#     # Rails model represents information that is found the model.rb class in the rails project
+#     class Statistics
+#       attr_accessor :column_counts
+#       attr_accessor :code_counts
+#       attr_accessor :code_dsl_counts
+#       attr_accessor :data_counts
+#       attr_accessor :issues
+
+#       def initialize(meta)
+#         @column_counts = OpenStruct.new(meta[:column_counts])
+#         @code_counts = OpenStruct.new(meta[:code_counts])
+#         @code_dsl_counts = OpenStruct.new(meta[:code_dsl_counts])
+#         @data_counts = OpenStruct.new(meta[:data_counts])
+#         @issues = meta[:issues]
+#       end
+#     end
+#   end
+# end

data/lib/k_domain/domain_model/dtos/validate.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Validate
+      KEYS = [:on].freeze
+
+      attr_accessor :methods
+
+      attr_accessor :on
+
+      def format_on
+        for_template(on)
+      end
+
+      def for_template(value)
+        return nil if value.nil?
+        return value.to_s if value.is_a?(Hash)
+        return ":#{value}" if value.is_a?(Symbol)
+
+        value
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/dtos/validates.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Validates
+      KEYS = %i[length unless format presence].freeze
+
+      attr_accessor :name
+
+      attr_accessor :length
+      attr_accessor :unless
+      attr_accessor :format
+      attr_accessor :presence
+
+      def format_length
+        for_template(length)
+      end
+
+      def format_unless
+        for_template(self.unless)
+      end
+
+      def format_format
+        for_template(self.format)
+      end
+
+      def format_presence
+        for_template(presence)
+      end
+
+      def for_template(value)
+        return nil if value.nil?
+        return value.to_s if value.is_a?(Hash)
+        return ":#{value}" if value.is_a?(Symbol)
+
+        value
+      end
+
+      def to_h
+        {
+          name: name,
+          length: length,
+          unless: self.unless,
+          format: self.format,
+          presence: presence
+        }
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/load.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Annotates the original schema with methods that implement existing method calls
+# that are already in the schema so that we can build a hash.
+#
+# Writes a new annotated schema.rb file with a public method called load that
+# builds the hash
+
+module KDomain
+  module DomainModel
+    class Load
+      include KLog::Logging
+
+      attr_reader :source_file
+      attr_reader :data
+
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        json = File.read(source_file)
+        data = KUtil.data.json_parse(json, as: :hash_symbolized)
+
+        @data = KDomain::DomainModel::Schema.new(data)
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/transform.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# Loads the db schema object and works through a series of enrichment steps to
+# that builds the domain modal
+
+module KDomain
+  module DomainModel
+    class Transform
+      include KLog::Logging
+
+      attr_reader :db_schema
+      attr_reader :target_step_file
+      attr_reader :target_file
+      attr_reader :erd_path
+
+      def initialize(db_schema, target_file, target_step_file, erd_path)
+        @db_schema        = db_schema
+        @target_step_file = target_step_file
+        @target_file      = target_file
+        @erd_path         = erd_path
+      end
+
+      def call
+        valid = true
+        valid &&= step1
+        valid &&= step2
+        valid &&= step3
+        valid &&= step4
+        valid &&= step5
+
+        raise 'DomainModal transform failed' unless valid
+
+        write
+
+        nil
+      end
+
+      def step1
+        Step1AttachDbSchema.run(domain_data, db_schema: db_schema)
+        write(step: '1-attach-db-schema')
+      end
+
+      def step2
+        Step2AttachModels.run(domain_data, erd_path: erd_path)
+        write(step: '2-attach-model')
+      end
+
+      def step3
+        Step3AttachColumns.run(domain_data)
+        write(step: '3-attach-columns')
+      end
+
+      def step4
+        Step4AttachErdFiles.run(domain_data, erd_path: erd_path)
+        write(step: '4-attach-erd-files')
+      end
+
+      def step5
+        Step5AttachDictionary.run(domain_data, erd_path: erd_path)
+        write(step: '5-attach-dictionary')
+      end
+
+      def write(step: nil)
+        file = if step.nil?
+                 target_file
+               else
+                 format(target_step_file, step: step)
+               end
+        FileUtils.mkdir_p(File.dirname(file))
+        File.write(file, JSON.pretty_generate(domain_data))
+      end
+
+      def domain_data
+        # The initial domain model structure is created here, but populated during the workflows.
+        @domain_data ||= {
+          domain: {
+            models: [],
+            erd_files: [],
+            dictionary: []
+          },
+          database: {
+            tables: [],
+            indexes: [],
+            foreign_keys: [],
+            meta: {}
+          },
+          investigate: {
+            issues: []
+          }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# The require order is important due to dependencies
+require_relative './step'
+require_relative './step1_attach_db_schema'
+require_relative './step2_attach_models'
+require_relative './step3_attach_columns'
+require_relative './step4_attach_erd_files'
+require_relative './step5_attach_dictionary'

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Step
+      include KLog::Logging
+
+      attr_reader :domain_data
+      attr_reader :opts
+      attr_reader :valid
+      alias valid? valid
+
+      def initialize(domain_data, **opts)
+        # Useful for debugging
+        # log.info "Initialize #{self.class.name}"
+
+        @domain_data  = domain_data
+        @opts         = opts
+        @valid        = true
+      end
+
+      def call; end
+
+      def self.run(domain_data, **opts)
+        step = new(domain_data, **opts)
+        step.call
+        step
+      end
+
+      def guard(message)
+        log.error message
+        @valid = false
+      end
+
+      # Domain Model Accessor/Helpers
+      def domain
+        guard('domain is missing') if domain_data[:domain].nil?
+
+        domain_data[:domain]
+      end
+
+      def domain_models
+        domain[:models]
+      end
+
+      # Database Accessor/Helpers
+      def database=(value)
+        domain_data[:database] = value
+      end
+
+      def database
+        guard('database is missing') if domain_data[:database].nil?
+
+        domain_data[:database]
+      end
+
+      def database_tables
+        guard('database_tables is missing') if database[:tables].nil?
+
+        database[:tables]
+      end
+
+      def database_foreign_keys
+        guard('database_foreign_keys is missing') if database[:foreign_keys].nil?
+
+        database[:foreign_keys]
+      end
+
+      def find_table_for_model(model)
+        database_tables.find { |table| table[:name] == model[:table_name] }
+      end
+
+      def table_name_exist?(table_name)
+        if table_name.nil?
+          guard('table_name_exist? was provided with a table_name: nil')
+          return false
+        end
+        database_table_name_hash.key?(table_name)
+      end
+
+      def find_foreign_table(lhs_table_name, column_name)
+        fk = database_foreign_keys.find { |foreign_key| foreign_key[:left] == lhs_table_name && foreign_key[:column] == column_name }
+        return fk[:right] if fk
+
+        nil
+      end
+
+      def investigate(step:, location:, key:, message:)
+        unique_key = build_key(step, location, key)
+
+        return if issue_hash.key?(unique_key)
+
+        value = { step: step, location: location, key: key, message: message }
+
+        issues << value                   # list
+        issue_hash[unique_key] = value    # lookup
+      end
+
+      def issues
+        domain_data[:investigate][:issues]
+      end
+
+      private
+
+      def database_table_name_hash
+        @database_table_name_hash ||= database_tables.to_h { |table| [table[:name], table[:name]] }
+      end
+
+      def build_key(*values)
+        values.join('-')
+      end
+
+      def issue_hash
+        return @issue_hash if defined? @issue_hash
+
+        @issue_hash = issues.to_h do |issue|
+          unique_key = build_key(issue[:step], issue[:location], issue[:key])
+          [unique_key, issue]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Step1AttachDbSchema < KDomain::DomainModel::Step
+      # Map database schema to domain model
+      def call
+        raise 'Schema not supplied' if opts[:db_schema].nil?
+
+        self.database = opts[:db_schema].clone
+
+        guard('tables are missing')               if database[:tables].nil?
+        guard('indexes are missing')              if database[:indexes].nil?
+        guard('foreign keys are missing')         if database[:foreign_keys].nil?
+        guard('rails version is missing')         if database[:meta][:rails].nil?
+        guard('postgres extensions are missing')  if database[:meta][:database][:extensions].nil?
+        guard('unique keys are missing')          if database[:meta][:unique_keys].nil?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Loop through the db_schema tables and build up a
+# basic model for each table
+class Step2AttachModels < KDomain::DomainModel::Step
+  # Map database schema to domain model
+  def call
+    raise 'ERD path not supplied' if opts[:erd_path].nil?
+
+    # Schema is re-shaped into a format designed for domain modeling
+    domain[:models] = database_tables.map { |table| model(table) }
+  end
+
+  def model(table)
+    table_name = table[:name].to_s
+    model_name = table_name.singularize
+
+    {
+      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),
+      erd_location: location(table_name, model_name),
+      statistics: {},                                   # Load in future step
+      columns: []                                       # Load in future step
+    }
+  end
+
+  def primary_key(table)
+    {
+      name: table[:primary_key],
+      type: table[:primary_key_type],
+      exist: !table[:primary_key].nil?
+    }
+  end
+
+  # Location of source code
+  def location(table_name, model_name)
+    file_normal = File.join(opts[:erd_path], "#{model_name}.rb")
+    file_custom = File.join(opts[:erd_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                      # display_state: state.join(' ')
+    }
+  end
+end