webamm_to_rails 7.0.0

data/lib/webamm_to_rails/sources/migrations/devise/definition.rb

@@ -0,0 +1,278 @@
+module WebammToRails
+  module Sources
+    module Migrations
+      module Devise
+        class Definition
+          def initialize(table_name:, waml_definition:)
+            @table_name = table_name
+            @waml_definition = waml_definition
+          end
+
+          def columns_collection
+            return [] if authentication.blank?
+
+            columns = [
+              ::Webamm::Database::Schema::Column.new(
+                name: 'email',
+                type: 'string',
+                null: false,
+                default: ''
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'encrypted_password',
+                type: 'string',
+                null: false,
+                default: ''
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'reset_password_token',
+                type: 'string',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'reset_password_sent_at',
+                type: 'datetime',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'remember_created_at',
+                type: 'datetime',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'sign_in_count',
+                type: 'integer',
+                null: false,
+                default: '0'
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'current_sign_in_at',
+                type: 'datetime',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'last_sign_in_at',
+                type: 'datetime',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'current_sign_in_ip',
+                type: 'string',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'last_sign_in_ip',
+                type: 'string',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'confirmation_token',
+                type: 'string',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'confirmed_at',
+                type: 'datetime',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'confirmation_sent_at',
+                type: 'datetime',
+                null: true,
+                default: nil
+              ),
+              ::Webamm::Database::Schema::Column.new(
+                name: 'unconfirmed_email',
+                type: 'string',
+                null: true,
+                default: nil
+              )
+            ]
+
+            if authentication.features.include?('invitations')
+              columns |= [
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'invitation_token',
+                  type: 'string',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'invitation_created_at',
+                  type: 'datetime',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'invitation_sent_at',
+                  type: 'datetime',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'invitation_accepted_at',
+                  type: 'datetime',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'invitation_limit',
+                  type: 'integer',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'invited_by_id',
+                  type: 'integer',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'invited_by_type',
+                  type: 'string',
+                  null: true,
+                  default: nil
+                )
+              ]
+            end
+
+            if authentication.features.include?('two_factor_authentication')
+              columns |= [
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_auth_secret',
+                  type: 'string',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_recovery_secret',
+                  type: 'string',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_enabled',
+                  type: 'boolean',
+                  null: false,
+                  default: 'false'
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_mandatory',
+                  type: 'boolean',
+                  null: false,
+                  default: 'false'
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_enabled_on',
+                  type: 'datetime',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_failed_attempts',
+                  type: 'integer',
+                  null: false,
+                  default: '0'
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_recovery_counter',
+                  type: 'integer',
+                  null: false,
+                  default: '0'
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_persistence_seed',
+                  type: 'string',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_session_challenge',
+                  type: 'string',
+                  null: true,
+                  default: nil
+                ),
+                ::Webamm::Database::Schema::Column.new(
+                  name: 'otp_challenge_expires',
+                  type: 'datetime',
+                  null: true,
+                  default: nil
+                )
+              ]
+            end
+
+            columns
+          end
+
+          def indices_collection
+            return [] if authentication.blank?
+
+            indices = [
+              ::Webamm::Database::Schema::Index.new(
+                columns: %w[email],
+                unique: true,
+                name: 'email_idx'
+              ),
+              ::Webamm::Database::Schema::Index.new(
+                columns: %w[reset_password_token],
+                unique: true,
+                name: 'reset_password_token_idx'
+              ),
+              ::Webamm::Database::Schema::Index.new(
+                columns: %w[confirmation_token],
+                unique: true,
+                name: 'confirmation_token_idx'
+              )
+            ]
+
+            if authentication.features.include?('invitations')
+              indices |= [
+                ::Webamm::Database::Schema::Index.new(
+                  columns: %w[invitation_token],
+                  unique: true,
+                  name: 'invitation_token_idx'
+                )
+              ]
+            end
+
+            if authentication.features.include?('two_factor_authentication')
+              indices |= [
+                ::Webamm::Database::Schema::Index.new(
+                  columns: %w[otp_session_challenge],
+                  unique: true,
+                  name: 'otp_session_challenge_idx'
+                ),
+                ::Webamm::Database::Schema::Index.new(
+                  columns: %w[otp_challenge_expires],
+                  name: 'otp_challenge_expires_idx',
+                  unique: false
+                )
+              ]
+            end
+
+            indices
+          end
+
+          private
+
+          def authentication
+            return @authentication if defined?(@authentication)
+
+            @authentication = (@waml_definition.authentication || []).find do |auth|
+              auth.table == @table_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webamm_to_rails/sources/migrations/files_list.rb

