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

package/src/lib/version/version.ts

@@ -0,0 +1,222 @@
+import { S } from '#lib/kit-temp/effect'
+import { Equivalence, Match, Order, ParseResult } from 'effect'
+import { DateOnly } from '../date-only/$.js'
+import { Semver as SemverLib } from '../semver/$.js'
+import * as CustomVersion from './custom.js'
+import * as DateVersion from './date.js'
+import * as IntegerVersion from './integer.js'
+import * as SemverVersion from './semver.js'
+
+// Re-export member modules as namespaces
+export { CustomVersion, DateVersion, IntegerVersion, SemverVersion }
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+const VersionUnion = S.Union(
+  IntegerVersion.Integer,
+  SemverVersion.Semver,
+  DateVersion.Date,
+  CustomVersion.Custom,
+)
+
+/**
+ * Schema for version identifiers that supports multiple formats:
+ *
+ * - **Integer**: Simple numeric versions (1, 2, 3) - most common for GraphQL APIs
+ * - **Semver**: Semantic versions (1.0.0, 2.1.3) - typically not useful for GraphQL APIs since
+ *   patch/minor changes are usually realized as revisions rather than new versions
+ * - **Date**: ISO date versions (2024-01-15) - useful for time-based releases
+ * - **Custom**: Arbitrary string versions for any other format
+ *
+ * Parsing priority: Integer > Semver > Date > Custom
+ */
+export const Version = S.transformOrFail(
+  S.Union(S.String, S.Number),
+  VersionUnion,
+  {
+    strict: true,
+    decode: (input, _, ast) => {
+      // Try parsing as integer first
+      if (typeof input === 'number' && Number.isInteger(input)) {
+        return ParseResult.succeed(IntegerVersion.make({ value: input }))
+      }
+
+      // Try parsing string as integer
+      if (typeof input === 'string') {
+        const parsed = Number(input)
+        if (Number.isInteger(parsed) && parsed.toString() === input) {
+          return ParseResult.succeed(IntegerVersion.make({ value: parsed }))
+        }
+      }
+
+      // For string inputs, continue with existing logic
+      if (typeof input === 'string') {
+        // Try parsing as semver
+        try {
+          SemverLib.decodeSync(input) // Validate it's a valid semver
+          return ParseResult.succeed(SemverVersion.make({ value: input }))
+        } catch {
+          // Not a semver, continue
+        }
+
+        // Try parsing as ISO date
+        try {
+          const dateOnly = DateOnly.decodeSync(input)
+          return ParseResult.succeed(DateVersion.make({ value: dateOnly }))
+        } catch {
+          // Not an ISO date, continue
+        }
+
+        // Fall back to custom version
+        return ParseResult.succeed(CustomVersion.make({ value: input }))
+      }
+
+      return ParseResult.fail(new ParseResult.Type(ast, input))
+    },
+    encode: (version) => {
+      switch (version._tag) {
+        case 'VersionInteger':
+          return ParseResult.succeed(version.value)
+        case 'VersionSemver':
+          return ParseResult.succeed(version.value)
+        case 'VersionDate':
+          return ParseResult.succeed(version.value)
+        case 'VersionCustom':
+          return ParseResult.succeed(version.value)
+      }
+    },
+  },
+)
+
+export type Version = S.Schema.Type<typeof Version>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+// Note: No make constructor for transform schemas - use fromString instead
+
+// ============================================================================
+// Ordering
+// ============================================================================
+
+/**
+ * Order versions with type precedence: Integer > Semver > Date > Custom
+ * Within each type, use natural ordering
+ */
+export const order: Order.Order<Version> = Order.make((a, b) => {
+  // Different types - use type precedence
+  if (a._tag !== b._tag) {
+    const typeOrder = { VersionInteger: 0, VersionSemver: 1, VersionDate: 2, VersionCustom: 3 }
+    const diff = typeOrder[a._tag] - typeOrder[b._tag]
+    return diff < 0 ? -1 : diff > 0 ? 1 : 0
+  }
+
+  // Same type - use type-specific ordering
+  switch (a._tag) {
+    case 'VersionInteger':
+      return Order.number(a.value, (b as IntegerVersion.Integer).value)
+    case 'VersionSemver': {
+      const semverA = SemverLib.decodeSync(a.value)
+      const semverB = SemverLib.decodeSync((b as SemverVersion.Semver).value)
+      return SemverLib.order(semverA, semverB)
+    }
+    case 'VersionDate':
+      return DateOnly.order(a.value, (b as DateVersion.Date).value)
+    case 'VersionCustom':
+      return Order.string(a.value, (b as CustomVersion.Custom).value)
+  }
+})
+
+export const min = Order.min(order)
+
+export const max = Order.max(order)
+
+export const lessThan = Order.lessThan(order)
+
+export const greaterThan = Order.greaterThan(order)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence: Equivalence.Equivalence<Version> = Equivalence.make((a, b) => {
+  if (a._tag !== b._tag) return false
+
+  switch (a._tag) {
+    case 'VersionInteger':
+      return a.value === (b as IntegerVersion.Integer).value
+    case 'VersionSemver': {
+      const semverA = SemverLib.decodeSync(a.value)
+      const semverB = SemverLib.decodeSync((b as SemverVersion.Semver).value)
+      return SemverLib.equivalence(semverA, semverB)
+    }
+    case 'VersionDate':
+      return DateOnly.equivalence(a.value, (b as DateVersion.Date).value)
+    case 'VersionCustom':
+      return a.value === (b as CustomVersion.Custom).value
+  }
+})
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Version)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Version)
+export const decodeSync = S.decodeSync(Version)
+export const encode = S.encode(Version)
+
+// ============================================================================
+// Importers
+// ============================================================================
+
+export const fromString = S.decodeSync(Version)
+
+/**
+ * Create a semver version
+ */
+export const fromSemver = (semver: SemverLib.Semver): Version =>
+  SemverVersion.make({ value: semver.version.toString() })
+
+/**
+ * Create a date version
+ */
+export const fromDateOnly = (date: DateOnly.DateOnly): Version => DateVersion.make({ value: date })
+
+/**
+ * Create an integer version
+ */
+export const fromInteger = (value: number): Version => IntegerVersion.make({ value })
+
+/**
+ * Create a custom version
+ */
+export const fromCustom = (value: string): Version => CustomVersion.make({ value })
+
+// ============================================================================
+// Domain Logic
+// ============================================================================
+
+/**
+ * Get the string representation of a version
+ */
+export const toString = (version: Version): string => {
+  switch (version._tag) {
+    case 'VersionInteger':
+      return version.value.toString()
+    case 'VersionSemver':
+      return version.value
+    case 'VersionDate':
+      return version.value
+    case 'VersionCustom':
+      return version.value
+  }
+}

