graph_weaver 0.2.0 → 0.2.1

data/lib/graph_weaver.rb

@@ -4,6 +4,7 @@ require "sorbet-runtime"
 require_relative "graph_weaver/logging"
 require_relative "graph_weaver/errors"
 require_relative "graph_weaver/hints"
+require_relative "graph_weaver/input_struct"
 require_relative "graph_weaver/response"
 require_relative "graph_weaver/inflect"
 require_relative "graph_weaver/codegen"
@@ -56,15 +57,58 @@ module GraphWeaver
       target.is_a?(Client) ? target.transport! : target
     end
 
-    # Conventional locations, factory_bot-style: used as defaults by
-    # generate!, verify_generated!, load_generated!, and the rake tasks;
-    # override the accessors or pass paths.
-    attr_writer :queries_path, :generated_path, :schema_path
+    # Conventional locations, factory_bot-style — LISTS, so extra
+    # locations (a test-only dir, an engine's) can be appended and every
+    # loader walks them all:
+    #
+    #      # e.g. in spec/support/graph_weaver.rb
+    #      GraphWeaver.generated_paths << "spec/support/graphql/generated"
+    #      GraphWeaver.queries_paths << "spec/support/graphql/queries"
+    #
+    # The singular accessors read the first entry (the default target
+    # for generate! and the rake tasks); assigning one replaces the list.
+    attr_writer :queries_paths, :generated_paths, :schema_path
+
+    # Entries may be glob patterns — the generated default also matches
+    # per-schema layouts (app/graphql/github/generated). Queries stay
+    # single-schema: load_queries! parses everything against one client.
+    def queries_paths = @queries_paths ||= ["app/graphql/queries"]
+    def generated_paths = @generated_paths ||= ["app/graphql/generated", "app/graphql/*/generated"]
+
+    def queries_path = queries_paths.first
+    def generated_path = generated_paths.first
+
+    def queries_path=(path)
+      @queries_paths = path.nil? ? nil : [path]
+    end
+
+    def generated_path=(path)
+      @generated_paths = path.nil? ? nil : [path]
+    end
 
-    def queries_path = @queries_path || "app/graphql/queries"
-    def generated_path = @generated_path || "app/graphql/generated"
     def schema_path = @schema_path || "app/graphql/schema.json"
 
+    # The shared-inputs module name: set it globally, pass inputs_module:
+    # per generate!, or let it derive from the output path — the
+    # directory above generated/ names the schema in multi-schema
+    # layouts (app/graphql/github/generated => GithubInputs); the
+    # conventional layout (and anything unrecognizable) stays
+    # GraphQLInputs.
+    attr_writer :inputs_module
+
+    def inputs_module(output = generated_path)
+      return @inputs_module if @inputs_module
+
+      segments = File.expand_path(output.to_s).split(File::SEPARATOR)
+      segments.pop if segments.last == "generated"
+      parent = segments.last.to_s
+      if parent.match?(/\A[a-zA-Z]\w*\z/) && !%w[graphql app lib spec support test].include?(parent)
+        "#{Inflect.camelize(parent)}Inputs"
+      else
+        "GraphQLInputs"
+      end
+    end
+
     # Generate every .graphql query in a directory into checked-in Ruby
     # files. Paths default to the conventions above; schema: defaults to
     # the dump at schema_path (any supported extension):
@@ -73,16 +117,28 @@ module GraphWeaver
     #
     # person.graphql => person_query.rb defining PersonQuery. Returns the
     # written paths. Pair with a freshness spec (docs/generated_modules.md).
-    def generate!(schema: nil, queries: queries_path, output: generated_path, client: nil)
+    def generate!(schema: nil, queries: queries_path, output: generated_path, client: nil,
+      shared_inputs: true, inputs_module: nil)
       schema ||= locate_schema!
-      FileUtils.mkdir_p(output)
+      inputs_module ||= self.inputs_module(output)
 
-      each_query(queries, schema:, client:).map do |base, source|
-        target = File.join(output, "#{base}_query.rb")
+      plan = generation_plan(queries:, schema:, client:, shared_inputs:, inputs_module:)
+      written = plan.map do |filename, source|
+        target = File.join(output, filename)
+        FileUtils.mkdir_p(File.dirname(target))
         File.write(target, source)
         log(:info) { "generated #{target}" }
         target
       end
