polen 0.11.0-next.15 → 0.11.0-next.16

package/src/cli-effect/commands/open.ts

@@ -1,183 +0,0 @@
-import { Api } from '#api/index'
-import { Vite } from '#dep/vite/index'
-import { Grafaid } from '#lib/grafaid'
-import { GraphqlSchemaLoader } from '#lib/graphql-schema-loader'
-import { toViteUserConfig } from '#vite/config'
-import { Command, Options } from '@effect/cli'
-import { Err, Fs, Json, Path, Rec } from '@wollybeard/kit'
-import { Effect, Option } from 'effect'
-import { homedir } from 'node:os'
-import { allowGlobalParameter } from '../_/parameters.js'
-
-// Define introspection headers option
-const introspectionHeaders = Options.text('introspection-headers').pipe(
-  Options.withAlias('inh'),
-  Options.optional,
-  Options.withDescription(
-    'Include headers in the introspection query request sent when using --introspection-url. Format is JSON Object.',
-  ),
-)
-
-// Define mutually exclusive source options
-const introspectUrl = Options.text('introspect').pipe(
-  Options.withAlias('in'),
-  Options.withAlias('i'),
-  Options.optional,
-  Options.withDescription('Get the schema by sending a GraphQL introspection query to this URL.'),
-)
-
-const sdlPath = Options.text('sdl').pipe(
-  Options.withAlias('s'),
-  Options.optional,
-  Options.withDescription(
-    'Get the schema from a GraphQL Schema Definition Language file. Can be a path to a local file or an HTTP URL to a remote one.',
-  ),
-)
-
-const namedSchema = Options.choice('name', ['github', 'hive']).pipe(
-  Options.withAlias('n'),
-  Options.optional,
-  Options.withDescription(
-    'Pick from a well known public API. Polen already knows how to fetch the schema for these APIs.',
-  ),
-)
-
-const cache = Options.boolean('cache').pipe(
-  Options.withDefault(true),
-  Options.withDescription('Enable or disable caching. By default this command caches fetched schemas for re-use.'),
-)
-
-// Cache implementation
-const cacheDir = Path.join(homedir(), '.polen', 'cache', 'cli', 'open')
-
-const base64Codec = {
-  encode: (str: string) => Buffer.from(str).toString('base64'),
-  decode: (str: string) => Buffer.from(str, 'base64').toString('utf-8'),
-}
-
-const cacheWrite = async (source: string, schema: Grafaid.Schema.Schema, useCache: boolean) => {
-  if (!useCache) return
-
-  await Err.tryCatchIgnore(async () => {
-    const fileName = base64Codec.encode(source)
-    const filePath = Path.join(cacheDir, fileName)
-    const sdl = Grafaid.Schema.print(schema)
-    await Fs.write({ path: filePath, content: sdl })
-  })
-}
-
-const cacheRead = async (source: string, useCache: boolean) => {
-  if (!useCache) return null
-
-  return Err.tryCatchIgnore(async () => {
-    const fileName = base64Codec.encode(source)
-    const filePath = Path.join(cacheDir, fileName)
-    const sdl = await Fs.read(filePath)
-    if (!sdl) return null
-    const documentNode = await Effect.runPromise(Grafaid.Schema.AST.parse(sdl))
-    return await Effect.runPromise(Grafaid.Schema.fromAST(documentNode))
-  })
-}
-
-const wrapCache = (fn: typeof GraphqlSchemaLoader.load, useCache: boolean) => {
-  const wrapped = (...args: Parameters<typeof GraphqlSchemaLoader.load>) =>
-    Effect.gen(function*() {
-      const cacheKey = JSON.stringify(args)
-      const cachedSchema = yield* Effect.promise(() => cacheRead(cacheKey, useCache))
-
-      if (cachedSchema) {
-        return cachedSchema
-      }
-
-      // GraphqlSchemaLoader.load returns Effect<GraphQLSchema, Error, FileSystem>
-      const value = yield* fn(...args)
-
-      yield* Effect.promise(() => cacheWrite(cacheKey, value, useCache))
-
-      return value
-    })
-
-  return wrapped
-}
-
-const parseHeaders = (headersJsonEncoded: string): Record<string, string> => {
-  const headersJson = Json.codec.decode(headersJsonEncoded)
-  if (!Rec.is(headersJson)) {
-    throw new Error('--introspection-headers must be a JSON object.')
-  }
-  return headersJson as any
-}
-
-export const open = Command.make(
-  'open',
-  {
-    introspectionHeaders,
-    introspectUrl,
-    sdlPath,
-    namedSchema,
-    cache,
-    allowGlobal: allowGlobalParameter,
-  },
-  ({ introspectionHeaders, introspectUrl, sdlPath, namedSchema, cache, allowGlobal }) =>
-    Effect.gen(function*() {
-      // Validate that exactly one source option is provided
-      const introspectValue = Option.getOrUndefined(introspectUrl)
-      const sdlValue = Option.getOrUndefined(sdlPath)
-      const namedValue = Option.getOrUndefined(namedSchema)
-      const headersValue = Option.getOrUndefined(introspectionHeaders)
-
-      const sources = [introspectValue, sdlValue, namedValue].filter(Boolean)
-      if (sources.length === 0) {
-        return yield* Effect.fail(new Error('Must specify one of: --introspect, --sdl, or --name'))
-      }
-      if (sources.length > 1) {
-        return yield* Effect.fail(new Error('Cannot specify multiple source options'))
-      }
-
-      // Determine source type and value
-      let sourceConfig: any
-
-      if (introspectValue) {
-        sourceConfig = {
-          type: 'introspect',
-          url: introspectValue,
-          headers: headersValue ? parseHeaders(headersValue) : undefined,
-        }
-      } else if (sdlValue) {
-        sourceConfig = {
-          type: 'sdl',
-          pathOrUrl: sdlValue,
-        }
-      } else if (namedValue) {
-        sourceConfig = {
-          type: 'name',
-          name: namedValue,
-        }
-      }
-
-      const load = wrapCache(GraphqlSchemaLoader.load, cache)
-      const schema = yield* load(sourceConfig)
-
-      const tempDir = yield* Effect.promise(() => Fs.makeTemporaryDirectory())
-      const config = yield* Api.ConfigResolver.fromMemory({
-        schema: {
-          sources: {
-            memory: {
-              revisions: [
-                {
-                  date: new Date(),
-                  value: schema,
-                },
-              ],
-            },
-          },
-        },
-      }, tempDir)
-
-      const viteConfig = toViteUserConfig(config)
-      const viteDevServer = yield* Effect.promise(() => Vite.createServer(viteConfig))
-
-      yield* Effect.promise(() => viteDevServer.listen())
-      viteDevServer.printUrls()
-    }),
-)

