pakyow-data 1.0.0.rc1

data/lib/pakyow/data/migrator.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "uri"
+require "sequel"
+
+require "pakyow/support/inflector"
+
+module Pakyow
+  module Data
+    class Migrator
+      def initialize(connection)
+        @connection = connection
+      end
+
+      IVARS_TO_DISCONNECT = %i(@runner @migrator).freeze
+
+      def disconnect!
+        IVARS_TO_DISCONNECT.each do |ivar|
+          if instance_variable_defined?(ivar) && value = instance_variable_get(ivar)
+            value.disconnect!
+          end
+        end
+
+        @connection.disconnect
+      end
+
+      def create!
+        migrator.create!
+        disconnect!
+
+        # Recreate the connection, since we just created the database it's supposed to connect to.
+        #
+        @connection = Connection.new(
+          opts: @connection.opts,
+          type: @connection.type,
+          name: @connection.name
+        )
+      end
+
+      def drop!
+        migrator.drop!
+      end
+
+      def migrate!
+        if migrations_to_run?
+          runner.run!
+        end
+      end
+
+      def auto_migrate!
+        migrator.auto_migrate!
+      end
+
+      def finalize!
+        migrator.finalize!.each do |filename, content|
+          FileUtils.mkdir_p(migration_path)
+
+          File.open(File.join(migration_path, filename), "w+") do |file|
+            file.write <<~CONTENT
+              Pakyow.migration do
+              #{content.to_s.split("\n").map { |line| "  #{line}" }.join("\n")}
+              end
+            CONTENT
+          end
+        end
+      end
+
+      private
+
+      def migrator
+        @migrator = self.class.migrator_for_adapter(Support.inflector.classify(@connection.type), :Migrator).new(
+          @connection, sources: sources
+        )
+      end
+
+      def runner
+        @runner = self.class.migrator_for_adapter(Support.inflector.classify(@connection.type), :Runner).new(
+          @connection, migration_path
+        )
+      end
+
+      def sources
+        Pakyow.apps.reject(&:rescued?).flat_map { |app|
+          app.data.containers.flat_map(&:sources).concat(
+            app.plugs.flat_map { |plug|
+              plug.data.containers.flat_map(&:sources)
+            }
+          )
+        }.select { |source|
+          source.connection == @connection.name && source.adapter == @connection.type
+        }
+      end
+
+      def migrations
+        Dir.glob(File.join(migration_path, "*.rb"))
+      end
+
+      def migrations_to_run?
+        migrations.count > 0
+      end
+
+      def migration_path
+        File.join(Pakyow.config.data.migration_path, "#{@connection.type}/#{@connection.name}")
+      end
+
+      def track_exported_migrations
+        initial_migrations = migrations
+        yield
+        migrations - initial_migrations
+      end
+
+      class << self
+        def migrator_for_adapter(adapter, type = :Migrator)
+          Adapters.const_get(Support.inflector.camelize(adapter)).const_get(type)
+        end
+
+        def connect(adapter:, connection:, connection_overrides: {})
+          adapter = if adapter
+            adapter.to_sym
+          else
+            Pakyow.config.data.default_adapter
+          end
+
+          connection = if connection
+            connection.to_sym
+          else
+            Pakyow.config.data.default_connection
+          end
+
+          connection_opts = Connection.parse_connection_string(
+            Pakyow.config.data.connections.send(adapter)[connection]
+          )
+
+          merge_connection_overrides!(connection_opts, connection_overrides)
+          new(Connection.new(opts: connection_opts, type: adapter, name: connection))
+        end
+
+        def connect_global(adapter:, connection:, connection_overrides: {})
+          adapter = if adapter
+            adapter.to_sym
+          else
+            Pakyow.config.data.default_adapter
+          end
+
+          connection = if connection
+            connection.to_sym
+          else
+            Pakyow.config.data.default_connection
+          end
+
+          connection_opts = Connection.parse_connection_string(
+            Pakyow.config.data.connections.send(adapter)[connection]
+          )
+
+          merge_connection_overrides!(connection_opts, connection_overrides)
+          globalize_connection_opts!(adapter, connection_opts)
+
+          connect(
+            adapter: adapter,
+            connection: connection,
+            connection_overrides: connection_opts
+          )
+        end
+
+        def globalize_connection_opts!(adapter, connection_opts)
+          migrator_for_adapter(adapter).globalize_connection_opts!(connection_opts)
+        end
+
+        def merge_connection_overrides!(connection_opts, connection_overrides)
+          connection_overrides.each do |key, value|
+            key = key.to_sym
+            connection_opts[key] = if value.is_a?(Proc)
+              value.call(connection_opts[key])
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/object.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "pakyow/support/bindable"
+require "pakyow/support/class_state"
+require "pakyow/support/makeable"
+require "pakyow/support/indifferentize"
+
+module Pakyow
+  module Data
+    # Wraps values for a data object returned by a source.
+    #
+    class Object
+      include Support::Bindable
+
+      attr_reader :values
+
+      # @api private
+      attr_accessor :originating_source
+
+      extend Support::ClassState
+      class_state :__serialized_methods, default: [], inheritable: true
+
+      extend Support::Makeable
+
+      def initialize(values)
+        @values = Support::IndifferentHash.new(values).freeze
+      end
+
+      def source
+        @originating_source.__object_name.name
+      end
+
+      def include?(key)
+        respond_to?(key)
+      end
+      alias key? include?
+
+      def [](key)
+        key = key.to_s.to_sym
+        if respond_to?(key)
+          public_send(key)
+        else
+          @values[key]
+        end
+      end
+
+      def method_missing(name, *_args)
+        if include?(name)
+          @values[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, *)
+        @values.include?(name) || super
+      end
+
+      def to_h
+        hash = @values.dup
+        self.class.__serialized_methods.each do |method|
+          hash[method] = public_send(method)
+        end
+
+        hash
+      end
+
+      def to_json(*)
+        @values.to_json
+      end
+
+      def ==(other)
+        comparator = case other
+        when self.class
+          other
+        when Result
+          other.__getobj__
+        else
+          nil
+        end
+
+        comparator && comparator.class == self.class && comparator.values == @values
+      end
+
+      class << self
+        attr_reader :name
+
+        def make(name, state: nil, parent: nil, **kwargs, &block)
+          super(name, state: state, parent: parent, **kwargs, &block)
+        end
+
+        def serialize(*methods)
+          @__serialized_methods.concat(methods.map(&:to_sym)).uniq!
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/proxy.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "pakyow/support/core_refinements/array/ensurable"
+require "pakyow/support/deep_dup"
+require "pakyow/support/inspectable"
+
+require "pakyow/data/result"
+
+module Pakyow
+  module Data
+    # @api private
+    class Proxy
+      include Support::Inspectable
+      inspectable :@source
+
+      using Support::Refinements::Array::Ensurable
+
+      using Support::DeepDup
+
+      attr_reader :source, :proxied_calls, :nested_proxies, :app
+
+      def initialize(source, subscribers, app)
+        @source, @subscribers, @app = source, subscribers, app
+
+        @proxied_calls = []
+        @subscribable = true
+        @nested_proxies = []
+      end
+
+      IVARS_TO_DUP = %i(@proxied_calls @nested_proxies).freeze
+
+      def deep_dup
+        super.tap do |duped|
+          IVARS_TO_DUP.each do |ivar|
+            duped.instance_variable_set(ivar, duped.instance_variable_get(ivar).deep_dup)
+          end
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        if @source.command?(method_name)
+          dup.tap { |duped_proxy|
+            result = @source.command(method_name).call(*args) { |yielded_result|
+              duped_proxy.instance_variable_set(:@source, yielded_result)
+              yield duped_proxy if block_given?
+            }
+
+            if @source.respond_to?(:transaction) && @source.transaction?
+              @source.on_commit do
+                @subscribers.did_mutate(
+                  @source.source_name, args[0], result
+                )
+              end
+            else
+              @subscribers.did_mutate(
+                @source.source_name, args[0], result
+              )
+            end
+          }
+        elsif @source.query?(method_name) || @source.modifier?(method_name)
+          dup.tap { |duped_proxy|
+            nested_calls = []
+
+            new_source = if block_given? && @source.block_for_nested_source?(method_name)
+              # In this case a block has been passed that would, without intervention,
+              # be called in context of a source instance. We don't want that, since
+              # it would provide full access to the underlying dataset. Instead the
+              # exposed object should simply be another proxy.
+
+              local_subscribers, local_app = @subscribers, @app
+              @source.source_from_self.public_send(method_name, *args) {
+                nested_proxy = Proxy.new(self, local_subscribers, local_app)
+                nested_proxy.instance_variable_set(:@proxied_calls, nested_calls)
+                nested_proxy.instance_exec(&block).source.tap do |nested_proxy_source|
+                  duped_proxy.nested_proxies << nested_proxy.dup.tap do |finalized_nested_proxy|
+                    finalized_nested_proxy.instance_variable_set(:@source, nested_proxy_source)
+                  end
+                end
+              }
+            else
+              @source.source_from_self.public_send(method_name, *args).tap do |working_source|
+                working_source.included.each do |_, included_source|
+                  nested_proxy = Proxy.new(included_source, @subscribers, @app)
+                  duped_proxy.nested_proxies << nested_proxy
+                end
+              end
+            end
+
+            duped_proxy.instance_variable_set(:@source, new_source)
+            duped_proxy.instance_variable_get(:@proxied_calls) << [
+              method_name, args, nested_calls
+            ]
+          }
+        else
+          if Array.instance_methods.include?(method_name) && !@source.class.instance_methods.include?(method_name)
+            build_result(
+              @source.to_a.public_send(method_name, *args, &block),
+              method_name, args
+            )
+          elsif @source.class.instance_methods.include?(method_name)
+            build_result(
+              @source.public_send(method_name, *args, &block),
+              method_name, args
+            )
+          else
+            super
+          end
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        return false if method_name == :marshal_dump || method_name == :marshal_load
+        @source.command?(method_name) || @source.query?(method_name) || @source.modifier?(method_name) || @source.respond_to?(method_name, include_private)
+      end
+
+      def to_ary
+        to_a
+      end
+
+      def to_json(*)
+        @source.to_json
+      end
+
+      def subscribe(subscriber, handler:, payload: nil, &block)
+        subscriptions = []
+
+        if subscribable?
+          subscriptions << {
+            source: @source.source_name,
+            ephemeral: @source.is_a?(Sources::Ephemeral),
+            handler: handler,
+            payload: payload,
+            qualifications: qualifications,
+            proxy: self
+          }
+
+          @nested_proxies.each do |related_proxy|
+            subscriptions.concat(
+              related_proxy.subscribe_related(
+                parent_source: @source,
+                serialized_proxy: self,
+                handler: handler,
+                payload: payload
+              )
+            )
+          end
+        end
+
+        @subscribers.register_subscriptions(subscriptions, subscriber: subscriber, &block)
+      end
+
+      def subscribe_related(parent_source:, serialized_proxy:, handler:, payload: nil)
+        subscriptions = []
+
+        if association = parent_source.class.find_association_to_source(@source)
+          parent_source.each do |parent_result|
+            subscriptions << {
+              source: @source.source_name,
+              handler: handler,
+              payload: payload,
+              qualifications: qualifications.merge(
+                association.associated_query_field => parent_result[association.query_field]
+              ),
+              proxy: serialized_proxy
+            }
+          end
+        else
+          Pakyow.logger.error "tried to subscribe a related source, but we don't know how it's related"
+        end
+
+        @nested_proxies.each do |related_proxy|
+          subscriptions.concat(
+            related_proxy.subscribe_related(
+              parent_source: @source,
+              serialized_proxy: serialized_proxy,
+              handler: handler,
+              payload: payload
+            )
+          )
+        end
+
+        subscriptions
+      end
+
+      def unsubscribe
+        subscribable(false)
+      end
+
+      def subscribable(boolean)
+        tap do
+          @subscribable = boolean
+        end
+      end
+
+      def subscribable?
+        @subscribable == true
+      end
+
+      def _dump(_)
+        Marshal.dump(
+          {
+            app: @app,
+            source: @source.is_a?(Sources::Ephemeral) ? @source : @source.source_name,
+            proxied_calls: @proxied_calls
+          }
+        )
+      end
+
+      def self._load(state)
+        state = Marshal.load(state)
+
+        case state[:source]
+        when Sources::Ephemeral
+          ephemeral = state[:app].data.ephemeral(state[:source].source_name)
+          ephemeral.instance_variable_set(:@source, state[:source])
+          ephemeral
+        else
+          state[:app].data.public_send(state[:source]).apply(state[:proxied_calls])
+        end
+      end
+
+      def qualifications
+        @proxied_calls.inject(@source.qualifications) { |qualifications, proxied_call|
+          qualifications_for_proxied_call = @source.class.qualifications(proxied_call[0]).dup
+
+          # Populate argument qualifications with argument values.
+          #
+          qualifications_for_proxied_call.each do |qualification_key, qualification_value|
+            next unless qualification_value.to_s.start_with?("__arg")
+            arg_number = qualification_value.to_s.gsub(/[^0-9]/, "").to_i
+            qualifications_for_proxied_call[qualification_key] = @source.class.attributes[qualification_key][proxied_call[1][arg_number]]
+          end
+
+          qualifications.merge(qualifications_for_proxied_call)
+        }
+      end
+
+      # @api private
+      def apply(proxied_calls)
+        proxied_calls.inject(self) { |proxy, proxied_call|
+          if proxied_call[2].any?
+            proxy.public_send(proxied_call[0], *proxied_call[1]) do
+              apply(proxied_call[2])
+            end
+          else
+            proxy.public_send(proxied_call[0], *proxied_call[1])
+          end
+        }
+      end
+
+      private
+
+      def build_result(value, method_name, args)
+        if method_name.to_s.end_with?("?")
+          value
+        else
+          Result.new(value, self, originating_method: method_name, originating_args: args)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/result.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Pakyow
+  module Data
+    class Result < SimpleDelegator
+      def initialize(result, proxy, originating_method: nil, originating_args: [])
+        @__proxy = proxy
+        @originating_method = originating_method
+        @originating_args = originating_args
+        __setobj__(result)
+      end
+
+      def nil?
+        __getobj__.nil?
+      end
+
+      def marshal_dump
+        {
+          proxy: {
+            app: @__proxy.app,
+            source: @__proxy.source.source_name,
+            proxied_calls: @__proxy.proxied_calls
+          },
+
+          originating_method: @originating_method,
+          originating_args: @originating_args
+        }
+      end
+
+      def marshal_load(state)
+        result = state[:proxy][:app].data.public_send(
+          state[:proxy][:source]
+        ).apply(
+          state[:proxy][:proxied_calls]
+        )
+
+        if state[:originating_method]
+          result = result.public_send(state[:originating_method], *state[:originating_args])
+        end
+
+        __setobj__(result)
+      end
+
+      # Fixes an issue using pp inside a delegator.
+      #
+      def pp(*args)
+        Kernel.pp(*args)
+      end
+    end
+  end
+end

