@kubb/plugin-cypress 5.0.0-beta.42 → 5.0.0-beta.64

package/src/components/Request.tsx

@@ -1,113 +0,0 @@
-import { getOperationParameters } from '@internals/shared'
-import { camelCase, URLPath } from '@internals/utils'
-import { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginCypress } from '../types.ts'
-
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string
-  /**
-   * AST operation node
-   */
-  node: ast.OperationNode
-  /**
-   * TypeScript resolver for resolving param/data/response type names
-   */
-  resolver: ResolverTs
-  baseURL: string | null | undefined
-  dataReturnType: PluginCypress['resolvedOptions']['dataReturnType']
-  paramsCasing: PluginCypress['resolvedOptions']['paramsCasing']
-  paramsType: PluginCypress['resolvedOptions']['paramsType']
-  pathParamsType: PluginCypress['resolvedOptions']['pathParamsType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-export function Request({ baseURL = '', name, dataReturnType, resolver, node, paramsType, pathParamsType, paramsCasing }: Props): KubbReactNode {
-  if (!ast.isHttpOperationNode(node)) return null
-  const paramsNode = ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType,
-    paramsCasing,
-    resolver,
-    extraParams: [
-      ast.createFunctionParameter({
-        name: 'options',
-        type: ast.createParamsType({ variant: 'reference', name: 'Partial<Cypress.RequestOptions>' }),
-        default: '{}',
-      }),
-    ],
-  })
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  const responseType = resolver.resolveResponseName(node)
-  const returnType = dataReturnType === 'data' ? `Cypress.Chainable<${responseType}>` : `Cypress.Chainable<Cypress.Response<${responseType}>>`
-
-  const casedPathParams = getOperationParameters(node, { paramsCasing }).path
-  // Build a lookup keyed by camelCase-normalized name so that path-template names
-  // (e.g. `{pet_id}`) correctly resolve to the function-parameter name (`petId`)
-  // even when the OpenAPI spec has inconsistent casing between the two.
-  const pathParamNameMap = new Map(casedPathParams.map((p) => [camelCase(p.name), p.name]))
-
-  const urlPath = new URLPath(node.path, { casing: paramsCasing })
-  const urlTemplate = urlPath.toTemplateString({
-    prefix: baseURL,
-    replacer: (param) => pathParamNameMap.get(camelCase(param)) ?? param,
-  })
-
-  const requestOptions: Array<string> = [`method: '${node.method}'`, `url: ${urlTemplate}`]
-
-  const queryParams = getOperationParameters(node).query
-  if (queryParams.length > 0) {
-    const casedQueryParams = getOperationParameters(node, { paramsCasing }).query
-    // When paramsCasing renames query params (e.g. page_size → pageSize), we must remap
-    // the camelCase keys back to the original API names before passing them to `qs`.
-    const needsQsTransform = casedQueryParams.some((p, i) => p.name !== queryParams[i]!.name)
-    if (needsQsTransform) {
-      const pairs = queryParams.map((orig, i) => `${orig.name}: params.${casedQueryParams[i]!.name}`).join(', ')
-      requestOptions.push(`qs: params ? { ${pairs} } : undefined`)
-    } else {
-      requestOptions.push('qs: params')
-    }
-  }
-
-  const headerParams = getOperationParameters(node).header
-  if (headerParams.length > 0) {
-    const casedHeaderParams = getOperationParameters(node, { paramsCasing }).header
-    // When paramsCasing renames header params (e.g. x-api-key → xApiKey), we must remap
-    // the camelCase keys back to the original API names before passing them to `headers`.
-    const needsHeaderTransform = casedHeaderParams.some((p, i) => p.name !== headerParams[i]!.name)
-    if (needsHeaderTransform) {
-      const pairs = headerParams.map((orig, i) => `'${orig.name}': headers.${casedHeaderParams[i]!.name}`).join(', ')
-      requestOptions.push(`headers: headers ? { ${pairs} } : undefined`)
-    } else {
-      requestOptions.push('headers')
-    }
-  }
-
-  if (node.requestBody?.content?.[0]?.schema) {
-    requestOptions.push('body: data')
-  }
-
-  requestOptions.push('...options')
-
-  return (
-    <File.Source name={name} isIndexable isExportable>
-      <Function name={name} export params={paramsSignature} returnType={returnType}>
-        {dataReturnType === 'data'
-          ? `return cy.request<${responseType}>({
-  ${requestOptions.join(',\n  ')}
-}).then((res) => res.body)`
-          : `return cy.request<${responseType}>({
-  ${requestOptions.join(',\n  ')}
-})`}
-      </Function>
-    </File.Source>
-  )
-}

