@salesforce/webapp-template-app-react-sample-b2e-experimental 1.61.2 → 1.61.4

package/dist/.a4drules/skills/feature-graphql-graphql-data-access/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: graphql-data-access
+description: Add or modify Salesforce GraphQL data access code. Use when the user asks to fetch, query, or mutate Salesforce data, or add a GraphQL operation for an object like Account, Contact, or Opportunity.
+---
+
+# GraphQL Data Access
+
+Add or modify Salesforce GraphQL data access code using `getDataSDK()` + `data.graphql?.()` and codegen tooling.
+
+## When to Use
+
+- User asks to "fetch data from Salesforce"
+- User asks to "query" or "mutate" Salesforce records
+- User wants to add a new GraphQL operation (query or mutation)
+- User asks to add data access for a Salesforce object (Account, Contact, Opportunity, etc.)
+
+## Prerequisites
+
+The base React app (`base-react-app`) ships with all GraphQL dependencies and tooling pre-configured:
+
+- `@salesforce/sdk-data` — runtime SDK for `getDataSDK` and `gql`
+- `@graphql-codegen/cli` + plugins — type generation from `.graphql` files and inline `gql` queries
+- `@graphql-eslint/eslint-plugin` — linting for `.graphql` files and `gql` template literals
+- `graphql` — shared by codegen, ESLint, and schema introspection
+
+Before using this skill, ensure:
+
+1. The `@salesforce/sdk-data` package is available (provides `getDataSDK`, `gql`, `NodeOfConnection`)
+2. A `schema.graphql` file exists at the project root. If missing, generate it:
+   ```bash
+   npm run graphql:schema
+   ```
+
+## npm Scripts
+
+The base app provides two npm scripts for GraphQL tooling:
+
+- **`npm run graphql:schema`** — Downloads the full GraphQL schema from a connected Salesforce org via introspection. Outputs `schema.graphql` to the project root.
+- **`npm run graphql:codegen`** — Generates TypeScript types from `.graphql` files and inline `gql` queries. Outputs to `src/api/graphql-operations-types.ts`.
+
+## Workflow
+
+### Step 1: Explore the Schema
+
+Before writing any query, verify the target object and its fields exist in the schema.
+
+See `docs/explore-schema.md` for detailed guidance on exploring the Salesforce GraphQL schema.
+
+Key actions:
+
+- Search `schema.graphql` for `type <ObjectName> implements Record` to find available fields
+- Search for `input <ObjectName>_Filter` for filter options
+- Search for `input <ObjectName>_OrderBy` for sorting options
+- For mutations: search for `input <ObjectName>CreateInput` or `<ObjectName>UpdateInput`
+
+### Step 2: Choose the Query Pattern
+
+**Pattern 1 — External `.graphql` file** (recommended for complex queries):
+
+- Queries with variables, fragments, or shared across files
+- Enables full codegen type generation
+- See example: `api/utils/accounts.ts` + `api/utils/query/highRevenueAccountsQuery.graphql`
+
+**Pattern 2 — Inline `gql` tag** (recommended for simple queries):
+
+- Simple queries without variables
+- Colocated with usage code
+- See example: `api/utils/user.ts`
+
+### Step 3: Write the Query
+
+For **Pattern 1**:
+
+1. Create a `.graphql` file under `src/api/utils/query/`
+2. Follow UIAPI structure: `query { uiapi { query { ObjectName(...) { edges { node { ... } } } } } }`
+3. For mutations, see `docs/generate-mutation-query.md`
+4. For read queries, see `docs/generate-read-query.md`
+
+For **Pattern 2**:
+
+1. Define query inline using the `gql` template tag
+2. Ensure the query name matches what codegen expects
+
+### Step 4: Generate Types
+
+```bash
+npm run graphql:codegen
+```
+
+This updates `src/api/graphql-operations-types.ts` with:
+
+- `<OperationName>Query` or `<OperationName>Mutation` — response type
+- `<OperationName>QueryVariables` or `<OperationName>MutationVariables` — input variables type
+
+### Step 5: Implement the Data Access Function
+
+```typescript
+// Pattern 1
+import { getDataSDK, type NodeOfConnection } from "@salesforce/sdk-data";
+import MY_QUERY from "./query/myQuery.graphql?raw";
+import type { GetMyDataQuery, GetMyDataQueryVariables } from "../graphql-operations-types";
+
+type MyNode = NodeOfConnection<GetMyDataQuery["uiapi"]["query"]["MyObject"]>;
+
+export async function getMyData(variables: GetMyDataQueryVariables): Promise<MyNode[]> {
+  const data = await getDataSDK();
+  const response = await data.graphql?.<GetMyDataQuery, GetMyDataQueryVariables>(
+    MY_QUERY,
+    variables,
+  );
+
+  if (response?.errors?.length) {
+    const errorMessages = response.errors.map((e) => e.message).join("; ");
+    throw new Error(`GraphQL Error: ${errorMessages}`);
+  }
+
+  return response?.data?.uiapi?.query?.MyObject?.edges?.map((edge) => edge?.node) || [];
+}
+```
+
+```typescript
+// Pattern 2
+import { getDataSDK, gql } from "@salesforce/sdk-data";
+import type { MySimpleQuery } from "../graphql-operations-types";
+
+const MY_QUERY = gql`
+  query MySimple {
+    uiapi { ... }
+  }
+`;
+
+export async function getSimpleData(): Promise<SomeType> {
+  const data = await getDataSDK();
+  const response = await data.graphql?.<MySimpleQuery>(MY_QUERY);
+  // check response.errors, then extract response.data
+}
+```
+
+### Step 6: Verify
+
+- [ ] Query field names match the schema exactly (case-sensitive)
+- [ ] Response type generic is provided to `data.graphql?.<T>()`
+- [ ] Optional chaining is used for nested response data
+- [ ] Pattern 1: `.graphql` file imported with `?raw` suffix
+- [ ] Pattern 2: Query uses `gql` tag (not plain string)
+- [ ] Generated types imported from `graphql-operations-types.ts`
+
+## Reference
+
+- Schema exploration: `docs/explore-schema.md`
+- Read query generation: `docs/generate-read-query.md`
+- Mutation query generation: `docs/generate-mutation-query.md`
+- Shared GraphQL schema types: `docs/shared-schema.graphqls`
+- Schema download: `npm run graphql:schema` (in the base app)
+- Type generation: `npm run graphql:codegen` (in the base app)

