polen 0.10.0-next.13 → 0.10.0-next.3

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

@@ -1,365 +0,0 @@
-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!')
-    })
-  })
-})