polen 0.10.0-next.11 → 0.10.0-next.12

package/src/lib/graphql-document/schema-integration.test.ts

@@ -0,0 +1,365 @@
+import { buildSchema } from 'graphql'
+import { describe, expect, it } from 'vitest'
+import { analyzeWithSchema, createPolenSchemaResolver } from './schema-integration.ts'
+
+// Test schema
+const testSchema = buildSchema(`
+  """
+  A user in the system
+  """
+  type User {
+    """
+    The user's unique identifier
+    """
+    id: ID!
+    
+    """
+    The user's full name
+    """
+    name: String!
+    
+    """
+    The user's email address
+    """
+    email: String!
+    
+    """
+    User's posts
+    """
+    posts(
+      """
+      Maximum number of posts to return
+      """
+      first: Int = 10
+      
+      """
+      Filter posts after this cursor
+      """
+      after: String
+    ): [Post!]!
+    
+    """
+    @deprecated Use profile.avatar instead
+    """
+    avatar: String @deprecated(reason: "Use profile.avatar instead")
+  }
+
+  """
+  A blog post
+  """
+  type Post {
+    id: ID!
+    title: String!
+    content: String!
+    author: User!
+  }
+
+  """
+  Input for creating a user
+  """
+  input CreateUserInput {
+    name: String!
+    email: String!
+  }
+
+  type Query {
+    """
+    Get a user by ID
+    """
+    user(id: ID!): User
+    
+    """
+    Search for users
+    """
+    users(query: String!): [User!]!
+  }
+
+  type Mutation {
+    """
+    Create a new user
+    """
+    createUser(input: CreateUserInput!): User!
+  }
+
+  """
+  Custom directive for validation
+  """
+  directive @validate(pattern: String!) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION
+`)
+
+describe('Schema Integration', () => {
+  describe('PolenSchemaResolver', () => {
+    const resolver = createPolenSchemaResolver(testSchema)
+
+    describe('Type Resolution', () => {
+      it('should resolve existing types', () => {
+        const identifier = {
+          name: 'User',
+          kind: 'Type' as const,
+          position: { start: 0, end: 4, line: 1, column: 1 },
+          schemaPath: ['User'],
+          context: { selectionPath: [] },
+        }
+
+        const resolution = resolver.resolveIdentifier(identifier)
+
+        expect(resolution).toBeDefined()
+        expect(resolution!.exists).toBe(true)
+        expect(resolution!.referenceUrl).toBe('/reference/User')
+        expect(resolution!.documentation?.description).toContain('A user in the system')
+        expect(resolution!.documentation?.typeInfo).toBe('User')
+      })
+
+      it('should handle non-existent types', () => {
+        const identifier = {
+          name: 'NonExistentType',
+          kind: 'Type' as const,
+          position: { start: 0, end: 15, line: 1, column: 1 },
+          schemaPath: ['NonExistentType'],
+          context: { selectionPath: [] },
+        }
+
+        const resolution = resolver.resolveIdentifier(identifier)
+
+        expect(resolution).toBeDefined()
+        expect(resolution!.exists).toBe(false)
+        expect(resolution!.referenceUrl).toBe('/reference/NonExistentType')
+        expect(resolution!.documentation).toBeUndefined()
+      })
+    })
+
+    describe('Field Resolution', () => {
+      it('should resolve existing fields', () => {
+        const identifier = {
+          name: 'name',
+          kind: 'Field' as const,
+          position: { start: 0, end: 4, line: 1, column: 1 },
+          parentType: 'User',
+          schemaPath: ['User', 'name'],
+          context: { selectionPath: ['name'] },
+        }
+
+        const resolution = resolver.resolveIdentifier(identifier)
+
+        expect(resolution).toBeDefined()
+        expect(resolution!.exists).toBe(true)
+        expect(resolution!.referenceUrl).toBe('/reference/User#name')
+        expect(resolution!.documentation?.description).toContain("The user's full name")
+        expect(resolution!.documentation?.typeInfo).toBe('String!')
+      })
+
+      it('should detect deprecated fields', () => {
+        const identifier = {
+          name: 'avatar',
+          kind: 'Field' as const,
+          position: { start: 0, end: 6, line: 1, column: 1 },
+          parentType: 'User',
+          schemaPath: ['User', 'avatar'],
+          context: { selectionPath: ['avatar'] },
+        }
+
+        const resolution = resolver.resolveIdentifier(identifier)
+
+        expect(resolution).toBeDefined()
+        expect(resolution!.exists).toBe(true)
+        expect(resolution!.deprecated).toBeDefined()
+        expect(resolution!.deprecated!.reason).toBe('Use profile.avatar instead')
+      })
+
+      it('should handle non-existent fields', () => {
+        const identifier = {
+          name: 'nonExistentField',
+          kind: 'Field' as const,
+          position: { start: 0, end: 16, line: 1, column: 1 },
+          parentType: 'User',
+          schemaPath: ['User', 'nonExistentField'],
+          context: { selectionPath: ['nonExistentField'] },
+        }
+
+        const resolution = resolver.resolveIdentifier(identifier)
+
+        expect(resolution).toBeDefined()
+        expect(resolution!.exists).toBe(false)
+        expect(resolution!.referenceUrl).toBe('/reference/User#nonExistentField')
+      })
+    })
+
+    describe('Argument Resolution', () => {
+      it('should resolve field arguments', () => {
+        const identifier = {
+          name: 'first',
+          kind: 'Argument' as const,
+          position: { start: 0, end: 5, line: 1, column: 1 },
+          parentType: 'User',
+          schemaPath: ['User', 'posts', 'first'],
+          context: { selectionPath: ['posts'] },
+        }
+
+        const resolution = resolver.resolveIdentifier(identifier)
+
+        expect(resolution).toBeDefined()
+        expect(resolution!.exists).toBe(true)
+        expect(resolution!.referenceUrl).toBe('/reference/User#posts-first')
+        expect(resolution!.documentation?.description).toContain('Maximum number of posts')
+        expect(resolution!.documentation?.typeInfo).toBe('Int')
+        expect(resolution!.documentation?.defaultValue).toBe('10')
+      })
+    })
+
+    describe('Variable Resolution', () => {
+      it('should handle variables', () => {
+        const identifier = {
+          name: 'id',
+          kind: 'Variable' as const,
+          position: { start: 0, end: 2, line: 1, column: 1 },
+          schemaPath: ['id'],
+          context: { selectionPath: [] },
+        }
+
+        const resolution = resolver.resolveIdentifier(identifier)
+
+        expect(resolution).toBeDefined()
+        expect(resolution!.exists).toBe(true)
+        expect(resolution!.referenceUrl).toBe('/reference#variables')
+        expect(resolution!.documentation?.typeInfo).toBe('Variable')
+        expect(resolution!.documentation?.description).toBe('Query variable: $id')
+      })
+    })
+
+    describe('Directive Resolution', () => {
+      it('should resolve directives', () => {
+        const identifier = {
+          name: 'validate',
+          kind: 'Directive' as const,
+          position: { start: 0, end: 8, line: 1, column: 1 },
+          schemaPath: ['validate'],
+          context: { selectionPath: [] },
+        }
+
+        const resolution = resolver.resolveIdentifier(identifier)
+
+        expect(resolution).toBeDefined()
+        expect(resolution!.exists).toBe(true)
+        expect(resolution!.referenceUrl).toBe('/reference/directives#validate')
+        expect(resolution!.documentation?.description).toContain('Custom directive for validation')
+      })
+    })
+
+    describe('URL Generation', () => {
+      it('should generate correct URLs with custom base path', () => {
+        const customResolver = createPolenSchemaResolver(testSchema, {
+          basePath: '/docs/schema',
+        })
+
+        expect(customResolver.generateReferenceLink(['User'])).toBe('/docs/schema/User')
+        expect(customResolver.generateReferenceLink(['User', 'name'])).toBe('/docs/schema/User#name')
+        expect(customResolver.generateReferenceLink(['User', 'posts', 'first'])).toBe('/docs/schema/User#posts-first')
+      })
+
+      it('should handle fragment configuration', () => {
+        const noFragmentResolver = createPolenSchemaResolver(testSchema, {
+          includeFragments: false,
+        })
+
+        expect(noFragmentResolver.generateReferenceLink(['User', 'name'])).toBe('/reference/User')
+      })
+    })
+
+    describe('Documentation Extraction', () => {
+      it('should extract type documentation', () => {
+        const docs = resolver.getDocumentation(['User'])
+
+        expect(docs).toBeDefined()
+        expect(docs!.description).toContain('A user in the system')
+        expect(docs!.typeInfo).toBe('User')
+      })
+
+      it('should extract field documentation', () => {
+        const docs = resolver.getDocumentation(['User', 'email'])
+
+        expect(docs).toBeDefined()
+        expect(docs!.description).toContain("The user's email address")
+        expect(docs!.typeInfo).toBe('String!')
+      })
+
+      it('should extract argument documentation', () => {
+        const docs = resolver.getDocumentation(['User', 'posts', 'after'])
+
+        expect(docs).toBeDefined()
+        expect(docs!.description).toContain('Filter posts after this cursor')
+        expect(docs!.typeInfo).toBe('String')
+      })
+    })
+
+    describe('Schema Validation', () => {
+      it('should return all types', () => {
+        const types = resolver.getAllTypes()
+
+        expect(types).toContain('User')
+        expect(types).toContain('Post')
+        expect(types).toContain('CreateUserInput')
+        expect(types).toContain('Query')
+        expect(types).toContain('Mutation')
+        expect(types).not.toContain('__Schema') // Should filter introspection types
+      })
+
+      it('should check type existence', () => {
+        expect(resolver.typeExists('User')).toBe(true)
+        expect(resolver.typeExists('NonExistentType')).toBe(false)
+      })
+    })
+  })
+
+  describe('Schema-Aware Analysis', () => {
+    it('should perform complete schema-aware analysis', () => {
+      const source = `
+        query GetUser($id: ID!) {
+          user(id: $id) {
+            name
+            email
+            avatar
+          }
+        }
+      `
+
+      const result = analyzeWithSchema(source, testSchema)
+
+      expect(result.analysis.isValid).toBe(true)
+      expect(result.resolutions.size).toBeGreaterThan(0)
+      expect(result.schemaErrors.length).toBeGreaterThan(0)
+
+      // Should have deprecation warning for avatar field
+      const deprecationWarning = result.schemaErrors.find(
+        error => error.message.includes('avatar') && error.message.includes('deprecated'),
+      )
+      expect(deprecationWarning).toBeDefined()
+      expect(deprecationWarning!.severity).toBe('warning')
+    })
+
+    it('should resolve identifiers correctly', () => {
+      const source = `
+        query {
+          user(id: "123") {
+            name
+          }
+        }
+      `
+
+      const result = analyzeWithSchema(source, testSchema)
+
+      // Find the name field resolution
+      const nameField = result.analysis.identifiers.all.find(
+        id => id.name === 'name' && id.kind === 'Field',
+      )
+      expect(nameField).toBeDefined()
+
+      const nameResolutionKey = `${nameField!.position.start}-${nameField!.name}-${nameField!.kind}`
+      const nameResolution = result.resolutions.get(nameResolutionKey)
+
+      expect(nameResolution).toBeDefined()
+      expect(nameResolution!.exists).toBe(true)
+      expect(nameResolution!.referenceUrl).toBe('/reference/User#name')
+      expect(nameResolution!.documentation?.typeInfo).toBe('String!')
+    })
+  })
+})