@@ -0,0 +1,98 @@
+require_relative 'definition'
+require_relative 'uuid_definition/presenter'
+require_relative 'active_storage_definition/presenter'
+
+module WebammToRails
+  module Sources
+    module Migrations
+      class FilesList
+        def initialize(waml_definition:, database_tables:)
+          @waml_definition = waml_definition
+          @database_tables = database_tables
+        end
+
+        def collection
+          migrations = []
+          migration_timestamp = Time.now.utc - 1_000
+          migration_count = 0
+
+          uuid_presenter = ::WebammToRails::Sources::Migrations::UuidDefinition::Presenter.new(waml_definition: @waml_definition)
+
+          if uuid_presenter.render?
+            migrations << {
+              path: uuid_presenter.file_name((migration_timestamp + migration_count).strftime('%Y%m%d%H%M%S')),
+              content: uuid_presenter.render
+            }
+
+            migration_count += 1
+          end
+
+          active_storage_presenter = ::WebammToRails::Sources::Migrations::ActiveStorageDefinition::Presenter.new(waml_definition: @waml_definition)
+
+          if active_storage_presenter.render?
+            migrations << {
+              path: active_storage_presenter.file_name((migration_timestamp + migration_count).strftime('%Y%m%d%H%M%S')),
+              content: active_storage_presenter.render
+            }
+
+            migration_count += 1
+          end
+
+          models_order = []
+
+          @database_tables.each do |model|
+            depending_on = @waml_definition.database.relationships.select { |r| r.source == model.table && r.type == 'belongs_to' }.map(&:destination)
+            models_order << { model: model.table, depending_on: depending_on }
+          end
+
+          models_hash = models_order.each_with_object({}) do |model, hash|
+            hash[model[:model]] = model
+          end
+
+          # Topological Sort
+          sorted_models = []
+          visited = {}
+          temp_marks = {}
+  
+          models_order.each do |model|
+            visit(model[:model], models_hash, sorted_models, visited, temp_marks)
+          end
+
+          sorted_models.each do |attrs|
+            table_name = attrs[:model]
+            db_table = @database_tables.find { |t| t.table == table_name }
+
+            migration_code = ::WebammToRails::Sources::Migrations::Definition.new(
+              table_definition: db_table, waml_definition: @waml_definition
+            ).render
+            
+            migrations << {
+              path: "db/migrate/#{(migration_timestamp + migration_count).strftime('%Y%m%d%H%M%S')}_create_#{db_table.table}.rb",
+              content: migration_code
+            }
+
+            migration_count += 1
+          end
+
+          migrations
+        end
+
+        private
+
+        # helper to topologically sort models
+        def visit(model, models_hash, sorted_models, visited, temp_marks)
+          return if visited[model]
+          raise "Circular dependency detected" if temp_marks[model]
+          
+          temp_marks[model] = true
+          models_hash[model][:depending_on].each do |dependency|
+            visit(dependency, models_hash, sorted_models, visited, temp_marks)
+          end
+          temp_marks.delete(model)
+          visited[model] = true
+          sorted_models << models_hash[model]
+        end
+      end
+    end
+  end
+end

data/lib/webamm_to_rails/sources/migrations/index_definition/presenter.rb

