polen 0.10.0-next.14 → 0.10.0-next.16

package/src/lib/github-actions/step.test.ts

@@ -1,149 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { z } from 'zod/v4'
-import { createStep } from './step.ts'
-
-describe('defineWorkflowStep', () => {
-  const mockCore = {
-    startGroup: vi.fn(),
-    endGroup: vi.fn(),
-    debug: vi.fn(),
-    info: vi.fn(),
-    warning: vi.fn(),
-    error: vi.fn(),
-    setOutput: vi.fn(),
-  } as any
-
-  const mockContext = {
-    core: mockCore,
-    github: {} as any,
-    context: {} as any,
-    $: {} as any,
-    fs: {} as any,
-  } as any
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('executes step with validated inputs', async () => {
-    const TestStep = createStep({
-      name: 'test-step',
-      description: 'Test step',
-      inputs: z.object({
-        required: z.string(),
-        optional: z.string().optional(),
-      }),
-      outputs: z.object({ result: z.string() }),
-      async run({ inputs }) {
-        return { result: `Got ${inputs.required}` }
-      },
-    })
-
-    // Create context with PR controller
-    const contextWithPR = {
-      ...mockContext,
-      pr: {
-        number: 0,
-        isActive: false,
-        comment: vi.fn(),
-        deleteComment: vi.fn(),
-        getComments: vi.fn(),
-      },
-    }
-
-    const result = await TestStep.run({
-      ...contextWithPR,
-      inputs: {
-        required: 'value',
-        optional: 'optional-value',
-      },
-    })
-
-    expect(result).toEqual({ result: 'Got value' })
-  })
-
-  it('validates output types', async () => {
-    const TestStep = createStep({
-      name: 'test-step',
-      description: 'Test step',
-      inputs: z.object({
-        required: z.string(),
-      }),
-      outputs: z.object({ result: z.string() }),
-      async run({ inputs }) {
-        return { result: inputs.required }
-      },
-    })
-
-    // Outputs are validated in the runner, not in execute
-    expect(TestStep.definition.outputsSchema).toBeDefined()
-    expect(TestStep.definition.inputsSchema).toBeDefined()
-  })
-
-  it('step definition contains all metadata', async () => {
-    const TestStep = createStep({
-      name: 'test-step',
-      description: 'Test step',
-      inputs: z.object({
-        number: z.number(),
-      }),
-      outputs: z.object({ result: z.string() }),
-      async run() {
-        return { result: 'ok' }
-      },
-    })
-
-    expect(TestStep.definition.name).toBe('test-step')
-    expect(TestStep.definition.description).toBe('Test step')
-    expect(TestStep.definition.inputsSchema).toBeDefined()
-    expect(TestStep.definition.outputsSchema).toBeDefined()
-  })
-
-  // todo: this test is now a static type error, update to refelct that
-  // it('does not warn for non-object schemas', async () => {
-  //   const TestStep = defineStep({
-  //     name: 'test-step',
-  //     description: 'Test step',
-  //     inputs: z.string(),
-  //     outputs: z.object({ result: z.string() }),
-  //     async run({ inputs }) {
-  //       return { result: inputs }
-  //     },
-  //   })
-
-  //   await TestStep(mockContext, 'just-a-string')
-
-  //   expect(mockCore.warning).not.toHaveBeenCalled()
-  // })
-
-  it('always provides PR controller', async () => {
-    const mockPR = {
-      number: 123,
-      isActive: true,
-      comment: vi.fn(),
-      deleteComment: vi.fn(),
-      getComments: vi.fn(),
-    }
-
-    const contextWithPR = {
-      ...mockContext,
-      pr: mockPR,
-    }
-
-    const TestStep = createStep({
-      name: 'test-step',
-      description: 'Test step with PR',
-      inputs: z.object({}),
-      outputs: z.object({ isActive: z.boolean() }),
-      async run({ pr }) {
-        return { isActive: pr.isActive }
-      },
-    })
-
-    const result = await TestStep.run({
-      ...contextWithPR,
-      inputs: {},
-    })
-    expect(result).toEqual({ isActive: true })
-  })
-})

package/src/lib/github-actions/step.ts

