pakyow-data 1.0.0.rc1

data/lib/pakyow/data/container.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "pakyow/support/inflector"
+
+require "pakyow/data/types"
+
+module Pakyow
+  module Data
+    class Container
+      attr_reader :connection, :sources
+
+      def initialize(connection:, sources:, objects:)
+        @connection, @sources = connection, sources
+
+        @object_map = objects.each_with_object({}) { |object, map|
+          map[object.__object_name.name] = object
+        }
+      end
+
+      def source(source_name)
+        plural_source_name = Support.inflector.pluralize(source_name).to_sym
+
+        if found_source = sources.find { |source|
+             source.plural_name == plural_source_name
+           }
+
+          found_source.new(
+            @connection.dataset_for_source(found_source)
+          )
+        end
+      end
+
+      def object(object_name)
+        @object_map.fetch(object_name, Object)
+      end
+
+      def finalize_associations!(other_containers)
+        @sources.each do |source|
+          discover_has_and_belongs_to!(source, other_containers)
+        end
+
+        @sources.each do |source|
+          set_container_for_source!(source)
+          define_reciprocal_associations!(source, other_containers)
+        end
+      end
+
+      def finalize_sources!(other_containers)
+        @sources.each do |source|
+          mixin_commands!(source)
+          mixin_dataset_methods!(source)
+          define_attributes_for_associations!(source, other_containers)
+          define_queries_for_attributes!(source)
+          wrap_defined_queries!(source)
+          define_methods_for_associations!(source)
+          define_methods_for_objects!(source)
+          finalize_source_types!(source)
+        end
+      end
+
+      private
+
+      def adapter
+        @connection.adapter
+      end
+
+      def discover_has_and_belongs_to!(source, other_containers)
+        source.associations.values.flatten.select { |association|
+          # Only look for has_* associations that aren't already setup through another source.
+          #
+          association.type == :has
+        }.each do |association|
+          reciprocal_association = nil
+          reciprocal_source = (@sources + other_containers.flat_map(&:sources)).reject { |potentially_reciprocal_source|
+            potentially_reciprocal_source == source
+          }.find { |potentially_reciprocal_source|
+            reciprocal_association = potentially_reciprocal_source.associations.values.flatten.find { |potentially_reciprocal_association|
+              potentially_reciprocal_association.specific_type == association.specific_type &&
+                potentially_reciprocal_association.associated_source_name == source.plural_name &&
+                Support.inflector.pluralize(potentially_reciprocal_association.name) == Support.inflector.pluralize(association.associated_name) &&
+                Support.inflector.pluralize(potentially_reciprocal_association.associated_name) == Support.inflector.pluralize(association.name)
+            }
+          }
+
+          if reciprocal_source
+            joining_source_name = [source.plural_name, reciprocal_source.plural_name].sort.join("_")
+            joining_source = (@sources + other_containers.flat_map(&:sources)).find { |potentially_joining_source|
+              potentially_joining_source.plural_name == joining_source_name
+            }
+
+            unless joining_source
+              joining_source = source.ancestors.find { |ancestor|
+                ancestor != source && ancestor.ancestors.include?(Sources::Abstract)
+              }.make(
+                joining_source_name,
+                adapter: source.adapter,
+                connection: source.connection,
+                within: source.__object_name.namespace
+              )
+
+              @sources << joining_source
+            end
+
+            # Modify both sides of the association to be through the joining source.
+            #
+            source.setup_as_through(association, through: joining_source_name).internal!
+            reciprocal_source.setup_as_through(reciprocal_association, through: joining_source_name).internal!
+          end
+        end
+      end
+
+      def set_container_for_source!(source)
+        source.container = self
+      end
+
+      def mixin_commands!(source)
+        source.include adapter.class.const_get("Commands")
+      end
+
+      def mixin_dataset_methods!(source)
+        source.extend adapter.class.const_get("DatasetMethods")
+      end
+
+      def define_attributes_for_associations!(source, other_containers)
+        source.associations.values.flatten.each do |association|
+          associated_source = (@sources + other_containers.flat_map(&:sources)).find { |potentially_associated_source|
+            potentially_associated_source.plural_name == association.associated_source_name
+          }
+
+          if associated_source
+            association.associated_source = associated_source
+
+            if association.type == :through
+              association.joining_source = (@sources + other_containers.flat_map(&:sources)).find { |potentially_joining_source|
+                potentially_joining_source.plural_name == association.joining_source_name
+              }
+            end
+
+            if association.type == :belongs
+              # Define an attribute for the foreign key.
+              #
+              source.attribute(
+                association.foreign_key_field,
+                association.foreign_key_type,
+                foreign_key: association.associated_source_name
+              )
+            end
+          end
+        end
+      end
+
+      def define_reciprocal_associations!(source, other_containers)
+        (source.associations[:has_many] + source.associations[:has_one]).each do |association|
+          associated_source = (@sources + other_containers.flat_map(&:sources)).find { |potentially_associated_source|
+            potentially_associated_source.plural_name == association.associated_source_name
+          }
+
+          if associated_source
+            if association.type == :through
+              joining_source = (@sources + other_containers.flat_map(&:sources)).find { |potential_joining_source|
+                potential_joining_source.plural_name == association.joining_source_name
+              }
+
+              if joining_source
+                unless joining_source.associations[:belongs_to].any? { |current_association| current_association.name == association.left_name }
+                  joining_source.belongs_to(association.left_name, source: associated_source.plural_name)
+                end
+
+                unless joining_source.associations[:belongs_to].any? { |current_association| current_association.name == association.right_name }
+                  joining_source.belongs_to(association.right_name, source: source.plural_name)
+                end
+
+                unless association.internal?
+                  unless associated_source.associations[association.specific_type].any? { |current_association| current_association.joining_source_name == association.joining_source_name }
+                    associated_source.send(association.specific_type, association.associated_name, source: source.plural_name, as: association.left_name, through: association.joining_source_name, dependent: association.dependent)
+                  end
+
+                  unless source.associations[association.specific_type].any? { |current_association| current_association.associated_source_name == association.joining_source_name }
+                    source.send(association.specific_type, association.joining_source_name, source: joining_source.plural_name, as: Support.inflector.singularize(association.associated_name), dependent: association.dependent)
+                  end
+                end
+              end
+            else
+              unless associated_source.associations[:belongs_to].any? { |current_association| current_association.name == Support.inflector.singularize(association.associated_name).to_sym }
+                associated_source.belongs_to(association.associated_name, source: source.plural_name)
+              end
+            end
+          end
+        end
+      end
+
+      def define_queries_for_attributes!(source)
+        source.attributes.keys.each do |attribute|
+          method_name = :"by_#{attribute}"
+          unless source.instance_methods.include?(method_name)
+            source.class_eval do
+              define_method method_name do |value|
+                self.class.container.connection.adapter.result_for_attribute_value(attribute, value, self)
+              end
+
+              # Qualify the query.
+              #
+              subscribe :"by_#{attribute}", attribute => :__arg0__
+            end
+          end
+        end
+      end
+
+      def define_methods_for_associations!(source)
+        source.associations.values.flatten.each do |association|
+          method_name = :"with_#{association.name}"
+          unless source.instance_methods.include?(method_name)
+            source.class_eval do
+              define_method method_name do
+                including(association.name)
+              end
+            end
+          end
+        end
+      end
+
+      def define_methods_for_objects!(source)
+        @object_map.keys.each do |object_name|
+          method_name = :"as_#{object_name}"
+          unless source.instance_methods.include?(method_name)
+            source.class_eval do
+              define_method method_name do
+                as(object_name)
+              end
+            end
+          end
+        end
+      end
+
+      # Override queries with methods that update the source with a new dataset.
+      #
+      def wrap_defined_queries!(source)
+        local_queries = source.queries
+        source.prepend(
+          Module.new do
+            local_queries.each do |query|
+              define_method query do |*args, &block|
+                tap do
+                  result = super(*args, &block)
+                  case result
+                  when self.class
+                    result
+                  else
+                    __setobj__(result)
+                  end
+                end
+              end
+            end
+          end
+        )
+      end
+
+      def finalize_source_types!(source)
+        source.attributes.each do |attribute_name, attribute_info|
+          if attribute_info.is_a?(Hash)
+            type = Types.type_for(attribute_info[:type], connection.types)
+
+            if attribute_name == source.primary_key_field
+              type = type.meta(primary_key: true)
+            end
+
+            source.attributes[attribute_name] = type.meta(attribute_info[:options])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/errors.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "pakyow/error"
+
+module Pakyow
+  module Data
+    class Error < Pakyow::Error
+    end
+
+    class ConnectionError < Error
+      def contextual_message
+        String.new(
+          <<~MESSAGE
+            Connection for #{@context.type}.#{@context.name} could not be established.
+          MESSAGE
+        )
+      end
+    end
+
+    class ConstraintViolation < Error
+      class_state :messages, default: {
+        associate_many_missing: "can't associate results as `{association}' because at least one value could not be found",
+        associate_missing: "can't find associated {source} with {field} of `{value}'",
+        associate_multiple: "can't associate multiple results as `{association}'",
+        dependent_delete: "can't delete {source} because of {count} dependent {dependent}"
+      }.freeze
+    end
+
+    class MissingAdapter < Error
+    end
+
+    class NotNullViolation < Error
+      class_state :messages, default: {
+        default: "`{attribute}' is a required attribute"
+      }.freeze
+    end
+
+    class QueryError < Error
+    end
+
+    class Rollback < Error
+    end
+
+    class TypeMismatch < Error
+      class_state :messages, default: {
+        default: "can't convert `{type}' into {mapping}",
+        associate_many_not_object: "can't associate results as `{association}' because at least one value is not a Pakyow::Data::Object",
+        associate_many_wrong_source: "can't associate results as `{association}' because at least one value did not originate from {source}",
+        associate_unknown_object: "can't associate an object with an unknown source as `{association}'",
+        associate_wrong_object: "can't associate an object from {source} as `{association}'",
+        associate_wrong_source: "can't associate {source} as `{association}'",
+        associate_wrong_type: "can't associate {type} as `{association}'"
+      }.freeze
+    end
+
+    class UniqueViolation < Error
+    end
+
+    class UnknownAdapter < Error
+      class_state :messages, default: {
+        default: "`{type}' is not a known adapter"
+      }.freeze
+    end
+
+    class UnknownAttribute < Error
+      class_state :messages, default: {
+        default: "`{attribute}' is not a known attribute for {source}"
+      }.freeze
+    end
+
+    class UnknownAssociation < Error
+      def contextual_message
+        if associations.any?
+          String.new(
+            <<~MESSAGE
+              The following associations exist for #{@context.__object_name.name}:
+            MESSAGE
+          ).tap do |message|
+            associations.each do |association|
+              message << "  * #{association.name}"
+            end
+          end
+        else
+          String.new(
+            <<~MESSAGE
+              No associations exist for #{@context.__object_name.name}.
+            MESSAGE
+          )
+        end
+      end
+
+      private
+
+      def associations
+        @context.associations.values.flatten
+      end
+    end
+
+    class UnknownCommand < Error
+      class_state :messages, default: {
+        default: "`{command}' is not a known command"
+      }.freeze
+
+      def contextual_message
+        if commands.any?
+          String.new(
+            <<~MESSAGE
+              The following commands are defined for #{@context.__object_name.name}:
+            MESSAGE
+          ).tap do |message|
+            commands.keys.each do |command|
+              message << "  * #{command}\n"
+            end
+          end
+        else
+          String.new(
+            <<~MESSAGE
+              No commands are defined for #{@context.__object_name.name}.
+            MESSAGE
+          )
+        end
+      end
+
+      private
+
+      def commands
+        @context.commands
+      end
+    end
+
+    class UnknownSource < Error
+      class_state :messages, default: {
+        default: "unknown source `{association_source}' for association: {source} {association_type} {association_name}"
+      }.freeze
+
+      def contextual_message
+        if sources.any?
+          String.new(
+            <<~MESSAGE
+              The following sources are defined:
+            MESSAGE
+          ).tap do |message|
+            sources.keys.each do |source|
+              message << "  * #{source}\n"
+            end
+          end
+        else
+          String.new(
+            <<~MESSAGE
+              No sources are defined.
+            MESSAGE
+          )
+        end
+      end
+
+      private
+
+      def sources
+        @context.sources
+      end
+    end
+
+    class UnknownSubscriberAdapter < Error
+      class_state :messages, default: {
+        default: "Failed to load subscriber adapter named `{adapter}'"
+      }.freeze
+    end
+  end
+end