package/src/cli-effect/commands/static/rebase.ts

@@ -1,66 +0,0 @@
-import { Api } from '#api/index'
-import { Args, Command, Options } from '@effect/cli'
-import { Effect, Option } from 'effect'
-import { allowGlobalParameter } from '../../_/parameters.js'
-
-const source = Args.text({ name: 'source' }).pipe(
-  Args.withDescription('Path to the Polen build directory to rebase'),
-)
-
-const newBasePath = Args.text({ name: 'newBasePath' }).pipe(
-  Args.withDescription('New base path for the build (e.g., /new-path/)'),
-)
-
-const target = Options.text('target').pipe(
-  Options.withAlias('t'),
-  Options.optional,
-  Options.withDescription('Target directory for copy mode (if not provided, mutate in place)'),
-)
-
-export const staticRebase = Command.make(
-  'rebase',
-  {
-    source,
-    newBasePath,
-    target,
-    allowGlobal: allowGlobalParameter,
-  },
-  ({ source, newBasePath, target, allowGlobal }) =>
-    Effect.gen(function*() {
-      const targetPath = Option.getOrUndefined(target)
-      const plan: Api.Static.RebasePlan = targetPath
-        ? {
-          changeMode: 'copy',
-          sourcePath: source,
-          targetPath: targetPath,
-          newBasePath,
-        }
-        : {
-          changeMode: 'mutate',
-          sourcePath: source,
-          newBasePath,
-        }
-
-      // Direct Effect execution with timing and error handling
-      const start = Date.now()
-
-      const result = yield* Effect.promise(() => Api.Static.rebase(plan))
-        .pipe(
-          Effect.tap(() => {
-            const duration = Date.now() - start
-            console.log(`Task: rebase`)
-            console.log(`Duration: ${duration}ms`)
-            console.log(`Input: ${JSON.stringify(plan, null, 2)}`)
-          }),
-          Effect.tapError((error) => {
-            const duration = Date.now() - start
-            console.error(`Task: rebase failed`)
-            console.error(`Duration: ${duration}ms`)
-            console.error(`Error:`, error)
-            return Effect.succeed(undefined)
-          }),
-        )
-
-      return result
-    }),
-)

