polen 0.11.0-next.16 → 0.11.0-next.18

package/src/api/examples/diagnostic/validator.ts

@@ -1,9 +1,9 @@
 import { Catalog as SchemaCatalog } from '#lib/catalog/$'
 import { Document } from '#lib/document/$'
+import { Schema } from '#lib/schema/$'
 import { Version } from '#lib/version/$'
-import { HashMap, Match, Option } from 'effect'
-import { Array } from 'effect'
-import type { GraphQLError, GraphQLSchema } from 'graphql'
+import { Array, Either, Match, Schema as S } from 'effect'
+import type { DocumentNode, GraphQLError } from 'graphql'
 import { parse, specifiedRules, validate } from 'graphql'
 import { Example } from '../schemas/example/$.js'
 import type { DiagnosticValidationError } from './diagnostic.js'
@@ -15,6 +15,35 @@ import { makeDiagnosticValidationError } from './diagnostic.js'
 
 export type ValidationDiagnostic = DiagnosticValidationError
 
+// ============================================================================
+// Schemas
+// ============================================================================
+
+const GraphQLErrorData = S.Struct({
+  message: S.String,
+  locations: S.optional(S.Array(S.Struct({
+    line: S.Number,
+    column: S.Number,
+  }))),
+})
+
+type GraphQLErrorData = S.Schema.Type<typeof GraphQLErrorData>
+
+// ============================================================================
+// Safe Parsing
+// ============================================================================
+
+/**
+ * Safely parse a GraphQL document without throwing.
+ * Returns an Either with the document on success or error on failure.
+ */
+const parseDocumentSafe = (content: string): Either.Either<DocumentNode, GraphQLError> => {
+  return Either.try({
+    try: () => parse(content),
+    catch: (error) => error as GraphQLError,
+  })
+}
+
 // ============================================================================
 // Validation
 // ============================================================================
