polen 0.11.0-next.2 → 0.11.0-next.20

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

@@ -1,317 +0,0 @@
-import type { Config } from '#api/config/index'
-import { SchemaAugmentation } from '#api/schema-augmentation/index'
-import { createSchemaSource } from '#api/schema-source/index'
-import { Schema } from '#api/schema/index'
-import type { Vite } from '#dep/vite/index'
-import { Grafaid } from '#lib/grafaid/index'
-import { ViteVirtual } from '#lib/vite-virtual/index'
-import { debugPolen } from '#singletons/debug'
-import { Cache } from '@wollybeard/kit'
-import * as NodeFs from 'node:fs/promises'
-import * as NodePath from 'node:path'
-import { polenVirtual } from '../vi.js'
-
-export const viProjectSchemaMetadata = polenVirtual([`project`, `schema-metadata`])
-
-/**
- * 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: Config.Config): Vite.Plugin => {
-  const debug = debugPolen.sub(`vite-plugin:schema-assets`)
-  let viteServer: Vite.ViteDevServer | null = null
-
-  // Helper to load and process schema data
-  const loadAndProcessSchemaData = Cache.memoize(async () => {
-    const schemaData = await Schema.readOrThrow({
-      ...config.schema,
-      projectRoot: config.paths.project.rootDir,
-    })
-
-    if (!schemaData) {
-      const metadata: Schema.SchemaMetadata = { hasSchema: false, versions: [] }
-      return {
-        schemaData: null,
-        metadata,
-      }
-    }
-
-    // Apply augmentations
-    schemaData.forEach(version => {
-      SchemaAugmentation.apply(version.after, config.schemaAugmentations)
-    })
-
-    // Build metadata
-    const versionStrings: string[] = []
-    for (const [index, version] of schemaData.entries()) {
-      const versionName = index === 0 ? Schema.VERSION_LATEST : Schema.dateToVersionString(version.date)
-      versionStrings.push(versionName)
-    }
-
-    const metadata = {
-      hasSchema: true,
-      versions: versionStrings,
-    }
-
-    debug(`schemaDataLoaded`, { versionCount: schemaData.length })
-
-    return {
-      schemaData,
-      metadata,
-    }
-  })
-
-  // Helper to create schema source with filesystem IO
-  const createDevSchemaSource = (metadata: Schema.SchemaMetadata) => {
-    return createSchemaSource({
-      io: {
-        read: async () => {
-          throw new Error('Read not supported in dev asset writer')
-        },
-        write: async (path: string, content: string) => {
-          await NodeFs.writeFile(path, content, 'utf-8')
-        },
-        clearDirectory: async (path: string) => {
-          try {
-            const files = await NodeFs.readdir(path)
-            await Promise.all(files.map(file => NodeFs.rm(NodePath.join(path, file), { force: true })))
-          } catch (error) {
-            // Directory might not exist, which is fine
-          }
-        },
-        removeFile: async (path: string) => {
-          await NodeFs.rm(path, { force: true })
-        },
-      },
-      versions: metadata.versions,
-      assetsPath: config.paths.framework.devAssets.absolute,
-    })
-  }
-
-  // Helper to write assets using schema-source API
-  const writeDevAssets = async (
-    schemaData: Awaited<ReturnType<typeof Schema.readOrThrow>>,
-    metadata: Schema.SchemaMetadata,
-  ) => {
-    if (!schemaData) return
-
-    const devAssetsDir = config.paths.framework.devAssets.schemas
-    await NodeFs.mkdir(devAssetsDir, { recursive: true })
-
-    const schemaSource = createDevSchemaSource(metadata)
-    await schemaSource.writeAllAssets(schemaData, metadata)
-    debug(`devAssetsWritten`, { versionCount: schemaData.length })
-  }
-
-  return {
-    name: `polen:schema-assets`,
-
-    configureServer(server) {
-      viteServer = server
-
-      // Clear all assets when dev server starts
-      const clearAssets = async () => {
-        try {
-          // Create a basic schema source just for clearing
-          const schemaSource = createDevSchemaSource({ hasSchema: false, versions: [] })
-          await schemaSource.clearAllAssets()
-          debug(`devAssetsCleared`, {})
-        } catch (error) {
-          // Ignore errors during clearing
-        }
-      }
-
-      // Clear assets immediately
-      void clearAssets()
-
-      // Set up file watching for schema source files
-      if (config.schema?.dataSources?.directory?.path) {
-        // Watch the entire directory for directory mode
-        server.watcher.add(config.schema.dataSources.directory.path)
-        debug(`watchingSchemaDirectory`, { path: config.schema.dataSources.directory.path })
-      }
-
-      if (config.schema?.dataSources?.file?.path) {
-        // Watch the specific file for file mode
-        server.watcher.add(config.schema.dataSources.file.path)
-        debug(`watchingSchemaFile`, { path: config.schema.dataSources.file.path })
-      }
-
-      // Handle file removal
-      server.watcher.on('unlink', async (file) => {
-        const isSchemaFile = config.schema && (() => {
-          const absoluteFile = NodePath.resolve(file)
-
-          // Check if file path matches the configured schema file
-          if (config.schema.dataSources?.file?.path) {
-            const absoluteSchemaFile = NodePath.resolve(
-              config.paths.project.rootDir,
-              config.schema.dataSources.file.path,
-            )
-            if (absoluteFile === absoluteSchemaFile) return true
-          }
-
-          // Check if file path is within the configured schema directory
-          if (config.schema.dataSources?.directory?.path) {
-            const absoluteSchemaDir = NodePath.resolve(
-              config.paths.project.rootDir,
-              config.schema.dataSources.directory.path,
-            )
-            if (absoluteFile.startsWith(absoluteSchemaDir + NodePath.sep)) return true
-          }
-
-          return false
-        })()
-
-        if (isSchemaFile) {
-          debug(`schemaFileRemoved`, { file })
-
-          try {
-            // Clear cache and regenerate
-            loadAndProcessSchemaData.clear()
-            const { schemaData, metadata } = await loadAndProcessSchemaData()
-
-            if (schemaData) {
-              // Write new assets without the removed file
-              await writeDevAssets(schemaData, metadata)
-              debug(`hmr:schemaAssetsUpdatedAfterRemoval`, { versionCount: schemaData.length })
-            } else {
-              // No schema data - clear all assets
-              const schemaSource = createDevSchemaSource({ hasSchema: false, versions: [] })
-              await schemaSource.clearAllAssets()
-              debug(`hmr:allAssetsCleared`, {})
-            }
-          } catch (error) {
-            debug(`hmr:schemaRemovalFailed`, { error })
-          }
-
-          // Send HMR invalidation signal
-          server.ws.send({
-            type: 'custom',
-            event: 'polen:schema-invalidate',
-            data: { timestamp: Date.now() },
-          })
-
-          debug(`hmr:schemaInvalidationSent`, {})
-        }
-      })
-    },
-
-    async buildStart() {
-      debug(`buildStart`, {})
-
-      // Load and process schema data
-      const { schemaData, metadata } = await loadAndProcessSchemaData()
-
-      if (!schemaData) {
-        debug(`noSchemaFound`, {})
-        return
-      }
-
-      // Handle asset generation differently for dev vs build
-      if (viteServer) {
-        // Dev mode: Write assets directly to filesystem
-        await writeDevAssets(schemaData, metadata)
-        debug(`devMode:schemaAssetsWritten`, {})
-        return
-      }
-
-      // Build mode: Create schema source for emitting files
-      const schemaSource = createSchemaSource({
-        io: {
-          read: async () => {
-            throw new Error('Read not supported in build asset emitter')
-          },
-          write: async (path: string, content: string) => {
-            // Convert absolute path to relative filename for Vite
-            const relativePath = NodePath.relative(config.paths.framework.devAssets.absolute, path)
-            const fileName = `${config.paths.project.relative.build.relative.assets.root}/${relativePath}`
-
-            this.emitFile({
-              type: `asset`,
-              fileName,
-              source: content,
-            })
-          },
-        },
-        versions: metadata.versions,
-        assetsPath: config.paths.framework.devAssets.absolute,
-      })
-
-      // Emit all assets using the high-level API
-      await schemaSource.writeAllAssets(schemaData, metadata)
-      debug(`buildMode:allAssetsEmitted`, { versionCount: schemaData.length })
-    },
-
-    async handleHotUpdate({ file, server }) {
-      const isSchemaFile = config.schema && (() => {
-        const absoluteFile = NodePath.resolve(file)
-
-        // Check if file path matches the configured schema file
-        if (config.schema.dataSources?.file?.path) {
-          const absoluteSchemaFile = NodePath.resolve(config.paths.project.rootDir, config.schema.dataSources.file.path)
-          if (absoluteFile === absoluteSchemaFile) return true
-        }
-
-        // Check if file path is within the configured schema directory
-        if (config.schema.dataSources?.directory?.path) {
-          const absoluteSchemaDir = NodePath.resolve(
-            config.paths.project.rootDir,
-            config.schema.dataSources.directory.path,
-          )
-          if (absoluteFile.startsWith(absoluteSchemaDir + NodePath.sep)) return true
-        }
-
-        return false
-      })()
-      if (isSchemaFile) {
-        debug(`schemaFileChanged`, { file })
-
-        // Regenerate schema assets
-        try {
-          loadAndProcessSchemaData.clear()
-          const { schemaData, metadata } = await loadAndProcessSchemaData()
-
-          if (schemaData) {
-            debug(`hmr:schemaRegenerated`, { versionCount: schemaData.length })
-
-            // Write new assets to filesystem
-            await writeDevAssets(schemaData, metadata)
-          }
-        } catch (error) {
-          debug(`hmr:schemaRegenerationFailed`, { error })
-        }
-
-        // Send HMR invalidation signal
-        server.ws.send({
-          type: 'custom',
-          event: 'polen:schema-invalidate',
-          data: { timestamp: Date.now() },
-        })
-
-        debug(`hmr:schemaInvalidationSent`, {})
-      }
-    },
-
-    ...ViteVirtual.IdentifiedLoader.toHooks({
-      identifier: viProjectSchemaMetadata,
-      async loader() {
-        debug(`virtualModuleLoad`, { id: viProjectSchemaMetadata.id })
-        const { metadata } = await loadAndProcessSchemaData()
-        return `export default ${JSON.stringify(metadata)}`
-      },
-    }),
-  }
-}

package/src/api/vite/plugins/serve.ts

@@ -1,161 +0,0 @@
-import type { Config } from '#api/config/index'
-import { reportError } from '#api/server/report-error'
-import type { Hono } from '#dep/hono/index'
-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 } from '@wollybeard/kit'
-import * as NodePath from 'node:path'
-
-interface AppServerModule {
-  createApp: (options: AppOptions) => App
-}
-
-export const Serve = (
-  config: Config.Config,
-): Vite.PluginOption => {
-  const debug = debugPolen.sub(`serve`)
-  const appModulePath = config.paths.framework.template.absolute.server.app
-
-  let appPromise: Promise<App | Error>
-
-  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): Promise<App | Error> => {
-    debug(`reloadApp`)
-
-    return server.ssrLoadModule(config.paths.framework.template.absolute.server.app)
-      .then(module => module as AppServerModule)
-      .then(module => {
-        return module.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,
-            },
-          },
-        })
-      })
-      .catch(async (error) => {
-        if (Err.is(error)) {
-          // ━ Clean Stack Trace
-          server.ssrFixStacktrace(error)
-          reportError(error)
-          return error
-        }
-        throw error
-      })
-  }
-
-  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`)
-      // Initial load
-      appPromise = reloadApp(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)) {
-              // Err.log(app)
-              return ResponseInternalServerError()
-            }
-
-            return await app.fetch(request)
-          })(req, res)
-        })
-      }
-    },
-  }
-}

package/src/api/vite/vi.ts

@@ -1,5 +0,0 @@
-import { ViteVirtual } from '#lib/vite-virtual/index'
-
-export const polenVirtual = ViteVirtual.Identifier.createFactory({
-  namespace: `polen`,
-})

package/src/cli/commands/$default.ts

@@ -1,102 +0,0 @@
-#!/usr/bin/env node
-
-import { Arr, Cli, Path, Str } from '@wollybeard/kit'
-import $ from 'ansis'
-import console from 'console'
-import manifest from '../../../package.json' with { type: 'json' }
-
-const commandsDir = import.meta.dirname
-const thisModuleName = Path.parse(import.meta.filename).name
-const cliName = `polen`
-
-// Styles
-
-const code = (str: string) => {
-  if (!$.isSupported()) return `\`${str}\``
-  return $.magenta(str)
-}
-
-const link = (str: string) => {
-  if (!$.isSupported()) return $.underline(str)
-  const url = new URL(str)
-  // Split URL into protocol and the rest
-  const protocol = `${url.protocol}//`
-  const rest = str.substring(protocol.length)
-  return `${$.dim(protocol)}${$.blue(rest)}`
-}
-
-const h2 = (str: string) => {
-  return $.bold.black.bgWhiteBright(` ${str.toUpperCase()} `)
-}
-
-// ------
-
-const getRepoUrl = (url: string): string => {
-  return url
-    .replace(/^git\+/, ``)
-    .replace(/\.git$/, ``)
-}
-
-const s = Str.Builder()
-const repoUrl = getRepoUrl(manifest.repository.url)
-const allCommands = await Cli.discoverCommandPointers(commandsDir)
-const commands = allCommands.filter(_ => _.name !== thisModuleName)
-
-s``
-s``
-s`${$.bold.redBright`POLEN 🌺`} ${$.dim(`v${manifest.version}`)}`
-s`${$.whiteBright(manifest.description)}.`
-s``
-s``
-s`${h2(`commands`)}`
-s``
-
-// todo?
-
-// match(commands)
-//   .empty(() => {
-//     s`  No commands available yet.`
-//   })
-//   .else(commands => {
-//     commands.forEach(command => {
-//       s`  ${$.dim`$ ${cliName}`} ${$.cyanBright(command.name)}`
-//     })
-//   })
-
-// match(commands, [
-//   [[], () => {
-//     s`  No commands available yet.`
-//   }],
-//   commands => {
-//     commands.forEach(command => {
-//       s`  ${$.dim`$ ${cliName}`} ${$.cyanBright(command.name)}`
-//     })
-//   },
-// ])
-
-if (Arr.isEmpty(commands)) {
-  s`No commands available yet.`
-} else {
-  commands.forEach(command => {
-    s`${$.dim`$ ${cliName}`} ${$.cyanBright(command.name)}`
-  })
-}
-s``
-s`${$.dim`Get help for a command with ${code(`polen <command> --help`)}`}`
-s``
-s``
-s`${h2(`learn more`)}`
-s``
-s`${
-  Str.table({
-    data: {
-      'Source Code': link(repoUrl),
-      'Built By': link(`https://the-guild.dev`),
-      'Ecosystem': link(`https://graphql.org`),
-    },
-  })
-}`
-s``
-s``
-
-console.log(Str.indent(String(s)))

package/src/cli/commands/config/$default.ts

@@ -1,7 +0,0 @@
-import { consola } from 'consola'
-
-consola.info(`Available config commands:`)
-console.log(``)
-console.log(`  polen config create    Create a Polen configuration file`)
-console.log(``)
-consola.info(`Run a command to see its help.`)

package/src/cli/commands/static/$default.ts

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-
-import { Arr, Cli, Path, Str } from '@wollybeard/kit'
-import $ from 'ansis'
-import console from 'console'
-
-const commandsDir = import.meta.dirname
-const thisModuleName = Path.parse(import.meta.filename).name
-const cliName = `polen static`
-
-const h2 = (str: string) => {
-  return $.bold.black.bgWhiteBright(` ${str.toUpperCase()} `)
-}
-
-const code = (str: string) => {
-  if (!$.isSupported()) return `\`${str}\``
-  return $.magenta(str)
-}
-
-const s = Str.Builder()
-const allCommands = await Cli.discoverCommandPointers(commandsDir)
-const commands = allCommands.filter(_ => _.name !== thisModuleName)
-
-s``
-s`${$.bold.redBright`POLEN 🌺`} ${$.dim(`static commands`)}`
-s`Manage static builds and deployments.`
-s``
-s``
-s`${h2(`commands`)}`
-s``
-
-if (Arr.isEmpty(commands)) {
-  s`No commands available yet.`
-} else {
-  commands.forEach(command => {
-    s`${$.dim`$ ${cliName}`} ${$.cyanBright(command.name)}`
-  })
-}
-s``
-s`${$.dim`Get help for a command with ${code(`polen static <command> --help`)}`}`
-s``
-
-console.log(Str.indent(String(s)))

package/src/dep/superjson/index.ts

@@ -1 +0,0 @@
-export * as Superjson from './superjson.js'

package/src/dep/superjson/superjson.ts

@@ -1,8 +0,0 @@
-import type { Json } from '@wollybeard/kit'
-import type { registerCustom } from 'superjson'
-
-export type CustomTransformer<I, O extends Json.Value> = Parameters<
-  typeof registerCustom<I, O>
->[0]
-
-export * from 'superjson'

package/src/lib/errors/index.ts

@@ -1 +0,0 @@
-export * as Errors from './errors.js'

package/src/lib/file-router/diagnostic-reporter.ts

@@ -1,22 +0,0 @@
-import type { Diagnostic } from './linter.js'
-
-export const reportDiagnostics = (diagnostics: Diagnostic[]) => {
-  if (diagnostics.length === 0) return
-
-  const errors = diagnostics.filter(d => d.severity === `error`)
-  const warnings = diagnostics.filter(d => d.severity === `warning`)
-  const infos = diagnostics.filter(d => d.severity === `info`)
-
-  const summary = [
-    errors.length > 0 && `${errors.length} error${errors.length === 1 ? `` : `s`}`,
-    warnings.length > 0 && `${warnings.length} warning${warnings.length === 1 ? `` : `s`}`,
-    infos.length > 0 && `${infos.length} info${infos.length === 1 ? `` : `s`}`,
-  ].filter(Boolean).join(`, `)
-
-  console.warn(`\nPolen found ${summary}:\n`)
-
-  diagnostics.forEach((diagnostic, index) => {
-    const icon = diagnostic.severity === `error` ? `✗` : diagnostic.severity === `warning` ? `⚠` : `ⓘ`
-    console.warn(`${icon} ${index + 1}. ${diagnostic.message}\n`)
-  })
-}

package/src/lib/file-router/index.ts

@@ -1 +0,0 @@
-export * as FileRouter from './file-router.js'

package/src/lib/grafaid/index.ts

@@ -1 +0,0 @@
-export * as Grafaid from './grafaid.js'