@kubb/plugin-ts 5.0.0-alpha.20 → 5.0.0-alpha.21

package/src/builders/builderTs.ts

@@ -0,0 +1,92 @@
+import { createProperty, createSchema } from '@kubb/ast'
+import { defineBuilder } from '@kubb/core'
+import type { PluginTs } from '../types.ts'
+
+export const builderTs = defineBuilder<PluginTs>(() => ({
+  name: 'default',
+  buildParams({ params, node, resolver }) {
+    return createSchema({
+      type: 'object',
+      properties: params.map((param) =>
+        createProperty({
+          name: param.name,
+          required: param.required,
+          schema: createSchema({
+            type: 'ref',
+            name: resolver.resolveParamName(node, param),
+          }),
+        }),
+      ),
+    })
+  },
+  buildData({ node, resolver }) {
+    const pathParams = node.parameters.filter((p) => p.in === 'path')
+    const queryParams = node.parameters.filter((p) => p.in === 'query')
+    const headerParams = node.parameters.filter((p) => p.in === 'header')
+
+    return createSchema({
+      type: 'object',
+      deprecated: node.deprecated,
+      properties: [
+        createProperty({
+          name: 'data',
+          schema: node.requestBody?.schema
+            ? createSchema({ type: 'ref', name: resolver.resolveDataTypedName(node), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+        }),
+        createProperty({
+          name: 'pathParams',
+          required: pathParams.length > 0,
+          schema: pathParams.length > 0 ? this.buildParams({ params: pathParams, node, resolver }) : createSchema({ type: 'never' }),
+        }),
+        createProperty({
+          name: 'queryParams',
+          schema:
+            queryParams.length > 0
+              ? createSchema({ ...this.buildParams({ params: queryParams, node, resolver }), optional: true })
+              : createSchema({ type: 'never', optional: true }),
+        }),
+        createProperty({
+          name: 'headerParams',
+          schema:
+            headerParams.length > 0
+              ? createSchema({ ...this.buildParams({ params: headerParams, node, resolver }), optional: true })
+              : createSchema({ type: 'never', optional: true }),
+        }),
+        createProperty({
+          name: 'url',
+          required: true,
+          schema: createSchema({ type: 'url', path: node.path }),
+        }),
+      ],
+    })
+  },
+  buildResponses({ node, resolver }) {
+    if (node.responses.length === 0) {
+      return null
+    }
+
+    return createSchema({
+      type: 'object',
+      properties: node.responses.map((res) =>
+        createProperty({
+          name: String(res.statusCode),
+          required: true,
+          schema: createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) }),
+        }),
+      ),
+    })
+  },
+  buildResponseUnion({ node, resolver }) {
+    const responsesWithSchema = node.responses.filter((res) => res.schema)
+
+    if (responsesWithSchema.length === 0) {
+      return null
+    }
+
+    return createSchema({
+      type: 'union',
+      members: responsesWithSchema.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+    })
+  },
+}))

package/src/builders/index.ts

@@ -0,0 +1 @@
+export { builderTs } from './builderTs.ts'

package/src/components/Type.tsx

@@ -1,9 +1,8 @@
 import { collect, narrowSchema, schemaTypes } from '@kubb/ast'
 import type { EnumSchemaNode, SchemaNode } from '@kubb/ast/types'
-import { safePrint } from '@kubb/fabric-core/parsers/typescript'
 import { File } from '@kubb/react-fabric'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import { printerTs } from '../printer.ts'
+import { printerTs } from '../printers/printerTs.ts'
 import type { PluginTs } from '../types.ts'
 import { Enum, getEnumNames } from './Enum.tsx'
 
@@ -17,7 +16,6 @@ type Props = {
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
   syntaxType: PluginTs['resolvedOptions']['syntaxType']
   resolver: PluginTs['resolvedOptions']['resolver']
-  legacy?: boolean
   description?: string
   keysToOmit?: string[]
 }
