desiru 0.1.0 → 0.1.1

data/lib/desiru/graphql/batch_loader.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+module Desiru
+  module GraphQL
+    # GraphQL-compatible batch loader that integrates with GraphQL's lazy execution
+    class BatchLoader < ::GraphQL::Dataloader::Source
+      def initialize(module_instance)
+        super()
+        @module_instance = module_instance
+      end
+
+      # Fetch implementation for GraphQL::Dataloader
+      def fetch(inputs_array)
+        if @module_instance.respond_to?(:batch_forward)
+          # Use batch processing if available
+          @module_instance.batch_forward(inputs_array)
+        else
+          # Fall back to individual processing
+          inputs_array.map { |inputs| @module_instance.call(inputs) }
+        end
+      end
+    end
+
+    # Module loader that provides batch loading for Desiru modules
+    class ModuleLoader < ::GraphQL::Dataloader::Source
+      def initialize(operation_name, modules)
+        super()
+        @operation_name = operation_name
+        @modules = modules
+      end
+
+      def fetch(args_array)
+        module_instance = @modules[@operation_name.to_s] || @modules[@operation_name.to_sym]
+
+        raise "Module not found for operation: #{@operation_name}" unless module_instance
+
+        # Transform GraphQL arguments to snake_case
+        transformed_args = args_array.map { |args| transform_graphql_args(args) }
+
+        results = if module_instance.respond_to?(:batch_forward)
+                    # Batch process all requests
+                    module_instance.batch_forward(transformed_args)
+                  else
+                    # Fall back to individual processing
+                    transformed_args.map { |args| module_instance.call(args) }
+                  end
+
+        # Transform results back to camelCase
+        results.map { |result| transform_module_result(result) }
+      end
+
+      private
+
+      def transform_graphql_args(args)
+        # Convert camelCase keys to snake_case
+        args.transform_keys do |key|
+          key_str = key.to_s
+          if key_str =~ /[a-z][A-Z]/
+            key_str.gsub(/([A-Z])/, '_\1').downcase.to_sym
+          else
+            key_str.downcase.to_sym
+          end
+        end
+      end
+
+      def transform_module_result(result)
+        # Convert ModuleResult to hash with camelCase keys
+        if result.respond_to?(:to_h)
+          result.to_h.transform_keys { |key| camelcase_field_name(key) }
+        else
+          result
+        end
+      end
+
+      def camelcase_field_name(field_name)
+        # Convert snake_case to camelCase
+        clean_name = field_name.to_s.gsub('?', '')
+        parts = clean_name.split('_')
+        parts[0] + parts[1..].map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/desiru/graphql/data_loader.rb

@@ -9,35 +9,38 @@ module Desiru
         @loaders = {}
         @results_cache = {}
         @pending_loads = Hash.new { |h, k| h[k] = [] }
+        @pending_promises = Hash.new { |h, k| h[k] = {} }
+        @mutex = Mutex.new
       end
 
       # Get or create a loader for a specific module
-      def for(module_class, **options)
+      def for(module_class_or_instance, **options)
+        # Handle both module classes and instances
+        module_class = module_class_or_instance.is_a?(Class) ? module_class_or_instance : module_class_or_instance.class
         key = loader_key(module_class, options)
-        @loaders[key] ||= BatchLoader.new(module_class, **options)
+        @loaders[key] ||= BatchLoader.new(module_class_or_instance, self, **options)
       end
 
       # Execute all pending loads in batch
       def perform_loads
-        @pending_loads.each do |loader_key, batch|
-          next if batch.empty?
-
-          loader = @loaders[loader_key]
-          results = loader.load_batch(batch.map(&:first))
-
-          batch.each_with_index do |(_inputs, promise), idx|
-            promise.fulfill(results[idx])
+        @mutex.synchronize do
+          @pending_loads.each do |loader_key, batch|
+            process_loader_batch(loader_key, batch)
           end
-        end
 
-        @pending_loads.clear
+          @pending_loads.clear
+          @pending_promises.clear
+        end
       end
 
       # Clear all caches
       def clear!
-        @results_cache.clear
-        @pending_loads.clear
-        @loaders.values.each(&:clear_cache!)
+        @mutex.synchronize do
+          @results_cache.clear
+          @pending_loads.clear
+          @pending_promises.clear
+          @loaders.each_value(&:clear_cache!)
+        end
       end
 
       private
@@ -46,48 +49,115 @@ module Desiru
         "#{module_class.name}:#{options.hash}"
       end
 
