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

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

@@ -0,0 +1,145 @@
+import { Api } from '#api/index'
+import { Vite } from '#dep/vite/index'
+import { Catalog } from '#lib/catalog/$'
+import { SchemaDefinition } from '#lib/schema-definition/$'
+import { debugPolen } from '#singletons/debug'
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
+import consola from 'consola'
+import { Effect } from 'effect'
+import { isInterfaceType, isObjectType } from 'graphql'
+import * as fs from 'node:fs/promises'
+
+/**
+ * Vite plugin that generates a routes manifest during build for SSG.
+ * This manifest contains all concrete route paths (no parameters)
+ * that the SSG process needs to generate.
+ */
+export const RoutesManifest = (config: Api.Config.Config): Vite.Plugin => {
+  const debug = debugPolen.sub(`vite:routes-manifest`)
+
+  return {
+    name: `polen:routes-manifest`,
+    apply: `build`,
+    applyToEnvironment: Vite.isEnvironmentSsr,
+    async closeBundle() {
+      const routes: string[] = []
+
+      // Add base routes
+      routes.push('/')
+      routes.push('/changelog')
+
+      // Check if schema exists using configured sources
+      const schemaExists = await Effect.runPromise(
+        Api.Schema.hasSchema(config).pipe(
+          Effect.provide(NodeFileSystem.layer),
+        ),
+      )
+
+      if (schemaExists) {
+        // Load catalog data
+        const catalogData = await Effect.runPromise(
+          Api.Schema.loadOrThrow(config).pipe(
+            Effect.provide(NodeFileSystem.layer),
+          ),
+        )
+
+        const catalog = catalogData?.data
+
+        if (catalog) {
+          routes.push('/reference')
+
+          // Process catalog using fold
+          Catalog.fold(
+            (versioned) => processVersionedCatalog(versioned, routes),
+            (unversioned) => processUnversionedCatalog(unversioned, routes),
+          )(catalog)
+        }
+      }
+
+      // Add custom page routes
+      const pagesDir = config.paths.project.absolute.pages
+      try {
+        await fs.access(pagesDir)
+        // TODO: Scan pages directory and add routes
+        // For now, we'll leave this as a future enhancement
+      } catch (err: any) {
+        if (err.code === 'ENOENT') {
+          debug('Pages directory not found, skipping custom page routes:', pagesDir)
+        } else {
+          throw err // Let unexpected errors bubble up
+        }
+      }
+
+      // Write manifest using the new Routes API
+      await Effect.runPromise(
+        Api.Routes.Manifest.write(
+          {
+            version: `1.0.0`,
+            timestamp: new Date().toISOString(),
+            totalRoutes: routes.length,
+            routes: routes.sort(), // Sort for deterministic output
+          },
+          config.paths.project.absolute.build.assets.root,
+        ).pipe(
+          Effect.provide(NodeFileSystem.layer),
+        ),
+      )
+
+      consola.success(`Generated routes manifest with ${routes.length} routes`)
+      debug(`Routes manifest written`, {
+        totalRoutes: routes.length,
+        path: config.paths.project.absolute.build.assets.root,
+      })
+    },
+  }
+}
+
+function processVersionedCatalog(
+  catalog: Catalog.Versioned.Versioned,
+  routes: string[],
+): void {
+  for (const schema of catalog.entries) {
+    const version = schema.version
+    routes.push(`/reference/version/${version}`)
+
+    processSchemaDefinition(
+      schema.definition,
+      routes,
+      `/reference/version/${version}`,
+    )
+  }
+}
+
+function processUnversionedCatalog(
+  catalog: Catalog.Unversioned.Unversioned,
+  routes: string[],
+): void {
+  // Process schema definition if it exists
+  if (catalog.schema.definition) {
+    processSchemaDefinition(catalog.schema.definition, routes, '/reference')
+  }
+}
+
+function processSchemaDefinition(
+  definition: SchemaDefinition.SchemaDefinition,
+  routes: string[],
+  basePath: string,
+): void {
+  // SchemaDefinition is a GraphQLSchema instance
+  const typeMap = definition.getTypeMap()
+
+  for (const [typeName, type] of Object.entries(typeMap)) {
+    // Skip introspection types
+    if (typeName.startsWith('__')) continue
+
+    routes.push(`${basePath}/${typeName}`)
+
+    // Handle fields for object and interface types
+    if (isObjectType(type) || isInterfaceType(type)) {
+      const fields = type.getFields()
+      for (const fieldName of Object.keys(fields)) {
+        routes.push(`${basePath}/${typeName}/${fieldName}`)
+      }
+    }
+  }
+}

