stardust_rails 0.1.1

data/lib/stardust/graphql/collector.rb

@@ -0,0 +1,161 @@
+module Stardust
+  module GraphQL
+    module Collector
+      module_function
+
+      FIXED_TYPES = {
+        id: ::GraphQL::Types::ID,
+        int: Integer,
+        integer: Integer,
+        float: Float,
+        string: String,
+        date: ::GraphQL::Types::ISO8601DateTime,
+        datetime: ::GraphQL::Types::ISO8601DateTime,
+        boolean: ::GraphQL::Types::Boolean,
+      }.freeze
+
+
+      @@__types__ = {}.merge(FIXED_TYPES)
+      @@__defined_types__ = []
+      @@__queries__ = {}
+      @@__mutations__ = {}
+
+      def add_type(type, block, object_klass)
+        if type.in?(@@__types__.keys)
+          raise "Type #{type.to_s} is alread defined."
+        end
+
+        @@__defined_types__ << type.to_s.camelize
+
+        klass = Class.new(object_klass, &block)
+
+        begin
+          klass.graphql_name
+        rescue NotImplementedError
+          klass.graphql_name(type.to_s.camelize)
+        end
+        
+        ::Stardust::GraphQL::Types.const_set("#{type.to_s.camelize}", klass)
+        @@__types__[type] = "Stardust::GraphQL::Types::#{type.to_s.camelize}".constantize
+      end
+
+      def self.clear_definitions!
+        @@__defined_types__ = []
+        @@__types__ = {}.merge(FIXED_TYPES)
+        @@__queries__ = {}
+        @@__mutations__ = {}
+
+        ::Stardust::GraphQL.send(:remove_const, "Types")
+        ::Stardust::GraphQL.send(:remove_const, "Schema")
+        load 'stardust/graphql/types'
+        load 'stardust/graphql/schema'
+      end
+
+      def add_query(name, query:)
+        if name.in?(@@__queries__.keys)
+          raise "Query #{name.to_s} is already defined."
+        end
+        @@__queries__[name] = query
+      end
+
+      def add_mutation(name, mutation:)
+        if name.in?(@@__queries__.keys)
+          raise "Mutation #{name.to_s} is already defined."
+        end
+        @@__mutations__[name] = mutation
+      end
+
+      def self.types
+        @@__types__
+      end
+
+      def self.queries
+        @@__queries__
+      end
+
+      def self.lookup_type(type)
+        if type.is_a?(Array)
+          type = type.first
+          is_a_array = true
+        end
+
+        raise MissingType, type.to_s unless @@__types__[type]
+
+        if is_a_array
+          [@@__types__[type]]
+        else
+          @@__types__[type]
+        end
+      end
+
+      def self.replace_types!
+        @@__types__.values.each do |klass|
+          begin
+            klass.replace_types! if klass.respond_to?(:replace_types!)
+          rescue MissingType => e
+            warn <<~TEXT
+
+              Stardust Compilation Error
+              Type #{e.message} is not defined.
+
+            TEXT
+          end
+        end
+
+        query_class = Class.new(::Stardust::GraphQL::Object)
+        query_class.graphql_name("QueryRoot")
+        @@__queries__.each do |name, query|
+
+          block = ->(field) {
+
+            query.get_arguments.each do |name, type, description, kwargs, block|
+              field.argument(name, type, description, **kwargs, &block)
+            end
+
+            field.instance_variable_set(:@resolver_class, query)
+            field.instance_variable_set(:@resolver_method, :resolve)
+            field.extension(Extensions::Authorize)
+          }
+
+          query_class.send(:field,
+            name,
+            query.get_type,
+            query.get_description,
+            null: query.get_null,
+            &block
+          )
+        end
+
+        begin
+          query_class.replace_types!
+        rescue MissingType => e
+          warn <<~TEXT
+
+            Stardust Compilation Error
+            Type #{e.message} is not defined.
+
+          TEXT
+        end
+        Schema.query(query_class)
+
+
+        mutation_class = Class.new(::GraphQL::Schema::Object)
+        mutation_class.graphql_name("MutationRoot")
+        @@__mutations__.each do |name, mutation|
+          begin
+            mutation.replace_types!
+            mutation_class.send(:field, name, mutation: mutation )
+          rescue MissingType => e
+            warn <<~TEXT
+
+              Stardust Compilation Error
+              Type #{e.message} is not defined.
+
+            TEXT
+          end
+        end
+        Schema.mutation(mutation_class)
+      end
+    end
+  end
+end

