hecks-adapters-sql-database 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5dd924418dc3e3cbc0550d67a7b833789e634f9c
+  data.tar.gz: 44855f256c24dda6ecad8fbe3baafff10c61909b
+SHA512:
+  metadata.gz: 48f92c5faa521559100658cd02e3f74523a375fd96957ef439331ebceb7a40b3b6e62dfa8c4d9f74cd345cbf0d5c9f32556dcf6c6ae67ded41572ea6777e6b0a
+  data.tar.gz: 2bc7bd4b7ee26f68b8a17f6e3ab3870188b68e6221729e3f7c2558e890d10dbb0a76ab91042e13229cdd9548e975de98f0e75febb4e571944317d30faec06e54

data/lib/column.rb

@@ -0,0 +1,78 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      class Column
+        attr_reader :referenced_object
+        TYPE_MAP = {
+          'Currency' => "BigDecimal",
+          'String'   => 'String',
+          'Integer'  => 'Integer'
+        }
+
+        def initialize(name:, referenced_object: nil, table_name: nil, type:, is_list: false)
+          @name = name
+          @referenced_object = referenced_object
+          @type = type
+          @table_name = table_name
+          @is_list = is_list
+        end
+
+        def self.factory(attribute)
+          new(
+            name: attribute.name,
+            referenced_object: attribute.referenced_object,
+            type: attribute.type,
+            table_name: attribute.object_name,
+            is_list: attribute.list?
+          )
+        end
+
+        def to_foreign_key
+          (type.downcase + '_id').to_sym
+        end
+
+        def to_table_name
+          name.downcase.pluralize.to_sym
+        end
+
+        def list?
+          @is_list
+        end
+
+        def reference?
+          @referenced_object
+        end
+
+        def referenced_table
+          return unless @referenced_object
+          @referenced_object.pluralize.underscore
+        end
+
+        def name
+          @name
+        end
+
+        def copy(new_attributes={})
+          self.class.new(
+            {
+              name: self.name,
+              referenced_object: self.referenced_object,
+              type: self.type,
+              is_list: self.list?
+            }.merge(new_attributes)
+          )
+        end
+
+        def ==(other)
+          return false if name != other.name
+          return false if referenced_table != other.referenced_table
+          true
+        end
+
+        def type
+          TYPE_MAP[@type] || @type
+        end
+      end
+    end
+  end
+end

data/lib/commands/commands.rb

@@ -0,0 +1,4 @@
+require_relative 'create'
+require_relative 'read'
+require_relative 'update'
+require_relative 'delete'

data/lib/commands/create.rb

@@ -0,0 +1,59 @@
+require_relative 'create/find_or_create_references'
+require_relative 'create/add_to_join_tables'
+
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Create
+          attr_reader :id
+
+          def initialize(attributes:, head:)
+            @attributes = attributes.clone
+            @reference_ids = {}
+            @head = head
+            @references = @head.references
+            @table = Table.factory([@head]).first
+          end
+
+          def call
+            DB.transaction do
+              find_or_create_references
+              create
+              add_to_join_tables
+            end
+            self
+          end
+
+          private
+
+          def find_or_create_references
+            @reference_ids =
+            FindOrCreateReferences.new(
+              head: @head,
+              attributes: @attributes
+            ).call.reference_ids
+          end
+
+          def create
+            graph = @references.map do |reference|
+              next if reference.list?
+              column = Column.factory(reference)
+              [column.to_foreign_key, @reference_ids[reference.name]]
+            end.compact.to_h
+
+            @id = DB[@table.name.to_sym].insert(@attributes.merge(graph))
+          end
+
+          def add_to_join_tables
+            AddToJoinTables.new(
+              head: @head,
+              id: @id,
+              reference_ids: @reference_ids
+            ).call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/create/add_to_join_tables.rb

@@ -0,0 +1,39 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Create
+          class AddToJoinTables
+            attr_reader :reference_ids
+            def initialize(head:, reference_ids:, id:)
+              @head = head
+              @table = Table.factory([@head]).first
+              @reference_ids = reference_ids
+              @id = id
+            end
+
+            def call
+              @head.references.each do |reference|
+                column = Column.factory(reference)
+                join_table = JoinTable.new(@table, column)
+
+                next unless reference.list?
+
+                @reference_ids[reference.name.downcase].each do |id|
+                  DB[join_table.name.to_sym].insert(record(column, id))
+                end
+              end
+              self
+            end
+
+            private
+
+            def record(column, id)
+              [[@table.to_foreign_key, @id], [(column.to_foreign_key).to_sym, id]].to_h
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/create/find_or_create_references.rb

