polen 0.11.0-next.27 → 0.11.0-next.29

package/src/api/builder/ssg/page-generator.worker.ts

@@ -2,15 +2,11 @@
  * Worker that generates static pages by fetching from servers.
  * This is executed in a worker thread using Effect Worker API.
  */
-import { debugPolen } from '#singletons/debug'
-import { Path, WorkerRunner } from '@effect/platform'
+import { FileSystem, Path, WorkerRunner } from '@effect/platform'
 import { NodeContext, NodeRuntime, NodeWorkerRunner } from '@effect/platform-node'
-import { Data, Effect, Layer } from 'effect'
-import { promises as fs } from 'node:fs'
+import { Array, Data, Duration, Effect, Either, Layer } from 'effect'
 import { type GenerateResult, PageMessage } from './worker-messages.js'
 
-const debug = debugPolen.sub(`api:ssg:page-generator`)
-
 // ============================================================================
 // Error Types
 // ============================================================================
@@ -31,85 +27,122 @@ class RouteProcessingError extends Data.Error<{
 // Generate Pages Handler
 // ============================================================================
 
+// Fetch HTML from server using Effect patterns
+const fetchPage = (url: string) =>
+  Effect.gen(function*() {
+    const response = yield* Effect.tryPromise({
+      try: () => fetch(url),
+      catch: (error) => new Error(`Network error: ${error}`),
+    })
+
+    if (!response.ok) {
+      return yield* Effect.fail(
+        new Error(`HTTP ${response.status}: ${response.statusText}`),
+      )
+    }
+
+    return yield* Effect.tryPromise({
+      try: () => response.text(),
+      catch: (error) => new Error(`Failed to read response: ${error}`),
+    })
+  })
+
+// Write HTML to file system
+const writeHtmlFile = (outputPath: string, html: string) =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+
+    const dir = path.dirname(outputPath)
+    yield* fs.makeDirectory(dir, { recursive: true })
+    yield* fs.writeFileString(outputPath, html)
+  })
+
+// Process a single route
+const processRoute = (
+  route: string,
+  serverPort: number,
+  outputDir: string,
+  basePath?: string,
+) =>
+  Effect.gen(function*() {
+    const path = yield* Path.Path
+
+    // Fetch the page from the server
+    // Construct URL with base path if provided
+    const basePathNormalized = basePath ? basePath.replace(/\/$/, '') : ''
+    const url = `http://localhost:${serverPort}${basePathNormalized}${route}`
+    const html = yield* fetchPage(url).pipe(
+      Effect.mapError(error => new RouteProcessingError({ route, cause: error })),
+    )
+
+    // Determine output file path
+    const outputPath = path.join(
+      outputDir,
+      route === '/' ? 'index.html' : `${route.slice(1)}/index.html`,
+    )
+
+    // Write the HTML file
+    yield* writeHtmlFile(outputPath, html).pipe(
+      Effect.mapError(error => new RouteProcessingError({ route, cause: error })),
+    )
+
+    return route
+  })
+
 const handlers = {
   GeneratePages: (
-    { routes, serverPort, outputDir }: { routes: readonly string[]; serverPort: number; outputDir: string },
+    { routes, serverPort, outputDir, basePath }: { routes: readonly string[]; serverPort: number; outputDir: string; basePath?: string | undefined },
   ) =>
     Effect.gen(function*() {
-      const path = yield* Path.Path
-      const startTime = Date.now()
-      let processedCount = 0
-
-      debug(`Starting batch generation`, {
-        totalRoutes: routes.length,
-        serverPort,
-      })
-
-      // Process each route by fetching from the server
-      for (const route of routes) {
-        yield* Effect.tryPromise({
-          try: async () => {
-            // Fetch the page from the server
-            const url = `http://localhost:${serverPort}${route}`
-            const response = await fetch(url)
-
-            if (!response.ok) {
-              throw new Error(`Failed to fetch ${route}: ${response.status} ${response.statusText}`)
-            }
-
-            const html = await response.text()
-
-            // Determine output file path
-            const outputPath = path.join(
-              outputDir,
-              route === '/' ? 'index.html' : `${route.slice(1)}/index.html`,
-            )
-
-            // Ensure directory exists
-            const dir = path.dirname(outputPath)
-            await fs.mkdir(dir, { recursive: true })
-
-            // Write the HTML file
-            await fs.writeFile(outputPath, html, 'utf-8')
-
-            processedCount++
-
-            // Log progress every 5 routes or on last route
-            if (processedCount % 5 === 0 || processedCount === routes.length) {
-              debug(`Progress`, {
-                processedCount,
-                totalRoutes: routes.length,
-                serverPort,
-              })
-            }
-          },
-          catch: (error) => {
-            debug(`Failed to process route`, { route, error })
-            return new RouteProcessingError({ route, cause: error })
-          },
-        })
-      }
+      yield* Effect.logDebug(`Starting batch generation`).pipe(
+        Effect.annotateLogs({
+          totalRoutes: routes.length,
+          serverPort,
+          basePath: basePath || 'none',
+        }),
+      )
+
+      // Process all routes with timing, collecting both successes and failures
+      const [duration, results] = yield* Effect.forEach(
+        routes,
+        (route, index) =>
+          processRoute(route, serverPort, outputDir, basePath).pipe(
+            Effect.tap(() =>
+              // Log progress every 5 routes
+              (index + 1) % 5 === 0 || index === routes.length - 1
+                ? Effect.logDebug(`Progress: ${index + 1}/${routes.length} routes processed`)
+                : Effect.void
+            ),
+            Effect.either, // Convert to Either to capture both success and failure
+          ),
+        { concurrency: 1 }, // Process sequentially to avoid overwhelming the server
+      ).pipe(Effect.timed)
+
+      // Partition results into successes and failures
+      const [failures, successes] = Array.partition(results, Either.isRight)
+      const processedCount = successes.length
 
       const result: GenerateResult = {
-        success: true,
+        success: failures.length === 0,
         processedCount,
-        duration: Date.now() - startTime,
+        duration: Duration.toMillis(duration),
         memoryUsed: process.memoryUsage().heapUsed,
+        ...(failures.length > 0 && {
+          error: `Failed to generate ${failures.length} out of ${routes.length} routes`,
+          failures: failures.map((f) => ({
+            route: f.left.route,
+            error: f.left.cause instanceof Error ? f.left.cause.message : String(f.left.cause),
+          })),
+        }),
       }
 
-      debug(`Batch generation complete`, result)
+      yield* Effect.logDebug(`Batch generation complete`).pipe(
+        Effect.annotateLogs(result),
+      )
+
       return result
-    }).pipe(
-      Effect.catchAll((error) =>
-        Effect.succeed({
-          success: false,
-          processedCount: 0,
-          duration: Date.now() - Date.now(),
-          memoryUsed: process.memoryUsage().heapUsed,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      ),
-    ),
+    }),
 }
 
 // ============================================================================
