polen 0.11.0-next.14 → 0.11.0-next.16

package/src/template/layouts/ChangelogLayout.tsx

@@ -1,164 +0,0 @@
-import {
-  CRITICALITY_CONFIG,
-  isCriticalityBreaking,
-  isCriticalityDangerous,
-  isCriticalitySafe,
-} from '#lib/graphql-change/criticality'
-import { GraphqlChangeset } from '#lib/graphql-changeset'
-import { Box, Flex, Text } from '@radix-ui/themes'
-import type React from 'react'
-import { useEffect, useState } from 'react'
-import { renderDate } from '../components/Changelog.js'
-
-interface ChangelogLayoutProps {
-  children: React.ReactNode
-  versions: GraphqlChangeset.ChangeSet[]
-}
-
-interface VersionCounts {
-  breaking: number
-  dangerous: number
-  safe: number
-}
-
-const calculateCounts = (version: GraphqlChangeset.ChangeSet): VersionCounts => {
-  if (GraphqlChangeset.isIntermediateChangeSet(version)) {
-    return {
-      breaking: version.changes.filter(isCriticalityBreaking).length,
-      dangerous: version.changes.filter(isCriticalityDangerous).length,
-      safe: version.changes.filter(isCriticalitySafe).length,
-    }
-  }
-  return {
-    breaking: 0,
-    dangerous: 0,
-    safe: 0,
-  }
-}
-
-const SidebarEntry: React.FC<{
-  version: GraphqlChangeset.ChangeSet
-  counts: VersionCounts
-  isActive: boolean
-}> = ({ version, counts, isActive }) => {
-  const dateId = version.date.toISOString()
-
-  return (
-    <Box mb='2'>
-      <a
-        href={`#${dateId}`}
-        style={{
-          textDecoration: 'none',
-          display: 'flex',
-          alignItems: 'center',
-          justifyContent: 'space-between',
-          padding: '0.5rem 0.75rem',
-          borderRadius: '4px',
-          backgroundColor: isActive ? 'var(--gray-a3)' : 'transparent',
-          color: 'inherit',
-          transition: 'background-color 0.2s',
-        }}
-        onClick={(e) => {
-          e.preventDefault()
-          document.getElementById(dateId)?.scrollIntoView({ behavior: 'smooth' })
-        }}
-      >
-        <Text size='2' weight={isActive ? 'medium' : 'regular'}>
-          {renderDate(version.date)}
-        </Text>
-        <Flex gap='2' align='center'>
-          {counts.breaking > 0 && (
-            <Text size='1' weight='medium' style={{ color: CRITICALITY_CONFIG.BREAKING.color }}>
-              {counts.breaking}
-            </Text>
-          )}
-          {counts.dangerous > 0 && (
-            <Text size='1' weight='medium' style={{ color: CRITICALITY_CONFIG.DANGEROUS.color }}>
-              {counts.dangerous}
-            </Text>
-          )}
-          {counts.safe > 0 && (
-            <Text size='1' weight='medium' style={{ color: CRITICALITY_CONFIG.NON_BREAKING.color }}>
-              {counts.safe}
-            </Text>
-          )}
-        </Flex>
-      </a>
-    </Box>
-  )
-}
-
-export const ChangelogLayout: React.FC<ChangelogLayoutProps> = ({ children, versions }) => {
-  const [activeVersion, setActiveVersion] = useState<string | null>(null)
-
-  // Calculate counts for all versions (SSR-safe)
-  const versionsWithCounts = versions.map(version => ({
-    version,
-    counts: calculateCounts(version),
-  }))
-
-  // Set up scroll spy after hydration
-  useEffect(() => {
-    const handleScroll = () => {
-      const scrollPosition = window.scrollY + 100 // Offset for header
-
-      // Find the current version based on scroll position
-      let currentVersion: string | null = null
-
-      for (const { version } of versionsWithCounts) {
-        const element = document.getElementById(version.date.toISOString())
-        if (element) {
-          const { top } = element.getBoundingClientRect()
-          if (top <= 100) {
-            currentVersion = version.date.toISOString()
-          }
-        }
-      }
-
-      setActiveVersion(currentVersion)
-    }
-
-    // Initial check
-    handleScroll()
-
-    // Add scroll listener
-    window.addEventListener('scroll', handleScroll, { passive: true })
-
-    return () => {
-      window.removeEventListener('scroll', handleScroll)
-    }
-  }, [versionsWithCounts])
-
-  return (
-    <Flex gap='6' style={{ position: 'relative' }}>
-      {/* Sidebar */}
-      <Box
-        style={{
-          position: 'sticky',
-          top: '2rem',
-          height: 'fit-content',
-          minWidth: '250px',
-          maxHeight: 'calc(100vh - 4rem)',
-          overflowY: 'auto',
-        }}
-      >
-        <Text size='2' weight='medium' mb='3' style={{ display: 'block' }}>
-          Releases
-        </Text>
-        {versionsWithCounts.map(({ version, counts }) => (
-          <SidebarEntry
-            key={version.date.toISOString()}
-            version={version}
-            counts={counts}
-            isActive={activeVersion === version.date.toISOString()}
-          />
-        ))}
-      </Box>
-
-      {/* Main content */}
-      <Box style={{ flex: 1, minWidth: 0 }}>
-        {children}
-      </Box>
-    </Flex>
-  )
-}

