Rename fetchable field option to returnable

Author: jwils

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/indexing/index.rb

@@ -325,11 +325,11 @@ def mappings
             hash["_routing"] = {"required" => true} if uses_custom_routing?
             hash["_size"] = {"enabled" => true} if schema_def_state.index_document_sizes?
 
-            # Exclude non-fetchable fields from `_source` to save storage. These fields are still
+            # Exclude non-returnable fields from `_source` to save storage. These fields are still
             # indexed (in the inverted index and/or doc_values) for filtering, sorting, and aggregation,
             # but their values are not stored in the compressed `_source` blob.
-            if indexed_type.respond_to?(:non_fetchable_field_paths)
-              source_excludes = indexed_type.non_fetchable_field_paths
+            if indexed_type.respond_to?(:non_returnable_field_paths)
+              source_excludes = indexed_type.non_returnable_field_paths
               hash["_source"] = {"excludes" => source_excludes} if source_excludes.any?
             end
           end

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/schema_elements/field.rb

@@ -91,7 +91,7 @@ class Field < Struct.new(
         :name, :original_type, :parent_type, :original_type_for_derived_types, :schema_def_state, :accuracy_confidence,
         :filter_customizations, :grouped_by_customizations, :highlights_customizations, :sub_aggregations_customizations,
         :aggregated_values_customizations, :sort_order_enum_value_customizations, :args,
-        :sortable, :filterable, :aggregatable, :groupable, :highlightable, :fetchable,
+        :sortable, :filterable, :aggregatable, :groupable, :highlightable, :returnable,
         :graphql_only, :source, :runtime_field_script, :relationship, :singular_name,
         :computation_detail, :non_nullable_in_json_schema, :as_input,
         :name_in_index, :resolver
@@ -106,7 +106,7 @@ def initialize(
           name:, type:, parent_type:, schema_def_state:,
           accuracy_confidence: :high, name_in_index: name,
           type_for_derived_types: nil, graphql_only: nil, singular: nil,
-          sortable: nil, filterable: nil, aggregatable: nil, groupable: nil, highlightable: nil, fetchable: nil,
+          sortable: nil, filterable: nil, aggregatable: nil, groupable: nil, highlightable: nil, returnable: nil,
           as_input: false, resolver: nil
         )
           type_ref = schema_def_state.type_ref(type)
@@ -129,7 +129,7 @@ def initialize(
             aggregatable: aggregatable,
             groupable: groupable,
             highlightable: highlightable,
-            fetchable: fetchable,
+            returnable: returnable,
             graphql_only: graphql_only,
             source: nil,
             runtime_field_script: nil,
@@ -744,14 +744,14 @@ def highlightable?
           type_for_derived_types.fully_unwrapped.as_object_type&.supports?(&:highlightable?)
         end
 
-        # Indicates if this field is fetchable in GraphQL query responses. When `false`, the field will
+        # Indicates if this field is returnable in GraphQL query responses. When `false`, the field will
         # still be available for filtering, sorting, grouping, and aggregation, but will not appear in the
         # GraphQL output type and its data will be excluded from `_source` in the datastore for storage savings.
         #
-        # @return [Boolean] true if this field's data can be fetched (default: true)
-        def fetchable?
-          return true if fetchable.nil?
-          fetchable
+        # @return [Boolean] true if this field's data can be returned (default: true)
+        def returnable?
+          return true if returnable.nil?
+          returnable
         end
 
         # Defines an argument on the field.
@@ -905,8 +905,8 @@ def to_filter_field(parent_type:, for_single_value: !type_for_derived_types.list
             type_for_derived_types: nil,
             resolver: nil,
             # Filter fields should always appear in their parent input type's SDL regardless
-            # of the source field's fetchability.
-            fetchable: nil
+            # of the source field's returnability.
+            returnable: nil
           )
 
           schema_def_state.factory.new_field(**params).tap do |f|

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/schema_elements/type_with_subfields.rb

@@ -137,7 +137,7 @@ def name
         #   ElasticGraph will infer field sortability based on the field's GraphQL type and mapping type.
         # @option options [Boolean] highlightable force-enables or disables the ability to request search highlights for this field. When
         #   not provided, ElasticGraph will infer field highlightable based on the field's mapping type.
-        # @option options [Boolean] fetchable when set to `false`, the field will not appear in the GraphQL output type and its data
+        # @option options [Boolean] returnable when set to `false`, the field will not appear in the GraphQL output type and its data
         #   will be excluded from `_source` in the datastore for storage savings. The field will still be available for filtering,
         #   sorting, grouping, and aggregation. Defaults to `true`.
         # @yield [Field] the field for further customization
@@ -485,21 +485,21 @@ def to_indexing_field_type
           )
         end
 
-        # Returns the list of field paths (in dotted notation) for fields that have `fetchable: false`.
+        # Returns the list of field paths (in dotted notation) for fields that have `returnable: false`.
         # These paths are used to populate `_source.excludes` in the datastore mapping so that
-        # non-fetchable field data is not stored in `_source`, saving storage space.
+        # non-returnable field data is not stored in `_source`, saving storage space.
         #
         # Uses `indexing_fields_by_name_in_index` for traversal (same as `index_field_runtime_metadata_tuples`)
         # to avoid infinite recursion through interface/union subtype cycles.
         #
         # @private
-        def non_fetchable_field_paths(path_prefix: "")
+        def non_returnable_field_paths(path_prefix: "")
           indexing_fields_by_name_in_index.flat_map do |name, field|
             path = path_prefix + name
-            if !field.fetchable?
+            if !field.returnable?
               [path]
-            elsif (object_type = field.type.fully_unwrapped.as_object_type) && object_type.respond_to?(:non_fetchable_field_paths)
-              object_type.non_fetchable_field_paths(path_prefix: "#{path}.")
+            elsif (object_type = field.type.fully_unwrapped.as_object_type) && object_type.respond_to?(:non_returnable_field_paths)
+              object_type.non_returnable_field_paths(path_prefix: "#{path}.")
             else
               []
             end
@@ -555,7 +555,7 @@ def index_field_runtime_metadata_tuples(
 
         def fields_sdl(&arg_selector)
           graphql_fields_by_name.values
-            .select(&:fetchable?)
+            .select(&:returnable?)
             .map { |f| f.to_sdl(&arg_selector) }
             .flat_map { |sdl| sdl.split("\n") }
             .join("\n  ")

elasticgraph-schema_definition/spec/unit/elastic_graph/schema_definition/datastore_config/index_mappings/miscellaneous_spec.rb

@@ -117,12 +117,12 @@ module SchemaDefinition
         })
       end
 
