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

package/src/api/schema/metadata.ts

@@ -1,23 +0,0 @@
-import { Fs } from '@wollybeard/kit'
-import { z } from 'zod'
-
-export const SchemaMetadataSchema = z.object({
-  /** Whether a schema is present in the project */
-  hasSchema: z.boolean(),
-  /** Array of available version identifiers */
-  versions: z.array(z.string()),
-})
-
-export type SchemaMetadata = z.infer<typeof SchemaMetadataSchema>
-
-export const getMetadata = async (path: string): Promise<SchemaMetadata> => {
-  const result = await Fs.readJson(path)
-  if (!result) {
-    return {
-      hasSchema: false,
-      versions: [],
-    }
-  }
-
-  return SchemaMetadataSchema.parse(result)
-}

package/src/api/schema/read.ts

@@ -1,196 +0,0 @@
-import type { GraphqlChangeset } from '#lib/graphql-changeset'
-import { Arr } from '@wollybeard/kit'
-import * as DataSources from './data-sources/data-sources.js'
-
-export type DataSourceType =
-  | `file`
-  | `directory`
-  | `memory`
-  | `data`
-  | `introspection`
-  | `introspectionFile`
-  | `introspectionAuto`
-
-/**
- * Result of schema reading with provenance tracking for file watching and debugging.
- */
-export interface SchemaReadResult {
-  data: GraphqlChangeset.ChangelogLinked | null
-  source: {
-    type: DataSourceType
-    /**
-     * Recreate the schema data and file after it has been deleted.
-     *
-     * This function re-fetches data from the original source and recreates
-     * the schema file on disk. Only called by file watchers after deletion.
-     *
-     * @returns Promise resolving to the recreated schema data, or null if recreation fails
-     */
-    reCreate?: () => Promise<GraphqlChangeset.ChangelogLinked | null>
-  }
-}
-
-/**
- * Schema configuration for Polen.
- *
- * Polen supports multiple ways to load your GraphQL schema, from simple files
- * to dynamic introspection. Configure which sources to use and in what order.
- *
- * @example
- * ```ts
- * // Load from a file (default)
- * schema: {} // Looks for schema.graphql
- *
- * // Load via introspection
- * schema: {
- *   dataSources: {
- *     introspection: {
- *       url: 'https://api.example.com/graphql',
- *       headers: { 'Authorization': 'Bearer token' }
- *     }
- *   }
- * }
- *
- * // Try multiple sources in order
- * schema: {
- *   useDataSources: ['introspection', 'file'],
- *   dataSources: {
- *     introspection: { url: 'https://api.example.com/graphql' },
- *     file: { path: './fallback-schema.graphql' }
- *   }
- * }
- * ```
- */
-export interface Config {
-  /**
-   * Whether to enable schema loading.
-   *
-   * Set to `false` to disable schema features entirely. This removes
-   * the Reference and Changelog pages from your portal.
-   *
-   * @default true
-   *
-   * @example
-   * ```ts
-   * // Disable schema features
-   * schema: { enabled: false }
-   * ```
-   */
-  enabled?: boolean
-  /**
-   * Which data sources to use for loading schemas.
-   *
-   * - `file` - Load from a single SDL file (default: `./schema.graphql`)
-   * - `directory` - Load multiple SDL files from a directory (default: `./schema/`)
-   * - `memory` - Use schemas defined in configuration
-   * - `data` - Use a pre-built schema object
-   * - `introspection` - Load schema via GraphQL introspection
-   *
-   * If not specified, Polen tries all sources in this order:
-   * 1. `data` 2. `directory` 3. `file` 4. `memory` 5. `introspection`
-   *
-   * @example
-   * ```ts
-   * // Use only file source
-   * useDataSources: 'file'
-   *
-   * // Try multiple sources in custom order
-   * useDataSources: ['introspection', 'file']
-   *
-   * // Default behavior (try all sources)
-   * // useDataSources: undefined
-   * ```
-   */
-  useDataSources?: Arr.Maybe<DataSourceType>
-  /**
-   * Configuration for each data source type.
-   */
-  dataSources?: {
-    /**
-     * Configuration for loading schema from a single SDL file.
-     */
-    file?: DataSources.SchemaFile.ConfigInput
-    /**
-     * Configuration for loading multiple schema versions from a directory.
-     */
-    directory?: DataSources.SchemaDirectory.ConfigInput
-    /**
-     * Configuration for defining schemas programmatically.
-     */
-    memory?: DataSources.Memory.ConfigInput
-    /**
-     * Pre-built schema object to use directly.
-     */
-    data?: GraphqlChangeset.ChangelogLinked
-    /**
-     * Configuration for loading schema via GraphQL introspection.
-     *
-     * Introspection fetches your schema directly from a running GraphQL endpoint.
-     * The schema is saved to `schema.introspection.json` in your project root.
-     * Delete this file to force a fresh introspection on the next build.
-     *
-     * @example
-     * ```ts
-     * introspection: {
-     *   url: 'https://api.example.com/graphql',
-     *   headers: { 'Authorization': 'Bearer token' }
-     * }
-     * ```
-     */
-    introspection?: DataSources.Introspection.ConfigInput
-  }
-  projectRoot: string
-}
-
-export const readOrThrow = async (
-  config: Config,
-): Promise<SchemaReadResult> => {
-  if (config.enabled === false) {
-    return { data: null, source: { type: 'data' } }
-  }
-
-  const useDataSources = config.useDataSources ? Arr.sure(config.useDataSources) : null
-  const usingDataSource = (dataSource: DataSourceType) => useDataSources === null || useDataSources.includes(dataSource)
-
-  if (usingDataSource(`data`) && config.dataSources?.data) {
-    return { data: config.dataSources.data, source: { type: 'data' } }
-  }
-
-  if (usingDataSource(`directory`)) {
-    const directoryConfig = {
-      projectRoot: config.projectRoot,
-      ...config.dataSources?.directory,
-    }
-    const result = await DataSources.SchemaDirectory.readOrThrow(directoryConfig)
-    if (result) return { data: result, source: { type: 'directory' } }
-  }
-
-  if (usingDataSource(`file`)) {
-    const fileConfig = {
-      projectRoot: config.projectRoot,
-      ...config.dataSources?.file,
-    }
-    const result = await DataSources.SchemaFile.readOrThrow(fileConfig)
-    if (result) return { data: result, source: { type: 'file' } }
-  }
-
-  if (usingDataSource(`memory`) && config.dataSources?.memory) {
-    const memoryConfig = {
-      projectRoot: config.projectRoot,
-      ...config.dataSources.memory,
-    }
-    const result = await DataSources.Memory.read(memoryConfig)
-    if (result) return { data: result, source: { type: 'memory' } }
-  }
-
-  if (usingDataSource(`introspection`) && config.dataSources?.introspection) {
-    const introspectionConfig = {
-      projectRoot: config.projectRoot,
-      ...config.dataSources.introspection,
-    }
-    const result = await DataSources.Introspection.readOrThrow(introspectionConfig)
-    if (result.data) return result
-  }
-
-  return { data: null, source: { type: 'data' } }
-}

