feat(compiler): allow SDL to contain built-in scalar definitions (#990)

Adds new `ignore_builtin_redefinitions` option on the `SchemaBuilder` to allow SDL to contain built-in scalar re-definitions. Re-definitions are going to be effectively ignored and compiler will continue to use built-in GraphQL spec definitions. While [GraphQL spec](https://spec.graphql.org/October2021/#sec-Scalars) explicitly specifies following

```
When representing a GraphQL schema using the type system definition language, all built-in scalars must be omitted for brevity.
```

`graphql-js` reference implementation does not enforce this and does not report any errors even if built-in scalars are present in SDL. This change allows users to skip this validation to match `graphql-js` behavior.

Author: dariuszkuc

crates/apollo-compiler/CHANGELOG.md

@@ -17,6 +17,14 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ## Maintenance
 ## Documentation-->
 
+# [x.x.x] (unreleased) - 2025-mm-dd
+
+## Features
+
+- **Adds `ignore_builtin_redefinitions` option to `SchemaBuilder` to allow SDL to contain built-in
+  scalar definitions - [dariuszkuc], [pull/990]**
+
+
 # [1.29.0](https://crates.io/crates/apollo-compiler/1.29.0) - 2025-08-08
 
 ## Features

crates/apollo-compiler/src/schema/from_ast.rs

@@ -7,6 +7,7 @@ use std::sync::Arc;
 #[derive(Clone)]
 pub struct SchemaBuilder {
     adopt_orphan_extensions: bool,
+    ignore_builtin_redefinitions: bool,
     pub(crate) schema: Schema,
     schema_definition: SchemaDefinitionStatus,
     orphan_type_extensions: IndexMap<Name, Vec<ast::Definition>>,
@@ -33,6 +34,7 @@ impl SchemaBuilder {
         BUILT_IN.get_or_init(|| {
             let mut builder = SchemaBuilder {
                 adopt_orphan_extensions: false,
+                ignore_builtin_redefinitions: false,
                 schema: Schema {
                     sources: Default::default(),
                     schema_definition: Node::new(SchemaDefinition {
@@ -76,6 +78,14 @@ impl SchemaBuilder {
         self
     }
 
+    /// Configure the builder to allow SDL to contain scalar built-in types re-definitions.
+    /// Re-definitions are going to be effectively ignored and compiler will continue to use
+    /// built-in GraphQL spec definitions.
+    pub fn ignore_builtin_redefinitions(mut self) -> Self {
+        self.ignore_builtin_redefinitions = true;
+        self
+    }
+
     /// Parse an input file with the default configuration as an additional input for this schema.
     ///
     /// Create a [`Parser`] to use different parser configuration.
@@ -125,10 +135,14 @@ impl SchemaBuilder {
                         Entry::Occupied(entry) => {
                             let previous = entry.get();
                             if $is_scalar && previous.is_built_in() {
-                                self.errors.push(
-                                    $def.location(),
-                                    BuildError::BuiltInScalarTypeRedefinition,
-                                )
+                                if self.ignore_builtin_redefinitions {
+                                    continue;
+                                } else {
+                                    self.errors.push(
+                                        $def.location(),
+                                        BuildError::BuiltInScalarTypeRedefinition,
+                                    )
+                                }
                             } else {
                                 self.errors.push(
                                     $def.name.location(),
@@ -264,6 +278,7 @@ impl SchemaBuilder {
     pub(crate) fn build_inner(self) -> (Schema, DiagnosticList) {
         let SchemaBuilder {
             adopt_orphan_extensions,
+            ignore_builtin_redefinitions: _allow_builtin_redefinitions,
             mut schema,
             schema_definition,
             orphan_type_extensions,

crates/apollo-compiler/tests/validation/types.rs

@@ -1,8 +1,10 @@
 //! Ported from graphql-js, 2023-11-16
 //! https://github.com/graphql/graphql-js/blob/0b7590f0a2b65e6210da2e49be0d8e6c27781af2/src/validation/__tests__/ValuesOfCorrectTypeRule-test.ts
+use apollo_compiler::schema::SchemaBuilder;
 use apollo_compiler::validation::Valid;
 use apollo_compiler::ExecutableDocument;
 use apollo_compiler::Schema;
+use expect_test::expect;
 use expect_test::Expect;
 use std::sync::OnceLock;
 use unindent::unindent;
@@ -2016,3 +2018,34 @@ mod variable_default_values {
         );
     }
 }
+
+#[test]
+fn handles_built_in_type_redefinition() {
+    let schema = r#"
+scalar String
+
+type Query {
+  foo: String
+}
+"#;
+
+    let errors = Schema::parse_and_validate(schema, "schema.graphql")
+        .expect_err("invalid schema")
+        .errors;
+    let expected = expect![[r#"
+        Error: built-in scalar definitions must be omitted
+           ╭─[ schema.graphql:2:1 ]
+           │
+         2 │ scalar String
+           │ ──────┬──────  
+           │       ╰──────── remove this scalar definition
+        ───╯
+    "#]];
+    expected.assert_eq(&errors.to_string());
+
+    let builder = SchemaBuilder::new().ignore_builtin_redefinitions();
+    let _ = builder
+        .parse(schema, "schema.graphql")
+        .build()
+        .expect("schema parsed successfully");
+}