package/dist/.a4drules/{graphql/tools/knowledge/lds-explore-graphql-schema.md → skills/feature-graphql-graphql-data-access/docs/explore-schema.md}

@@ -9,8 +9,9 @@ This document provides guidance for AI agents working with the Salesforce GraphQ
 > ⚠️ **Important**: The schema file is very large (~265,000+ lines). Do NOT read it entirely. Instead, use targeted searches to find specific types, fields, or operations.
 
 If the file is not present, generate it by running:
+
 ```bash
-npm run graphql:get-schema
+npm run graphql:schema
 ```
 
 ## Required Pre-Flight Check
@@ -18,8 +19,8 @@ npm run graphql:get-schema
 **BEFORE generating any GraphQL query, you MUST:**
 
 1. **Check if schema exists**: Look for `schema.graphql` in the project root
-2. **If schema is missing**: 
-   - Run `npm run graphql:get-schema` to download it
+2. **If schema is missing**:
+   - Run `npm run graphql:schema` to download it
    - Wait for the command to complete successfully
    - Then proceed with schema exploration
 3. **If schema exists**: Proceed with targeted searches as described below
@@ -31,6 +32,7 @@ npm run graphql:get-schema
 The schema follows the Salesforce GraphQL Wire Adapter pattern with these main entry points:
 
 ### Query Entry Point
+
 ```graphql
 type Query {
   uiapi: UIAPI!
@@ -38,16 +40,18 @@ type Query {
 ```
 
 ### UIAPI Structure
+
 ```graphql
 type UIAPI {
-  query: RecordQuery!           # For querying records
-  aggregate: RecordQueryAggregate!  # For aggregate queries
-  objectInfos: [ObjectInfo]     # For metadata
+  query: RecordQuery! # For querying records
+  aggregate: RecordQueryAggregate! # For aggregate queries
+  objectInfos: [ObjectInfo] # For metadata
   relatedListByName: RelatedListInfo
 }
 ```
 
 ### Mutation Entry Point