-      it "includes `_source.excludes` for `fetchable: false` fields" do
+      it "includes `_source.excludes` for `returnable: false` fields" do
         mapping = index_mapping_for "my_type" do |s|
           s.object_type "MyType" do |t|
             t.field "id", "ID"
             t.field "name", "String"
-            t.field "internal_code", "String", fetchable: false
+            t.field "internal_code", "String", returnable: false
             t.index "my_type"
           end
         end
@@ -132,7 +132,7 @@ module SchemaDefinition
         expect(mapping.dig("properties", "internal_code")).to eq({"type" => "keyword"})
       end
 
-      it "does not include `_source` config when all fields are fetchable" do
+      it "does not include `_source` config when all fields are returnable" do
         mapping = index_mapping_for "my_type" do |s|
           s.object_type "MyType" do |t|
             t.field "id", "ID"

elasticgraph-schema_definition/spec/unit/elastic_graph/schema_definition/graphql_schema/object_type_spec.rb

@@ -643,12 +643,12 @@ module SchemaDefinition
           end
         end
 
-        it "excludes `fetchable: false` fields from the output type but keeps them in filter, sort, grouped_by, aggregated_values, and highlights types" do
+        it "excludes `returnable: false` fields from the output type but keeps them in filter, sort, grouped_by, aggregated_values, and highlights types" do
           result = define_schema do |api|
             api.object_type "Widget" do |t|
               t.field "id", "ID"
               t.field "name", "String"
-              t.field "internal_code", "String", fetchable: false
+              t.field "internal_code", "String", returnable: false
               t.index "widgets"
             end
           end
@@ -660,19 +660,19 @@ module SchemaDefinition
             }
           EOS
 
-          # fetchable: false field should still appear in filter input
+          # returnable: false field should still appear in filter input
           expect(filter_type_from(result, "Widget")).to include("internal_code: StringFilterInput")
 
-          # fetchable: false field should still appear in sort order
+          # returnable: false field should still appear in sort order
           expect(sort_order_type_from(result, "Widget")).to include("internal_code_ASC")
 
-          # fetchable: false field should still appear in grouped_by
+          # returnable: false field should still appear in grouped_by
           expect(grouped_by_type_from(result, "Widget")).to include("internal_code: String")
 
-          # fetchable: false field should still appear in aggregated_values
+          # returnable: false field should still appear in aggregated_values
           expect(aggregated_values_type_from(result, "Widget")).to include("internal_code: NonNumericAggregatedValues")
 
-          # fetchable: false field should still appear in highlights
+          # returnable: false field should still appear in highlights
           expect(highlights_type_from(result, "Widget")).to include("internal_code: [String!]!")
         end