data/lib/pakyow/data/framework.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "pakyow/framework"
+
+require "pakyow/data/object"
+require "pakyow/data/helpers"
+
+require "pakyow/data/behavior/config"
+require "pakyow/data/behavior/lookup"
+require "pakyow/data/behavior/serialization"
+
+require "pakyow/data/sources/relational"
+
+module Pakyow
+  module Data
+    class Framework < Pakyow::Framework(:data)
+      def boot
+        object.class_eval do
+          isolate Sources::Relational
+          isolate Object
+
+          stateful :source, isolated(:Relational)
+          stateful :object, isolated(:Object)
+
+          # Autoload sources from the `sources` directory.
+          #
+          aspect :sources
+
+          # Autoload objects from the `objects` directory.
+          #
+          aspect :objects
+
+          register_helper :active, Helpers
+
+          include Behavior::Config
+          include Behavior::Lookup
+          include Behavior::Serialization
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/data/helpers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Data
+    module Helpers
+      def data
+        @connection.app.data
+      end
+    end
+  end
+end

data/lib/pakyow/data/lookup.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "pakyow/data/errors"
+require "pakyow/data/proxy"
+require "pakyow/data/sources/ephemeral"
+
+module Pakyow
+  module Data
+    class Lookup
+      # @api private
+      attr_reader :subscribers, :sources, :containers
+
+      def initialize(containers:, subscribers:, app:)
+        @subscribers = subscribers
+        @subscribers.lookup = self
+        @app = app
+
+        @sources = {}
+        @containers = containers
+        @containers.each do |container|
+          container.sources.each do |source|
+            @sources[source.__object_name.name] = source
+            define_singleton_method source.__object_name.name do
+              Proxy.new(
+                container.source(
+                  source.__object_name.name
+                ),
+
+                @subscribers, @app
+              )
+            end
+          end
+        end
+
+        validate!
+      end
+
+      def ephemeral(type, **qualifications)
+        Proxy.new(
+          Sources::Ephemeral.new(type, **qualifications),
+          @subscribers, @app
+        )
+      end
+
+      def unsubscribe(subscriber)
+        @subscribers.unsubscribe(subscriber)
+      end
+
+      def expire(subscriber, seconds)
+        @subscribers.expire(subscriber, seconds)
+      end
+
+      def persist(subscriber)
+        @subscribers.persist(subscriber)
+      end
+
+      private
+
+      def validate!
+        validate_associated_sources!
+      end
+
+      def validate_associated_sources!
+        @sources.values.each do |source|
+          source.associations.values.flatten.each do |association|
+            association.dependent_source_names.compact.each do |source_name|
+              unless @sources.key?(source_name)
+                raise(
+                  UnknownSource.new_with_message(
+                    source: source.__object_name.name,
+                    association_source: source_name,
+                    association_type: association.specific_type,
+                    association_name: association.name
+                  ).tap do |error|
+                    error.context = self
+                  end
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end