@kubb/plugin-ts 5.0.0-beta.56 → 5.0.0-beta.73

package/src/generators/typeGenerator.tsx

@@ -1,274 +0,0 @@
-import { resolveContentTypeVariants } from '@internals/shared'
-import { ast, defineGenerator } from '@kubb/core'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
-import { Type } from '../components/Type.tsx'
-import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
-import { printerTs } from '../printers/printerTs.ts'
-import type { PluginTs } from '../types'
-import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
-
-/**
- * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per
- * schema in the spec plus per-operation request, response, and parameter
- * types. Drop-replace with a custom `Generator<PluginTs>` to change how
- * TypeScript output is produced.
- */
-export const typeGenerator = defineGenerator<PluginTs>({
-  name: 'typescript',
-  renderer: jsxRenderer,
-  schema(node, ctx) {
-    const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options
-    const { adapter, config, resolver, root } = ctx
-
-    if (!node.name) {
-      return
-    }
-    // Build a set of schema names that are enums so the ref handler and getImports
-    // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
-    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)
-
-    function resolveImportName(schemaName: string): string {
-      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) {
-        return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix)
-      }
-      return resolver.resolveTypeName(schemaName)
-    }
-
-    const imports = adapter.getImports(node, (schemaName) => ({
-      name: resolveImportName(schemaName),
-      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
-    }))
-
-    const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum)
-
-    const meta = {
-      name:
-        ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && isEnumSchema
-          ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix)
-          : resolver.resolveTypeName(node.name),
-      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group: group ?? undefined }),
-    } as const
-
-    const schemaPrinter = printerTs({
-      optionalType,
-      arrayType,
-      enum: enumOptions,
-      name: meta.name,
-      syntaxType,
-      description: node.description,
-      resolver,
-      enumSchemaNames,
-      nodes: printer?.nodes,
-    })
-
-    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 } })}
-      >
-        {imports.map((imp) => (
-          <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
-        ))}
-        <Type name={meta.name} node={node} enum={enumOptions} resolver={resolver} printer={schemaPrinter} />
-      </File>
-    )
-  },
-  operation(node, ctx) {
-    const { enum: enumOptions, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options
-    const { adapter, config, resolver, root } = ctx
-
-    const params = ast.caseParams(node.parameters, paramsCasing)
-
-    const meta = {
-      file: resolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        { root, output, group: group ?? undefined },
-      ),
-    } as const
-
-    // Build a set of schema names that are enums so the ref handler and getImports
-    // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
-    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)
-
-    function resolveImportName(schemaName: string): string {
-      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) {
-        return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix)
-      }
-      return resolver.resolveTypeName(schemaName)
-    }
-
-    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> | null }) {
-      if (!schema) return null
-
-      const imports = adapter.getImports(schema, (schemaName) => ({
-        name: resolveImportName(schemaName),
-        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
-      }))
-
-      const schemaPrinter = printerTs({
-        optionalType,
-        arrayType,
-        enum: enumOptions,
-        name,
-        syntaxType,
-        description: schema.description,
-        keysToOmit,
-        resolver,
-        enumSchemaNames,
-        nodes: printer?.nodes,
-      })
-
-      return (
-        <>
-          {imports.map((imp) => (
-            <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
-          ))}
-          <Type name={name} node={schema} enum={enumOptions} resolver={resolver} printer={schemaPrinter} />
-        </>
-      )
-    }
-
-    /**
-     * Emits an individual type per content type plus a union alias under `baseName`.
-     * Shared by the request body and multi-content-type responses.
-     */
-    function buildContentTypeVariants(
-      entries: Array<{ contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }>,
-      baseName: string,
-      decorate?: (schema: ast.SchemaNode) => ast.SchemaNode,
-    ) {
-      const variants = resolveContentTypeVariants(entries, baseName)
-      const unionSchema = ast.createSchema({
-        type: 'union',
-        members: variants.map((variant) => ast.createSchema({ type: 'ref', name: variant.name })),
-      })
-      return (
-        <>
-          {variants.map((variant) =>
-            renderSchemaType({
-              schema: decorate ? decorate(variant.schema) : variant.schema,
-              name: variant.name,
-              keysToOmit: variant.keysToOmit,
-            }),
-          )}
-          {renderSchemaType({ schema: unionSchema, name: baseName })}
-        </>
-      )
-    }
-
-    const paramTypes = params.map((param) =>
-      renderSchemaType({
-        schema: param.schema,
-        name: resolver.resolveParamName(node, param),
-      }),
-    )
-
-    const requestBodyContent = node.requestBody?.content ?? []
-
-    function buildRequestType() {
-      if (requestBodyContent.length === 0) return null
-      if (requestBodyContent.length === 1) {
-        const entry = requestBodyContent[0]!
-        if (!entry.schema) return null
-        return renderSchemaType({
-          schema: {
-            ...entry.schema,
-            description: node.requestBody!.description ?? entry.schema.description,
-          },
-          name: resolver.resolveDataName(node),
-          keysToOmit: entry.keysToOmit,
-        })
-      }
-      // Multiple content types — generate individual types + union alias
-      return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
-        ...schema,
-        description: node.requestBody!.description ?? schema.description,
-      }))
-    }
-
-    const requestType = buildRequestType()
-
-    const responseTypes = node.responses.map((res) => {
-      const variants = (res.content ?? []).filter((entry) => entry.schema)
-      // Multiple content types for a single status code — generate a union of the variants.
-      if (variants.length > 1) {
-        return buildContentTypeVariants(variants, resolver.resolveResponseStatusName(node, res.statusCode))
-      }
-      const primary = variants[0] ?? res.content?.[0]
-      return renderSchemaType({
-        schema: primary?.schema ?? null,
-        name: resolver.resolveResponseStatusName(node, res.statusCode),
-        keysToOmit: primary?.keysToOmit,
-      })
-    })
-
-    const dataType = renderSchemaType({
-      schema: buildData({ ...node, parameters: params }, { resolver }),
-      name: resolver.resolveRequestConfigName(node),
-    })
-
-    const responsesType = renderSchemaType({
-      schema: buildResponses(node, { resolver }),
-      name: resolver.resolveResponsesName(node),
-    })
-
-    function buildResponseType() {
-      const hasSchema = (res: ast.ResponseNode) => (res.content ?? []).some((entry) => entry.schema)
-      if (!node.responses.some(hasSchema)) {
-        return null
-      }
-
-      const responseName = resolver.resolveResponseName(node)
-
-      const responsesWithSchema = node.responses.filter(hasSchema)
-      const importedNames = new Set(
-        responsesWithSchema.flatMap((res) =>
-          (res.content ?? []).flatMap((entry) =>
-            entry.schema
-              ? adapter
-                  .getImports(entry.schema, (schemaName) => ({
-                    name: resolveImportName(schemaName),
-                    path: '',
-                  }))
-                  .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
-              : [],
-          ),
-        ),
-      )
-
-      if (importedNames.has(responseName)) {
-        return null
-      }
-
-      return renderSchemaType({
-        schema: {
-          ...buildResponseUnion(node, { resolver })!,
-          description: 'Union of all possible responses',
-        },
-        name: responseName,
-      })
-    }
-
-    const responseType = buildResponseType()
-
-    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 } })}
-      >
-        {paramTypes}
-        {responseTypes}
-        {requestType}
-        {dataType}
-        {responsesType}
-        {responseType}
-      </File>
-    )
-  },
-})