package/src/vite/plugins/schema-assets.ts

@@ -0,0 +1,265 @@
+import { Api } from '#api/index'
+import type { Vite } from '#dep/vite/index'
+import { Catalog } from '#lib/catalog/$'
+import { debugPolen } from '#singletons/debug'
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
+import { Cache } from '@wollybeard/kit'
+import { Effect } from 'effect'
+import * as NodeFs from 'node:fs/promises'
+import * as NodePath from 'node:path'
+
+/**
+ * Vite plugin that generates JSON assets for GraphQL schemas at build time.
+ *
+ * This plugin:
+ * - Reads GraphQL schema files from the project
+ * - Applies schema augmentations
+ * - Converts schemas to AST format and emits as JSON assets
+ * - Creates a metadata file with available versions
+ * - Provides a virtual module for accessing schema metadata
+ *
+ * The generated assets enable client-side loading of different schema versions
+ * without requiring all schemas to be bundled into the main JavaScript bundle.
+ *
+ * @param config - Polen configuration object
+ * @returns Vite plugin instance
+ */
+export const SchemaAssets = (config: Api.Config.Config): Vite.Plugin => {
+  const debug = debugPolen.sub(`vite-plugin:schema-assets`)
+  let viteServer: Vite.ViteDevServer | null = null
+
+  const schemaLoad = Cache.memoize(async () => {
+    return await Effect.runPromise(
+      Api.Schema.loadOrNull(config).pipe(
+        Effect.provide(NodeFileSystem.layer),
+      ),
+    )
+  })
+
+  // Helper to check if a file is a schema file that should trigger regeneration
+  const isSchemaFile = (file: string): boolean => {
+    if (!config.schema) return false
+
+    const absoluteFile = NodePath.resolve(file)
+
+    // Check if file path matches the configured schema file
+    if (config.schema.sources?.file?.path) {
+      const absoluteSchemaFile = NodePath.resolve(
+        config.paths.project.rootDir,
+        config.schema.sources.file.path,
+      )
+      if (absoluteFile === absoluteSchemaFile) return true
+    }
+
+    // Check if file path is within the configured schema directory
+    if (config.schema.sources?.directory?.path) {
+      const absoluteSchemaDir = NodePath.resolve(
+        config.paths.project.rootDir,
+        config.schema.sources.directory.path,
+      )
+      if (absoluteFile.startsWith(absoluteSchemaDir + NodePath.sep)) return true
+    }
+
+    // Check if file is the introspection file
+    if (config.schema.sources?.introspection?.url) {
+      const absoluteIntrospectionFile = NodePath.resolve(
+        config.paths.project.rootDir,
+        `schema.introspection.json`,
+      )
+      if (absoluteFile === absoluteIntrospectionFile) return true
+    }
+
+    return false
+  }
+
+  // Helper to send HMR invalidation signal for schema changes
+  const sendSchemaInvalidation = (server: Vite.ViteDevServer) => {
+    server.ws.send({
+      type: 'custom',
+      event: 'polen:schema-invalidate',
+      data: { timestamp: Date.now() },
+    })
+    debug(`hmr:schemaInvalidationSent`, {})
+  }
+
+  // Helper to write assets
+  const writeDevAssets = async (
+    loadedCatalog: Api.Schema.InputSource.LoadedCatalog,
+  ) => {
+    const { data: catalog } = loadedCatalog
+    if (!catalog) throw new Error('No catalog data to write')
+
+    // Encode catalog to convert GraphQLSchema to AST, then write as JSON
+    const devAssetsDir = config.paths.framework.devAssets.schemas
+    await NodeFs.mkdir(devAssetsDir, { recursive: true })
+    const catalogPath = NodePath.join(devAssetsDir, 'catalog.json')
+
+    const encodedCatalog = await Effect.runPromise(Catalog.encode(catalog))
+
+    await NodeFs.writeFile(catalogPath, JSON.stringify(encodedCatalog, null, 2))
+
+    debug(`devAssetsWritten`)
+  }
+
+  return {
+    name: `polen:schema-assets`,
+
+    configureServer(server) {
+      viteServer = server
+
+      // Clear all assets when dev server starts
+      const clearAssets = async () => {
+        try {
+          // Clear all assets
+          const devAssetsDir = config.paths.framework.devAssets.schemas
+          await NodeFs.rm(devAssetsDir, { recursive: true, force: true })
+          debug(`devAssetsCleared`, {})
+        } catch (error) {
+          // Ignore errors during clearing
+          debug(`devAssetsClearError`, { error })
+        }
+      }
+
+      // Clear assets immediately
+      void clearAssets()
+
+      // Set up file watching for schema source files
+      // TODO: Even when schema is disabled, we should still watch for schema file patterns
+      // during development. If a user enables schema in config during dev, we need to be
+      // ready to detect and load schema files immediately. Currently we skip file watching
+      // entirely when schema is disabled, which means manual dev server restart is required.
+      if (config.schema?.sources?.directory?.path) {
+        // Watch the entire directory for directory mode
+        server.watcher.add(config.schema.sources.directory.path)
+        debug(`watchingSchemaDirectory`, { path: config.schema.sources.directory.path })
+      }
+
+      if (config.schema?.sources?.file?.path) {
+        // Watch the specific file for file mode
+        server.watcher.add(config.schema.sources.file.path)
+        debug(`watchingSchemaFile`, { path: config.schema.sources.file.path })
+      }
+
+      if (config.schema?.sources?.introspection?.url) {
+        // Watch the introspection file if introspection is configured
+        const introspectionFilePath = NodePath.join(config.paths.project.rootDir, `schema.introspection.json`)
+        server.watcher.add(introspectionFilePath)
+        debug(`watchingIntrospectionFile`, { path: introspectionFilePath })
+      }
+
+      // Handle file removal
+      server.watcher.on('unlink', async (file) => {
+        const schemaFileDetected = isSchemaFile(file)
+
+        if (schemaFileDetected) {
+          debug(`schemaFileRemoved`, { file })
+
+          try {
+            // Clear cache and regenerate
+            schemaLoad.clear()
+            const loadedSchema = await schemaLoad()
+            if (!loadedSchema) return
+
+            // const { data: schemaData, manifest, source } = loadedSchema
+
+            // If file was deleted but can be recreated, attempt recreation
+            if (!loadedSchema.data && loadedSchema.source.reCreate) {
+              debug(`attemptingSchemaRecreation`, { sourceType: loadedSchema.source.name })
+              try {
+                const recreatedData = await loadedSchema.source.reCreate({} as any, { paths: config.paths })
+                if (recreatedData) {
+                  // Clear cache again and reload after recreation
+                  schemaLoad.clear()
+                  const reloadResult = await schemaLoad()
+                  if (reloadResult?.data) {
+                    await writeDevAssets(reloadResult)
+                    debug(`hmr:schemaRecreatedAndWritten`)
+                  }
+                } else {
+                  debug(`hmr:schemaRecreationFailed`, { reason: 'reCreate returned null' })
+                }
+              } catch (recreationError) {
+                debug(`hmr:schemaRecreationFailed`, { error: recreationError })
+              }
+            } else if (loadedSchema.data) {
+              // Write new assets without the removed file
+              await writeDevAssets(loadedSchema)
+              debug(`hmr:schemaAssetsUpdatedAfterRemoval`)
+            } else {
+              // No schema data and cannot recreate - clear catalog file
+              const catalogPath = NodePath.join(config.paths.framework.devAssets.schemas, 'catalog.json')
+              await NodeFs.rm(catalogPath, { force: true })
+              debug(`hmr:catalogCleared`, {})
+            }
+          } catch (error) {
+            debug(`hmr:schemaRemovalFailed`, { error })
+          }
+
+          // Send HMR invalidation signal
+          sendSchemaInvalidation(server)
+        }
+      })
+    },
+
+    async buildStart() {
+      debug(`buildStart`, {})
+
+      // Load and process schema data
+      const loadedSchema = await schemaLoad()
+      if (!loadedSchema) {
+        debug(`schemaDisabled`, {})
+        return
+      }
+      const { data: schemaData } = loadedSchema
+
+      if (!schemaData) {
+        debug(`noSchemaFound`, {})
+        return
+      }
+
+      // Handle asset generation differently for dev vs build
+      if (viteServer) {
+        // Dev mode: Write assets directly to filesystem
+        await writeDevAssets(loadedSchema)
+        debug(`devMode:schemaAssetsWritten`, {})
+        return
+      }
+
+      // Build mode: Encode and emit catalog as a single JSON file
+      const encodedCatalog = await Effect.runPromise(Catalog.encode(schemaData))
+      const catalogJson = JSON.stringify(encodedCatalog, null, 2)
+      this.emitFile({
+        type: `asset`,
+        fileName: `${config.paths.project.relative.build.relative.assets.root}/schemas/catalog.json`,
+        source: catalogJson,
+      })
+
+      debug(`buildMode:catalogAssetEmitted`)
+    },
+
+    async handleHotUpdate({ file, server }) {
+      const schemaFileDetected = isSchemaFile(file)
+      if (schemaFileDetected) {
+        debug(`schemaFileChanged`, { file })
+
+        // Regenerate schema assets
+        try {
+          schemaLoad.clear()
+          const schema = await schemaLoad()
+
+          if (schema?.data) {
+            debug(`hmr:schemaRegenerated`)
+
+            // Write new assets to filesystem
+            await writeDevAssets(schema)
+          }
+        } catch (error) {
+          debug(`hmr:schemaRegenerationFailed`, { error })
+        }
+
+        // Send HMR invalidation signal
+        sendSchemaInvalidation(server)
+      }
+    },
+  }
+}

