test: add unit and integration tests for deduplication

Author: kbrabrand

src/typescript/__tests__/__snapshots__/schemaTypeGenerator.test.ts.snap

@@ -0,0 +1,14 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`SchemaTypeGenerator > deduplication > snapshot of dedup output for queries with shared inline objects 1`] = `
+{
+  "query1": "Array<{
+  title: string | null;
+  mainImage: InlineImage | null;
+}>",
+  "query2": "Array<{
+  name: string | null;
+  avatar: InlineImage | null;
+}>",
+}
+`;

src/typescript/__tests__/__snapshots__/typeGenerator.test.ts.snap

@@ -47,3 +47,114 @@ export type STRANGE_QUERY_RESULT = Array<{
 
 "
 `;
+
+exports[`TypeGenerator > deduplicates repeated inline object types across queries 1`] = `
+"export type Post = {
+  _id: string;
+  _type: "post";
+  mainImage?: {
+    _type: "image";
+    alt?: string;
+    url: string;
+  };
+  title?: string;
+};
+
+export type Author = {
+  _id: string;
+  _type: "author";
+  avatar?: {
+    _type: "image";
+    alt?: string;
+    url: string;
+  };
+  name?: string;
+};
+
+export type AllSanitySchemaTypes = Post | Author;
+
+export declare const internalGroqTypeReferenceTo: unique symbol;
+
+type InlineImage = {
+  _type: "image";
+  alt?: string;
+  url: string;
+};
+
+// Source: posts.ts
+// Variable: allPostsQuery
+// Query: *[_type == "post"]{_id, title, mainImage}
+export type AllPostsQueryResult = Array<{
+  _id: string;
+  title: string | null;
+  mainImage: InlineImage | null;
+}>;
+
+// Source: authors.ts
+// Variable: allAuthorsQuery
+// Query: *[_type == "author"]{_id, name, avatar}
+export type AllAuthorsQueryResult = Array<{
+  _id: string;
+  name: string | null;
+  avatar: InlineImage | null;
+}>;
+
+"
+`;
+
+exports[`TypeGenerator > deduplication with deeply nested shared objects 1`] = `
+"export type Page = {
+  _id: string;
+  _type: "page";
+  footer?: {
+    image?: {
+      alt?: string;
+      url: string;
+    };
+    text: string;
+  };
+  hero?: {
+    image?: {
+      alt?: string;
+      url: string;
+    };
+    title: string;
+  };
+};
+
+export type AllSanitySchemaTypes = Page;
+
+export declare const internalGroqTypeReferenceTo: unique symbol;
+
+type InlineType = {
+  hero: InlineHero | null;
+  footer: InlineFooter | null;
+};
+
+type InlineHero = {
+  image?: InlineImage;
+  title: string;
+};
+
+type InlineImage = {
+  alt?: string;
+  url: string;
+};
+
+type InlineFooter = {
+  image?: InlineImage;
+  text: string;
+};
+
+// Source: pages.ts
+// Variable: pagesQuery
+// Query: *[_type == "page"]{hero, footer}
+export type PagesQueryResult = Array<InlineType>;
+
+// Source: pages.ts
+// Variable: singlePageQuery
+// Query: *[_type == "page"][0]{hero, footer}
+export type SinglePageQueryResult = InlineType | null;
+
+"
+`;

src/typescript/__tests__/schemaTypeGenerator.test.ts

@@ -1,9 +1,14 @@
 import {CodeGenerator} from '@babel/generator'
 import * as t from '@babel/types'
-import {type TypeNode} from 'groq-js'
+import {type ObjectTypeNode, type TypeNode} from 'groq-js'
 import {describe, expect, test} from 'vitest'
 
 import {SchemaTypeGenerator, walkAndCountQueryTypeNodeStats} from '../schemaTypeGenerator.js'
+import {
+  buildDeduplicationRegistry,
+  collectObjectFingerprints,
+  fingerprintTypeNode,
+} from '../typeNodeFingerprint.js'
 
 function generateCode(node: t.Node | undefined) {
   if (!node) throw new Error('Node is undefined')
@@ -574,6 +579,130 @@ describe(SchemaTypeGenerator.name, () => {
     })
   })
 
+  describe('deduplication', () => {
+    // eslint-disable-next-line unicorn/consistent-function-scoping
+    function buildSchemaWithDuplicateInlineObjects() {
+      // The inline image object has 2+ meaningful attributes (url, alt) beyond _type,
+      // which meets the deduplication extraction threshold
+      const imageAttributes = {
+        _type: {type: 'objectAttribute' as const, value: {type: 'string' as const, value: 'image'}},
+        alt: {optional: true, type: 'objectAttribute' as const, value: {type: 'string' as const}},
+        url: {type: 'objectAttribute' as const, value: {type: 'string' as const}},
+      }
+
+      return new SchemaTypeGenerator([
+        {
+          attributes: {
+            _id: {type: 'objectAttribute', value: {type: 'string'}},
+            _type: {type: 'objectAttribute', value: {type: 'string', value: 'post'}},
+            mainImage: {
+              optional: true,
+              type: 'objectAttribute',
+              value: {attributes: imageAttributes, type: 'object'},
+            },
+            title: {optional: true, type: 'objectAttribute', value: {type: 'string'}},
+          },
+          name: 'post',
+          type: 'document',
+        },
+        {
+          attributes: {
+            _id: {type: 'objectAttribute', value: {type: 'string'}},
+            _type: {type: 'objectAttribute', value: {type: 'string', value: 'author'}},
+            avatar: {
+              optional: true,
+              type: 'objectAttribute',
+              value: {attributes: imageAttributes, type: 'object'},
+            },
+            name: {optional: true, type: 'objectAttribute', value: {type: 'string'}},
+          },
+          name: 'author',
+          type: 'document',
+        },
+      ])
+    }
+
+    test('setDeduplicationRegistry enables type references in object generation', () => {
+      const gen = buildSchemaWithDuplicateInlineObjects()
+
+      // Evaluate two queries that produce the same inline image object
+      const {typeNode: tn1} = gen.evaluateQueryTypeNode({
+        query: '*[_type == "post"]{title, mainImage}',
+      })
+      const {typeNode: tn2} = gen.evaluateQueryTypeNode({
+        query: '*[_type == "author"]{name, avatar}',
+      })
+
+      // Build registry from collected type nodes
+      const fingerprints = collectObjectFingerprints([tn1, tn2])
+      const registry = buildDeduplicationRegistry(fingerprints, new Set(['Author', 'Post']))
+      gen.setDeduplicationRegistry(registry)
+
+      // After setting registry, generating TS type should reference the extracted type
+      const tsType = gen.generateQueryTsType(tn1)
+      const code = generateCode(tsType)
+
+      // We should have exactly one extracted type (the image type)
+      expect(registry.extractedTypes.size).toBe(1)
+
+      // Verify the generated code contains a reference to an extracted type
+      const extractedNames = [...registry.extractedTypes.values()].map((e) => e.id.name)
+      const hasRef = extractedNames.some((name) => code.includes(name))
+      expect(extractedNames).includes('InlineImage')
+      expect(hasRef).toBe(true)
+    })
+
+    test('generateExtractedTypeTsType expands the object without self-referencing', () => {
+      const gen = buildSchemaWithDuplicateInlineObjects()
+
+      const imageObj: ObjectTypeNode = {
+        attributes: {
+          _type: {type: 'objectAttribute', value: {type: 'string', value: 'image'}},
+          alt: {optional: true, type: 'objectAttribute', value: {type: 'string'}},
+          url: {type: 'objectAttribute', value: {type: 'string'}},
+        },
+        type: 'object',
+      }
+
+      const fp = fingerprintTypeNode(imageObj)
+      const fingerprints = new Map([[fp, {candidateName: 'image', count: 2, typeNode: imageObj}]])
+      const registry = buildDeduplicationRegistry(fingerprints, new Set())
+      gen.setDeduplicationRegistry(registry)
+
+      // Generate the extracted type body — it should NOT produce a self-reference
+      const imageTypeBody = gen.generateExtractedTypeTsType(imageObj, fp)
+
+      expect(generateCode(imageTypeBody)).toMatchInlineSnapshot(String.raw`
+      "{
+        _type: "image";
+        alt?: string;
+        url: string;
+      }"
+      `)
+    })
+
+    test('snapshot of dedup output for queries with shared inline objects', () => {
+      const gen = buildSchemaWithDuplicateInlineObjects()
+
+      const {typeNode: tn1} = gen.evaluateQueryTypeNode({
+        query: '*[_type == "post"]{title, mainImage}',
+      })
+      const {typeNode: tn2} = gen.evaluateQueryTypeNode({
+        query: '*[_type == "author"]{name, avatar}',
+      })
+
+      const fingerprints = collectObjectFingerprints([tn1, tn2])
+      const registry = buildDeduplicationRegistry(fingerprints, new Set(['Author', 'Post']))
+      gen.setDeduplicationRegistry(registry)
+
+      const code1 = generateCode(gen.generateQueryTsType(tn1))
+      const code2 = generateCode(gen.generateQueryTsType(tn2))
+
+      // Both queries should reference the same extracted type for image
+      expect({query1: code1, query2: code2}).toMatchSnapshot()
+    })
+  })
+
   describe('walkAndCountQueryTypeNodeStats', () => {
     test('counts unknown type', () => {
       const node: TypeNode = {type: 'unknown'}