package/src/lib/vite-plugin-json/vite-plugin-json.ts

@@ -59,7 +59,7 @@ export interface VitePluginJsonImportsOptions {
     }
   }
   /**
-   * Plugin name. Useful to customize if providing a custom codec e.g. `superjson`.
+   * Plugin name. Useful to customize if providing a custom codec.
    *
    * @default 'json'
    */
@@ -95,8 +95,7 @@ export const create = (options: VitePluginJsonImportsOptions = {}): Plugin => {
       if (!shouldHandle(id)) return
 
       try {
-        // Skip validation for superjson since the codec validates the envelope format
-        if (options.codec?.validate && !options.codec.importPath?.includes(`superjson`)) {
+        if (options.codec?.validate) {
           codec.parse(code)
         }
 

package/src/lib/vite-plugin-mdx/vite-plugin-mdx.ts

@@ -77,7 +77,9 @@ export const VitePluginMdx = (options?: Readonly<Options> | null): Plugin => {
           code,
           moduleType: `jsx`,
           // When MDX compiles to JS (not JSX), we don't need to set moduleType
-          map: compiled.map,
+          // Cast to any because vfile's Map type is compatible with Rolldown's source map
+          // but has minor type differences with exactOptionalPropertyTypes
+          map: compiled.map as any,
         }
 
         return sourceDescription

package/src/lib/vite-plugin-reactive-data/vite-plugin-reactive-data.ts

@@ -18,7 +18,7 @@ interface ReactiveDataOptions {
    */
   data: ComputedRef<object | unknown[]> | (() => object | unknown[]) | object | unknown[]
   /**
-   * JSON codec to use (e.g., superjson)
+   * JSON codec to use
    * Default: JSON
    * Only used when includeJsonPlugin is true
    */

package/src/project-data.ts

@@ -1,4 +1,4 @@
-import type { Config } from '#api/config/index'
+import type { Config } from '#api/config/$'
 import type { NavbarItem } from '#api/content/navbar'
 
 export interface ProjectData {

package/src/sandbox.ts

@@ -1 +1,15 @@
-// Temporary sandbox file for testing
+//
+//
+//
+//
+//
+// Temporary Work File
+//
+// ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
+//
+// – Use freely
+// – Try to remember to not commit changes
+// – Included by development TypeScript configuration
+// – Excluded by build TypeScript configuration
+//
+//

package/src/template/catalog-bridge.ts

@@ -0,0 +1,102 @@
+import { Catalog } from '#lib/catalog/$'
+import { Effect } from 'effect'
+import PROJECT_SCHEMA from 'virtual:polen/project/schema.json'
+
+// ============================================================================
+// Catalog Storage
+// ============================================================================
+
+// Store the catalog data directly in memory
+let catalogData: Catalog.Catalog
+
+if (PROJECT_SCHEMA) {
+  catalogData = Effect.runSync(Catalog.decode(PROJECT_SCHEMA as any))
+}
+
+// ============================================================================
+// Bridge API
+// ============================================================================
+
+/**
+ * Create a simplified catalog bridge without hydra
+ */
+const createCatalogBridge = () => {
+  const assertCatalogLoaded = () => {
+    if (!catalogData) {
+      throw new Error(
+        'No schema catalog available. This page requires a GraphQL schema to be configured. '
+          + 'Please ensure your Polen configuration includes a valid schema source.',
+      )
+    }
+  }
+
+  return {
+    /**
+     * Get the full catalog
+     */
+    view: () => {
+      assertCatalogLoaded()
+      return Effect.succeed(catalogData)
+    },
+
+    /**
+     * Set catalog data
+     */
+    setData: (data: Catalog.Catalog) => {
+      catalogData = data
+      return Effect.succeed(undefined)
+    },
+
+    /**
+     * Add a root value (for compatibility)
+     */
+    addRootValue: (value: Catalog.Catalog) => {
+      catalogData = value
+    },
+
+    /**
+     * Export to memory (for compatibility)
+     */
+    exportToMemory: () => {
+      if (!catalogData) return []
+      // Return as a single JSON blob instead of fragments
+      return [{
+        filename: 'catalog.json',
+        content: JSON.stringify(catalogData, null, 2),
+      }]
+    },
+
+    /**
+     * Export (for compatibility)
+     */
+    export: () => {
+      // No-op in simplified version
+      return Effect.succeed(undefined)
+    },
+
+    /**
+     * Import (for compatibility)
+     */
+    import: () => {
+      // No-op in simplified version - data is already loaded
+      return Effect.succeed(undefined)
+    },
+  }
+}
+
+// ============================================================================
+// Exported Instance
+// ============================================================================
+
+export const catalogBridge = createCatalogBridge()
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Check if catalog data is available
+ */
+export const hasCatalog = (): boolean => {
+  return catalogData !== undefined && catalogData !== null
+}

package/src/template/components/Changelog/ChangeBase.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change'
+import { Change as GraphqlChange } from '#lib/change/$'
 import type React from 'react'
 
 interface ChangeBaseProps {

package/src/template/components/Changelog/Changelog.tsx

@@ -0,0 +1,148 @@
+import { Catalog } from '#lib/catalog/$'
+import { Change } from '#lib/change/$'
+import { DateOnly } from '#lib/date-only/$'
+import { Revision } from '#lib/revision/$'
+import { Version } from '#lib/version/$'
+const CRITICALITY_LEVELS = ['BREAKING', 'DANGEROUS', 'NON_BREAKING'] as const
+import type { CriticalityLevel } from '@graphql-inspector/core'
+import { Box, Heading } from '@radix-ui/themes'
+import React, { useEffect } from 'react'
+import { useMemo } from 'react'
+import { useNavigate, useParams } from 'react-router'
+import { ComponentDispatch } from '../ComponentDispatch.js'
+import { CriticalitySection } from './CriticalitySection.js'
+import * as Group from './groups/index.js'
+
+export const renderDate = (dateOnly: DateOnly.DateOnly) => {
+  const date = DateOnly.toDate(dateOnly)
+  const year = date.getUTCFullYear()
+  return `${year} ${
+    date.toLocaleString('default', {
+      month: 'long',
+      day: 'numeric',
+      timeZone: 'UTC',
+    })
+  }`
+}
+
+export const Changelog: React.FC<{ catalog: Catalog.Catalog }> = ({ catalog }) => {
+  const params = useParams()
+  const navigate = useNavigate()
+  const urlVersion = params['version']
+
+  // Redirect to latest version if versioned catalog and no version specified
+  useEffect(() => {
+    if (urlVersion) return
+    if (Catalog.Unversioned.is(catalog)) return
+    const latestSchema = catalog.entries[0]
+    if (!latestSchema) return
+    const latestVersion = Version.toString(latestSchema.version)
+    navigate(`/changelog/version/${latestVersion}`, { replace: true })
+  }, [catalog, urlVersion, navigate])
+
+  // Get revisions based on catalog type and URL params
+  const revisions = useMemo(() => {
+    if (Catalog.Unversioned.is(catalog)) {
+      return catalog.schema.revisions
+    } else {
+      // For versioned catalogs, always show specific version (never all)
+      if (urlVersion) {
+        const entry = catalog.entries.find(e => Version.toString(e.version) === urlVersion)
+        return entry ? entry.revisions : []
+      }
+      // This shouldn't happen due to redirect above, but return empty as fallback
+      return []
+    }
+  }, [catalog, urlVersion])
+
+  // Don't render anything while redirecting
+  if (Catalog.Versioned.is(catalog) && !urlVersion) {
+    return null
+  }
+
+  return (
+    <Box>
+      {/* Title bar - always shown */}
+      <Heading size='5' style={{ padding: '1rem 0', borderBottom: '1px solid var(--gray-4)', marginBottom: '1.5rem' }}>
+        Changelog
+      </Heading>
+
+      {revisions.map(revision => <Changeset key={revision.date} revision={revision} />)}
+    </Box>
+  )
+}
+
+const Changeset: React.FC<{ revision: Revision.Revision }> = ({ revision }) => {
+  // Group changes by criticality level
+  const groupedChanges = useMemo(() => {
+    const groups = {} as Record<CriticalityLevel, Change.Change[]>
+
+    // Initialize empty arrays for each level
+    CRITICALITY_LEVELS.forEach(level => {
+      groups[level] = []
+    })
+
+    // Group changes - revisions always have changes array
+    revision.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],
+      }))
+  }, [revision])
+
+  return (
+    <Box mb='6' id={revision.date} style={{ scrollMarginTop: '2rem' }}>
+      <h1>
+        <a
+          href={`#${revision.date}`}
+          style={{
+            color: 'inherit',
+            textDecoration: 'none',
+            position: 'relative',
+          }}
+          onClick={(e) => {
+            e.preventDefault()
+            // Update URL hash
+            window.history.pushState(null, '', `#${revision.date}`)
+            // Dispatch custom event for pushState
+            window.dispatchEvent(new Event('pushstate'))
+            // Smooth scroll to element
+            document.getElementById(revision.date)?.scrollIntoView({ behavior: 'smooth' })
+          }}
+          onMouseEnter={(e) => {
+            e.currentTarget.style.textDecoration = 'underline'
+          }}
+          onMouseLeave={(e) => {
+            e.currentTarget.style.textDecoration = 'none'
+          }}
+        >
+          {renderDate(revision.date)}
+        </a>
+      </h1>
+      {groupedChanges.map(group => (
+        <CriticalitySection key={group.level} level={group.level} changes={group.changes}>
+          {group.changes.map((change, index) => {
+            const type = Change.getType(change)
+            return (
+              <ComponentDispatch
+                key={`${change._tag}-${change.path || change.message}-${index}`}
+                components={Group}
+                name={type}
+                props={{ change }}
+              />
+            )
+          })}
+        </CriticalitySection>
+      ))}
+    </Box>
+  )
+}

package/src/template/components/Changelog/ChangelogVersionPicker.tsx

@@ -0,0 +1,36 @@
+import { Select } from '@radix-ui/themes'
+import React from 'react'
+import { useNavigate } from 'react-router'
+
+interface Props {
+  versions: string[]
+  currentVersion: string
+}
+
+export const ChangelogVersionPicker: React.FC<Props> = ({ versions, currentVersion }) => {
+  const navigate = useNavigate()
+
+  // Don't show selector if only one version
+  if (versions.length <= 1) {
+    return null
+  }
+
+  const handleVersionChange = (newVersion: string) => {
+    navigate(`/changelog/version/${newVersion}`)
+  }
+
+  return (
+    <Select.Root value={currentVersion} onValueChange={handleVersionChange}>
+      <Select.Trigger>
+        Version {currentVersion}
+      </Select.Trigger>
+      <Select.Content>
+        {versions.map(version => (
+          <Select.Item key={version} value={version}>
+            Version {version}
+          </Select.Item>
+        ))}
+      </Select.Content>
+    </Select.Root>
+  )
+}

package/src/template/components/Changelog/CriticalitySection.tsx

@@ -1,5 +1,21 @@
-import type { GraphqlChange } from '#lib/graphql-change'
-import { CRITICALITY_CONFIG, type CriticalityLevel } from '#lib/graphql-change/criticality'
+import { Change as GraphqlChange } from '#lib/change/$'
+
+type CriticalityLevel = 'BREAKING' | 'DANGEROUS' | 'NON_BREAKING'
+
+const CRITICALITY_CONFIG = {
+  BREAKING: {
+    label: 'Breaking Changes',
+    color: 'red',
+  },
+  DANGEROUS: {
+    label: 'Dangerous Changes',
+    color: 'orange',
+  },
+  NON_BREAKING: {
+    label: 'Safe Changes',
+    color: 'green',
+  },
+} as const
 import { Heading } from '@radix-ui/themes'
 import type React from 'react'
 

package/src/template/components/Changelog/groups/DirectiveArgument.tsx

@@ -1,24 +1,23 @@
-import type { GraphqlChange } from '#lib/graphql-change'
+import { Change as GraphqlChange } from '#lib/change/$'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'
 
-export const DirectiveArgument: React.FC<{ change: GraphqlChange.Group.DirectiveArgument }> = ({ change }) => {
-  switch (change.type) {
+export const DirectiveArgument: React.FC<{ change: any }> = ({ change }) => {
+  switch (change._tag) {
     case `DIRECTIVE_ARGUMENT_DEFAULT_VALUE_CHANGED`:
       return (
         <ChangeBase change={change}>
-          Changed default value for directive <Code>@{change.meta.directiveName}</Code> argument{' '}
-          <Code>{change.meta.directiveArgumentName}</Code>
+          Changed default value for directive <Code>@{change.directiveName}</Code> argument{' '}
+          <Code>{change.argumentName}</Code>
         </ChangeBase>
       )
     case `DIRECTIVE_ARGUMENT_TYPE_CHANGED`:
       return (
         <ChangeBase change={change}>
-          Changed directive <Code>@{change.meta.directiveName}</Code> argument{' '}
-          <Code>{change.meta.directiveArgumentName}</Code> type from <Code>{change.meta.oldDirectiveArgumentType}</Code>
+          Changed directive <Code>@{change.directiveName}</Code> argument <Code>{change.argumentName}</Code> type from
           {' '}
-          to <Code>{change.meta.newDirectiveArgumentType}</Code>
+          <Code>{change.oldType}</Code> to <Code>{change.newType}</Code>
         </ChangeBase>
       )
   }

package/src/template/components/Changelog/groups/DirectiveArgumentDescription.tsx

@@ -1,15 +1,14 @@
-import type { GraphqlChange } from '#lib/graphql-change'
+import { Change as GraphqlChange } from '#lib/change/$'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'
 
-export const DirectiveArgumentDescription: React.FC<{ change: GraphqlChange.Group.DirectiveArgumentDescription }> = (
+export const DirectiveArgumentDescription: React.FC<{ change: any }> = (
   { change },
 ) => {
   return (
     <ChangeBase change={change}>
-      Changed description for directive <Code>@{change.meta.directiveName}</Code> argument{' '}
-      <Code>{change.meta.directiveArgumentName}</Code>
+      Changed description for directive <Code>@{change.directiveName}</Code> argument <Code>{change.argumentName}</Code>
     </ChangeBase>
   )
 }