package/src/vite/plugins/serve.ts

@@ -0,0 +1,201 @@
+import type { Api } from '#api/index'
+import { reportError } from '#api/server/report-error'
+import type { Vite } from '#dep/vite/index'
+import { createHtmlTransformer } from '#lib/html-utils/html-transformer'
+import { ResponseInternalServerError } from '#lib/kit-temp'
+import { debugPolen } from '#singletons/debug'
+import type { App, AppOptions } from '#template/server/app'
+import * as HonoNodeServer from '@hono/node-server'
+import { Err, Null } from '@wollybeard/kit'
+import * as NodePath from 'node:path'
+
+interface AppServerModule {
+  createApp: (options: AppOptions) => App
+}
+
+type AppPromise = AppPromiseGeneric<App>
+
+type PluginScope = { server?: Vite.ViteDevServer | undefined }
+
+export const Serve = (
+  config: Api.Config.Config,
+): Vite.PluginOption => {
+  const PLUGIN_SCOPE: PluginScope = {}
+
+  const debug = debugPolen.sub(`serve`)
+  const appModulePath = config.paths.framework.template.absolute.server.app
+
+  let appPromise: AppPromise
+
+  const isNeedAppLoadOrReload = (server: Vite.ViteDevServer): boolean => {
+    const appModule = server.moduleGraph.getModuleById(appModulePath)
+    if (!appModule) return true // Not loaded yet
+
+    // Check if the module or any of its dependencies are invalidated
+    const checkInvalidated = (mod: Vite.ModuleNode, visited = new Set<string>()): boolean => {
+      if (!mod.id || visited.has(mod.id)) return false
+      visited.add(mod.id)
+
+      // Check if this module is invalidated
+      // SSR modules use ssrInvalidationState, client modules use invalidationState
+      if (mod.ssrInvalidationState === `HARD_INVALIDATED` || mod.invalidationState === `HARD_INVALIDATED`) {
+        return true
+      }
+
+      // Also check if transformResult is null (indicates invalidation)
+      if (mod.ssrTransformResult === null && mod.transformResult === null) {
+        return true
+      }
+
+      // Check all imported modules recursively
+      for (const imported of mod.importedModules) {
+        if (checkInvalidated(imported, visited)) return true
+      }
+
+      return false
+    }
+
+    return checkInvalidated(appModule)
+  }
+
+  const reloadApp = async (server: Vite.ViteDevServer): AppPromise => {
+    debug(`reloadApp`)
+
+    const App = await ssrLoadModule<AppServerModule>(server, config.paths.framework.template.absolute.server.app)
+    if (Err.is(App)) return App
+    if (Null.is(App)) return App
+
+    return App.createApp({
+      hooks: {
+        transformHtml: [
+          // Inject entry client script for development
+          createHtmlTransformer((html, ___ctx) => {
+            const entryClientPath = `/${config.paths.framework.template.relative.client.entrypoint}`
+            const entryClientScript = `<script type="module" src="${entryClientPath}"></script>`
+            return html.replace(`</body>`, `${entryClientScript}\n</body>`)
+          }),
+          // Apply Vite's transformations
+          createHtmlTransformer(async (html, ctx) => {
+            return await server.transformIndexHtml(ctx.req.url, html)
+          }),
+        ],
+      },
+      paths: {
+        base: config.build.base,
+        assets: {
+          // Calculate relative path from CWD to Polen's assets
+          // CWD is user's project directory where they run 'pnpm dev'
+          // Assets are in Polen's dev assets directory
+          directory: NodePath.relative(
+            process.cwd(),
+            config.paths.framework.devAssets.absolute,
+          ),
+          route: config.server.routes.assets,
+        },
+      },
+    })
+  }
+
+  return {
+    name: `polen:serve`,
+    apply: `serve`,
+    config() {
+      return {
+        server: {
+          port: config.server.port,
+          watch: {
+            disableGlobbing: false,
+          },
+          fs: {
+            strict: false, // bring back true, with the allow below might already work now
+            allow: [
+              config.paths.project.rootDir,
+            ],
+          },
+        },
+      }
+    },
+    handleHotUpdate({ server }) {
+      debug(`handleHotUpdate`)
+      // Reload app server immediately in the background
+      appPromise = reloadApp(server)
+    },
+    async configureServer(server) {
+      debug(`configureServer`)
+
+      PLUGIN_SCOPE.server = server
+
+      return () => {
+        // Remove index.html serving middleware.
+        server.middlewares.stack.splice(
+          // @ts-expect-error
+          server.middlewares.stack.findIndex(m => m.handle.name === `viteHtmlFallbackMiddleware`),
+          1,
+        )
+
+        // Add middleware that runs our entry server
+        server.middlewares.use((req, res, ___next) => {
+          // Check if app needs reloading due to module invalidation
+          if (isNeedAppLoadOrReload(server)) {
+            appPromise = reloadApp(server)
+          }
+
+          void HonoNodeServer.getRequestListener(async request => {
+            // Always await the current app promise
+            const app = await appPromise
+            if (Err.is(app)) {
+              return ResponseInternalServerError()
+            }
+            if (Null.is(app)) {
+              // todo better response type, 'not available' etc.
+              return ResponseInternalServerError()
+            }
+
+            return await app.fetch(request)
+          })(req, res)
+        })
+      }
+    },
+    buildStart() {
+      if (PLUGIN_SCOPE.server) {
+        appPromise = reloadApp(PLUGIN_SCOPE.server)
+      }
+    },
+  }
+}
+
+// Helpers
+
+const isServerClosing = (server: Vite.ViteDevServer): boolean => {
+  // @ts-expect-error
+  return Boolean(server.environments.ssr._closing)
+}
+
+const isFetchTransportDisconnectError = (error: Error): boolean => {
+  const regex = /transport was disconnected.*fetchModule/
+  return regex.test(error.message)
+}
+/**
+ * null when dev server was closed/is closing making ssrLoadModule impossible to succeed.
+ */
+type AppPromiseGeneric<$AppServerModule> = Promise<$AppServerModule | Error | null>
+
+const ssrLoadModule = async <$AppServerModule>(
+  server: Vite.ViteDevServer,
+  appModulePath: string,
+): AppPromiseGeneric<$AppServerModule> => {
+  return await server
+    // .ssrLoadModule(config.paths.framework.template.absolute.server.app)
+    .ssrLoadModule(appModulePath)
+    .then(module => module as $AppServerModule)
+    .catch(async (error) => {
+      if (isFetchTransportDisconnectError(error) && isServerClosing(server)) return null
+      if (Err.is(error)) {
+        // ━ Clean Stack Trace
+        server.ssrFixStacktrace(error)
+        reportError(error)
+        return error
+      }
+      throw error
+    })
+}

package/build/api/config/config.d.ts

@@ -1,5 +0,0 @@
-export * from './configurator.js';
-export * from './define.js';
-export * from './load.js';
-export * from './merge.js';
-//# sourceMappingURL=config.d.ts.map

package/build/api/config/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/api/config/config.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA"}

package/build/api/config/config.js

@@ -1,5 +0,0 @@
-export * from './configurator.js';
-export * from './define.js';
-export * from './load.js';
-export * from './merge.js';
-//# sourceMappingURL=config.js.map

package/build/api/config/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/api/config/config.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA"}