@kubb/plugin-cypress 5.0.0-alpha.3 → 5.0.0-alpha.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-cypress",
-  "version": "5.0.0-alpha.3",
+  "version": "5.0.0-alpha.31",
   "description": "Cypress test generator plugin for Kubb, creating end-to-end tests from OpenAPI specifications for automated API testing.",
   "keywords": [
     "cypress",
@@ -34,33 +34,10 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./components": {
-      "import": "./dist/components.js",
-      "require": "./dist/components.cjs"
-    },
-    "./generators": {
-      "import": "./dist/generators.js",
-      "require": "./dist/generators.cjs"
-    },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "utils": [
-        "./dist/utils.d.ts"
-      ],
-      "hooks": [
-        "./dist/hooks.d.ts"
-      ],
-      "components": [
-        "./dist/components.d.ts"
-      ],
-      "generators": [
-        "./dist/generators.d.ts"
-      ]
-    }
-  },
+  "typesVersions": {},
   "files": [
     "src",
     "dist",
@@ -76,11 +53,10 @@
     }
   ],
   "dependencies": {
-    "@kubb/react-fabric": "0.13.3",
-    "@kubb/core": "5.0.0-alpha.3",
-    "@kubb/oas": "5.0.0-alpha.3",
-    "@kubb/plugin-oas": "5.0.0-alpha.3",
-    "@kubb/plugin-ts": "5.0.0-alpha.3"
+    "@kubb/react-fabric": "0.15.1",
+    "@kubb/ast": "5.0.0-alpha.31",
+    "@kubb/plugin-ts": "5.0.0-alpha.31",
+    "@kubb/core": "5.0.0-alpha.31"
   },
   "engines": {
     "node": ">=22"

package/src/components/Request.tsx

@@ -1,8 +1,9 @@
-import { URLPath } from '@internals/utils'
-import { type HttpMethod, isAllOptional, isOptional } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
+import { camelCase, URLPath } from '@internals/utils'
+import { caseParams, createFunctionParameter, createOperationParams, createTypeNode } from '@kubb/ast'
+import type { OperationNode } from '@kubb/ast/types'
+import type { ResolverTs } from '@kubb/plugin-ts'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function } from '@kubb/react-fabric'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
 import type { PluginCypress } from '../types.ts'
 