@@ -0,0 +1,55 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Create
+          class FindOrCreateReferences
+            attr_reader :reference_ids
+
+            def initialize(head:, attributes:)
+              @head = head
+              @attributes = attributes
+              @reference_ids = {}
+            end
+
+            def call
+              find_or_create_reference
+              find_or_create_references
+              self
+            end
+
+            private
+
+            def find_or_create_reference
+              @head.references.each do |reference|
+                next if reference.list?
+                attributes = @attributes.delete(reference.name.to_sym)
+                column = Column.factory(reference)
+                result = DB[column.to_table_name].first(attributes)
+
+                @reference_ids[reference.name] = result[:id] and return if result
+                @reference_ids[reference.name] = DB[column.as_table_name].insert(attributes)
+              end
+            end
+
+            def find_or_create_references
+              @head.references.each do |reference|
+                next unless reference.list?
+                attributes = @attributes.delete(reference.name.to_sym)
+                attributes.each do |attributes|
+                  @reference_ids[reference.name] = [] unless @reference_ids[reference.name]
+
+                  column = Column.factory(reference)
+                  result = DB[column.to_table_name].first(attributes)
+
+                  @reference_ids[reference.name] << result[:id] and return if result
+                  @reference_ids[reference.name] << DB[column.to_table_name].insert(attributes)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/delete.rb

@@ -0,0 +1,20 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Delete
+          def initialize(id:, head:)
+            @id = id
+            @head = head
+          end
+
+          def call
+            table = Table.factory([@head]).first
+            DB[table.name.to_sym].where(id: @id).delete
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/read.rb

