Merge branch 'issue-7-deprecated'

uhyo · uhyo · commit f571db1a7062 · 2023-04-17T20:33:03.000+09:00
diff --git a/crates/cli/src/check.rs b/crates/cli/src/check.rs
@@ -4,7 +4,7 @@ use log::{debug, info};
 
 use graphql_builtins::generate_builtins;
 use nitrogql_checker::{check_operation_document, check_type_system_document};
-use nitrogql_error::{print_positioned_error, Result};
+use nitrogql_error::Result;
 use nitrogql_semantics::{ast_to_type_system, resolve_extensions};
 
 use crate::{context::LoadedSchema, output::InputFileKind};
diff --git a/crates/cli/src/output/mod.rs b/crates/cli/src/output/mod.rs
@@ -39,11 +39,6 @@ impl CliOutput {
         self.command_error = Some((command_name, error));
     }
 
-    /// Add a check error.
-    pub fn check_error(&mut self, kind: InputFileKind, error: CheckError) {
-        self.check_errors.push((kind, error));
-    }
-
     /// Add a generated file.
     pub fn generated_file(&mut self, kind: OutputFileKind, path: PathBuf) {
         self.generated_files.push((kind, path));
diff --git a/crates/introspection/src/introspection.rs b/crates/introspection/src/introspection.rs
@@ -59,10 +59,8 @@ struct IntrospectionField<'src> {
     #[serde(rename = "type")]
     ty: IntrospectionType<'src>,
     #[serde(rename = "isDeprecated")]
-    #[allow(dead_code)]
-    is_deprecated: bool,
+    is_deprecated: Option<bool>,
     #[serde(rename = "deprecationReason")]
-    #[allow(dead_code)]
     deprecation_reason: Option<Cow<'src, str>>,
 }
 
@@ -74,17 +72,19 @@ struct IntrospectionInputValue<'src> {
     ty: IntrospectionType<'src>,
     #[serde(rename = "defaultValue")]
     default_value: Option<Cow<'src, str>>,
+    #[serde(rename = "isDeprecated")]
+    is_deprecated: Option<bool>,
+    #[serde(rename = "deprecationReason")]
+    deprecation_reason: Option<Cow<'src, str>>,
 }
 
 #[derive(Deserialize)]
 struct IntrospectionEnumValue<'src> {
     name: Cow<'src, str>,
     description: Option<Cow<'src, str>>,
     #[serde(rename = "isDeprecated")]
-    #[allow(dead_code)]
-    is_deprecated: bool,
+    is_deprecated: Option<bool>,
     #[serde(rename = "deprecationReason")]
-    #[allow(dead_code)]
     deprecation_reason: Option<Cow<'src, str>>,
 }
 
@@ -262,8 +262,16 @@ fn as_type_definition<'src, D: Default>(
             .map(|ev| {
                 let name = node_clone(&ev.name);
                 let description = ev.description.as_ref().map(node_clone);
-
-                EnumMember { name, description }
+                let deprecation = ev
+                    .is_deprecated
+                    .unwrap_or(false)
+                    .then(|| ev.deprecation_reason.as_ref().cloned().unwrap_or_default());
+
+                EnumMember {
+                    name,
+                    description,
+                    deprecation,
+                }
             })
             .collect();
 
@@ -305,12 +313,20 @@ fn as_field<'src, D: Default>(
         .map(as_input_value)
         .collect::<Result<_, _>>()
         .unwrap_or(vec![]);
+    let deprecation = value.is_deprecated.unwrap_or(false).then(|| {
+        value
+            .deprecation_reason
+            .as_ref()
+            .cloned()
+            .unwrap_or_default()
+    });
 
     Ok(Field {
         name,
         description,
         r#type: ty,
         arguments,
+        deprecation,
     })
 }
 
@@ -321,12 +337,20 @@ fn as_input_value<'src, D: Default>(
     let description = value.description.as_ref().map(node_clone);
     let ty = as_type(&value.ty)?;
     let default_value = value.default_value.as_ref().map(node_clone);
+    let deprecation = value.is_deprecated.unwrap_or(false).then(|| {
+        value
+            .deprecation_reason
+            .as_ref()
+            .cloned()
+            .unwrap_or_default()
+    });
 
     Ok(InputValue {
         name,
         description,
         r#type: ty,
         default_value,
+        deprecation,
     })
 }
 
diff --git a/crates/printer/src/schema_type_printer/tests/mod.rs b/crates/printer/src/schema_type_printer/tests/mod.rs
@@ -134,6 +134,35 @@ fn scalar_printing() {
     assert_snapshot!(printed);
 }
 
