polen 0.11.0-next.13 → 0.11.0-next.15

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'

package/src/lib/graph/graph.ts

@@ -0,0 +1,197 @@
+import { S } from '#lib/kit-temp/effect'
+
+// ─── Schema ──────────────────────────────────────────────────────────────────
+
+/**
+ * Dependency graph for tracking relationships between nodes
+ * Used to efficiently handle dependencies in various contexts
+ */
+export const DependencyGraph = S.Struct({
+  /**
+   * Map from parent ID to array of child IDs (parent depends on children)
+   */
+  dependencies: S.Record({ key: S.String, value: S.Array(S.String) }),
+
+  /**
+   * Map from child ID to array of parent IDs (child is depended on by parents)
+   */
+  dependents: S.Record({ key: S.String, value: S.Array(S.String) }),
+}).annotations({
+  identifier: 'DependencyGraph',
+  description: 'A directed graph tracking dependencies between nodes',
+})
+
+export type DependencyGraph = S.Schema.Type<typeof DependencyGraph>
+
+// ─── Constructors ────────────────────────────────────────────────────────────
+
+export const make = DependencyGraph.make
+
+/**
+ * Create an empty dependency graph
+ */
+export const create = (): DependencyGraph =>
+  make({
+    dependencies: {},
+    dependents: {},
+  })
+
+// ─── Domain Logic ────────────────────────────────────────────────────────────
+
+/**
+ * Add a dependency relationship (immutable)
+ * @param graph - The dependency graph
+ * @param parent - The parent node ID
+ * @param child - The child node ID that the parent depends on
+ * @returns A new graph with the dependency added
+ */
+export const addDependency = (
+  graph: DependencyGraph,
+  parent: string,
+  child: string,
+): DependencyGraph => {
+  // Get existing arrays or create empty ones
+  const children = graph.dependencies[parent] || []
+  const parents = graph.dependents[child] || []
+
+  // Add child if not already present
+  const newChildren = children.includes(child) ? children : [...children, child]
+
+  // Add parent if not already present
+  const newParents = parents.includes(parent) ? parents : [...parents, parent]
+
+  return make({
+    dependencies: {
+      ...graph.dependencies,
+      [parent]: newChildren,
+    },
+    dependents: {
+      ...graph.dependents,
+      [child]: newParents,
+    },
+  })
+}
+
+/**
+ * Add a dependency relationship (mutable)
+ * @param graph - The dependency graph to mutate
+ * @param parent - The parent node ID
+ * @param child - The child node ID that the parent depends on
+ */
+export const addDependencyMutable = (
+  graph: DependencyGraph,
+  parent: string,
+  child: string,
+): void => {
+  // Cast to mutable for mutation
+  const mutableGraph = graph as {
+    dependencies: Record<string, string[]>
+    dependents: Record<string, string[]>
+  }
+
+  // Add to dependencies
+  if (!mutableGraph.dependencies[parent]) {
+    mutableGraph.dependencies[parent] = []
+  }
+  if (!mutableGraph.dependencies[parent].includes(child)) {
+    mutableGraph.dependencies[parent].push(child)
+  }
+
+  // Add to dependents
+  if (!mutableGraph.dependents[child]) {
+    mutableGraph.dependents[child] = []
+  }
+  if (!mutableGraph.dependents[child].includes(parent)) {
+    mutableGraph.dependents[child].push(parent)
+  }
+}
+
+/**
+ * Find all nodes that have no dependencies (leaf nodes)
+ */
+export const findLeafNodes = (graph: DependencyGraph): Set<string> => {
+  const leaves = new Set<string>()
+
+  // Check all nodes that appear as children
+  for (const child of Object.keys(graph.dependents)) {
+    const deps = graph.dependencies[child]
+    if (!deps || deps.length === 0) {
+      leaves.add(child)
+    }
+  }
+
+  return leaves
+}
+
+/**
+ * Check if all dependencies of a node have been processed
+ */
+export const areDependenciesReady = (
+  node: string,
+  graph: DependencyGraph,
+  processed: Set<string>,
+): boolean => {
+  const deps = graph.dependencies[node]
+  if (!deps) return true
+
+  return deps.every(dep => processed.has(dep))
+}
+
+/**
+ * Get topological ordering of nodes (children before parents)
+ * This ensures we process dependencies before the nodes that depend on them
+ *
+ * @param graph - The dependency graph
+ * @returns Array of node IDs in topological order
+ */
+export const topologicalSort = (graph: DependencyGraph): string[] => {
+  const result: string[] = []
+  const visited = new Set<string>()
+  const visiting = new Set<string>() // For cycle detection
+
+  // Get all nodes
+  const allNodes = new Set<string>()
+  for (const parent of Object.keys(graph.dependencies)) {
+    allNodes.add(parent)
+  }
+  for (const child of Object.keys(graph.dependents)) {
+    allNodes.add(child)
+  }
+
+  const visit = (node: string): void => {
+    if (visited.has(node)) return
+
+    if (visiting.has(node)) {
+      // Cycle detected - just skip this node
+      return
+    }
+
+    visiting.add(node)
+
+    // Visit all children first
+    const children = graph.dependencies[node]
+    if (children) {
+      for (const child of children) {
+        visit(child)
+      }
+    }
+
+    visiting.delete(node)
+    visited.add(node)
+    result.push(node)
+  }
+
+  // Visit all nodes
+  for (const node of allNodes) {
+    visit(node)
+  }
+
+  return result
+}
+
+// ─── Codec ───────────────────────────────────────────────────────────────────
+
+export const decode = S.decode(DependencyGraph)
+export const decodeSync = S.decodeSync(DependencyGraph)
+export const encode = S.encode(DependencyGraph)
+export const encodeSync = S.encodeSync(DependencyGraph)

