activerecord-dbt 0.1.0 → 0.3.0

data/lib/active_record/dbt/column/testable/relationships_testable.rb

@@ -5,19 +5,15 @@ module ActiveRecord
     module Column
       module Testable
         module RelationshipsTestable
-          REQUIRED_RELATIONSHIPS_TESTABLE_METHODS = %i[@config foreign_keys column_name].freeze
-
           include ActiveRecord::Dbt::DbtPackage::Dbterd::Column::Testable::RelationshipsMetaRelationshipType
 
+          extend ActiveRecord::Dbt::RequiredMethods
+
+          define_required_methods :@config, :foreign_keys, :column_name
+
           delegate :source_name, :data_sync_delayed?, to: :@config
           delegate :to_table, to: :foreign_key
 
-          REQUIRED_RELATIONSHIPS_TESTABLE_METHODS.each do |method_name|
-            define_method(method_name) do
-              raise NotImplementedError, "You must implement #{self.class}##{__method__}"
-            end
-          end
-
           def relationships_test
             return nil if foreign_key.blank?
 

data/lib/active_record/dbt/column/testable/unique_testable.rb

@@ -5,13 +5,9 @@ module ActiveRecord
     module Column
       module Testable
         module UniqueTestable
-          REQUIRED_UNIQUE_TESTABLE_METHODS = %i[table_name column_name primary_keys].freeze
+          extend ActiveRecord::Dbt::RequiredMethods
 
-          REQUIRED_UNIQUE_TESTABLE_METHODS.each do |method_name|
-            define_method(method_name) do
-              raise NotImplementedError, "You must implement #{self.class}##{__method__}"
-            end
-          end
+          define_required_methods :table_name, :column_name, :primary_keys
 
           def unique_test
             unique? ? 'unique' : nil

data/lib/active_record/dbt/config.rb

@@ -8,38 +8,11 @@ module ActiveRecord
       include Singleton
 
       include ActiveRecord::Dbt::Configuration::DataSync
+      include ActiveRecord::Dbt::Configuration::DwhPlatform
+      include ActiveRecord::Dbt::Configuration::I18nConfiguration
       include ActiveRecord::Dbt::Configuration::Logger
-      include ActiveRecord::Dbt::Configuration::Parser
+      include ActiveRecord::Dbt::Configuration::Source
       include ActiveRecord::Dbt::Configuration::UsedDbtPackage
-
-      DEFAULT_CONFIG_DIRECTORY_PATH = 'lib/dbt'
-      DEFAULT_EXPORT_DIRECTORY_PATH = 'doc/dbt'
-
-      attr_writer :config_directory_path, :export_directory_path
-
-      def source_config_path
-        @source_config_path ||= "#{config_directory_path}/source_config.yml"
-      end
-
-      def source_config
-        @source_config ||= parse_yaml(source_config_path)
-      end
-
-      def source_name
-        @source_name ||= source_config.dig(:sources, :name).tap do |source_name|
-          raise SourceNameIsNullError, "'sources.name' is required in '#{source_config_path}'." if source_name.nil?
-        end
-      end
-
-      def config_directory_path
-        @config_directory_path ||= DEFAULT_CONFIG_DIRECTORY_PATH
-      end
-
-      def export_directory_path
-        @export_directory_path ||= DEFAULT_EXPORT_DIRECTORY_PATH
-      end
-
-      class SourceNameIsNullError < StandardError; end
     end
   end
 end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module Configuration