+#[test]
+fn deprecated_items() {
+    let doc = parse_type_system_document(
+        r#"
+        type User {
+            id: ID!
+            name: String!
+            "Age of user."
+            age: Int @deprecated
+            gender: String @deprecated(reason: "Deprecated for political reasons")
+        }
+
+        input UserSearchQuery {
+            age: Int @deprecated
+            name: String
+        }
+
+        type Query {
+            me: User!
+        }
+        "#,
+    )
+    .unwrap();
+    let doc = resolve_extensions(doc).unwrap();
+    let options = SchemaTypePrinterOptions::default();
+    let printed = print_document(&doc, options).unwrap();
+    assert_snapshot!(printed);
+}
+
 fn print_document(
     document: &TypeSystemDocument,
     options: SchemaTypePrinterOptions,
diff --git a/crates/printer/src/schema_type_printer/tests/snapshots/nitrogql_printer__schema_type_printer__tests__deprecated_items.snap b/crates/printer/src/schema_type_printer/tests/snapshots/nitrogql_printer__schema_type_printer__tests__deprecated_items.snap
@@ -0,0 +1,42 @@
+---
+source: crates/printer/src/schema_type_printer/tests/mod.rs
+expression: printed
+---
+export type __nitrogql_schema = {
+  query: Query;
+};
+
+type __Beautify<Obj> = { [K in keyof Obj]: Obj[K] } & {};
+export type __SelectionSet<Orig, Obj, Others> =
+  __Beautify<Pick<{
+    [K in keyof Orig]: Obj extends Record<K, infer V> ? V : unknown
+  }, Extract<keyof Orig, keyof Obj>> & Others>;
+export type User = {
+  __typename: "User";
+  id: ID;
+  name: String;
+  /**
+   * Age of user.
+   * @deprecated No longer supported
+   */
+  age: Int | null;
+  /**
+   * @deprecated Deprecated for political reasons
+   */
+  gender: String | null;
+};
+
+export type Query = {
+  __typename: "Query";
+  me: User;
+};
+
+export type UserSearchQuery = {
+  /**
+   * @deprecated No longer supported
+   */
+  readonly age?: Int | null;
+  readonly name?: String | null;
+};
+
+
diff --git a/crates/printer/src/schema_type_printer/type_printer.rs b/crates/printer/src/schema_type_printer/type_printer.rs
@@ -1,4 +1,4 @@
-use std::borrow::Borrow;
+use std::{borrow::Borrow, fmt::Display};
 
 use crate::{
     ts_types::{
@@ -72,7 +72,7 @@ fn get_schema_metadata_type(document: &TypeSystemDocument) -> TSType {
             (
                 op.as_str(),
                 TSType::TypeVariable(ty.into()),
-                schema_def.description.clone(),
+                schema_def.description.as_ref().map(|d| d.value.clone()),
             )
         }));
     }
@@ -171,13 +171,14 @@ impl TypePrinter for ScalarTypeDefinition<'_> {
 impl TypePrinter for ObjectTypeDefinition<'_> {
     fn print_type(
         &self,
-        _context: &SchemaTypePrinterContext,
+        context: &SchemaTypePrinterContext,
         writer: &mut impl SourceMapWriter,
     ) -> SchemaTypePrinterResult<()> {
         let type_name_ident = Ident {
             name: "__typename",
             position: Pos::builtin(),
         };
+        let schema_type = context.schema.get_type(self.name.name);
         let obj_type = TSType::object(
             vec![(
                 &type_name_ident,
@@ -186,12 +187,18 @@ impl TypePrinter for ObjectTypeDefinition<'_> {
             )]
             .into_iter()
             .chain(self.fields.iter().map(|field| {
+                let schema_field = schema_type
+                    .and_then(|ty| ty.as_object())
+                    .and_then(|ty| ty.fields.iter().find(|f| f.name == field.name.name));
                 (
                     &field.name,
                     get_ts_type_of_type(&field.r#type, |name| {
                         TSType::TypeVariable((&name.name).into())
                     }),
-                    field.description.clone(),
+                    make_ts_description(
+                        &field.description,
+                        &schema_field.and_then(|f| f.deprecation.as_ref()),
+                    ),
                 )
             })),
         );
@@ -283,10 +290,16 @@ impl TypePrinter for InputObjectTypeDefinition<'_> {
         context: &SchemaTypePrinterContext,
         writer: &mut impl SourceMapWriter,
     ) -> SchemaTypePrinterResult<()> {
+        let schema_type = context.schema.get_type(self.name.name);
         let obj_type = TSType::Object(
             self.fields
                 .iter()
                 .map(|field| {
+                    let schema_field = schema_type
+                        .and_then(|t| t.as_input_object())
+                        .and_then(|t| t.fields.iter().find(|f| f.name == field.name.name))
+                        .expect("Type system error");
+
                     let ts_type = get_ts_type_of_type(&field.r#type, |name| {
                         TSType::TypeVariable((&name.name).into())
                     })
@@ -297,7 +310,10 @@ impl TypePrinter for InputObjectTypeDefinition<'_> {
                         readonly: true,
                         optional: context.options.input_nullable_field_is_optional
                             && !field.r#type.is_nonnull(),
-                        description: field.description.clone(),
+                        description: make_ts_description(
+                            &field.description,
+                            &schema_field.deprecation,
+                        ),
                     }
                 })
                 .collect(),