package/src/index.ts

@@ -1,9 +0,0 @@
-export { Enum } from './components/Enum.tsx'
-export { Type } from './components/Type.tsx'
-export { typeGenerator } from './generators/typeGenerator.tsx'
-export { default, pluginTs, pluginTsName } from './plugin.ts'
-export { functionPrinter } from './printers/functionPrinter.ts'
-export type { PrinterTsFactory, PrinterTsNodes, PrinterTsOptions } from './printers/printerTs.ts'
-export { printerTs } from './printers/printerTs.ts'
-export { resolverTs } from './resolvers/resolverTs.ts'
-export type { PluginTs, ResolverTs } from './types.ts'

package/src/plugin.ts

@@ -1,95 +0,0 @@
-import { createGroupConfig } from '@internals/shared'
-import { definePlugin } from '@kubb/core'
-import { typeGenerator } from './generators/typeGenerator.tsx'
-import { resolverTs } from './resolvers/resolverTs.ts'
-import type { PluginTs } from './types.ts'
-
-/**
- * Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and
- * cross-plugin dependency references.
- */
-export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
-
-/**
- * Generates TypeScript `type` aliases and `interface` declarations from an
- * OpenAPI spec. The foundation that every other Kubb plugin builds on:
- * clients, query hooks, mocks, and validators all reference the names this
- * plugin produces.
- *
- * @example
- * ```ts
- * import { defineConfig } from 'kubb'
- * import { pluginTs } from '@kubb/plugin-ts'
- *
- * export default defineConfig({
- *   input: { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   plugins: [
- *     pluginTs({
- *       output: { path: './types' },
- *       enum: { type: 'asConst' },
- *       optionalType: 'questionTokenAndUndefined',
- *     }),
- *   ],
- * })
- * ```
- */
-export const pluginTs = definePlugin<PluginTs>((options) => {
-  const {
-    output = { path: 'types', barrel: { type: 'named' } },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    enum: enumOptions = {},
-    optionalType = 'questionToken',
-    arrayType = 'array',
-    syntaxType = 'type',
-    paramsCasing,
-    printer,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  const groupConfig = createGroupConfig(group)
-
-  const resolvedEnum = {
-    type: enumOptions.type ?? 'asConst',
-    constCasing: enumOptions.constCasing ?? 'camelCase',
-    typeSuffix: enumOptions.typeSuffix ?? 'Key',
-    keyCasing: enumOptions.keyCasing ?? 'none',
-  }
-
-  return {
-    name: pluginTsName,
-    options,
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        ctx.setOptions({
-          output,
-          exclude,
-          include,
-          override,
-          optionalType,
-          group: groupConfig,
-          arrayType,
-          enum: resolvedEnum,
-          syntaxType,
-          paramsCasing,
-          printer,
-        })
-        ctx.setResolver(userResolver ? { ...resolverTs, ...userResolver } : resolverTs)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-        ctx.addGenerator(typeGenerator)
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-      },
-    },
-  }
-})
-
-export default pluginTs

