@kubb/plugin-cypress 5.0.0-beta.15 → 5.0.0-beta.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-cypress",
-  "version": "5.0.0-beta.15",
+  "version": "5.0.0-beta.25",
   "description": "Generate Cypress request commands and e2e test fixtures from your OpenAPI specification, enabling automated API testing with zero manual setup.",
   "keywords": [
     "code-generation",
@@ -47,16 +47,16 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.19",
-    "@kubb/renderer-jsx": "5.0.0-beta.19",
-    "@kubb/plugin-ts": "5.0.0-beta.15"
+    "@kubb/core": "5.0.0-beta.25",
+    "@kubb/renderer-jsx": "5.0.0-beta.25",
+    "@kubb/plugin-ts": "5.0.0-beta.25"
   },
   "devDependencies": {
     "@internals/shared": "0.0.0",
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.19"
+    "@kubb/renderer-jsx": "5.0.0-beta.25"
   },
   "size-limit": [
     {

package/src/components/Request.tsx

@@ -20,7 +20,7 @@ type Props = {
    * TypeScript resolver for resolving param/data/response type names
    */
   resolver: ResolverTs
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   dataReturnType: PluginCypress['resolvedOptions']['dataReturnType']
   paramsCasing: PluginCypress['resolvedOptions']['paramsCasing']
   paramsType: PluginCypress['resolvedOptions']['paramsType']
@@ -60,7 +60,7 @@ export function Request({ baseURL = '', name, dataReturnType, resolver, node, pa
     replacer: (param) => pathParamNameMap.get(camelCase(param)) ?? param,
   })
 
-  const requestOptions: string[] = [`method: '${node.method}'`, `url: ${urlTemplate}`]
+  const requestOptions: Array<string> = [`method: '${node.method}'`, `url: ${urlTemplate}`]
 
   const queryParams = getOperationParameters(node).query
   if (queryParams.length > 0) {

package/src/generators/cypressGenerator.tsx

@@ -5,11 +5,16 @@ 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) {
-    const { config, resolver, driver, root, inputNode } = ctx
+    const { config, resolver, driver, root } = ctx
     const { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType, group } = ctx.options
 
     const pluginTs = driver.getPlugin(pluginTsName)
@@ -24,13 +29,16 @@ export const cypressGenerator = defineGenerator<PluginCypress>({
 
     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 }),
+      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,
+          group: pluginTs.options?.group ?? undefined,
         },
       ),
     } as const
@@ -40,8 +48,8 @@ export const cypressGenerator = defineGenerator<PluginCypress>({
         baseName={meta.file.baseName}
         path={meta.file.path}
         meta={meta.file.meta}
-        banner={resolver.resolveBanner(inputNode, { output, config })}
-        footer={resolver.resolveFooter(inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config })}
       >
         {meta.fileTs && importedTypeNames.length > 0 && <File.Import name={importedTypeNames} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />}
         <Request

package/src/plugin.ts

@@ -6,24 +6,31 @@ import { resolverCypress } from './resolvers/resolverCypress.ts'
 import type { PluginCypress } from './types.ts'
 
 /**
- * Canonical plugin name for `@kubb/plugin-cypress`, used to identify the plugin
- * in driver lookups and warnings.
+ * Canonical plugin name for `@kubb/plugin-cypress`. Used for driver lookups and
+ * cross-plugin dependency references.
  */
 export const pluginCypressName = 'plugin-cypress' satisfies PluginCypress['name']
 
 /**
- * The `@kubb/plugin-cypress` plugin factory.
- *
- * Generates Cypress `cy.request()` test functions from an OpenAPI/AST `RootNode`.
- * Walks operations, delegates rendering to the active generators,
- * and writes barrel files based on `output.barrelType`.
+ * 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 pluginCypress from '@kubb/plugin-cypress'
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginCypress } from '@kubb/plugin-cypress'
  *
  * export default defineConfig({
- *   plugins: [pluginCypress({ output: { path: 'cypress' } })],
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginCypress({
+ *       output: { path: './cypress' },
+ *     }),
+ *   ],
  * })
  * ```
  */
@@ -56,7 +63,7 @@ export const pluginCypress = definePlugin<PluginCypress>((options) => {
               return `${camelCase(ctx.group)}Requests`
             },
       } satisfies Group)
-    : undefined
+    : null
 
   return {
     name: pluginCypressName,

package/src/resolvers/resolverCypress.ts

@@ -3,12 +3,16 @@ import { defineResolver } from '@kubb/core'
 import type { PluginCypress } from '../types.ts'
 
 /**
- * Naming convention resolver for Cypress plugin.
+ * 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`.
  *
- * Provides default naming helpers using camelCase for functions and file paths.
+ * @example Resolve a helper name
+ * ```ts
+ * import { resolverCypress } from '@kubb/plugin-cypress'
  *
- * @example
- * `resolverCypress.default('list pets', 'function')  // → 'listPets'`
+ * resolverCypress.default('list pets', 'function') // 'listPets'
+ * ```
  */
 export const resolverCypress = defineResolver<PluginCypress>(() => ({
   name: 'default',

package/src/types.ts

@@ -23,21 +23,23 @@ export type ResolverCypress = Resolver & {
 type ParamsTypeOptions =
   | {
       /**
-       * All parameters merged into a single destructured object.
+       * Every operation parameter is wrapped in a single destructured object argument.
        */
       paramsType: 'object'
       /**
-       * Not applicable when all parameters are merged into a single object.
+       * `pathParamsType` has no effect when `paramsType` is `'object'`.
        */
       pathParamsType?: never
     }
   | {
       /**
-       * Each parameter group emitted as a separate function argument.
+       * Each parameter group is emitted as a separate positional function argument.
        */
       paramsType?: 'inline'
       /**
-       * How path parameters are arranged: grouped in an object or spread 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'
        */
@@ -46,50 +48,56 @@ type ParamsTypeOptions =
 
 export type Options = {
   /**
-   * Specify the export location for the files and define the behavior of the output.
-   * @default { path: 'cypress', barrelType: 'named' }
+   * Where the generated Cypress helpers are written and how they are exported.
+   *
+   * @default { path: 'cypress', barrel: { type: 'named' } }
    */
   output?: Output
   /**
-   * Return type when calling cy.request: response data only or full response.
+   * 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'
   /**
-   * Apply casing to parameter names.
+   * 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 generated request URL.
+   * Base URL prepended to every request URL. When omitted, falls back to the
+   * adapter's server URL (typically `servers[0].url`).
    */
   baseURL?: string
   /**
-   * Group the Cypress requests based on the provided name.
+   * Split generated files into subfolders based on the operation's tag.
    */
   group?: Group
   /**
-   * Tags, operations, or paths to exclude from generation.
+   * Skip operations matching at least one entry in the list.
    */
   exclude?: Array<Exclude>
   /**
-   * Tags, operations, or paths to include in generation.
+   * Restrict generation to operations matching at least one entry in the list.
    */
   include?: Array<Include>
   /**
-   * Override options for specific tags, operations, or paths.
+   * Apply a different options object to operations matching a pattern.
    */
   override?: Array<Override<ResolvedOptions>>
   /**
-   * Override naming conventions for function names and types.
+   * Override how helper names and file paths are built.
    */
   resolver?: Partial<ResolverCypress> & ThisType<ResolverCypress>
   /**
-   * AST visitor to transform generated nodes.
+   * AST visitor applied to each operation node before printing.
    */
   transformer?: ast.Visitor
   /**
-   * Additional generators alongside the default generators.
+   * Custom generators that run alongside the built-in Cypress generators.
    */
   generators?: Array<Generator<PluginCypress>>
 } & ParamsTypeOptions
@@ -99,7 +107,7 @@ type ResolvedOptions = {
   exclude: Array<Exclude>
   include: Array<Include> | undefined
   override: Array<Override<ResolvedOptions>>
-  group: Group | undefined
+  group: Group | null
   baseURL: Options['baseURL'] | undefined
   dataReturnType: NonNullable<Options['dataReturnType']>
   pathParamsType: NonNullable<NonNullable<Options['pathParamsType']>>