@@ -318,3 +334,19 @@ fn print_description(description: &Option<StringValue>, writer: &mut impl Source
         jsdoc_print_description(description, writer);
     }
 }
+
+/// Combines description and deprecation reason into a single string.
+fn make_ts_description(
+    description: &Option<StringValue>,
+    deprecation: &Option<impl Display>,
+) -> Option<String> {
+    match (description, deprecation) {
+        (Some(description), Some(deprecation)) => Some(format!(
+            "{}\n\n@deprecated {}",
+            description.value, deprecation
+        )),
+        (Some(description), None) => Some(description.value.clone()),
+        (None, Some(deprecation)) => format!("@deprecated {}", deprecation).into(),
+        (None, None) => None,
+    }
+}
diff --git a/crates/printer/src/ts_types/mod.rs b/crates/printer/src/ts_types/mod.rs
@@ -1,7 +1,4 @@
-use nitrogql_ast::{
-    base::{HasPos, Ident, Pos},
-    value::StringValue,
-};
+use nitrogql_ast::base::{HasPos, Ident, Pos};
 use sourcemap_writer::SourceMapWriter;
 
 use super::jsdoc::print_description;
@@ -84,7 +81,7 @@ pub struct ObjectField {
     pub r#type: TSType,
     pub readonly: bool,
     pub optional: bool,
-    pub description: Option<StringValue>,
+    pub description: Option<String>,
 }
 
 #[derive(Clone, Debug)]
@@ -158,7 +155,7 @@ impl TSType {
                 writer.indent();
                 for field in properties {
                     if let Some(ref description) = field.description {
-                        print_description(&description.value, writer);
+                        print_description(description, writer);
                     }
                     if field.readonly {
                         writer.write("readonly ");
@@ -268,7 +265,7 @@ impl TSType {
 
     /// Creates an object type from given set of non-readonly, non-optional properties.
     pub fn object<S: Into<ObjectKey>>(
-        properties: impl IntoIterator<Item = (S, TSType, Option<StringValue>)>,
+        properties: impl IntoIterator<Item = (S, TSType, Option<String>)>,
     ) -> TSType {
         TSType::Object(
             properties
diff --git a/crates/semantics/src/ast_to_type_system.rs b/crates/semantics/src/ast_to_type_system.rs
@@ -7,12 +7,13 @@ use graphql_type_system::{
 };
 use nitrogql_ast::{
     base::{HasPos, Pos},
+    directive::Directive,
     operation::OperationType,
     type_system::{
         ArgumentsDefinition, DirectiveDefinition as AstDirectiveDefinition, FieldDefinition,
         SchemaDefinition, TypeDefinition as AstTypeDefinition, TypeSystemDefinition,
     },
-    value::StringValue,
+    value::{StringValue, Value},
     TypeSystemDocument,
 };
 
@@ -124,6 +125,7 @@ fn convert_type_definition<'src>(
                             .map(|mem| EnumMember {
                                 name: ident_to_node(&mem.name),
                                 description: convert_description(&mem.description),
+                                deprecation: convert_deprecation(&mem.directives),
                             })
                             .collect(),
                     }),
@@ -150,6 +152,7 @@ fn convert_type_definition<'src>(
                                     let value_disp = Box::leak(value_disp);
                                     Node::from(&*value_disp, *value.position())
                                 }),
+                                deprecation: convert_deprecation(&input.directives),
                             })
                             .collect(),
                     }),
@@ -205,6 +208,7 @@ fn convert_arguments<'src>(
                     let value_disp = Box::leak(value_disp);
                     Node::from(&*value_disp, *value.position())
                 }),
+                deprecation: convert_deprecation(&input.directives),
             })
             .collect()
     })
@@ -216,5 +220,27 @@ fn convert_field<'src>(field: &FieldDefinition<'src>) -> Field<Cow<'src, str>, P
         description: convert_description(&field.description),
         r#type: convert_type(&field.r#type),
         arguments: convert_arguments(&field.arguments),
+        deprecation: convert_deprecation(&field.directives),
     }
 }
+
+fn convert_deprecation<'src>(directives: &[Directive<'src>]) -> Option<Cow<'src, str>> {
+    directives
+        .iter()
+        .find(|dir| dir.name.name == "deprecated")
+        .map(|dir| {
+            dir.arguments
+                .iter()
+                .flat_map(|args| args.arguments.iter())
+                .find(|(name, _)| name.name == "reason")
+                .map(|(_, value)| value)
+                .and_then(|value| match value {
+                    Value::StringValue(string) => Some(Cow::Owned(string.value.clone())),
+                    _ => None,
+                })
+                .unwrap_or(
+                    // Default value is from the spec
+                    Cow::Borrowed("No longer supported"),
+                )
+        })
+}
diff --git a/crates/semantics/src/direct_fields_of_output_type.rs b/crates/semantics/src/direct_fields_of_output_type.rs
diff --git a/crates/type-system/src/definitions.rs b/crates/type-system/src/definitions.rs