@@ -32,71 +61,76 @@ export const validateExamples = (
 ): ValidationDiagnostic[] => {
   const diagnostics: ValidationDiagnostic[] = []
 
-  return Match.value(catalog).pipe(
-    Match.tagsExhaustive({
-      CatalogVersioned: (versioned) => {
-        const schemaVersions = versioned.entries.map(e => e.version)
-
-        for (const example of examples) {
-          Match.value(example.document).pipe(
-            Match.tagsExhaustive({
-              DocumentVersioned: (doc) => {
-                // Validate each version against its corresponding schema
-                for (const entry of versioned.entries) {
-                  const content = Document.Versioned.getContentForVersion(doc, entry.version)
-                  if (content) {
-                    const versionStr = Version.encodeSync(entry.version)
-                    validateDocument(
-                      example.name,
-                      example.path,
-                      versionStr,
-                      content,
-                      entry.definition,
-                      diagnostics,
-                    )
-                  }
-                }
-                return undefined
-              },
-              DocumentUnversioned: (doc) => {
-                const latestEntry = versioned.entries[0]!
-                validateDocument(
-                  example.name,
-                  example.path,
-                  'default',
-                  doc.document,
-                  latestEntry.definition,
-                  diagnostics,
-                )
-                return undefined
-              },
-            }),
-          )
-        }
-
-        return diagnostics
-      },
-      CatalogUnversioned: (unversioned) => {
-        // For unversioned catalog, only unversioned documents make sense
-        for (const example of examples) {
-          if (example.document._tag === 'DocumentUnversioned') {
-            validateDocument(
-              example.name,
-              example.path,
-              'default',
-              example.document.document,
-              unversioned.schema.definition,
-              diagnostics,
+  Array.forEach(examples, (example) => {
+    if (example.document._tag === 'DocumentVersioned') {
+      // Versioned document: iterate all versions and let utility handle compatibility
+      const documentVersions = Document.Versioned.getAllVersions(example.document)
+      let versionMismatchDetected = false
+
+      Array.forEach(documentVersions, (version) => {
+        // Skip remaining versions if we already detected a version mismatch
+        if (versionMismatchDetected) return
+
+        const result = Document.resolveDocumentAndSchema(
+          example.document,
+          catalog,
+          version, // Pass each version as VersionCoverage
+        )
+
+        Either.match(result, {
+          onLeft: (error) => {
+            // Pattern match on error types - all errors are now tagged
+            Match.value(error).pipe(
+              Match.when({ _tag: 'VersionCoverageMismatchError' }, (err) => {
+                diagnostics.push(makeDiagnosticValidationError({
+                  message: `Example "${example.name}" has versioned content but catalog is unversioned`,
+                  example: { name: example.name, path: example.path },
+                  version: undefined,
+                  errors: [{ message: err.reason }],
+                }))
+                // Set flag to skip remaining versions - all will have same error
+                versionMismatchDetected = true
+              }),
+              Match.when({ _tag: 'VersionNotFoundInDocumentError' }, () => {
+                // Skip silently - version not found in document
+              }),
+              Match.when({ _tag: 'VersionNotFoundInCatalogError' }, () => {
+                // Skip silently - version not found in catalog
+              }),
+              Match.when({ _tag: 'EmptyCatalogError' }, () => {
+                // Skip silently - catalog has no entries
+              }),
+              Match.exhaustive,
             )
+          },
+          onRight: ({ content, schema }) => {
+            if (schema) {
+              validateDocument(example, schema, content, diagnostics)
+            }
+          },
+        })
+      })
+    } else {
+      // Unversioned document: call without version coverage
+      const result = Document.resolveDocumentAndSchema(
+        example.document,
+        catalog,
+      )
+
+      Either.match(result, {
+        onLeft: () => {
+          // Resolution failed - skip silently
+        },
+        onRight: ({ content, schema }) => {
+          if (schema) {
+            validateDocument(example, schema, content, diagnostics)
           }
-          // Versioned/PartiallyVersioned documents with unversioned catalog don't make sense
-          // These should be caught by other diagnostics
-        }
+        },
+      })
+    }
+  })
 
-        return diagnostics
-      },
-    }),
-  )
+  return diagnostics
 }
 
 // ============================================================================
@@ -107,54 +141,67 @@ export const validateExamples = (
  * Validate a single document and add diagnostics if needed.
  */
 const validateDocument = (
-  exampleName: string,
-  examplePath: string,
-  version: string,
+  example: Example.Example,
+  schema: Schema.Schema,
   content: string,
-  schema: GraphQLSchema,
   diagnostics: ValidationDiagnostic[],
 ): void => {
-  try {
-    // Parse the GraphQL document
-    const document = parse(content)
-
-    // Validate against the schema
-    const errors = validate(schema, document, specifiedRules)
-
-    if (errors.length > 0) {
-      diagnostics.push(makeDiagnosticValidationError({
-        message: formatValidationMessage(exampleName, version, errors),
-        example: { name: exampleName, path: examplePath },
-        version,
-        errors: errors.map(formatGraphQLError),
-      }))
-    }
-  } catch (parseError) {
-    // Parse errors are also validation errors
+  // Extract version from schema (undefined for unversioned)
+  const version = Schema.getVersion(schema)
+
+  // Parse the document safely
+  const parseResult = parseDocumentSafe(content)
+
+  if (Either.isLeft(parseResult)) {
+    // Handle parse errors
+    diagnostics.push(makeDiagnosticValidationError({
+      message: formatParseError(example.name, version),
+      example: { name: example.name, path: example.path },
+      version,
+      errors: [{ message: parseResult.left.message }],
+    }))
+    return
+  }
+
+  // Validate the parsed document against the schema
+  const errors = validate(schema.definition, parseResult.right, specifiedRules)
+
+  if (Array.isNonEmptyReadonlyArray(errors)) {
     diagnostics.push(makeDiagnosticValidationError({
-      message: `Example "${exampleName}" (${version}) has invalid GraphQL syntax`,
-      example: { name: exampleName, path: examplePath },
+      message: formatValidationMessage(example.name, version, errors),
+      example: { name: example.name, path: example.path },
       version,
-      errors: [{ message: String(parseError) }],
+      errors: errors.map(formatGraphQLError),
     }))
   }
 }
 
+/**
+ * Format a parse error message for an example.
+ */
+const formatParseError = (
+  exampleId: string,
+  version: Version.Version | undefined,
+): string => {
+  const versionStr = version ? ` (${Version.encodeSync(version)})` : ''
+  return `Example "${exampleId}"${versionStr} has invalid GraphQL syntax`
+}
+
 /**
  * Format a validation message for an example.
  */
 const formatValidationMessage = (
   exampleId: string,
-  version: string,
-  errors: readonly GraphQLError[],
+  version: Version.Version | undefined,
+  errors: Array.NonEmptyReadonlyArray<GraphQLError>,
 ): string => {
-  const versionStr = version === 'default' ? '' : ` (${version})`
+  const versionStr = version ? ` (${Version.encodeSync(version)})` : ''
   const errorCount = errors.length
   const errorWord = errorCount === 1 ? 'error' : 'errors'
 
-  // Include the first error message for context
-  const firstError = errors[0]
-  const preview = firstError ? `: ${firstError.message}` : ''
+  // Include the first error message for context - always safe with NonEmptyArray
+  const firstError = Array.headNonEmpty(errors)
+  const preview = `: ${firstError.message}`
 
   return `Example "${exampleId}"${versionStr} has ${errorCount} validation ${errorWord}${preview}`
 }
@@ -162,17 +209,13 @@ const formatValidationMessage = (
 /**
  * Format a GraphQL error for diagnostic reporting.
  */
-const formatGraphQLError = (error: GraphQLError): {
-  message: string
-  locations?: Array<{ line: number; column: number }>
-} => ({
-  message: error.message,
-  ...(error.locations
-    ? {
+const formatGraphQLError = (error: GraphQLError): GraphQLErrorData =>
+  GraphQLErrorData.make({
+    message: error.message,
+    ...(error.locations && {
       locations: error.locations.map(loc => ({
         line: loc.line,
         column: loc.column,
       })),
-    }
-    : {}),
-})
+    }),
+  })

package/src/api/examples/filter.ts

@@ -1,3 +1,4 @@
+import { HashSet } from 'effect'
 import type { ExampleName, ExampleSelection } from './config.js'
 import { Example } from './schemas/example/$.js'
 
@@ -28,14 +29,14 @@ export const filterExamplesBySelection = (
 
   // Handle include pattern
   if ('include' in selection) {
-    const includeSet = new Set<ExampleName>(selection.include)
-    return examples.filter(example => includeSet.has(example.name as ExampleName))
+    const includeSet = HashSet.fromIterable(selection.include)
+    return examples.filter(example => HashSet.has(includeSet, example.name as ExampleName))
   }
 
   // Handle exclude pattern
   if ('exclude' in selection) {
-    const excludeSet = new Set<ExampleName>(selection.exclude)
-    return examples.filter(example => !excludeSet.has(example.name as ExampleName))
+    const excludeSet = HashSet.fromIterable(selection.exclude)
+    return examples.filter(example => !HashSet.has(excludeSet, example.name as ExampleName))
   }
 
   // Fallback to all examples if selection pattern is not recognized
@@ -69,12 +70,14 @@ export const shouldDisplayExample = (
 
   // Handle include pattern
   if ('include' in selection) {
-    return selection.include.includes(exampleName)
+    const includeSet = HashSet.fromIterable(selection.include)
+    return HashSet.has(includeSet, exampleName)
   }
 
   // Handle exclude pattern
   if ('exclude' in selection) {
-    return !selection.exclude.includes(exampleName)
+    const excludeSet = HashSet.fromIterable(selection.exclude)
+    return !HashSet.has(excludeSet, exampleName)
   }
 
   // Fallback to show if selection pattern is not recognized