package/src/printers/functionPrinter.ts

@@ -1,197 +0,0 @@
-import { ast } from '@kubb/core'
-import { PARAM_RANK } from '../constants.ts'
-
-/**
- * Maps each function-printer handler key to its concrete node type.
- */
-export type FunctionNodeByType = {
-  functionParameter: ast.FunctionParameterNode
-  parameterGroup: ast.ParameterGroupNode
-  functionParameters: ast.FunctionParametersNode
-  paramsType: ast.ParamsTypeNode
-}
-
-const kindToHandlerKey = {
-  FunctionParameter: 'functionParameter',
-  ParameterGroup: 'parameterGroup',
-  FunctionParameters: 'functionParameters',
-  ParamsType: 'paramsType',
-} satisfies Record<string, ast.FunctionNodeType>
-
-/**
- * Creates a function-parameter printer factory.
- *
- * Uses `createPrinterFactory` and dispatches handlers by `node.kind`
- * (for function nodes) rather than by `node.type` (for schema nodes).
- */
-export const defineFunctionPrinter = ast.createPrinterFactory<ast.FunctionParamNode, ast.FunctionNodeType, FunctionNodeByType>(
-  (node) => kindToHandlerKey[node.kind],
-)
-
-export type FunctionPrinterOptions = {
-  /**
-   * Rendering modes supported by `functionPrinter`.
-   *
-   * | Mode          | Output example                              | Use case                        |
-   * |---------------|---------------------------------------------|---------------------------------|
-   * | `declaration` | `id: string, config: Config = {}`           | Function parameter declaration |
-   * | `call`        | `id, { method, url }`                       | Function call arguments |
-   * | `keys`        | `{ id, config }`                            | Key names only (destructuring) |
-   * | `values`      | `{ id: id, config: config }`                | Key/value object entries |
-   */
-  mode: 'declaration' | 'call' | 'keys' | 'values'
-  /**
-   * Optional transformation applied to every parameter name before printing.
-   */
-  transformName?: (name: string) => string
-  /**
-   * Optional transformation applied to every type string before printing.
-   */
-  transformType?: (type: string) => string
-}
-
-type DefaultPrinter = ast.PrinterFactoryOptions<'functionParameters', FunctionPrinterOptions, string>
-
-function rank(param: ast.FunctionParameterNode | ast.ParameterGroupNode): number {
-  if (param.kind === 'ParameterGroup') {
-    if (param.default) return PARAM_RANK.withDefault
-    const isOptional = param.optional ?? param.properties.every((p) => p.optional || p.default !== undefined)
-    return isOptional ? PARAM_RANK.optional : PARAM_RANK.required
-  }
-  if (param.rest) return PARAM_RANK.rest
-  if (param.default) return PARAM_RANK.withDefault
-  return param.optional ? PARAM_RANK.optional : PARAM_RANK.required
-}
-
-function sortParams(params: ReadonlyArray<ast.FunctionParameterNode | ast.ParameterGroupNode>): Array<ast.FunctionParameterNode | ast.ParameterGroupNode> {
-  return params.toSorted((a, b) => rank(a) - rank(b))
-}
-
-function sortChildParams(params: Array<ast.FunctionParameterNode>): Array<ast.FunctionParameterNode> {
-  return params.toSorted((a, b) => rank(a) - rank(b))
-}
-
-/**
- * Default function-signature printer.
- * Covers the four standard output modes used across Kubb plugins.
- *
- * @example
- * ```ts
- * const printer = functionPrinter({ mode: 'declaration' })
- *
- * const sig = createFunctionParameters({
- *   params: [
- *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
- *     createFunctionParameter({ name: 'config', type: 'Config', optional: false, default: '{}' }),
- *   ],
- * })
- *
- * printer.print(sig)  // → "petId: string, config: Config = {}"
- * ```
- */
-export const functionPrinter = defineFunctionPrinter<DefaultPrinter>((options) => ({
-  name: 'functionParameters',
-  options,
-  nodes: {
-    paramsType(node) {
-      if (node.kind !== 'ParamsType') return null
-      if (node.variant === 'member') {
-        return `${node.base}['${node.key}']`
-      }
-      if (node.variant === 'struct') {
-        const parts = node.properties.map((p) => {
-          const typeStr = this.transform(p.type)
-          const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name)
-          return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`
-        })
-        return `{ ${parts.join('; ')} }`
-      }
-      if (node.variant === 'reference') {
-        return node.name
-      }
-      return null
-    },
-    functionParameter(node) {
-      const { mode, transformName, transformType } = this.options
-      const name = transformName ? transformName(node.name) : node.name
-
-      const rawType = node.type ? this.transform(node.type) : undefined
-      const type = rawType != null && transformType ? transformType(rawType) : rawType
-
-      if (mode === 'keys' || mode === 'values') {
-        return node.rest ? `...${name}` : name
-      }
-
-      if (mode === 'call') {
-        return node.rest ? `...${name}` : name
-      }
-
-      if (node.rest) {
-        return type ? `...${name}: ${type}` : `...${name}`
-      }
-      if (type) {
-        if (node.optional) return `${name}?: ${type}`
-        return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`
-      }
-      return node.default ? `${name} = ${node.default}` : name
-    },
-    parameterGroup(node) {
-      const { mode, transformName, transformType } = this.options
-      const sorted = sortChildParams(node.properties)
-      const isOptional = node.optional ?? sorted.every((p) => p.optional || p.default !== undefined)
-
-      if (node.inline) {
-        return sorted
-          .map((p) => this.transform(p))
-          .filter(Boolean)
-          .join(', ')
-      }
-
-      if (mode === 'keys' || mode === 'values') {
-        const keys = sorted.map((p) => p.name).join(', ')
-        return `{ ${keys} }`
-      }
-
-      if (mode === 'call') {
-        const keys = sorted.map((p) => p.name).join(', ')
-        return `{ ${keys} }`
-      }
-
-      const names = sorted.map((p) => {
-        const n = transformName ? transformName(p.name) : p.name
-
-        return n
-      })
-
-      const nameStr = names.length ? `{ ${names.join(', ')} }` : undefined
-      if (!nameStr) return null
-
-      let typeAnnotation: string | undefined = node.type ? (this.transform(node.type) ?? undefined) : undefined
-      if (!typeAnnotation) {
-        const typeParts = sorted
-          .filter((p) => p.type)
-          .map((p) => {
-            const rawT = p.type ? this.transform(p.type) : undefined
-            const t = rawT != null && transformType ? transformType(rawT) : rawT
-            return p.optional || p.default !== undefined ? `${p.name}?: ${t}` : `${p.name}: ${t}`
-          })
-        typeAnnotation = typeParts.length ? `{ ${typeParts.join('; ')} }` : undefined
-      }
-
-      if (typeAnnotation) {
-        if (isOptional) return `${nameStr}: ${typeAnnotation} = ${node.default ?? '{}'}`
-        return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`
-      }
-
-      return node.default ? `${nameStr} = ${node.default}` : nameStr
-    },
-    functionParameters(node) {
-      const sorted = sortParams(node.params)
-
-      return sorted
-        .map((p) => this.transform(p))
-        .filter(Boolean)
-        .join(', ')
-    },
-  },
-}))