polen 0.11.0-next.14 → 0.11.0-next.15

package/src/template/components/Changelog.tsx

@@ -1,80 +0,0 @@
-import { GraphqlChange } from '#lib/graphql-change'
-import { CRITICALITY_LEVELS } from '#lib/graphql-change/criticality'
-import { GraphqlChangeset } from '#lib/graphql-changeset'
-import type { CriticalityLevel } from '@graphql-inspector/core'
-import { Box } from '@radix-ui/themes'
-import React from 'react'
-import { useMemo } from 'react'
-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`, {
-    month: `long`,
-    year: `numeric`,
-    day: `numeric`,
-    timeZone: `utc`,
-  })
-}
-
-export const Changelog: React.FC<{ changesets: GraphqlChangeset.Changelog }> = ({ changesets }) => {
-  return (
-    <Box>
-      {changesets.map(changeset => <Changeset key={changeset.date.toISOString()} changeset={changeset} />)}
-    </Box>
-  )
-}
-
-const Changeset: React.FC<{ changeset: GraphqlChangeset.ChangeSet }> = ({ changeset }) => {
-  // Group changes by criticality level
-  const groupedChanges = useMemo(() => {
-    const groups = {} as Record<CriticalityLevel, GraphqlChange.Change[]>
-
-    // Initialize empty arrays for each level
-    CRITICALITY_LEVELS.forEach(level => {
-      groups[level] = []
-    })
-
-    // Group changes
-    if (GraphqlChangeset.isIntermediateChangeSet(changeset)) {
-      changeset.changes.forEach(change => {
-        const level = change.criticality.level
-        if (groups[level]) {
-          groups[level].push(change)
-        }
-      })
-    }
-
-    // Return only non-empty groups in order
-    return CRITICALITY_LEVELS
-      .filter(level => groups[level].length > 0)
-      .map(level => ({
-        level,
-        changes: groups[level],
-      }))
-  }, [changeset])
-
-  return (
-    <Box mb='6'>
-      <h1 title={changeset.date.toISOString()} id={changeset.date.toISOString()}>
-        {renderDate(changeset.date)}
-      </h1>
-      {groupedChanges.map(group => (
-        <CriticalitySection key={group.level} level={group.level} changes={group.changes}>
-          {group.changes.map((change, index) => {
-            const type = GraphqlChange.Group.getType(change)
-            return (
-              <ComponentDispatch
-                key={`${change.type}-${change.path || change.message}-${index}`}
-                components={Group}
-                name={type}
-                props={{ change }}
-              />
-            )
-          })}
-        </CriticalitySection>
-      ))}
-    </Box>
-  )
-}

package/src/template/contexts/SchemaLifecycleContext.tsx

@@ -1,30 +0,0 @@
-import type { React } from '#dep/react/index'
-import { SchemaLifecycle } from '#lib/schema-lifecycle'
-import { createContext, useContext } from 'react'
-
-interface SchemaLifecycleContextValue {
-  lifecycle: SchemaLifecycle.SchemaLifecycle | null
-  currentVersion: string
-}
-
-const SchemaLifecycleContext = createContext<SchemaLifecycleContextValue | undefined>(undefined)
-
-export const SchemaLifecycleProvider: React.FC<{
-  children: React.ReactNode
-  lifecycle: SchemaLifecycle.SchemaLifecycle | null
-  currentVersion: string
-}> = ({ children, lifecycle, currentVersion }) => {
-  return (
-    <SchemaLifecycleContext.Provider value={{ lifecycle, currentVersion }}>
-      {children}
-    </SchemaLifecycleContext.Provider>
-  )
-}
-
-export const useSchemaLifecycle = () => {
-  const context = useContext(SchemaLifecycleContext)
-  if (!context) {
-    throw new Error(`useSchemaLifecycle must be used within a SchemaLifecycleProvider`)
-  }
-  return context
-}

package/src/template/global.d.ts

@@ -1,7 +0,0 @@
-import type { PolenGlobalData } from './constants'
-
-declare global {
-  var __POLEN__: PolenGlobalData
-}
-
-export {}

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
-}