package/src/template/server/ssg/generate.ts

@@ -1,101 +0,0 @@
-import { Hono } from '#dep/hono/index'
-import type { ReactRouter } from '#dep/react-router/index'
-import { asyncParallel, chunk } from '#lib/kit-temp'
-import { debugPolen } from '#singletons/debug'
-import * as NodeFs from 'node:fs/promises'
-import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
-import viteClientAssetManifest from 'virtual:polen/vite/client/manifest'
-import { createPageHtmlResponse } from '../create-page-html-response.js'
-import { injectManifestIntoHtml } from '../manifest.js'
-import { createPolenDataInjector } from '../transformers/inject-polen-data.js'
-import { createThemeInitInjector } from '../transformers/inject-theme-init.js'
-import { getRoutesPaths } from './get-route-paths.js'
-
-export const generate = async (view: ReactRouter.StaticHandler) => {
-  const debug = debugPolen.sub(`ssg`)
-
-  const routePaths = await getRoutesPaths()
-  const totalPaths = routePaths.length
-  debug(`start`, { totalPaths })
-
-  // Process routes in batches using the new utilities
-  const batchSize = 50
-  const batches = chunk(routePaths, batchSize)
-
-  const result = await asyncParallel(
-    batches,
-    async (batchPaths, batchIndex) => {
-      const batchApp = new Hono.Hono()
-
-      // Create a custom handler for batch processing that includes base path handling
-      const batchHandler: Hono.Handler = async (ctx) => {
-        // For SSG, we need to create a request with the base path prepended
-        const url = new URL(ctx.req.raw.url)
-        const basePath = PROJECT_DATA.basePath === `/` ? `` : PROJECT_DATA.basePath.slice(0, -1)
-
-        // Create a new request with the base path prepended to the pathname
-        const modifiedRequest = new Request(
-          `${url.protocol}//${url.host}${basePath}${url.pathname}${url.search}`,
-          {
-            method: ctx.req.raw.method,
-            headers: ctx.req.raw.headers,
-            body: ctx.req.raw.body,
-          },
-        )
-
-        const staticHandlerContext = await view.query(modifiedRequest)
-        if (staticHandlerContext instanceof Response) {
-          return staticHandlerContext
-        }
-
-        // SSG needs Polen data injection, theme init, and manifest transformation
-        const polenDataInjector = createPolenDataInjector()
-        const themeInitInjector = createThemeInitInjector()
-        const transformHtml = async (html: string) => {
-          // First inject Polen data
-          html = await polenDataInjector(html, ctx)
-          // Then inject theme initialization
-          html = await themeInitInjector(html, ctx)
-          // Finally inject manifest
-          return injectManifestIntoHtml(html, viteClientAssetManifest, PROJECT_DATA.basePath)
-        }
-        // Pass ctx for SSG to set up Polen data
-        return createPageHtmlResponse(staticHandlerContext, { transformHtml }, ctx)
-      }
-
-      // Register only the routes for this batch
-      for (const routePath of batchPaths) {
-        batchApp.get(routePath, batchHandler)
-      }
-
-      debug(`batch:start`, {
-        batchIndex: batchIndex + 1,
-        totalBatches: batches.length,
-        pagesInBatch: batchPaths.length,
-      })
-
-      const ssgResult = await Hono.SSG.toSSG(batchApp, NodeFs, {
-        concurrency: 5, // Reduced concurrency for memory efficiency
-        dir: PROJECT_DATA.paths.project.relative.build.root,
-      })
-
-      if (!ssgResult.success) {
-        throw new Error(`Failed to generate static site at batch ${batchIndex + 1}`, {
-          cause: ssgResult.error,
-        })
-      }
-
-      return ssgResult
-    },
-    {
-      concurrency: 1, // Process batches sequentially to avoid memory issues
-      failFast: true, // Stop on first batch failure
-    },
-  )
-
-  if (!result.success) {
-    throw new Error(`SSG generation failed`, { cause: result.errors[0] })
-  }
-
-  debug(`complete`, { totalPaths })
-}