package/src/lib/graphql-schema-loader/graphql-schema-loader.ts

@@ -1,13 +1,15 @@
 import { Grafaid } from '#lib/grafaid'
+import { FileSystem } from '@effect/platform/FileSystem'
 import { Fs } from '@wollybeard/kit'
 import { neverCase } from '@wollybeard/kit/language'
+import { Effect } from 'effect'
 import { Graffle } from 'graffle'
 import { Introspection } from 'graffle/extensions/introspection'
 
 export type SchemaPointer = {
   type: `introspect`
   url: string
-  headers?: Record<string, string>
+  headers?: Record<string, string> | undefined
 } | {
   type: `sdl`
   pathOrUrl: string
@@ -16,67 +18,80 @@ export type SchemaPointer = {
   name: `github` | `hive`
 }
 
-export const load = async (source: SchemaPointer): Promise<Grafaid.Schema.Schema> => {
-  switch (source.type) {
-    case `introspect`: {
-      const graffle = Graffle
-        .create()
-        .use(Introspection())
-        .transport({
-          url: source.url,
-          headers: source.headers,
+export const load = (source: SchemaPointer): Effect.Effect<Grafaid.Schema.Schema, Error, FileSystem> =>
+  Effect.gen(function*() {
+    switch (source.type) {
+      case `introspect`: {
+        const graffle = Graffle
+          .create()
+          .use(Introspection())
+          .transport({
+            url: source.url,
+            headers: source.headers || {},
+          })
+
+        const introspectionResult = yield* Effect.tryPromise({
+          try: () => graffle.introspect(),
+          catch: (error) => new Error(`Failed to introspect schema: ${error}`),
         })
 
-      const introspectionResult = await graffle.introspect()
-      if (!introspectionResult) throw new Error(`Failed to introspect schema.`)
+        if (!introspectionResult) {
+          return yield* Effect.fail(new Error(`Failed to introspect schema.`))
+        }
 
-      return Grafaid.Schema.fromIntrospectionQuery(introspectionResult)
-    }
-    case `sdl`: {
-      if (URL.canParse(source.pathOrUrl)) {
-        const response = await fetch(source.pathOrUrl)
+        return Grafaid.Schema.fromIntrospectionQuery(introspectionResult)
+      }
+      case `sdl`: {
+        if (URL.canParse(source.pathOrUrl)) {
+          const response = yield* Effect.tryPromise({
+            try: () => fetch(source.pathOrUrl),
+            catch: (error) => new Error(`Failed to fetch SDL from ${source.pathOrUrl}: ${error}`),
+          })
 
-        if (!response.ok) {
-          throw new Error(`Failed to download SDL from ${source.pathOrUrl}. Status: ${String(response.status)}`)
-        }
+          if (!response.ok) {
+            return yield* Effect.fail(
+              new Error(`Failed to download SDL from ${source.pathOrUrl}. Status: ${String(response.status)}`),
+            )
+          }
 
-        const sdlContent = await response.text()
+          const sdlContent = yield* Effect.tryPromise({
+            try: () => response.text(),
+            catch: (error) => new Error(`Failed to read response text: ${error}`),
+          })
 
-        try {
-          const ast = Grafaid.Schema.AST.parse(sdlContent)
-          return Grafaid.Schema.fromAST(ast)
-        } catch (error) {
-          throw new Error(
-            `Failed to parse SDL from ${source.pathOrUrl}: ${error instanceof Error ? error.message : String(error)}`,
+          const ast = yield* Grafaid.Schema.AST.parse(sdlContent).pipe(
+            Effect.mapError((error) => new Error(`Failed to parse SDL from ${source.pathOrUrl}: ${error}`)),
+          )
+          return yield* Grafaid.Schema.fromAST(ast).pipe(
+            Effect.mapError((error) => new Error(`Failed to build schema from ${source.pathOrUrl}: ${error}`)),
+          )
+        } else {
+          const fs = yield* FileSystem
+          const sdlContent = yield* fs.readFileString(source.pathOrUrl).pipe(
+            Effect.mapError((error) => new Error(`Failed to read SDL from ${source.pathOrUrl}: ${error}`)),
           )
-        }
-      } else {
-        const sdlContent = await Fs.read(source.pathOrUrl)
-        if (!sdlContent) throw new Error(`Failed to read SDL from ${source.pathOrUrl}.`)
 
-        try {
-          const ast = Grafaid.Schema.AST.parse(sdlContent)
-          return Grafaid.Schema.fromAST(ast)
-        } catch (error) {
-          throw new Error(
-            `Failed to parse SDL from ${source.pathOrUrl}: ${error instanceof Error ? error.message : String(error)}`,
+          const ast = yield* Grafaid.Schema.AST.parse(sdlContent).pipe(
+            Effect.mapError((error) => new Error(`Failed to parse SDL from ${source.pathOrUrl}: ${error}`)),
+          )
+          return yield* Grafaid.Schema.fromAST(ast).pipe(
+            Effect.mapError((error) => new Error(`Failed to build schema from ${source.pathOrUrl}: ${error}`)),
           )
         }
       }
-    }
-    case `name`: {
-      switch (source.name) {
-        case `github`: {
-          return load({ type: `sdl`, pathOrUrl: `https://docs.github.com/public/fpt/schema.docs.graphql` })
-        }
-        case `hive`: {
-          return load({ type: `introspect`, url: `https://api.graphql-hive.com/graphql` })
+      case `name`: {
+        switch (source.name) {
+          case `github`: {
+            return yield* load({ type: `sdl`, pathOrUrl: `https://docs.github.com/public/fpt/schema.docs.graphql` })
+          }
+          case `hive`: {
+            return yield* load({ type: `introspect`, url: `https://api.graphql-hive.com/graphql` })
+          }
+          default:
+            return neverCase(source.name)
         }
-        default:
-          return neverCase(source.name)
       }
+      default:
+        return neverCase(source)
     }
-    default:
-      return neverCase(source)
-  }
-}
+  })

package/src/lib/helpers.ts

@@ -1,20 +1,84 @@
-import { Err, Manifest } from '@wollybeard/kit'
+import { S } from '#lib/kit-temp/effect'
+import { FileSystem } from '@effect/platform'
+import { Effect } from 'effect'
+import * as Path from 'node:path'
+
+// ============================================================================
+// Error Types
+// ============================================================================
+
+export class PackageJsonNotFound extends S.TaggedError<PackageJsonNotFound>()('PackageJsonNotFound', {
+  projectRoot: S.String,
+  message: S.String,
+}) {}
+
+export class PackageJsonReadError extends S.TaggedError<PackageJsonReadError>()('PackageJsonReadError', {
+  projectRoot: S.String,
+  message: S.String,
+}) {}
+
+export class PackageJsonParseError extends S.TaggedError<PackageJsonParseError>()('PackageJsonParseError', {
+  projectRoot: S.String,
+  message: S.String,
+}) {}
+
+export type PackageInstallationError = PackageJsonNotFound | PackageJsonReadError | PackageJsonParseError
+
+// ============================================================================
+// Core Function
+// ============================================================================
 
 /**
  * Check if a project has a package installed by examining its package.json
  */
-export async function checkIsProjectHasPackageInstalled(
+export const checkIsProjectHasPackageInstalled = (
   projectRoot: string,
   packageName: string,
-): Promise<boolean> {
-  const packageJson = await Manifest.resource.read(projectRoot)
-
-  if (Err.is(packageJson)) {
-    if (packageJson._tag === `ResourceErrorNotFound`) return false
-    throw packageJson
-  }
-
-  // Check if React is in dependencies or devDependencies
-  return !!(packageJson.dependencies?.[packageName]
-    ?? packageJson.devDependencies?.[packageName])
-}
+): Effect.Effect<boolean, PackageInstallationError, FileSystem.FileSystem> =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const packageJsonPath = Path.join(projectRoot, 'package.json')
+
+    // Check if package.json exists
+    const exists = yield* fs.exists(packageJsonPath).pipe(
+      Effect.mapError((error) =>
+        new PackageJsonReadError({
+          projectRoot,
+          message: `Failed to check if package.json exists: ${(error as any).message || String(error)}`,
+        })
+      ),
+    )
+
+    if (!exists) {
+      return yield* Effect.fail(
+        new PackageJsonNotFound({
+          projectRoot,
+          message: `package.json not found in ${projectRoot}`,
+        }),
+      )
+    }
+
+    // Read package.json content
+    const content = yield* fs.readFileString(packageJsonPath).pipe(
+      Effect.mapError((error) =>
+        new PackageJsonReadError({
+          projectRoot,
+          message: `Failed to read package.json: ${(error as any).message || String(error)}`,
+        })
+      ),
+    )
+
+    // Parse JSON
+    const packageJson = yield* Effect.try({
+      try: () => JSON.parse(content),
+      catch: (error) =>
+        new PackageJsonParseError({
+          projectRoot,
+          message: `Invalid JSON in package.json: ${error instanceof Error ? error.message : String(error)}`,
+        }),
+    })
+
+    // Check if package is in dependencies or devDependencies
+    return !!(packageJson.dependencies?.[packageName]
+      ?? packageJson.devDependencies?.[packageName])
+  })