activerecord-dbt 0.4.0 → 0.5.0

data/lib/active_record/dbt/column/data_test.rb

@@ -8,6 +8,7 @@ module ActiveRecord
         include ActiveRecord::Dbt::Column::DataTestable::NotNullDataTestable
         include ActiveRecord::Dbt::Column::DataTestable::RelationshipsDataTestable
         include ActiveRecord::Dbt::Column::DataTestable::UniqueDataTestable
+        include ActiveRecord::Dbt::Validation::TableNameValidator
 
         attr_reader :table_name, :column, :primary_keys, :foreign_keys
 
@@ -15,11 +16,11 @@ module ActiveRecord
         delegate :source_config, to: :@config
 
         def initialize(table_name, column, primary_keys: [], foreign_keys: [{}])
-          @table_name = table_name
+          @config = ActiveRecord::Dbt::Config.instance
+          @table_name = validate_table_name(table_name, @config)
           @column = column
           @primary_keys = primary_keys
           @foreign_keys = foreign_keys
-          @config = ActiveRecord::Dbt::Config.instance
         end
 
         def properties

data/lib/active_record/dbt/column/data_testable/accepted_values_data_testable.rb

@@ -7,18 +7,21 @@ module ActiveRecord
         module AcceptedValuesDataTestable
           extend ActiveRecord::Dbt::RequiredMethods
 
+          using ActiveRecord::Dbt::CoreExt::ActiveRecordExt
+
           define_required_methods :@config, :column, :table_name, :column_name
 
-          delegate :type, to: :column, prefix: true
           delegate :add_log, to: :@config
 
           def accepted_values_test
-            return nil unless column_type == :boolean || enum_values.present?
+            return nil if values.blank?
 
             {
               'accepted_values' => {
-                'values' => values,
-                'quote' => quote?
+                'arguments' => {
+                  'values' => values,
+                  'quote' => quote?
+                }
               }
             }
           end
@@ -26,11 +29,19 @@ module ActiveRecord
           private
 
           def values
-            column_type == :boolean ? [true, false] : enum_accepted_values
+            if column_type == :boolean
+              [true, false]
+            elsif column.sql_type == 'tinyint(1)'
+              [0, 1]
+            elsif enum_values.present?
+              enum_accepted_values
+            else
+              []
+            end
           end
 
           def enum_accepted_values
-            enum_values.map { |key| quote? ? key.to_s : key }
+            enum_values.compact.map { |key| quote? ? key.to_s : key }
           end
 
           def enum_values
@@ -48,6 +59,11 @@ module ActiveRecord
           def quote?
             @quote ||= %i[integer boolean].exclude?(column_type)
           end
+
+          # MEMO: With `delegate :type, to: :column, prefix: true` I could not rewrite the type method with a refine.
+          def column_type
+            @column_type ||= column.type
+          end
         end
       end
     end

data/lib/active_record/dbt/column/data_testable/relationships_data_testable.rb

@@ -11,18 +11,16 @@ module ActiveRecord
 
           define_required_methods :@config, :foreign_keys, :column_name
 
-          delegate :source_name, :data_sync_delayed?, to: :@config
+          delegate :source_name, :data_sync_delayed?, :exclude_table_names, to: :@config
           delegate :to_table, to: :foreign_key
 
           def relationships_test
-            return nil if foreign_key.blank?
+            return nil if foreign_key.blank? || exclude_table_names.include?(to_table)
 
             {
               'relationships' => {
-                'severity' => data_sync_delayed? ? 'warn' : nil,
-                'to' => "source('#{source_name}', '#{to_table}')",
-                'field' => primary_key,
-                'meta' => relationships_meta_relationship_type
+                'arguments' => relationships_arguments,
+                'config' => relationships_config
               }.compact
             }
           end
@@ -38,6 +36,22 @@ module ActiveRecord
               fk.dig(:options, :column) == column_name
             end
           end