@@ -1,232 +0,0 @@
-/**
- * Type-safe workflow step framework for GitHub Actions
- */
-
-// import type { Context } from '@actions/github/lib/context.ts'
-import type { GitHub } from '@actions/github/lib/utils.ts'
-import { z } from 'zod/v4'
-import type { GitController } from './git-controller.ts'
-import type { PullRequestController } from './pr-controller.ts'
-import type { Context, ContextSchema as RealContextSchema } from './schemas/context.ts'
-
-/**
- * Arguments passed to the step's run function.
- *
- * @template $Inputs - The validated input values based on your inputs schema
- * @template $Context - The GitHub Actions context (validated if context schema provided)
- */
-export interface Args<$Inputs extends Inputs = Inputs, $Context = Context> {
-  /** GitHub Actions core utilities for logging, setting outputs, etc. */
-  core: typeof import('@actions/core')
-
-  /** GitHub Actions context containing event payload, repo info, etc. */
-  context: $Context
-
-  /** Validated input values passed to the step */
-  inputs: $Inputs
-
-  /** Authenticated Octokit instance for GitHub API operations */
-  github: InstanceType<typeof GitHub>
-
-  /** zx's $ function for executing shell commands */
-  $: typeof import('zx').$
-
-  /** Node.js fs/promises module for file operations */
-  fs: typeof import('node:fs/promises')
-
-  /** PR controller for pull request operations (comment, review, etc.) */
-  pr: PullRequestController
-
-  /** Git controller for git operations (commit, push, etc.) without subprocess details */
-  git: GitController
-}
-
-export type Outputs = object
-
-export type Inputs = object
-
-type InputsSchema = z.ZodObject
-
-type OutputsSchema = z.ZodObject
-
-// This is a loose type because working with sub/sup schema types is complex, maybe not even workable, unclear, and not worth the effort
-type ContextSchema = z.Schema
-
-// Export the full step definition for runner
-export interface Step<
-  $InputsSchema extends InputsSchema = InputsSchema,
-  $OutputsSchema extends OutputsSchema = OutputsSchema,
-  $ContextSchema extends ContextSchema = ContextSchema,
-> {
-  definition: Definition<
-    $InputsSchema,
-    $OutputsSchema,
-    $ContextSchema
-  >
-  run: Runner<
-    z.output<$InputsSchema>,
-    z.output<$OutputsSchema>,
-    z.output<$ContextSchema>
-  >
-}
-
-export type Runner<
-  $Inputs extends Inputs = Inputs,
-  $Outputs extends Outputs = Outputs,
-  $Context = Context,
-> = (
-  context: Args<$Inputs, $Context>,
-) => Promise<$Outputs>
-
-// Generic workflow step definition
-export interface Definition<
-  $InputsSchema extends InputsSchema,
-  $OutputsSchema extends OutputsSchema,
-  $ContextSchema extends ContextSchema,
-> {
-  description?: string
-  name?: string
-  inputsSchema?: $InputsSchema
-  outputsSchema?: $OutputsSchema
-  contextSchema?: $ContextSchema
-}
-
-// Generic workflow step definition
-export interface CreateInput<
-  $InputsSchema extends InputsSchema,
-  $OutputsSchema extends OutputsSchema,
-  $ContextSchema extends z.Schema,
-> {
-  description?: string
-  name?: string
-  inputs?: $InputsSchema
-  outputs?: $OutputsSchema
-  context?: $ContextSchema
-  run: (
-    args: Args<z.output<$InputsSchema>, z.output<$ContextSchema>>,
-    // todo: Obj.isEmpty ...
-  ) => Promise<{} extends z.Infer<$OutputsSchema> ? void : z.Infer<$OutputsSchema>>
-}
-
-/**
- * Create a type-safe GitHub Actions workflow step with runtime validation.
- *
- * This is the main entry point for defining custom workflow steps that can be executed
- * by the GitHub Actions runner. It provides:
- * - Type-safe inputs/outputs with Zod schema validation
- * - Automatic GitHub Actions output handling (both individual outputs and bundled JSON)
- * - Context validation to ensure steps run in the correct workflow events
- * - Integration with GitHub API via Octokit
- * - Built-in error handling and logging
- *
- * @example Basic step with inputs and outputs
- * ```typescript
- * import { z } from 'zod'
- * import { GitHubActions } from '#lib/github-actions'
- *
- * export default GitHubActions.createStep({
- *   name: 'my-step',
- *   description: 'Processes some data and returns results',
- *   inputs: z.object({
- *     message: z.string(),
- *     count: z.number().optional().default(1),
- *   }),
- *   outputs: z.object({
- *     result: z.string(),
- *     processed: z.boolean(),
- *   }),
- *   async run({ inputs, core }) {
- *     core.info(`Processing: ${inputs.message}`)
- *
- *     return {
- *       result: inputs.message.toUpperCase(),
- *       processed: true,
- *     }
- *   }
- * })
- * ```
- *
- * @example Step with specific context requirements
- * ```typescript
- * export default GitHubActions.createStep({
- *   name: 'pr-only-step',
- *   description: 'This step only runs on pull requests',
- *   context: GitHubActions.PullRequestContext,
- *   outputs: z.object({
- *     pr_number: z.number(),
- *   }),
- *   async run({ context, core }) {
- *     const prNumber = context.payload.pull_request.number
- *     core.info(`Running on PR #${prNumber}`)
- *
- *     return { pr_number: prNumber }
- *   }
- * })
- * ```
- *
- * @example Using the GitHub API
- * ```typescript
- * export default GitHubActions.createStep({
- *   name: 'create-issue',
- *   description: 'Creates a GitHub issue',
- *   inputs: z.object({
- *     title: z.string(),
- *     body: z.string(),
- *   }),
- *   outputs: z.object({
- *     issue_number: z.number(),
- *     issue_url: z.string(),
- *   }),
- *   async run({ inputs, github, context }) {
- *     const issue = await github.rest.issues.create({
- *       owner: context.repo.owner,
- *       repo: context.repo.repo,
- *       title: inputs.title,
- *       body: inputs.body,
- *     })
- *
- *     return {
- *       issue_number: issue.data.number,
- *       issue_url: issue.data.html_url,
- *     }
- *   }
- * })
- * ```
- *
- * @param input - Step configuration object
- * @param input.name - Unique identifier for the step (used in logging and debugging)
- * @param input.description - Human-readable description of what the step does
- * @param input.inputs - Optional Zod schema for validating step inputs
- * @param input.outputs - Optional Zod schema for validating step outputs
- * @param input.context - Optional Zod schema for validating GitHub Actions context (event type)
- * @param input.run - Async function that implements the step logic
- *
- * @returns A Step object that can be executed by the GitHub Actions runner
- *
- * @remarks
- * - All outputs are automatically set as GitHub Actions outputs
- * - Boolean outputs are properly handled (use fromJSON in workflows)
- * - A special 'json' output contains all outputs bundled together
- * - The runner provides extensive logging and error handling
- * - Steps can access PR controller for pull request operations
- * - The `$` from zx is available for shell commands
- */
-export function createStep<
-  $InputsSchema extends InputsSchema,
-  $OutputsSchema extends OutputsSchema,
-  $ContextSchema extends ContextSchema = RealContextSchema,
->(
-  input: CreateInput<$InputsSchema, $OutputsSchema, $ContextSchema>,
-): Step<$InputsSchema, $OutputsSchema, $ContextSchema> {
-  const { run, inputs, outputs, context, ...rest } = input
-  const definition: Definition<$InputsSchema, $OutputsSchema, $ContextSchema> = {
-    ...rest,
-    inputsSchema: inputs,
-    outputsSchema: outputs,
-    contextSchema: context,
-  }
-  return {
-    definition,
-    run,
-  } as any
-}