@@ -11,137 +12,100 @@ type Props = {
    * Name of the function
    */
   name: string
-  typeSchemas: OperationSchemas
-  url: string
+  /**
+   * AST operation node
+   */
+  node: OperationNode
+  /**
+   * TypeScript resolver for resolving param/data/response type names
+   */
+  resolver: ResolverTs
   baseURL: string | undefined
   dataReturnType: PluginCypress['resolvedOptions']['dataReturnType']
   paramsCasing: PluginCypress['resolvedOptions']['paramsCasing']
   paramsType: PluginCypress['resolvedOptions']['paramsType']
   pathParamsType: PluginCypress['resolvedOptions']['pathParamsType']
-  method: HttpMethod
-}
-
-type GetParamsProps = {
-  paramsCasing: PluginCypress['resolvedOptions']['paramsCasing']
-  paramsType: PluginCypress['resolvedOptions']['paramsType']
-  pathParamsType: PluginCypress['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
 }
 
-function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }: GetParamsProps) {
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing })
-
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children: {
-          ...pathParams,
-          data: typeSchemas.request?.name
-            ? {
-                type: typeSchemas.request?.name,
-                optional: isOptional(typeSchemas.request?.schema),
-              }
-            : undefined,
-          params: typeSchemas.queryParams?.name
-            ? {
-                type: typeSchemas.queryParams?.name,
-                optional: isOptional(typeSchemas.queryParams?.schema),
-              }
-            : undefined,
-          headers: typeSchemas.headerParams?.name
-            ? {
-                type: typeSchemas.headerParams?.name,
-                optional: isOptional(typeSchemas.headerParams?.schema),
-              }
-            : undefined,
-        },
-      },
-      options: {
-        type: 'Partial<Cypress.RequestOptions>',
-        default: '{}',
-      },
-    })
-  }
-
-  return FunctionParams.factory({
-    pathParams: typeSchemas.pathParams?.name
-      ? {
-          mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-          children: getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-          default: isAllOptional(typeSchemas.pathParams?.schema) ? '{}' : undefined,
-        }
-      : undefined,
-    data: typeSchemas.request?.name
-      ? {
-          type: typeSchemas.request?.name,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-    options: {
-      type: 'Partial<Cypress.RequestOptions>',
-      default: '{}',
-    },
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+
+export function Request({ baseURL = '', name, dataReturnType, resolver, node, paramsType, pathParamsType, paramsCasing }: Props): FabricReactNode {
+  const paramsNode = createOperationParams(node, {
+    paramsType,
+    pathParamsType,
+    paramsCasing,
+    resolver,
+    extraParams: [
+      createFunctionParameter({ name: 'options', type: createTypeNode({ variant: 'reference', name: 'Partial<Cypress.RequestOptions>' }), default: '{}' }),
+    ],
   })
-}
-
-export function Request({ baseURL = '', name, dataReturnType, typeSchemas, url, method, paramsType, paramsCasing, pathParamsType }: Props): FabricReactNode {
-  const path = new URLPath(url, { casing: paramsCasing })
-
-  const params = getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
-  const returnType =
-    dataReturnType === 'data' ? `Cypress.Chainable<${typeSchemas.response.name}>` : `Cypress.Chainable<Cypress.Response<${typeSchemas.response.name}>>`
+  const responseType = resolver.resolveResponseName(node)
+  const returnType = dataReturnType === 'data' ? `Cypress.Chainable<${responseType}>` : `Cypress.Chainable<Cypress.Response<${responseType}>>`
 
-  // Build the URL template string - this will convert /pets/:petId to /pets/${petId}
-  const urlTemplate = path.toTemplateString({ prefix: baseURL })
-
-  // Build request options object
-  const requestOptions: string[] = [`method: '${method}'`, `url: ${urlTemplate}`]
+  const casedPathParams = caseParams(
+    node.parameters.filter((p) => p.in === 'path'),
+    paramsCasing,
+  )
+  // 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,
+  })
 
-  // Add query params if they exist
-  if (typeSchemas.queryParams?.name) {
-    requestOptions.push('qs: params')
+  const requestOptions: string[] = [`method: '${node.method}'`, `url: ${urlTemplate}`]
+
+  const queryParams = node.parameters.filter((p) => p.in === 'query')
+  if (queryParams.length > 0) {
+    const casedQueryParams = caseParams(queryParams, paramsCasing)
+    // 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')
+    }
   }
 
-  // Add headers if they exist
-  if (typeSchemas.headerParams?.name) {
-    requestOptions.push('headers')
+  const headerParams = node.parameters.filter((p) => p.in === 'header')
+  if (headerParams.length > 0) {
+    const casedHeaderParams = caseParams(headerParams, paramsCasing)
+    // 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')
+    }
   }
 
-  // Add body if request schema exists
-  if (typeSchemas.request?.name) {
+  if (node.requestBody?.schema) {
     requestOptions.push('body: data')
   }
 
-  // Spread additional Cypress options
   requestOptions.push('...options')
 
   return (
     <File.Source name={name} isIndexable isExportable>
-      <Function name={name} export params={params.toConstructor()} returnType={returnType}>
+      <Function name={name} export params={paramsSignature} returnType={returnType}>
         {dataReturnType === 'data'
-          ? `return cy.request<${typeSchemas.response.name}>({
+          ? `return cy.request<${responseType}>({
   ${requestOptions.join(',\n  ')}
 }).then((res) => res.body)`
-          : `return cy.request<${typeSchemas.response.name}>({
+          : `return cy.request<${responseType}>({
   ${requestOptions.join(',\n  ')}
 })`}
       </Function>
     </File.Source>
   )
 }
-
-Request.getParams = getParams

package/src/generators/cypressGenerator.tsx

@@ -1,64 +1,69 @@
-import { usePluginManager } from '@kubb/core/hooks'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
+import { caseParams } from '@kubb/ast'
+import { defineGenerator } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { File } from '@kubb/react-fabric'
-import { Request } from '../components'
-import type { PluginCypress } from '../types'
+import { Request } from '../components/Request.tsx'
+import type { PluginCypress } from '../types.ts'
 
-export const cypressGenerator = createReactGenerator<PluginCypress>({
+export const cypressGenerator = defineGenerator<PluginCypress>({
   name: 'cypress',
-  Operation({ operation, generator, plugin }) {
-    const {
-      options: { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType },
-    } = plugin
-    const pluginManager = usePluginManager()
+  operation(node, options) {
+    const { adapter, config, resolver, driver, root } = this
+    const { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType, group } = options
 
-    const oas = useOas()
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
+    const pluginTs = driver.getPlugin(pluginTsName)
 
-    const request = {
-      name: getName(operation, { type: 'function' }),
-      file: getFile(operation),
+    if (!pluginTs?.resolver) {
+      return null
     }
 
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-    }
+    const casedParams = caseParams(node.parameters, paramsCasing)
+
+    const pathParams = casedParams.filter((p) => p.in === 'path')
+    const queryParams = casedParams.filter((p) => p.in === 'query')
+    const headerParams = casedParams.filter((p) => p.in === 'header')
+
+    const importedTypeNames = [
+      ...pathParams.map((p) => pluginTs.resolver.resolvePathParamsName(node, p)),
+      ...queryParams.map((p) => pluginTs.resolver.resolveQueryParamsName(node, p)),
+      ...headerParams.map((p) => pluginTs.resolver.resolveHeaderParamsName(node, p)),
+      node.requestBody?.schema ? pluginTs.resolver.resolveDataName(node) : undefined,
+      pluginTs.resolver.resolveResponseName(node),
+    ].filter(Boolean)
+
+    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 }),
+      fileTs: pluginTs.resolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        {
+          root,
+          output: pluginTs.options?.output ?? output,
+          group: pluginTs.options?.group,
+        },
+      ),
+    } as const
 
     return (
       <File
-        baseName={request.file.baseName}
-        path={request.file.path}
-        meta={request.file.meta}
-        banner={getBanner({ oas, output, config: pluginManager.config })}
-        footer={getFooter({ oas, output })}
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
       >
-        <File.Import
-          name={[
-            type.schemas.request?.name,
-            type.schemas.response.name,
-            type.schemas.pathParams?.name,
-            type.schemas.queryParams?.name,
-            type.schemas.headerParams?.name,
-            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
-          ].filter(Boolean)}
-          root={request.file.path}
-          path={type.file.path}
-          isTypeOnly
-        />
+        {meta.fileTs && importedTypeNames.length > 0 && (
+          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
+        )}
         <Request
-          name={request.name}
+          name={meta.name}
+          node={node}
+          resolver={pluginTs.resolver}
           dataReturnType={dataReturnType}
           paramsCasing={paramsCasing}
           paramsType={paramsType}
           pathParamsType={pathParamsType}
-          typeSchemas={type.schemas}
-          method={operation.method}
           baseURL={baseURL}
-          url={operation.path}
         />
       </File>
     )

package/src/index.ts

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

package/src/plugin.ts

@@ -1,119 +1,109 @@
-import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { definePlugin, type Group, getBarrelFiles, getMode } from '@kubb/core'
-import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
+import { createPlugin, type Group, getPreset, mergeGenerators } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
-import { cypressGenerator } from './generators'
+import { version } from '../package.json'
+import { presets } from './presets.ts'
 import type { PluginCypress } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-cypress`, used to identify the plugin
+ * in driver lookups and warnings.
+ */
 export const pluginCypressName = 'plugin-cypress' satisfies PluginCypress['name']
 
-export const pluginCypress = definePlugin<PluginCypress>((options) => {
+/**
+ * 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`.
+ *
+ * @example
+ * ```ts
+ * import { pluginCypress } from '@kubb/plugin-cypress'
+ *
+ * export default defineConfig({
+ *   plugins: [pluginCypress({ output: { path: 'cypress' } })],
+ * })
+ * ```
+ */
+export const pluginCypress = createPlugin<PluginCypress>((options) => {
   const {
     output = { path: 'cypress', barrelType: 'named' },
     group,
-    dataReturnType = 'data',
     exclude = [],
     include,
     override = [],
-    transformers = {},
-    generators = [cypressGenerator].filter(Boolean),
-    contentType,
+    dataReturnType = 'data',
     baseURL,
     paramsCasing,
     paramsType = 'inline',
     pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
+    compatibilityPreset = 'default',
+    resolver: userResolver,
+    transformer: userTransformer,
+    generators: userGenerators = [],
   } = options
 
-  return {
-    name: pluginCypressName,
-    options: {
-      output,
-      dataReturnType,
-      group,
-      baseURL,
+  const preset = getPreset({
+    preset: compatibilityPreset,
+    presets,
+    resolver: userResolver,
+    transformer: userTransformer,
+    generators: userGenerators,
+  })
 
-      paramsCasing,
-      paramsType,
-      pathParamsType,
-    },
-    pre: [pluginOasName, pluginTsName].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? getMode(path.resolve(root, output.path))
-
-      if (mode === 'single') {
-        /**
-         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
-         */
-        return path.resolve(root, output.path)
-      }
+  const generators = preset.generators ?? []
+  const mergedGenerator = mergeGenerators(generators)
 
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: Group['name'] = group?.name
-          ? group.name
-          : (ctx) => {
-              if (group?.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-              return `${camelCase(ctx.group)}Requests`
-            }
-
-        return path.resolve(
-          root,
-          output.path,
-          groupName({
-            group: group.type === 'path' ? options.group.path! : options.group.tag!,
-          }),
-          baseName,
-        )
-      }
-
-      return path.resolve(root, output.path, baseName)
+  return {
+    name: pluginCypressName,
+    version,
+    get resolver() {
+      return preset.resolver
     },
-    resolveName(name, type) {
-      const resolvedName = camelCase(name, {
-        isFile: type === 'file',
-      })
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
-      }
-
-      return resolvedName
+    get transformer() {
+      return preset.transformer
     },
-    async install() {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = getMode(path.resolve(root, output.path))
-      const oas = await this.getOas()
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        pluginManager: this.pluginManager,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
+    get options() {
+      return {
+        output,
         exclude,
         include,
         override,
-        mode,
-      })
-
-      const files = await operationGenerator.build(...generators)
-      await this.upsertFile(...files)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
+        dataReturnType,
+        group: group
+          ? ({
+              ...group,
+              name: group.name
+                ? group.name
+                : (ctx: { group: string }) => {
+                    if (group.type === 'path') {
+                      return `${ctx.group.split('/')[1]}`
+                    }
+                    return `${camelCase(ctx.group)}Requests`
+                  },
+            } satisfies Group)
+          : undefined,
+        baseURL,
+        paramsCasing,
+        paramsType,
+        pathParamsType,
+        resolver: preset.resolver,
+      }
+    },
+    pre: [pluginTsName].filter(Boolean),
+    async schema(node, options) {
+      return mergedGenerator.schema?.call(this, node, options)
+    },
+    async operation(node, options) {
+      return mergedGenerator.operation?.call(this, node, options)
+    },
+    async operations(nodes, options) {
+      return mergedGenerator.operations?.call(this, nodes, options)
+    },
+    async buildStart() {
+      await this.openInStudio({ ast: true })
     },
   }
 })

package/src/presets.ts

@@ -0,0 +1,23 @@
+import { definePresets } from '@kubb/core'
+import { cypressGenerator } from './generators/cypressGenerator.tsx'
+import { resolverCypress } from './resolvers/resolverCypress.ts'
+import type { ResolverCypress } from './types.ts'
+
+/**
+ * Built-in preset registry for `@kubb/plugin-cypress`.
+ *
+ * - `default` — uses `resolverCypress` and `cypressGenerator`.
+ * - `kubbV4`  — uses `resolverCypress` and `cypressGenerator`.
+ */
+export const presets = definePresets<ResolverCypress>({
+  default: {
+    name: 'default',
+    resolver: resolverCypress,
+    generators: [cypressGenerator],
+  },
+  kubbV4: {
+    name: 'kubbV4',
+    resolver: resolverCypress,
+    generators: [cypressGenerator],
+  },
+})

package/src/resolvers/resolverCypress.ts

@@ -0,0 +1,26 @@
+import { camelCase } from '@internals/utils'
+import { defineResolver } from '@kubb/core'
+import type { PluginCypress } from '../types.ts'
+
+/**
+ * Resolver for `@kubb/plugin-cypress` that provides the default naming
+ * and path-resolution helpers used by the plugin.
+ *
+ * @example
+ * ```ts
+ * import { resolverCypress } from '@kubb/plugin-cypress'
+ *
+ * resolverCypress.default('list pets', 'function') // -> 'listPets'
+ * resolverCypress.resolveName('show pet by id')    // -> 'showPetById'
+ * ```
+ */
+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')
+  },
+}))