polen 0.11.0-next.14 → 0.11.0-next.16

package/src/lib/file-router/linter.test.ts

@@ -1,4 +1,5 @@
-import { describe, expect, test } from 'vitest'
+import { expect } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
 import { lint } from './linter.js'
 import type { Route } from './route.js'
 
@@ -33,85 +34,100 @@ const createRoute = (path: string[], order?: number, isIndex = false): Route =>
   }
 }
 
-describe('linter', () => {
-  test('warns about numbered prefix on index files', () => {
-    const routes: Route[] = [
-      createRoute(['docs'], 10, true), // 10_index.md
-      createRoute(['docs', 'getting-started']),
-    ]
-
-    const result = lint(routes)
+interface LinterTestCase {
+  routes: Array<{ path: string[]; order?: number; isIndex?: boolean }>
+  expectedDiagnosticCount: number
+  expectedMessage?: string
+  checkDiagnostic?: (diagnostic: any) => void
+}
 
-    expect(result.diagnostics).toHaveLength(1)
-    expect(result.diagnostics[0]).toMatchObject({
-      message: expect.stringContaining('Numbered prefix on index file has no effect'),
-      file: expect.objectContaining({
-        path: expect.objectContaining({
-          relative: expect.objectContaining({
-            name: 'index',
+// dprint-ignore
+Test.suite<LinterTestCase>('linter', [
+  { 
+    name: 'warns about numbered prefix on index files',
+    routes: [
+      { path: ['docs'], order: 10, isIndex: true }, // 10_index.md
+      { path: ['docs', 'getting-started'] },
+    ],
+    expectedDiagnosticCount: 1,
+    expectedMessage: 'Numbered prefix on index file has no effect',
+    checkDiagnostic: (diagnostic) => {
+      expect(diagnostic).toMatchObject({
+        message: expect.stringContaining('Numbered prefix on index file has no effect'),
+        file: expect.objectContaining({
+          path: expect.objectContaining({
+            relative: expect.objectContaining({
+              name: 'index',
+            }),
           }),
         }),
-      }),
-      order: 10,
-    })
-  })
-
-  test('no warning for index files without numbered prefix', () => {
-    const routes: Route[] = [
-      createRoute(['docs'], undefined, true), // index.md
-      createRoute(['docs', 'getting-started']),
-    ]
-
-    const result = lint(routes)
-
-    expect(result.diagnostics).toHaveLength(0)
-  })
-
-  test('warns about numbered prefix conflicts', () => {
-    const routes: Route[] = [
-      createRoute(['about'], 10), // 10_about.md
-      createRoute(['about'], 20), // 20_about.md
-    ]
-
-    const result = lint(routes)
-
-    expect(result.diagnostics).toHaveLength(1)
-    expect(result.diagnostics[0]).toMatchObject({
-      message: expect.stringContaining('conflicting routes due to numbered prefixes'),
-      kept: expect.objectContaining({ order: 20 }),
-      dropped: expect.objectContaining({ order: 10 }),
-    })
-  })
-
-  test('warns about index/literal conflicts', () => {
-    const routes: Route[] = [
-      createRoute(['docs'], undefined, true), // docs/index.md
-      createRoute(['docs']), // docs.md
-    ]
-
-    const result = lint(routes)
-
-    expect(result.diagnostics).toHaveLength(1)
-    expect(result.diagnostics[0]).toMatchObject({
-      message: expect.stringContaining('conflicting routes'),
-      literal: expect.any(Object),
-      index: expect.any(Object),
-    })
-  })
-
-  test('warns about numbered prefix conflicts with same order number', () => {
-    const routes: Route[] = [
-      createRoute(['about'], 10), // 10_about.md
-      createRoute(['about'], 10), // 10-about.md (same order)
-    ]
-
-    const result = lint(routes)
-
-    expect(result.diagnostics).toHaveLength(1)
-    expect(result.diagnostics[0]).toMatchObject({
-      message: expect.stringContaining('Both files have the same order number (10)'),
-      kept: expect.objectContaining({ order: 10 }),
-      dropped: expect.objectContaining({ order: 10 }),
-    })
-  })
+        order: 10,
+      })
+    }
+  },
+  { 
+    name: 'no warning for index files without numbered prefix',
+    routes: [
+      { path: ['docs'], isIndex: true }, // index.md
+      { path: ['docs', 'getting-started'] },
+    ],
+    expectedDiagnosticCount: 0,
+  },
+  { 
+    name: 'warns about numbered prefix conflicts',
+    routes: [
+      { path: ['about'], order: 10 }, // 10_about.md
+      { path: ['about'], order: 20 }, // 20_about.md
+    ],
+    expectedDiagnosticCount: 1,
+    expectedMessage: 'conflicting routes due to numbered prefixes',
+    checkDiagnostic: (diagnostic) => {
+      expect(diagnostic).toMatchObject({
+        message: expect.stringContaining('conflicting routes due to numbered prefixes'),
+        kept: expect.objectContaining({ order: 20 }),
+        dropped: expect.objectContaining({ order: 10 }),
+      })
+    }
+  },
+  { 
+    name: 'warns about index/literal conflicts',
+    routes: [
+      { path: ['docs'], isIndex: true }, // docs/index.md
+      { path: ['docs'] }, // docs.md
+    ],
+    expectedDiagnosticCount: 1,
+    expectedMessage: 'conflicting routes',
+    checkDiagnostic: (diagnostic) => {
+      expect(diagnostic).toMatchObject({
+        message: expect.stringContaining('conflicting routes'),
+        literal: expect.any(Object),
+        index: expect.any(Object),
+      })
+    }
+  },
+  { 
+    name: 'warns about numbered prefix conflicts with same order number',
+    routes: [
+      { path: ['about'], order: 10 }, // 10_about.md
+      { path: ['about'], order: 10 }, // 10-about.md (same order)
+    ],
+    expectedDiagnosticCount: 1,
+    expectedMessage: 'Both files have the same order number (10)',
+    checkDiagnostic: (diagnostic) => {
+      expect(diagnostic).toMatchObject({
+        message: expect.stringContaining('Both files have the same order number (10)'),
+        kept: expect.objectContaining({ order: 10 }),
+        dropped: expect.objectContaining({ order: 10 }),
+      })
+    }
+  },
+], ({ routes, expectedDiagnosticCount, expectedMessage, checkDiagnostic }) => {
+  const routeObjects = routes.map(r => createRoute(r.path, r.order, r.isIndex))
+  const result = lint(routeObjects)
+  
+  expect(result.diagnostics).toHaveLength(expectedDiagnosticCount)
+  
+  if (expectedDiagnosticCount > 0 && checkDiagnostic) {
+    checkDiagnostic(result.diagnostics[0])
+  }
 })

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

@@ -1,43 +1,82 @@
+import { Diagnostic } from '#lib/diagnostic/$'
+import { S } from '#lib/kit-temp/effect'
 import { Idx, Path } from '@wollybeard/kit'
 import { type Route, type RouteFile, routeIsFromIndexFile, routeToPathExpression } from './route.js'
 
-export type DiagnosticSeverity = `error` | `warning` | `info`
-
-export type Diagnostic = DiagnosticIndexConflict | DiagnosticNumberedPrefixConflict | DiagnosticNumberedPrefixOnIndex
-
-export interface DiagnosticIndexConflict {
-  type: `index-conflict`
-  severity: DiagnosticSeverity
-  message: string
-  literal: {
-    file: RouteFile
-  }
-  index: {
-    file: RouteFile
-  }
-}
-
-export interface DiagnosticNumberedPrefixConflict {
-  type: `numbered-prefix-conflict`
-  severity: DiagnosticSeverity
-  message: string
-  kept: {
-    file: RouteFile
-    order: number
-  }
-  dropped: {
-    file: RouteFile
-    order: number
-  }
-}
-
-export interface DiagnosticNumberedPrefixOnIndex {
-  type: `numbered-prefix-on-index`
-  severity: DiagnosticSeverity
-  message: string
-  file: RouteFile
-  order: number
-}
+// ============================================================================
+// Schema - File Router Diagnostics
+// ============================================================================
+
+export const DiagnosticIndexConflict = Diagnostic.create({
+  source: 'file-router',
+  name: 'index-conflict',
+  severity: 'error',
+  context: {
+    literal: S.Struct({
+      file: S.Any, // RouteFile - using Any to avoid circular dependencies
+    }),
+    index: S.Struct({
+      file: S.Any, // RouteFile
+    }),
+  },
+}).annotations({
+  identifier: 'DiagnosticIndexConflict',
+  description: 'Diagnostic for conflicting index and literal file routes',
+})
+export const makeDiagnosticIndexConflict = Diagnostic.createMake(DiagnosticIndexConflict)
+
+export const DiagnosticNumberedPrefixConflict = Diagnostic.create({
+  source: 'file-router',
+  name: 'numbered-prefix-conflict',
+  severity: 'error',
+  context: {
+    kept: S.Struct({
+      file: S.Any, // RouteFile
+      order: S.Number,
+    }),
+    dropped: S.Struct({
+      file: S.Any, // RouteFile
+      order: S.Number,
+    }),
+  },
+}).annotations({
+  identifier: 'DiagnosticNumberedPrefixConflict',
+  description: 'Diagnostic for conflicting routes with numbered prefixes',
+})
+export const makeDiagnosticNumberedPrefixConflict = Diagnostic.createMake(DiagnosticNumberedPrefixConflict)
+
+export const DiagnosticNumberedPrefixOnIndex = Diagnostic.create({
+  source: 'file-router',
+  name: 'numbered-prefix-on-index',
+  severity: 'warning',
+  context: {
+    file: S.Any, // RouteFile
+    order: S.Number,
+  },
+})
+  .annotations({
+    identifier: 'DiagnosticNumberedPrefixOnIndex',
+    description: 'Diagnostic for numbered prefix on index file that has no effect',
+  })
+
+export const makeDiagnosticNumberedPrefixOnIndex = Diagnostic.createMake(DiagnosticNumberedPrefixOnIndex)
+
+// Union of all file-router diagnostics
+export const FileRouterDiagnostic = S.Union(
+  DiagnosticIndexConflict,
+  DiagnosticNumberedPrefixConflict,
+  DiagnosticNumberedPrefixOnIndex,
+).annotations({
+  identifier: 'FileRouterDiagnostic',
+  description: 'All diagnostics that can be generated by the file router',
+})
+
+export type Diagnostic = typeof FileRouterDiagnostic.Type
+
+// Individual diagnostic types
+export type DiagnosticIndexConflict = typeof DiagnosticIndexConflict.Type
+export type DiagnosticNumberedPrefixConflict = typeof DiagnosticNumberedPrefixConflict.Type
+export type DiagnosticNumberedPrefixOnIndex = typeof DiagnosticNumberedPrefixOnIndex.Type
 
 export interface LintResult {
   diagnostics: Diagnostic[]
@@ -52,15 +91,13 @@ export const lint = (routes: Route[]): LintResult => {
   // ━ Check for numbered prefix on index files
   for (const route of routes) {
     if (routeIsFromIndexFile(route) && route.logical.order !== undefined) {
-      const diagnostic: DiagnosticNumberedPrefixOnIndex = {
-        type: `numbered-prefix-on-index`,
-        severity: `warning`,
+      const diagnostic = makeDiagnosticNumberedPrefixOnIndex({
         message: `Numbered prefix on index file has no effect. The file:\n  ${
           Path.format(route.file.path.relative)
         }\n\nhas a numbered prefix (${route.logical.order}_) which doesn't affect ordering since index files represent their parent directory.`,
         file: route.file,
         order: route.logical.order,
-      }
+      })
       diagnostics.push(diagnostic)
     }
   }
@@ -84,9 +121,7 @@ export const lint = (routes: Route[]): LintResult => {
           ? `Both files have the same order number (${kept.logical.order}). The file processed later is being kept based on processing order.`
           : `The file with lower order number (${dropped.logical.order}) is being dropped in favor of the one with higher order (${kept.logical.order}).`
 
-        const diagnostic: DiagnosticNumberedPrefixConflict = {
-          type: `numbered-prefix-conflict`,
-          severity: `error`,
+        const diagnostic = makeDiagnosticNumberedPrefixConflict({
           // dprint-ignore
           message: `Your files represent conflicting routes due to numbered prefixes. This file:\n  ${Path.format(kept.file.path.relative)}\n\nconflicts with this file:\n\n  ${Path.format(dropped.file.path.relative)}.\n\n${orderMessage}`,
           kept: {
@@ -97,7 +132,7 @@ export const lint = (routes: Route[]): LintResult => {
             file: dropped.file,
             order: dropped.logical.order!,
           },
-        }
+        })
         diagnostics.push(diagnostic)
         continue
       }
@@ -109,9 +144,7 @@ export const lint = (routes: Route[]): LintResult => {
       }
 
       // Report
-      const diagnostic: DiagnosticIndexConflict = {
-        type: `index-conflict`,
-        severity: `error`,
+      const diagnostic = makeDiagnosticIndexConflict({
         // dprint-ignore
         message: `Your files represent conflicting routes. This index file route:\n  ${Path.format(index.file.path.relative)}\n\nconflicts with this literal file route:\n\n  ${Path.format(literal.file.path.relative)}.\n\nYour index route is being ignored.`,
         literal: {
@@ -120,7 +153,7 @@ export const lint = (routes: Route[]): LintResult => {
         index: {
           file: index.file,
         },
-      }
+      })
       diagnostics.push(diagnostic)
 
       continue

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

@@ -42,7 +42,7 @@ export interface Route {
 
 export interface RouteLogical {
   path: Path
-  order?: number
+  order?: number | undefined
 }
 
 export interface RouteFile {

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

@@ -1,5 +1,6 @@
-import { TinyGlobby } from '#dep/tiny-globby/index'
+import * as TinyGlobbyModule from '#dep/tiny-globby/index'
 import { Path, Str } from '@wollybeard/kit'
+import { Effect } from 'effect'
 import { type Diagnostic, lint } from './linter.js'
 import { type Route, type RouteFile, type RouteLogical } from './route.js'
 
@@ -41,27 +42,31 @@ export interface ScanResult {
 //
 //
 
-export const scan = async (parameters: {
+export const scan = (parameters: {
   dir: string
   glob?: string
-}): Promise<ScanResult> => {
-  const { dir, glob = `**/*.{md,mdx}` } = parameters
-
-  // Get all files directly
-  const filePaths = await TinyGlobby.glob(glob, {
-    absolute: true,
-    cwd: dir,
-    onlyFiles: true,
-  })
+}): Effect.Effect<ScanResult, Error, never> =>
+  Effect.gen(function*() {
+    const { dir, glob = `**/*.{md,mdx}` } = parameters
 
-  // Convert to routes
-  const routes = filePaths.map(filePath => filePathToRoute(filePath, dir))
+    // Get all files directly
+    const filePaths = yield* TinyGlobbyModule.EffectGlobby.glob(glob, {
+      absolute: true,
+      cwd: dir,
+      onlyFiles: true,
+    })
 
-  // Apply linting
-  const lintResult = lint(routes)
+    // Convert to routes
+    const routes = filePaths.map((filePath: string) => filePathToRoute(filePath, dir))
 
-  return lintResult
-}
+    // Apply linting
+    const lintResult = lint(routes)
+
+    return {
+      routes: lintResult.routes,
+      diagnostics: lintResult.diagnostics,
+    }
+  })
 
 export const filePathToRoute = (filePathExpression: string, rootDir: string): Route => {
   const file: RouteFile = {

package/src/lib/grafaid/schema/ast.ts

@@ -1,6 +1,12 @@
-export { parse } from 'graphql'
+import { Effect } from 'effect'
+import { type DocumentNode, Kind, parse as graphqlParse } from 'graphql'
 
-import { type DocumentNode, Kind } from 'graphql'
+// Effect-based version of parse
+export const parse = (source: string): Effect.Effect<DocumentNode, Error> =>
+  Effect.try({
+    try: () => graphqlParse(source),
+    catch: (error) => new Error(`Failed to parse GraphQL: ${error}`),
+  })
 
 export { type DocumentNode as Document } from 'graphql'
 

package/src/lib/grafaid/schema/read.ts

@@ -1,13 +1,29 @@
+import { FileSystem } from '@effect/platform/FileSystem'
 import { Fs } from '@wollybeard/kit'
-import { buildASTSchema, type GraphQLSchema, parse } from 'graphql'
-
-export const read = async (sdlFilePath: string): Promise<null | Fs.File<GraphQLSchema>> => {
-  const content = await Fs.read(sdlFilePath)
-  if (!content) return null
-  const node = parse(content)
-  const schema = buildASTSchema(node)
-  return {
-    path: sdlFilePath,
-    content: schema,
-  }
-}
+import { Effect } from 'effect'
+import { type GraphQLSchema } from 'graphql'
+import * as AST from './ast.js'
+import { fromAST } from './schema.js'
+
+export const read = (sdlFilePath: string): Effect.Effect<null | Fs.File<GraphQLSchema>, Error, FileSystem> =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem
+
+    // Check if file exists
+    const exists = yield* Effect.either(fs.exists(sdlFilePath))
+    if (exists._tag === 'Left' || !exists.right) {
+      return null
+    }
+
+    // Read file content
+    const content = yield* fs.readFileString(sdlFilePath)
+
+    // Parse and build schema
+    const node = yield* AST.parse(content)
+    const schema = yield* fromAST(node)
+
+    return {
+      path: sdlFilePath,
+      content: schema,
+    }
+  })

package/src/lib/grafaid/schema/schema.ts

@@ -1,13 +1,20 @@
+import { Effect } from 'effect'
 import { buildASTSchema, type GraphQLSchema } from 'graphql'
 
 export {
-  buildASTSchema as fromAST,
   buildClientSchema as fromIntrospectionQuery,
   GraphQLSchema as Schema,
   introspectionFromSchema as toIntrospectionQuery,
   printSchema as print,
 } from 'graphql'
 
+// Effect-based version of fromAST
+export const fromAST = (ast: AST.Document): Effect.Effect<GraphQLSchema, Error> =>
+  Effect.try({
+    try: () => buildASTSchema(ast),
+    catch: (error) => new Error(`Failed to build schema from AST: ${error}`),
+  })
+
 export * as AST from './ast.js'
 
 export * as Type from './type.js'

package/src/lib/grafaid/schema/type-class-name.ts

@@ -49,15 +49,15 @@ export type TypeClassName =
   | TypeClassName.NonNull
 
 // dprint-ignore
-export type TypeClassToName<C> =
-    C extends GraphQLScalarType    		? TypeClassName.Scalar
-  : C extends GraphQLObjectType    		? TypeClassName.Object
-  : C extends GraphQLInterfaceType 		? TypeClassName.Interface
-  : C extends GraphQLUnionType     		? TypeClassName.Union
-  : C extends GraphQLEnumType      		? TypeClassName.Enum
-  : C extends GraphQLInputObjectType 	? TypeClassName.InputObject
-  : C extends GraphQLList<any>       	? TypeClassName.List
-  : C extends GraphQLNonNull<any>    	? TypeClassName.NonNull
+export type TypeClassToName<$C> =
+    $C extends GraphQLScalarType    		? TypeClassName.Scalar
+  : $C extends GraphQLObjectType    		? TypeClassName.Object
+  : $C extends GraphQLInterfaceType 		? TypeClassName.Interface
+  : $C extends GraphQLUnionType     		? TypeClassName.Union
+  : $C extends GraphQLEnumType      		? TypeClassName.Enum
+  : $C extends GraphQLInputObjectType 	? TypeClassName.InputObject
+  : $C extends GraphQLList<any>       	? TypeClassName.List
+  : $C extends GraphQLNonNull<any>    	? TypeClassName.NonNull
   : never
 
 export const typeClassToName = <$Node extends GraphQLNamedType>(

package/src/lib/grafaid-old/grafaid.ts

@@ -36,13 +36,13 @@ export namespace Groups {
   export type Named = GraphQLNamedType
 }
 
-export type GraphQLOutputField<Source = any, Context = any, Args = any> = GraphQLField_graphql<
-  Source,
-  Context,
-  Args
+export type GraphQLOutputField<$Source = any, $Context = any, $Args = any> = GraphQLField_graphql<
+  $Source,
+  $Context,
+  $Args
 >
-export type GraphQLField<Source = any, Context = any, Args = any> =
-  | GraphQLOutputField<Source, Context, Args>
+export type GraphQLField<$Source = any, $Context = any, $Args = any> =
+  | GraphQLOutputField<$Source, $Context, $Args>
   | GraphQLInputField
 
 export const isOutputField = (field: GraphQLField): field is GraphQLOutputField => {

package/src/lib/graph/$$.ts

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

package/src/lib/graph/$.ts

@@ -0,0 +1 @@
+export * as Graph from './$$.js'