polen 0.11.0-next.13 → 0.11.0-next.15

package/src/template/routes/reference.tsx

@@ -1,51 +1,81 @@
 import type { Content } from '#api/content/$'
 import { Api } from '#api/iso'
-import type { React } from '#dep/react/index'
+import { Catalog } from '#lib/catalog/$'
 import { GrafaidOld } from '#lib/grafaid-old'
-import { route, routeIndex } from '#lib/react-router-aid/react-router-aid'
-import { createLoader, useLoaderData } from '#lib/react-router-loader/react-router-loader'
-import { Box } from '@radix-ui/themes'
+import { S } from '#lib/kit-temp/effect'
+import { Lifecycles } from '#lib/lifecycles/$'
+import { route, useLoaderData } from '#lib/react-router-effect/react-router-effect'
+import { Schema } from '#lib/schema/$'
+import { Version } from '#lib/version/$'
+import { catalog } from '#template/data/catalog'
 import { neverCase } from '@wollybeard/kit/language'
+import { Effect, Match } from 'effect'
+import React from 'react'
 import { useParams } from 'react-router'
+import { catalogBridge, hasCatalog } from '../catalog-bridge.js'
 import { Field } from '../components/Field.js'
 import { MissingSchema } from '../components/MissingSchema.js'
 import { NamedType } from '../components/NamedType.js'
 import { VersionPicker } from '../components/VersionPicker.js'
-import { SchemaLifecycleProvider } from '../contexts/SchemaLifecycleContext.js'
+import { GraphqlLifecycleProvider } from '../contexts/GraphqlLifecycleContext.js'
 import { SidebarLayout } from '../layouts/index.js'
-import { schemaSource } from '../sources/schema-source.js'
 
-export const loader = createLoader(async ({ params }) => {
-  // Handle both versioned and unversioned routes:
-  // - Versioned: /reference/version/:version/:type → params.version exists
-  // - Unversioned: /reference/:type → params.version is undefined, defaults to latest
-  const currentVersion = params.version ?? Api.Schema.VERSION_LATEST
-
-  const schema = await schemaSource.get(currentVersion)
-  const availableVersions = schemaSource.versions
+const routeSchema = S.Struct({
+  catalog: Catalog.Catalog,
+  schema: Schema.Schema,
+})
 
-  // Load lifecycle data if available
-  const lifecycle = await schemaSource.getLifecycle()
+const referenceLoader = ({ params }: any) =>
+  catalogBridge.view().pipe(
+    Effect.map(catalog => {
+      // Resolve the actual schema based on catalog type and params
+      const schema = Match.value(catalog).pipe(
+        Match.tagsExhaustive({
+          CatalogUnversioned: (c) => c.schema,
+          CatalogVersioned: (c) => {
+            // If version param provided, find that specific version
+            if (params.version) {
+              const requestedVersion = Version.decodeSync(params.version)
+              const found = c.entries.find(s => Version.equivalence(requestedVersion, s.version))
+              if (!found) {
+                // TODO: Return 404 error
+                throw new Error(`Version ${params.version} not found`)
+              }
+              return found
+            }
+            // No version param means "latest" - use the last entry
+            const latest = c.entries[c.entries.length - 1]
+            if (!latest) {
+              throw new Error('No schemas available in versioned catalog')
+            }
+            return latest
+          },
+        }),
+      )
 
-  return {
-    schema,
-    currentVersion,
-    availableVersions,
-    lifecycle,
-  }
-})
+      return {
+        catalog,
+        schema,
+      }
+    }),
+  )
 
 // Single component that handles all reference route variations
 const ReferenceView = () => {
   const params = useParams() as { version?: string; type?: string; field?: string }
-  const data = useLoaderData<typeof loader>()
+  const loaderData = useLoaderData(routeSchema)
+  const { catalog, schema } = loaderData
+
+  // Create lifecycles from schema
+  const lifecycle = React.useMemo(() => Lifecycles.createFromSchema(schema), [schema])
 
-  if (!data.schema) {
+  if (!schema) {
+    // this would be some sort of internal error, make issue more clear.
     return <MissingSchema />
   }
 
   // Build reference sidebar from schema types
-  const kindMap = GrafaidOld.getKindMap(data.schema)
+  const kindMap = GrafaidOld.getKindMap(schema.definition)
 
   const sidebarItems: Content.Item[] = []
   const kindEntries = Object.entries(kindMap.list).filter(([_, types]) => types.length > 0)
@@ -64,14 +94,16 @@ const ReferenceView = () => {
     })
   }
 