package/src/generators/cypressGenerator.tsx

@@ -1,69 +0,0 @@
-import { resolveOperationTypeNames } from '@internals/shared'
-import { ast, defineGenerator } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { File, jsxRendererSync } from '@kubb/renderer-jsx'
-import { Request } from '../components/Request.tsx'
-import type { PluginCypress } from '../types.ts'
-
-/**
- * Built-in generator for `@kubb/plugin-cypress`. Emits one typed
- * `cy.request()` wrapper per OpenAPI operation, ready to call inside Cypress
- * test specs and custom commands.
- */
-export const cypressGenerator = defineGenerator<PluginCypress>({
-  name: 'cypress',
-  renderer: jsxRendererSync,
-  operation(node, ctx) {
-    if (!ast.isHttpOperationNode(node)) return null
-    const { config, resolver, driver, root } = ctx
-    const { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType, group } = ctx.options
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-
-    if (!pluginTs) {
-      return null
-    }
-
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing })
-
-    const meta = {
-      name: resolver.resolveName(node.operationId),
-      file: resolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        { root, output, group: group ?? undefined },
-      ),
-      fileTs: tsResolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        {
-          root,
-          output: pluginTs.options?.output ?? output,
-          group: pluginTs.options?.group ?? undefined,
-        },
-      ),
-    } as const
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-      >
-        {meta.fileTs && importedTypeNames.length > 0 && <File.Import name={importedTypeNames} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />}
-        <Request
-          name={meta.name}
-          node={node}
-          resolver={tsResolver}
-          dataReturnType={dataReturnType}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          pathParamsType={pathParamsType}
-          baseURL={baseURL}
-        />
-      </File>
-    )
-  },
-})

package/src/index.ts

@@ -1,9 +0,0 @@
-export { Request } from './components/Request.tsx'
-
-export { cypressGenerator } from './generators/cypressGenerator.tsx'
-
-export { default, pluginCypress, pluginCypressName } from './plugin.ts'
-
-export { resolverCypress } from './resolvers/resolverCypress.ts'
-
-export type { PluginCypress, ResolverCypress } from './types.ts'

package/src/plugin.ts

@@ -1,90 +0,0 @@
-import { createGroupConfig } from '@internals/shared'
-import { definePlugin } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { cypressGenerator } from './generators/cypressGenerator.tsx'
-import { resolverCypress } from './resolvers/resolverCypress.ts'
-import type { PluginCypress } from './types.ts'
-
-/**
- * Canonical plugin name for `@kubb/plugin-cypress`. Used for driver lookups and
- * cross-plugin dependency references.
- */
-export const pluginCypressName = 'plugin-cypress' satisfies PluginCypress['name']
-
-/**
- * Generates one typed `cy.request()` wrapper per OpenAPI operation. Each helper
- * has typed path params, body, query, and a typed response, so failing API
- * calls in Cypress show up at compile time instead of inside the test runner.
- *
- * @example
- * ```ts
- * import { defineConfig } from 'kubb'
- * import { pluginTs } from '@kubb/plugin-ts'
- * import { pluginCypress } from '@kubb/plugin-cypress'
- *
- * export default defineConfig({
- *   input: { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   plugins: [
- *     pluginTs(),
- *     pluginCypress({
- *       output: { path: './cypress' },
- *     }),
- *   ],
- * })
- * ```
- */
-export const pluginCypress = definePlugin<PluginCypress>((options) => {
-  const {
-    output = { path: 'cypress', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    dataReturnType = 'data',
-    baseURL,
-    paramsCasing,
-    paramsType = 'inline',
-    pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  const groupConfig = createGroupConfig(group, { suffix: 'Requests' })
-
-  return {
-    name: pluginCypressName,
-    options,
-    dependencies: [pluginTsName],
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        const resolver = userResolver ? { ...resolverCypress, ...userResolver } : resolverCypress
-
-        ctx.setOptions({
-          output,
-          exclude,
-          include,
-          override,
-          dataReturnType,
-          group: groupConfig,
-          baseURL,
-          paramsCasing,
-          paramsType,
-          pathParamsType,
-          resolver,
-        })
-        ctx.setResolver(resolver)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-        ctx.addGenerator(cypressGenerator)
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-      },
-    },
-  }
-})
-
-export default pluginCypress

package/src/resolvers/resolverCypress.ts

