polen 0.10.0 → 0.11.0-next.1

package/src/lib/graphql-document/positioning-simple.ts

@@ -1,260 +0,0 @@
-/**
- * Layer 3: Simplified Positioning & Layout Engine
- *
- * Maps GraphQL AST positions to DOM coordinates for overlay placement.
- * This simplified version focuses on working with Polen's existing infrastructure.
- */
-
-import type { Identifier } from './types.js'
-
-/**
- * DOM position for rendering overlays
- */
-export interface DOMPosition {
-  /** Distance from top of container in pixels */
-  top: number
-  /** Distance from left of container in pixels */
-  left: number
-  /** Width of the identifier in pixels */
-  width: number
-  /** Height of the identifier in pixels */
-  height: number
-}
-
-/**
- * Position calculation result
- */
-export interface PositionResult {
-  /** The calculated DOM position */
-  position: DOMPosition
-  /** The identifier this position is for */
-  identifier: Identifier
-}
-
-/**
- * Simplified position calculator for syntax-highlighted code
- *
- * This version uses a more straightforward approach:
- * 1. Find the line element by line number
- * 2. Search for the identifier text within that line
- * 3. Create a span around the identifier for positioning
- *
- * This approach modifies the DOM but is more reliable for testing
- * and works well with React's reconciliation.
- */
-export class SimplePositionCalculator {
-  /**
-   * Prepare a code block for positioning by wrapping identifiers in spans
-   */
-  prepareCodeBlock(
-    containerElement: Element,
-    identifiers: Identifier[],
-  ): void {
-    // Get the full text content of the container
-    const fullText = containerElement.textContent || ``
-    const lines = fullText.split(`\n`)
-
-    // Build a map of line start positions in the full text
-    const lineStartPositions: number[] = [0]
-    for (let i = 0; i < lines.length - 1; i++) {
-      const lineLength = lines[i]?.length ?? 0
-      lineStartPositions.push(lineStartPositions[i]! + lineLength + 1) // +1 for newline
-    }
-
-    // Process identifiers by line
-    for (const identifier of identifiers) {
-      const lineIndex = identifier.position.line - 1
-      if (lineIndex >= lines.length || lineIndex < 0) continue
-
-      const lineText = lines[lineIndex]
-      if (!lineText) continue
-
-      const columnIndex = identifier.position.column - 1
-
-      // Check if the identifier exists at the expected position
-      if (lineText.substring(columnIndex).startsWith(identifier.name)) {
-        // Calculate the absolute position in the full text
-        const lineStartPosition = lineStartPositions[lineIndex] ?? 0
-        const absolutePosition = lineStartPosition + columnIndex
-
-        // Check if already wrapped at this specific position
-        const existingWrapped = containerElement.querySelectorAll(`[data-graphql-id]`)
-        let alreadyWrapped = false
-        for (const wrapped of existingWrapped) {
-          if (wrapped.textContent === identifier.name) {
-            const startPos = parseInt(wrapped.getAttribute(`data-graphql-start`) || `0`)
-            if (startPos === identifier.position.start) {
-              alreadyWrapped = true
-              break
-            }
-          }
-        }
-        if (alreadyWrapped) continue
-
-        // Create wrapper span
-        const wrapper = document.createElement(`span`)
-        const id = `${identifier.position.start}-${identifier.name}-${identifier.kind}`
-        wrapper.setAttribute(`data-graphql-id`, id)
-        wrapper.setAttribute(`data-graphql-name`, identifier.name)
-        wrapper.setAttribute(`data-graphql-kind`, identifier.kind)
-        wrapper.setAttribute(`data-graphql-start`, String(identifier.position.start))
-        wrapper.setAttribute(`data-graphql-end`, String(identifier.position.end))
-        wrapper.setAttribute(`data-graphql-line`, String(identifier.position.line))
-        wrapper.setAttribute(`data-graphql-column`, String(identifier.position.column))
-        wrapper.setAttribute(`data-graphql-path`, identifier.schemaPath.join(`,`))
-
-        // Find the position in the container and wrap the text
-        const walker = document.createTreeWalker(
-          containerElement,
-          NodeFilter.SHOW_TEXT,
-          null,
-        )
-
-        let currentPos = 0
-        let node: Node | null
-
-        while (node = walker.nextNode()) {
-          const textNode = node as Text
-          const text = textNode.textContent || ``
-
-          // Check if this text node contains our identifier
-          if (currentPos <= absolutePosition && absolutePosition < currentPos + text.length) {
-            const relativePos = absolutePosition - currentPos
-
-            if (text.substring(relativePos).startsWith(identifier.name)) {
-              // Split the text node
-              const before = text.substring(0, relativePos)
-              const identifierText = identifier.name
-              const after = text.substring(relativePos + identifierText.length)
-
-              const parent = textNode.parentNode!
-
-              if (before) {
-                parent.insertBefore(document.createTextNode(before), textNode)
-              }
-
-              wrapper.textContent = identifierText
-              parent.insertBefore(wrapper, textNode)
-
-              if (after) {
-                parent.insertBefore(document.createTextNode(after), textNode)
-              }
-
-              parent.removeChild(textNode)
-              break
-            }
-          }
-
-          currentPos += text.length
-        }
-      }
-    }
-  }
-
-  /**
-   * Get positions of all wrapped identifiers
-   */
-  getIdentifierPositions(
-    containerElement: Element,
-    relativeToElement?: Element,
-  ): Map<string, PositionResult> {
-    const results = new Map<string, PositionResult>()
-
-    // Find all wrapped identifiers
-    const wrappedIdentifiers = containerElement.querySelectorAll(`[data-graphql-id]`)
-
-    // Use the provided element for relative positioning, or the container itself
-    const referenceElement = relativeToElement || containerElement
-
-    for (const element of wrappedIdentifiers) {
-      const id = element.getAttribute(`data-graphql-id`)
-      if (!id) continue
-
-      // Get position relative to the reference element
-      const referenceRect = referenceElement.getBoundingClientRect()
-      const elementRect = element.getBoundingClientRect()
-
-      const position: DOMPosition = {
-        top: elementRect.top - referenceRect.top,
-        left: elementRect.left - referenceRect.left,
-        width: elementRect.width,
-        height: elementRect.height,
-      }
-
-      // Reconstruct identifier from data attributes
-      const identifier: Identifier = {
-        name: element.getAttribute(`data-graphql-name`) || ``,
-        kind: (element.getAttribute(`data-graphql-kind`) || `Field`) as Identifier[`kind`],
-        position: {
-          start: parseInt(element.getAttribute(`data-graphql-start`) || `0`),
-          end: parseInt(element.getAttribute(`data-graphql-end`) || `0`),
-          line: parseInt(element.getAttribute(`data-graphql-line`) || `1`),
-          column: parseInt(element.getAttribute(`data-graphql-column`) || `1`),
-        },
-        schemaPath: (element.getAttribute(`data-graphql-path`) || ``).split(`,`).filter(Boolean),
-        context: { selectionPath: [] },
-      }
-
-      results.set(id, { position, identifier })
-    }
-
-    return results
-  }
-}
-
-/**
- * Create invisible overlay for a position
- */
-export const createSimpleOverlay = (
-  position: DOMPosition,
-  identifier: Identifier,
-  options?: {
-    onClick?: (identifier: Identifier) => void
-    onHover?: (identifier: Identifier, event: MouseEvent) => void
-    className?: string
-  },
-): HTMLElement => {
-  const overlay = document.createElement(`div`)
-
-  // Base styles for positioning
-  overlay.style.position = `absolute`
-  overlay.style.top = `${position.top}px`
-  overlay.style.left = `${position.left}px`
-  overlay.style.width = `${position.width}px`
-  overlay.style.height = `${position.height}px`
-  overlay.style.cursor = `pointer`
-  overlay.style.zIndex = `10`
-
-  // Add custom class if provided
-  if (options?.className) {
-    overlay.className = options.className
-  }
-
-  // Data attributes
-  overlay.setAttribute(`data-graphql-overlay`, `true`)
-  overlay.setAttribute(`data-graphql-name`, identifier.name)
-  overlay.setAttribute(`data-graphql-kind`, identifier.kind)
-
-  // Event handlers
-  if (options?.onClick) {
-    overlay.addEventListener(`click`, (e) => {
-      e.preventDefault()
-      options.onClick!(identifier)
-    })
-  }
-
-  if (options?.onHover) {
-    overlay.addEventListener(`mouseenter`, (e) => {
-      options.onHover!(identifier, e)
-    })
-  }
-
-  return overlay
-}
-
-/**
- * Factory function for position calculator
- */
-export const createSimplePositionCalculator = (): SimplePositionCalculator => {
-  return new SimplePositionCalculator()
-}

package/src/lib/graphql-document/schema-context.tsx

@@ -1,20 +0,0 @@
-import type { GraphQLSchema } from 'graphql'
-import React from 'react'
-
-export const GraphQLSchemaContext = React.createContext<GraphQLSchema | null>(null)
-
-export const useGraphQLSchema = () => {
-  const schema = React.useContext(GraphQLSchemaContext)
-  return schema
-}
-
-export const GraphQLSchemaProvider: React.FC<React.PropsWithChildren<{ schema: GraphQLSchema | null }>> = ({
-  children,
-  schema,
-}) => {
-  return (
-    <GraphQLSchemaContext.Provider value={schema}>
-      {children}
-    </GraphQLSchemaContext.Provider>
-  )
-}

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.js'
-
-// 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!')
-    })
-  })
-})