pakyow-data 1.0.0.rc1

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        class Runner
+          def initialize(connection, migration_path)
+            @connection, @migration_path = connection, migration_path
+          end
+
+          def disconnect!
+            @connection.disconnect
+          end
+
+          def run!
+            Pakyow.module_eval do
+              unless singleton_class.instance_methods.include?(:migration)
+                def self.migration(&block)
+                  Sequel.migration(&block)
+                end
+              end
+            end
+
+            # Allows migrations to be defined with the nice mapping, then executed with the Sequel type.
+            #
+            local_types = @connection.types
+            @connection.adapter.connection.define_singleton_method :type_literal do |column|
+              if column[:type].is_a?(Symbol)
+                begin
+                  column[:type] = Data::Types.type_for(column[:type], local_types).meta[:database_type]
+                rescue Pakyow::UnknownType
+                end
+              end
+
+              super(column)
+            end
+
+            Sequel.extension :migration
+            Sequel::Migrator.run(
+              @connection.adapter.connection, @migration_path,
+              allow_missing_migration_files: true
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        module SourceExtension
+          extend Support::Extension
+
+          private def build(string, *args)
+            Sequel.lit(string, *args)
+          end
+
+          apply_extension do
+            class_state :dataset_table, default: self.__object_name.name
+
+            class << self
+              def table(table_name)
+                @dataset_table = table_name
+              end
+
+              def default_primary_key_type
+                :bignum
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql
+        module Types
+          module Postgres
+            TYPES = {
+              bignum: Sql::TYPES[:bignum].meta(native_type: "bigint"),
+              decimal: Sql::TYPES[:decimal].meta(column_type: :decimal, native_type: ->(meta) { "numeric(#{meta[:size][0]},#{meta[:size][1]})" }),
+              integer: Sql::TYPES[:integer].meta(native_type: "integer"),
+              string: Sql::TYPES[:string].meta(native_type: "text"),
+              text: Sql::TYPES[:text].meta(column_type: :string),
+
+              json: Pakyow::Data::Types.Constructor(:json) { |value|
+                Sequel.pg_json(value)
+              }.meta(mapping: :json, database_type: :json)
+            }.freeze
+          end
+
+          module SQLite
+            TYPES = {
+              bignum: Sql::TYPES[:bignum].meta(native_type: "bigint"),
+              decimal: Sql::TYPES[:decimal].meta(column_type: :decimal, native_type: ->(meta) { "numeric(#{meta[:size][0]}, #{meta[:size][1]})" }),
+              integer: Sql::TYPES[:integer].meta(native_type: "integer"),
+              string: Sql::TYPES[:string].meta(native_type: "varchar(255)"),
+              text: Sql::TYPES[:text].meta(column_type: :string),
+
+              # Used indirectly for migrations to override the column type (since
+              # sqlite doesn't support bignum as a primary key).
+              #
+              pk_bignum: Sql::TYPES[:bignum].meta(column_type: :integer)
+            }.freeze
+          end
+
+          module MySQL
+            TYPES = {
+              bignum: Sql::TYPES[:bignum].meta(native_type: "bigint(20)"),
+              decimal: Sql::TYPES[:decimal].meta(column_type: :decimal, native_type: ->(meta) { "decimal(#{meta[:size][0]},#{meta[:size][1]})" }),
+              integer: Sql::TYPES[:integer].meta(native_type: "int(11)"),
+              string: Sql::TYPES[:string].meta(native_type: "varchar(255)"),
+              text: Sql::TYPES[:text].meta(column_type: :string)
+            }.freeze
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "sequel"
+
+require "pakyow/support/extension"
+
+require "pakyow/support/core_refinements/string/normalization"
+
+require "pakyow/data/adapters/abstract"
+
+module Pakyow
+  module Data
+    module Adapters
+      class Sql < Abstract
+        require "pakyow/data/adapters/sql/commands"
+        require "pakyow/data/adapters/sql/dataset_methods"
+        require "pakyow/data/adapters/sql/migrator"
+        require "pakyow/data/adapters/sql/runner"
+        require "pakyow/data/adapters/sql/source_extension"
+
+        TYPES = {
+          # overrides for default types
+          boolean: Data::Types::MAPPING[:boolean].meta(default: false, database_type: :boolean, column_type: :boolean),
+          date: Data::Types::MAPPING[:date].meta(database_type: :date),
+          datetime: Data::Types::MAPPING[:datetime].meta(database_type: DateTime),
+          decimal: Data::Types::MAPPING[:decimal].meta(database_type: BigDecimal, size: [10, 2]),
+          float: Data::Types::MAPPING[:float].meta(database_type: :float),
+          integer: Data::Types::MAPPING[:integer].meta(database_type: Integer),
+          string: Data::Types::MAPPING[:string].meta(database_type: String),
+          time: Data::Types::MAPPING[:time].meta(database_type: Time, column_type: :datetime),
+
+          # sql-specific types
+          file: Types.Constructor(Sequel::SQL::Blob).meta(mapping: :file, database_type: File, column_type: :blob),
+          text: Types::Coercible::String.meta(mapping: :text, database_type: :text, column_type: :text, native_type: "text"),
+          bignum: Types::Coercible::Integer.meta(mapping: :bignum, database_type: :Bignum)
+        }.freeze
+
+        require "pakyow/data/adapters/sql/types"
+
+        attr_reader :connection
+
+        DEFAULT_EXTENSIONS = %i(
+          connection_validator
+        ).freeze
+
+        DEFAULT_ADAPTER_EXTENSIONS = {
+          postgres: %i(
+            pg_json
+          ).freeze
+        }.freeze
+
+        def initialize(opts, logger: nil)
+          @opts, @logger = opts, logger
+          connect
+        end
+
+        def qualify_attribute(attribute, source)
+          Sequel.qualify(source.class.dataset_table, attribute)
+        end
+
+        def alias_attribute(attribute, as)
+          Sequel.as(attribute, as)
+        end
+
+        def dataset_for_source(source)
+          @connection[source.dataset_table]
+        end
+
+        def result_for_attribute_value(attribute, value, source)
+          source.where(attribute => value)
+        end
+
+        def restrict_to_source(restrict_to_source, source, *additional_fields)
+          source.select.qualify(
+            restrict_to_source.class.dataset_table
+          ).select_append(
+            *additional_fields
+          )
+        end
+
+        def restrict_to_attribute(attribute, source)
+          source.select(*attribute)
+        end
+
+        def merge_results(left_column_name, right_column_name, mergeable_source, merge_into_source)
+          merge_into_source.tap do
+            merge_into_source.__setobj__(
+              merge_into_source.join(
+                mergeable_source.class.dataset_table, left_column_name => right_column_name
+              )
+            )
+          end
+        end
+
+        def transaction(&block)
+          @connection.transaction do
+            begin
+              block.call
+            rescue Rollback
+              raise Sequel::Rollback
+            end
+          end
+        end
+
+        def connect
+          @connection = Sequel.connect(
+            adapter: @opts[:adapter],
+            database: @opts[:path],
+            host: @opts[:host],
+            port: @opts[:port],
+            user: @opts[:user],
+            password: @opts[:password],
+            logger: @logger
+          )
+
+          (DEFAULT_EXTENSIONS + DEFAULT_ADAPTER_EXTENSIONS[@opts[:adapter].to_s.to_sym].to_a).each do |extension|
+            @connection.extension extension
+          end
+
+          if @opts.include?(:timeout)
+            @connection.pool.connection_validation_timeout = @opts[:timeout].to_i
+          end
+        rescue Sequel::AdapterNotFound => error
+          raise MissingAdapter.build(error)
+        rescue Sequel::DatabaseConnectionError => error
+          raise ConnectionError.build(error)
+        end
+
+        def disconnect
+          if connected?
+            @connection.disconnect
+          end
+        end
+
+        def connected?
+          @connection.opts[:adapter] == "sqlite" || @connection.test_connection
+        rescue
+          false
+        end
+
+        def migratable?
+          true
+        end
+
+        def auto_migratable?
+          true
+        end
+
+        def finalized_attribute(attribute)
+          if attribute.meta[:primary_key] || attribute.meta[:foreign_key]
+            begin
+              finalized_attribute = Data::Types.type_for(:"pk_#{attribute.meta[:mapping]}", Sql.types_for_adapter(@connection.opts[:adapter].to_sym)).dup
+
+              if attribute.meta[:primary_key]
+                finalized_attribute = finalized_attribute.meta(primary_key: attribute.meta[:primary_key])
+              end
+
+              if attribute.meta[:foreign_key]
+                finalized_attribute = finalized_attribute.meta(foreign_key: attribute.meta[:foreign_key])
+              end
+            rescue Pakyow::UnknownType
+              finalized_attribute = attribute.dup
+            end
+          else
+            finalized_attribute = attribute.dup
+          end
+
+          finalized_meta = finalized_attribute.meta.dup
+
+          if finalized_meta.include?(:mapping)
+            finalized_meta[:migration_type] = finalized_meta[:mapping]
+          end
+
+          unless finalized_meta.include?(:migration_type)
+            finalized_meta[:migration_type] = migration_type_for_attribute(attribute)
+          end
+
+          unless finalized_meta.include?(:column_type)
+            finalized_meta[:column_type] = column_type_for_attribute(attribute)
+          end
+
+          unless finalized_meta.include?(:database_type)
+            finalized_meta[:database_type] = database_type_for_attribute(attribute)
+          end
+
+          finalized_meta.each do |key, value|
+            finalized_meta[key] = case value
+            when Proc
+              if value.arity == 1
+                value.call(finalized_meta)
+              else
+                value.call
+              end
+            else
+              value
+            end
+          end
+
+          finalized_attribute.meta(finalized_meta)
+        end
+
+        private
+
+        def migration_type_for_attribute(attribute)
+          attribute.meta[:database_type] || attribute.primitive
+        end
+
+        def column_type_for_attribute(attribute)
+          attribute.primitive.to_s.downcase.to_sym
+        end
+
+        def database_type_for_attribute(attribute)
+          attribute.primitive
+        end
+
+        class << self
+          CONNECTION_TYPES = {
+            postgres: "Types::Postgres",
+            sqlite: "Types::SQLite",
+            mysql2: "Types::MySQL"
+          }.freeze
+
+          def types_for_adapter(adapter)
+            TYPES.dup.merge(const_get(CONNECTION_TYPES[adapter.to_sym])::TYPES)
+          end
+
+          using Support::Refinements::String::Normalization
+
+          def build_opts(opts)
+            database = if opts[:adapter] == "sqlite"
+              if opts[:host]
+                File.join(opts[:host], opts[:path])
+              else
+                opts[:path]
+              end
+            else
+              String.normalize_path(opts[:path])[1..-1]
+            end
+
+            opts[:path] = database
+            opts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/behavior/config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Data
+    module Behavior
+      module Config
+        extend Support::Extension
+
+        apply_extension do
+          configurable :data do
+            configurable :subscriptions do
+              setting :adapter_settings, {}
+              setting :version
+
+              defaults :production do
+                setting :adapter_settings do
+                  { key_prefix: [Pakyow.config.redis.key_prefix, config.name].join("/") }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/behavior/lookup.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/data/container"
+require "pakyow/data/lookup"
+require "pakyow/data/subscribers"
+
+module Pakyow
+  module Data
+    module Behavior
+      module Lookup
+        extend Support::Extension
+
+        # Data container object.
+        #
+        attr_reader :data
+
+        apply_extension do
+          after "boot", "initialize.data", priority: :high do
+            # Validate that each source connection exists.
+            #
+            state(:source).each do |source|
+              Pakyow.connection(source.adapter, source.connection)
+            end
+
+            subscribers = if is_a?(Plugin)
+              # Plugins should use the same subscribers object as their parent app.
+              #
+              parent.data.subscribers
+            else
+              Subscribers.new(
+                self,
+                Pakyow.config.data.subscriptions.adapter,
+                Pakyow.config.data.subscriptions.adapter_settings
+              )
+            end
+
+            containers = Pakyow.data_connections.values.each_with_object([]) { |connections, arr|
+              connections.values.each do |connection|
+                arr << Container.new(
+                  connection: connection,
+                  sources: state(:source).select { |source|
+                    connection.name == source.connection && connection.type == source.adapter
+                  },
+                  objects: state(:object)
+                )
+              end
+            }
+
+            containers.each do |container|
+              container.finalize_associations!(containers - [container])
+            end
+
+            containers.each do |container|
+              container.finalize_sources!(containers - [container])
+            end
+
+            @data = Data::Lookup.new(
+              app: self,
+              containers: containers,
+              subscribers: subscribers
+            )
+          end
+
+          on "shutdown" do
+            if instance_variable_defined?(:@data)
+              @data.subscribers.shutdown
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/behavior/serialization.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+require "pakyow/support/serializer"
+
+module Pakyow
+  module Data
+    module Behavior
+      # Persists in-memory subscribers across restarts.
+      #
+      module Serialization
+        extend Support::Extension
+
+        apply_extension do
+          on "shutdown", priority: :high do
+            if Pakyow.config.data.subscriptions.adapter == :memory && data
+              subscriber_serializer.serialize
+            end
+          end
+
+          after "boot" do
+            if Pakyow.config.data.subscriptions.adapter == :memory && data
+              subscriber_serializer.deserialize
+            end
+          end
+        end
+
+        private def subscriber_serializer
+          Support::Serializer.new(
+            data.subscribers.adapter,
+            name: "#{config.name}-subscribers",
+            path: File.join(
+              Pakyow.config.root, "tmp", "state"
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/connection.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "uri"
+require "forwardable"
+
+require "pakyow/support/class_state"
+require "pakyow/support/deep_freeze"
+require "pakyow/support/indifferentize"
+require "pakyow/support/inflector"
+
+module Pakyow
+  module Data
+    class Connection
+      extend Forwardable
+      def_delegators :@adapter, :dataset_for_source, :transaction
+
+      attr_reader :type, :name, :opts, :adapter, :failure
+
+      extend Support::DeepFreeze
+      unfreezable :logger, :adapter
+
+      def initialize(type:, name:, string: nil, opts: nil, logger: nil)
+        @type, @name, @logger, @failure = type, name, logger, nil
+
+        @opts = self.class.adapter(type).build_opts(
+          opts.is_a?(Hash) ? opts : self.class.parse_connection_string(string)
+        )
+
+        @adapter = self.class.adapter(@type).new(@opts, logger: @logger)
+      rescue ConnectionError, MissingAdapter => error
+        error.context = self
+        @failure = error
+      end
+
+      def connected?
+        !failed? && @adapter.connected?
+      end
+
+      def failed?
+        !@failure.nil?
+      end
+
+      def auto_migrate?
+        migratable? && @adapter.auto_migratable?
+      end
+
+      def migratable?
+        connected? && @adapter.migratable?
+      end
+
+      def connect
+        @adapter.connect
+      end
+
+      def disconnect
+        @adapter.disconnect
+      end
+
+      def types
+        if @adapter.class.const_defined?("TYPES")
+          @adapter.class.types_for_adapter(adapter.connection.opts[:adapter])
+        else
+          {}
+        end
+      end
+
+      extend Support::ClassState
+      class_state :adapter_types, default: []
+
+      using Support::Indifferentize
+
+      class << self
+        def parse_connection_string(connection_string)
+          uri = URI(connection_string)
+
+          {
+            adapter: uri.scheme,
+            path: uri.path,
+            host: uri.host,
+            port: uri.port,
+            user: uri.user,
+            password: uri.password
+          }.merge(
+            CGI::parse(uri.query.to_s).transform_values(&:first).indifferentize
+          )
+        end
+
+        def register_adapter(type)
+          (@adapter_types << type).uniq!
+        end
+
+        def adapter(type)
+          if @adapter_types.include?(type.to_sym)
+            require "pakyow/data/adapters/#{type}"
+            Adapters.const_get(Support.inflector.camelize(type))
+          else
+            raise UnknownAdapter.new_with_message(type: type)
+          end
+        end
+      end
+    end
+  end
+end