+      def group_inputs_by_signature(inputs_array)
+        inputs_array.group_by do |inputs|
+          # Group by input keys to process similar queries together
+          inputs.keys.sort.join(':')
+        end
+      end
+
+      def process_loader_batch(loader_key, batch)
+        return if batch.empty?
+
+        loader = @loaders[loader_key]
+        return unless loader # Skip if loader not found
+
+        # Deduplicate requests
+        unique_inputs_map, promises_by_inputs = deduplicate_batch(batch)
+        unique_inputs = unique_inputs_map.values
+
+        # Process batch and handle results
+        results_map = execute_batch(loader, unique_inputs, unique_inputs_map)
+
+        # Fulfill promises with results
+        fulfill_promises(promises_by_inputs, results_map)
+      end
+
+      def deduplicate_batch(batch)
+        unique_inputs_map = {}
+        promises_by_inputs = Hash.new { |h, k| h[k] = [] }
+
+        batch.each do |inputs, promise|
+          input_key = inputs.sort.to_h.hash
+          unique_inputs_map[input_key] = inputs
+          promises_by_inputs[input_key] << promise
+        end
+
+        [unique_inputs_map, promises_by_inputs]
+      end
+
+      def execute_batch(loader, unique_inputs, unique_inputs_map)
+        results_map = {}
+
+        begin
+          results = loader.load_batch(unique_inputs)
+          unique_inputs.each_with_index do |inputs, idx|
+            input_key = inputs.sort.to_h.hash
+            results_map[input_key] = results[idx]
+          end
+        rescue StandardError => e
+          # Mark all promises as rejected on error
+          unique_inputs_map.each_key do |input_key|
+            results_map[input_key] = { error: e }
+          end
+        end
+
+        results_map
+      end
+
+      def fulfill_promises(promises_by_inputs, results_map)
+        promises_by_inputs.each do |input_key, promises|
+          result = results_map[input_key]
+
+          promises.each do |promise|
+            if result.is_a?(Hash) && result[:error]
+              promise.reject(result[:error])
+            else
+              promise.fulfill(result)
+            end
+          end
+        end
+      end
+
       # Individual batch loader for a specific module
       class BatchLoader
-        attr_reader :module_class, :batch_size, :cache
+        attr_reader :module_class_or_instance, :batch_size, :cache, :parent_loader
 
-        def initialize(module_class, batch_size: 100, cache: true)
-          @module_class = module_class
+        def initialize(module_class_or_instance, parent_loader, batch_size: 100, cache: true)
+          @module_class_or_instance = module_class_or_instance
+          @parent_loader = parent_loader
           @batch_size = batch_size
           @cache = cache
           @cache_store = {} if cache
         end
 
-        # Load a batch of inputs
+        # Load a batch of inputs - used for immediate batch processing
         def load_batch(inputs_array)
           return load_from_cache(inputs_array) if cache && all_cached?(inputs_array)
 
-          # Group inputs by signature to optimize processing
-          grouped = group_by_signature(inputs_array)
-          results = []
+          results = process_batch(inputs_array)
 
-          grouped.each do |_signature_key, inputs_group|
-            module_instance = create_module_instance(inputs_group.first)
-
-            # Process in chunks to respect batch_size
-            inputs_group.each_slice(batch_size) do |chunk|
-              chunk_results = process_chunk(module_instance, chunk)
-              results.concat(chunk_results)
-
-              # Cache results if enabled
-              cache_results(chunk, chunk_results) if cache
-            end
-          end
+          # Cache results if enabled
+          cache_results(inputs_array, results) if cache
 
           results
         end
 
         # Load a single input (returns a promise for lazy evaluation)
         def load(inputs)
-          Promise.new do |promise|
-            if cache && @cache_store.key?(cache_key(inputs))
-              promise.fulfill(@cache_store[cache_key(inputs)])
-            else
-              # Queue for batch loading
+          # Check cache first if enabled
+          if cache && @cache_store.key?(cache_key(inputs))
+            # Return immediately fulfilled promise for cached value
+            promise = Promise.new
+            promise.fulfill(@cache_store[cache_key(inputs)])
+            promise
+          else
+            # Check for existing pending promise to enable deduplication
+            existing_promise = check_pending_promise(inputs)
+            return existing_promise if existing_promise
+
+            # Create promise and queue for batch loading
+            Promise.new do |promise|
               queue_for_loading(inputs, promise)
             end
           end
@@ -97,6 +167,29 @@ module Desiru
           @cache_store.clear if cache
         end
 
+        # Process a batch of inputs
+        def process_batch(inputs_array)
+          # Use the provided module instance or create one
+          module_instance = if @module_class_or_instance.is_a?(Class)
+                              create_module_instance(inputs_array.first)
+                            else
+                              @module_class_or_instance
+                            end
+
+          if module_instance.respond_to?(:batch_forward)
+            # If module supports batch processing
+            module_instance.batch_forward(inputs_array)
+          else
+            # Fall back to individual processing
+            inputs_array.map { |inputs| module_instance.call(inputs) }
+          end
+        end
+
+        # Cache a single result
+        def cache_result(inputs, result)
+          @cache_store[cache_key(inputs)] = result if cache
+        end
+
         private
 
         def all_cached?(inputs_array)