+      module DwhPlatform
+        extend ActiveRecord::Dbt::RequiredMethods
+
+        define_required_methods :source_config_path
+
+        def dwh_platform=(dwh_platform)
+          @dwh_platform = validate_dwh_platform(dwh_platform)
+        end
+
+        def dwh_platform
+          @dwh_platform || (raise DwhPlatformIsNullError, "'dwh_platform' is required in '#{source_config_path}'.")
+        end
+
+        private
+
+        def validate_dwh_platform(dwh_platform)
+          return dwh_platform if selectable_dwh_platforms.include?(dwh_platform)
+
+          raise DoesNotExistOnTheDwhPlatformError, [
+            "'#{dwh_platform}' does not exist on the DWH platform.",
+            "Please specify one of the following: #{selectable_dwh_platforms.join(', ')}."
+          ].join(' ')
+        end
+
+        def selectable_dwh_platforms
+          @selectable_dwh_platforms ||= ActiveRecord::Dbt::DataType::Mapper::RUBY_TO_DWH_PLATFORM_TYPE_MAP.keys
+        end
+
+        class DoesNotExistOnTheDwhPlatformError < StandardError; end
+        class DwhPlatformIsNullError < StandardError; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module Configuration
+      module I18nConfiguration
+        def locale=(locale = I18n.locale)
+          I18n.load_path += Dir[Rails.root.join('config/locales/**/*.{rb,yml}')]
+          I18n.locale = locale
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module Configuration
+      module Source
+        include ActiveRecord::Dbt::Configuration::Parser
+
+        DEFAULT_CONFIG_DIRECTORY_PATH = 'lib/dbt'
+        DEFAULT_EXPORT_DIRECTORY_PATH = 'doc/dbt'
+
+        attr_writer :config_directory_path, :export_directory_path
+
+        def config_directory_path
+          @config_directory_path ||= DEFAULT_CONFIG_DIRECTORY_PATH
+        end
+
+        def export_directory_path
+          @export_directory_path ||= DEFAULT_EXPORT_DIRECTORY_PATH
+        end
+
+        def source_config_path
+          @source_config_path ||= "#{config_directory_path}/source_config.yml"
+        end
+
+        def source_config
+          @source_config ||= parse_yaml(source_config_path)
+        end
+
+        def source_name
+          @source_name ||= source_config.dig(:sources, :name).tap do |source_name|
+            raise SourceNameIsNullError, "'sources.name' is required in '#{source_config_path}'." if source_name.nil?
+          end
+        end
+
+        class SourceNameIsNullError < StandardError; end
+      end
+    end
+  end
+end

data/lib/active_record/dbt/data_type/mapper.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module DataType
+      module Mapper
+        extend ActiveRecord::Dbt::RequiredMethods
+
+        # [Platform-specific data types | dbt Developer Hub](https://docs.getdbt.com/reference/resource-properties/data-types)
+        RUBY_TO_DWH_PLATFORM_TYPE_MAP = {
+          # [Data types  |  BigQuery  |  Google Cloud](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#data_type_list)
+          'bigquery' => {
+            binary: 'bytes',
+            boolean: 'bool',
+            date: 'date',
+            datetime: 'datetime',
+            decimal: 'int64',
+            float: 'float64',
+            integer: 'int64',
+            json: 'json',
+            string: 'string',
+            text: 'string',
+            time: 'time'
+          },
+
+          # TODO: I have not tried it. I don't know if this is the correct data_type.
+          # [PostgreSQL: Documentation: 16: Chapter 8. Data Types](https://www.postgresql.org/docs/current/datatype.html)
+          'postgres' => {
+            binary: 'bytea',
+            boolean: 'boolean',
+            date: 'date',
+            datetime: 'timestamp',
+            decimal: 'bigint',
+            float: 'double precision',
+            integer: 'bigint',
+            json: 'json',
+            string: 'text',
+            text: 'text',
+            time: 'time'
+          },
+
+          # TODO: I have not tried it. I don't know if this is the correct data_type.
+          # [Data types - Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/c_Supported_data_types.html)
+          'redshift' => {
+            binary: 'varbyte',
+            boolean: 'bool',
+            date: 'date',
+            datetime: 'timestamp',
+            decimal: 'decimal',
+            float: 'double precision',
+            integer: 'integer',
+            json: 'super',
+            string: 'varchar',
+            text: 'varchar',
+            time: 'time'
+          },
+
+          # TODO: I have not tried it. I don't know if this is the correct data_type.
+          # [Summary of data types | Snowflake Documentation](https://docs.snowflake.com/en/sql-reference/intro-summary-data-types)
+          'snowflake' => {
+            binary: 'binary',
+            boolean: 'boolean',
+            date: 'date',
+            datetime: 'datetime',
+            decimal: 'decimal',
+            float: 'float',
+            integer: 'integer',
+            json: 'variant',
+            string: 'varchar',
+            text: 'varchar',
+            time: 'time'
+          },
+
+          # TODO: I have not tried it. I don't know if this is the correct data_type.
+          # [Data Types - Spark 3.5.1 Documentation](https://spark.apache.org/docs/latest/sql-ref-datatypes.html)
+          'spark' => {
+            binary: 'binary',
+            boolean: 'boolean',
+            date: 'date',
+            datetime: 'timestamp',
+            decimal: 'decimal',
+            float: 'float',
+            integer: 'integer',
+            json: 'string',
+            string: 'string',
+            text: 'string',
+            time: 'string'
+          }
+        }.freeze
+
+        define_required_methods :@config
+
+        delegate :dwh_platform, to: :@config
+
+        private
+
+        def data_type(type)
+          RUBY_TO_DWH_PLATFORM_TYPE_MAP[dwh_platform].fetch(type, 'unknown')
+        end
+      end
+    end
+  end
+end