@@ -120,6 +153,9 @@ const handlers = {
 WorkerRunner.launch(
   Layer.provide(
     WorkerRunner.layerSerialized(PageMessage, handlers),
-    Layer.merge(NodeWorkerRunner.layer, NodeContext.layer),
+    Layer.mergeAll(
+      NodeWorkerRunner.layer,
+      NodeContext.layer,
+    ),
   ),
 ).pipe(NodeRuntime.runMain)

package/src/api/builder/ssg/server-runner.worker.ts

@@ -2,18 +2,15 @@
  * Worker that runs a Polen server for SSG.
  * This is executed in a child process using Effect Worker API.
  */
-import { debugPolen } from '#singletons/debug'
 import { WorkerRunner } from '@effect/platform'
 import { NodeRuntime, NodeWorkerRunner } from '@effect/platform-node'
-import { Duration, Effect, Layer, Scope } from 'effect'
+import { Duration, Effect, Layer, Ref, Scope } from 'effect'
 import { spawn } from 'node:child_process'
 import type { ChildProcess } from 'node:child_process'
 import { ServerMessage } from './worker-messages.js'
 
-const debug = debugPolen.sub(`api:ssg:server-runner`)
-
-// Store the server process for cleanup
-let serverProcess: ChildProcess | null = null
+// Store the server process reference for cleanup
+const serverProcessRef = Ref.unsafeMake<ChildProcess | null>(null)
 
 // ============================================================================
 // Handlers
@@ -23,20 +20,21 @@ const handlers = {
   StartServer: ({ serverPath, port }: { serverPath: string; port: number }) =>
     Effect.gen(function*() {
       // If there's already a server running, stop it first
-      if (serverProcess) {
-        serverProcess.kill('SIGTERM')
+      const existingProcess = yield* Ref.get(serverProcessRef)
+      if (existingProcess) {
+        existingProcess.kill('SIGTERM')
         yield* Effect.sleep(Duration.millis(500))
-        if (!serverProcess.killed) {
-          serverProcess.kill('SIGKILL')
+        if (!existingProcess.killed) {
+          existingProcess.kill('SIGKILL')
         }
-        serverProcess = null
+        yield* Ref.set(serverProcessRef, null)
       }
 
       // Start the server process
-      const startServer = Effect.sync((): ChildProcess => {
-        debug(`Starting server with command: node ${serverPath}`)
+      yield* Effect.logDebug(`Starting server with command: node ${serverPath}`)
 
-        serverProcess = spawn('node', [serverPath], {
+      const proc = yield* Effect.sync(() => {
+        const serverProc = spawn('node', [serverPath], {
           env: {
             ...process.env,
             PORT: port.toString(),
@@ -44,18 +42,23 @@ const handlers = {
           stdio: ['ignore', 'pipe', 'pipe'],
         })
 
-        serverProcess.stdout?.on('data', (data) => {
-          debug(`[Server ${port}] stdout`, data.toString().trim())
+        // Log server output
+        serverProc.stdout?.on('data', (data) => {
+          Effect.logDebug(`[Server ${port}] stdout: ${data.toString().trim()}`).pipe(
+            Effect.runSync,
+          )
         })
 
-        serverProcess.stderr?.on('data', (data) => {
-          debug(`[Server ${port}] stderr`, data.toString().trim())
+        serverProc.stderr?.on('data', (data) => {
+          Effect.logDebug(`[Server ${port}] stderr: ${data.toString().trim()}`).pipe(
+            Effect.runSync,
+          )
         })
 
-        return serverProcess
+        return serverProc
       })
 
-      const proc: ChildProcess = yield* startServer
+      yield* Ref.set(serverProcessRef, proc)
 
       // Wait for server to be ready with proper interruption support
       const waitForReady = Effect.async<void>((resume) => {
@@ -80,7 +83,7 @@ const handlers = {
           try {
             const response = await fetch(`http://localhost:${port}/`)
             if (response.ok || response.status === 404) {
-              debug(`[Server ${port}] Ready!`)
+              Effect.logDebug(`[Server ${port}] Ready!`).pipe(Effect.runSync)
               if (checkInterval) clearInterval(checkInterval)
               proc.removeListener('error', errorHandler)
               proc.removeListener('exit', exitHandler)
@@ -114,33 +117,25 @@ const handlers = {
           Effect.die(new Error(`Server on port ${port} failed to start within 30 seconds`))),
       )
 
-      // Add finalizer to ensure cleanup
-      yield* Effect.addFinalizer(() =>
-        Effect.sync(() => {
-          debug(`Finalizer: Stopping server on port ${port}`)
-          if (serverProcess && !serverProcess.killed) {
-            serverProcess.kill('SIGTERM')
-            // Try to kill forcefully after a brief wait
-            setTimeout(() => {
-              if (serverProcess && !serverProcess.killed) {
-                serverProcess.kill('SIGKILL')
-              }
-              serverProcess = null
-            }, 100)
-          }
-        })
-      )
-    }).pipe(Effect.scoped),
-  StopServer: () =>
+      yield* Effect.logDebug(`Server on port ${port} started successfully`)
+    }),
+  StopServer: ({ port }: { port?: number | undefined }) =>
     Effect.gen(function*() {
-      if (serverProcess) {
-        serverProcess.kill('SIGTERM')
+      const serverProc = yield* Ref.get(serverProcessRef)
+      if (serverProc) {
+        if (port !== undefined) {
+          yield* Effect.logDebug(`Stopping server on port ${port}`)
+        }
+        serverProc.kill('SIGTERM')
         // Give it time to shut down gracefully
         yield* Effect.sleep(Duration.millis(500))
-        if (!serverProcess.killed) {
-          serverProcess.kill('SIGKILL')
+        if (!serverProc.killed) {
+          serverProc.kill('SIGKILL')
+        }
+        yield* Ref.set(serverProcessRef, null)
+        if (port !== undefined) {
+          yield* Effect.logDebug(`Server on port ${port} stopped`)
         }
-        serverProcess = null
       }
     }),
 }

package/src/api/builder/ssg/worker-messages.ts

@@ -16,6 +16,14 @@ const GenerateResultSchema = S.Struct({
   duration: S.Number,
   memoryUsed: S.Number,
   error: S.optional(S.String),
+  failures: S.optional(
+    S.Array(
+      S.Struct({
+        route: S.String,
+        error: S.String,
+      }),
+    ),
+  ),
 })
 
 export type GenerateResult = S.Schema.Type<typeof GenerateResultSchema>
@@ -40,7 +48,9 @@ export class StopServerMessage extends S.TaggedRequest<StopServerMessage>()(
   'StopServer',
   {
     failure: S.Never,
-    payload: {},
+    payload: {
+      port: S.optional(S.Number),
+    },
     success: S.Void,
   },
 ) {}
@@ -60,6 +70,7 @@ export class GeneratePagesMessage extends S.TaggedRequest<GeneratePagesMessage>(
       routes: S.Array(RouteSchema),
       serverPort: S.Number,
       outputDir: S.String,
+      basePath: S.optional(S.String),
     },
     success: GenerateResultSchema,
   },

package/src/vite/plugins/main.ts

@@ -2,7 +2,7 @@ import type { Api } from '#api/$'
 import type { Vite } from '#dep/vite/index'
 import { Manifest } from '#vite/plugins/manifest'
 import { vitePluginSsrCss } from '@hiogawa/vite-plugin-ssr-css'
-import ViteReact from '@vitejs/plugin-react-oxc'
+import ViteReact from '@vitejs/plugin-react'
 import { Path } from '@wollybeard/kit'
 import Inspect from 'vite-plugin-inspect'
 import { Branding } from './branding.js'

package/src/vite/plugins/routes-manifest.ts

@@ -3,6 +3,7 @@ import { Vite } from '#dep/vite/index'
 import { Catalog } from '#lib/catalog/$'
 import { FileRouter } from '#lib/file-router/$'
 import { SchemaDefinition } from '#lib/schema-definition/$'
+import { Version } from '#lib/version/$'
 import { debugPolen } from '#singletons/debug'
 import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
 import consola from 'consola'
@@ -102,12 +103,14 @@ function processVersionedCatalog(
 ): void {
   for (const schema of Catalog.Versioned.getAll(catalog)) {
     const version = schema.version
-    routes.push(`/reference/version/${version}`)
+    // Properly encode the version to its string representation
+    const versionValue = Version.encodeSync(version)
+    routes.push(`/reference/version/${versionValue}`)
 
     processSchemaDefinition(
       schema.definition,
       routes,
-      `/reference/version/${version}`,
+      `/reference/version/${versionValue}`,
     )
   }
 }