polen 0.11.0-next.18 → 0.11.0-next.19

package/src/api/schema/input-source/input-source.ts

@@ -1,4 +1,5 @@
 import { InputSource } from '#api/schema/input-source/$'
+import type { InputSourceError } from '#api/schema/input-source/errors'
 import type { Catalog } from '#lib/catalog/$'
 import type { PlatformError } from '@effect/platform/Error'
 import type { FileSystem } from '@effect/platform/FileSystem'
@@ -7,28 +8,6 @@ import { Effect } from 'effect'
 
 type Options = object
 
-// ============================================================================
-// Error Types
-// ============================================================================
-
-export interface InputSourceError {
-  readonly _tag: 'InputSourceError'
-  readonly source: string
-  readonly message: string
-  readonly cause?: unknown
-}
-
-export const InputSourceError = (
-  source: string,
-  message: string,
-  cause?: unknown,
-): InputSourceError => ({
-  _tag: 'InputSourceError',
-  source,
-  message,
-  cause,
-})
-
 // ============================================================================
 // Effect-based InputSource
 // ============================================================================

package/src/api/schema/input-sources/directory.ts

@@ -1,4 +1,5 @@
 import { InputSource } from '#api/schema/input-source/$'
+import { InputSourceError } from '#api/schema/input-source/errors'
 import { Catalog } from '#lib/catalog/$'
 import { Change } from '#lib/change/$'
 import { DateOnly } from '#lib/date-only/$'