package/src/lib/graphql-document/components/CopyButton.tsx

@@ -1,76 +0,0 @@
-/**
- * Copy button component for GraphQL documents
- */
-
-import type { React } from '#dep/react/index'
-import { React as ReactHooks } from '#dep/react/index'
-import { CheckIcon, CopyIcon } from '@radix-ui/react-icons'
-import { Button } from '@radix-ui/themes'
-
-export interface CopyButtonProps {
-  /** The text to copy */
-  text: string
-  /** Optional className */
-  className?: string
-  /** Size variant */
-  size?: '1' | '2' | '3'
-}
-
-/**
- * Copy button for GraphQL code blocks
- *
- * Shows a copy icon that changes to a checkmark when clicked
- */
-export const CopyButton: React.FC<CopyButtonProps> = ({
-  text,
-  className = '',
-  size = '1',
-}) => {
-  const [copied, setCopied] = ReactHooks.useState(false)
-  const timeoutRef = ReactHooks.useRef<NodeJS.Timeout | null>(null)
-
-  const handleCopy = ReactHooks.useCallback(async (e: React.MouseEvent) => {
-    e.preventDefault()
-    e.stopPropagation()
-
-    try {
-      await navigator.clipboard.writeText(text)
-      setCopied(true)
-
-      // Clear any existing timeout
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current)
-      }
-
-      // Reset after 2 seconds
-      timeoutRef.current = setTimeout(() => {
-        setCopied(false)
-        timeoutRef.current = null
-      }, 2000)
-    } catch (err) {
-      console.error('Failed to copy text:', err)
-    }
-  }, [text])
-
-  // Cleanup timeout on unmount
-  ReactHooks.useEffect(() => {
-    return () => {
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current)
-      }
-    }
-  }, [])
-
-  return (
-    <Button
-      size={size}
-      variant='ghost'
-      className={`graphql-copy-button ${className}`}
-      onClick={handleCopy}
-      aria-label={copied ? 'Copied!' : 'Copy code'}
-      data-copied={copied}
-    >
-      {copied ? <CheckIcon width='16' height='16' /> : <CopyIcon width='16' height='16' />}
-    </Button>
-  )
-}