package/src/template/server/ssg/get-route-paths.test.ts

@@ -1,145 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest'
-
-// Mock node:fs/promises
-vi.mock('node:fs/promises', () => ({
-  readFile: vi.fn(),
-}))
-
-// Mock the virtual import
-vi.mock('virtual:polen/project/data.jsonsuper', () => ({
-  default: {
-    paths: {
-      project: {
-        absolute: {
-          build: {
-            assets: {
-              schemas: '/mock/schemas',
-            },
-          },
-        },
-      },
-    },
-  },
-}))
-
-// Mock the routes
-vi.mock('../../routes.js', () => ({
-  routes: [
-    {
-      path: 'reference',
-      children: [
-        {
-          path: 'version/:version',
-          children: [
-            {
-              path: ':type',
-            },
-          ],
-        },
-        {
-          path: ':type',
-        },
-      ],
-    },
-  ],
-}))
-
-// Mock the API
-vi.mock('#api/index', () => ({
-  Api: {
-    Schema: {
-      getMetadata: vi.fn(),
-      VERSION_LATEST: 'latest',
-      Routing: {
-        createReferencePath: vi.fn((parts) => {
-          const version = parts.version || 'latest'
-          const basePath = version === 'latest' ? '/reference' : `/reference/version/${version}`
-          if (parts.type) {
-            return parts.field ? `${basePath}/${parts.type}/${parts.field}` : `${basePath}/${parts.type}`
-          }
-          return basePath
-        }),
-        createReferenceBasePath: vi.fn((version) => {
-          return version === 'latest' ? '/reference' : `/reference/version/${version}`
-        }),
-      },
-    },
-  },
-}))
-
-describe('getRoutesPaths', () => {
-  beforeEach(() => {
-    vi.resetAllMocks()
-  })
-
-  test('should handle versioned routes without type parameter', async () => {
-    // Mock schema metadata
-    const { Api } = await import('#api/index')
-    vi.mocked(Api.Schema.getMetadata).mockResolvedValue({
-      hasSchema: true,
-      versions: ['2024-01-01', '2024-02-01'],
-    })
-
-    // Mock file system reads with proper GraphQL AST
-    const NodeFs = await import('node:fs/promises')
-    vi.mocked(NodeFs.readFile).mockImplementation(async (path) => {
-      if (typeof path === 'string' && path.includes('.json')) {
-        // Return a minimal GraphQL document AST
-        return JSON.stringify({
-          kind: 'Document',
-          definitions: [],
-        })
-      }
-      throw new Error(`Unexpected file read: ${path}`)
-    })
-
-    const { getRoutesPaths } = await import('./get-route-paths.js')
-
-    // This should not throw "Unhandled parameterized path: /reference/version/:version"
-    await expect(getRoutesPaths()).resolves.toBeDefined()
-  })
-
-  test('should generate paths for all schema versions', async () => {
-    const { Api } = await import('#api/index')
-    vi.mocked(Api.Schema.getMetadata).mockResolvedValue({
-      hasSchema: true,
-      versions: ['2024-01-01', '2024-02-01'],
-    })
-
-    // Mock schema with types - proper GraphQL AST
-    const mockSchema = {
-      kind: 'Document',
-      definitions: [
-        {
-          kind: 'ObjectTypeDefinition',
-          name: { kind: 'Name', value: 'User' },
-        },
-        {
-          kind: 'ObjectTypeDefinition',
-          name: { kind: 'Name', value: 'Post' },
-        },
-      ],
-    }
-
-    const NodeFs = await import('node:fs/promises')
-    vi.mocked(NodeFs.readFile).mockImplementation(async (path) => {
-      if (typeof path === 'string' && path.includes('.json')) {
-        return JSON.stringify(mockSchema)
-      }
-      throw new Error(`Unexpected file read: ${path}`)
-    })
-
-    const { getRoutesPaths } = await import('./get-route-paths.js')
-    const paths = await getRoutesPaths()
-
-    // Should include versioned paths
-    expect(paths).toContain('/reference/version/2024-01-01/User')
-    expect(paths).toContain('/reference/version/2024-01-01/Post')
-    expect(paths).toContain('/reference/version/2024-02-01/User')
-    expect(paths).toContain('/reference/version/2024-02-01/Post')
-
-    // Should include unversioned paths
-    expect(paths).toContain('/reference/User')
-    expect(paths).toContain('/reference/Post')
-  })
-})