+
+      # a type dropped from the schema must not linger as a stale file —
+      # inputs/ is wholly generated, so pruning is safe
+      (Dir[File.join(output, "inputs", "*.rb")] - written).each do |orphan|
+        File.delete(orphan)
+        log(:info) { "pruned #{orphan}" }
+      end
+
+      written
     end
 
     # The freshness guard: raise unless every generated file matches what
@@ -92,12 +148,17 @@ module GraphWeaver
     #      it "generated queries are current" do
     #        GraphWeaver.verify_generated!
     #      end
-    def verify_generated!(schema: nil, queries: queries_path, output: generated_path, client: nil)
+    def verify_generated!(schema: nil, queries: queries_path, output: generated_path, client: nil,
+      shared_inputs: true, inputs_module: nil)
       schema ||= locate_schema!
-      stale = each_query(queries, schema:, client:).filter_map do |base, source|
-        target = File.join(output, "#{base}_query.rb")
+      inputs_module ||= self.inputs_module(output)
+      plan = generation_plan(queries:, schema:, client:, shared_inputs:, inputs_module:)
+      stale = plan.filter_map do |filename, source|
+        target = File.join(output, filename)
         target unless File.exist?(target) && File.read(target) == source
       end
+      # strays: a type file the current schema no longer produces
+      stale += Dir[File.join(output, "inputs", "*.rb")] - plan.map { |f, _| File.join(output, f) }
 
       unless stale.empty?
         raise Error, "stale generated queries — regenerate (rake graph_weaver:generate): #{stale.join(", ")}"
@@ -116,10 +177,11 @@ module GraphWeaver
     # Generated::PersonQuery from generated/person_query.rb, and
     # generated code only changes on regeneration anyway (restart, like
     # a schema migration).
-    def load_generated!(path = generated_path)
-      files = Dir[File.join(path, "**/*.rb")].sort
+    def load_generated!(path = nil)
+      paths = path ? [path] : generated_paths
+      files = paths.flat_map { |dir| Dir[File.join(dir, "**/*.rb")].sort }.uniq
       files.each { |file| require File.expand_path(file) }
-      log(:info) { "loaded #{files.size} generated module(s) from #{path}" }
+      log(:info) { "loaded #{files.size} generated module(s) from #{paths.join(", ")}" }
       files
     end
 
@@ -130,20 +192,39 @@ module GraphWeaver
     end
     private :locate_schema!
 
-    # (base, generated_source) per .graphql file in a directory
-    def each_query(queries, schema:, client:)
-      Dir[File.join(queries, "*.graphql")].sort.map do |path|
+    # (filename, source) per artifact: shared_inputs (the default) emits
+    # every variable type once into inputs.rb, with query modules
+    # aliasing what they use — the difference between hundreds of
+    # duplicated bool_exp structs and one copy per schema.
+    def generation_plan(queries:, schema:, client:, shared_inputs:, inputs_module: self.inputs_module)
+      namespace = shared_inputs ? inputs_module : nil
+      used = { inputs: [], enums: [], mapped: [] }
+
+      plan = Dir[File.join(queries, "*.graphql")].sort.map do |path|
         base = File.basename(path, ".graphql")
-        source = Codegen.generate(
+        codegen = Codegen.new(
           schema:,
           query: File.read(path),
           module_name: "#{Inflect.camelize(base)}Query",
           client:,
+          inputs_namespace: namespace,
         )
-        [base, source]
+        source = codegen.generate
+        codegen.variable_type_names.each { |kind, names| used[kind] |= names }
+        ["#{base}_query.rb", source]
       end
+
+      if namespace && used.values.any?(&:any?)
+        shared = Codegen.generate_inputs(
+          schema:, module_name: namespace,
+          input_types: used[:inputs], enum_types: used[:enums] + used[:mapped],
+        )
+        plan = shared.to_a + plan
+      end
+
+      plan
     end
-    private :each_query
+    private :generation_plan
 
     # Default input coercion for scalars that don't say coerce: themselves,
     # resolved lazily at generation time (so set it any time before you

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph_weaver
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Daniel Pepper
@@ -255,6 +255,7 @@ files:
 - lib/graph_weaver/errors.rb
 - lib/graph_weaver/hints.rb
 - lib/graph_weaver/inflect.rb
+- lib/graph_weaver/input_struct.rb
 - lib/graph_weaver/logging.rb
 - lib/graph_weaver/railtie.rb
 - lib/graph_weaver/response.rb