+
 ```graphql
 type Mutation {
   uiapi(input: UIAPIMutationsInput): UIAPIMutations!
@@ -59,35 +63,45 @@ type Mutation {
 When you need to build a GraphQL query, use these search patterns:
 
 ### 1. Find Available Fields for a Record Type
+
 Search for `type <ObjectName> implements Record` to find all queryable fields:
+
 ```bash
 # Example: Find Account fields
 grep "^type Account implements Record" schema.graphql -A 50
 ```
 
 ### 2. Find Filter Options for a Record Type
+
 Search for `input <ObjectName>_Filter` to find filterable fields and operators:
+
 ```bash
 # Example: Find Account filter options
 grep "^input Account_Filter" schema.graphql -A 30
 ```
 
 ### 3. Find OrderBy Options
+
 Search for `input <ObjectName>_OrderBy` for sorting options:
+
 ```bash
 # Example: Find Account ordering options
 grep "^input Account_OrderBy" schema.graphql -A 20
 ```
 
 ### 4. Find Mutation Operations
+
 Search for operations in `UIAPIMutations`:
+
 ```bash
 # Example: Find Account mutations
 grep "Account.*Create\|Account.*Update\|Account.*Delete" schema.graphql
 ```
 
 ### 5. Find Input Types for Mutations
+
 Search for `input <ObjectName>CreateInput` or `input <ObjectName>UpdateInput`:
+
 ```bash
 # Example: Find Account create input
 grep "^input AccountCreateInput" schema.graphql -A 30
@@ -96,32 +110,36 @@ grep "^input AccountCreateInput" schema.graphql -A 30
 ## Common Operator Types
 
 ### StringOperators (for text fields)
+
 ```graphql
 input StringOperators {
-  eq: String      # equals
-  ne: String      # not equals
-  like: String    # pattern matching (use % as wildcard)
-  lt: String      # less than
-  gt: String      # greater than
-  lte: String     # less than or equal
-  gte: String     # greater than or equal
-  in: [String]    # in list
-  nin: [String]   # not in list
+  eq: String # equals
+  ne: String # not equals
+  like: String # pattern matching (use % as wildcard)
+  lt: String # less than
+  gt: String # greater than
+  lte: String # less than or equal
+  gte: String # greater than or equal
+  in: [String] # in list
+  nin: [String] # not in list
 }
 ```
 
 ### OrderByClause
+
 ```graphql
 input OrderByClause {
-  order: ResultOrder   # ASC or DESC
-  nulls: NullOrder     # FIRST or LAST
+  order: ResultOrder # ASC or DESC
+  nulls: NullOrder # FIRST or LAST
 }
 ```
 
 ## Query Pattern Examples
 
 ### Basic Query Structure
+
 All record queries follow this pattern:
+
 ```graphql
 query {
   uiapi {
@@ -146,6 +164,7 @@ query {
 ```
 
 ### Example: Query Accounts with Filter
+
 ```graphql
 query GetHighRevenueAccounts($minRevenue: Currency) {
   uiapi {
@@ -158,9 +177,15 @@ query GetHighRevenueAccounts($minRevenue: Currency) {
         edges {
           node {
             Id
-            Name { value }
-            AnnualRevenue { value }
-            Industry { value }
+            Name {
+              value
+            }
+            AnnualRevenue {
+              value
+            }
+            Industry {
+              value
+            }
           }
         }
       }
@@ -170,13 +195,16 @@ query GetHighRevenueAccounts($minRevenue: Currency) {
 ```
 
 ### Mutation Pattern