+
+          def relationships_arguments
+            {
+              'to' => "source('#{source_name}', '#{to_table}')",
+              'field' => primary_key,
+              'meta' => relationships_meta_relationship_type
+            }
+          end
+
+          def relationships_config
+            return nil unless data_sync_delayed?
+
+            {
+              'severity' => 'warn'
+            }
+          end
         end
       end
     end

data/lib/active_record/dbt/column/yml.rb

@@ -6,43 +6,60 @@ module ActiveRecord
       class Yml
         include ActiveRecord::Dbt::DataType::Mapper
         include ActiveRecord::Dbt::I18nWrapper::Translate
+        include ActiveRecord::Dbt::Validation::TableNameValidator
+
+        using ActiveRecord::Dbt::CoreExt::ActiveRecordExt
 
         attr_reader :table_name, :column, :column_data_test, :primary_keys
 
+        # MEMO: GitHub copilot taught me this.
+        SQL_KEYWORDS = %w[
+          ADD ALL ALTER AND ANY AS ASC BACKUP BETWEEN CASE CHECK COLUMN CONSTRAINT CREATE
+          DATABASE DEFAULT DELETE DESC DISTINCT DROP EXEC EXISTS FOREIGN FROM FULL GROUP
+          HAVING IN INDEX INNER INSERT INTO IS JOIN LEFT LIKE LIMIT NOT NULL OR ORDER OUTER
+          PRIMARY PROCEDURE RIGHT ROWNUM SELECT SET TABLE TOP TRUNCATE UNION UNIQUE UPDATE
+          VALUES VIEW WHERE
+        ].freeze
+
         delegate :name, :comment, to: :column, prefix: true
         delegate :source_config, to: :@config
 
-        def initialize(table_name, column, column_data_test, primary_keys: [])
-          @table_name = table_name
+        def initialize(table_name, column, column_data_test = Struct.new(:properties).new, primary_keys: [])
+          @config = ActiveRecord::Dbt::Config.instance
+          @table_name = validate_table_name(table_name, @config)
           @column = column
           @column_data_test = column_data_test
           @primary_keys = primary_keys
-          @config = ActiveRecord::Dbt::Config.instance
         end
 
         def properties
           {
             'name' => column_name,
             'description' => description,
+            'quote' => quote?,
             'data_type' => data_type(column.type),
             **column_overrides.except(:data_tests),
             'data_tests' => column_data_test.properties
           }.compact
         end
 
+        def column_description
+          config_column_description ||
+            translated_column_name ||
+            column_comment ||
+            key_column_name ||
+            default_column_description
+        end
+
         private
 
         def description
           @description ||=
             column_description ||
-            translated_attribute_name ||
-            column_comment ||
-            key_column_name ||
-            default_column_description ||
             "Write a description of the '#{table_name}.#{column_name}' column."
         end
 
-        def column_description
+        def config_column_description
           source_config.dig(:table_descriptions, table_name, :columns, column_name)
         end
 
@@ -64,6 +81,11 @@ module ActiveRecord
                        &.gsub(/{{\s*column_name\s*}}/, column_name)
         end
 
+        # MEMO: [quote | dbt Developer Hub](https://docs.getdbt.com/reference/resource-properties/quote)
+        def quote?
+          true if SQL_KEYWORDS.include?(column_name.upcase)
+        end
+
         def column_overrides
           @column_overrides ||=
             source_config.dig(:table_overrides, table_name, :columns, column_name) ||

data/lib/active_record/dbt/configuration/source.rb

@@ -33,6 +33,18 @@ module ActiveRecord
           end
         end
 
+        def project_name
+          @project_name ||=
+            source_config.dig(:sources, :config, :meta, :project_name) ||
+            source_name
+        end
+
+        def exclude_table_names
+          @exclude_table_names ||=
+            source_config.dig(:sources, :config, :meta, :exclude, :table_names) ||
+            []
+        end
+
         class SourceNameIsNullError < StandardError; end
       end
     end