@@ -117,17 +210,17 @@ module Desiru
           inputs.sort.to_h.hash
         end
 
-        def group_by_signature(inputs_array)
-          inputs_array.group_by do |inputs|
-            # Group by input keys to process similar queries together
-            inputs.keys.sort.join(':')
-          end
-        end
-
         def create_module_instance(sample_inputs)
           # Infer signature from inputs
           signature = infer_signature(sample_inputs)
-          module_class.new(signature)
+
+          # Get the module class
+          if @module_class_or_instance.is_a?(Class)
+            @module_class_or_instance.new(signature)
+          else
+            # Already an instance, return it
+            @module_class_or_instance
+          end
         end
 
         def infer_signature(inputs)
@@ -145,64 +238,138 @@ module Desiru
           when TrueClass, FalseClass then 'bool'
           when Array then 'list'
           when Hash then 'hash'
-          else 'string'
+          else value.class.name.downcase
           end
         end
 
-        def process_chunk(module_instance, chunk)
-          if module_instance.respond_to?(:batch_forward)
-            # If module supports batch processing
-            module_instance.batch_forward(chunk)
-          else
-            # Fall back to individual processing
-            chunk.map { |inputs| module_instance.call(inputs) }
+        def check_pending_promise(inputs)
+          # Check if there's already a pending promise for these inputs
+          final_key = loader_key
+          input_key = inputs.sort.to_h.hash
+
+          parent_loader.instance_variable_get(:@mutex).synchronize do
+            parent_loader.instance_variable_get(:@pending_promises)[final_key][input_key]
           end
         end
 
         def queue_for_loading(inputs, promise)
-          # This would integrate with the parent DataLoader's pending loads
-          # For now, process immediately
-          result = module_class.new(infer_signature(inputs)).call(inputs)
-          promise.fulfill(result)
-          @cache_store[cache_key(inputs)] = result if cache
+          # Queue the request with the parent DataLoader for batch processing
+          final_key = loader_key
+          input_key = inputs.sort.to_h.hash
+
+          parent_loader.instance_variable_get(:@mutex).synchronize do
+            # Store this promise for future deduplication
+            parent_loader.instance_variable_get(:@pending_promises)[final_key][input_key] = promise
+            parent_loader.instance_variable_get(:@pending_loads)[final_key] << [inputs, promise]
+          end
+        end
+
+        def loader_key
+          # Create a key that matches how this loader was registered
+          module_name = if @module_class_or_instance.is_a?(Class)
+                          @module_class_or_instance.name
+                        else
+                          @module_class_or_instance.class.name
+                        end
+          loader_key = "#{module_name}:#{batch_size}:#{cache}"
+
+          # Find the actual loader key that was used to create this loader
+          loaders = parent_loader.instance_variable_get(:@loaders)
+          actual_key = loaders.keys.find { |k| loaders[k] == self }
+          actual_key || loader_key
         end
       end
 
-      # Promise implementation for lazy loading
+      # Thread-safe Promise implementation for lazy loading
       class Promise
         def initialize(&block)
+          @mutex = Mutex.new
+          @condition = ConditionVariable.new
           @fulfilled = false
           @value = nil
+          @error = nil
           @callbacks = []
-          block.call(self) if block
+          block&.call(self)
         end
 
         def fulfill(value)
-          return if @fulfilled
+          callbacks_to_run = nil
+
+          @mutex.synchronize do
+            return if @fulfilled
+
+            @value = value
+            @fulfilled = true
+            callbacks_to_run = @callbacks.dup
+            @callbacks.clear
 
-          @value = value
-          @fulfilled = true
-          @callbacks.each { |cb| cb.call(value) }
-          @callbacks.clear
+            # Signal all waiting threads
+            @condition.broadcast
+          end
+
+          # Run callbacks outside the mutex to avoid deadlock
+          callbacks_to_run&.each { |cb| cb.call(value) }
+        end
+
+        def reject(error)
+          @mutex.synchronize do
+            return if @fulfilled
+
+            @error = error
+            @fulfilled = true
+            @callbacks.clear
+
+            # Signal all waiting threads
+            @condition.broadcast
+          end
         end
 
         def then(&block)
-          if @fulfilled
-            block.call(@value)
-          else
-            @callbacks << block
+          run_immediately = false
+          value_to_pass = nil
+
+          @mutex.synchronize do
+            if @fulfilled && !@error
+              run_immediately = true
+              value_to_pass = @value
+            elsif !@fulfilled
+              @callbacks << block
+            end
           end
+
+          # Run callback outside mutex if already fulfilled
+          block.call(value_to_pass) if run_immediately
+
           self
         end
 
