Drop JSON schema definition methods from core entirely

Per review feedback: `elasticgraph-schema_definition` should not know about
JSON schema at all, so `json_schema_version`, `enforce_json_schema_version`,
and `json_schema_strictness` no longer exist on the core API (calling them
without `elasticgraph-json_ingestion` raises `NoMethodError`). Test support
and the doctest helper feature-detect the extension with `respond_to?`.

Author: jwils

config/site/support/doctest_helper.rb

@@ -66,9 +66,9 @@ module ElasticGraph
         )
 
         # This is required in all JSON ingestion schemas, but we don't want to have to put it in all
-        # our examples, so we set it here. (Without a JSON ingestion extension, JSON schema versioning
-        # is not supported and there is no version to set.)
-        @api.json_schema_version 1 if @api.supports_json_schema_versioning?
+        # our examples, so we set it here. (Without a JSON ingestion extension, the
+        # `json_schema_version` API does not exist and there is no version to set.)
+        @api.json_schema_version 1 if @api.respond_to?(:json_schema_version)
 
         @api.object_type "SomeIndexedTypeToEnsureQueryTypeHasFields" do |t|
           t.field "id", "ID"

elasticgraph-json_ingestion/lib/elastic_graph/json_ingestion/schema_definition/api_extension.rb

@@ -45,14 +45,6 @@ def self.extended(api)
           end
         end
 
-        # Indicates that this extension implements JSON schema versioning.
-        #
-        # @return [Boolean] true
-        # @api private
-        def supports_json_schema_versioning?
-          true
-        end
-
         # Defines the version number of the current JSON schema. Importantly, every time a change is made that impacts the JSON schema
         # artifact, the version number must be incremented to ensure that each different version of the JSON schema is identified by a unique
         # version number. The publisher will then include this version number in published events to identify the version of the schema it

elasticgraph-json_ingestion/sig/elastic_graph/json_ingestion/schema_definition/api_extension.rbs

@@ -2,7 +2,6 @@ module ElasticGraph
   module JSONIngestion
     module SchemaDefinition
       module APIExtension: ::ElasticGraph::SchemaDefinition::API
-        def supports_json_schema_versioning?: () -> bool
         def json_schema_version: (::Integer) -> void
         def enforce_json_schema_version: (bool) -> void
         def json_schema_strictness: (?allow_omitted_fields: bool, ?allow_extra_fields: bool) -> void

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/api.rb

@@ -452,55 +452,6 @@ def results
         @results ||= @factory.new_results
       end
 
-      # Indicates whether a schema definition extension that implements JSON schema versioning (such as
-      # `elasticgraph-json_ingestion`) has been loaded onto this API instance.
-      #
-      # @return [Boolean] `false` unless an extension overrides this
-      # @api private
-      def supports_json_schema_versioning?
-        false
-      end
-
-      # Defines the version number of the current JSON schema.
-      #
-      # JSON schema generation is provided by an ingestion extension rather than by ElasticGraph core, so this
-      # raises an error directing you to `ElasticGraph::JSONIngestion::SchemaDefinition::APIExtension` (from the
-      # `elasticgraph-json_ingestion` gem), which overrides this with real behavior.
-      #
-      # @param version [Integer] current version number of the JSON schema artifact
-      # @return [void]
-      # @raise [Errors::SchemaError] unless an extension that implements JSON schema generation is loaded
-      def json_schema_version(version)
-        raise_json_schema_definition_not_supported_error(:json_schema_version)
-      end
-
-      # Configures whether the JSON schema version is required to be incremented when the JSON schemas artifact changes.
-      #
-      # JSON schema generation is provided by an ingestion extension rather than by ElasticGraph core, so this
-      # raises an error directing you to `ElasticGraph::JSONIngestion::SchemaDefinition::APIExtension` (from the
-      # `elasticgraph-json_ingestion` gem), which overrides this with real behavior.
-      #
-      # @param value [Boolean] whether JSON schema version bumps should be enforced
-      # @return [void]
-      # @raise [Errors::SchemaError] unless an extension that implements JSON schema generation is loaded
-      def enforce_json_schema_version(value)
-        raise_json_schema_definition_not_supported_error(:enforce_json_schema_version)
-      end
-
-      # Defines the strictness of the generated JSON schema validation.
-      #
-      # JSON schema generation is provided by an ingestion extension rather than by ElasticGraph core, so this
-      # raises an error directing you to `ElasticGraph::JSONIngestion::SchemaDefinition::APIExtension` (from the
-      # `elasticgraph-json_ingestion` gem), which overrides this with real behavior.
-      #
-      # @param allow_omitted_fields [Boolean] whether nullable fields can be omitted from indexing events
-      # @param allow_extra_fields [Boolean] whether extra fields can be included in indexing events
-      # @return [void]
-      # @raise [Errors::SchemaError] unless an extension that implements JSON schema generation is loaded
-      def json_schema_strictness(allow_omitted_fields: false, allow_extra_fields: true)
-        raise_json_schema_definition_not_supported_error(:json_schema_strictness)
-      end
-
       # Registers a customization callback that will be applied to every built-in type automatically provided by ElasticGraph. Provides
       # an opportunity to customize the built-in types (e.g. to add directives to them or whatever).
       #