data/lib/active_record/dbt/dbt_package/dbt_utils/table/testable/unique_combination_of_columns_testable.rb

@@ -7,32 +7,39 @@ module ActiveRecord
         module Table
           module Testable
             module UniqueCombinationOfColumnsTestable
-              REQUIRED_UNIQUE_COMBINATION_OF_COLUMNS_TESTABLE_METHODS = %i[table_name @config].freeze
+              extend ActiveRecord::Dbt::RequiredMethods
 
-              delegate :used_dbt_utils?, to: :@config
+              define_required_methods :table_name, :@config
 
-              REQUIRED_UNIQUE_COMBINATION_OF_COLUMNS_TESTABLE_METHODS.each do |method_name|
-                define_method(method_name) do
-                  raise NotImplementedError, "You must implement #{self.class}##{__method__}"
-                end
-              end
+              delegate :used_dbt_utils?, to: :@config
 
               def unique_combination_of_columns_test
                 return nil unless used_dbt_utils?
 
-                ActiveRecord::Base.connection.indexes(table_name).each_with_object([]) do |index, array|
-                  next if index.unique == false
-                  next if (unique_indexes = index.columns).size == 1
+                indexes.each_with_object([]) do |index, array|
+                  next if unique_indexes?(index)
 
                   array.push(
                     {
                       'dbt_utils.unique_combination_of_columns' => {
-                        'combination_of_columns' => unique_indexes
+                        'combination_of_columns' => index.columns
                       }
                     }
                   )
                 end.presence
               end
+
+              private
+
+              def indexes
+                ActiveRecord::Base.connection.indexes(table_name)
+              end
+
+              def unique_indexes?(index)
+                return true if index.unique == false
+
+                index.columns.size == 1
+              end
             end
           end
         end

data/lib/active_record/dbt/dbt_package/dbterd/column/testable/relationships_meta_relationship_type.rb

@@ -7,33 +7,20 @@ module ActiveRecord
         module Column
           module Testable
             module RelationshipsMetaRelationshipType
-              REQUIRED_RELATIONSHIP_TYPE_TESTABLE_METHODS = %i[@config foreign_key].freeze
+              extend ActiveRecord::Dbt::RequiredMethods
 
-              delegate :used_dbterd?, :add_log, to: :@config
+              define_required_methods :@config, :foreign_key
 