@@ -0,0 +1,34 @@
+module WebammToRails
+  module Sources
+    module Migrations
+      class IndexDefinition
+        class Presenter
+          def initialize(table_name:, index:)
+            @table_name = table_name
+            @index = index
+          end
+
+          def render
+            base_def = if @index.columns.size == 1
+              "add_index :#{@table_name}, :#{@index.columns.first}"
+            else
+              "add_index :#{@table_name}, %i[#{@index.columns.join(' ')}]"
+            end
+
+            base_def += ", unique: true" if @index.unique
+
+            base_def
+          end
+
+          private
+
+          def index_name
+            base_name = @index.columns.join('_')
+
+            "#{base_name[0..19]}_idx"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webamm_to_rails/sources/migrations/indices.rb

@@ -0,0 +1,33 @@
+require_relative 'index_definition/presenter'
+require_relative 'devise/definition'
+
+module WebammToRails
+  module Sources
+    module Migrations
+      class Indices
+        def initialize(waml_definition:, table_definition:)
+          @waml_definition = waml_definition
+          @table_definition = table_definition
+        end
+
+        def collection
+          indices.uniq(&:columns).map do |index|
+            ::WebammToRails::Sources::Migrations::IndexDefinition::Presenter.new(table_name: @table_definition.table, index: index).render
+          end
+        end
+
+        private
+
+        def indices
+          @table_definition.indices + devise_indices
+        end
+
+        def devise_indices
+          ::WebammToRails::Sources::Migrations::Devise::Definition.new(
+            waml_definition: @waml_definition, table_name: @table_definition.table
+          ).indices_collection
+        end
+      end
+    end
+  end
+end

data/lib/webamm_to_rails/sources/migrations/table_definition/presenter.rb

@@ -0,0 +1,21 @@
+module WebammToRails
+  module Sources
+    module Migrations
+      class TableDefinition
+        class Presenter
+          def initialize(table_definition:)
+            @table_definition = table_definition
+          end
+
+          def render
+            if @table_definition.options&.use_uuid.present?
+              "create_table :#{@table_definition.table}, id: :uuid do |t|"
+            else
+              "create_table :#{@table_definition.table} do |t|"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webamm_to_rails/sources/migrations/template.erb

@@ -0,0 +1,12 @@
+<%= class_definition %>
+  def change
+    <%= table_definition %>
+      <%= columns.join("\n") %>
+      <%= associations.join("\n") %>
+
+      t.timestamps
+    end
+
+    <%= indices.join("\n") %>
+  end
+end

data/lib/webamm_to_rails/sources/migrations/uuid_definition/presenter.rb