data/lib/active_record/dbt/core_ext/active_record_ext.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module CoreExt
+      module ActiveRecordExt
+        if defined?(ActiveRecord::ConnectionAdapters::MySQL::Column)
+          refine ActiveRecord::ConnectionAdapters::MySQL::Column do
+            def type
+              sql_type == 'tinyint(1)' ? :integer : super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/dbt/dbt_package/dbt_utils/table/data_testable/unique_combination_of_columns_data_testable.rb

@@ -17,13 +17,14 @@ module ActiveRecord
                 return nil unless used_dbt_utils?
 
                 indexes.each_with_object([]) do |index, array|
-                  next if unique_indexes?(index)
+                  next if single_column_index?(index)
 
                   array.push(
                     {
                       'dbt_utils.unique_combination_of_columns' => {
-                        'combination_of_columns' => index.columns
-                      }
+                        'arguments' => unique_combination_of_columns_arguments(index.columns),
+                        'config' => unique_combination_of_columns_config(index.columns)
+                      }.compact
                     }
                   )
                 end.presence
@@ -35,11 +36,38 @@ module ActiveRecord
                 ActiveRecord::Base.connection.indexes(table_name)
               end
 
-              def unique_indexes?(index)
+              def single_column_index?(index)
                 return true if index.unique == false
 
                 index.columns.size == 1
               end
+
+              def unique_combination_of_columns_arguments(combination_of_columns)
+                {
+                  'combination_of_columns' => combination_of_columns
+                }
+              end
+
+              def unique_combination_of_columns_config(combination_of_columns)
+                config_where = condition_for_unique_combination_of_columns(combination_of_columns)
+                return nil if config_where.blank?
+
+                {
+                  'where' => config_where
+                }
+              end
+
+              def condition_for_unique_combination_of_columns(unique_combination_of_columns)
+                columns.each_with_object([]) do |column, array|
+                  if unique_combination_of_columns.include?(column.name) && column.null == true
+                    array.push("#{column.name} is not null")
+                  end
+                end.join(' and ').presence
+              end
+
+              def columns
+                ActiveRecord::Base.connection.columns(table_name)
+              end
             end
           end
         end

data/lib/active_record/dbt/factory/enum/yml_factory.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module Factory
+      module Enum
+        module YmlFactory
+          def self.build(
+            table_name,
+            column_name,
+            primary_keys: ActiveRecord::Base.connection.primary_keys(table_name)
+          )
+            table = ActiveRecord::Dbt::Table::Yml.new(table_name)
+            column = ActiveRecord::Base.connection.columns(table_name).find { |c| c.name == column_name }
+            enum_column = ActiveRecord::Dbt::Column::Yml.new(
+              table_name,
+              column,
+              primary_keys: primary_keys
+            )
+
+            ActiveRecord::Dbt::Seed::Enum::Yml.new(table, enum_column)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/dbt/factory/tables/yml_factory.rb

@@ -6,7 +6,10 @@ module ActiveRecord
       module Tables
         module YmlFactory
           def self.build
-            ActiveRecord::Base.connection.tables.sort.map do |table_name|
+            config = ActiveRecord::Dbt::Config.instance
+            table_names = ActiveRecord::Base.connection.tables - config.exclude_table_names
+
+            table_names.sort.map do |table_name|
               ActiveRecord::Dbt::Factory::Table::YmlFactory.build(table_name)
             end
           end

data/lib/active_record/dbt/i18n_wrapper/translate.rb

@@ -14,14 +14,15 @@ module ActiveRecord
           I18n.t("activerecord.models.#{table_name_singularize}", default: nil)
         end
 
-        def translated_attribute_name
-          @translated_attribute_name ||=
-            translated_column_name || translated_default_column_name
+        def translated_column_name
+          @translated_column_name ||=
+            translated_attribute_name ||
+            translated_default_column_name
         end
 
         private
 
-        def translated_column_name
+        def translated_attribute_name
           I18n.t("activerecord.attributes.#{table_name_singularize}.#{column_name}", default: nil)
         end
 

data/lib/active_record/dbt/model/staging/base.rb

@@ -5,6 +5,10 @@ module ActiveRecord
     module Model
       module Staging
         module Base