@@ -0,0 +1,33 @@
+require_relative 'read/fetch_references'
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Read
+          attr_reader :head, :entity, :table, :id
+
+          def initialize(id:, head:, entity_class:)
+            @head = head
+            @table = Table.factory([@head]).first
+            @id = id
+            @entity_class = entity_class
+          end
+
+          def call
+            fetch_entity
+            return if @entity.nil?
+            @entity_class.new(
+              @entity.merge(FetchReferences.new(self).call.reference_map)
+            )
+          end
+
+          private
+
+          def fetch_entity
+            @entity = DB[@table.name.to_sym].first(id: @id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/read/fetch_references.rb

@@ -0,0 +1,56 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Read
+          class FetchReferences
+            attr_reader :reference_map
+            def initialize(read_command)
+              @head = read_command.head
+              @reference_map = {}
+              @entity = read_command.entity
+              @table = read_command.table
+              @id = read_command.id
+            end
+
+            def call
+              @head.references.each do |reference|
+                fetch_reference(reference)
+                fetch_references(reference)
+              end
+              self
+            end
+
+            private
+
+            def fetch_reference(reference)
+              return if reference.list?
+              column = Column.factory(reference)
+              value = DB[column.to_table_name].first(id: @entity[column.to_foreign_key])
+
+              @entity.delete(column.to_foreign_key)
+              value.delete(:id)
+              @reference_map[column.name.to_sym] = value
+            end
+
+            def fetch_references(reference)
+              return unless reference.list?
+
+              where_clause = {}
+              where_clause[@table.to_foreign_key.to_sym] = @id
+              column = Column.factory(reference)
+
+              @reference_map[column.name.to_sym] ||= []
+
+              DB[JoinTable.new(@table, reference).name.to_sym].where(where_clause).map do |record|
+                value_object = DB[column.to_table_name].first(id: record[column.to_foreign_key])
+                value_object.delete(:id)
+                @reference_map[column.name.to_sym] << value_object
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/update.rb

@@ -0,0 +1,46 @@
+require_relative 'update/update_values'
+require_relative 'update/link_to_references'
+require_relative 'update/create_new_value'
+require_relative 'update/delete_references'
+
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Update
+          attr_reader :id
+
+          def initialize(attributes:, head:, id:)
+            @attributes = attributes.clone
+            @references = head.references
+            @head_table = Table.factory([head]).first
+            @id = id
+          end
+
+          def call
+            DB.transaction do
+              update_references
+              fetch_record
+              update_record
+            end
+            self
+          end
+
+          private
+
+          def update_references
+            UpdateValues.new(@references, @attributes, @head_table, @id).call
+          end
+
+          def update_record
+            @record.update(@attributes)
+          end
+
+          def fetch_record
+            @record = DB[@head_table.name.to_sym].where(id: @id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/update/create_new_value.rb

@@ -0,0 +1,42 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Update
+          class CreateNewValue
+            attr_reader :reference_ids
+
+            def initialize(reference:, attributes:, reference_ids:)
+              @reference = reference
+              @attributes = attributes
+              @reference_ids = {}
+              @column = Column.factory(reference)
+              @column_name = @column.name.to_sym
+            end
+
+            def call
+              create_values
+              create_value
+              self
+            end
+
+            private
+
+            def create_values
+              return unless @reference.list?
+              @attributes[@column_name].each do |value|
+                @reference_ids[@column_name] ||= []
+                @reference_ids[@column_name] << DB[@column.to_table_name].insert(value)
+              end
+            end
+
+            def create_value
+              return if @reference.list?
+              @reference_ids[@reference.name] = DB[@column.to_table_name].insert(@attributes[@column.name.to_sym])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/update/delete_references.rb

@@ -0,0 +1,43 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Update
+          class DeleteReferences
+            attr_reader :attributes
+
+            def initialize(table:, attributes:, reference:)
+              @table = table
+              @attributes = attributes
+              @reference = reference
+              @where_clause = {}
+              @dataset = DB[JoinTable.new(@table, @reference).name.to_sym]
+            end
+
+            def call
+              # build_where_clause
+              delete_references
+              remove_references_from_attributes
+              self
+            end
+
+            private
+
+            def build_where_clause
+              DB[JoinTable.new(@table, @reference).name.to_sym]
+            end
+
+            def remove_references_from_attributes
+              @attributes.delete(@reference.name.to_sym)
+            end
+
+            def delete_references
+              return unless @reference.list?
+              @dataset.where(@where_clause).delete
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/update/link_to_references.rb

@@ -0,0 +1,44 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Update
+          class LinkToReferences
+            attr_reader :reference_ids
+            def initialize(reference:, table:, reference_ids:, attributes:, id:)
+              @reference = reference
+              @reference_ids = reference_ids
+              @table = table
+              @attributes = attributes
+              @column = Column.factory(@reference)
+              @record = {}
+              @id = id
+            end
+
+            def call
+              make_linking_records
+              make_foreign_keys
+              self
+            end
+
+            private
+
+            def make_linking_records
+              return unless @reference.list?
+              @reference_ids[@reference.name.to_sym].each do |value|
+                @record[@column.to_foreign_key] = value
+                @record[@table.to_foreign_key] = @id
+                DB[JoinTable.new(@table, @reference).name.to_sym].insert(@record)
+              end
+            end
+
+            def make_foreign_keys
+              return if @reference.list?
+              @attributes[@column.to_foreign_key] = @reference_ids[@reference.name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commands/update/update_values.rb

@@ -0,0 +1,55 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      module Commands
+        class Update
+          class UpdateValues
+            def initialize(references, attributes, table, id)
+              @references = references
+              @attributes = attributes
+              @reference_ids = {}
+              @table = table
+              @id = id
+            end
+
+            def call
+              @references.each do |reference|
+                create_new_value(reference)
+                delete_old_references(reference)
+                link_to_new_values(reference)
+              end
+            end
+
+            private
+
+            def create_new_value(reference)
+              @reference_ids = CreateNewValue.new(
+                reference: reference,
+                attributes: @attributes,
+                reference_ids: @reference_ids
+              ).call.reference_ids
+            end
+
+            def delete_old_references(reference)
+              @attributes = DeleteReferences.new(
+                reference: reference,
+                table: @table,
+                attributes: @attributes
+              ).call.attributes
+            end
+
+            def link_to_new_values(reference)
+              LinkToReferences.new(
+                reference: reference,
+                table: @table,
+                reference_ids: @reference_ids,
+                attributes: @attributes,
+                id: @id
+              ).call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks-adapters-sql-database.rb

@@ -0,0 +1,28 @@
+require 'sequel'
+require 'hecks-application'
+
+require_relative 'column'
+require_relative 'join_table'
+require_relative 'schema_factory'
+require_relative 'schema'
+require_relative 'table'
+require_relative 'repository'
+require_relative 'commands/commands'
+
+if ENV["DATABASE_URL"]
+  DB = Sequel.connect(ENV["DATABASE_URL"])
+end
+
+module Hecks
+  module Adapters
+    class SQLDatabase
+      def initialize(domain:)
+        @domain = domain
+      end
+
+      def [](module_name)
+        Repository.new(module_name: module_name)
+      end
+    end
+  end
+end

data/lib/join_table.rb

@@ -0,0 +1,22 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      class JoinTable
+        def initialize(table, column)
+          @table = table
+          @column = column
+        end
+
+        def name
+          "#{@table.name}_#{@column.name}"
+        end
+
+        def columns
+          [@table.name, @column.name].map do |name|
+            Column.new(name: name.singularize + '_id', type: 'Integer')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/repository.rb

@@ -0,0 +1,38 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      class Repository
+        def initialize(module_name:)
+          @module_name = module_name
+          @head = DOMAIN[module_name].head
+        end
+
+        def create attributes
+          Commands::Create.new(attributes: attributes, head: @head).call
+        end
+
+        def update id, attributes
+          Commands::Update.new(id: id, attributes: attributes, head: @head).call
+        end
+
+        def read id
+          Commands::Read.new(
+            id: id,
+            head: @head,
+            entity_class: entity_class
+          ).call
+        end
+
+        def delete id
+          Commands::Delete.new(id: id, head: @head).call
+        end
+
+        private
+
+        def entity_class
+          DOMAIN.name.camelcase.constantize::Domain.const_get(@module_name).head
+        end
+      end
+    end
+  end
+end

data/lib/schema.rb

@@ -0,0 +1,25 @@
+require_relative 'schema_factory'
+require_relative 'table'
+require_relative 'join_table'
+require_relative 'column'
+
+module Hecks
+  module Adapters
+    class SQLDatabase
+      class Schema
+        attr_reader :tables
+        def self.factory(domain_spec)
+          SchemaFactory.new(domain_spec).build
+        end
+
+        def initialize(tables)
+          @tables = tables
+        end
+
+        def to_h
+          tables.map { |table| [table.name.to_sym, table] }.to_h
+        end
+      end
+    end
+  end
+end

data/lib/schema_factory.rb

@@ -0,0 +1,57 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      class SchemaFactory
+        def initialize(domain_spec)
+          @domain_spec = domain_spec
+          @tables = Table.factory(domain_objects)
+          @join_tables = []
+        end
+
+        def build
+          @tables.each do |table|
+            swap_domain_references(table)
+            build_join_tables(table)
+            remove_domain_columns(table)
+          end
+
+          Schema.new(@tables + @join_tables)
+        end
+
+        private
+
+        def domain_objects
+          @domain_spec.domain_modules.values.flat_map(&:objects)
+        end
+
+        def swap_domain_references(table)
+          table.foreign_key_columns.each do |column|
+            add_db_reference(column, table)
+          end
+        end
+
+        def build_join_tables(table)
+          table.join_table_columns.each do |column|
+            @join_tables << JoinTable.new(table, column)
+          end
+        end
+
+        def remove_domain_columns(table)
+          (table.foreign_key_columns + table.join_table_columns).each do |column|
+            table.columns = table.columns.select do |table_column|
+              table_column != column
+            end
+          end
+        end
+
+        def add_db_reference(column, table)
+          table.columns << foreign_key_column(column.referenced_object)
+        end
+
+        def foreign_key_column(column_name, is_list = false)
+          Column.new(name: column_name + '_id', type: 'Integer', is_list: is_list)
+        end
+      end
+    end
+  end
+end

data/lib/table.rb

@@ -0,0 +1,41 @@
+module Hecks
+  module Adapters
+    class SQLDatabase
+      class Table
+        attr_accessor :columns
+
+        def self.factory(domain_objects)
+          r = domain_objects.map do |domain_object|
+            new(
+              name: domain_object.name,
+              columns: domain_object.attributes.map do |attribute|
+                Column.factory(attribute)
+              end
+            )
+          end
+        end
+
+        def initialize(name:, columns:)
+          @name = name
+          @columns = columns
+        end
+
+        def to_foreign_key
+          (name.singularize + '_id').to_sym
+        end
+
+        def join_table_columns
+          columns.select(&:list?)
+        end
+
+        def foreign_key_columns
+          columns.select(&:reference?)
+        end
+
+        def name
+          @name.pluralize.underscore
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: hecks-adapters-sql-database
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Young
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-11 00:00:00.000000000 Z
+dependencies: []
+description: Make the Domain the center of your programming world
+email: chris@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/column.rb
+- lib/commands/commands.rb
+- lib/commands/create.rb
+- lib/commands/create/add_to_join_tables.rb
+- lib/commands/create/find_or_create_references.rb
+- lib/commands/delete.rb
+- lib/commands/read.rb
+- lib/commands/read/fetch_references.rb
+- lib/commands/update.rb
+- lib/commands/update/create_new_value.rb
+- lib/commands/update/delete_references.rb
+- lib/commands/update/link_to_references.rb
+- lib/commands/update/update_values.rb
+- lib/hecks-adapters-sql-database.rb
+- lib/join_table.rb
+- lib/repository.rb
+- lib/schema.rb
+- lib/schema_factory.rb
+- lib/table.rb
+homepage: https://github.com/chrisyoung/hecks-domain
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: DDD and Hexagonal Code Generators
+test_files: []