package/src/api/schema/schema.ts

@@ -1,8 +0,0 @@
-// Re-export everything from isomorphic layer
-export * from '../iso/schema/constants.js'
-export * as Routing from '../iso/schema/routing.js'
-
-// Server-only exports
-export * as DataSources from './data-sources/data-sources.js'
-export * from './metadata.js'
-export * from './read.js'

package/src/api/schema-augmentation/augmentations/description.ts

@@ -1,57 +0,0 @@
-import type { GrafaidOld } from '#lib/grafaid-old'
-import { neverCase } from '@wollybeard/kit/language'
-import type { Target } from '../target.js'
-import { locateTargetField, locateTargetType } from '../target.js'
-
-export const Placement = {
-  Before: `before`,
-  After: `after`,
-  Over: `over`,
-} as const
-
-export type Placement = (typeof Placement)[keyof typeof Placement]
-
-export interface DescriptionAugmentation {
-  type: `description`
-  on: Target
-  placement: Placement
-  content: string
-}
-
-export const applyDescriptionContent = (
-  type: GrafaidOld.Groups.Describable,
-  augmentation: DescriptionAugmentation,
-) => {
-  const existingDescription = type.description ?? ``
-
-  switch (augmentation.placement) {
-    case `before`:
-      type.description = `${augmentation.content}\n\n${existingDescription}`
-      break
-    case `after`:
-      type.description = `${existingDescription}\n\n${augmentation.content}`
-      break
-    case `over`:
-      type.description = augmentation.content
-      break
-    default:
-      neverCase(augmentation.placement)
-  }
-}
-
-export const apply = (schema: GrafaidOld.Schema.Schema, augmentation: DescriptionAugmentation) => {
-  switch (augmentation.on.type) {
-    case `TargetType`: {
-      const type = locateTargetType(schema, augmentation.on)
-      applyDescriptionContent(type, augmentation)
-      break
-    }
-    case `TargetField`: {
-      const field = locateTargetField(schema, augmentation.on)
-      applyDescriptionContent(field, augmentation)
-      break
-    }
-    default:
-      neverCase(augmentation.on)
-  }
-}

