polen 0.11.0-next.21 → 0.11.0-next.23

package/src/api/examples/type-usage-indexer.test.ts

@@ -2,82 +2,90 @@ import { Catalog } from '#lib/catalog/$'
 import { Document } from '#lib/document/$'
 import { Schema } from '#lib/schema/$'
 import { Version } from '#lib/version/$'
-import { HashMap, HashSet, Schema as S } from 'effect'
-import { buildSchema } from 'graphql'
+import { HashMap, HashSet } from 'effect'
+import { buildSchema, type GraphQLSchema } from 'graphql'
 import { describe, expect, test } from 'vitest'
 import { Example } from './schemas/example/example.js'
-import * as ExampleReferenceModule from './schemas/type-usage-index.js'
+import { ExampleReference } from './schemas/type-usage-index.js'
 import { createTypeUsageIndex, getExampleReferencesForType } from './type-usage-indexer.js'
 
-describe('type-usage-indexer', () => {
-  const schemaString = `
-    type Query {
-      user(id: ID!): User
-      users: [User!]!
-      product(id: ID!): Product
-    }
-
-    type User {
-      id: ID!
-      name: String!
-      email: String!
-    }
-
-    type Product {
-      id: ID!
-      name: String!
-      price: Float!
-    }
-
-    interface Node {
-      id: ID!
-    }
-
-    union SearchResult = User | Product
-  `
-
-  const schemaDef = buildSchema(schemaString)
-  const version1 = Version.decodeSync('1.0.0')
-  const version2 = Version.decodeSync('2.0.0')
-
-  describe('createTypeUsageIndex', () => {
-    test('indexes unversioned examples', () => {
-      const example = Example.make({
-        name: 'get-user',
-        path: 'examples/get-user.graphql',
-        document: Document.Unversioned.make({
-          document: 'query { user(id: "1") { id name } }',
-        }),
-      })
-
-      const catalog = Catalog.Unversioned.make({
-        schema: Schema.Unversioned.make({
-          definition: schemaDef,
-          revisions: [],
-        }),
-      })
-
-      const index = createTypeUsageIndex([example], catalog)
-
-      // For unversioned examples, they get indexed with the latest version (1.0.0 default)
-      const defaultVersion = Version.decodeSync('1.0.0')
+// Test schema
+const schemaString = `
+  type Query {
+    user(id: ID!): User
+    users: [User!]!
+    product(id: ID!): Product
+  }
+  type User {
+    id: ID!
+    name: String!
+    email: String!
+  }
+  type Product {
+    id: ID!
+    name: String!
+    price: Float!
+  }
+  interface Node {
+    id: ID!
+  }
+  union SearchResult = User | Product
+`
+const schemaDef = buildSchema(schemaString)
+const version1 = Version.decodeSync('1.0.0')
+const version2 = Version.decodeSync('2.0.0')
+
+// Test helpers
+const makeUnversionedCatalog = (definition: GraphQLSchema) =>
+  Catalog.Unversioned.make({
+    schema: Schema.Unversioned.make({ definition, revisions: [] }),
+  })
 
-      // Should index Query and User types
-      const queryRefs = getExampleReferencesForType(index, 'Query')
-      const userRefs = getExampleReferencesForType(index, 'User')
+const makeVersionedCatalog = (definition: GraphQLSchema, versions: Version.Version[]) =>
+  Catalog.Versioned.make({
+    entries: HashMap.make(
+      ...versions.map(v =>
+        [
+          v,
+          Schema.Versioned.make({
+            version: v,
+            definition,
+            branchPoint: null,
+            revisions: [],
+          }),
+        ] as const
+      ),
+    ),
+  })
 
-      expect(HashSet.size(queryRefs)).toBe(1)
-      expect([...queryRefs][0]).toEqual({ name: 'get-user', version: defaultVersion })
+describe('createTypeUsageIndex', () => {
+  test.for([
+    { type: 'Query', shouldExist: true },
+    { type: 'User', shouldExist: true },
+    { type: 'Product', shouldExist: false },
+  ])('indexes unversioned example - type $type indexed=$shouldExist', ({ type, shouldExist }) => {
+    const example = Example.make({
+      name: 'get-user',
+      path: 'examples/get-user.graphql',
+      document: Document.Unversioned.make({
+        document: 'query { user(id: "1") { id name } }',
+      }),
+    })
 
-      expect(HashSet.size(userRefs)).toBe(1)
-      expect([...userRefs][0]).toEqual({ name: 'get-user', version: defaultVersion })
+    const index = createTypeUsageIndex([example], makeUnversionedCatalog(schemaDef))
+    const refs = getExampleReferencesForType(index, type)
 
-      // Should not index Product type (not used)
-      const productRefs = getExampleReferencesForType(index, 'Product')
-      expect(HashSet.size(productRefs)).toBe(0)
-    })
+    if (shouldExist) {
+      expect(HashSet.size(refs)).toBe(1)
+      expect([...refs][0]).toEqual({ name: 'get-user', version: null })
+    } else {
+      expect(HashSet.size(refs)).toBe(0)
+    }
+  })
 
-    test('indexes versioned examples', () => {
+  test.for([version1, version2])(
+    'indexes versioned examples for version %s',
+    (version) => {
       const example = Example.make({
         name: 'get-user-versioned',
         path: 'examples/get-user-versioned.graphql',
@@ -89,188 +97,98 @@ describe('type-usage-indexer', () => {
         }),
       })
 
-      const catalog = Catalog.Versioned.make({
-        entries: HashMap.make(
-          [
-            version1,
-            Schema.Versioned.make({
-              version: version1,
-              definition: schemaDef,
-              branchPoint: null,
-              revisions: [],
-            }),
-          ],
-          [
-            version2,
-            Schema.Versioned.make({
-              version: version2,
-              definition: schemaDef,
-              branchPoint: null,
-              revisions: [],
-            }),
-          ],
-        ),
-      })
-
-      const index = createTypeUsageIndex([example], catalog)
-
-      // Check version 1 references
-      const userRefsV1 = getExampleReferencesForType(index, 'User', version1)
-      expect(HashSet.size(userRefsV1)).toBe(1)
-      expect([...userRefsV1][0]).toEqual({ name: 'get-user-versioned', version: version1 })
-
-      // Check version 2 references
-      const userRefsV2 = getExampleReferencesForType(index, 'User', version2)
-      expect(HashSet.size(userRefsV2)).toBe(1)
-      expect([...userRefsV2][0]).toEqual({ name: 'get-user-versioned', version: version2 })
-    })
-
-    test('deduplicates example references using HashSet', () => {
-      // Create two examples that use the same types
-      const example1 = Example.make({
-        name: 'get-user-1',
-        path: 'examples/get-user-1.graphql',
-        document: Document.Unversioned.make({
-          document: 'query { user(id: "1") { id name } }',
-        }),
-      })
+      const index = createTypeUsageIndex(
+        [example],
+        makeVersionedCatalog(schemaDef, [version1, version2]),
+      )
 
-      const example2 = Example.make({
-        name: 'get-user-2',
-        path: 'examples/get-user-2.graphql',
+      const userRefs = getExampleReferencesForType(index, 'User', version)
+      expect(HashSet.size(userRefs)).toBe(1)
+      expect([...userRefs][0]).toEqual({ name: 'get-user-versioned', version })
+    },
+  )
+
+  test('deduplicates example references using HashSet', () => {
+    const examples = ['get-user-1', 'get-user-2'].map(name =>
+      Example.make({
+        name,
+        path: `examples/${name}.graphql`,
         document: Document.Unversioned.make({
-          document: 'query { user(id: "2") { id name } }',
+          document: `query { user(id: "${name}") { id name } }`,
         }),
       })
+    )
 
-      const catalog = Catalog.Unversioned.make({
-        schema: Schema.Unversioned.make({
-          definition: schemaDef,
-          revisions: [],
-        }),
-      })
-
-      const index = createTypeUsageIndex([example1, example2], catalog)
-
-      // For unversioned examples with unversioned catalog, use default version
-      const defaultVersion = Version.decodeSync('1.0.0')
+    const index = createTypeUsageIndex(examples, makeUnversionedCatalog(schemaDef))
+    const userRefs = getExampleReferencesForType(index, 'User')
 
-      // Both examples should be indexed for User type
-      const userRefs = getExampleReferencesForType(index, 'User')
-      expect(HashSet.size(userRefs)).toBe(2)
-
-      const refNames = [...userRefs].map(ref => ref.name).sort()
-      expect(refNames).toEqual(['get-user-1', 'get-user-2'])
+    expect(HashSet.size(userRefs)).toBe(2)
+    expect([...userRefs].map(ref => ref.name).sort()).toEqual(['get-user-1', 'get-user-2'])
+    expect([...userRefs].every(ref => ref.version === null)).toBe(true)
+  })
 
-      // All should have the same version
-      for (const ref of userRefs) {
-        expect(ref.version).toEqual(defaultVersion)
-      }
+  test('handles interface and union types', () => {
+    const example = Example.make({
+      name: 'search',
+      path: 'examples/search.graphql',
+      document: Document.Unversioned.make({
+        document: `query { user(id: "1") { ... on Node { id } } }`,
+      }),
     })
 
-    test('handles interface and union types', () => {
-      const example = Example.make({
-        name: 'search',
-        path: 'examples/search.graphql',
-        document: Document.Unversioned.make({
-          document: `
-            query {
-              user(id: "1") {
-                ... on Node {
-                  id
-                }
-              }
-            }
-          `,
-        }),
-      })
-
-      const catalog = Catalog.Unversioned.make({
-        schema: Schema.Unversioned.make({
-          definition: schemaDef,
-          revisions: [],
-        }),
-      })
-
-      const index = createTypeUsageIndex([example], catalog)
+    const index = createTypeUsageIndex([example], makeUnversionedCatalog(schemaDef))
+    const nodeRefs = getExampleReferencesForType(index, 'Node')
 
-      // For unversioned example with unversioned catalog
-      const defaultVersion = Version.decodeSync('1.0.0')
+    expect(HashSet.size(nodeRefs)).toBe(1)
+    expect([...nodeRefs][0]).toEqual({ name: 'search', version: null })
+  })
 
-      // Should index the Node interface
-      const nodeRefs = getExampleReferencesForType(index, 'Node')
-      expect(HashSet.size(nodeRefs)).toBe(1)
-      expect([...nodeRefs][0]).toEqual({ name: 'search', version: defaultVersion })
+  test('indexes examples with version sets', () => {
+    const versionSet = HashSet.make(version1, version2)
+    const example = Example.make({
+      name: 'shared-example',
+      path: 'examples/shared.graphql',
+      document: Document.Versioned.make({
+        versionDocuments: HashMap.make([versionSet, 'query { user(id: "1") { id name } }']),
+      }),
     })
 
-    test('indexes examples with version sets', () => {
-      // Create a versioned document where multiple versions share the same document
-      const versionSet = HashSet.make(version1, version2)
-      const example = Example.make({
-        name: 'shared-example',
-        path: 'examples/shared.graphql',
-        document: Document.Versioned.make({
-          versionDocuments: HashMap.make(
-            [versionSet, 'query { user(id: "1") { id name } }'],
-          ),
-        }),
-      })
-
-      const catalog = Catalog.Versioned.make({
-        entries: HashMap.make(
-          [
-            version1,
-            Schema.Versioned.make({
-              version: version1,
-              definition: schemaDef,
-              branchPoint: null,
-              revisions: [],
-            }),
-          ],
-          [
-            version2,
-            Schema.Versioned.make({
-              version: version2,
-              definition: schemaDef,
-              branchPoint: null,
-              revisions: [],
-            }),
-          ],
-        ),
-      })
-
-      const index = createTypeUsageIndex([example], catalog)
-
-      // Both versions should have the same example reference
-      const userRefsV1 = getExampleReferencesForType(index, 'User', version1)
-      expect(HashSet.size(userRefsV1)).toBe(1)
-      expect([...userRefsV1][0]).toEqual({ name: 'shared-example', version: version1 })
+    const index = createTypeUsageIndex(
+      [example],
+      makeVersionedCatalog(schemaDef, [version1, version2]),
+    )
 
-      const userRefsV2 = getExampleReferencesForType(index, 'User', version2)
-      expect(HashSet.size(userRefsV2)).toBe(1)
-      expect([...userRefsV2][0]).toEqual({ name: 'shared-example', version: version2 })
-    })
+    // Both versions should have the same example reference
+    for (const version of [version1, version2]) {
+      const userRefs = getExampleReferencesForType(index, 'User', version)
+      expect(HashSet.size(userRefs)).toBe(1)
+      expect([...userRefs][0]).toEqual({ name: 'shared-example', version })
+    }
   })
+})
 
-  describe('ExampleReference', () => {
-    test('ExampleReference structural equality works with HashSet', () => {
-      // Use the Schema's make constructor to create Data instances with proper Equal/Hash support
-      const version = Version.decodeSync('1.0.0')
-
-      const ref1 = ExampleReferenceModule.ExampleReference.make({ name: 'example1', version })
-      const ref2 = ExampleReferenceModule.ExampleReference.make({ name: 'example1', version })
-      const ref3 = ExampleReferenceModule.ExampleReference.make({ name: 'example2', version })
-
-      // Create a HashSet and add references
-      let set = HashSet.empty<ExampleReferenceModule.ExampleReference>()
-      set = HashSet.add(set, ref1)
-      set = HashSet.add(set, ref2) // Should not increase size (duplicate)
-      set = HashSet.add(set, ref3)
-
-      // Should have only 2 unique references
-      expect(HashSet.size(set)).toBe(2)
-      expect(HashSet.has(set, ExampleReferenceModule.ExampleReference.make({ name: 'example1', version }))).toBe(true)
-      expect(HashSet.has(set, ExampleReferenceModule.ExampleReference.make({ name: 'example2', version }))).toBe(true)
-    })
+describe('ExampleReference', () => {
+  test('structural equality works with HashSet', () => {
+    const version = Version.decodeSync('1.0.0')
+
+    // Create set with duplicates to test deduplication
+    const refs = [
+      ExampleReference.make({ name: 'example1', version }),
+      ExampleReference.make({ name: 'example1', version }), // duplicate
+      ExampleReference.make({ name: 'example2', version }),
+      ExampleReference.make({ name: 'example3', version: null }),
+      ExampleReference.make({ name: 'example3', version: null }), // duplicate
+    ]
+
+    const set = refs.reduce(
+      (acc, ref) => HashSet.add(acc, ref),
+      HashSet.empty<ExampleReference>(),
+    )
+
+    // Should have only 3 unique references
+    expect(HashSet.size(set)).toBe(3)
+    expect(HashSet.has(set, ExampleReference.make({ name: 'example1', version }))).toBe(true)
+    expect(HashSet.has(set, ExampleReference.make({ name: 'example2', version }))).toBe(true)
+    expect(HashSet.has(set, ExampleReference.make({ name: 'example3', version: null }))).toBe(true)
   })
 })

package/src/api/examples/type-usage-indexer.ts

@@ -1,19 +1,11 @@
 import { Catalog } from '#lib/catalog/$'
 import { Document } from '#lib/document/$'
+import { Grafaid } from '#lib/grafaid'
+import { Schema } from '#lib/schema/$'
 import { Version } from '#lib/version/$'
-import { HashMap, HashSet, Option } from 'effect'
+import { Effect, HashMap, HashSet, Option } from 'effect'
 import { Schema as S } from 'effect'
-import {
-  type DocumentNode,
-  getNamedType,
-  type GraphQLSchema,
-  isInterfaceType,
-  isObjectType,
-  isUnionType,
-  Kind,
-  parse,
-  visit,
-} from 'graphql'
+import { getNamedType, type GraphQLSchema, isInterfaceType, isObjectType, isUnionType, Kind, visit } from 'graphql'
 import type { Example } from './schemas/example/example.js'
 import { ExampleReference, type TypeUsageIndex, UNVERSIONED_KEY, type VersionKey } from './schemas/type-usage-index.js'
 
@@ -30,20 +22,17 @@ import { ExampleReference, type TypeUsageIndex, UNVERSIONED_KEY, type VersionKey
  * - For interfaces: both the interface and all implementations
  * - For unions: both the union and all member types
  */
-const extractTypesFromQuery = (
+const extractTypesFromDocument = (
   documentString: string,
   schema: GraphQLSchema,
 ): Set<string> => {
   const types = new Set<string>()
   const visitedTypes = new Set<string>() // Prevent infinite recursion
 
-  let ast: DocumentNode
-  try {
-    ast = parse(documentString)
-  } catch {
-    // If parsing fails, return empty set
-    return types
-  }
+  // Use Effect to parse, but handle it synchronously since this function is synchronous
+  const ast = Effect.runSync(
+    Grafaid.Parse.parseDocument(documentString, { source: 'example' }),
+  )
 
   // Helper to add a type and its related types
   const addType = (typeName: string) => {
@@ -164,6 +153,43 @@ const extractTypesFromQuery = (
 // Index Creation
 // ============================================================================
 
+/**
+ * Process a document version and add its type usage to the index.
+ *
+ * @param example - The example being processed
+ * @param documentContent - The document content to extract types from
+ * @param schema - The schema containing version and definition
+ * @param hashMap - The current type usage index
+ * @returns Updated type usage index
+ */
+const processDocumentVersion = (
+  example: Example,
+  documentContent: string,
+  schema: Schema.Schema,
+  hashMap: TypeUsageIndex,
+): TypeUsageIndex => {
+  const types = extractTypesFromDocument(documentContent, schema.definition)
+
+  // Get version from schema (null for unversioned)
+  const version = Schema.getVersion(schema) ?? null
+
+  // Map to storage key: use version or UNVERSIONED_KEY
+  const versionKey: VersionKey = version ?? UNVERSIONED_KEY
+
+  // Create reference with nullable version
+  const exampleRef = ExampleReference.make({
+    name: example.name,
+    version,
+  })
+
+  let updatedMap = hashMap
+  for (const typeName of types) {
+    updatedMap = addExampleToIndex(updatedMap, versionKey, typeName, exampleRef)
+  }
+
+  return updatedMap
+}
+
 /**
  * Create a type usage index from examples and schemas.
  *
@@ -174,52 +200,42 @@ export const createTypeUsageIndex = (
   examples: readonly Example[],
   schemasCatalog: Catalog.Catalog,
 ): TypeUsageIndex => {
-  let index = HashMap.empty<VersionKey, HashMap.HashMap<string, HashSet.HashSet<ExampleReference>>>()
+  let hashMap = HashMap.empty<VersionKey, HashMap.HashMap<string, HashSet.HashSet<ExampleReference>>>()
 
   for (const example of examples) {
-    // Process based on document type
     if (Document.Unversioned.is(example.document)) {
-      // Unversioned document
+      // For unversioned: get latest schema from catalog
       const schema = Catalog.getLatest(schemasCatalog)
-      const types = extractTypesFromQuery(example.document.document, schema.definition)
-
-      for (const typeName of types) {
-        // For unversioned, use the latest version from the catalog
-        const latestVersion = Option.getOrElse(
-          Catalog.getLatestVersion(schemasCatalog),
-          () => Version.fromString('1.0.0'),
-        )
-        index = addExampleToIndex(index, UNVERSIONED_KEY, typeName, example, latestVersion)
-      }
+      hashMap = processDocumentVersion(
+        example,
+        example.document.document,
+        schema,
+        hashMap,
+      )
     } else if (Document.Versioned.is(example.document)) {
-      // Versioned document - process each version covered
+      // For versioned: process each version
       const allVersions = Document.Versioned.getAllVersions(example.document)
 
       for (const version of allVersions) {
-        // Use centralized resolution to get schema for version
         const schemaOption = Option.liftThrowable(
           () => Catalog.resolveCatalogSchema(schemasCatalog, version),
         )()
-        if (Option.isNone(schemaOption)) {
-          // Skip if version not found in catalog
-          continue
-        }
-        const schema = schemaOption.value
-
-        const documentStringOption = Document.Versioned.getContentForVersion(example.document, version)
-        if (Option.isNone(documentStringOption)) continue
-        const documentString = documentStringOption.value
+        if (Option.isNone(schemaOption)) continue
 
-        const types = extractTypesFromQuery(documentString, schema.definition)
+        const documentOption = Document.Versioned.getContentForVersion(example.document, version)
+        if (Option.isNone(documentOption)) continue
 
-        for (const typeName of types) {
-          index = addExampleToIndex(index, version, typeName, example, version)
-        }
+        hashMap = processDocumentVersion(
+          example,
+          documentOption.value,
+          schemaOption.value,
+          hashMap,
+        )
       }
     }
   }
 
-  return index
+  return hashMap
 }
 
 /**
@@ -229,12 +245,8 @@ const addExampleToIndex = (
   index: TypeUsageIndex,
   versionKey: VersionKey,
   typeName: string,
-  example: Example,
-  version: Version.Version,
+  exampleRef: ExampleReference,
 ): TypeUsageIndex => {
-  // Create lightweight reference using the schema's make constructor
-  const exampleRef = ExampleReference.make({ name: example.name, version })
-
   // Get or create the version's type map
   const versionMap = HashMap.get(index, versionKey).pipe(
     Option.getOrElse(HashMap.empty<string, HashSet.HashSet<S.Schema.Type<typeof ExampleReference>>>),

package/src/api/schema/$.test.ts

@@ -112,7 +112,7 @@ const createTestConfig = (overrides?: Partial<Config.Config>): Config.Config =>
 // Helper to build GraphQL schema using Grafaid to avoid realm issues
 const buildSchemaWithGrafaid = (sdl: string) =>
   Effect.gen(function*() {
-    const ast = yield* Grafaid.Schema.AST.parse(sdl)
+    const ast = yield* Grafaid.Parse.parseSchema(sdl, { source: 'test' })
     return yield* Grafaid.Schema.fromAST(ast)
   })
 

package/src/api/schema/input-sources/directory.ts

@@ -186,11 +186,11 @@ const read = (
         Effect.gen(function*() {
           const fs = yield* FileSystem
           const content = yield* fs.readFileString(revisionInput.filePath)
-          const ast = yield* Grafaid.Schema.AST.parse(content).pipe(
+          const ast = yield* Grafaid.Parse.parseSchema(content, { source: revisionInput.filePath }).pipe(
             Effect.mapError((error) =>
               new InputSourceError({
                 source: 'directory',
-                message: `Failed to parse schema file ${revisionInput.filePath}: ${error}`,
+                message: error.message,
                 cause: error,
               })
             ),
@@ -199,7 +199,7 @@ const read = (
             Effect.mapError((error) =>
               new InputSourceError({
                 source: 'directory',
-                message: `Failed to build schema from ${revisionInput.filePath}: ${error}`,
+                message: error.message,
                 cause: error,
               })
             ),

package/src/api/schema/input-sources/file.ts

@@ -73,11 +73,11 @@ export const loader = InputSource.createEffect({
       const fs = yield* FileSystem
       const content = yield* fs.readFileString(config.path)
 
-      const ast = yield* Grafaid.Schema.AST.parse(content).pipe(
+      const ast = yield* Grafaid.Parse.parseSchema(content, { source: config.path }).pipe(
         Effect.mapError((error) =>
           new InputSource.InputSourceError({
             source: 'file',
-            message: `Failed to parse schema file: ${error}`,
+            message: error.message,
             cause: error,
           })
         ),
@@ -86,7 +86,7 @@ export const loader = InputSource.createEffect({
         Effect.mapError((error) =>
           new InputSource.InputSourceError({
             source: 'file',
-            message: `Failed to build schema: ${error}`,
+            message: error.message,
             cause: error,
           })
         ),