-              REQUIRED_RELATIONSHIP_TYPE_TESTABLE_METHODS.each do |method_name|
-                define_method(method_name) do
-                  raise NotImplementedError, "You must implement #{self.class}##{__method__}"
-                end
-              end
+              delegate :used_dbterd?, :add_log, to: :@config
 
               def relationships_meta_relationship_type
-                return nil unless used_dbterd?
-                return nil if foreign_key.nil? || relationship_type.blank?
+                return nil if !used_dbterd? || no_relationship?
 
                 {
                   'relationship_type' => relationship_type
                 }
-              rescue NotSpecifiedOrNotInvalidIdError, StandardError => e
-                add_log(self.class, e)
-
-                {
-                  'relationship_type' => 'many-to-one',
-                  'active_record_dbt_error' => {
-                    'class' => e.class.to_s,
-                    'message' => e.message.to_s
-                  }
-                }
+              rescue NotSpecifiedOrNotInvalidIdError, NameError => e
+                relationships_meta_relationship_type_with_active_record_dbt_error(e)
               end
 
               private
@@ -128,6 +115,22 @@ module ActiveRecord
                 @to_model ||= foreign_key.to_table.classify.constantize
               end
 
+              def no_relationship?
+                foreign_key.nil? || relationship_type.blank?
+              end
+
+              def relationships_meta_relationship_type_with_active_record_dbt_error(error)
+                add_log(self.class, error)
+
+                {
+                  'relationship_type' => 'many-to-one',
+                  'active_record_dbt_error' => {
+                    'class' => error.class.to_s,
+                    'message' => error.message.to_s
+                  }
+                }
+              end
+
               class NotSpecifiedOrNotInvalidIdError < StandardError; end
             end
           end

data/lib/active_record/dbt/factory/model/staging_factory.rb

@@ -5,14 +5,14 @@ module ActiveRecord
     module Factory
       module Model
         module StagingFactory
-          def self.yml_build(table_name)
+          def self.build(table_name)
             table_factory = ActiveRecord::Dbt::Factory::TableFactory.build(table_name)
             yml = ActiveRecord::Dbt::Model::Staging::Yml.new(table_factory)
-            struct = Struct.new(:export_path, :yml_dump, keyword_init: true)
+            struct = Struct.new(:export_path, :dump, keyword_init: true)
 
             struct.new(
               export_path: yml.export_path,
-              yml_dump: YAML.dump(yml.config.deep_stringify_keys)
+              dump: yml.dump
             )
           end
         end

data/lib/active_record/dbt/factory/source_factory.rb

@@ -6,9 +6,8 @@ module ActiveRecord
       module SourceFactory
         def self.build
           tables_factory = ActiveRecord::Dbt::Factory::TablesFactory.build
-          config = ActiveRecord::Dbt::Source::Yml.new(tables_factory).config
 
-          YAML.dump(config.deep_stringify_keys)
+          ActiveRecord::Dbt::Source::Yml.new(tables_factory).dump
         end
       end
     end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module I18nWrapper
+      module Translate
+        extend ActiveRecord::Dbt::RequiredMethods
+
+        define_required_methods :table_name
+
+        delegate :singularize, to: :table_name, prefix: true
+
+        def translated_table_name
+          I18n.t("activerecord.models.#{table_name_singularize}", default: nil)
+        end
+
+        def translated_attribute_name
+          @translated_attribute_name ||=
+            translated_column_name || translated_default_column_name
+        end
+
+        private
+
+        def translated_column_name
+          I18n.t("activerecord.attributes.#{table_name_singularize}.#{column_name}", default: nil)
+        end
+
+        def translated_default_column_name
+          I18n.t("attributes.#{column_name}", default: nil)
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,13 @@ module ActiveRecord
             "#{basename}.yml"
           end
 