package/src/api/schema-augmentation/index.ts

@@ -1 +0,0 @@
-export * as SchemaAugmentation from './schema-augmentation.js'

package/src/api/schema-augmentation/schema-augmentation.ts

@@ -1,25 +0,0 @@
-import type { GrafaidOld } from '#lib/grafaid-old'
-import { neverCase } from '@wollybeard/kit/language'
-import * as AugmentationDescription from './augmentations/description.js'
-
-export { AugmentationDescription }
-
-export type Augmentation = AugmentationDescription.DescriptionAugmentation
-
-export const apply = (
-  schema: GrafaidOld.Schema.Schema,
-  augmentations: Augmentation[],
-): GrafaidOld.Schema.Schema => {
-  for (const augmentation of augmentations) {
-    switch (augmentation.type) {
-      case `description`: {
-        AugmentationDescription.apply(schema, augmentation)
-        break
-      }
-      default:
-        neverCase(augmentation.type)
-    }
-  }
-
-  return schema
-}

package/src/api/schema-augmentation/target.ts

@@ -1,50 +0,0 @@
-import { Grafaid } from '#lib/grafaid'
-
-export type Target = TargetType | TargetField
-
-export interface TargetType {
-  type: `TargetType`
-  name: string
-}
-
-export interface TargetField {
-  type: `TargetField`
-  name: string
-  typeTarget: TargetType
-}
-
-export const locateTargetType = (
-  schema: Grafaid.Schema.Schema,
-  target: TargetType,
-): Grafaid.Schema.TypesLike.Named => {
-  const type = schema.getType(target.name)
-  if (!type) {
-    throw new Error(`Could not find type ${target.name}`)
-  }
-  return type
-}
-
-export const locateTargetField = (
-  schema: Grafaid.Schema.Schema,
-  target: TargetField,
-): Grafaid.Schema.NodesLike.Field => {
-  const type = schema.getType(target.typeTarget.name)
-
-  if (!type) {
-    throw new Error(`Could not find type ${target.typeTarget.name}`)
-  }
-
-  if (!Grafaid.Schema.TypesLike.isFielded(type)) {
-    throw new Error(`Type ${target.typeTarget.name} does not have fields`)
-  }
-
-  const fields = type.getFields()
-  const field = fields[target.name]
-
-  if (!field) {
-    // dprint-ignore
-    throw new Error(`Could not find field ${target.name} on type ${target.typeTarget.name}`)
-  }
-
-  return field
-}

package/src/api/schema-source/index.ts

@@ -1 +0,0 @@
-export * from './schema-source.js'

package/src/api/schema-source/schema-source.ts

