Generate schema for isograph.config.json

.github/workflows/ci.yml

@@ -348,6 +348,8 @@ jobs:
       #   # TODO do this less hackily
       - name: Build
         run: pnpm -r compile
+      - name: Build json schema
+        run: pnpm build-json-schema
       - name: Download artifact isograph_cli-linux-x64
         uses: actions/download-artifact@v4
         with:

.prettierignore

@@ -5,3 +5,4 @@
 **/.docusaurus/**
 **/dist/**
 **/relay-crates/**
+isograph-config-schema.json

Cargo.toml

@@ -22,6 +22,7 @@ notify-debouncer-full = "0.4.0"
 pathdiff = "0.2.1"
 pretty-duration = "0.1.1"
 regex = "1.6.0"
+schemars = { version="0.8.11", features=["indexmap1"] }
 serde = "1.0.197"
 serde_json = "1.0.108"
 strum = { version = "0.25.0", features = ["derive"] }

crates/common_lang_types/src/string_key_types.rs

@@ -10,6 +10,9 @@ string_key_newtype!(DirectiveArgumentName);
 // (client-defined linked fields do not exist, but will.)
 string_key_newtype!(SelectableFieldName);
 
+string_key_newtype!(ClientPointerFieldName);
+string_key_conversion!(from: ClientPointerFieldName, to: SelectableFieldName);
+
 string_key_newtype!(InputValueName);
 string_key_conversion!(from: InputValueName, to: VariableName);
 string_key_conversion!(from: InputValueName, to: FieldArgumentName);

crates/graphql_artifact_generation/src/format_parameter_type.rs

@@ -2,8 +2,8 @@ use common_lang_types::SelectableFieldName;
 use graphql_lang_types::{GraphQLNonNullTypeAnnotation, GraphQLTypeAnnotation};
 
 use isograph_lang_types::{
-    ClientFieldId, SelectableServerFieldId, SelectionType, ServerFieldId, TypeAnnotation,
-    UnionVariant,
+    ClientFieldId, ClientPointerId, SelectableServerFieldId, SelectionType, ServerFieldId,
+    TypeAnnotation, UnionVariant,
 };
 use isograph_schema::{ClientType, FieldType, ValidatedSchema};
 
@@ -75,7 +75,7 @@ fn format_server_field_type(
 fn format_field_definition(
     schema: &ValidatedSchema,
     name: &SelectableFieldName,
-    type_: &FieldType<ServerFieldId, ClientType<ClientFieldId>>,
+    type_: &FieldType<ServerFieldId, ClientType<ClientFieldId, ClientPointerId>>,
     indentation_level: u8,
 ) -> String {
     match type_ {

crates/graphql_artifact_generation/src/generate_artifacts.rs

@@ -247,6 +247,7 @@ pub fn get_artifact_path_and_content(
     }
 
     for user_written_client_field in schema.client_fields.iter().flat_map(|field| match field {
+        ClientType::ClientPointer(_) => todo!(),
         ClientType::ClientField(field) => match field.variant {
             ClientFieldVariant::UserWritten(_) => Some(field),
             ClientFieldVariant::ImperativelyLoadedField(_) => None,

crates/graphql_artifact_generation/src/iso_overload_file.rs

@@ -262,6 +262,7 @@ fn user_written_fields(
         .client_fields
         .iter()
         .filter_map(|client_field| match client_field {
+            ClientType::ClientPointer(_) => todo!(),
             ClientType::ClientField(client_field) => match client_field.variant {
                 ClientFieldVariant::UserWritten(info) => {
                     Some((client_field, info.user_written_component_variant))

crates/graphql_lang_types/src/graphql_type_annotation.rs

@@ -1,6 +1,6 @@
 use std::{fmt, ops::Deref};
 
-use common_lang_types::WithSpan;
+use common_lang_types::{Span, WithSpan};
 
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum GraphQLTypeAnnotation<TValue> {
@@ -18,6 +18,14 @@ impl<TValue> GraphQLTypeAnnotation<TValue> {
         }
     }
 
+    pub fn span(&self) -> &Span {
+        match self {
+            GraphQLTypeAnnotation::Named(named) => &named.0.span,
+            GraphQLTypeAnnotation::List(list) => list.0.span(),
+            GraphQLTypeAnnotation::NonNull(non_null) => non_null.span(),
+        }
+    }
+
     pub fn inner_mut(&mut self) -> &mut TValue {
         match self {
             GraphQLTypeAnnotation::Named(named) => &mut named.0.item,
@@ -103,6 +111,13 @@ impl<TValue> GraphQLNonNullTypeAnnotation<TValue> {
         }
     }
 
+    pub fn span(&self) -> &Span {
+        match self {
+            GraphQLNonNullTypeAnnotation::Named(named) => &named.0.span,
+            GraphQLNonNullTypeAnnotation::List(list) => list.0.span(),
+        }
+    }
+
     pub fn inner_mut(&mut self) -> &mut TValue {
         match self {
             GraphQLNonNullTypeAnnotation::Named(named) => &mut named.0.item,

crates/isograph_compiler/src/field_directives.rs

@@ -3,8 +3,10 @@ use intern::string_key::Intern;
 use isograph_lang_types::{
     from_isograph_field_directive, ClientFieldDeclaration,
     ClientFieldDeclarationWithUnvalidatedDirectives, ClientFieldDeclarationWithValidatedDirectives,
-    IsographFieldDirective, IsographSelectionVariant, LinkedFieldSelection, ScalarFieldSelection,
-    ServerFieldSelection,
+    ClientPointerDeclaration, ClientPointerDeclarationWithUnvalidatedDirectives,
+    ClientPointerDeclarationWithValidatedDirectives, IsographFieldDirective,
+    IsographSelectionVariant, LinkedFieldSelection, ScalarFieldSelection, ServerFieldSelection,
+    UnvalidatedSelection,
 };
 use isograph_schema::ProcessClientFieldDeclarationError;
 use lazy_static::lazy_static;
@@ -20,19 +22,42 @@ pub fn validate_isograph_field_directives(
     WithSpan<ClientFieldDeclarationWithValidatedDirectives>,
     Vec<WithLocation<ProcessClientFieldDeclarationError>>,
 > {
-    let ClientFieldDeclaration {
-        const_export_name,
-        parent_type,
-        client_field_name,
-        description,
-        selection_set,
-        directives,
-        variable_definitions,
-        definition_path,
-        dot,
-        field_keyword,
-    } = client_field.item;
-    let new_selecton_set = and_then_selection_set_and_collect_errors(
+    client_field.and_then(|client_field| {
+        let ClientFieldDeclaration {
+            const_export_name,
+            parent_type,
+            client_field_name,
+            description,
+            selection_set,
+            directives,
+            variable_definitions,
+            definition_path,
+            dot,
+            field_keyword,
+        } = client_field;
+
+        Ok(ClientFieldDeclarationWithValidatedDirectives {
+            const_export_name,
+            parent_type,
+            client_field_name,
+            description,
+            selection_set: validate_isograph_selection_set_directives(selection_set)?,
+            directives,
+            variable_definitions,
+            definition_path,
+            dot,
+            field_keyword,
+        })
+    })
+}
+
+pub fn validate_isograph_selection_set_directives(
+    selection_set: Vec<WithSpan<ServerFieldSelection<(), ()>>>,
+) -> Result<
+    Vec<WithSpan<UnvalidatedSelection>>,
+    Vec<WithLocation<ProcessClientFieldDeclarationError>>,
+> {
+    and_then_selection_set_and_collect_errors(
         selection_set,
         &|scalar_field_selection| {
             if let Some(directive) =
@@ -55,23 +80,44 @@ pub fn validate_isograph_field_directives(
                 Ok(IsographSelectionVariant::Regular)
             }
         },
-        &|_linked_field_selection| Ok(IsographSelectionVariant::Regular),
-    )?;
-    Ok(WithSpan::new(
-        ClientFieldDeclarationWithValidatedDirectives {
+        &|_object_pointer_selection| Ok(IsographSelectionVariant::Regular),
+    )
+}
+
+#[allow(clippy::complexity)]
+pub fn validate_isograph_pointer_directives(
+    client_pointer: WithSpan<ClientPointerDeclarationWithUnvalidatedDirectives>,
+) -> Result<
+    WithSpan<ClientPointerDeclarationWithValidatedDirectives>,
+    Vec<WithLocation<ProcessClientFieldDeclarationError>>,
+> {
+    client_pointer.and_then(|client_pointer| {
+        let ClientPointerDeclaration {
             const_export_name,
             parent_type,
-            client_field_name,
+            client_pointer_name,
             description,
-            selection_set: new_selecton_set,
-            directives,
+            selection_set,
             variable_definitions,
             definition_path,
             dot,
-            field_keyword,
-        },
-        client_field.span,
-    ))
+            pointer_keyword,
+            to_type,
+        } = client_pointer;
+
+        Ok(ClientPointerDeclarationWithValidatedDirectives {
+            const_export_name,
+            parent_type,
+            client_pointer_name,
+            description,
+            selection_set: validate_isograph_selection_set_directives(selection_set)?,
+            variable_definitions,
+            definition_path,
+            dot,
+            pointer_keyword,
+            to_type,
+        })
+    })
 }
 
 fn and_then_selection_set_and_collect_errors<

crates/isograph_compiler/src/isograph_literals.rs

@@ -14,7 +14,8 @@ use lazy_static::lazy_static;
 use regex::Regex;
 
 use crate::{
-    batch_compile::BatchCompileError, field_directives::validate_isograph_field_directives,
+    batch_compile::BatchCompileError,
+    field_directives::{validate_isograph_field_directives, validate_isograph_pointer_directives},
     source_files::ContainsIso,
 };
 
@@ -164,7 +165,22 @@ pub(crate) fn process_iso_literals(
                         Err(e) => errors.extend(e),
                     };
                 }
-                IsoLiteralExtractionResult::ClientPointerDeclaration(_) => todo!(),
+                IsoLiteralExtractionResult::ClientPointerDeclaration(
+                    client_pointer_declaration,
+                ) => {
+                    match validate_isograph_pointer_directives(client_pointer_declaration) {
+                        Ok(validated_client_pointer_declaration) => {
+                            if let Err(e) = schema.process_client_pointer_declaration(
+                                validated_client_pointer_declaration,
+                                text_source,
+                            ) {
+                                errors.push(e);
+                            }
+                        }
+                        Err(e) => errors.extend(e),
+                    };
+                }
+
                 IsoLiteralExtractionResult::EntrypointDeclaration(entrypoint_declaration) => schema
                     .entrypoints
                     .push((text_source, entrypoint_declaration)),

crates/isograph_compiler/src/refetch_fields.rs

@@ -6,7 +6,8 @@ use isograph_schema::{
     generate_refetch_field_strategy, id_arguments, id_selection, id_top_level_arguments,
     ClientField, ClientFieldVariant, ClientType, FieldType, ImperativelyLoadedFieldVariant,
     ObjectTypeAndFieldName, RefetchStrategy, RequiresRefinement, SchemaObject,
-    UnvalidatedClientField, UnvalidatedSchema, NODE_FIELD_NAME, REFETCH_FIELD_NAME,
+    UnvalidatedClientField, UnvalidatedClientPointer, UnvalidatedSchema, NODE_FIELD_NAME,
+    REFETCH_FIELD_NAME,
 };
 
 use crate::batch_compile::BatchCompileError;
@@ -32,7 +33,7 @@ pub fn add_refetch_fields_to_objects(
 
 fn add_refetch_field_to_object(
     object: &mut SchemaObject,
-    client_fields: &mut Vec<ClientType<UnvalidatedClientField>>,
+    client_fields: &mut Vec<ClientType<UnvalidatedClientField, UnvalidatedClientPointer>>,
     query_id: ServerObjectId,
 ) -> Option<Result<(), BatchCompileError>> {
     match object

crates/isograph_config/Cargo.toml

@@ -8,6 +8,7 @@ license = { workspace = true}
 
 [dependencies]
 common_lang_types = { path = "../common_lang_types" }
+schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 colorize = { workspace = true }