polen 0.10.0 → 0.11.0-next.2

package/src/api/vite/plugins/schema-assets.ts

@@ -0,0 +1,317 @@
+import type { Config } from '#api/config/index'
+import { SchemaAugmentation } from '#api/schema-augmentation/index'
+import { createSchemaSource } from '#api/schema-source/index'
+import { Schema } from '#api/schema/index'
+import type { Vite } from '#dep/vite/index'
+import { Grafaid } from '#lib/grafaid/index'
+import { ViteVirtual } from '#lib/vite-virtual/index'
+import { debugPolen } from '#singletons/debug'
+import { Cache } from '@wollybeard/kit'
+import * as NodeFs from 'node:fs/promises'
+import * as NodePath from 'node:path'
+import { polenVirtual } from '../vi.js'
+
+export const viProjectSchemaMetadata = polenVirtual([`project`, `schema-metadata`])
+
+/**
+ * Vite plugin that generates JSON assets for GraphQL schemas at build time.
+ *
+ * This plugin:
+ * - Reads GraphQL schema files from the project
+ * - Applies schema augmentations
+ * - Converts schemas to AST format and emits as JSON assets
+ * - Creates a metadata file with available versions
+ * - Provides a virtual module for accessing schema metadata
+ *
+ * The generated assets enable client-side loading of different schema versions
+ * without requiring all schemas to be bundled into the main JavaScript bundle.
+ *
+ * @param config - Polen configuration object
+ * @returns Vite plugin instance
+ */
+export const SchemaAssets = (config: Config.Config): Vite.Plugin => {
+  const debug = debugPolen.sub(`vite-plugin:schema-assets`)
+  let viteServer: Vite.ViteDevServer | null = null
+
+  // Helper to load and process schema data
+  const loadAndProcessSchemaData = Cache.memoize(async () => {
+    const schemaData = await Schema.readOrThrow({
+      ...config.schema,
+      projectRoot: config.paths.project.rootDir,
+    })
+
+    if (!schemaData) {
+      const metadata: Schema.SchemaMetadata = { hasSchema: false, versions: [] }
+      return {
+        schemaData: null,
+        metadata,
+      }
+    }
+
+    // Apply augmentations
+    schemaData.forEach(version => {
+      SchemaAugmentation.apply(version.after, config.schemaAugmentations)
+    })
+
+    // Build metadata
+    const versionStrings: string[] = []
+    for (const [index, version] of schemaData.entries()) {
+      const versionName = index === 0 ? Schema.VERSION_LATEST : Schema.dateToVersionString(version.date)
+      versionStrings.push(versionName)
+    }
+
+    const metadata = {
+      hasSchema: true,
+      versions: versionStrings,
+    }
+
+    debug(`schemaDataLoaded`, { versionCount: schemaData.length })
+
+    return {
+      schemaData,
+      metadata,
+    }
+  })
+
+  // Helper to create schema source with filesystem IO
+  const createDevSchemaSource = (metadata: Schema.SchemaMetadata) => {
+    return createSchemaSource({
+      io: {
+        read: async () => {
+          throw new Error('Read not supported in dev asset writer')
+        },
+        write: async (path: string, content: string) => {
+          await NodeFs.writeFile(path, content, 'utf-8')
+        },
+        clearDirectory: async (path: string) => {
+          try {
+            const files = await NodeFs.readdir(path)
+            await Promise.all(files.map(file => NodeFs.rm(NodePath.join(path, file), { force: true })))
+          } catch (error) {
+            // Directory might not exist, which is fine
+          }
+        },
+        removeFile: async (path: string) => {
+          await NodeFs.rm(path, { force: true })
+        },
+      },
+      versions: metadata.versions,
+      assetsPath: config.paths.framework.devAssets.absolute,
+    })
+  }
+
+  // Helper to write assets using schema-source API
+  const writeDevAssets = async (
+    schemaData: Awaited<ReturnType<typeof Schema.readOrThrow>>,
+    metadata: Schema.SchemaMetadata,
+  ) => {
+    if (!schemaData) return
+
+    const devAssetsDir = config.paths.framework.devAssets.schemas
+    await NodeFs.mkdir(devAssetsDir, { recursive: true })
+
+    const schemaSource = createDevSchemaSource(metadata)
+    await schemaSource.writeAllAssets(schemaData, metadata)
+    debug(`devAssetsWritten`, { versionCount: schemaData.length })
+  }
+
+  return {
+    name: `polen:schema-assets`,
+
+    configureServer(server) {
+      viteServer = server
+
+      // Clear all assets when dev server starts
+      const clearAssets = async () => {
+        try {
+          // Create a basic schema source just for clearing
+          const schemaSource = createDevSchemaSource({ hasSchema: false, versions: [] })
+          await schemaSource.clearAllAssets()
+          debug(`devAssetsCleared`, {})
+        } catch (error) {
+          // Ignore errors during clearing
+        }
+      }
+
+      // Clear assets immediately
+      void clearAssets()
+
+      // Set up file watching for schema source files
+      if (config.schema?.dataSources?.directory?.path) {
+        // Watch the entire directory for directory mode
+        server.watcher.add(config.schema.dataSources.directory.path)
+        debug(`watchingSchemaDirectory`, { path: config.schema.dataSources.directory.path })
+      }
+
+      if (config.schema?.dataSources?.file?.path) {
+        // Watch the specific file for file mode
+        server.watcher.add(config.schema.dataSources.file.path)
+        debug(`watchingSchemaFile`, { path: config.schema.dataSources.file.path })
+      }
+
+      // Handle file removal
+      server.watcher.on('unlink', async (file) => {
+        const isSchemaFile = config.schema && (() => {
+          const absoluteFile = NodePath.resolve(file)
+
+          // Check if file path matches the configured schema file
+          if (config.schema.dataSources?.file?.path) {
+            const absoluteSchemaFile = NodePath.resolve(
+              config.paths.project.rootDir,
+              config.schema.dataSources.file.path,
+            )
+            if (absoluteFile === absoluteSchemaFile) return true
+          }
+
+          // Check if file path is within the configured schema directory
+          if (config.schema.dataSources?.directory?.path) {
+            const absoluteSchemaDir = NodePath.resolve(
+              config.paths.project.rootDir,
+              config.schema.dataSources.directory.path,
+            )
+            if (absoluteFile.startsWith(absoluteSchemaDir + NodePath.sep)) return true
+          }
+
+          return false
+        })()
+
+        if (isSchemaFile) {
+          debug(`schemaFileRemoved`, { file })
+
+          try {
+            // Clear cache and regenerate
+            loadAndProcessSchemaData.clear()
+            const { schemaData, metadata } = await loadAndProcessSchemaData()
+
+            if (schemaData) {
+              // Write new assets without the removed file
+              await writeDevAssets(schemaData, metadata)
+              debug(`hmr:schemaAssetsUpdatedAfterRemoval`, { versionCount: schemaData.length })
+            } else {
+              // No schema data - clear all assets
+              const schemaSource = createDevSchemaSource({ hasSchema: false, versions: [] })
+              await schemaSource.clearAllAssets()
+              debug(`hmr:allAssetsCleared`, {})
+            }
+          } catch (error) {
+            debug(`hmr:schemaRemovalFailed`, { error })
+          }
+
+          // Send HMR invalidation signal
+          server.ws.send({
+            type: 'custom',
+            event: 'polen:schema-invalidate',
+            data: { timestamp: Date.now() },
+          })
+
+          debug(`hmr:schemaInvalidationSent`, {})
+        }
+      })
+    },
+
+    async buildStart() {
+      debug(`buildStart`, {})
+
+      // Load and process schema data
+      const { schemaData, metadata } = await loadAndProcessSchemaData()
+
+      if (!schemaData) {
+        debug(`noSchemaFound`, {})
+        return
+      }
+
+      // Handle asset generation differently for dev vs build
+      if (viteServer) {
+        // Dev mode: Write assets directly to filesystem
+        await writeDevAssets(schemaData, metadata)
+        debug(`devMode:schemaAssetsWritten`, {})
+        return
+      }
+
+      // Build mode: Create schema source for emitting files
+      const schemaSource = createSchemaSource({
+        io: {
+          read: async () => {
+            throw new Error('Read not supported in build asset emitter')
+          },
+          write: async (path: string, content: string) => {
+            // Convert absolute path to relative filename for Vite
+            const relativePath = NodePath.relative(config.paths.framework.devAssets.absolute, path)
+            const fileName = `${config.paths.project.relative.build.relative.assets.root}/${relativePath}`
+
+            this.emitFile({
+              type: `asset`,
+              fileName,
+              source: content,
+            })
+          },
+        },
+        versions: metadata.versions,
+        assetsPath: config.paths.framework.devAssets.absolute,
+      })
+
+      // Emit all assets using the high-level API
+      await schemaSource.writeAllAssets(schemaData, metadata)
+      debug(`buildMode:allAssetsEmitted`, { versionCount: schemaData.length })
+    },
+
+    async handleHotUpdate({ file, server }) {
+      const isSchemaFile = config.schema && (() => {
+        const absoluteFile = NodePath.resolve(file)
+
+        // Check if file path matches the configured schema file
+        if (config.schema.dataSources?.file?.path) {
+          const absoluteSchemaFile = NodePath.resolve(config.paths.project.rootDir, config.schema.dataSources.file.path)
+          if (absoluteFile === absoluteSchemaFile) return true
+        }
+
+        // Check if file path is within the configured schema directory
+        if (config.schema.dataSources?.directory?.path) {
+          const absoluteSchemaDir = NodePath.resolve(
+            config.paths.project.rootDir,
+            config.schema.dataSources.directory.path,
+          )
+          if (absoluteFile.startsWith(absoluteSchemaDir + NodePath.sep)) return true
+        }
+
+        return false
+      })()
+      if (isSchemaFile) {
+        debug(`schemaFileChanged`, { file })
+
+        // Regenerate schema assets
+        try {
+          loadAndProcessSchemaData.clear()
+          const { schemaData, metadata } = await loadAndProcessSchemaData()
+
+          if (schemaData) {
+            debug(`hmr:schemaRegenerated`, { versionCount: schemaData.length })
+
+            // Write new assets to filesystem
+            await writeDevAssets(schemaData, metadata)
+          }
+        } catch (error) {
+          debug(`hmr:schemaRegenerationFailed`, { error })
+        }
+
+        // Send HMR invalidation signal
+        server.ws.send({
+          type: 'custom',
+          event: 'polen:schema-invalidate',
+          data: { timestamp: Date.now() },
+        })
+
+        debug(`hmr:schemaInvalidationSent`, {})
+      }
+    },
+
+    ...ViteVirtual.IdentifiedLoader.toHooks({
+      identifier: viProjectSchemaMetadata,
+      async loader() {
+        debug(`virtualModuleLoad`, { id: viProjectSchemaMetadata.id })
+        const { metadata } = await loadAndProcessSchemaData()
+        return `export default ${JSON.stringify(metadata)}`
+      },
+    }),
+  }
+}