@@ -1,216 +0,0 @@
-import { Schema } from '#api/schema/index'
-import { Grafaid } from '#lib/grafaid'
-import { GraphqlChangeset } from '#lib/graphql-changeset'
-import { SchemaLifecycle } from '#lib/schema-lifecycle'
-import { astToSchema } from '#template/lib/schema-utils/schema-utils'
-import { Cache } from '@wollybeard/kit'
-import type { GraphQLSchema } from 'graphql'
-
-type WriteFile = (path: string, content: string) => Promise<void>
-
-type ReadFile = (locator: string) => Promise<string>
-
-type ClearDirectory = (path: string) => Promise<void>
-
-type RemoveFile = (path: string) => Promise<void>
-
-const NoImplementationWriteFile: WriteFile = async (path: string, content: string) => {
-  throw new Error('Write operations not supported in this environment')
-}
-
-const NoImplementationClearDirectory: ClearDirectory = async (path: string) => {
-  throw new Error('Directory operations not supported in this environment')
-}
-
-const NoImplementationRemoveFile: RemoveFile = async (path: string) => {
-  throw new Error('File removal operations not supported in this environment')
-}
-
-interface SchemaSourceConfig {
-  io: {
-    read: ReadFile
-    write?: WriteFile
-    clearDirectory?: ClearDirectory
-    removeFile?: RemoveFile
-  }
-  versions: string[]
-  assetsPath: string
-  debug?: boolean
-}
-
-export const createSchemaSource = (config: SchemaSourceConfig) => {
-  const getSchemaPath = (version: string) => `${config.assetsPath}/schemas/${version}.json`
-
-  const getChangelogPath = (version: string) => `${config.assetsPath}/schemas/${version}.release.changelog.json`
-
-  const getSchemasDirectory = () => `${config.assetsPath}/schemas`
-
-  const getMetadataPath = () => `${config.assetsPath}/schemas/metadata.json`
-
-  const getLifecyclePath = () => `${config.assetsPath}/schemas/lifecycle.json`
-
-  const ioWrite = config.io.write || NoImplementationWriteFile
-  const ioClearDirectory = config.io.clearDirectory || NoImplementationClearDirectory
-  const ioRemoveFile = config.io.removeFile || NoImplementationRemoveFile
-
-  // Memoize only the base IO read operation
-  const ioReadMemoized = Cache.memoize(config.io.read)
-
-  const get = async (version: string): Promise<GraphQLSchema> => {
-    const content = await ioReadMemoized(getSchemaPath(version))
-    const schemaAst = JSON.parse(content)
-    const schema = astToSchema(schemaAst)
-    return schema
-  }
-
-  const getChangelog = async (version: string): Promise<GraphqlChangeset.ChangeSet> => {
-    const content = await ioReadMemoized(getChangelogPath(version))
-    return GraphqlChangeset.fromJson(content)
-  }
-
-  const getAllChangesets = async (): Promise<GraphqlChangeset.Changelog> => {
-    const changesets: GraphqlChangeset.ChangeSet[] = []
-
-    for (let i = 0; i < config.versions.length; i++) {
-      const version = config.versions[i]
-      if (!version) continue
-
-      const schema = await get(version)
-      if (!schema) continue
-
-      // Only try to read changelog for non-oldest versions (matching writeDevAssets logic)
-      let changelogData = null
-      if (i < config.versions.length - 1) {
-        changelogData = await getChangelog(version)
-      }
-
-      if (changelogData) {
-        const prevVersion = config.versions[i + 1]
-
-        if (prevVersion) {
-          const prevSchema = await get(prevVersion)
-          changesets.push({
-            type: 'IntermediateChangeSet',
-            after: { data: schema, version },
-            before: { data: prevSchema, version: prevVersion },
-            changes: GraphqlChangeset.isIntermediateChangeSet(changelogData) ? changelogData.changes : [],
-            date: new Date(changelogData.date),
-          })
-        }
-      } else {
-        // Oldest version - no changelog, use existing utility
-        changesets.push({
-          type: 'InitialChangeSet',
-          date: Schema.versionStringToDate(version),
-          after: { data: schema, version },
-        })
-      }
-    }
-
-    return changesets as GraphqlChangeset.Changelog
-  }
-
-  const getLifecycle = async (): Promise<SchemaLifecycle.SchemaLifecycle> => {
-    const content = await ioReadMemoized(getLifecyclePath())
-    return SchemaLifecycle.fromJson(content)
-  }
-
-  return {
-    //
-    // Properties
-    //
-    versions: config.versions,
-    isEmpty: config.versions.length === 0,
-
-    //
-    // Methods
-    //
-    get,
-    getChangelog,
-    getAllChangesets,
-    getLifecycle,
-
-    // Expose the memoized reader's clear method
-    clearCache: ioReadMemoized.clear,
-
-    // Write operations (use the writer, which throws if not provided)
-    writeSchema: async (version: string, schema: GraphQLSchema) => {
-      const ast = Grafaid.Schema.AST.parse(Grafaid.Schema.print(schema))
-      await ioWrite(getSchemaPath(version), JSON.stringify(ast))
-    },
-
-    writeChangelog: async (version: string, changelog: GraphqlChangeset.ChangeSet) => {
-      await ioWrite(
-        getChangelogPath(version),
-        GraphqlChangeset.toJson(changelog),
-      )
-    },
-
-    writeLifecycle: async (lifecycle: SchemaLifecycle.SchemaLifecycle) => {
-      await ioWrite(getLifecyclePath(), SchemaLifecycle.toJson(lifecycle))
-    },
-
-    // Directory operations
-    clearAllAssets: async () => {
-      await ioClearDirectory(getSchemasDirectory())
-    },
-
-    removeAsset: async (version: string) => {
-      try {
-        await ioRemoveFile(getSchemaPath(version))
-      } catch (error) {
-        // Swallow errors for file removal as requested
-      }
-
-      try {
-        await ioRemoveFile(getChangelogPath(version))
-      } catch (error) {
-        // Swallow errors for file removal as requested
-      }
-    },
-
-    writeMetadata: async (metadata: Schema.SchemaMetadata) => {
-      await ioWrite(getMetadataPath(), JSON.stringify(metadata, null, 2))
-    },
-
-    writeAllAssets: async (
-      changelog: GraphqlChangeset.Changelog,
-      metadata: Schema.SchemaMetadata,
-      lifecycle?: SchemaLifecycle.SchemaLifecycle,
-    ) => {
-      if (!changelog) return
-
-      // Write schema and changelog files
-      for (const [index, changeset] of changelog.entries()) {
-        const versionName = index === 0 ? Schema.VERSION_LATEST : Schema.dateToVersionString(changeset.date)
-
-        // Write schema file
-        if (changeset.after?.data) {
-          await ioWrite(
-            getSchemaPath(versionName),
-            JSON.stringify(Grafaid.Schema.AST.parse(Grafaid.Schema.print(changeset.after.data))),
-          )
-        }
-
-        // Write changelog file only for intermediate changesets
-        if (GraphqlChangeset.isIntermediateChangeSet(changeset)) {
-          await ioWrite(
-            getChangelogPath(versionName),
-            GraphqlChangeset.toJson(changeset),
-          )
-        }
-      }
-
-      // Write metadata file
-      await ioWrite(getMetadataPath(), JSON.stringify(metadata, null, 2))
-
-      // Write lifecycle file if provided
-      if (lifecycle) {
-        await ioWrite(
-          getLifecyclePath(),
-          SchemaLifecycle.toJson(lifecycle),
-        )
-      }
-    },
-  }
-}

package/src/api/vite/logger.ts

@@ -1,33 +0,0 @@
-import type { Config } from '#api/api'
-import { Vite } from '#dep/vite/index'
-import { Err, Str } from '@wollybeard/kit'
-import { stripAnsi } from 'consola/utils'
-
-const baseLogger = Vite.createLogger(undefined)
-
-export const createLogger = (config: Config.Config): Vite.Logger => {
-  return {
-    ...baseLogger,
-    info(msg, options) {
-      // Filter out optimization-related messages
-      const msgString = typeof msg === `string` ? msg : String(msg)
-      if (
-        msgString.includes(`new dependencies optimized`)
-        || msgString.includes(`optimized dependencies changed`)
-        || msgString.includes(`Re-optimizing dependencies`)
-        || msgString.includes(`Forced re-optimization`)
-      ) {
-        return
-      }
-      baseLogger.info(msg, options)
-    },
-    error(msg, options) {
-      if (config.advanced.debug) {
-        const firstLine = stripAnsi(Str.lines(msg)[0] ?? `<no message>`)
-        const cause = options?.error
-        const error = new Error(firstLine, { cause })
-        Err.log(error)
-      }
-    },
-  }
-}