+
 ```graphql
 mutation CreateAccount($input: AccountCreateInput!) {
   uiapi(input: { AccountCreate: { input: $input } }) {
     AccountCreate {
       Record {
         Id
-        Name { value }
+        Name {
+          value
+        }
       }
     }
   }
@@ -187,11 +215,11 @@ mutation CreateAccount($input: AccountCreateInput!) {
 
 Salesforce GraphQL returns field values wrapped in typed objects:
 
-| Wrapper Type | Access Pattern |
-|-------------|----------------|
-| `StringValue` | `FieldName { value }` |
-| `IntValue` | `FieldName { value }` |
-| `BooleanValue` | `FieldName { value }` |
+| Wrapper Type    | Access Pattern                     |
+| --------------- | ---------------------------------- |
+| `StringValue`   | `FieldName { value }`              |
+| `IntValue`      | `FieldName { value }`              |
+| `BooleanValue`  | `FieldName { value }`              |
 | `DateTimeValue` | `FieldName { value displayValue }` |
 | `PicklistValue` | `FieldName { value displayValue }` |
 | `CurrencyValue` | `FieldName { value displayValue }` |
@@ -199,8 +227,9 @@ Salesforce GraphQL returns field values wrapped in typed objects:
 ## Agent Workflow for Building Queries
 
 **Pre-requisites (MANDATORY):**
+
 - [ ] Verified `schema.graphql` exists in project root
-- [ ] If missing, ran `npm run graphql:get-schema` and waited for completion
+- [ ] If missing, ran `npm run graphql:schema` and waited for completion
 - [ ] Confirmed connection to correct Salesforce org (if downloading fresh schema)
 
 **Workflow Steps:**
@@ -223,5 +252,5 @@ Salesforce GraphQL returns field values wrapped in typed objects:
 
 ## Related Documentation
 
-- For generating mutations and queries, see `lds-generate-graphql-mutationquery.md`
-- For GraphQL best practices, see `lds-guide-graphql.md`
+- For generating mutations and queries, see `generate-mutation-query.md`
+- For generating read queries, see `generate-read-query.md`

package/dist/.a4drules/{graphql/tools/knowledge/lds-generate-graphql-mutationquery.md → skills/feature-graphql-graphql-data-access/docs/generate-mutation-query.md}

@@ -1,20 +1,22 @@
 # GraphQL Mutation Query Generation
 
 **Triggering conditions**
-1. Only if the `LDS_Guide_GraphQL` rule completed successfully
+
+1. Only if the schema exploration phase completed successfully
 2. Only if the query to generate is a mutation query
 
 ## Your Role
 
 You are a GraphQL expert and your role is to help generate Salesforce compatible GraphQL mutation queries once the exploration phase has completed.
 
-You will leverage the context provided by the requesting user as well as the validation phase provided by the `LDS_Guide_GraphQL` rule. This tool will also provide you with a method to dynamically query the target org instance that you will use to test the generated query.
+You will leverage the context provided by the requesting user as well as the validation phase provided by the schema exploration. This tool will also provide you with a method to dynamically query the target org instance that you will use to test the generated query.
 
-If the `LDS_Guide_GraphQL` rule has not been executed yet, you **MUST** run it first, and then get back to mutation query generation.
+If the schema exploration has not been executed yet, you **MUST** run it first, and then get back to mutation query generation.
 
 ## Mutation Queries General Information
 
 **IMPORTANT**:
+
 1. **Mutation Types**: The GraphQL engine supports `Create`, `Update` and `Delete` operations
 2. **Id Based Mutations**: `Update` and `Delete` operations operate on Id-based entity identification
 3. **Mutation Schema**: Defined in the [mutation query schema](#mutation-query-schema) section
@@ -22,6 +24,7 @@ If the `LDS_Guide_GraphQL` rule has not been executed yet, you **MUST** run it f
 ## Mutation Query Generation Workflow
 
 Strictly follow the rules below when generating the GraphQL mutation query:
+
 1. **Input Fields Validation** - Validate that the set of fields validate [input field constraints](#mutation-queries-input-field-constraints)
 2. **Output Fields Validation** - Validate that the set of fields used in the select part of the query validate the [output fields constraints](#mutation-queries-output-field-constraints)
 3. **Type Consistency** - Make sure variables used as query arguments and their related fields share the same GraphQL type
@@ -31,7 +34,7 @@ Strictly follow the rules below when generating the GraphQL mutation query:
 7. **Query Generation** - Use the [mutation query](#mutation-query-templates) template and adjust it based on the selected operation
 8. **Output Format** - Use the [standalone](#mutation-standalone-default-output-format---clean-code-only)
 9. **Test the Query** - Use the [Generated Mutation Query Testing](#generated-mutation-query-testing) workflow to test the generated query
-    1. **Report First** - Always report first, using the proper output format, before testing
+   1. **Report First** - Always report first, using the proper output format, before testing
 
 ## Mutation Query Schema
 
@@ -64,32 +67,33 @@ type UIAPIMutations {
 ## Mutation Queries Input Field Constraints
 
 1. **`Create` Mutation Queries**:
-    1. **MUST** include all required fields
-    2. **MUST** only include createable fields
-    3. Child relationships can't be set and **MUST** be excluded
-    4. Fields with type `REFERENCE` can only be assigned IDs through their `ApiName` name
+   1. **MUST** include all required fields
+   2. **MUST** only include createable fields
+   3. Child relationships can't be set and **MUST** be excluded
+   4. Fields with type `REFERENCE` can only be assigned IDs through their `ApiName` name
 2. **`Update` Mutation Queries**:
-    1. **MUST** include the id of the entity to update
-    2. **MUST** only include updateable fields
-    3. Child relationships can't be set and **MUST** be excluded
-    4. Fields with type `REFERENCE` can only be assigned IDs through their `ApiName` name
+   1. **MUST** include the id of the entity to update
+   2. **MUST** only include updateable fields
+   3. Child relationships can't be set and **MUST** be excluded
+   4. Fields with type `REFERENCE` can only be assigned IDs through their `ApiName` name
 3. **`Delete` Mutation Queries**:
-    1. **MUST** include the id of the entity to delete
+   1. **MUST** include the id of the entity to delete
 
 ## Mutation Queries Output Field Constraints
 
 1. **`Create` and `Update` Mutation Queries**:
-    1. **MUST** exclude all child relationships
-    2. **MUST** exclude all `REFERENCE` fields, unless accessed through their `ApiName` member (no navigation to referenced entity)
-    3. Inaccessible fields will be reported as part of the `errors` attribute in the returned payload
-    4. Child relationships **CAN'T** be queried as part of a mutation
-    5. Fields with type `REFERENCE` can only be queried through their `ApiName` (no referenced entities navigation, no sub fields)
+   1. **MUST** exclude all child relationships
+   2. **MUST** exclude all `REFERENCE` fields, unless accessed through their `ApiName` member (no navigation to referenced entity)
+   3. Inaccessible fields will be reported as part of the `errors` attribute in the returned payload
+   4. Child relationships **CAN'T** be queried as part of a mutation
+   5. Fields with type `REFERENCE` can only be queried through their `ApiName` (no referenced entities navigation, no sub fields)
 2. **`Delete` Mutation Queries**:
-    1. **MUST** only include the `Id` field
+   1. **MUST** only include the `Id` field
 
 ## Mutation Query Report Template
 
 Input arguments:
+
 - Required fields: FieldName1 (Type1), FieldName2 (Type2)...
 - Other fields: FieldName3 (Type3)...
   Output fields: FieldNameA (TypeA), FieldNameB (TypeB)...
@@ -147,66 +151,72 @@ const QUERY_VARIABLES = {
 ```
 
 **❌ DO NOT INCLUDE:**