-  // Calculate basePath based on current version
-  const basePath = Api.Schema.Routing.createReferenceBasePath(data.currentVersion)
+  // Calculate basePath based on schema version
+  const basePath = Api.Schema.Routing.createReferenceBasePath(
+    Schema.getVersion(schema),
+  )
 
   // Determine view type and render appropriate content
   const viewType = Api.Schema.Routing.getReferenceViewType({
-    schema: data.schema,
-    type: params.type,
-    field: params.field,
+    schema: schema,
+    type: params.type || '',
+    field: params.field || '',
   })
 
   const content: React.ReactNode = (() => {
@@ -80,10 +112,10 @@ const ReferenceView = () => {
     } else if (viewType === 'type-missing' || viewType === 'field-missing') {
       return <MissingSchema />
     } else if (viewType === 'type') {
-      const type = data.schema.getType(params.type!)!
+      const type = schema.definition.getType(params.type!)!
       return <NamedType data={type} />
     } else if (viewType === 'field') {
-      const type = data.schema.getType(params.type!)!
+      const type = schema.definition.getType(params.type!)!
       const fields = (type as any).getFields()
       const field = fields[params.field!]
       return (
@@ -98,40 +130,49 @@ const ReferenceView = () => {
   })()
 
   return (
-    <SchemaLifecycleProvider lifecycle={data.lifecycle} currentVersion={data.currentVersion}>
+    <GraphqlLifecycleProvider lifecycle={lifecycle} schema={schema}>
       <SidebarLayout
         sidebar={sidebarItems}
         basePath={basePath}
-        topContent={
-          <VersionPicker
-            all={[...data.availableVersions]} // Convert readonly to mutable
-            current={data.currentVersion}
-          />
-        }
+        topContent={(() => {
+          const version = Schema.getVersion(schema)
+          return catalog._tag === 'CatalogVersioned' && version
+            ? (
+              <VersionPicker
+                data={catalog.entries.map(entry => entry.version)}
+                current={version}
+              />
+            )
+            : null
+        })()}
       >
         {content}
       </SidebarLayout>
-    </SchemaLifecycleProvider>
+    </GraphqlLifecycleProvider>
   )
 }
 
 // Define routes that handle type and field params
 const typeAndFieldRoutes = [
-  routeIndex({
+  route({
+    index: true,
     Component: ReferenceView,
-    loader,
+    loader: referenceLoader,
+    schema: routeSchema,
   }),
   route({
     path: `:type`,
     Component: ReferenceView,
     errorElement: <MissingSchema />,
-    loader,
+    loader: referenceLoader,
+    schema: routeSchema,
     children: [
       route({
         path: `:field`,
         Component: ReferenceView,
         errorElement: <MissingSchema />,
-        loader,
+        loader: referenceLoader,
+        schema: routeSchema,
       }),
     ],
   }),
@@ -143,13 +184,19 @@ const typeAndFieldRoutes = [
  * - Leaf routes have components and loaders that always run fresh
  * - Single ReferenceView component handles all variations
  */
-export const reference = route({
-  path: `reference`,
-  children: [
-    ...typeAndFieldRoutes,
-    route({
-      path: `version/:version`,
-      children: typeAndFieldRoutes,
-    }),
-  ],
-})
+
+export const reference = !hasCatalog()
+  ? null
+  : route({
+    path: `reference`,
+    children: [
+      ...typeAndFieldRoutes,
+      // Only add version routes if versioned
+      ...(Catalog.Versioned.is(catalog)
+        ? [route({
+          path: `version/:version`,
+          children: typeAndFieldRoutes,
+        })]
+        : []),
+    ],
+  })

package/src/template/routes/root.tsx

@@ -1,16 +1,21 @@
+import type { NavbarProps } from '#api/hooks/types'
 import type { ReactRouter } from '#dep/react-router/index'
-import { route } from '#lib/react-router-aid/react-router-aid'
-import { createLoader } from '#lib/react-router-loader/react-router-loader'
+import { S } from '#lib/kit-temp/effect'
+import { route } from '#lib/react-router-effect/route'
 import type { Stores } from '#template/stores/$'
 import { Box, Flex, Theme } from '@radix-ui/themes'
+
+const schema = S.Struct({})
 import { Link as LinkReactRouter } from 'react-router'
 import { Outlet, ScrollRestoration } from 'react-router'
 import logoSrc from 'virtual:polen/project/assets/logo.svg'
-import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
-import PROJECT_SCHEMA from 'virtual:polen/project/schema.jsonsuper'
+import PROJECT_DATA from 'virtual:polen/project/data.json'
+import * as projectHooks from 'virtual:polen/project/hooks'
+import PROJECT_SCHEMA from 'virtual:polen/project/schema.json'
 import { templateVariables } from 'virtual:polen/template/variables'
-import { Link as PolenLink } from '../components/Link.js'
 import { Logo } from '../components/Logo.js'
+import { DefaultNavbar } from '../components/navbar/DefaultNavbar.js'
+import { Item } from '../components/navbar/Item.js'
 import { NotFound } from '../components/NotFound.js'
 import { ThemeToggle } from '../components/ThemeToggle.js'
 import { ToastContainer } from '../components/ToastContainer.js'
@@ -34,16 +39,10 @@ export const Component = () => {
 const Layout = () => {
   const { appearance } = useTheme()
 
-  const header = (
-    <Flex
-      align='center'
-      gap={{ initial: `4`, md: `8` }}
-      pb='4'
-      mb={{ initial: `4`, md: `8` }}
-      style={{
-        borderBottom: `1px solid var(--gray-3)`,
-      }}
-    >
+  const navbarProps: NavbarProps = {
+    items: PROJECT_DATA.navbar,
+    Item,
+    Logo: () => (
       <LinkReactRouter
         to='/'
         style={{ color: `inherit`, textDecoration: `none` }}
@@ -57,25 +56,23 @@ const Layout = () => {
           />
         </Box>
       </LinkReactRouter>
-      <Flex direction='row' gap='4' style={{ flex: 1 }}>
-        {PROJECT_DATA.navbar
-          .filter(item => item.position !== 'right')
-          .map((item, key) => (
-            <PolenLink key={key} color='gray' to={item.pathExp}>
-              {item.title}
-            </PolenLink>
-          ))}
-      </Flex>
-      <Flex direction='row' gap='4'>
-        {PROJECT_DATA.navbar
-          .filter(item => item.position === 'right')
-          .map((item, key) => (
-            <PolenLink key={key} color='gray' to={item.pathExp}>
-              {item.title}
-            </PolenLink>
-          ))}
-      </Flex>
-      <ThemeToggle />
+    ),
+    ThemeToggle,
+  }
+
+  const NavbarComponent = projectHooks.navbar || DefaultNavbar
+
+  const header = (
+    <Flex
+      align='center'
+      gap={{ initial: `4`, md: `8` }}
+      pb='4'
+      mb={{ initial: `4`, md: `8` }}
+      style={{
+        borderBottom: `1px solid var(--gray-3)`,
+      }}
+    >
+      <NavbarComponent {...navbarProps} />
     </Flex>
   )
 
@@ -110,7 +107,9 @@ const children: ReactRouter.RouteObject[] = [index, pages]
 
 if (PROJECT_SCHEMA) {
   children.push(changelog)
-  children.push(reference)
+  if (reference) {
+    children.push(reference)
+  }
 }
 
 //
@@ -122,14 +121,14 @@ if (PROJECT_SCHEMA) {
 //
 //
 
-const notFoundRoute = route({
+const notFoundRoute = {
   id: `*_not_found`,
   path: `*`,
   Component: NotFound,
   handle: {
     statusCode: 404,
   },
-})
+}
 children.push(notFoundRoute)
 
 //
@@ -147,7 +146,8 @@ const storeModules = import.meta.glob('../stores/!($.*)*.ts', { eager: true }) a
 export const root = route({
   path: `/`,
   Component,
-  loader: createLoader(async () => {
+  schema,
+  loader: async () => {
     // Reset all stores on SSR to prevent cross-request pollution
     if (import.meta.env.SSR) {
       for (const module of Object.values(storeModules)) {
@@ -158,6 +158,6 @@ export const root = route({
     }
 
     return {}
-  }),
+  },
   children,
 })

package/src/template/server/create-page-html-response.ts

@@ -3,7 +3,7 @@ import type { Hono } from '#dep/hono/index'
 import type { ReactRouter } from '#dep/react-router/index'
 import { React } from '#dep/react/index'
 import { ResponseInternalServerError } from '#lib/kit-temp'
-import type { ReactRouterAid } from '#lib/react-router-aid'
+import type { RouteHandle } from '#lib/react-router-effect/react-router-effect'
 import * as Theme from '#lib/theme/theme'
 import { Arr } from '@wollybeard/kit'
 import * as ReactDomServer from 'react-dom/server'
@@ -99,7 +99,7 @@ const getStatusCode = (
   }
 
   // Then check for custom status in route handle
-  const handle = Arr.getLast(context.matches)?.route.handle as ReactRouterAid.RouteHandle | undefined
+  const handle = Arr.getLast(context.matches)?.route.handle as RouteHandle | undefined
   if (handle?.statusCode) {
     return handle.statusCode
   }

package/src/template/server/main.ts

@@ -1,21 +1,21 @@
 import { serve } from '@hono/node-server' // TODO: support non-node platforms.
+import { Path } from '@wollybeard/kit'
 import { neverCase } from '@wollybeard/kit/language'
-import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
+import PROJECT_DATA from 'virtual:polen/project/data.json'
 import { createApp } from './app.js'
-import { generate } from './ssg/generate.js'
-import { view } from './view.js'
 
 if (__BUILDING__) {
   switch (__BUILD_ARCHITECTURE__) {
     case `ssg`:
-      await generate(view)
-      break
     case `ssr`:
       const port = process.env[`PORT`] ? parseInt(process.env[`PORT`]) : PROJECT_DATA.server.port
       const app = createApp({
         paths: {
           assets: {
-            directory: PROJECT_DATA.paths.project.relative.build.relative.assets.root,
+            directory: Path.join(
+              PROJECT_DATA.paths.project.relative.build.root,
+              PROJECT_DATA.paths.project.relative.build.relative.assets.root,
+            ),
             route: PROJECT_DATA.server.routes.assets,
           },
           base: PROJECT_DATA.basePath,
@@ -24,7 +24,7 @@ if (__BUILDING__) {
       serve({ fetch: app.fetch, port })
       break
     case `spa`:
-      throw new Error(`Sorry, SPA build type not supported`)
+      throw new Error(`SPA build type not yet supported.`)
     default:
       neverCase(__BUILD_ARCHITECTURE__)
   }

package/src/template/server/view.ts

@@ -1,7 +1,9 @@
 import { createStaticHandler } from 'react-router'
-import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
+import PROJECT_DATA from 'virtual:polen/project/data.json'
 import { routes } from '../routes.js'
 
 export const view = createStaticHandler(routes, {
-  basename: PROJECT_DATA.basePath === `/` ? undefined : PROJECT_DATA.basePath.slice(0, -1), // Remove trailing slash for React Router
+  ...(PROJECT_DATA.basePath !== '/' && {
+    basename: PROJECT_DATA.basePath.slice(0, -1), // Remove trailing slash for React Router
+  }),
 })

package/src/template/stores/$$.ts

@@ -4,6 +4,9 @@ export { store as schema } from './schema.js'
 export * as Toast from './toast.js'
 export { store as toast } from './toast.js'
 
+export * as Changelog from './changelog.js'
+export { store as changelog } from './changelog.js'
+
 export interface Store {
   reset: () => void
   set: (data?: unknown) => void

package/src/template/stores/changelog.ts

@@ -0,0 +1,87 @@
+import { Revision } from '#lib/revision/$'
+import { Schema as SchemaLib } from '#lib/schema/$'
+import { Version } from '#lib/version/$'
+import { Schema as S } from 'effect'
+import { proxy } from 'valtio'
+
+// ============================================================================
+// Schema Definitions
+// ============================================================================
+
+/**
+ * State for each version - what revision is currently selected
+ */
+export const VersionState = S.Struct({
+  currentRevision: S.NullOr(Revision.Revision),
+})
+
+export type VersionState = S.Schema.Type<typeof VersionState>
+
+/**
+ * The changelog page state schema
+ */
+export const State = S.Struct({
+  // Using a plain object instead of HashMap for valtio compatibility
+  // Keys are Version.toString() results
+  versionMemory: S.Record({
+    key: S.String,
+    value: VersionState,
+  }),
+})
+
+export type State = S.Schema.Type<typeof State>
+
+// ============================================================================
+// Initial State
+// ============================================================================
+
+export const initialState: State = {
+  versionMemory: {},
+}
+
+// ============================================================================
+// Store
+// ============================================================================
+
+/**
+ * Changelog store
+ *
+ * Manages navigation state for the changelog page, remembering
+ * which revision was selected for each version during the session.
+ */
+export const store = proxy({
+  ...initialState,
+
+  /**
+   * Remember the current revision for a version
+   */
+  rememberRevision(schema: SchemaLib.Versioned.Versioned, revision: Revision.Revision | null) {
+    const versionKey = Version.toString(schema.version)
+    store.versionMemory = {
+      ...store.versionMemory,
+      [versionKey]: { currentRevision: revision },
+    }
+  },
+
+  /**
+   * Get the remembered revision for a version
+   */
+  getRememberedRevision(schema: SchemaLib.Versioned.Versioned): Revision.Revision | null {
+    const versionKey = Version.toString(schema.version)
+    return store.versionMemory[versionKey]?.currentRevision ?? null
+  },
+
+  /**
+   * Reset store to initial state
+   */
+  reset() {
+    Object.assign(store, initialState)
+  },
+
+  /**
+   * Set store state
+   */
+  set(data: State) {
+    Object.assign(store, data)
+  },
+})

package/src/template/stores/schema.ts

@@ -1,27 +1,39 @@
+import { Schema as S } from 'effect'
 import type { GraphQLSchema } from 'graphql'
 import { proxy, ref } from 'valtio'
 
+// ============================================================================
+// Schema Definitions
+// ============================================================================
+
 /**
- * Schema store state interface
+ * Schema store state
  */
-export interface State {
+export const State = S.Struct({
   /** Currently selected schema version */
-  currentVersion: string
+  currentVersion: S.String,
   /** All available schema versions */
-  availableVersions: string[]
+  availableVersions: S.mutable(S.Array(S.String)),
   /** Currently loaded GraphQL schema instance */
-  currentSchema: GraphQLSchema | null
-}
+  currentSchema: S.NullOr(S.Any), // GraphQL schema is too complex to model
+})
+
+export type State = S.Schema.Type<typeof State>
+
+// ============================================================================
+// Initial State
+// ============================================================================
 
-/**
- * Initial state for the schema store
- */
 export const initialState: State = {
   currentVersion: 'latest',
   availableVersions: [],
   currentSchema: null,
 }
 
+// ============================================================================
+// Store
+// ============================================================================
+
 /**
  * Schema store
  *
@@ -43,7 +55,6 @@ export const store = proxy({
    * @param data - New state data
    */
   set(data: State) {
-    // Set each property individually to avoid issues with complex objects
     store.currentVersion = data.currentVersion
     store.availableVersions = data.availableVersions
     // Use ref() to prevent Valtio from deeply proxying the GraphQL schema