+          include ActiveRecord::Dbt::Validation::TableNameValidator
+
+          using ActiveRecord::Dbt::CoreExt::ActiveRecordExt
+
           SORT_COLUMN_TYPES = %w[
             ids enums
             strings texts
@@ -17,8 +21,14 @@ module ActiveRecord
           delegate :source_name, :export_directory_path, to: :@config
 
           def initialize(table_name)
-            @table_name = table_name
             @config = ActiveRecord::Dbt::Config.instance
+            @table_name = validate_table_name(table_name, @config)
+          end
+
+          def select_column_names
+            columns_group_by_column_type.sort_by do |key, _|
+              SORT_COLUMN_TYPES.index(key)
+            end.to_h
           end
 
           def rename_primary_id
@@ -51,6 +61,22 @@ module ActiveRecord
             @primary_keys = ActiveRecord::Base.connection.primary_keys(table_name)
           end
 
+          def connection_columns
+            ActiveRecord::Base.connection.columns(table_name)
+          end
+
+          def columns_group_by_column_type
+            connection_columns.group_by do |column|
+              if id?(column.name)
+                'ids'
+              elsif enum?(column.name)
+                'enums'
+              else
+                column.type.to_s.pluralize
+              end
+            end
+          end
+
           def id?(column_name)
             primary_key?(column_name) || foreign_key?(column_name)
           end

data/lib/active_record/dbt/model/staging/sql.rb

@@ -12,30 +12,6 @@ module ActiveRecord
           def export_path
             "#{basename}.sql"
           end
-
-          def select_column_names
-            columns_group_by_column_type.sort_by do |key, _|
-              SORT_COLUMN_TYPES.index(key)
-            end.to_h
-          end
-
-          private
-
-          def columns
-            ActiveRecord::Base.connection.columns(table_name)
-          end
-
-          def columns_group_by_column_type
-            columns.group_by do |column|
-              if id?(column.name)
-                'ids'
-              elsif enum?(column.name)
-                'enums'
-              else
-                column.type.to_s.pluralize
-              end
-            end
-          end
         end
       end
     end

data/lib/active_record/dbt/model/staging/yml.rb

@@ -46,21 +46,12 @@ module ActiveRecord
 
           def sort_columns(columns)
             columns.sort_by do |column|
-              [
-                SORT_COLUMN_TYPES.index(data_type(column)) || -1,
-                columns.index(column)
-              ]
+              sort_column_names.index(column['name'])
             end
           end
 
-          def data_type(column)
-            if id?(column['name'])
-              'ids'
-            elsif enum?(column['name'])
-              'enums'
-            else
-              column.fetch('data_type', 'unknown').pluralize
-            end
+          def sort_column_names
+            @sort_column_names ||= select_column_names.values.flatten.map(&:name)
           end
 
           def override_columns
@@ -90,14 +81,28 @@ module ActiveRecord
           def relationships_test(column_name)
             {
               'relationships' => {
-                'severity' => data_sync_delayed? ? 'warn' : nil,
-                'to' => "source('#{source_name}', '#{table_name}')",
-                'field' => column_name,
-                'meta' => relationships_meta_relationship_type
+                'arguments' => relationships_arguments(column_name),
+                'config' => relationships_config
               }.compact
             }
           end
 
+          def relationships_arguments(column_name)
+            {
+              'to' => "source('#{source_name}', '#{table_name}')",
+              'field' => column_name,
+              'meta' => relationships_meta_relationship_type
+            }
+          end
+
+          def relationships_config
+            return nil unless data_sync_delayed?
+
+            {
+              'severity' => 'warn'
+            }
+          end
+
           def relationships_meta_relationship_type
             return nil unless used_dbterd?
 

data/lib/active_record/dbt/seed/enum/base.rb

@@ -5,15 +5,17 @@ module ActiveRecord
     module Seed
       module Enum
         module Base
+          include ActiveRecord::Dbt::Validation::TableNameValidator
+
           attr_reader :table_name, :enum_column_name
 
           delegate :source_name, :export_directory_path, to: :@config
           delegate :singularize, to: :table_name, prefix: true
 
           def initialize(table_name, enum_column_name)
-            @table_name = table_name
-            @enum_column_name = enum_column_name
             @config = ActiveRecord::Dbt::Config.instance
+            @table_name = validate_table_name(table_name, @config)
+            @enum_column_name = enum_column_name
           end
 
           private

data/lib/active_record/dbt/seed/enum/yml.rb

@@ -8,13 +8,21 @@ module ActiveRecord
           include ActiveRecord::Dbt::Column::DataTestable::UniqueDataTestable
           include ActiveRecord::Dbt::Column::DataTestable::NotNullDataTestable
           include ActiveRecord::Dbt::DataType::Mapper
-          include ActiveRecord::Dbt::I18nWrapper::Translate
           include ActiveRecord::Dbt::Seed::Enum::Base
 
-          delegate :source_config, to: :@config
+          attr_reader :table, :enum_column
+
+          delegate :source_config, :project_name, to: :@config
+          delegate :fetch_logical_name, to: :table
 
           alias column_name enum_column_name
 
+          def initialize(table, enum_column)
+            @table = table
+            @enum_column = enum_column
+            super(table.table_name, enum_column.column_name)
+          end
+
           def export_path
             "#{basename}.yml"
           end
@@ -40,15 +48,20 @@ module ActiveRecord
           end
 
           def seed_description
-            default_seed_description ||
-              "#{source_name} #{translated_table_name} #{translated_attribute_name} enum".strip
+            source_config_description.gsub(/{{\s*project_name\s*}}/, project_name)
+                                     .gsub(/{{\s*table_logical_name\s*}}/, fetch_logical_name)
+                                     .gsub(/{{\s*column_description\s*}}/, column_description)
+          end
+
+          def source_config_description
+            source_config.dig(:defaults, :seed_descriptions, :enum, :description) ||
+              '{{ project_name }} {{ table_logical_name }} {{ column_description }} enum'
           end
 
-          def default_seed_description
-            source_config.dig(:defaults, :seed_descriptions, :enum, :description)
-                         &.gsub(/{{\s*source_name\s*}}/, source_name)
-                         &.gsub(/{{\s*translated_table_name\s*}}/, translated_table_name)
-                         &.gsub(/{{\s*translated_attribute_name\s*}}/, translated_attribute_name)
+          def column_description
+            @column_description ||=
+              enum_column.column_description ||
+              enum_column_name
           end
 
           def column_types
@@ -80,7 +93,8 @@ module ActiveRecord
           def before_type_of_cast_column
             {
               'name' => "#{enum_column_name}_before_type_of_cast",
-              'description' => translated_attribute_name,
+              'description' => "#{column_description}(before_type_of_cast)",
+              'data_type' => data_type(before_type_of_cast_type),
               'data_tests' => data_tests
             }.compact
           end
@@ -88,7 +102,8 @@ module ActiveRecord
           def enum_key_column
             {
               'name' => "#{enum_column_name}_key",
-              'description' => "#{translated_attribute_name}(key)",
+              'description' => "#{column_description}(key)",
+              'data_type' => data_type(:string),
               'data_tests' => data_tests
             }.compact
           end
@@ -98,7 +113,8 @@ module ActiveRecord
               array.push(
                 {
                   'name' => "#{enum_column_name}_#{locale}",
-                  'description' => "#{translated_attribute_name}(#{locale})",
+                  'description' => "#{column_description}(#{locale})",
+                  'data_type' => data_type(:string),
                   'data_tests' => data_tests
                 }.compact
               )

data/lib/active_record/dbt/table/base.rb

@@ -4,11 +4,13 @@ module ActiveRecord
   module Dbt
     module Table
       module Base
+        include ActiveRecord::Dbt::Validation::TableNameValidator
+
         attr_reader :table_name
 
         def initialize(table_name)
-          @table_name = table_name
           @config = ActiveRecord::Dbt::Config.instance
+          @table_name = validate_table_name(table_name, @config)
         end
       end
     end