@@ -178,7 +179,7 @@ export const loader = InputSource.createEffect({
 
 const read = (
   revisionInputs: { date: DateOnly.DateOnly; filePath: string }[],
-): Effect.Effect<Schema.Unversioned.Unversioned, InputSource.InputSourceError | PlatformError, FileSystem> =>
+): Effect.Effect<Schema.Unversioned.Unversioned, InputSourceError | PlatformError, FileSystem> =>
   Effect.gen(function*() {
     const revisionInputsLoaded = yield* Effect.all(
       Arr.map(revisionInputs, (revisionInput) =>
@@ -187,20 +188,20 @@ const read = (
           const content = yield* fs.readFileString(revisionInput.filePath)
           const ast = yield* Grafaid.Schema.AST.parse(content).pipe(
             Effect.mapError((error) =>
-              InputSource.InputSourceError(
-                'directory',
-                `Failed to parse schema file ${revisionInput.filePath}: ${error}`,
-                error,
-              )
+              new InputSourceError({
+                source: 'directory',
+                message: `Failed to parse schema file ${revisionInput.filePath}: ${error}`,
+                cause: error,
+              })
             ),
           )
           const schema = yield* Grafaid.Schema.fromAST(ast).pipe(
             Effect.mapError((error) =>
-              InputSource.InputSourceError(
-                'directory',
-                `Failed to build schema from ${revisionInput.filePath}: ${error}`,
-                error,
-              )
+              new InputSourceError({
+                source: 'directory',
+                message: `Failed to build schema from ${revisionInput.filePath}: ${error}`,
+                cause: error,
+              })
             ),
           )
 
@@ -230,7 +231,11 @@ const read = (
 
           const changes = yield* Change.calcChangeset({ before, after }).pipe(
             Effect.mapError((error) =>
-              InputSource.InputSourceError('directory', `Failed to calculate changeset: ${error}`, error)
+              new InputSourceError({
+                source: 'directory',
+                message: `Failed to calculate changeset: ${error}`,
+                cause: error,
+              })
             ),
           )
 
@@ -245,7 +250,7 @@ const read = (
     // Get the latest schema (first in the array after sorting newest first)
     const latestSchemaData = revisionInputsSorted[0]?.schema
     if (!latestSchemaData) {
-      return yield* Effect.fail(InputSource.InputSourceError('directory', 'No schema files found'))
+      return yield* Effect.fail(new InputSourceError({ source: 'directory', message: 'No schema files found' }))
     }
 
     // Create unversioned schema with full revisions

package/src/api/schema/input-sources/file.ts

@@ -5,7 +5,6 @@ import { DateOnly } from '#lib/date-only/$'
 import { Grafaid } from '#lib/grafaid'
 import { Revision } from '#lib/revision/$'
 import { Schema } from '#lib/schema/$'
-import { PlatformError } from '@effect/platform/Error'
 import { FileSystem } from '@effect/platform/FileSystem'
 import { Path } from '@wollybeard/kit'
 import { Effect } from 'effect'
@@ -76,18 +75,32 @@ export const loader = InputSource.createEffect({
 
       const ast = yield* Grafaid.Schema.AST.parse(content).pipe(
         Effect.mapError((error) =>
-          InputSource.InputSourceError('file', `Failed to parse schema file: ${error}`, error)
+          new InputSource.InputSourceError({
+            source: 'file',
+            message: `Failed to parse schema file: ${error}`,
+            cause: error,
+          })
         ),
       )
       const after = yield* Grafaid.Schema.fromAST(ast).pipe(
-        Effect.mapError((error) => InputSource.InputSourceError('file', `Failed to build schema: ${error}`, error)),
+        Effect.mapError((error) =>
+          new InputSource.InputSourceError({
+            source: 'file',
+            message: `Failed to build schema: ${error}`,
+            cause: error,
+          })
+        ),
       )
 
       const date = new Date()
       const before = Grafaid.Schema.empty
       const changes = yield* Change.calcChangeset({ before, after }).pipe(
         Effect.mapError((error) =>
-          InputSource.InputSourceError('file', `Failed to calculate changeset: ${error}`, error)
+          new InputSource.InputSourceError({
+            source: 'file',
+            message: `Failed to calculate changeset: ${error}`,
+            cause: error,
+          })
         ),
       )
 

package/src/api/schema/input-sources/introspection-file.ts

@@ -80,7 +80,11 @@ export const read = (
 
     const introspectionFileContent = yield* fs.readFileString(config.path).pipe(
       Effect.mapError((error) =>
-        InputSource.InputSourceError('introspectionFile', `Failed to read file ${config.path}: ${error}`, error)
+        new InputSource.InputSourceError({
+          source: 'introspectionFile',
+          message: `Failed to read file ${config.path}: ${error}`,
+          cause: error,
+        })
       ),
     )
 
@@ -90,16 +94,20 @@ export const read = (
       try: () => Json.codec.decode(introspectionFileContent),
       catch: (error) => {
         if (error instanceof SyntaxError) {
-          return InputSource.InputSourceError(
-            'introspectionFile',
-            `Invalid JSON in ${config.path}: ${error.message}`,
-            error,
+          return new InputSource.InputSourceError(
+            {
+              source: 'introspectionFile',
+              message: `Invalid JSON in ${config.path}: ${error.message}`,
+              cause: error,
+            },
           )
         }
-        return InputSource.InputSourceError(
-          'introspectionFile',
-          `Failed to parse JSON in ${config.path}: ${error}`,
-          error,
+        return new InputSource.InputSourceError(
+          {
+            source: 'introspectionFile',
+            message: `Failed to parse JSON in ${config.path}: ${error}`,
+            cause: error,
+          },
         )
       },
     })
@@ -107,7 +115,10 @@ export const read = (
     // Validate introspection data structure before passing to fromIntrospectionQuery
     if (!introspectionData || typeof introspectionData !== 'object') {
       return yield* Effect.fail(
-        InputSource.InputSourceError('introspectionFile', 'Introspection data must be a valid JSON object'),
+        new InputSource.InputSourceError({
+          source: 'introspectionFile',
+          message: 'Introspection data must be a valid JSON object',
+        }),
       )
     }
 
@@ -115,10 +126,10 @@ export const read = (
     // It will provide more specific GraphQL-related error messages
     if (!('data' in introspectionData)) {
       return yield* Effect.fail(
-        InputSource.InputSourceError(
-          'introspectionFile',
-          'Introspection data missing required "data" property (expected GraphQL introspection result format)',
-        ),
+        new InputSource.InputSourceError({
+          source: 'introspectionFile',
+          message: 'Introspection data missing required "data" property (expected GraphQL introspection result format)',
+        }),
       )
     }
 
@@ -144,7 +155,11 @@ const createCatalogFromSchema = (
       after,
     }).pipe(
       Effect.mapError((error) =>
-        InputSource.InputSourceError('introspectionFile', `Failed to calculate changeset: ${error}`, error)
+        new InputSource.InputSourceError({
+          source: 'introspectionFile',
+          message: `Failed to calculate changeset: ${error}`,
+          cause: error,
+        })
       ),
     )
 

package/src/api/schema/input-sources/introspection.ts

@@ -150,7 +150,12 @@ export const loader = InputSource.createEffect({
       // Try to read from cache
       const cacheEntry = yield* Effect.tryPromise({
         try: () => readCache(cachePath),
-        catch: (error) => InputSource.InputSourceError('introspection', `Failed to read cache: ${error}`, error),
+        catch: (error) =>
+          new InputSource.InputSourceError({
+            source: 'introspection',
+            message: `Failed to read cache: ${error}`,
+            cause: error,
+          }),
       })
 
       let schema: Grafaid.Schema.Schema
@@ -162,7 +167,11 @@ export const loader = InputSource.createEffect({
         // Fetch fresh introspection
         schema = yield* fetchIntrospection(options).pipe(
           Effect.mapError((error) =>
-            InputSource.InputSourceError('introspection', `Failed to fetch introspection: ${error}`, error)
+            new InputSource.InputSourceError({
+              source: 'introspection',
+              message: `Failed to fetch introspection: ${error}`,
+              cause: error,
+            })
           ),
         )
 
@@ -176,13 +185,22 @@ export const loader = InputSource.createEffect({
 
         yield* Effect.tryPromise({
           try: () => writeCache(cachePath, newCacheEntry),
-          catch: (error) => InputSource.InputSourceError('introspection', `Failed to write cache: ${error}`, error),
+          catch: (error) =>
+            new InputSource.InputSourceError({
+              source: 'introspection',
+              message: `Failed to write cache: ${error}`,
+              cause: error,
+            }),
         })
       }
 
       return yield* createCatalogFromSchema(schema).pipe(
         Effect.mapError((error) =>
-          InputSource.InputSourceError('introspection', `Failed to create catalog: ${error}`, error)
+          new InputSource.InputSourceError({
+            source: 'introspection',
+            message: `Failed to create catalog: ${error}`,
+            cause: error,
+          })
         ),
       )
     }),
@@ -196,7 +214,11 @@ export const loader = InputSource.createEffect({
       // Force fresh introspection
       const schema = yield* fetchIntrospection(options).pipe(
         Effect.mapError((error) =>
-          InputSource.InputSourceError('introspection', `Failed to fetch introspection: ${error}`, error)
+          new InputSource.InputSourceError({
+            source: 'introspection',
+            message: `Failed to fetch introspection: ${error}`,
+            cause: error,
+          })
         ),
       )
 
@@ -210,12 +232,21 @@ export const loader = InputSource.createEffect({
 
       yield* Effect.tryPromise({
         try: () => writeCache(cachePath, newCacheEntry),
-        catch: (error) => InputSource.InputSourceError('introspection', `Failed to write cache: ${error}`, error),
+        catch: (error) =>
+          new InputSource.InputSourceError({
+            source: 'introspection',
+            message: `Failed to write cache: ${error}`,
+            cause: error,
+          }),
       })
 
       return yield* createCatalogFromSchema(schema).pipe(
         Effect.mapError((error) =>
-          InputSource.InputSourceError('introspection', `Failed to create catalog: ${error}`, error)
+          new InputSource.InputSourceError({
+            source: 'introspection',
+            message: `Failed to create catalog: ${error}`,
+            cause: error,
+          })
         ),
       )
     }),

package/src/api/schema/input-sources/memory.ts

@@ -122,10 +122,22 @@ const parseSchema = (value: string | GraphQLSchema): Effect.Effect<GraphQLSchema
   Effect.gen(function*() {
     if (typeof value === 'string') {
       const ast = yield* Grafaid.Schema.AST.parse(value).pipe(
-        Effect.mapError((error) => InputSource.InputSourceError('memory', `Failed to parse schema: ${error}`, error)),
+        Effect.mapError((error) =>
+          new InputSource.InputSourceError({
+            source: 'memory',
+            message: `Failed to parse schema: ${error}`,
+            cause: error,
+          })
+        ),
       )
       return yield* Grafaid.Schema.fromAST(ast).pipe(
-        Effect.mapError((error) => InputSource.InputSourceError('memory', `Failed to build schema: ${error}`, error)),
+        Effect.mapError((error) =>
+          new InputSource.InputSourceError({
+            source: 'memory',
+            message: `Failed to build schema: ${error}`,
+            cause: error,
+          })
+        ),
       )
     }
     return value // Already a GraphQLSchema
@@ -186,7 +198,11 @@ export const read = (
 
             changes = yield* Change.calcChangeset({ before, after }).pipe(
               Effect.mapError((error) =>
-                InputSource.InputSourceError('memory', `Failed to calculate changeset: ${error}`, error)
+                new InputSource.InputSourceError({
+                  source: 'memory',
+                  message: `Failed to calculate changeset: ${error}`,
+                  cause: error,
+                })
               ),
             )
           }

package/src/api/schema/input-sources/versioned-directory.ts

@@ -203,20 +203,20 @@ export const readOrThrow = (
                 const content = yield* fs.readFileString(filePath)
                 const ast = yield* Grafaid.Schema.AST.parse(content).pipe(
                   Effect.mapError((error) =>
-                    InputSource.InputSourceError(
-                      'versionedDirectory',
-                      `Failed to parse schema from ${filePath}: ${error}`,
-                      error,
-                    )
+                    new InputSource.InputSourceError({
+                      source: 'versionedDirectory',
+                      message: `Failed to parse schema from ${filePath}: ${error}`,
+                      cause: error,
+                    })
                   ),
                 )
                 const schema = yield* Grafaid.Schema.fromAST(ast).pipe(
                   Effect.mapError((error) =>
-                    InputSource.InputSourceError(
-                      'versionedDirectory',
-                      `Failed to build schema from ${filePath}: ${error}`,
-                      error,
-                    )
+                    new InputSource.InputSourceError({
+                      source: 'versionedDirectory',
+                      message: `Failed to build schema from ${filePath}: ${error}`,
+                      cause: error,
+                    })
                   ),
                 )
 
@@ -285,11 +285,11 @@ export const readOrThrow = (
 
                 const changes = yield* Change.calcChangeset({ before, after }).pipe(
                   Effect.mapError((error) =>
-                    InputSource.InputSourceError(
-                      'versionedDirectory',
-                      `Failed to calculate changeset for ${version.name}: ${error}`,
-                      error,
-                    )
+                    new InputSource.InputSourceError({
+                      source: 'versionedDirectory',
+                      message: `Failed to calculate changeset for ${version.name}: ${error}`,
+                      cause: error,
+                    })
                   ),
                 )
 
@@ -330,11 +330,11 @@ export const readOrThrow = (
 
                         const changes = yield* Change.calcChangeset({ before, after }).pipe(
                           Effect.mapError((error) =>
-                            InputSource.InputSourceError(
-                              'versionedDirectory',
-                              `Failed to calculate parent changeset: ${error}`,
-                              error,
-                            )
+                            new InputSource.InputSourceError({
+                              source: 'versionedDirectory',
+                              message: `Failed to calculate parent changeset: ${error}`,
+                              cause: error,
+                            })
                           ),
                         )
 

package/src/api/schema/load.ts

@@ -1,13 +1,14 @@
 import type { Config } from '#api/config/normalized'
 import { Augmentations } from '#api/schema/augmentations/$'
-import type { EffectInputSource, InputSource, InputSourceError } from '#api/schema/input-source/input-source'
+import type { InputSourceError } from '#api/schema/input-source/errors'
+import type { EffectInputSource, InputSource } from '#api/schema/input-source/input-source'
 import * as InputSourceLoader from '#api/schema/input-source/load'
 import { InputSources } from '#api/schema/input-sources/$'
 import { Catalog } from '#lib/catalog/$'
 import type { PlatformError } from '@effect/platform/Error'
 import type { FileSystem } from '@effect/platform/FileSystem'
 import { Arr } from '@wollybeard/kit'
-import { Array, Effect, Option } from 'effect'
+import { Effect } from 'effect'
 
 // For now, we'll need a type that accepts both promise and effect sources
 type AnyInputSource = InputSource | EffectInputSource

package/src/template/components/ReferenceVersionPicker.tsx

@@ -0,0 +1,107 @@
+import { Api } from '#api/iso'
+import type { React } from '#dep/react/index'
+import { Version } from '#lib/version/$'
+import { HashMap, Option } from 'effect'
+import { useNavigate } from 'react-router'
+import { schemasCatalog } from 'virtual:polen/project/schemas'
+import { useReferencePath } from '../hooks/useReferencePath.js'
+import { Stores } from '../stores/$.js'
+import { tryWithToast } from '../utils/try-with-toast.js'
+import { VersionPicker } from './VersionPicker.js'
+
+interface Props {
+  data: readonly Version.Version[]
+  current: Version.Version
+}
+
+export const ReferenceVersionPicker: React.FC<Props> = ({ data, current }) => {
+  const navigate = useNavigate()
+  const currentPath = useReferencePath()
+
+  const handleVersionChange = async (version: Version.Version) => {
+    const newVersion = Version.encodeSync(version)
+    const error = await tryWithToast(async () => {
+      // Get the full catalog to find the target schema
+      if (!schemasCatalog) {
+        throw new Error('No catalog available')
+      }
+      const catalog = schemasCatalog
+
+      // This component is only used for versioned catalogs
+      if (catalog._tag !== 'CatalogVersioned') {
+        throw new Error('VersionPicker used with non-versioned catalog')
+      }
+
+      // Find the schema for the target version
+      // Note: newVersion is a string that we need to parse
+      const targetSchemaOption = Option.map(
+        HashMap.findFirst(catalog.entries, (_, key) => Version.encodeSync(key) === newVersion),
+        ([, value]) => value,
+      )
+
+      if (Option.isNone(targetSchemaOption)) {
+        throw new Error(`Version ${newVersion} not found`)
+      }
+
+      const targetSchema = Option.getOrThrow(targetSchemaOption)
+
+      // Find fallback path if needed
+      const fallbackPath = Api.Schema.Validation.findFallbackPath(targetSchema.definition, currentPath)
+      // Get redirect description if path changed
+      const redirectDescription = Api.Schema.Validation.getRedirectDescription(
+        targetSchema.definition,
+        currentPath,
+        fallbackPath,
+        newVersion,
+      )
+      // Create the new path - parse newVersion string to Version type
+      const newPath = Api.Schema.Routing.createReferencePath({
+        version: Version.fromString(newVersion),
+        type: fallbackPath.type || '',
+        field: fallbackPath.field || '',
+      })
+      // Show toast notification if schema location redirect will occur
+      if (redirectDescription) {
+        Stores.Toast.store.info(redirectDescription, {
+          duration: 160_000,
+          actions: [
+            {
+              label: 'Go back',
+              onClick() {
+                navigate(-1)
+              },
+            },
+            {
+              label: 'View changelog',
+              onClick() {
+                // Navigate to changelog page
+                navigate('/changelog')
+              },
+            },
+          ],
+        })
+      }
+
+      navigate(newPath)
+    }, 'Failed to switch version')
+
+    // Fallback logic if error occurred
+    if (error) {
+      // Fallback to simple navigation if schema loading fails
+      const newPath = Api.Schema.Routing.createReferencePath({
+        version: Version.fromString(newVersion),
+        type: currentPath.type || '',
+        field: currentPath.field || '',
+      })
+      navigate(newPath)
+    }
+  }
+
+  return (
+    <VersionPicker
+      versions={data}
+      currentVersion={current}
+      onVersionChange={handleVersionChange}
+    />
+  )
+}