@@ -44,9 +42,9 @@ export function Type({
   })
 
   const printer = printerTs({ optionalType, arrayType, enumType, typeName: name, syntaxType, description: resolvedDescription, keysToOmit, resolver })
-  const typeNode = printer.print(node)
+  const output = printer.print(node)
 
-  if (!typeNode) {
+  if (!output) {
     return
   }
 
@@ -66,7 +64,7 @@ export function Type({
       {shouldExportEnums && enums.map(({ node }) => <Enum node={node} enumType={enumType} enumKeyCasing={enumKeyCasing} resolver={resolver} />)}
       {shouldExportType && (
         <File.Source name={typedName} isTypeOnly isExportable isIndexable>
-          {safePrint(typeNode)}
+          {output}
         </File.Source>
       )}
     </>

package/src/factory.ts

@@ -19,16 +19,6 @@ export const syntaxKind = {
   stringLiteral: SyntaxKind.StringLiteral,
 } as const
 
-export function getUnknownType(unknownType: 'any' | 'unknown' | 'void' | undefined) {
-  if (unknownType === 'any') {
-    return keywordTypeNodes.any
-  }
-  if (unknownType === 'void') {
-    return keywordTypeNodes.void
-  }
-
-  return keywordTypeNodes.unknown
-}
 function isValidIdentifier(str: string): boolean {
   if (!str.length || str.trim() !== str) {
     return false
@@ -76,28 +66,6 @@ export function createIntersectionDeclaration({ nodes, withParentheses }: { node
   return node
 }
 
-/**
- * Minimum nodes length of 2
- * @example `string & number`
- */
-export function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {
-  if (!nodes.length) {
-    return null
-  }
-
-  if (nodes.length === 1) {
-    return nodes[0] || null
-  }
-
-  const node = factory.createTupleTypeNode(nodes)
-
-  if (withParentheses) {
-    return factory.createParenthesizedType(node)
-  }
-
-  return node
-}
-
 export function createArrayDeclaration({ nodes, arrayType = 'array' }: { nodes: Array<ts.TypeNode>; arrayType?: 'array' | 'generic' }): ts.TypeNode | null {
   if (!nodes.length) {
     return factory.createTupleTypeNode([])

package/src/generators/index.ts

@@ -1 +1,2 @@
 export { typeGenerator } from './typeGenerator.tsx'
+export { typeGeneratorLegacy } from './typeGeneratorLegacy.tsx'

package/src/generators/typeGenerator.tsx

@@ -1,50 +1,24 @@
+import path from 'node:path'
 import { caseParams, composeTransformers, narrowSchema, schemaTypes, transform } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
-import { defineGenerator } from '@kubb/core'
-import { useKubb } from '@kubb/core/hooks'
+import { defineGenerator, getMode } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
+import { builderTs } from '../builders/builderTs.ts'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
 import type { PluginTs } from '../types'
-import {
-  buildDataSchemaNode,
-  buildGroupedParamsSchema,
-  buildLegacyResponsesSchemaNode,
-  buildLegacyResponseUnionSchemaNode,
-  buildParamsSchema,
-  buildResponsesSchemaNode,
-  buildResponseUnionSchemaNode,
-  nameUnnamedEnums,
-} from './utils.ts'
 
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
   type: 'react',
-  Operation({ node, adapter, options }) {
-    const {
-      enumType,
-      enumKeyCasing,
-      optionalType,
-      arrayType,
-      syntaxType,
-      paramsCasing,
-      group,
-      resolver,
-      baseResolver,
-      compatibilityPreset,
-      transformers = [],
-    } = options
-    const isKubbV4Compatibility = compatibilityPreset === 'kubbV4'
-    const { mode, getFile, resolveBanner, resolveFooter } = useKubb<PluginTs>()
+  Operation({ node, adapter, options, config }) {
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
+
+    const file = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
 
-    const file = getFile({
-      name: node.operationId,
-      extname: '.ts',
-      mode,
-      options: {
-        group: group ? (group.type === 'tag' ? { tag: node.tags[0] ?? 'default' } : { path: node.path }) : undefined,
-      },
-    })
     const params = caseParams(node.parameters, paramsCasing)
 
     function renderSchemaType({
@@ -68,7 +42,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
       const imports = adapter.getImports(transformedNode, (schemaName) => ({
         name: resolver.default(schemaName, 'type'),
-        path: getFile({ name: schemaName, extname: '.ts', mode }).path,
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
       }))
 
       return (
@@ -87,38 +61,22 @@ export const typeGenerator = defineGenerator<PluginTs>({
             syntaxType={syntaxType}
             resolver={resolver}
             keysToOmit={keysToOmit}
-            legacy={isKubbV4Compatibility}
           />
         </>
       )
     }
 
-    const responseTypes = isKubbV4Compatibility
-      ? node.responses.map((res) => {
-          const responseName = resolver.resolveResponseStatusName(node, res.statusCode)
-          const baseResponseName = baseResolver.resolveResponseStatusName(node, res.statusCode)
-
-          return renderSchemaType({
-            node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
-            name: responseName,
-            typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
-            description: res.description,
-            keysToOmit: res.keysToOmit,
-          })
-        })
-      : node.responses.map((res) =>
-          renderSchemaType({
-            node: res.schema,
-            name: resolver.resolveResponseStatusName(node, res.statusCode),
-            typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
-            description: res.description,
-            keysToOmit: res.keysToOmit,
-          }),
-        )
+    const paramTypes = params.map((param) =>
+      renderSchemaType({
+        node: param.schema,
+        name: resolver.resolveParamName(node, param),
+        typedName: resolver.resolveParamTypedName(node, param),
+      }),
+    )
 
     const requestType = node.requestBody?.schema
       ? renderSchemaType({
-          node: isKubbV4Compatibility ? nameUnnamedEnums(node.requestBody.schema, baseResolver.resolveDataName(node)) : node.requestBody.schema,
+          node: node.requestBody.schema,
           name: resolver.resolveDataName(node),
           typedName: resolver.resolveDataTypedName(node),
           description: node.requestBody.description ?? node.requestBody.schema.description,
@@ -126,99 +84,44 @@ export const typeGenerator = defineGenerator<PluginTs>({
         })
       : null
 
-    if (isKubbV4Compatibility) {
-      const pathParams = params.filter((p) => p.in === 'path')
-      const queryParams = params.filter((p) => p.in === 'query')
-      const headerParams = params.filter((p) => p.in === 'header')
-
-      const legacyParamTypes = [
-        pathParams.length > 0
-          ? renderSchemaType({
-              node: buildGroupedParamsSchema({ params: pathParams, parentName: baseResolver.resolvePathParamsName!(node) }),
-              name: resolver.resolvePathParamsName!(node),
-              typedName: resolver.resolvePathParamsTypedName!(node),
-            })
-          : null,
-        queryParams.length > 0
-          ? renderSchemaType({
-              node: buildGroupedParamsSchema({ params: queryParams, parentName: baseResolver.resolveQueryParamsName!(node) }),
-              name: resolver.resolveQueryParamsName!(node),
-              typedName: resolver.resolveQueryParamsTypedName!(node),
-            })
-          : null,
-        headerParams.length > 0
-          ? renderSchemaType({
-              node: buildGroupedParamsSchema({ params: headerParams, parentName: baseResolver.resolveHeaderParamsName!(node) }),
-              name: resolver.resolveHeaderParamsName!(node),
-              typedName: resolver.resolveHeaderParamsTypedName!(node),
-            })
-          : null,
-      ]
-
-      const legacyResponsesType = renderSchemaType({
-        node: buildLegacyResponsesSchemaNode({ node, resolver }),
-        name: resolver.resolveResponsesName(node),
-        typedName: resolver.resolveResponsesTypedName(node),
-      })
-
-      const legacyResponseType = renderSchemaType({
-        node: buildLegacyResponseUnionSchemaNode({ node, resolver }),
-        name: resolver.resolveResponseName(node),
-        typedName: resolver.resolveResponseTypedName(node),
-      })
-
-      return (
-        <File baseName={file.baseName} path={file.path} meta={file.meta} banner={resolveBanner()} footer={resolveFooter()}>
-          {legacyParamTypes}
-          {responseTypes}
-          {requestType}
-          {legacyResponseType}
-          {legacyResponsesType}
-        </File>
-      )
-    }
-
-    const paramTypes = params.map((param) =>
+    const responseTypes = node.responses.map((res) =>
       renderSchemaType({
-        node: param.schema,
-        name: resolver.resolveParamName(node, param),
-        typedName: resolver.resolveParamTypedName(node, param),
+        node: res.schema,
+        name: resolver.resolveResponseStatusName(node, res.statusCode),
+        typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
+        description: res.description,
+        keysToOmit: res.keysToOmit,
       }),
     )
 
-    const queryParamsList = params.filter((p) => p.in === 'query')
-    const queryParamsType =
-      queryParamsList.length > 0
-        ? renderSchemaType({
-            node: buildParamsSchema({ params: queryParamsList, node, resolver }),
-            name: resolver.resolveQueryParamsName!(node),
-            typedName: resolver.resolveQueryParamsTypedName!(node),
-          })
-        : null
-
     const dataType = renderSchemaType({
-      node: buildDataSchemaNode({ node: { ...node, parameters: params }, resolver }),
+      node: builderTs.buildData({ node: { ...node, parameters: params }, resolver }),
       name: resolver.resolveRequestConfigName(node),
       typedName: resolver.resolveRequestConfigTypedName(node),
     })
 
     const responsesType = renderSchemaType({
-      node: buildResponsesSchemaNode({ node, resolver }),
+      node: builderTs.buildResponses({ node, resolver }),
       name: resolver.resolveResponsesName(node),
       typedName: resolver.resolveResponsesTypedName(node),
     })
 
     const responseType = renderSchemaType({
-      node: buildResponseUnionSchemaNode({ node, resolver }),
+      node: builderTs.buildResponseUnion({ node, resolver }),
       name: resolver.resolveResponseName(node),
       typedName: resolver.resolveResponseTypedName(node),
       description: 'Union of all possible responses',
     })
 
     return (
-      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={resolveBanner()} footer={resolveFooter()}>
+      <File
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
         {paramTypes}
-        {queryParamsType}
         {responseTypes}
         {requestType}
         {dataType}
@@ -227,10 +130,11 @@ export const typeGenerator = defineGenerator<PluginTs>({
       </File>
     )
   },
-  Schema({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, resolver, compatibilityPreset, transformers = [] } = options
-    const isKubbV4Compatibility = compatibilityPreset === 'kubbV4'
-    const { mode, getFile, resolveBanner, resolveFooter } = useKubb<PluginTs>()
+  Schema({ node, adapter, options, config }) {
+    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
 
     if (!node.name) {
       return
@@ -240,7 +144,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
     const imports = adapter.getImports(transformedNode, (schemaName) => ({
       name: resolver.default(schemaName, 'type'),
-      path: getFile({ name: schemaName, extname: '.ts', mode }).path,
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
     const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
@@ -250,11 +154,17 @@ export const typeGenerator = defineGenerator<PluginTs>({
     const type = {
       name: resolver.resolveName(node.name),
       typedName,
-      file: getFile({ name: node.name, extname: '.ts', mode }),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
     return (
-      <File baseName={type.file.baseName} path={type.file.path} meta={type.file.meta} banner={resolveBanner()} footer={resolveFooter()}>
+      <File
+        baseName={type.file.baseName}
+        path={type.file.path}
+        meta={type.file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
         {mode === 'split' &&
           imports.map((imp) => (
             <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={type.file.path} path={imp.path} name={imp.name} isTypeOnly />
@@ -269,7 +179,6 @@ export const typeGenerator = defineGenerator<PluginTs>({
           arrayType={arrayType}
           syntaxType={syntaxType}
           resolver={resolver}
-          legacy={isKubbV4Compatibility}
         />
       </File>
     )