data/lib/stardust/graphql/configuration.rb

@@ -0,0 +1,23 @@
+module Stardust
+  module GraphQL
+    class Configuration
+
+      def setup_context(&block)
+        if block_given?
+          @setup_context = block
+        else
+          @setup_context
+        end
+      end
+
+      def around_execute(&block)
+        if block_given?
+          @around_execute = block
+        else
+          @around_execute
+        end
+      end
+
+    end
+  end
+end

data/lib/stardust/graphql/dsl.rb

@@ -0,0 +1,45 @@
+module Stardust
+  module GraphQL
+    module DSL
+
+      class MissingType < StandardError; end;
+
+      def define_types(&block)
+        klass = Class.new(Types::DSL)
+        klass.class_eval(&block)
+      end
+
+      def define_query(name, &block)
+        klass = Class.new(Query)
+        klass.class_eval(&block)
+        if !klass.get_type
+          warn <<~TEXT
+
+            Stardust Compilation Error
+            Missing type definition for query in "#{name}".
+            File: "#{calling_file}"
+
+              ## Define the return type of the query
+              type :my_type
+
+          TEXT
+        else
+          Collector.add_query(name, query: klass)
+        end
+      end
+
+      def define_mutation(name, &block)
+        klass = Class.new(Mutation)
+        klass.send(:graphql_name, name.to_s.camelize)
+        klass.class_eval(&block)
+        Collector.add_mutation(name, mutation: klass)
+      end
+
+      def calling_file
+        caller[1][/[^:]+/]
+        .gsub(Rails.root.to_s, "")[1..-1]
+      end
+
+    end
+  end
+end

data/lib/stardust/graphql/extensions/authorize.rb

@@ -0,0 +1,22 @@
+module Stardust
+  module GraphQL
+    module Extensions
+      class Authorize < ::GraphQL::Schema::FieldExtension
+
+        def after_resolve(object:, arguments:, context:, value:, memo:)
+         klass = field.instance_variable_get(:@resolver_class)
+         instance = klass.new(object: object, context: context)
+
+         if instance.respond_to?(:authorized?)
+           unless instance.authorized?(value: value, context: context, arguments: arguments)
+             raise ::GraphQL::ExecutionError, "Not authorized to access"
+           end
+         end
+         
+         value
+       end
+
+      end
+    end
+  end
+end

data/lib/stardust/graphql/field.rb

@@ -0,0 +1,38 @@
+module Stardust
+  module GraphQL
+    class Field < ::GraphQL::Schema::Field
+
+      def initialize(*args, **kwargs, &block)
+        super(*args, **kwargs, &block)
+      end
+
+      def authorize(proc, &block)
+        @authorize = block_given? ? block : proc
+      end
+
+      def authorized?(obj, ctx)
+        if @authorize.respond_to?(:call)
+          unless @authorize.(obj, ctx)
+            raise ::GraphQL::ExecutionError, "Not authorized"
+          end
+        else
+          super(obj, ctx)
+        end
+      end
+
+      def resolve(&block)
+        @resolve = block
+      end
+
+      def argument(name, type, description = nil, loads: nil, **kwargs)
+        actual_type = Collector.lookup_type(type)
+        if loads
+          kwargs[:prepare] = ->(obj, ctx) { loads.find(obj) }
+        end
+
+        super(name, actual_type, description, **kwargs)
+      end
+
+    end
+  end
+end

data/lib/stardust/graphql/input_object.rb

@@ -0,0 +1,24 @@
+module Stardust
+  module GraphQL
+    class InputObject < ::GraphQL::Schema::InputObject
+
+      def self.argument(name, type, description = nil, **kwargs, &block)
+
+        @__types_to_lookup__ ||= []
+        @__types_to_lookup__ << ->(klass) {
+          actual_type = Collector.lookup_type(type)
+
+          klass
+          .method(:argument)
+          .super_method
+          .call(name, actual_type, description, **kwargs, &block)
+
+        }
+      end
+
+      def self.replace_types!
+        @__types_to_lookup__.each {|lookup| lookup.(self)}
+      end
+    end
+  end
+end