+
 - Explanatory comments about the query
 - Field descriptions
 - Additional text about what the query does
 - Workflow step descriptions
 
 **✅ ONLY INCLUDE:**
+
 - Raw query string
 - Variables object
 - Nothing else
 
 ## Generated Mutation Query Testing
 
-**Triggering conditions** - **ALL CONDITIONS MUST VALIDATE***
+**Triggering conditions** - **ALL CONDITIONS MUST VALIDATE\***
+
 1. Only if the [Mutation Query Generation Workflow](#mutation-query-generation-workflow) step global status is `SUCCESS` and you have a generated query
 2. Only if the query to generate is a mutation query
-3. Only if non manual method was used during `LDS_Guide_GraphQL` rule execution to retrieve introspection data
+3. Only if non manual method was used during schema exploration to retrieve introspection data
 
 **Workflow**
+
 1. **Report Step** - Explain that you are able to test the query using the same method used during introspection
-    1. You **MUST** report the method you will use, based on the one you used during `LDS_Guide_GraphQL` rule execution
+   1. You **MUST** report the method you will use, based on the one you used during schema exploration
 2. **Interactive Step** - Ask the user whether they want you to test the query using the proposed method
-    1. **WAIT** for the user's answer.
+   1. **WAIT** for the user's answer.
 3. **Input Arguments** - You **MUST** ask the user for the input arguments to use
-    1. **WAIT** for the user's answer.
+   1. **WAIT** for the user's answer.
 4. **Test Query** - If the user are OK with you testing the query:
-    1. Use the selected method to test the query
-    2. **IMPORTANT** - If you use the Salesforce CLI `sf api request graphql` command, you will need to inject the variable values directly into the query, as this command doesn't accept variables as a parameter
+   1. Use the selected method to test the query
+   2. **IMPORTANT** - If you use the Salesforce CLI `sf api request graphql` command, you will need to inject the variable values directly into the query, as this command doesn't accept variables as a parameter
 5. **Result Analysis** - Retrieve the `data` and `errors` attributes from the returned payload, and report the result of the test as one of the following options:
-    1. `PARTIAL` if `data` is not an empty object, but `errors` is not an empty list - Explanation: some of the queried fields are not accessible on mutations
-    2. `FAILED` if `data` is an empty object - Explanation: the query is not valid
-    3. `SUCCESS` if `errors` is an empty list
+   1. `PARTIAL` if `data` is not an empty object, but `errors` is not an empty list - Explanation: some of the queried fields are not accessible on mutations
+   2. `FAILED` if `data` is an empty object - Explanation: the query is not valid
+   3. `SUCCESS` if `errors` is an empty list
 6. **Remediation Step** - If status is not `SUCCESS`, use the [`FAILED`](#failed-status-handling-workflow) or [`PARTIAL`](#partial-status-handling-workflow) status handling workflows
 
 ### `FAILED` Status Handling Workflow
 
 The query is invalid:
+
 1. **Error Analysis** - Parse and categorize the specific error messages
 2. **Root Cause Identification** - Use error message to identify the root cause:
-    - **Execution** - Error contains `invalid cross reference id` or `entity is deleted`
-    - **Syntax** - Error contains `invalid syntax`
-    - **Validation** - Error contains `validation error`
-    - **Type** - Error contains `VariableTypeMismatch` or `UnknownType`
-    - **Navigation** - Error contains `is not currently available in mutation results`
-    - **API Version** - Query deals with updates, you're testing with Connect API and error contains `Cannot invoke JsonElement.isJsonObject()`
+   - **Execution** - Error contains `invalid cross reference id` or `entity is deleted`
+   - **Syntax** - Error contains `invalid syntax`
+   - **Validation** - Error contains `validation error`
+   - **Type** - Error contains `VariableTypeMismatch` or `UnknownType`
+   - **Navigation** - Error contains `is not currently available in mutation results`
+   - **API Version** - Query deals with updates, you're testing with Connect API and error contains `Cannot invoke JsonElement.isJsonObject()`
 3. **Targeted Resolution** - Depending on the root cause categorization
-    - **Execution** - You're trying to update or delete an unknown/no longer available entity: either create an entity first, if you have generated the related query, or ask for a valid entity id to use
-    - **Syntax** - Update the query using the error message information to fix the syntax errors
-    - **Validation** - This field's name is most probably invalid, ask user for clarification and **WAIT** for the user's answer
-    - **Type** - Use the error details and GraphQL schema to correct argument's type, and adjust variables accordingly
-    - **Navigation** - Use the [`PARTIAL` status handling workflow](#partial-status-handling-workflow) below
-    - **API Version** - `Record` selection is only available with API version 64 and higher, **report** the issue, and try again with API version 64
+   - **Execution** - You're trying to update or delete an unknown/no longer available entity: either create an entity first, if you have generated the related query, or ask for a valid entity id to use
+   - **Syntax** - Update the query using the error message information to fix the syntax errors
+   - **Validation** - This field's name is most probably invalid, ask user for clarification and **WAIT** for the user's answer
+   - **Type** - Use the error details and GraphQL schema to correct argument's type, and adjust variables accordingly
+   - **Navigation** - Use the [`PARTIAL` status handling workflow](#partial-status-handling-workflow) below
+   - **API Version** - `Record` selection is only available with API version 64 and higher, **report** the issue, and try again with API version 64
 4. **Test Again** - Resume the [query testing workflow](#generated-mutation-query-testing) with the updated query (increment and track attempt counter)
 5. **Escalation Path** - If targeted resolution fails after 2 attempts, ask for additional details and restart the entire GraphQL workflow, going again through the introspection phase
 
 ### `PARTIAL` Status Handling Workflow
 
 The query can be improved:
+
 1. Report the fields mentioned in the `errors` list
 2. Explain that these fields can't be queried as part of a mutation query
 3. Explain that the query might be considered as failing, as it will report errors
 4. Offer to remove the offending fields
 5. **WAIT** for the user's answer
-6. If they are OK with removing the fields restart the [generation workflow](#mutation-query-generation-workflow) with the new field list
+6. If they are OK with removing the fields restart the [generation workflow](#mutation-query-generation-workflow) with the new field list