data/lib/pakyow/data/sources/abstract.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+require "pakyow/support/class_state"
+
+module Pakyow
+  module Data
+    module Sources
+      class Abstract < SimpleDelegator
+        extend Support::ClassState
+        class_state :__finalized, default: false, inheritable: true
+
+        def initialize(dataset)
+          __setobj__(dataset)
+        end
+
+        # Fixes an issue using pp inside a delegator.
+        #
+        def pp(*args)
+          Kernel.pp(*args)
+        end
+
+        # @api private
+        attr_reader :original_results
+
+        # @api private
+        def qualifications
+          {}
+        end
+
+        # @api private
+        def command?(_maybe_command_name)
+          false
+        end
+
+        # @api private
+        def query?(_maybe_query_name)
+          false
+        end
+
+        # @api private
+        def modifier?(_maybe_modifier_name)
+          false
+        end
+
+        # @api private
+        def source_from_self(dataset = __getobj__)
+          self.class.source_from_source(self, dataset)
+        end
+
+        class << self
+          attr_reader :container
+
+          def instance
+            container.source(plural_name)
+          end
+
+          # @api private
+          attr_writer :container
+
+          # @api private
+          def plural_name
+            Support.inflector.pluralize(__object_name.name).to_sym
+          end
+
+          # @api private
+          def singular_name
+            Support.inflector.singularize(__object_name.name).to_sym
+          end
+
+          # @api private
+          def source_from_source(source, dataset)
+            source.dup.tap do |duped_source|
+              duped_source.__setobj__(dataset)
+            end
+          end
+        end
+      end
+    end
+  end
+end