data/lib/stardust/graphql/mutation.rb

@@ -0,0 +1,61 @@
+module Stardust
+  module GraphQL
+    class Mutation < ::GraphQL::Schema::Mutation
+
+      def current_user
+        context[:current_user]
+      end
+
+      def self.argument(name, type, description = nil, loads: nil, **kwargs)
+        @__types_to_lookup__ ||= []
+        the_file = caller[0][/[^:]+/].gsub(Rails.root.to_s, "")
+        the_line = caller[0].split(":")[1]
+        @__types_to_lookup__ << lambda { |klass|
+          begin
+            actual_type = Collector.lookup_type(type)
+
+            kwargs[:prepare] = ->(obj, _ctx) { loads.find(obj) } if loads
+
+            klass.method(:argument)
+                 .super_method
+                 .call(name, actual_type, description, **kwargs)
+          rescue MissingType => e
+            warn <<~TEXT
+
+              Stardust Compilation Warning
+                - MESSAGE: Type #{e.message} is not defined.
+                - RESULT:  This mutation is not added to the graph.
+                - FILE:    #{the_file}
+                - LINE:    #{the_line}
+
+            TEXT
+          end
+        }
+      end
+
+      def self.field(name, type, description = nil, **kwargs)
+        @__types_to_lookup__ ||= []
+        @__types_to_lookup__ << lambda { |klass|
+          actual_type = Collector.lookup_type(type)
+
+          klass.method(:field)
+               .super_method
+               .call(name, actual_type, description, **kwargs)
+        }
+      end
+
+      def self.replace_types!
+        return unless @__types_to_lookup__
+        @__types_to_lookup__.each { |lookup| lookup.call(self) }
+      end
+
+      def self.resolve_method
+        :resolve_wrapper
+      end
+
+      def resolve_wrapper(**kwargs)
+        resolve(**kwargs)
+      end
+    end
+  end
+end

data/lib/stardust/graphql/object.rb

@@ -0,0 +1,30 @@
+module Stardust
+  module GraphQL
+    class Object < ::GraphQL::Schema::Object
+
+      field_class Field
+
+      def self.field(name, type, description = nil, **kwargs, &block)
+
+        @__types_to_lookup__ ||= []
+        @__types_to_lookup__ << ->(klass) {
+          actual_type = Collector.lookup_type(type)
+
+          klass
+          .method(:field)
+          .super_method
+          .call(name, actual_type, description, **kwargs, &block)
+        }
+      end
+
+      def self.replace_types!
+        return unless @__types_to_lookup__
+        @__types_to_lookup__.each {|lookup| lookup.(self)}
+      end
+
+      def current_user
+        context[:current_user]
+      end
+    end
+  end
+end

data/lib/stardust/graphql/query.rb

@@ -0,0 +1,62 @@
+module Stardust
+  module GraphQL
+    class Query
+      attr_reader :context
+
+      def initialize(object:, context:)
+        @context = context
+      end
+
+      def current_user
+        context[:current_user]
+      end
+
+      def self.authorized?(object, context)
+        true
+      end
+
+      def self.accessible?(context)
+        true
+      end
+
+      def self.visible?(context)
+        true
+      end
+
+      class << self
+        def type(type)
+          @__type__ = type
+        end
+
+        def null(null)
+          @__null__ = null
+        end
+
+        def description(description)
+          @__description__ = description
+        end
+
+        def argument(name, type, description = nil, **kwargs, &block)
+          @__arguments__ ||= []
+          @__arguments__ << [name, type, description, kwargs, block]
+        end
+
+        def get_type
+          @__type__
+        end
+
+        def get_null
+          @__null__
+        end
+
+        def get_description
+          @__description__
+        end
+
+        def get_arguments
+          @__arguments__ || []
+        end
+      end
+    end
+  end
+end

data/lib/stardust/graphql/scalar.rb