@@ -1,29 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginCypress } from '../types.ts'
-
-/**
- * Default resolver used by `@kubb/plugin-cypress`. Decides the names and file
- * paths for every generated `cy.request()` wrapper. Functions and files use
- * camelCase, matching the convention from `@kubb/plugin-client`.
- *
- * @example Resolve a helper name
- * ```ts
- * import { resolverCypress } from '@kubb/plugin-cypress'
- *
- * resolverCypress.default('list pets', 'function') // 'listPets'
- * ```
- */
-export const resolverCypress = defineResolver<PluginCypress>(() => ({
-  name: 'default',
-  pluginName: 'plugin-cypress',
-  default(name, type) {
-    return camelCase(name, { isFile: type === 'file' })
-  },
-  resolveName(name) {
-    return this.default(name, 'function')
-  },
-  resolvePathName(name, type) {
-    return this.default(name, type)
-  },
-}))

package/src/types.ts

@@ -1,127 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
-
-/**
- * Resolver for Cypress that provides naming methods for test functions.
- */
-export type ResolverCypress = Resolver & {
-  /**
-   * Resolves the function name for an operation.
-   *
-   * @example Resolving function names
-   * `resolver.resolveName('show pet by id') // -> 'showPetById'`
-   */
-  resolveName(this: ResolverCypress, name: string): string
-  /**
-   * Resolves the output file name for a Cypress request module.
-   */
-  resolvePathName(this: ResolverCypress, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-}
-
-/**
- * Parameter handling mode that determines how path params and query/body params are arranged in function signatures.
- */
-type ParamsTypeOptions =
-  | {
-      /**
-       * Every operation parameter is wrapped in a single destructured object argument.
-       */
-      paramsType: 'object'
-      /**
-       * `pathParamsType` has no effect when `paramsType` is `'object'`.
-       */
-      pathParamsType?: never
-    }
-  | {
-      /**
-       * Each parameter group is emitted as a separate positional function argument.
-       */
-      paramsType?: 'inline'
-      /**
-       * How URL path parameters are arranged inside the inline argument list.
-       * - `'object'` groups them into one destructured object.
-       * - `'inline'` emits each path param as its own argument.
-       *
-       * @default 'inline'
-       */
-      pathParamsType?: 'object' | 'inline'
-    }
-
-export type Options = {
-  /**
-   * Where the generated Cypress helpers are written and how they are exported.
-   *
-   * @default { path: 'cypress', barrel: { type: 'named' } }
-   */
-  output?: Output
-  /**
-   * Shape of the value returned from each helper.
-   * - `'data'` — only the response body.
-   * - `'full'` — the full Cypress response object (headers, status, body).
-   *
-   * @default 'data'
-   */
-  dataReturnType?: 'data' | 'full'
-  /**
-   * Rename parameter properties in the generated helpers (path, query, headers).
-   *
-   * @note Must match the value of `paramsCasing` on `@kubb/plugin-ts`.
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * Base URL prepended to every request URL. When omitted, falls back to the
-   * adapter's server URL (typically `servers[0].url`).
-   */
-  baseURL?: string
-  /**
-   * Split generated files into subfolders based on the operation's tag.
-   */
-  group?: Group
-  /**
-   * Skip operations matching at least one entry in the list.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Restrict generation to operations matching at least one entry in the list.
-   */
-  include?: Array<Include>
-  /**
-   * Apply a different options object to operations matching a pattern.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Override how helper names and file paths are built.
-   */
-  resolver?: Partial<ResolverCypress> & ThisType<ResolverCypress>
-  /**
-   * AST visitor applied to each operation node before printing.
-   */
-  transformer?: ast.Visitor
-  /**
-   * Custom generators that run alongside the built-in Cypress generators.
-   */
-  generators?: Array<Generator<PluginCypress>>
-} & ParamsTypeOptions
-
-type ResolvedOptions = {
-  output: Output
-  exclude: Array<Exclude>
-  include: Array<Include> | undefined
-  override: Array<Override<ResolvedOptions>>
-  group: Group | null
-  baseURL: Options['baseURL'] | undefined
-  dataReturnType: NonNullable<Options['dataReturnType']>
-  pathParamsType: NonNullable<NonNullable<Options['pathParamsType']>>
-  paramsType: NonNullable<Options['paramsType']>
-  paramsCasing: Options['paramsCasing']
-  resolver: ResolverCypress
-}
-
-export type PluginCypress = PluginFactoryOptions<'plugin-cypress', Options, ResolvedOptions, ResolverCypress>
-
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-cypress': PluginCypress
-    }
-  }
-}