pakyow-data 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 48569dc1d1d2f24fdf3a94b7b642ac33ecf1f80ed5fd2ae336300815eccc59ff
+  data.tar.gz: b4fae401a84c092cdd0fa5df7564016a2f9209b6c53c81d408b8f5a3ae96900e
+SHA512:
+  metadata.gz: 683e102bdc37a1806c78f181cdca846015d82277e3580ade5347f91a5f2182ba1e12f6cd48d1e2bd0184ce3fa7a96b9862a067924e0515f61319a4e2228f1efa
+  data.tar.gz: feeafc96cc49182ad4ad8819c628429fae848818fd284ade6906cdd34c32f0f8e1883cdcb72c23f037ebd86a70081a4f4f506ce430a7b5bd086cdab74077e0e7

data/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) Metabahn, LLC
+
+Pakyow Data is an open-source project licensed under the terms of the LGPLv3 license.
+See <https://choosealicense.com/licenses/lgpl-3.0/> for license text.

data/README.md

@@ -0,0 +1,29 @@
+# pakyow-data
+
+Data layer for Pakyow.
+
+# Download
+
+The latest version of Pakyow Data can be installed with RubyGems:
+
+```
+gem install pakyow-data
+```
+
+Source code can be downloaded as part of the Pakyow project on Github:
+
+- https://github.com/pakyow/pakyow/tree/master/pakyow-data
+
+# License
+
+Pakyow Data is free and open-source under the [LGPLv3 license](https://choosealicense.com/licenses/lgpl-3.0/).
+
+# Support
+
+Found a bug? Tell us about it here:
+
+- https://github.com/pakyow/pakyow/issues
+
+We'd love to have you in the community:
+
+- http://pakyow.org/get-involved

data/lib/pakyow/data/adapters/abstract.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Adapters
+      class Abstract
+        def initialize(opts, logger: nil)
+          @opts, @logger = opts, logger
+        end
+
+        def dataset_for_source(_source)
+          raise "dataset_for_source is not implemented on #{self}"
+        end
+
+        def result_for_attribute_value(_attribute, _value, _source)
+          raise "result_for_attribute_value is not implemented on #{self}"
+        end
+
+        def transaction
+          raise "transactions are not supported by #{self}"
+        end
+
+        def connected?
+          false
+        end
+
+        def migratable?
+          false
+        end
+
+        class << self
+          def types_for_adapter(_adapter)
+          end
+        end
+
+        module SourceExtension
+        end
+
+        module Commands
+        end
+
+        module DatasetMethods
+          def to_a(_dataset)
+            raise "to_a is not implemented on #{self}"
+          end
+
+          def one(_dataset)
+            raise "one is not implemented on #{self}"
+          end
+
+          def count(_dataset)
+            raise "count is not implemented on #{self}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/adapters/sql/commands.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        module Commands
+          extend Support::Extension
+
+          apply_extension do
+            command :create, performs_create: true do |values|
+              begin
+                inserted_return_value = insert(values)
+                if self.class.primary_key_field
+                  if Migrator::AUTO_INCREMENTING_TYPES.include?(self.class.primary_key_type)
+                    where(self.class.primary_key_field => inserted_return_value)
+                  else
+                    where(self.class.primary_key_field => values[self.class.primary_key_field])
+                  end
+                else
+                  where(values)
+                end
+              rescue Sequel::UniqueConstraintViolation => error
+                raise UniqueViolation.build(error)
+              rescue Sequel::ForeignKeyConstraintViolation => error
+                raise ConstraintViolation.build(error)
+              end
+            end
+
+            command :update, performs_update: true do |values|
+              __getobj__.select(self.class.primary_key_field).map { |result|
+                result[self.class.primary_key_field]
+              }.tap do
+                begin
+                  unless values.empty?
+                    update(values)
+                  end
+                rescue Sequel::UniqueConstraintViolation => error
+                  raise UniqueViolation.build(error)
+                rescue Sequel::ForeignKeyConstraintViolation => error
+                  raise ConstraintViolation.build(error)
+                end
+              end
+            end
+
+            command :delete, provides_dataset: false, performs_delete: true do
+              begin
+                delete
+              rescue Sequel::ForeignKeyConstraintViolation => error
+                raise ConstraintViolation.build(error)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/adapters/sql/dataset_methods.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        module DatasetMethods
+          def to_a(dataset)
+            dataset.qualify.all
+          rescue Sequel::Error => error
+            raise QueryError.build(error)
+          end
+
+          def one(dataset)
+            dataset.qualify.first
+          rescue Sequel::Error => error
+            raise QueryError.build(error)
+          end
+
+          def count(dataset)
+            dataset.qualify.count
+          rescue Sequel::Error => error
+            raise QueryError.build(error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/adapters/sql/differ.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        class Differ
+          def initialize(connection:, source:, attributes: source.attributes)
+            @connection, @source, @attributes = connection, source, attributes
+          end
+
+          def exists?
+            raw_connection.table_exists?(table_name)
+          end
+
+          def changes?
+            attributes_to_add.any? || columns_to_remove.any? || column_types_to_change.any?
+          end
+
+          def table_name
+            @source.dataset_table
+          end
+
+          def attributes
+            Hash[@attributes.map { |attribute_name, attribute|
+              [attribute_name, @connection.adapter.finalized_attribute(attribute)]
+            }]
+          end
+
+          def attributes_to_add
+            {}.tap { |attributes|
+              self.attributes.each do |attribute_name, attribute_type|
+                unless schema.find { |column| column[0] == attribute_name }
+                  attributes[attribute_name] = attribute_type
+                end
+              end
+            }
+          end
+
+          def columns_to_remove
+            {}.tap { |columns|
+              schema.each do |column_name, column_info|
+                unless @source.attributes.keys.find { |attribute_name| attribute_name == column_name }
+                  columns[column_name] = column_info
+                end
+              end
+            }
+          end
+
+          def column_types_to_change
+            {}.tap { |attributes|
+              self.attributes.each do |attribute_name, attribute_type|
+                if found_column = schema.find { |column| column[0] == attribute_name }
+                  column_name, column_info = found_column
+                  unless column_info[:type] == attribute_type.meta[:column_type] && (!attribute_type.meta.include?(:native_type) || column_info[:db_type] == attribute_type.meta[:native_type])
+                    attributes[column_name] = attribute_type.meta[:migration_type]
+                  end
+                end
+              end
+            }
+          end
+
+          private
+
+          def raw_connection
+            @connection.adapter.connection
+          end
+
+          def schema
+            raw_connection.schema(table_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/adapters/sql/migrator/adapter_methods.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        class Migrator
+          module AdapterMethods
+            module Mysql
+              def create!
+                handle_error do
+                  @connection.adapter.connection.run("CREATE DATABASE `#{database}`")
+                end
+              end
+
+              def drop!
+                handle_error do
+                  @connection.adapter.connection.run("DROP DATABASE `#{database}`")
+                end
+              end
+
+              def self.globalize_connection_opts!(connection_opts)
+                connection_opts[:initial] = Sql.build_opts(path: connection_opts[:path])
+                connection_opts[:path] = nil
+              end
+
+              private def database
+                if @connection.opts.key?(:initial)
+                  @connection.opts[:initial][:path]
+                else
+                  @connection.opts[:path]
+                end
+              end
+            end
+
+            module Postgres
+              def create!
+                handle_error do
+                  @connection.adapter.connection.run("CREATE DATABASE \"#{database}\"")
+                end
+              end
+
+              def drop!
+                handle_error do
+                  @connection.adapter.connection.run <<~SQL
+                    SELECT
+                    pg_terminate_backend(pid)
+                    FROM
+                    pg_stat_activity
+                    WHERE
+                    -- don't kill my own connection!
+                    pid <> pg_backend_pid()
+                    -- don't kill the connections to other databases
+                    AND datname = '#{@connection.opts[:path]}';
+                  SQL
+
+                  @connection.adapter.connection.run("DROP DATABASE \"#{database}\"")
+                end
+              end
+
+              def self.globalize_connection_opts!(connection_opts)
+                connection_opts[:initial] = Sql.build_opts(path: connection_opts[:path])
+                connection_opts[:path] = "template1"
+              end
+
+              private def database
+                if @connection.opts.key?(:initial)
+                  @connection.opts[:initial][:path]
+                else
+                  @connection.opts[:path]
+                end
+              end
+            end
+
+            module Sqlite
+              def create!
+                # intentionally empty; automatically created on connect
+              end
+
+              def drop!
+                if File.exist?(@connection.opts[:path])
+                  FileUtils.rm(@connection.opts[:path])
+                end
+              end
+
+              def self.globalize_connection_opts!(connection_opts)
+                # nothing to do here
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/adapters/sql/migrator.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "pakyow/data/adapters/sql/differ"
+require "pakyow/data/sources/relational/migrator"
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        class Migrator < Sources::Relational::Migrator
+          require "pakyow/data/adapters/sql/migrator/adapter_methods"
+
+          def initialize(*)
+            super
+
+            extend self.class.adapter_methods_for_adapter(
+              @connection.opts[:adapter]
+            )
+          end
+
+          def disconnect!
+            @connection.disconnect
+          end
+
+          def create_source?(source)
+            !differ(source).exists?
+          end
+
+          def change_source?(source, attributes = source.attributes)
+            create_source?(source) || differ(source, attributes).changes?
+          end
+
+          def create_source!(source, attributes)
+            local_context = self
+            differ = differ(source, attributes)
+            create_table differ.table_name do
+              differ.attributes.each do |attribute_name, attribute|
+                local_context.send(:add_column_for_attribute, attribute_name, attribute, self, source)
+              end
+            end
+          end
+
+          def reassociate_source!(source, foreign_keys)
+            foreign_keys.each do |foreign_key_name, foreign_key|
+              differ = differ(source, foreign_key_name => foreign_key)
+
+              if create_source?(source) || differ.changes?
+                local_context = self
+
+                associate_table differ.table_name, with: foreign_key.meta[:foreign_key] do
+                  attributes_to_add = if local_context.send(:create_source?, source)
+                    differ.attributes
+                  else
+                    differ.attributes_to_add
+                  end
+
+                  attributes_to_add.each do |attribute_name, attribute|
+                    local_context.send(:add_column_for_attribute, attribute_name, attribute, self, source, method_prefix: "add_")
+                  end
+                end
+              end
+            end
+          end
+
+          def change_source!(source, attributes)
+            differ = differ(source, attributes)
+
+            if differ.changes?
+              local_context = self
+
+              alter_table differ.table_name do
+                differ.attributes_to_add.each do |attribute_name, attribute|
+                  local_context.send(:add_column_for_attribute, attribute_name, attribute, self, source, method_prefix: "add_")
+                end
+
+                differ.column_types_to_change.each do |column_name, _column_type|
+                  local_context.send(:change_column_type_for_attribute, column_name, differ.attributes[column_name], self)
+                end
+
+                # TODO: revisit when we're ready to tackle foreign key removal
+                #
+                # differ.columns_to_remove.keys.each do |column_name|
+                #   local_context.send(:remove_column_by_name, column_name, self)
+                # end
+              end
+            end
+          end
+
+          private
+
+          def automator
+            require "pakyow/data/adapters/sql/migrators/automator"
+            Migrators::Automator.new(@connection, sources: @sources)
+          end
+
+          def finalizer
+            require "pakyow/data/adapters/sql/migrators/finalizer"
+            Migrators::Finalizer.new(@connection, sources: @sources)
+          end
+
+          def differ(source, attributes = source.attributes)
+            Differ.new(connection: @connection, source: source, attributes: attributes)
+          end
+
+          AUTO_INCREMENTING_TYPES = %i(integer bignum).freeze
+          def add_column_for_attribute(attribute_name, attribute, context, source, method_prefix: "")
+            if attribute.meta[:primary_key]
+              if AUTO_INCREMENTING_TYPES.include?(attribute.meta[:migration_type])
+                context.send(:"#{method_prefix}primary_key", attribute_name, type: type_for_attribute(attribute))
+              else
+                context.send(:"#{method_prefix}column", attribute_name, type_for_attribute(attribute), primary_key: true, **column_opts_for_attribute(attribute))
+              end
+            elsif attribute.meta[:foreign_key] && source.container.sources.any? { |potential_foreign_source| potential_foreign_source.plural_name == attribute.meta[:foreign_key] }
+              context.send(:"#{method_prefix}foreign_key", attribute_name, attribute.meta[:foreign_key], type: type_for_attribute(attribute))
+            else
+              context.send(:"#{method_prefix}column", attribute_name, type_for_attribute(attribute), **column_opts_for_attribute(attribute))
+            end
+          end
+
+          def change_column_type_for_attribute(attribute_name, attribute, context)
+            context.set_column_type(attribute_name, type_for_attribute(attribute), **column_opts_for_attribute(attribute))
+          end
+
+          def remove_column_by_name(column_name, context)
+            context.drop_column(column_name)
+          end
+
+          ALLOWED_COLUMN_OPTS = %i(size text)
+          def column_opts_for_attribute(attribute)
+            {}.tap do |opts|
+              ALLOWED_COLUMN_OPTS.each do |opt|
+                if attribute.meta.include?(opt)
+                  opts[opt] = attribute.meta[opt]
+                end
+              end
+            end
+          end
+
+          def column_opts_string_for_attribute(attribute)
+            opts = column_opts_for_attribute(attribute)
+
+            if opts.any?
+              opts.each_with_object(String.new) { |(key, value), opts_string|
+                opts_string << ", #{key}: #{value.inspect}"
+              }
+            else
+              ""
+            end
+          end
+
+          def handle_error
+            yield
+          rescue Sequel::Error => error
+            Pakyow.logger.warn "#{error}"
+          end
+
+          class << self
+            def adapter_methods_for_adapter(adapter)
+              case adapter
+              when "mysql", "mysql2"
+                AdapterMethods::Mysql
+              when "postgres"
+                AdapterMethods::Postgres
+              when "sqlite"
+                AdapterMethods::Sqlite
+              end
+            end
+
+            def globalize_connection_opts!(connection_opts)
+              adapter_methods_for_adapter(
+                connection_opts[:adapter]
+              ).globalize_connection_opts!(
+                connection_opts
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/adapters/sql/migrators/automator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "pakyow/data/adapters/sql/migrator"
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        module Migrators
+          class Automator < Migrator
+            def associate_table(name, **, &block)
+              alter_table(name, &block)
+            end
+
+            def alter_table(name, &block)
+              @connection.adapter.connection.alter_table name do
+                AlterTable.new(self).instance_exec(&block)
+              end
+            end
+
+            def method_missing(name, *args, &block)
+              @connection.adapter.connection.public_send(name, *args, &block)
+            end
+
+            private
+
+            def type_for_attribute(attribute)
+              attribute.meta[:database_type]
+            end
+
+            class AlterTable
+              def initialize(table)
+                @table = table
+              end
+
+              def drop_column(*)
+                # Prevent columns from being dropped during auto migrate.
+              end
+
+              def method_missing(name, *args, &block)
+                @table.public_send(name, *args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/adapters/sql/migrators/finalizer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "pakyow/data/adapters/sql/migrator"
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        module Migrators
+          class Finalizer < Migrator
+            attr_reader :migrations
+
+            def initialize(*)
+              super
+              @migrations = []
+            end
+
+            def create_table(name, &block)
+              writer = Writer.new(root: true)
+              writer.create_table(name, &block)
+              @migrations << ["create_#{name}", writer]
+            end
+
+            def associate_table(name, with:, &block)
+              writer = Writer.new(root: true)
+              writer.alter_table(name, &block)
+              @migrations << ["associate_#{name}_with_#{with}", writer]
+            end
+
+            def alter_table(name, &block)
+              writer = Writer.new(root: true)
+              writer.alter_table(name, &block)
+              @migrations << ["change_#{name}", writer]
+            end
+
+            private
+
+            def type_for_attribute(attribute)
+              attribute.meta[:migration_type]
+            end
+
+            class Writer
+              def initialize(root: false)
+                @root, @content = root, String.new
+              end
+
+              def to_s
+                if @root
+                  <<~CONTENT
+                    change do
+                    #{indent(@content.strip)}
+                    end
+                  CONTENT
+                else
+                  @content.strip
+                end
+              end
+
+              def to_ary
+                [to_s]
+              end
+
+              def method_missing(name, *args, **kwargs, &block)
+                method_call = "#{name} #{args_to_string(args, kwargs)}"
+
+                if block_given?
+                  @content << <<~CONTENT
+                    #{method_call} do
+                    #{indent(Writer.new.tap { |writer| writer.instance_exec(&block) }.to_s)}
+                    end
+                  CONTENT
+                else
+                  @content << <<~CONTENT
+                    #{method_call}
+                  CONTENT
+                end
+              end
+
+              private
+
+              def args_to_string(args, kwargs)
+                kwargs.each_with_object(args.map(&:inspect).join(", ")) { |(key, value), string|
+                  string << ", #{key}: #{value.inspect}"
+                }
+              end
+
+              def indent(content)
+                content.split("\n").map { |line| "  #{line}" }.join("\n")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end