-        def value
-          raise "Promise not yet fulfilled" unless @fulfilled
+        def value(timeout: nil)
+          @mutex.synchronize do
+            if timeout
+              end_time = Time.now + timeout
+              until @fulfilled
+                remaining = end_time - Time.now
+                break if remaining <= 0
+
+                @condition.wait(@mutex, remaining)
+              end
+            else
+              @condition.wait(@mutex) until @fulfilled
+            end
+
+            raise @error if @error
+            raise "Promise not yet fulfilled" unless @fulfilled
 
-          @value
+            @value
+          end
         end
 
         def fulfilled?
-          @fulfilled
+          @mutex.synchronize { @fulfilled }
+        end
+
+        def rejected?
+          @mutex.synchronize { @fulfilled && !@error.nil? }
         end
       end
     end

data/lib/desiru/graphql/enum_builder.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+module Desiru
+  module GraphQL
+    # Handles GraphQL enum type generation
+    module EnumBuilder
+      extend self
+
+      def create_enum_type(field, type_cache, cache_mutex)
+        values = extract_literal_values(field)
+        cache_key = "Enum:#{field.name}:#{values.sort.join(',')}"
+
+        cache_mutex.synchronize do
+          return type_cache[cache_key] if type_cache[cache_key]
+        end
+
+        enum_name = "#{field.name.to_s.capitalize}Enum#{cache_key.hash.abs}"
+
+        enum_type = Class.new(::GraphQL::Schema::Enum) do
+          graphql_name enum_name
+          description "Enum for #{field.name}"
+
+          values.each do |val|
+            value val.upcase.gsub(/[^A-Z0-9_]/, '_'), value: val
+          end
+        end
+
+        cache_mutex.synchronize do
+          type_cache[cache_key] = enum_type
+        end
+
+        enum_type
+      end
+
+      def create_enum_from_values(values, type_cache, cache_mutex)
+        cache_key = "LiteralEnum:#{values.sort.join(',')}"
+
+        cache_mutex.synchronize do
+          return type_cache[cache_key] if type_cache[cache_key]
+        end
+
+        enum_name = "Literal#{cache_key.hash.abs}Enum"
+
+        enum_type = Class.new(::GraphQL::Schema::Enum) do
+          graphql_name enum_name
+
+          values.each do |val|
+            value val.upcase.gsub(/[^A-Z0-9_]/, '_'), value: val
+          end
+        end
+
+        cache_mutex.synchronize do
+          type_cache[cache_key] = enum_type
+        end
+
+        enum_type
+      end
+
+      private
+
+      def extract_literal_values(field)
+        # Try to extract values from the field's validator
+        if field.respond_to?(:validator) && field.validator.respond_to?(:instance_variable_get)
+          field.validator.instance_variable_get(:@values) || []
+        elsif field.respond_to?(:element_type) && field.element_type.is_a?(Hash)
+          field.element_type[:values] || []
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/desiru/graphql/executor.rb

@@ -53,20 +53,48 @@ module Desiru
         results
       end
 
+      # Execute with automatic lazy loading support
+      def execute_with_lazy_loading(query_string, variables: {}, context: {}, operation_name: nil)
+        context[:data_loader] = @data_loader
+
+        # Use GraphQL's built-in lazy execution
+        @schema.execute(
+          query_string,
+          variables: variables,
+          context: context,
+          operation_name: operation_name
+        ) do |schema_query|
+          # Configure lazy loading behavior
+          schema_query.after_lazy_resolve do |value|
+            # Trigger batch loading after each lazy resolution
+            @data_loader.perform_loads
+            value
+          end
+        end
+      end
+
       private
 
       def batch_execute
         # Start batch loading context
         @data_loader.clear! if @data_loader.respond_to?(:clear!)
 
-        # Execute the GraphQL queries
+        # Execute the GraphQL queries with lazy loading support
         result = yield
 
-        # Perform all pending batch loads
-        @data_loader.perform_loads if @data_loader.respond_to?(:perform_loads)
+        # Always perform loads at least once to ensure batch processing
+        @data_loader.perform_loads
+
+        # Then perform any additional pending loads
+        @data_loader.perform_loads while pending_loads?
 
         result
       end
+
+      def pending_loads?
+        pending_loads = @data_loader.instance_variable_get(:@pending_loads)
+        pending_loads&.any? { |_, batch| !batch.empty? }
+      end
     end
 
     # GraphQL field extension for lazy loading
@@ -79,8 +107,13 @@ module Desiru
           if result.fulfilled?
             result.value
           else
-            # Create a lazy resolver
+            # Create a lazy resolver that integrates with DataLoader
             ::GraphQL::Execution::Lazy.new do
+              data_loader = context[:data_loader]
+
+              # Ensure batch loads are performed before accessing value
+              data_loader.perform_loads if data_loader && !result.fulfilled?
+
               result.value
             end
           end