package/src/cli-effect/commands/static.ts

@@ -1,39 +0,0 @@
-import { Command } from '@effect/cli'
-import $ from 'ansis'
-import { Console, Effect } from 'effect'
-
-// Import subcommands
-import { staticRebase } from './static/rebase.js'
-
-const h2 = (str: string) => {
-  return $.bold.black.bgWhiteBright(` ${str.toUpperCase()} `)
-}
-
-const code = (str: string) => {
-  if (!$.isSupported()) return `\`${str}\``
-  return $.magenta(str)
-}
-
-// Default static command that shows usage
-const staticDefault = Command.make(
-  'static',
-  {},
-  () =>
-    Effect.gen(function*() {
-      yield* Console.log(`${$.bold.redBright`POLEN 🌺`} ${$.dim(`static commands`)}`)
-      yield* Console.log('Manage static builds and deployments.')
-      yield* Console.log('')
-      yield* Console.log('')
-      yield* Console.log(`${h2('commands')}`)
-      yield* Console.log('')
-      yield* Console.log(`${$.dim`$ polen static`} ${$.cyanBright('rebase')}`)
-      yield* Console.log('')
-      yield* Console.log(`${$.dim`Get help for a command with ${code('polen static <command> --help')}`}`)
-      yield* Console.log('')
-    }),
-)
-
-// Export the static command with subcommands
-export const staticCommand = staticDefault.pipe(
-  Command.withSubcommands([staticRebase]),
-)

package/src/cli-effect/index.ts

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-
-import { checkGlobalVsLocal } from '#lib/kit-temp'
-import { Command } from '@effect/cli'
-import { NodeContext, NodeRuntime } from '@effect/platform-node'
-import { Console, Effect } from 'effect'
-import manifest from '../../package.json' with { type: 'json' }
-import { allowGlobalParameter } from './_/parameters.js'
-
-// Import all commands
-import { build } from './commands/build.js'
-import { cache } from './commands/cache.js'
-import { config } from './commands/config.js'
-import { create } from './commands/create.js'
-import { dev } from './commands/dev.js'
-import { open } from './commands/open.js'
-import { staticCommand } from './commands/static.js'
-
-// Define the main Polen command
-const polenMain = Command.make(
-  'polen',
-  { allowGlobal: allowGlobalParameter },
-  ({ allowGlobal }) => Console.log('Polen Effect CLI - Use --help to see available commands'),
-)
-
-// Combine all commands into the main CLI
-const command = polenMain.pipe(
-  Command.withSubcommands([
-    dev,
-    build,
-    create,
-    open,
-    cache,
-    config,
-    staticCommand,
-  ]),
-)
-
-// Set up and run the CLI application
-const cli = Command.run(command, {
-  name: 'Polen Effect CLI',
-  version: manifest.version,
-})
-
-// Handle version flag manually since Effect CLI handles it differently
-if (process.argv.includes('--version') || process.argv.includes('-v')) {
-  console.log(manifest.version)
-  process.exit(0)
-}
-
-// Check for global vs local Polen conflict
-try {
-  await checkGlobalVsLocal({
-    packageName: 'polen',
-    currentExecutablePath: process.argv[1] ?? '',
-    errorMessageTemplate: {
-      title: 'Global Polen detected in project with local Polen',
-      explanation:
-        'You are running the global Polen CLI in a project that has Polen installed locally. This can cause version mismatches, cache conflicts, and unexpected behavior.',
-      solutions: [
-        'pnpm exec polen <command>',
-        'npx polen <command>',
-        './node_modules/.bin/polen <command>',
-      ],
-    },
-  })
-} catch (error) {
-  process.exit(1)
-}
-
-// Remove --allow-global from argv before dispatching to commands
-// This prevents "Unknown flag" errors in individual commands
-const filteredArgv = process.argv.filter(arg => arg !== '--allow-global')
-
-NodeRuntime.runMain(
-  cli(filteredArgv).pipe(
-    Effect.provide(NodeContext.layer),
-  ),
-)

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/task/$$.ts

@@ -1,2 +0,0 @@
-export * from './report.js'
-export * from './task.js'

package/src/lib/task/$.test.ts