@@ -547,15 +498,6 @@ def as_active_instance
       ensure
         ::Thread.current[:ElasticGraph_SchemaDefinition_API_instance] = old_value
       end
-
-      private
-
-      def raise_json_schema_definition_not_supported_error(method_name)
-        raise Errors::SchemaError,
-          "`#{method_name}` is not supported because no loaded schema definition extension implements JSON schema generation. " \
-          "To use it, add `elasticgraph-json_ingestion` to your bundle and include " \
-          "`ElasticGraph::JSONIngestion::SchemaDefinition::APIExtension` in your configured `extension_modules`."
-      end
     end
   end
 end

elasticgraph-schema_definition/lib/elastic_graph/schema_definition/test_support.rb

@@ -75,20 +75,23 @@ def define_schema_with_schema_elements(
 
         yield api if block_given?
 
-        # Set the json_schema_version to the provided value, if needed. JSON schema versioning is only
-        # available when an extension that implements JSON schema generation (such as
+        # Set the json_schema_version to the provided value, if needed. The `json_schema_version` API only
+        # exists when an extension that implements JSON schema generation (such as
         # `elasticgraph-json_ingestion`) is loaded; without one there is no JSON schema version to set.
-        if !json_schema_version.nil? && api.supports_json_schema_versioning?
-          state = api.state # : untyped
-          api.json_schema_version(json_schema_version) if state.json_schema_version.nil?
+        if !json_schema_version.nil? && api.respond_to?(:json_schema_version)
+          versioned_api = api # : untyped
+          versioned_api.json_schema_version(json_schema_version) if versioned_api.state.json_schema_version.nil?
         end
 
         # :nocov: -- the else branch and code past this aren't used by tests in elasticgraph-schema_definition.
         return api.results unless reload_schema_artifacts
 
         # Reloading the schema artifacts takes extra time that we don't usually want to spend (so it's opt-in)
         # but it can be useful in some cases because there is a bit of extra pruning/validation that it applies.
-        api.enforce_json_schema_version false if api.supports_json_schema_versioning?
+        if api.respond_to?(:enforce_json_schema_version)
+          versioned_api = api # : untyped
+          versioned_api.enforce_json_schema_version false
+        end
         tmp_dir = ::Dir.mktmpdir
         artifacts_manager = api.factory.new_schema_artifact_manager(
           schema_definition_results: api.results,

elasticgraph-schema_definition/sig/elastic_graph/schema_definition/api.rbs

@@ -65,7 +65,6 @@ module ElasticGraph
         ?output: io
       ) -> void
 
-      def json_schema_strictness: (?allow_omitted_fields: bool, ?allow_extra_fields: bool) -> void
       def raw_sdl: (::String) -> void
       def object_type: (::String) { (SchemaElements::ObjectType) -> void } -> void
       def namespace_type: (::String) ?{ (SchemaElements::NamespaceType) -> void } -> void
@@ -77,17 +76,10 @@ module ElasticGraph
       def as_active_instance: { () -> void } -> void
       @results: Results?
       def results: () -> Results
-      def supports_json_schema_versioning?: () -> bool
-      def json_schema_version: (::Integer) -> void
-      def enforce_json_schema_version: (bool) -> void
       def register_graphql_extension: (::Module, defined_at: ::String, **untyped) -> void
       def register_graphql_resolver: (::Symbol, ::Class, defined_at: ::String, ?built_in: bool, **untyped) -> void
       def on_built_in_types: () { (SchemaElements::graphQLType) -> void } -> void
       def on_root_query_type: () { (SchemaElements::ObjectType) -> void } -> void
-
-      private
-
-      def raise_json_schema_definition_not_supported_error: (::Symbol) -> bot
     end
   end
 end

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

@@ -54,24 +54,6 @@ module SchemaDefinition
           }.to raise_error Errors::SchemaError, a_string_including("Let ElasticGraph load")
         end
 
-        it "raises a clear error when JSON schema definition APIs are used without an extension that implements them" do
-          api = API.new(schema_elements, true)
-
-          expect(api.supports_json_schema_versioning?).to be false
-
-          expect {
-            api.json_schema_version 1
-          }.to raise_error Errors::SchemaError, a_string_including("`json_schema_version` is not supported", "elasticgraph-json_ingestion")
-
-          expect {
-            api.enforce_json_schema_version false
-          }.to raise_error Errors::SchemaError, a_string_including("`enforce_json_schema_version` is not supported", "elasticgraph-json_ingestion")
-
-          expect {
-            api.json_schema_strictness allow_omitted_fields: true
-          }.to raise_error Errors::SchemaError, a_string_including("`json_schema_strictness` is not supported", "elasticgraph-json_ingestion")
-        end
-
         it "does not leak the active API instance, even when an error occurs" do
           api = API.new(schema_elements, true)