kanji-web 0.1.0

data/lib/kanji/templates/system/project/import.rb.tt

@@ -0,0 +1,5 @@
+require_relative "container"
+
+module <%= config[:camel_cased_app_name] %>
+  Import = <%= config[:camel_cased_app_name] %>::Container.injector
+end

data/lib/kanji/templates/system/project/settings.rb.tt

@@ -0,0 +1,8 @@
+require "dry/web/settings"
+require "kanji/types"
+
+module <%= config[:camel_cased_app_name] %>
+  class Settings < Dry::Web::Settings
+    setting :database_url, Kanji::Types::Strict::String.constrained(filled: true)
+  end
+end

data/lib/kanji/type.rb

@@ -0,0 +1,62 @@
+require "dry-container"
+require "kanji/types"
+require "kanji/type/class_interface"
+require "kanji/errors"
+
+module Kanji
+  class Type
+    extend Dry::Container::Mixin
+    extend ClassInterface
+
+    include Dry::Container::Mixin
+
+    def initialize(params)
+      result = self.class.resolve(:schema).call(params)
+
+      if result.success?
+        register :value, -> { self.class.resolve(:value_object).new(params) }
+      else
+        errors = parse_error_messages(result)
+        raise ValidationError, "Schema validation failed - #{errors}"
+      end
+
+      self.class.instance_variable_get(:@_values).each do |key, value|
+        register key.to_sym, value
+      end
+
+      if repo = self.class.resolve(:repo)
+        register :repo, repo
+      end
+    end
+
+    def to_h
+      resolve(:value).to_h
+    end
+
+    def to_json
+      to_h.to_json
+    end
+
+    def method_missing(method_name, *args, &block)
+      if resolve(:value).respond_to?(method_name)
+        resolve(:value).send(method_name, *args)
+      else
+        super(method_name, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      if resolve(:value).respond_to?(method_name)
+        true
+      else
+        super(method_name, include_private)
+      end
+    end
+
+    private
+
+    def parse_error_messages(result)
+      result.messages(full: true).values.flatten.join(",")
+    end
+  end
+end

data/lib/kanji/type/argument.rb

@@ -0,0 +1,12 @@
+require "dry-struct"
+require "kanji/types"
+
+module Kanji
+  class Type
+    class Argument < Dry::Struct
+      attribute :name, Kanji::Types::String
+      attribute :type, Kanji::Types::Class
+      attribute :options, Kanji::Types::Hash
+    end
+  end
+end

data/lib/kanji/type/attribute.rb

@@ -0,0 +1,14 @@
+require "dry-struct"
+require "kanji/types"
+
+module Kanji
+  class Type
+    class Attribute < Dry::Struct
+      attribute :name, Kanji::Types::String
+      attribute :type, Kanji::Types::Class
+      attribute :description, Kanji::Types::String
+      attribute :options, Kanji::Types::Hash
+      attribute :resolve, Kanji::Types::Callable.optional
+    end
+  end
+end

data/lib/kanji/type/attribute_definer.rb

@@ -0,0 +1,33 @@
+require "kanji/type/attribute"
+require "kanji/instance_define"
+require "kanji/errors"
+
+module Kanji
+  class Type
+    class AttributeDefiner
+      extend Kanji::InstanceDefine
+
+      instance_define :type, :description, :options, :resolve
+
+      def initialize(name, type = nil, description = nil, **kwargs, &block)
+        @_name = name
+        @_type = type
+        @_description = description
+        @_options = kwargs
+        self.instance_eval &block if block_given?
+
+        raise AttributeError unless @_type
+      end
+
+      def call
+        Attribute.new({
+          name: @_name,
+          type: @_type,
+          description: @_description,
+          options: @_options,
+          resolve: @_resolve
+        })
+      end
+    end
+  end
+end

data/lib/kanji/type/class_interface.rb

@@ -0,0 +1,156 @@
+require "dry-validation"
+require "graphql"
+require "dry/core/class_builder"
+require "dry/core/constants"
+require "dry/core/inflector"
+require "kanji/type/attribute"
+require "kanji/graph/register_object"
+require "kanji/graph/register_mutation"
+require "kanji/type/attribute_definer"
+
+module Kanji
+  class Type
+    module ClassInterface
+      include Dry::Core::Constants
+
+      attr_reader :_attributes, :_name, :_description, :_repo_name,
+        :_associations
+
+      def graphql_type(klass)
+        Kanji::Graph::RegisterObject.new(
+          attributes: klass._attributes + klass._associations,
+          name: klass._name,
+          description: klass._description
+        ).call
+      end
+
+      def inherited(klass)
+        super
+
+        klass.instance_variable_set(:@_attributes, [])
+        klass.instance_variable_set(:@_values, {})
+        klass.instance_variable_set(:@_associations, [])
+
+        klass.attribute(:id, Kanji::Types::Int, "The primary key")
+
+        TracePoint.trace(:end) do |t|
+          if klass == t.self
+            self.finalize(klass)
+            t.disable
+          end
+        end
+      end
+
+      def finalize(klass)
+        klass.register :graphql_type, graphql_type(klass)
+        klass.register :schema, -> { klass.register_schema }
+        klass.register :value_object, -> { klass.create_value_object }
+        klass.instance_variable_set(:@_repo_name, get_repo_name(klass))
+      end
+
+      def get_repo_name(klass)
+        name = Dry::Core::Inflector.underscore(klass._name)
+        Dry::Core::Inflector.pluralize(name).to_sym
+      end
+
+      def name(name)
+        @_name = name
+      end
+
+      def description(description)
+        @_description = description
+      end
+
+      def attribute(name, type = nil, description = nil, **kwargs, &block)
+        if @_attributes.map(&:name).include?(name)
+          fail AttributeError, "Attribute #{name} is already defined"
+        else
+          @_attributes <<
+            AttributeDefiner.new(name, type, description, kwargs, &block).call
+        end
+      end
+
+      def assoc(name, type = nil, description = nil, **kwargs, &block)
+        if @_associations.map(&:name).include?(name)
+          fail AttributeError, "Association #{name} is already defined"
+        else
+          @_associations <<
+          AttributeDefiner.new(name, type, description, kwargs, &block).call
+        end
+      end
+
+      def demodulized_type_name
+        @_demodulized_type_name ||= Dry::Core::Inflector.demodulize(self.to_s)
+      end
+
+      def create(&block)
+        register :create_mutation do
+          Kanji::Graph::RegisterMutation.new(
+            return_type: resolve(:graphql_type),
+            attributes: @_attributes.reject { |attr| attr.name == :id },
+            name: "Create#{demodulized_type_name}Mutation",
+            description: "Create a new #{demodulized_type_name}.",
+            resolve: block
+          ).call
+        end
+      end
+
+      def update(&block)
+        register :update_mutation do
+          Kanji::Graph::RegisterMutation.new(
+            return_type: resolve(:graphql_type),
+            attributes: @_attributes,
+            name: "Update#{demodulized_type_name}Mutation",
+            description: "Update an instance of #{demodulized_type_name}.",
+            resolve: block
+          ).call
+        end
+      end
+
+      def destroy(&block)
+        register :destroy_mutation do
+          Kanji::Graph::RegisterMutation.new(
+            return_type: resolve(:graphql_type),
+            attributes: [@_attributes.find { |attr| attr.name == :id }],
+            name: "Destroy#{demodulized_type_name}Mutation",
+            description: "Destroy a #{demodulized_type_name}.",
+            resolve: block
+          ).call
+        end
+      end
+
+      def register_schema
+        attributes = _attributes
+
+        Dry::Validation.JSON do
+          configure { config.type_specs = true }
+
+          attributes.each do |attribute|
+            if attribute.options[:required]
+              required(attribute.name, attribute.type).filled
+            else
+              optional(attribute.name, attribute.type).maybe
+            end
+          end
+        end
+      end
+
+      def create_value_object
+        builder = Dry::Core::ClassBuilder.new(
+          name: "#{instance_variable_get(:@_name)}Value",
+          parent: Dry::Struct::Value
+        )
+        klass = builder.call
+
+        klass.constructor_type(:schema)
+
+        instance_variable_get(:@_attributes).each do |attribute|
+          klass.attribute(attribute.name, attribute.type)
+        end
+
+        klass
+      end
+    end
+  end
+end
+

data/lib/kanji/type/mutation.rb

@@ -0,0 +1,13 @@
+require "dry-struct"
+require "kanji/types"
+
+module Kanji
+  class Type
+    class Mutation < Dry::Struct::Value
+      attribute :name, Kanji::Types::String
+      attribute :return_type, Kanji::Types::Class
+      attribute :arguments, Kanji::Types::Strict::Array.member(Kanji::Type::Argument)
+      attribute :resolve, Kanji::Types::Class
+    end
+  end
+end

data/lib/kanji/type/mutation_definer.rb

@@ -0,0 +1,43 @@
+require "kanji/instance_define"
+require "kanji/errors"
+require "kanji/type/mutation"
+require "kanji/type/argument"
+
+module Kanji
+  class Type
+    class MutationDefiner
+      extend Kanji::InstanceDefine
+
+      instance_define :name, :return_type, :resolve
+
+      def initialize(&block)
+        @_arguments = []
+        self.instance_eval &block
+
+        raise(AttributeError, "You must supply a name") unless @_name
+        raise(AttributeError, "You must supply a return type") unless @_return_type
+        raise(AttributeError, "You must supply a resolve proc") unless @_resolve
+        raise(AttributeError, "You must supply at least one argument") if @_arguments.empty?
+      end
+
+      def argument(name, type, **kwargs)
+        raise ArgumentError if @_arguments.map(&:name).include?(name.to_s)
+
+        @_arguments << Argument.new({
+          name: name.to_s,
+          type: type,
+          options: kwargs
+        })
+      end
+
+      def call
+        Mutation.new({
+          name: @_name,
+          return_type: @_return_type,
+          arguments: @_arguments,
+          resolve: @_resolve
+        })
+      end
+    end
+  end
+end

data/lib/kanji/types.rb

@@ -0,0 +1,11 @@
+require "dry-types"
+require_relative "./types/callable"
+
+module Kanji
+  module Types
+    include Dry::Types.module
+
+    ID = String | Integer
+    Email = String.constrained(format: /.+\@.+\..+/)
+  end
+end

data/lib/kanji/types/callable.rb

@@ -0,0 +1,30 @@
+require "dry-types"
+require_relative "./type_interface"
+
+module Kanji
+  module Types
+    class Callable
+      extend TypeInterface
+
+      class << self
+        def call(obj)
+          raise constraint_error(obj) unless valid?(obj)
+          obj
+        end
+
+        def valid?(obj)
+          obj.respond_to?(:call)
+        end
+
+        private
+
+        def constraint_error(obj)
+          Dry::Types::ConstraintError.new(
+            "Object must respond to the call method",
+            obj
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kanji/types/type_interface.rb

@@ -0,0 +1,43 @@
+require "dry-types"
+
+module Kanji
+  module Types
+    module TypeInterface
+      def try(obj, &block)
+        result = valid?(obj) ? success(obj) : failure(obj, constraint_error(obj))
+
+        return result if result.success?
+
+        if block
+          yield(result)
+        else
+          result
+        end
+      end
+
+      def success(obj)
+        Dry::Types::Result::Success.new(obj)
+      end
+
+      def failure(obj, error)
+        Dry::Types::Result::Failure.new(obj, error)
+      end
+
+      def |(other)
+        Dry::Types::Sum::Constrained.new(self, other)
+      end
+
+      def optional
+        Dry::Types::Sum.new(Kanji::Types::Nil, self)
+      end
+
+      def constrained?
+        true
+      end
+
+      def valid?
+        raise NotImplementedError, "You must implement the valid? method"
+      end
+    end
+  end
+end