@@ -1,210 +0,0 @@
-import { Effect } from 'effect'
-import * as fc from 'fast-check'
-import { describe, expect, test, vi } from 'vitest'
-import { Task } from './$.js'
-
-describe('create', () => {
-  test('executes Effect function and captures timing', async () => {
-    const double = Task.create(
-      (x: number) => Effect.succeed(x * 2),
-      { name: 'double' },
-    )
-
-    const report = await Effect.runPromise(double(5))
-
-    expect(report.task.name).toBe('double')
-    expect(report.execution.input).toBe(5)
-    expect(report.execution.output).toBe(10)
-    expect(report.execution.timings.duration).toBeGreaterThan(0)
-  })
-
-  test('captures errors', async () => {
-    const failing = Task.create(
-      () => Effect.fail(new Error('Failed')),
-      { name: 'failing' },
-    )
-
-    const report = await Effect.runPromise(failing(null))
-
-    expect(report.execution.output).toBeInstanceOf(Error)
-    expect((report.execution.output as Error).message).toBe('Failed')
-  })
-})
-
-describe('formatReport', () => {
-  test('masks sensitive data', async () => {
-    const createUser = Task.create(
-      (data: any) =>
-        Effect.succeed({
-          email: data.email,
-          token: 'abc123',
-        }),
-      {
-        name: 'create-user',
-        mask: {
-          input: { password: false }, // Hide password
-          output: { token: false }, // Hide token
-        },
-      },
-    )
-
-    const report = await Effect.runPromise(createUser({
-      email: 'user@example.com',
-      password: 'secret',
-    }))
-
-    // Uses mask from task definition by default
-    const formatted = Task.formatReport(report)
-
-    expect(formatted).toContain('create-user')
-    expect(formatted).toContain('user@example.com')
-    expect(formatted).not.toContain('secret')
-    expect(formatted).not.toContain('abc123')
-  })
-
-  test('debug mode reveals all data', async () => {
-    const createUser = Task.create(
-      (data: any) =>
-        Effect.succeed({
-          email: data.email,
-          token: 'abc123',
-        }),
-      {
-        name: 'create-user',
-        mask: {
-          input: { password: false }, // Hide password
-          output: { token: false }, // Hide token
-        },
-      },
-    )
-
-    const report = await Effect.runPromise(createUser({
-      email: 'user@example.com',
-      password: 'secret',
-    }))
-
-    const formatted = Task.formatReport(report, { debug: true })
-
-    expect(formatted).toContain('secret')
-    expect(formatted).toContain('abc123')
-  })
-})
-
-describe('exitWithReport', () => {
-  test('exits with code 0 on success', async () => {
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
-      throw new Error('process.exit called')
-    })
-    const mockLog = vi.spyOn(console, 'log').mockImplementation(() => {})
-
-    const success = Task.create(() => Effect.succeed('result'))
-    const report = await Effect.runPromise(success(null))
-
-    expect(() => Task.exitWithReport(report)).toThrow('process.exit called')
-    expect(mockExit).toHaveBeenCalledWith(0)
-    expect(mockLog).toHaveBeenCalled()
-
-    mockExit.mockRestore()
-    mockLog.mockRestore()
-  })
-
-  test('exits with code 1 on error', async () => {
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
-      throw new Error('process.exit called')
-    })
-    const mockLog = vi.spyOn(console, 'log').mockImplementation(() => {})
-
-    const failing = Task.create(() => Effect.fail(new Error('Failed')))
-    const report = await Effect.runPromise(failing(null))
-
-    expect(() => Task.exitWithReport(report)).toThrow('process.exit called')
-    expect(mockExit).toHaveBeenCalledWith(1)
-    expect(mockLog).toHaveBeenCalled()
-
-    mockExit.mockRestore()
-    mockLog.mockRestore()
-  })
-})
-
-describe('runAndExit', () => {
-  test('combines create, execute, and exit into one call', async () => {
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
-      throw new Error('process.exit called')
-    })
-    const mockLog = vi.spyOn(console, 'log').mockImplementation(() => {})
-
-    const double = (x: number) => Effect.succeed(x * 2)
-
-    await expect(() => Effect.runPromise(Task.runAndExit(double, 5, { name: 'double' }))).rejects.toThrow(
-      'process.exit called',
-    )
-
-    expect(mockExit).toHaveBeenCalledWith(0)
-    expect(mockLog).toHaveBeenCalled()
-
-    // Verify the logged output contains expected content
-    const loggedOutput = mockLog.mock.calls[0]?.[0]
-    expect(loggedOutput).toContain('double')
-    expect(loggedOutput).toContain('10') // Result of 5 * 2
-
-    mockExit.mockRestore()
-    mockLog.mockRestore()
-  })
-
-  test('exits with error code on failure', async () => {
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
-      throw new Error('process.exit called')
-    })
-    const mockLog = vi.spyOn(console, 'log').mockImplementation(() => {})
-
-    const failing = () => Effect.fail(new Error('Task failed'))
-
-    await expect(() => Effect.runPromise(Task.runAndExit(failing, null, { name: 'failing' }))).rejects.toThrow(
-      'process.exit called',
-    )
-
-    expect(mockExit).toHaveBeenCalledWith(1)
-    expect(mockLog).toHaveBeenCalled()
-
-    mockExit.mockRestore()
-    mockLog.mockRestore()
-  })
-})
-
-describe('property-based tests', () => {
-  test('duration is always positive', async () => {
-    await fc.assert(
-      fc.asyncProperty(
-        fc.integer(),
-        async (input) => {
-          const identity = Task.create(
-            (x: any) => Effect.succeed(x),
-            { name: 'identity' },
-          )
-
-          const report = await Effect.runPromise(identity(input))
-
-          expect(report.execution.timings.duration).toBeGreaterThanOrEqual(0)
-          expect(report.execution.output).toBe(input)
-        },
-      ),
-    )
-  })
-
-  test('timing fields are consistent', async () => {
-    await fc.assert(
-      fc.asyncProperty(
-        fc.anything(),
-        async (input) => {
-          const noop = Task.create((_: any) => Effect.succeed(null))
-          const report = await Effect.runPromise(noop(input))
-
-          const { start, end, duration } = report.execution.timings
-
-          expect(end).toBeGreaterThanOrEqual(start)
-          expect(duration).toBeCloseTo(end - start, 5)
-        },
-      ),
-    )
-  })
-})