package/src/template/server/ssg/get-route-paths.ts

@@ -1,151 +0,0 @@
-import { Api } from '#api/index'
-import { ReactRouterAid } from '#lib/react-router-aid'
-import { visit } from 'graphql'
-import * as NodeFs from 'node:fs/promises'
-import * as NodePath from 'node:path'
-import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
-import { routes } from '../../routes.js'
-
-// todo: Frameworks tend to colocate ssg data loaders with routes to solve the following
-// problem which is we have to map data loaders to paramterized routes.
-// Maybe we can figure something out too.
-const knownParameterizedRouteExpressions = {
-  reference_type: `/reference/:type`,
-  reference_type_field: `/reference/:type/:field`,
-  reference_version: `/reference/version/:version`,
-  reference_versioned_type: `/reference/version/:version/:type`,
-  reference_versioned_type_field: `/reference/version/:version/:type/:field`,
-}
-
-export const getRoutesPaths = async (): Promise<string[]> => {
-  const paths = new Set<string>()
-  const routeExpressions = ReactRouterAid.getRouteExpressions(routes)
-
-  // Helper function to load schema from filesystem and add type paths
-  const addTypePathsForVersion = async (version: string, includeFields = false) => {
-    try {
-      const schemaFilePath = NodePath.join(PROJECT_DATA.paths.project.absolute.build.assets.schemas, `${version}.json`)
-      const schemaContent = await NodeFs.readFile(schemaFilePath, 'utf-8')
-      const schemaAst = JSON.parse(schemaContent)
-
-      visit(schemaAst, {
-        ObjectTypeDefinition(node) {
-          const typePath = Api.Schema.Routing.createReferencePath({
-            version: version === Api.Schema.VERSION_LATEST ? undefined : version,
-            type: node.name.value,
-          })
-          paths.add(typePath)
-
-          // Add field paths if requested
-          if (includeFields && node.fields) {
-            for (const field of node.fields) {
-              const fieldPath = Api.Schema.Routing.createReferencePath({
-                version: version === Api.Schema.VERSION_LATEST ? undefined : version,
-                type: node.name.value,
-                field: field.name.value,
-              })
-              paths.add(fieldPath)
-            }
-          }
-        },
-        InterfaceTypeDefinition(node) {
-          const typePath = Api.Schema.Routing.createReferencePath({
-            version: version === Api.Schema.VERSION_LATEST ? undefined : version,
-            type: node.name.value,
-          })
-          paths.add(typePath)
-
-          // Add field paths if requested
-          if (includeFields && node.fields) {
-            for (const field of node.fields) {
-              const fieldPath = Api.Schema.Routing.createReferencePath({
-                version: version === Api.Schema.VERSION_LATEST ? undefined : version,
-                type: node.name.value,
-                field: field.name.value,
-              })
-              paths.add(fieldPath)
-            }
-          }
-        },
-        EnumTypeDefinition(node) {
-          const typePath = Api.Schema.Routing.createReferencePath({
-            version: version === Api.Schema.VERSION_LATEST ? undefined : version,
-            type: node.name.value,
-          })
-          paths.add(typePath)
-        },
-        InputObjectTypeDefinition(node) {
-          const typePath = Api.Schema.Routing.createReferencePath({
-            version: version === Api.Schema.VERSION_LATEST ? undefined : version,
-            type: node.name.value,
-          })
-          paths.add(typePath)
-        },
-        UnionTypeDefinition(node) {
-          const typePath = Api.Schema.Routing.createReferencePath({
-            version: version === Api.Schema.VERSION_LATEST ? undefined : version,
-            type: node.name.value,
-          })
-          paths.add(typePath)
-        },
-        ScalarTypeDefinition(node) {
-          const typePath = Api.Schema.Routing.createReferencePath({
-            version: version === Api.Schema.VERSION_LATEST ? undefined : version,
-            type: node.name.value,
-          })
-          paths.add(typePath)
-        },
-      })
-    } catch (error) {
-      throw new Error(`SSG failed to load schema for version ${version}. Ensure schema assets are built. ${error}`)
-    }
-  }
-
-  const schemaMetadataPath = NodePath.join(PROJECT_DATA.paths.project.absolute.build.assets.schemas, 'metadata.json')
-
-  const schemaMetadata = await Api.Schema.getMetadata(schemaMetadataPath)
-  const { hasSchema, versions: availableVersions } = schemaMetadata
-
-  for (const exp of routeExpressions) {
-    if (exp === knownParameterizedRouteExpressions.reference_type) {
-      if (hasSchema) {
-        // Add paths for latest version (no version in URL)
-        await addTypePathsForVersion(Api.Schema.VERSION_LATEST)
-      }
-    } else if (exp === knownParameterizedRouteExpressions.reference_version) {
-      if (hasSchema) {
-        // Add paths for version pages themselves (without type)
-        for (const version of availableVersions) {
-          const versionPath = Api.Schema.Routing.createReferenceBasePath(version)
-          paths.add(versionPath)
-        }
-      }
-    } else if (exp === knownParameterizedRouteExpressions.reference_type_field) {
-      if (hasSchema) {
-        // Add paths for latest version fields
-        await addTypePathsForVersion(Api.Schema.VERSION_LATEST, true)
-      }
-    } else if (exp === knownParameterizedRouteExpressions.reference_versioned_type) {
-      if (hasSchema) {
-        // Add paths for all versions using new route structure
-        for (const version of availableVersions) {
-          await addTypePathsForVersion(version)
-        }
-      }
-    } else if (exp === knownParameterizedRouteExpressions.reference_versioned_type_field) {
-      if (hasSchema) {
-        // Add paths for all versions with fields
-        for (const version of availableVersions) {
-          await addTypePathsForVersion(version, true)
-        }
-      }
-    } else if (ReactRouterAid.isParameterizedPath(exp)) {
-      throw new Error(`Unhandled parameterized path: ${exp}`)
-    } else {
-      // Static path
-      paths.add(exp)
-    }
-  }
-
-  return Array.from(paths).sort() // Sort for deterministic output
-}