@@ -0,0 +1,29 @@
+module WebammToRails
+  module Sources
+    module Migrations
+      class UuidDefinition
+        class Presenter
+          def initialize(waml_definition:)
+            @waml_definition = waml_definition
+          end
+
+          def file_name(migration_timestamp)
+            "db/migrate/#{migration_timestamp}_enable_uuid.rb"
+          end
+
+          def render
+            template_path = File.expand_path('template.erb', __dir__)
+            template_content = File.read(template_path)
+            raw_content = ERB.new(template_content, trim_mode: '-').result(instance_eval { binding })
+
+            ::WebammToRails::Utils::FormatCode.call(raw_content)
+          end
+
+          def render?
+            @waml_definition.database.schema.any? { |table| table.options&.use_uuid.present? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webamm_to_rails/sources/migrations/uuid_definition/template.erb

@@ -0,0 +1,5 @@
+class EnableUuid < ActiveRecord::Migration[7.1]
+  def change
+    enable_extension 'pgcrypto'
+  end
+end

data/lib/webamm_to_rails/sources/models/association_definition/presenter.rb

@@ -0,0 +1,49 @@
+module WebammToRails
+  module Sources
+    module Models
+      class AssociationDefinition
+        class Presenter
+          UnknownAssociationType = Class.new(StandardError)
+
+          def initialize(table_definition:, association:)
+            @table_definition = table_definition
+            @association = association
+          end
+
+          def render
+            assoc_definition = case @association.type
+                                when 'belongs_to'
+                                  assoc_def = "belongs_to :#{@association.destination.underscore.singularize}"
+                                  assoc_def << ", optional: true" unless @association.required
+                                  assoc_def
+                                when 'has_one'
+                                  "has_one :#{@association.destination.underscore.singularize}"
+                                when 'has_many'
+                                  assoc_def = "has_many :#{@association.destination.underscore.pluralize}"
+                                  assoc_def << ", through: :#{@association.options.through}" if @association.options&.through.present?
+                                  assoc_def
+                                when 'has_many_and_belongs_to_many'
+                                  "has_and_belongs_to_many :#{@association.destination.underscore.pluralize}"
+                                else
+                                  raise UnknownAssociationType, @association.type
+                                end
+
+            if @association.options&.class_name.present?
+              assoc_definition << ", class_name: '#{@association.options.class_name}'"
+            end
+
+            if @association.options&.foreign_key.present?
+              assoc_definition << ", foreign_key: '#{@association.options.foreign_key}'"
+            end
+
+            if @association.options&.dependent.present?
+              assoc_definition << ", dependent: :#{@association.options.dependent}"
+            end
+
+            assoc_definition
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webamm_to_rails/sources/models/associations.rb

@@ -0,0 +1,113 @@
+require_relative 'association_definition/presenter'
+
+module WebammToRails
+  module Sources
+    module Models
+      class Associations
+        def initialize(table_definition:, waml_definition:)
+          @table_definition = table_definition
+          @waml_definition = waml_definition
+        end
+
+        def collection
+          raw_associations.map do |association|
+            ::WebammToRails::Sources::Models::AssociationDefinition::Presenter.new(table_definition: @table_definition, association: association).render
+          end
+        end
+
+        private
+
+        def table_name
+          @table_definition.table
+        end
+
+        def habtm_table_with_columns?
+          @table_definition.columns.any? && !!@table_definition.options&.habtm
+        end
+
+        def raw_associations
+          base_associations = habtm_associations
+
+          @waml_definition.database.relationships.select { |assoc| assoc.source == table_name }.each do |assoc|
+            if assoc.type == 'has_many_and_belongs_to_many'
+              habtm_table_name = assoc.options.habtm_table
+              habtm_table = find_table_definition(habtm_table_name)
+
+              if habtm_table.columns.any?
+                base_associations << Webamm::Database::Relationship.new(
+                  type: 'has_many',
+                  source: table_name,
+                  destination: habtm_table_name,
+                  required: true
+                )
+
+                base_associations << Webamm::Database::Relationship.new(
+                  type: 'has_many',
+                  source: table_name,
+                  destination: assoc.destination,
+                  required: true,
+                  options: {
+                    through: habtm_table_name
+                  }
+                )
+              else
+                base_associations << assoc
+              end
+            elsif assoc.type == 'parent_children'
+              base_associations << Webamm::Database::Relationship.new(
+                type: 'belongs_to',
+                source: table_name,
+                destination: 'parent',
+                required: false,
+                options: {
+                  class_name: table_name.classify
+                }
+              )
+             
+              base_associations << Webamm::Database::Relationship.new(
+                type: 'has_many',
+                source: table_name,
+                destination: 'children',
+                required: true,
+                options: {
+                  class_name: table_name.classify,
+                  foreign_key: 'parent_id',
+                  dependent: 'destroy'
+                }
+              )
+            else
+              base_associations << assoc
+            end
+          end
+
+          base_associations
+        end
+
+        def habtm_associations
+          return [] unless habtm_table_with_columns?
+
+          table1, table2 = @table_definition.options.habtm_tables
+
+          [
+            Webamm::Database::Relationship.new(
+              type: 'belongs_to',
+              required: true,
+              source: table_name,
+              destination: table1
+            ),
+            Webamm::Database::Relationship.new(
+              type: 'belongs_to',
+              required: true,
+              source: table_name,
+              destination: table2
+            )
+          ]
+        end
+
+        def find_table_definition(table_name)
+          @waml_definition.database.schema.find { |table| table.table == table_name }
+        end
+      end
+    end
+  end
+end