package/src/lib/task/$.ts

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

package/src/lib/task/report.ts

@@ -1,72 +0,0 @@
-import { Mask } from '#lib/mask'
-import { Err, Str } from '@wollybeard/kit'
-import type { Definition, MaskOptions } from './task.js'
-
-export interface Report<$Input, $Output> {
-  task: Definition<$Input, $Output>
-  execution: {
-    input: $Input
-    output: $Output | Error
-    timings: {
-      start: number
-      end: number
-      duration: number
-    }
-  }
-}
-
-export interface FormatOptions<$Input, $Output> {
-  /**
-   * Force masks to reveal all data
-   */
-  debug?: boolean | undefined
-  /**
-   * A mask to apply to the input (if any) and successful return (if any).
-   *
-   * @default Uses the mask bundled with the task, if any.
-   */
-  mask?: MaskOptions<$Input, $Output> | undefined
-}
-
-export const formatReport = <$Input, $Output>(
-  report: Report<$Input, $Output>,
-  options?: FormatOptions<$Input, $Output>,
-): string => {
-  const maskOptions = options?.debug
-    ? undefined
-    : (options?.mask ?? report.task.mask)
-
-  // Apply masks
-  const maskedInput = maskOptions?.input
-    ? Mask.apply(report.execution.input, Mask.create(maskOptions.input))
-    : report.execution.input
-
-  const maskedOutput = report.execution.output instanceof Error || !maskOptions?.output
-    ? report.execution.output
-    : Mask.apply(report.execution.output, Mask.create(maskOptions.output))
-
-  // Format report
-  const s = Str.Builder()
-
-  s`Task: ${report.task.name}`
-  s`Duration: ${report.execution.timings.duration.toFixed(2)}ms`
-  s`Input: ${JSON.stringify(maskedInput, null, 2)}`
-
-  if (report.execution.output instanceof Error) {
-    s(Err.inspect(report.execution.output))
-  } else {
-    s`Output: ${JSON.stringify(maskedOutput, null, 2)}`
-  }
-
-  return s.render()
-}
-
-export const exitWithReport = <$Input, $Output>(
-  report: Report<$Input, $Output>,
-  options?: FormatOptions<$Input, $Output>,
-): never => {
-  const isError = Err.is(report.execution.output)
-  const exitCode = isError ? 1 : 0
-  console.log(formatReport(report, options))
-  process.exit(exitCode)
-}