package/src/template/sources/schema-source.ts

@@ -1,69 +0,0 @@
-import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
-import PROJECT_SCHEMA_METADATA from 'virtual:polen/project/schema-metadata'
-import { createSchemaSource } from '../../api/schema-source/index.js'
-import { polenUrlPathAssets } from '../lib/polen-url.js'
-
-// Environment-specific IO implementation
-const io = import.meta.env.SSR
-  ? {
-    // Server-side: Read from filesystem
-    read: async (path: string) => {
-      // Dynamic import to keep fs out of client bundle
-      const { readFile } = await import('node:fs/promises')
-
-      // Extract the path after the assets route
-      // e.g., "/assets/schemas/latest.json" -> "schemas/latest.json"
-      // e.g., "/demos/pokemon/assets/schemas/latest.json" -> "schemas/latest.json"
-      const assetsRoute = PROJECT_DATA.server.routes.assets
-      const routePattern = new RegExp(`${assetsRoute}/(.+)$`)
-      const match = path.match(routePattern)
-      const assetPath = match ? match[1] : path
-
-      // In SSR, we need to read from the correct location
-      // During dev, assets are served from Polen's node_modules
-      // In production, they're in the build output directory
-      let fullPath: string
-      if (import.meta.env.DEV) {
-        // Development: Read from Polen's Vite cache
-        fullPath = `${PROJECT_DATA.paths.framework.devAssets.absolute}/${assetPath}`
-      } else {
-        // Production: Read from build output
-        // The server runs from the project root, and assets are in build/assets/
-        fullPath =
-          `${PROJECT_DATA.paths.project.relative.build.root}/${PROJECT_DATA.paths.project.relative.build.relative.assets.root}/${assetPath}`
-      }
-
-      return readFile(fullPath, 'utf-8')
-    },
-  }
-  : {
-    // Client-side: Fetch from HTTP
-    read: async (path: string) => {
-      const response = await fetch(path)
-      if (!response.ok) {
-        throw new Error(`Failed to fetch: ${path} (${response.status} ${response.statusText})`)
-      }
-      return response.text()
-    },
-  }
-
-// Create and export the source object directly
-export const schemaSource = createSchemaSource({
-  io,
-  versions: PROJECT_SCHEMA_METADATA.versions,
-  assetsPath: polenUrlPathAssets(),
-})
-
-// HMR cache invalidation for development
-if (import.meta.hot) {
-  import.meta.hot.on('polen:schema-invalidate', () => {
-    console.log('[HMR] Schema cache invalidated')
-    schemaSource.clearCache()
-
-    // Brute force approach: reload the page to ensure fresh data
-    // This guarantees all components see the updated schema immediately
-    // TODO: When we have reactive data fetching, remove this reload
-    //       and let the reactive system handle updates gracefully
-    window.location.reload()
-  })
-}

package/src/vite-env.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="vite/client" />
-
-declare module 'virtual:polen/project/hooks' {
-  export const navbar: ((props: import('./api/hooks/types').NavbarProps) => React.ReactNode) | null
-}