package/src/api/vite/plugins/serve.ts

@@ -5,16 +5,10 @@ import type { Vite } from '#dep/vite/index'
 import { createHtmlTransformer } from '#lib/html-utils/html-transformer'
 import { ResponseInternalServerError } from '#lib/kit-temp'
 import { debugPolen } from '#singletons/debug'
+import type { App, AppOptions } from '#template/server/app'
 import * as HonoNodeServer from '@hono/node-server'
 import { Err } from '@wollybeard/kit'
-
-type App = Hono.Hono
-
-interface AppOptions {
-  hooks?: {
-    transformHtml?: ((html: string, ctx: Hono.Context) => Promise<string> | string)[]
-  }
-}
+import * as NodePath from 'node:path'
 
 interface AppServerModule {
   createApp: (options: AppOptions) => App
@@ -80,6 +74,19 @@ export const Serve = (
               }),
             ],
           },
+          paths: {
+            base: config.build.base,
+            assets: {
+              // Calculate relative path from CWD to Polen's assets
+              // CWD is user's project directory where they run 'pnpm dev'
+              // Assets are in Polen's dev assets directory
+              directory: NodePath.relative(
+                process.cwd(),
+                config.paths.framework.devAssets.absolute,
+              ),
+              route: config.server.routes.assets,
+            },
+          },
         })
       })
       .catch(async (error) => {

package/src/lib/graphql-change/change-groups.ts

@@ -1,3 +1,4 @@
+import { neverCase } from '@wollybeard/kit/language'
 import type {
   Change,
   DirectiveAddedChange,
@@ -248,3 +249,59 @@ export type DirectiveUsage =
   | DirectiveUsageInputFieldDefinitionRemovedChange
 
 export const isDirectiveUsage = (change: Change): change is DirectiveUsage => change.type.startsWith(`DIRECTIVE_USAGE_`)
+
+export type Type =
+  | 'TypeOperation'
+  | 'TypeDescription'
+  | 'FieldOperation'
+  | 'FieldDescription'
+  | 'FieldDeprecation'
+  | 'FieldDeprecationReason'
+  | 'FieldArgumentOperation'
+  | 'FieldArgument'
+  | 'FieldArgumentDescription'
+  | 'EnumValueOperation'
+  | 'EnumValueDescription'
+  | 'EnumValueDeprecationReason'
+  | 'InputFieldOperation'
+  | 'InputFieldDescription'
+  | 'InputFieldDefaultValue'
+  | 'UnionMemberOperation'
+  | 'ObjectTypeInterfaceOperation'
+  | 'DirectiveOperation'
+  | 'DirectiveDescription'
+  | 'DirectiveLocationOperation'
+  | 'DirectiveArgumentOperation'
+  | 'DirectiveArgument'
+  | 'DirectiveArgumentDescription'
+  | 'SchemaRootType'
+  | 'DirectiveUsage'
+
+export const getType = (change: Change): Type => {
+  if (isTypeOperation(change)) return 'TypeOperation'
+  if (isTypeDescription(change)) return 'TypeDescription'
+  if (isFieldOperation(change)) return 'FieldOperation'
+  if (isFieldDescription(change)) return 'FieldDescription'
+  if (isFieldDeprecation(change)) return 'FieldDeprecation'
+  if (isFieldDeprecationReason(change)) return 'FieldDeprecationReason'
+  if (isFieldArgumentOperation(change)) return 'FieldArgumentOperation'
+  if (isFieldArgument(change)) return 'FieldArgument'
+  if (isFieldArgumentDescription(change)) return 'FieldArgumentDescription'
+  if (isEnumValueOperation(change)) return 'EnumValueOperation'
+  if (isEnumValueDescription(change)) return 'EnumValueDescription'
+  if (isEnumValueDeprecationReason(change)) return 'EnumValueDeprecationReason'
+  if (isInputFieldOperation(change)) return 'InputFieldOperation'
+  if (isInputFieldDescription(change)) return 'InputFieldDescription'
+  if (isInputFieldDefaultValue(change)) return 'InputFieldDefaultValue'
+  if (isUnionMemberOperation(change)) return 'UnionMemberOperation'
+  if (isObjectTypeInterfaceOperation(change)) return 'ObjectTypeInterfaceOperation'
+  if (isDirectiveOperation(change)) return 'DirectiveOperation'
+  if (isDirectiveDescription(change)) return 'DirectiveDescription'
+  if (isDirectiveLocationOperation(change)) return 'DirectiveLocationOperation'
+  if (isDirectiveArgumentOperation(change)) return 'DirectiveArgumentOperation'
+  if (isDirectiveArgument(change)) return 'DirectiveArgument'
+  if (isDirectiveArgumentDescription(change)) return 'DirectiveArgumentDescription'
+  if (isSchemaRootType(change)) return 'SchemaRootType'
+  if (isDirectiveUsage(change)) return 'DirectiveUsage'
+  neverCase(change)
+}

package/src/lib/kit-temp.ts

@@ -181,6 +181,19 @@ export const ensureEnd = (string: string, ending: string) => {
   return string + ending
 }
 
+/**
+ * Create a generic cache with clear interface
+ */
+export const createCache = <T>() => {
+  const cache = new Map<string, T>()
+  return {
+    has: (key: string) => cache.has(key),
+    get: (key: string) => cache.get(key),
+    set: (key: string, value: T) => cache.set(key, value),
+    clear: () => cache.clear(),
+  }
+}
+
 export const ResponseInternalServerError = () =>
   new Response(null, {
     status: Http.Status.InternalServerError.code,

package/src/lib/path-map/$.test.ts

@@ -197,6 +197,22 @@ describe('PathMap', () => {
   })
 
   describe('property tests', () => {
+    // Helper to normalize base paths the same way PathMap.create does
+    const normalizeBasePath = (base: string): string => {
+      const trimmedBase = base.trim()
+      const collapsedBase = trimmedBase.replace(/\/+/g, '/')
+      const cleanedBase = collapsedBase === '/.' ? '/' : collapsedBase
+      return cleanedBase === '/' ? '/' : cleanedBase.replace(/\/$/, '')
+    }
+
+    // Helper to build absolute paths with proper handling of root base
+    const buildAbsolutePath = (normalizedBase: string, segments: string[]): string => {
+      if (segments.length === 0) return normalizedBase
+      return normalizedBase === '/'
+        ? `/${segments.join('/')}`
+        : `${normalizedBase}/${segments.join('/')}`
+    }
+
     // Arbitrary for valid path segments
     const pathSegment = fc.stringMatching(/^[a-zA-Z0-9_-]+$/)
 
@@ -243,10 +259,7 @@ describe('PathMap', () => {
       fc.assert(
         fc.property(pathInput, fc.string({ minLength: 1 }).filter(s => s.startsWith('/')), (input, base) => {
           const paths = PathMap.create(input, base)
-
-          // Base is normalized (trimmed, multiple slashes collapsed, trailing removed)
-          const collapsedBase = base.trim().replace(/\/+/g, '/')
-          const normalizedBase = collapsedBase === '/' ? '/' : collapsedBase.replace(/\/$/, '')
+          const normalizedBase = normalizeBasePath(base)
 
           function checkAbsolute(obj: any) {
             for (const [key, value] of Object.entries(obj)) {
@@ -278,14 +291,11 @@ describe('PathMap', () => {
             expect(JSON.stringify(p1.rooted)).toBe(JSON.stringify(p2.rooted))
 
             // Only absolute paths and base should change
-            const collapsedBase2 = base2.trim().replace(/\/+/g, '/')
-            const normalizedBase2 = collapsedBase2 === '/' ? '/' : collapsedBase2.replace(/\/$/, '')
-            expect(p2.base).toBe(normalizedBase2)
-
+            // Use the normalized base from the PathMap itself
             function checkBase(obj: any) {
               for (const [key, value] of Object.entries(obj)) {
                 if (typeof value === 'string') {
-                  expect(value.startsWith(normalizedBase2)).toBe(true)
+                  expect(value.startsWith(p2.base)).toBe(true)
                 } else if (typeof value === 'object') {
                   checkBase(value)
                 }
@@ -309,20 +319,13 @@ describe('PathMap', () => {
               if (currentPath.length === 0) {
                 expect(rel.$).toBe('.')
                 expect(rooted.$).toBe('.')
-                // Base is normalized in create() (trimmed, collapsed, trailing removed)
-                const collapsedBase = base.trim().replace(/\/+/g, '/')
-                const normalizedBase = collapsedBase === '/' ? '/' : collapsedBase.replace(/\/$/, '')
+                const normalizedBase = normalizeBasePath(base)
                 expect(abs.$).toBe(normalizedBase)
               } else {
                 expect(rel.$).toBe(currentPath[currentPath.length - 1])
                 expect(rooted.$).toBe(currentPath.join('/'))
-                // Handle base that might be '/' or have trailing slash
-                // Note: create() normalizes the base (trim + collapse + remove trailing)
-                const collapsedBase = base.trim().replace(/\/+/g, '/')
-                const normalizedBase = collapsedBase === '/' ? '/' : collapsedBase.replace(/\/$/, '')
-                const expectedAbs = normalizedBase === '/'
-                  ? `/${currentPath.join('/')}`
-                  : `${normalizedBase}/${currentPath.join('/')}`
+                const normalizedBase = normalizeBasePath(base)
+                const expectedAbs = buildAbsolutePath(normalizedBase, currentPath)
                 expect(abs.$).toBe(expectedAbs)
               }
             }

package/src/lib/path-map/path-map.ts

@@ -113,7 +113,9 @@ export function create<T extends PathInput>(paths: T, base?: string): RelativePa
   const trimmedBase = base.trim()
   // Collapse multiple slashes to single, then remove trailing (unless it's just "/")
   const collapsedBase = trimmedBase.replace(/\/+/g, `/`)
-  const normalizedBase = collapsedBase === `/` ? `/` : collapsedBase.replace(/\/$/, ``)
+  // Handle edge case where base is "/." - this should become "/"
+  const cleanedBase = collapsedBase === `/.` ? `/` : collapsedBase
+  const normalizedBase = cleanedBase === `/` ? `/` : cleanedBase.replace(/\/$/, ``)
 
   const rooted = processRootedPaths(paths, [])
   const absolute = processAbsolutePaths(paths, normalizedBase, [])

package/src/project-data.ts

@@ -1,18 +1,10 @@
 import type { Config } from '#api/config/index'
 import type { NavbarItem } from '#api/content/navbar'
-import type { Schema } from './api/schema/index.js'
 
 export interface ProjectData {
-  schema: null | Schema.Schema
   basePath: string
-  paths: Config.Config[`paths`][`project`]
+  paths: Config.Config['paths']
   navbar: NavbarItem[]
-  server: {
-    port: number
-    static: {
-      directory: string
-      route: string
-    }
-  }
-  warnings: Config.Config[`warnings`]
+  server: Config.Config['server']
+  warnings: Config.Config['warnings']
 }

package/src/template/components/Changelog.tsx

@@ -1,15 +1,14 @@
-import type { GrafaidOld } from '#lib/grafaid-old/index'
+import type { Api } from '#api/index'
 import { CRITICALITY_LEVELS } from '#lib/graphql-change/criticality'
 import { GraphqlChange } from '#lib/graphql-change/index'
 import type { GraphqlChangeset } from '#lib/graphql-changeset/index'
 import type { CriticalityLevel } from '@graphql-inspector/core'
 import { Box } from '@radix-ui/themes'
-import { neverCase } from '@wollybeard/kit/language'
-import type React from 'react'
+import React from 'react'
 import { useMemo } from 'react'
-import type { Schema as ChangelogData } from '../../api/schema/index.js'
 import { CriticalitySection } from './Changelog/CriticalitySection.js'
 import * as Group from './Changelog/groups/index.js'
+import { ComponentDispatch } from './ComponentDispatch.js'
 
 export const renderDate = (date: Date) => {
   return date.toLocaleString(`default`, {
@@ -20,10 +19,10 @@ export const renderDate = (date: Date) => {
   })
 }
 
-export const Changelog: React.FC<{ schema: ChangelogData.Schema }> = ({ schema }) => {
+export const Changelog: React.FC<{ changesets: Api.Schema.NonEmptyChangeSets }> = ({ changesets }) => {
   return (
     <Box>
-      {schema.versions.map(changeset => <Changeset key={changeset.date.toISOString()} changeset={changeset} />)}
+      {changesets.map(changeset => <Changeset key={changeset.date.toISOString()} changeset={changeset} />)}
     </Box>
   )
 }
@@ -62,69 +61,19 @@ const Changeset: React.FC<{ changeset: GraphqlChangeset.ChangeSet }> = ({ change
       </h1>
       {groupedChanges.map(group => (
         <CriticalitySection key={group.level} level={group.level} changes={group.changes}>
-          {group.changes.map(change => (
-            <Change key={`${change.type}-${change.path || change.message}`} change={change} schema={changeset.after} />
-          ))}
+          {group.changes.map(change => {
+            const type = GraphqlChange.Group.getType(change)
+            return (
+              <ComponentDispatch
+                key={`${change.type}-${change.path || change.message}`}
+                components={Group}
+                name={type}
+                props={{ change }}
+              />
+            )
+          })}
         </CriticalitySection>
       ))}
     </Box>
   )
 }
-
-const Change: React.FC<{ change: GraphqlChange.Change; schema: GrafaidOld.Schema.Schema }> = (
-  { change, schema },
-) => {
-  if (GraphqlChange.Group.isTypeOperation(change)) {
-    return <Group.TypeOperation change={change} />
-  } else if (GraphqlChange.Group.isTypeDescription(change)) {
-    return <Group.TypeDescription change={change} />
-  } else if (GraphqlChange.Group.isFieldOperation(change)) {
-    return <Group.FieldOperation change={change} />
-  } else if (GraphqlChange.Group.isFieldDescription(change)) {
-    return <Group.FieldDescription change={change} />
-  } else if (GraphqlChange.Group.isFieldDeprecation(change)) {
-    return <Group.FieldDeprecation change={change} />
-  } else if (GraphqlChange.Group.isFieldDeprecationReason(change)) {
-    return <Group.FieldDeprecationReason change={change} />
-  } else if (GraphqlChange.Group.isFieldArgumentOperation(change)) {
-    return <Group.FieldArgumentOperation change={change} />
-  } else if (GraphqlChange.Group.isFieldArgument(change)) {
-    return <Group.FieldArgument change={change} />
-  } else if (GraphqlChange.Group.isFieldArgumentDescription(change)) {
-    return <Group.FieldArgumentDescription change={change} />
-  } else if (GraphqlChange.Group.isEnumValueOperation(change)) {
-    return <Group.EnumValueOperation change={change} />
-  } else if (GraphqlChange.Group.isEnumValueDescription(change)) {
-    return <Group.EnumValueDescription change={change} />
-  } else if (GraphqlChange.Group.isEnumValueDeprecationReason(change)) {
-    return <Group.EnumValueDeprecationReason change={change} />
-  } else if (GraphqlChange.Group.isInputFieldOperation(change)) {
-    return <Group.InputFieldOperation change={change} />
-  } else if (GraphqlChange.Group.isInputFieldDescription(change)) {
-    return <Group.InputFieldDescription change={change} />
-  } else if (GraphqlChange.Group.isInputFieldDefaultValue(change)) {
-    return <Group.InputFieldDefaultValue change={change} />
-  } else if (GraphqlChange.Group.isUnionMemberOperation(change)) {
-    return <Group.UnionMemberOperation change={change} />
-  } else if (GraphqlChange.Group.isObjectTypeInterfaceOperation(change)) {
-    return <Group.ObjectTypeInterfaceOperation change={change} />
-  } else if (GraphqlChange.Group.isDirectiveOperation(change)) {
-    return <Group.DirectiveOperation change={change} />
-  } else if (GraphqlChange.Group.isDirectiveDescription(change)) {
-    return <Group.DirectiveDescription change={change} />
-  } else if (GraphqlChange.Group.isDirectiveLocationOperation(change)) {
-    return <Group.DirectiveLocationOperation change={change} />
-  } else if (GraphqlChange.Group.isDirectiveArgumentOperation(change)) {
-    return <Group.DirectiveArgumentOperation change={change} />
-  } else if (GraphqlChange.Group.isDirectiveArgument(change)) {
-    return <Group.DirectiveArgument change={change} />
-  } else if (GraphqlChange.Group.isDirectiveArgumentDescription(change)) {
-    return <Group.DirectiveArgumentDescription change={change} />
-  } else if (GraphqlChange.Group.isSchemaRootType(change)) {
-    return <Group.SchemaRootType change={change} />
-  } else if (GraphqlChange.Group.isDirectiveUsage(change)) {
-    return <Group.DirectiveUsage change={change} />
-  } else {
-    neverCase(change)
-  }
-}