k_domain 0.0.1 → 0.0.14

data/lib/k_domain/raw_db_schema/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 RawDbSchema
+    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::Database::Schema.new(data)
+      end
+    end
+  end
+end

data/lib/k_domain/raw_db_schema/transform.rb

@@ -0,0 +1,82 @@
+# 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 RawDbSchema
+    class Transform
+      include KLog::Logging
+
+      attr_reader :source_file
+      attr_reader :template_file
+      attr_reader :schema_loader
+
+      def initialize(source_file)
+        @source_file = source_file
+        @template_file = KDomain::Gem.resource('templates/load_schema.rb')
+      end
+
+      def call
+        # log.kv 'source_file', source_file
+        # 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)
+        content
+          .gsub!(/ActiveRecord::Schema.define/, 'load')
+
+        lines = content.lines.map { |line| "    #{line}" }.join
+
+        @schema_loader = File
+          .read(template_file)
+          .gsub('{{source_file}}', source_file)
+          .gsub('{{rails_schema}}', lines)
+      end
+
+      # rename to target_ruby
+      # This is an internal ruby structure that is evaluated
+      # writing is only needed for debugging purposes
+      def write_schema_loader(target_file)
+        if schema_loader.nil?
+          puts '.call method has not been executed'
+          return
+        end
+
+        FileUtils.mkdir_p(File.dirname(target_file))
+        File.write(target_file, schema_loader)
+      end
+
+      def write_json(json_file)
+        if schema_loader.nil?
+          puts '.call method has not been executed'
+          return
+        end
+
+        FileUtils.mkdir_p(File.dirname(json_file))
+        File.write(json_file, JSON.pretty_generate(schema))
+      end
+
+      # rubocop:disable Security/Eval
+      def schema
+        if schema_loader.nil?
+          puts '.call method has not been executed'
+          return
+        end
+
+        eval(schema_loader)#, __FILE__, __LINE__)
+
+        loader = LoadSchema.new
+        loader.load_schema
+        return loader.schema
+      rescue => ex
+        log.exception(ex)
+      end
+      # rubocop:enable Security/Eval
+    end
+  end
+end

data/lib/k_domain/schemas/_.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# log.warn 'models->domain' if AppDebug.require?
+
+module Types
+  include Dry.Types()
+end
+
+require_relative 'rails_resource'
+require_relative 'investigate'
+require_relative 'database/_'
+require_relative 'dictionary'
+require_relative 'domain/_'
+
+require_relative './domain_model'

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

@@ -0,0 +1,7 @@
+# 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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,32 @@
+# 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/dictionary.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Domain class holds a dictionary entry
+module KDomain
+  module Schemas
+    class Dictionary < Dry::Struct
+      attribute :items              , Types::Strict::Array do
+        attribute :name             , Types::Strict::String
+        attribute :type             , Types::Strict::String
+        attribute :label            , Types::Strict::String
+        attribute :segment          , Types::Strict::String
+        attribute :models           , Types::Strict::Array
+        attribute :model_count      , Types::Strict::Integer
+        attribute :types            , Types::Strict::Array
+        attribute :type_count       , Types::Strict::Integer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# log.warn 'models->domain' if AppDebug.require?
+
+require_relative './models/column'
+require_relative './models/model'
+require_relative './erd_file'
+require_relative './domain'
+
+module KDomain
+  module DomainModel
+    RUBY_TYPE = {
+      text: 'String',
+      string: 'String',
+      primary_key: 'Integer', # this could be GUID in future
+      foreign_key: 'Integer', # this could be GUID in future
+      integer: 'Integer',
+      bigint: 'Integer',
+      bigserial: 'Integer',
+      boolean: 'Boolean',
+      float: 'Float',
+      decimal: 'Decimal',
+      datetime: 'DateTime',
+      date: 'DateTime',
+      json: 'Hash',
+      jsonb: 'Hash',
+      hstore: 'Hash'
+    }.freeze
+
+    CSHARP_TYPE = {
+      string: 'string',
+      text: 'string', # NEED TO DEAL WITH THIS BETTER
+      integer: 'int',
+      bigint: 'int',
+      bigserial: 'long',
+      boolean: 'bool',
+      decimal: 'decimal',
+      float: 'double',
+      datetime: 'DateTime',
+      date: 'DateTime',
+      json: 'object',
+      jsonb: 'object',
+      hstore: 'object'
+    }.freeze
+
+    # this is used by the ruby migration files
+    DB_TYPE = {
+      boolean: 'boolean',
+      primary_key: 'integer',
+      foreign_key: 'integer',
+      integer: 'integer',
+      bigint: 'integer',
+      bigserial: 'bigserial',
+      decimal: 'decimal',
+      float: 'float',
+      datetime: 'datetime',
+      date: 'date',
+      text: 'text',
+      string: 'string',
+      json: 'json',
+      jsonb: 'jsonb',
+      hstore: 'hstore'
+    }.freeze
+  end
+end

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

@@ -0,0 +1,11 @@
+# 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/erd_file.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# 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? :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
+  end
+end

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

@@ -0,0 +1,49 @@
+# 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

@@ -0,0 +1,111 @@
+# 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/lib/k_domain/schemas/domain/old/belongs_to.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class BelongsTo
+      KEYS = %i[a_lambda polymorphic class_name foreign_key primary_key inverse_of with_deleted code_duplicate].freeze
+
+      attr_accessor :name
+
+      attr_accessor :model_name
+      attr_accessor :model_name_plural
+
+      attr_accessor :a_lambda
+      attr_accessor :polymorphic
+      attr_accessor :class_name
+      attr_accessor :foreign_key
+      attr_accessor :primary_key
+      attr_accessor :inverse_of
+      attr_accessor :with_deleted
+
+      attr_accessor :related_entity
+      attr_accessor :code_duplicate
+    end
+  end
+end