polen 0.9.1-next.1 → 0.10.0-next.10

package/src/lib/demos/ui/data-collector.ts

@@ -0,0 +1,246 @@
+/**
+ * Data collection for demo landing pages
+ */
+
+import { Str } from '@wollybeard/kit'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { getDemoConfig, getDemoExamples } from '../index.ts'
+
+export interface DemoMetadata {
+  title: string
+  description: string
+  enabled: boolean
+  reason?: string
+}
+
+export interface TrunkDeployment {
+  sha: string
+  shortSha: string
+  tag: string | null
+}
+
+export interface TrunkDeploymentsData {
+  latest: TrunkDeployment | null
+  previous: TrunkDeployment[]
+}
+
+export interface PrDeployment {
+  number: number
+  sha?: string
+  ref?: string
+  previousDeployments?: string[]
+}
+
+export interface DistTagsData {
+  [key: string]: string
+}
+
+export interface LandingPageData {
+  demoMetadata: Record<string, DemoMetadata>
+  demoExamples: string[]
+  trunkDeployments?: TrunkDeploymentsData
+  prDeployments?: PrDeployment[]
+  distTags?: DistTagsData
+  config: {
+    basePath: string
+    mode: 'production' | 'development'
+    prNumber?: string
+    currentSha?: string
+  }
+}
+
+/**
+ * Collects all data needed for generating demo landing pages
+ */
+export class DemoDataCollector {
+  constructor(private workingDir: string = process.cwd()) {}
+
+  /**
+   * Collect all data for landing page generation
+   */
+  async collectLandingPageData(options: {
+    mode?: 'production' | 'development'
+    basePath?: string
+    prNumber?: string
+    currentSha?: string
+    trunkDeployments?: string | TrunkDeploymentsData
+    prDeployments?: string | PrDeployment[]
+    distTags?: string | DistTagsData
+  }): Promise<LandingPageData> {
+    try {
+      const {
+        mode = 'production',
+        basePath = '/',
+        prNumber,
+        currentSha,
+        trunkDeployments,
+        prDeployments,
+        distTags,
+      } = options
+
+      // Get demo examples
+      const demoExamples = await this.getDemoExamples()
+
+      // Load demo metadata
+      const demoMetadata = await this.loadDemoMetadata(demoExamples)
+
+      // Parse deployment data based on mode
+      const parsedTrunkDeployments = mode === 'development'
+        ? this.getMockTrunkDeployments()
+        : this.parseTrunkDeployments(trunkDeployments)
+
+      const parsedPrDeployments = this.parsePrDeployments(prDeployments)
+
+      const parsedDistTags = mode === 'development'
+        ? this.getMockDistTags()
+        : this.parseDistTags(distTags)
+
+      return {
+        demoMetadata,
+        demoExamples,
+        trunkDeployments: parsedTrunkDeployments,
+        prDeployments: parsedPrDeployments,
+        distTags: parsedDistTags,
+        config: {
+          mode,
+          basePath,
+          prNumber,
+          currentSha,
+        },
+      }
+    } catch (error) {
+      throw new Error(`Failed to collect landing page data: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /**
+   * Get demo examples using existing utility
+   */
+  private async getDemoExamples(): Promise<string[]> {
+    try {
+      return await getDemoExamples()
+    } catch (error) {
+      throw new Error(`Failed to get demo examples: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /**
+   * Load metadata for all demos (enabled and disabled)
+   */
+  private async loadDemoMetadata(demoExamples: string[]): Promise<Record<string, DemoMetadata>> {
+    const metadata: Record<string, DemoMetadata> = {}
+    const config = getDemoConfig().fullConfig
+
+    // Load metadata from package.json files for enabled examples
+    for (const example of demoExamples) {
+      try {
+        const packageJsonPath = join(this.workingDir, 'examples', example, 'package.json')
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+
+        metadata[example] = {
+          title: packageJson.displayName || Str.Case.title(packageJson.name || example),
+          description: packageJson.description
+            || `Explore the ${example} GraphQL API with comprehensive documentation.`,
+          enabled: true,
+        }
+      } catch {
+        // Fallback if package.json is missing or invalid
+        metadata[example] = {
+          title: Str.Case.title(example),
+          description: `Explore the ${example} GraphQL API with comprehensive documentation.`,
+          enabled: true,
+        }
+      }
+    }
+
+    // Add disabled demos from configuration
+    const disabledDemos = getDemoConfig().getDisabledDemos()
+    for (const [name, disabledDemo] of Object.entries(disabledDemos)) {
+      metadata[name] = {
+        title: disabledDemo.title,
+        description: disabledDemo.description,
+        enabled: false,
+        reason: disabledDemo.reason,
+      }
+    }
+
+    return metadata
+  }
+
+  /**
+   * Parse trunk deployments from JSON string or object
+   */
+  private parseTrunkDeployments(trunkDeployments?: string | TrunkDeploymentsData): TrunkDeploymentsData | undefined {
+    if (!trunkDeployments) return undefined
+
+    if (typeof trunkDeployments === 'string') {
+      try {
+        return JSON.parse(trunkDeployments) as TrunkDeploymentsData
+      } catch {
+        return undefined
+      }
+    }
+
+    return trunkDeployments
+  }
+
+  /**
+   * Parse PR deployments from JSON string or array
+   */
+  private parsePrDeployments(prDeployments?: string | PrDeployment[]): PrDeployment[] | undefined {
+    if (!prDeployments) return undefined
+
+    if (typeof prDeployments === 'string') {
+      try {
+        return JSON.parse(prDeployments) as PrDeployment[]
+      } catch {
+        return undefined
+      }
+    }
+
+    return prDeployments
+  }
+
+  /**
+   * Parse dist-tags from JSON string or object
+   */
+  private parseDistTags(distTags?: string | DistTagsData): DistTagsData | undefined {
+    if (!distTags) return undefined
+
+    if (typeof distTags === 'string') {
+      try {
+        return JSON.parse(distTags) as DistTagsData
+      } catch {
+        return undefined
+      }
+    }
+
+    return distTags
+  }
+
+  /**
+   * Get mock data for development mode
+   */
+  private getMockTrunkDeployments(): TrunkDeploymentsData {
+    return {
+      latest: { sha: '1.2.0', shortSha: '1.2.0', tag: '1.2.0' },
+      previous: [
+        { sha: '1.1.0', shortSha: '1.1.0', tag: '1.1.0' },
+        { sha: '1.0.0', shortSha: '1.0.0', tag: '1.0.0' },
+        { sha: '0.9.1', shortSha: '0.9.1', tag: '0.9.1' },
+        { sha: '0.9.0', shortSha: '0.9.0', tag: '0.9.0' },
+      ],
+    }
+  }
+
+  /**
+   * Get mock dist-tags for development mode
+   */
+  private getMockDistTags(): DistTagsData {
+    return {
+      latest: '1.2.0',
+      next: '1.3.0-beta.2',
+    }
+  }
+}

package/src/lib/demos/ui/landing-page-cli.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { Command } from '@molt/command'
+import { z } from 'zod'
+import { buildDemosHome } from './landing-page.ts'
+
+/**
+ * CLI entry point
+ */
+const command = Command.create()
+  .parameter('basePath', z.string().optional().describe('Base path for demo links'))
+  .parameter('prNumber', z.string().optional().describe('PR number for preview mode'))
+  .parameter('currentSha', z.string().optional().describe('Current commit SHA'))
+  .parameter('mode', z.enum(['production', 'development']).optional().describe('Page mode'))
+  .parameter('prDeployments', z.string().optional().describe('JSON string of PR deployments'))
+  .parameter('trunkDeployments', z.string().optional().describe('JSON string of trunk deployments'))
+  .parameter('distTags', z.string().optional().describe('JSON string of dist-tags'))
+  .parameter('serve', z.boolean().optional().describe('Start development server'))
+  .parameter('outputDir', z.string().optional().describe('Output directory'))
+  .parameter('outputPath', z.string().optional().describe('Output file path (overrides outputDir)'))
+
+const args = await command.parse()
+await buildDemosHome(args)

package/src/lib/demos/ui/landing-page.ts

@@ -0,0 +1,126 @@
+/**
+ * Main entry point for demo landing page generation
+ */
+import type { VersionCatalog } from '#lib/version-history/index'
+import { promises as fs } from 'node:fs'
+import { dirname, extname, join } from 'node:path'
+import { DemoDataCollector } from './data-collector.ts'
+import { DemoPageRenderer } from './page-renderer.ts'
+
+// Define the interface for the build options
+export interface Options {
+  basePath?: string
+  prNumber?: string
+  currentSha?: string
+  mode?: 'production' | 'development'
+  prDeployments?: string | any[]
+  trunkDeployments?: string | any
+  distTags?: string | Record<string, string>
+  outputDir?: string
+  outputPath?: string
+}
+
+// Options when using a version catalog
+export interface CatalogOptions {
+  basePath?: string
+  prNumber?: string
+  currentSha?: string
+  mode?: 'production' | 'development'
+  prDeployments?: string | any[]
+  catalog: VersionCatalog
+  outputDir?: string
+  outputPath?: string
+}
+
+/**
+ * Build demos home page with a version catalog
+ */
+export async function buildDemosHomeWithCatalog(options: CatalogOptions): Promise<void> {
+  const { catalog, ...otherOptions } = options
+
+  // Transform catalog data inline
+  const latestStable = catalog.distTags.latest || catalog.stable[0] || null
+  const trunkDeployments = {
+    latest: latestStable
+      ? {
+        sha: latestStable.git.sha,
+        shortSha: latestStable.git.sha.substring(0, 7),
+        tag: latestStable.git.tag,
+      }
+      : null,
+    previous: catalog.versions
+      .filter(v => v.git.tag !== latestStable?.git.tag)
+      .slice(0, 10)
+      .map(v => ({
+        sha: v.git.sha,
+        shortSha: v.git.sha.substring(0, 7),
+        tag: v.git.tag,
+      })),
+  }
+
+  const distTags: Record<string, string> = {}
+  for (const [name, version] of Object.entries(catalog.distTags)) {
+    if (version) {
+      distTags[name] = version.git.tag
+    }
+  }
+
+  // Use the existing function with transformed data
+  return buildDemosHome({
+    ...otherOptions,
+    trunkDeployments,
+    distTags,
+  })
+}
+
+// Function overloads
+export async function buildDemosHome(options: CatalogOptions): Promise<void>
+export async function buildDemosHome(options?: Options): Promise<void>
+
+/**
+ * Main function that builds the demos home page
+ */
+export async function buildDemosHome(options: CatalogOptions | Options = {}): Promise<void> {
+  // Check if catalog is provided
+  if ('catalog' in options && options.catalog) {
+    return buildDemosHomeWithCatalog(options as CatalogOptions)
+  }
+  const config = {
+    basePath: '/',
+    mode: 'production' as const,
+    outputDir: 'dist-demos',
+    ...options,
+  }
+
+  // Collect all required data
+  const dataCollector = new DemoDataCollector()
+  const data = await dataCollector.collectLandingPageData(config)
+
+  // Render the page
+  const renderer = new DemoPageRenderer()
+  const html = renderer.renderPage(data)
+
+  // Determine output path
+  let outputPath: string
+
+  if (config.outputPath) {
+    // Use provided outputPath
+    outputPath = config.outputPath
+
+    // If it's a directory (no extension), append the filename
+    if (!extname(outputPath)) {
+      const fileName = 'index.html'
+      outputPath = join(outputPath, fileName)
+    }
+
+    // Ensure parent directory exists
+    await fs.mkdir(dirname(outputPath), { recursive: true })
+  } else {
+    // Use outputDir (legacy behavior)
+    await fs.mkdir(config.outputDir, { recursive: true })
+    const fileName = 'index.html'
+    outputPath = join(config.outputDir, fileName)
+  }
+
+  await fs.writeFile(outputPath, html)
+}

package/src/lib/demos/ui/page-renderer.ts

@@ -0,0 +1,124 @@
+/**
+ * HTML page renderer for demo landing pages
+ */
+
+import { getDemoConfig } from '../index.ts'
+import {
+  generateDemosGrid,
+  generateFooter,
+  generateHeader,
+  generatePrBanner,
+  generateVersionInfo,
+  getDemoPageStyles,
+} from './components.ts'
+import type { LandingPageData } from './data-collector.ts'
+
+/**
+ * Renders complete HTML pages for demo landing
+ */
+export class DemoPageRenderer {
+  /**
+   * Render main demo landing page
+   */
+  renderMainLandingPage(data: LandingPageData): string {
+    const config = getDemoConfig().fullConfig
+    const { mode, prNumber } = data.config
+
+    let pageTitle = config.ui.branding.title
+    if (prNumber) {
+      pageTitle = `${pageTitle} - PR #${prNumber} Preview`
+    }
+
+    const prBannerHtml = prNumber ? generatePrBanner(prNumber) : ''
+    const headerHtml = generateHeader(data)
+    const demosGridHtml = generateDemosGrid(data)
+    const versionInfoHtml = generateVersionInfo(data)
+    const footerHtml = generateFooter()
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${pageTitle}</title>
+  <meta name="description" content="${config.ui.branding.description}">
+  ${config.ui.branding.logoUrl ? `<link rel="icon" href="${config.ui.branding.logoUrl}">` : ''}
+  <style>
+    ${getDemoPageStyles()}
+  </style>
+</head>
+<body>
+  ${prBannerHtml}
+  <div class="container">
+    ${headerHtml}
+    ${demosGridHtml}
+    ${versionInfoHtml}
+    ${footerHtml}
+  </div>
+</body>
+</html>`
+  }
+
+  /**
+   * Render development page with mock data
+   */
+  renderDevPage(data: LandingPageData): string {
+    const headerHtml = generateHeader(data)
+    const demosGridHtml = generateDemosGrid(data)
+    const versionInfoHtml = generateVersionInfo(data)
+    const footerHtml = generateFooter()
+
+    const devNoticeHtml = `
+      <div style="background: #fff3cd; border: 1px solid #ffeaa7; padding: 1rem; margin-bottom: 2rem; border-radius: 4px;">
+        <strong>Development Mode:</strong> This page is using mock data for development purposes.
+      </div>
+    `
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Polen Demos - Development</title>
+  <meta name="description" content="Development version of Polen demos">
+  <style>
+    ${getDemoPageStyles()}
+  </style>
+</head>
+<body>
+  <div class="container">
+    ${devNoticeHtml}
+    ${headerHtml}
+    ${demosGridHtml}
+    ${versionInfoHtml}
+    ${footerHtml}
+  </div>
+</body>
+</html>`
+  }
+
+  /**
+   * Render page based on mode
+   */
+  renderPage(data: LandingPageData): string {
+    const { mode } = data.config
+
+    switch (mode) {
+      case 'development':
+        return this.renderDevPage(data)
+      case 'production':
+      default:
+        return this.renderMainLandingPage(data)
+    }
+  }
+}
+
+/**
+ * Utility function for quick page rendering
+ */
+export async function renderDemoLandingPage(
+  data: LandingPageData,
+): Promise<string> {
+  const renderer = new DemoPageRenderer()
+  return renderer.renderPage(data)
+}

package/src/lib/demos/utils.ts

@@ -0,0 +1,43 @@
+/**
+ * Utility functions for demo management
+ */
+
+import type { Version } from '#lib/version-history/index'
+import { promises as fs } from 'node:fs'
+import { join } from 'node:path'
+import { getDemoConfig } from './config.ts'
+
+/**
+ * Get list of demo examples from the examples directory
+ */
+export async function getDemoExamples(): Promise<string[]> {
+  const examplesDir = join(process.cwd(), 'examples')
+  const examples: string[] = []
+
+  // Read all directories in examples/
+  try {
+    const dirs = await fs.readdir(examplesDir, { withFileTypes: true })
+    const dirNames = dirs
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name)
+
+    examples.push(...dirNames)
+  } catch (e) {
+    console.error(`Error reading examples directory:`, (e as Error).message)
+  }
+
+  // Use DemoConfig to filter and order examples
+  const config = getDemoConfig()
+  return config.getOrderedDemos(examples)
+}
+
+/**
+ * Get deployment path for a version
+ */
+export const getDistTagPath = (version: Version): string => {
+  return version.isPrerelease ? `/next/` : '/latest/'
+}
+
+export const getSemverPath = (version: Version): string => {
+  return `/${version.semver}/`
+}

package/src/lib/deployment/$$.ts

@@ -0,0 +1,2 @@
+export * from './metadata.ts'
+export * from './path-manager.ts'

package/src/lib/deployment/$.test.ts

@@ -0,0 +1,53 @@
+import { Fs } from '@wollybeard/kit'
+import { beforeEach, describe, expect, test } from 'vitest'
+import { Deployment } from './$.ts'
+
+describe('metadata', () => {
+  let testDir: string
+
+  beforeEach(async () => {
+    testDir = await Fs.makeTemporaryDirectory()
+  })
+
+  test('writes and reads deployment metadata', async () => {
+    const metadata: Deployment.DeploymentMetadata = {
+      timestamp: '2024-01-01T00:00:00.000Z',
+      pullRequest: {
+        number: 123,
+        branch: 'feat/awesome',
+        commit: 'abc123',
+        title: 'Add awesome feature',
+        author: 'octocat',
+      },
+      deployment: {
+        url: 'https://example.github.io/repo/pr-123/',
+        environment: 'pr-123',
+      },
+    }
+
+    await Deployment.metadata.write(metadata, testDir)
+
+    const result = await Deployment.metadata.read(testDir)
+    expect(result).toEqual(metadata)
+  })
+
+  test('creates .deployment.json file', async () => {
+    const metadata: Deployment.DeploymentMetadata = {
+      timestamp: new Date().toISOString(),
+      pullRequest: {
+        number: 456,
+        branch: 'main',
+        commit: 'def456',
+      },
+      deployment: {
+        url: 'https://example.com',
+        environment: 'pr-456',
+      },
+    }
+
+    await Deployment.metadata.write(metadata, testDir)
+
+    const fileExists = await Fs.exists(`${testDir}/.deployment.json`)
+    expect(fileExists).toBe(true)
+  })
+})

package/src/lib/deployment/$.ts

@@ -0,0 +1 @@
+export * as Deployment from './$$.ts'

package/src/lib/deployment/metadata.ts

@@ -0,0 +1,40 @@
+import { Codec, Resource } from '@wollybeard/kit'
+import { z } from 'zod/v4'
+
+export const DeploymentMetadataSchema = z.object({
+  timestamp: z.iso.datetime(),
+  pullRequest: z.object({
+    number: z.number(),
+    branch: z.string(),
+    commit: z.string(),
+    title: z.string().optional(),
+    author: z.string().optional(),
+  }),
+  deployment: z.object({
+    url: z.url(),
+    environment: z.string(),
+  }),
+})
+
+export type DeploymentMetadata = z.infer<typeof DeploymentMetadataSchema>
+
+export const metadata = Resource.create({
+  name: 'deployment-metadata',
+  path: '.deployment.json',
+  codec: Codec.fromZod(DeploymentMetadataSchema),
+  init: {
+    auto: true,
+    value: () => ({
+      timestamp: new Date().toISOString(),
+      pullRequest: {
+        number: 0,
+        branch: 'unknown',
+        commit: 'unknown',
+      },
+      deployment: {
+        url: '',
+        environment: 'unknown',
+      },
+    }),
+  },
+})