-          def config
+          def dump
+            YAML.dump(model_config.deep_stringify_keys)
+          end
+
+          private
+
+          def model_config
             {
               'version' => 2,
               'models' => [
@@ -34,8 +40,6 @@ module ActiveRecord
             }
           end
 
-          private
-
           def columns
             @columns ||= sort_columns(table.config['columns'])
           end
@@ -43,19 +47,19 @@ module ActiveRecord
           def sort_columns(columns)
             columns.sort_by do |column|
               [
-                SORT_COLUMN_TYPES.index(column_type(column)) || -1,
+                SORT_COLUMN_TYPES.index(data_type(column)) || -1,
                 columns.index(column)
               ]
             end
           end
 
-          def column_type(column)
+          def data_type(column)
             if id?(column['name'])
               'ids'
             elsif enum?(column['name'])
               'enums'
             else
-              column.dig('meta', 'column_type').pluralize
+              column.fetch('data_type', 'unknown').pluralize
             end
           end
 

data/lib/active_record/dbt/required_methods.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module RequiredMethods
+      def define_required_methods(*methods)
+        methods.each do |method_name|
+          define_method(method_name) do
+            raise RequiredImplementationMissingError, "You must implement #{self.class}##{__method__}"
+          end
+        end
+      end
+
+      class RequiredImplementationMissingError < StandardError; end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Dbt
+    module Seed
+      module Enum
+        module Base
+          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
+          end
+
+          private
+
+          def basename
+            "#{export_directory_path}/#{seed_name}"
+          end
+
+          def seed_name
+            "seed_#{source_name}__#{table_name_singularize}_enum_#{enum_pluralized}"
+          end
+
+          def locales
+            @locales ||= I18n.available_locales
+          end
+
+          def application_record_klass
+            @application_record_klass ||= table_name_singularize.classify.constantize
+          rescue NameError => _e
+            raise DoesNotExistTableError, "#{table_name} table does not exist."
+          end
+
+          def enum_pluralized
+            enum_column_name.pluralize
+          end
+
+          class DoesNotExistTableError < StandardError; end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module ActiveRecord
+  module Dbt
+    module Seed
+      module Enum
+        class Csv
+          include ActiveRecord::Dbt::Seed::Enum::Base
+
+          delegate :singularize, to: :table_name, prefix: true
+
+          def export_path
+            "#{basename}.csv"
+          end
+
+          def dump
+            CSV.generate(headers: true) do |csv|
+              rows.each { |row| csv << row }
+            end
+          end
+
+          private
+
+          def rows
+            [
+              header,
+              *enum_rows
+            ]
+          end
+
+          def header
+            [
+              "#{enum_column_name}_before_type_of_cast",
+              "#{enum_column_name}_key",
+              *locale_header
+            ]
+          end
+
+          def locale_header
+            locales.map { |locale| "#{enum_column_name}_#{locale}" }
+          end
+
+          def enum_rows
+            enums.map do |enum_key, enum_before_type_of_cast|
+              [
+                enum_before_type_of_cast,
+                enum_key,
+                *enum_values(enum_key)
+              ]
+            end
+          end
+
+          def enums
+            application_record_klass.defined_enums.fetch(enum_column_name)
+          rescue KeyError => _e
+            raise NotEnumColumnError, "#{table_name}.#{enum_column_name} column is not an enum." if enum_column?
+
+            raise DoesNotExistColumnError, "The #{enum_column_name} column in the #{table_name} table does not exist."
+          end
+
+          def enum_column?
+            application_record_klass.column_names.include?(enum_column_name)
+          end
+
+          def enum_values(enum_key)
+            locales.map { |locale| translated_enum_value(enum_key, locale) }
+          end
+
+          def translated_enum_value(enum_key, locale)
+            I18n.t(
+              "activerecord.enum.#{table_name_singularize}.#{enum_column_name}.#{enum_key}",
+              locale: locale,
+              default: nil
+            )
+          end
+
+          class DoesNotExistColumnError < StandardError; end
+          class NotEnumColumnError < StandardError; end
+        end
+      end
+    end
+  end
+end