k_domain 0.0.20 → 0.0.27

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-# Attach columns to models
-class Step3AttachColumns < KDomain::DomainModel::Step
-  attr_accessor :table
-  attr_reader :column_name
-  attr_reader :column_symbol
-
-  def call
-    build_columns
-  end
-
-  def build_columns
-    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)
-    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?
-    # 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 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)
-
-    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: :step3_attach_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: :step3_attach_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
-
-  # 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
-    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
-    return :token               if column_name.ends_with?('_token') || column_name.ends_with?('_token_iv')
-
-    :data
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-# Locate rails model files
-class Step5RailsModels < KDomain::DomainModel::Step
-  def call
-    raise 'ERD path not supplied' unless opts[:erd_path]
-
-    self.rails_structure_models = rails_resource_models.map do |resource|
-      process_resource(OpenStruct.new(resource))
-    end
-  end
-
-  private
-
-  def process_resource(resource)
-    @model = {
-      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_model_behavior(resource.file)
-    @model[:functions] = extract_model_functions(resource.file)
-
-    @model
-  end
-
-  def extract_model_behavior(file)
-    extractor.extract(file)
-    extractor.model
-  end
-
-  def extract_model_functions(file)
-    klass_name = File.basename(file, File.extname(file))
-
-    klass = case klass_name
-            when 'clearbit_quota'
-              ClearbitQuota
-            when 'account_history_data'
-              AccountHistoryData
-            else
-              Module.const_get(klass_name.classify)
-            end
-
-    class_info = Peeky.api.build_class_info(klass.new)
-
-    class_info.to_h
-  rescue StandardError => e
-    log.exception(e)
-  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
-    shim_loader.register(:fake_module  , KDomain::Gem.resource('templates/fake_module_shims.rb'))
-    shim_loader.register(:active_record, KDomain::Gem.resource('templates/active_record_shims.rb'))
-    shim_loader
-  end
-end

data/lib/k_domain/schemas/database/_.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-# The require order is important due to dependencies
-require_relative './index'
-require_relative './table'
-require_relative './foreign_key'
-require_relative './schema'

data/lib/k_domain/schemas/database/foreign_key.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module KDomain
-  module Database
-    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
-  end
-end

data/lib/k_domain/schemas/database/index.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module KDomain
-  module Database
-    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
-  end
-end

data/lib/k_domain/schemas/database/schema.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module KDomain
-  module Database
-    class Schema < Dry::Struct
-      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::Database::Schema::DbInfo
-        attribute :unique_keys          , Types::Strict::Array.of(KDomain::Database::Schema::UniqueKey)
-      end
-
-      attribute :tables               , Types::Strict::Array.of(KDomain::Database::Table)
-      attribute :foreign_keys?        , Types::Strict::Array.of(KDomain::Database::ForeignKey)
-      attribute :indexes?             , Types::Strict::Array.of(KDomain::Database::Index)
-      attribute :meta                 , KDomain::Database::Schema::Meta
-    end
-  end
-end

data/lib/k_domain/schemas/database/table.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module KDomain
-  module Database
-    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::Database::Table::Column)
-      attribute :indexes                , Types::Strict::Array.of(KDomain::Database::Index) # May want to have a Table::Index, but for now this is a shared scheam
-      attribute :rails_schema           , KDomain::Database::Table::RailsSchema
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-# Domain class holds a list of the entities
-module KDomain
-  module DomainModel
-    class Domain < Dry::Struct
-      attribute :models               , Types::Strict::Array.of(KDomain::DomainModel::Model)
-      # attribute :erd_files            , Types::Strict::Array.of(KDomain::DomainModel::ErdFile)
-    end
-  end
-end

data/lib/k_domain/schemas/domain/models/column.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module KDomain
-  module DomainModel
-    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
-  end
-end

data/lib/k_domain/schemas/domain/models/model.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-# Domain class holds a list of the entities
-module KDomain
-  module DomainModel
-    class Model < Dry::Struct
-      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
-
-      class ErdLocation < Dry::Struct
-        attribute :file               , Types::Strict::String
-        attribute :exist              , Types::Strict::Bool
-        attribute :state              , Types::Strict::Array
-      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::DomainModel::Model::Pk
-      attribute :erd_location         , KDomain::DomainModel::Model::ErdLocation
-      attribute :columns              , Types::Strict::Array.of(KDomain::DomainModel::Column)
-
-      def ruby?
-        location.exist
-      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
-  end
-end

data/templates/fake_module_shims.rb

@@ -1,42 +0,0 @@
-class Rails
-  def self.env; end
-
-  def self.application
-    OpenStruct.new(secrets: OpenStruct.new(credentials_secret_key: Base64.encode64('ABC')))
-  end
-end
-
-module ActsAsCommentable
-  module Comment
-  end
-end
-
-module Scopes
-  module CompanyScopes
-  end
-end
-
-module ActionView
-  module Helpers
-    module NumberHelper
-    end
-  end
-end
-
-module RailsUpgrade
-  def rails4?
-    true
-  end
-
-  def rails5?
-    true
-  end
-
-  def rails6?
-    true
-  end
-
-  def belongs_to_required
-    {}
-  end
-end