fix: correct interface types for nested global fields, add taxonomy field support

Nested global fields (a global field referencing another global field,
whether inside a plain field, a group, or a modular block) got the
wrong GraphQL interface type. The interface field name was derived by
blindly string-replacing the parent type name onto every child field,
which only works when the child's type name is literally built from
that parent name. A nested global field's type name is built from its
own reference_to instead, so the blind replace produced a
non-existent, malformed interface type.

Detect the nested-global-field case explicitly in both
buildBlockCustomSchema and buildCustomSchema, and point the interface
field at the referenced global field's own interface type instead.

Also add support for the `taxonomy` field data type, which previously
had no schema handling at all — content types with a taxonomy field
now correctly expose a `[taxonomyType]` field (taxonomy_uid, term_uid)
instead of the field being silently dropped.

Fixes DX-10112.

Author: abhishek-ezhava-cstk

.talismanrc

@@ -5,4 +5,6 @@ fileignoreconfig:
 - filename: package-lock.json
   ignore_detectors:
     - filecontent
+- filename: src/normalize.js
+  checksum: 471ff9d6a837381c4568abea54abfb5d04821e412b7d046fddacbfd434970d4f
 version: "1.0"

README.md

@@ -165,6 +165,28 @@ query {
 }
 ```
 
+## Querying taxonomy fields
+
+Taxonomy fields let you categorize entries using taxonomy terms defined in your stack. Each
+taxonomy field resolves to a list of `taxonomyType` objects exposing the taxonomy and term UIDs.
+
+```graphql
+{
+  allContentstackBlogs {
+    edges {
+      node {
+        id
+        title
+        topics {
+          taxonomy_uid
+          term_uid
+        }
+      }
+    }
+  }
+}
+```
+
 ## Querying downloaded images
 
 ## Prerequisites

src/normalize.js

@@ -206,7 +206,15 @@ const buildBlockCustomSchema = (blocks, types, references, groups, fileFields, j
     const interfaceFields = {};
     for (const key in fields) {
       typeFields[key] = fields[key].type || fields[key];
-      interfaceFields[key] = typeFields[key].replace(newparent, newInterfaceParent);
+      // A field nested inside this block can itself be a global field: its type name is
+      // built from its own reference_to, not from newparent, so the blind replace below
+      // would produce a malformed interface field. Point at its own interface type instead.
+      const childField = (block.schema || []).find(f => f.uid === key);
+      if (childField && childField.data_type === 'global_field' && childField.reference_to) {
+        interfaceFields[key] = typeFields[key].replace(`${newparent}_${key}`, `${prefix}_${childField.reference_to}`);
+      } else {
+        interfaceFields[key] = typeFields[key].replace(newparent, newInterfaceParent);
+      }
     }
 
     if (Object.keys(fields).length > 0) {
@@ -429,7 +437,13 @@ const buildCustomSchema = (exports.buildCustomSchema = (schema, types, reference
         const interfaceFields = {};
         for (const key in result.fields) {
           typeFields[key] = result.fields[key].type || result.fields[key];
-          interfaceFields[key] = typeFields[key].replace(newParent, newInterfaceParent);
+          // Same nested-global-field case as buildBlockCustomSchema above.
+          const childField = (field.schema || []).find(f => f.uid === key);
+          if (childField && childField.data_type === 'global_field' && childField.reference_to) {
+            interfaceFields[key] = typeFields[key].replace(`${newParent}_${key}`, `${prefix}_${childField.reference_to}`);
+          } else {
+            interfaceFields[key] = typeFields[key].replace(newParent, newInterfaceParent);
+          }
         }
 
         if (Object.keys(typeFields).length > 0) {
@@ -515,6 +529,17 @@ const buildCustomSchema = (exports.buildCustomSchema = (schema, types, reference
           }
         }
         break;
+      case 'taxonomy':
+        types.push('type taxonomyType { taxonomy_uid: String term_uid: String }');
+        fields[field.uid] = {
+          resolve: source => source[field.uid] || null,
+        };
+        if (field.mandatory && !disableMandatoryFields) {
+          fields[field.uid].type = '[taxonomyType]!';
+        } else {
+          fields[field.uid].type = '[taxonomyType]';
+        }
+        break;
     }
   });
   return { fields, types, references, groups, fileFields, jsonRteFields };

src/tests/normalize-nested-global-field-taxonomy.test.js

@@ -0,0 +1,62 @@
+const { buildCustomSchema } = require('../normalize');
+
+describe('buildCustomSchema: nested global field inside a block', () => {
+  test('interface field points at the nested global field\'s own type, not a blind parent-name substitution', () => {
+    const schema = [
+      {
+        uid: 'sections',
+        data_type: 'blocks',
+        mandatory: false,
+        multiple: true,
+        blocks: [
+          {
+            uid: 'hero',
+            reference_to: 'hero_global',
+            schema: [
+              {
+                uid: 'author_info',
+                data_type: 'global_field',
+                reference_to: 'author_global',
+                mandatory: false,
+                multiple: false,
+                schema: [
+                  { uid: 'name', data_type: 'text', mandatory: false, multiple: false },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const result = buildCustomSchema(schema, [], [], [], [], [], 'Contentstack_blog', 'Contentstack', false, false, () => {}, undefined);
+
+    const heroInterface = result.types.find((t) => t.startsWith('interface Contentstack_hero_global'));
+    expect(heroInterface).toBeDefined();
+    expect(heroInterface).toContain('author_info:Contentstack_author_global');
+    expect(heroInterface).not.toContain('Contentstack_hero_global_author_info');
+  });
+});
+
+describe('buildCustomSchema: taxonomy field', () => {
+  test('produces a taxonomyType field instead of being silently dropped', () => {
+    const schema = [
+      { uid: 'topics', data_type: 'taxonomy', mandatory: false, multiple: true },
+    ];
+
+    const result = buildCustomSchema(schema, [], [], [], [], [], 'Contentstack_blog', 'Contentstack', false, false, () => {}, undefined);
+
+    expect(result.fields.topics.type).toBe('[taxonomyType]');
+    expect(result.types).toContain('type taxonomyType { taxonomy_uid: String term_uid: String }');
+  });
+
+  test('is wrapped in a non-null list when mandatory', () => {
+    const schema = [
+      { uid: 'topics', data_type: 'taxonomy', mandatory: true, multiple: true },
+    ];
+
+    const result = buildCustomSchema(schema, [], [], [], [], [], 'Contentstack_blog', 'Contentstack', false, false, () => {}, undefined);
+
+    expect(result.fields.topics.type).toBe('[taxonomyType]!');
+  });
+});