@kubb/plugin-cypress 5.0.0-alpha.9 → 5.0.0-beta.100

package/src/components/Request.tsx

@@ -1,147 +0,0 @@
-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 type { FabricReactNode } from '@kubb/react-fabric/types'
-import type { PluginCypress } from '../types.ts'
-
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string
-  typeSchemas: OperationSchemas
-  url: string
-  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: '{}',
-    },
-  })
-}
-
-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 returnType =
-    dataReturnType === 'data' ? `Cypress.Chainable<${typeSchemas.response.name}>` : `Cypress.Chainable<Cypress.Response<${typeSchemas.response.name}>>`
-
-  // 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}`]
-
-  // Add query params if they exist
-  if (typeSchemas.queryParams?.name) {
-    requestOptions.push('qs: params')
-  }
-
-  // Add headers if they exist
-  if (typeSchemas.headerParams?.name) {
-    requestOptions.push('headers')
-  }
-
-  // Add body if request schema exists
-  if (typeSchemas.request?.name) {
-    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}>
-        {dataReturnType === 'data'
-          ? `return cy.request<${typeSchemas.response.name}>({
-  ${requestOptions.join(',\n  ')}
-}).then((res) => res.body)`
-          : `return cy.request<${typeSchemas.response.name}>({
-  ${requestOptions.join(',\n  ')}
-})`}
-      </Function>
-    </File.Source>
-  )
-}
-
-Request.getParams = getParams

package/src/components/index.ts

@@ -1 +0,0 @@
-export { Request } from './Request.tsx'

package/src/generators/cypressGenerator.tsx

@@ -1,66 +0,0 @@
-import { usePluginDriver } 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 { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
-import { Request } from '../components'
-import type { PluginCypress } from '../types'
-
-export const cypressGenerator = createReactGenerator<PluginCypress>({
-  name: 'cypress',
-  Operation({ operation, generator, plugin }) {
-    const {
-      options: { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType },
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
-
-    const request = {
-      name: getName(operation, { type: 'function' }),
-      file: getFile(operation),
-    }
-
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-    }
-
-    return (
-      <File
-        baseName={request.file.baseName}
-        path={request.file.path}
-        meta={request.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
-      >
-        <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
-        />
-        <Request
-          name={request.name}
-          dataReturnType={dataReturnType}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          pathParamsType={pathParamsType}
-          typeSchemas={type.schemas}
-          method={operation.method}
-          baseURL={baseURL}
-          url={operation.path}
-        />
-      </File>
-    )
-  },
-})

package/src/generators/index.ts

@@ -1 +0,0 @@
-export { cypressGenerator } from './cypressGenerator.tsx'

package/src/index.ts

@@ -1,2 +0,0 @@
-export { pluginCypress, pluginCypressName } from './plugin.ts'
-export type { PluginCypress } from './types.ts'

package/src/plugin.ts

@@ -1,119 +0,0 @@
-import path from 'node:path'
-import { camelCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode } from '@kubb/core'
-import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { cypressGenerator } from './generators'
-import type { PluginCypress } from './types.ts'
-
-export const pluginCypressName = 'plugin-cypress' satisfies PluginCypress['name']
-
-export const pluginCypress = createPlugin<PluginCypress>((options) => {
-  const {
-    output = { path: 'cypress', barrelType: 'named' },
-    group,
-    dataReturnType = 'data',
-    exclude = [],
-    include,
-    override = [],
-    transformers = {},
-    generators = [cypressGenerator].filter(Boolean),
-    contentType,
-    baseURL,
-    paramsCasing,
-    paramsType = 'inline',
-    pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
-  } = options
-
-  return {
-    name: pluginCypressName,
-    options: {
-      output,
-      dataReturnType,
-      group,
-      baseURL,
-
-      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)
-      }
-
-      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)
-    },
-    resolveName(name, type) {
-      const resolvedName = camelCase(name, {
-        isFile: type === 'file',
-      })
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
-      }
-
-      return resolvedName
-    },
-    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,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        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)
-    },
-  }
-})

package/src/types.ts

@@ -1,83 +0,0 @@
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-
-import type { contentType, Oas } from '@kubb/oas'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { Generator } from '@kubb/plugin-oas/generators'
-
-export type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'cypress', barrelType: 'named' }
-   */
-  output?: Output<Oas>
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType
-  /**
-   * Return type when calling cy.request.
-   * - 'data' returns ResponseConfig[data].
-   * - 'full' returns ResponseConfig.
-   * @default 'data'
-   */
-  dataReturnType?: 'data' | 'full'
-  /**
-   * How to style your params, by default no casing is applied
-   * - 'camelcase' uses camelcase for the params names
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * How to pass your params.
-   * - 'object' returns the params and pathParams as an object.
-   * - 'inline' returns the params as comma separated params.
-   * @default 'inline'
-   */
-  paramsType?: 'object' | 'inline'
-  /**
-   * How to pass your pathParams.
-   * - 'object' returns the pathParams as an object.
-   * - 'inline' returns the pathParams as comma separated params.
-   * @default 'inline'
-   */
-  pathParamsType?: 'object' | 'inline'
-  baseURL?: string
-  /**
-   * Group the Cypress requests based on the provided name.
-   */
-  group?: Group
-  /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Array containing include parameters to include tags/operations/methods/paths.
-   */
-  include?: Array<Include>
-  /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
-  }
-  /**
-   * Define some generators next to the Cypress generators.
-   */
-  generators?: Array<Generator<PluginCypress>>
-}
-
-type ResolvedOptions = {
-  output: Output<Oas>
-  group: Options['group']
-  baseURL: Options['baseURL'] | undefined
-  dataReturnType: NonNullable<Options['dataReturnType']>
-  pathParamsType: NonNullable<Options['pathParamsType']>
-  paramsType: NonNullable<Options['paramsType']>
-  paramsCasing: Options['paramsCasing']
-}
-
-export type PluginCypress = PluginFactoryOptions<'plugin-cypress', Options, ResolvedOptions, never, ResolvePathOptions>