@@ -0,0 +1,23 @@
+module Stardust
+  module GraphQL
+    class Scalar < GraphQL::Schema::Scalar
+
+      def self.coerce_input(input_value = nil, context = nil, &block)
+        if block_given?
+          @@__coerce_input_block__ = block
+        else
+          @@__coerce_input_block__.(input_value, context)
+        end
+      end
+
+      def self.coerce_result(ruby_value = nil, context = nil, &block)
+        if block_given?
+          @@__coerce_result_block__ = block
+        else
+          @@__coerce_result_block__.(ruby_value, context)
+        end
+      end
+
+    end
+  end
+end

data/lib/stardust/graphql/schema.rb

@@ -0,0 +1,8 @@
+
+module Stardust
+  module GraphQL
+    class Schema < ::GraphQL::Schema
+      use ::GraphQL::Batch
+    end
+  end
+end

data/lib/stardust/graphql/types/dsl.rb

@@ -0,0 +1,27 @@
+module Stardust
+  module GraphQL
+    module Types
+      class DSL
+
+        class << self
+          def object(type, &block)
+            Collector.add_type( type, block, Object)
+          end
+
+          def input_object(type, &block)
+            Collector.add_type( type, block, InputObject )
+          end
+
+          def scalar(type, &block)
+            Collector.add_type( type, block, Scalar )
+          end
+
+          def union(type, &block)
+            Collector.add_type( type, block, Union )
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/stardust/graphql/types.rb

@@ -0,0 +1,10 @@
+module Stardust
+  module GraphQL
+    module Types
+
+      def self.types
+        Collector.types
+      end
+    end
+  end
+end

data/lib/stardust/graphql/union.rb

@@ -0,0 +1,27 @@
+module Stardust
+  module GraphQL
+    class Union < GraphQL::Schema::Union
+
+
+      def self.possible_type(type, klass)
+        @__possible_types__ ||= {}
+        @__possible_types__[type] = klass
+      end
+
+      def self.replace_types!
+        return unless @__possible_types__
+        @__possible_types__ = @__possible_types__.reduce({}) do |accu, (type, klass)|
+          lu_type = Collector.lookup_type(type)
+          accu[lu_type] = klass
+          accu
+        end
+        self.send(:possible_types, *@__possible_types__.keys)
+      end
+
+      def self.resolve_type(obj, ctx)
+        @__possible_types__.invert[obj.class]
+      end
+
+    end
+  end
+end

data/lib/stardust/graphql.rb

@@ -0,0 +1,25 @@
+require "graphql"
+require "graphiql/rails"
+require "graphql/rails_logger"
+require "graphql/batch"
+
+require "stardust/graphql/types"
+require "stardust/graphql/schema"
+
+require "stardust/graphql/dsl"
+require "stardust/graphql/types/dsl"
+
+module Stardust
+  module GraphQL
+    extend DSL
+
+    class MissingType < StandardError; end
+  end
+end
+
+require "stardust/graphql/field"
+require "stardust/graphql/object"
+require "stardust/graphql/union"
+require "stardust/graphql/scalar"
+require "stardust/graphql/collector"
+require "stardust/graphql/input_object"

data/lib/stardust/instance.rb

@@ -0,0 +1,25 @@
+module Stardust
+  module Instance
+
+    def instance
+      if Rails.env == 'production'
+        ENV['INSTANCE'].to_sym || :production
+      else
+        Rails.env.to_sym
+      end
+    end
+    
+    def production?
+      instance == :production
+    end
+
+    def staging?
+      instance == :staging
+    end
+
+    def development?
+      instance == :development
+    end
+
+  end
+end

data/lib/stardust/version.rb

@@ -0,0 +1,3 @@
+module Stardust
+  VERSION = '0.1.1'
+end

data/lib/stardust.rb

@@ -0,0 +1,26 @@
+require "rails"
+require "stardust/engine"
+require "stardust/instance"
+require "stardust/configuration"
+
+# this allows us to
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym "GraphQL"
+  inflect.acronym "DSL"
+end
+
+module Stardust
+  extend Instance
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+end
+
+require "stardust/graphql"
+require "stardust/generators"

data/lib/tasks/stardust_tasks.rake

@@ -0,0 +1,13 @@
+# desc "Explaining what the task does"
+# task :stardust do
+#   # Task goes here
+# end
+
+
+
+namespace :stardust do
+
+  task :install do
+    
+  end
+end