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

package/src/generators/typeGenerator.tsx

@@ -1,468 +1,184 @@
-import { pascalCase } from '@internals/utils'
-import type { PluginManager } from '@kubb/core'
-import { useMode, usePluginManager } from '@kubb/core/hooks'
-import { safePrint } from '@kubb/fabric-core/parsers/typescript'
-import type { Operation } from '@kubb/oas'
-import { isKeyword, type OperationSchemas, type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
-import { applyParamsCasing, getBanner, getFooter, getImports, isParameterSchema } from '@kubb/plugin-oas/utils'
+import path from 'node:path'
+import { caseParams, composeTransformers, narrowSchema, schemaTypes, transform } from '@kubb/ast'
+import type { SchemaNode } from '@kubb/ast/types'
+import { defineGenerator, getMode } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
-import ts from 'typescript'
-import { Type } from '../components'
-import * as factory from '../factory.ts'
-import { createUrlTemplateType, getUnknownType, keywordTypeNodes } from '../factory.ts'
-import { pluginTsName } from '../plugin.ts'
+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'
 
-function printCombinedSchema({ name, schemas, pluginManager }: { name: string; schemas: OperationSchemas; pluginManager: PluginManager }): string {
-  const properties: Record<string, ts.TypeNode> = {}
-
-  if (schemas.response) {
-    properties['response'] = factory.createUnionDeclaration({
-      nodes: schemas.responses.map((res) => {
-        const identifier = pluginManager.resolveName({
-          name: res.name,
-          pluginName: pluginTsName,
-          type: 'function',
-        })
-
-        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-      }),
-    })!
-  }
-
-  if (schemas.request) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.request.name,
-      pluginName: pluginTsName,
-      type: 'function',
-    })
-    properties['request'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.pathParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.pathParams.name,
-      pluginName: pluginTsName,
-      type: 'function',
-    })
-    properties['pathParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.queryParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.queryParams.name,
-      pluginName: pluginTsName,
-      type: 'function',
-    })
-    properties['queryParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.headerParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.headerParams.name,
-      pluginName: pluginTsName,
-      type: 'function',
-    })
-    properties['headerParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.errors) {
-    properties['errors'] = factory.createUnionDeclaration({
-      nodes: schemas.errors.map((error) => {
-        const identifier = pluginManager.resolveName({
-          name: error.name,
-          pluginName: pluginTsName,
-          type: 'function',
-        })
-
-        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-      }),
-    })!
-  }
-
-  const namespaceNode = factory.createTypeAliasDeclaration({
-    name,
-    type: factory.createTypeLiteralNode(
-      Object.keys(properties)
-        .map((key) => {
-          const type = properties[key]
-          if (!type) {
-            return undefined
-          }
-
-          return factory.createPropertySignature({
-            name: pascalCase(key),
-            type,
-          })
-        })
-        .filter(Boolean),
-    ),
-    modifiers: [factory.modifiers.export],
-  })
-
-  return safePrint(namespaceNode)
-}
-
-function printRequestSchema({
-  baseName,
-  operation,
-  schemas,
-  pluginManager,
-}: {
-  baseName: string
-  operation: Operation
-  schemas: OperationSchemas
-  pluginManager: PluginManager
-}): string {
-  const name = pluginManager.resolveName({
-    name: `${baseName} Request`,
-    pluginName: pluginTsName,
-    type: 'type',
-  })
-
-  const results: string[] = []
-
-  // Generate DataRequest type
-  const dataRequestProperties: ts.PropertySignature[] = []
-
-  if (schemas.request) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.request.name,
-      pluginName: pluginTsName,
-      type: 'type',
-    })
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'data',
-        questionToken: true,
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      }),
-    )
-  } else {
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'data',
-        questionToken: true,
-        type: keywordTypeNodes.never,
-      }),
-    )
-  }
-
-  // Add pathParams property
-  if (schemas.pathParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.pathParams.name,
-      pluginName: pluginTsName,
-      type: 'type',
-    })
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'pathParams',
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      }),
-    )
-  } else {
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'pathParams',
-        questionToken: true,
-        type: keywordTypeNodes.never,
-      }),
-    )
-  }
-
-  // Add queryParams property
-  if (schemas.queryParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.queryParams.name,
-      pluginName: pluginTsName,
-      type: 'type',
-    })
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'queryParams',
-        questionToken: true,
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      }),
-    )
-  } else {
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'queryParams',
-        questionToken: true,
-        type: keywordTypeNodes.never,
-      }),
-    )
-  }
-
-  // Add headerParams property
-  if (schemas.headerParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.headerParams.name,
-      pluginName: pluginTsName,
-      type: 'type',
-    })
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'headerParams',
-        questionToken: true,
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      }),
-    )
-  } else {
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'headerParams',
-        questionToken: true,
-        type: keywordTypeNodes.never,
-      }),
-    )
-  }
-
-  // Add url property with template literal type
-  dataRequestProperties.push(
-    factory.createPropertySignature({
-      name: 'url',
-      type: createUrlTemplateType(operation.path),
-    }),
-  )
-
-  const dataRequestNode = factory.createTypeAliasDeclaration({
-    name,
-    type: factory.createTypeLiteralNode(dataRequestProperties),
-    modifiers: [factory.modifiers.export],
-  })
-
-  results.push(safePrint(dataRequestNode))
-
-  return results.join('\n\n')
-}
-
-function printResponseSchema({
-  baseName,
-  schemas,
-  pluginManager,
-  unknownType,
-}: {
-  baseName: string
-  schemas: OperationSchemas
-  pluginManager: PluginManager
-  unknownType: PluginTs['resolvedOptions']['unknownType']
-}): string {
-  const results: string[] = []
-
-  const name = pluginManager.resolveName({
-    name: `${baseName} ResponseData`,
-    pluginName: pluginTsName,
-    type: 'type',
-  })
-
-  // Generate Responses type (mapping status codes to response types)
-  if (schemas.responses && schemas.responses.length > 0) {
-    const responsesProperties: ts.PropertySignature[] = schemas.responses.map((res) => {
-      const identifier = pluginManager.resolveName({
-        name: res.name,
-        pluginName: pluginTsName,
-        type: 'type',
-      })
-
-      return factory.createPropertySignature({
-        name: res.statusCode?.toString() ?? 'default',
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      })
-    })
-
-    const responsesNode = factory.createTypeAliasDeclaration({
-      name: `${baseName}Responses`,
-      type: factory.createTypeLiteralNode(responsesProperties),
-      modifiers: [factory.modifiers.export],
-    })
-
-    results.push(safePrint(responsesNode))
-
-    // Generate Response type (union via indexed access)
-    const responseNode = factory.createTypeAliasDeclaration({
-      name,
-      type: factory.createIndexedAccessTypeNode(
-        factory.createTypeReferenceNode(factory.createIdentifier(`${baseName}Responses`), undefined),
-        factory.createTypeOperatorNode(
-          ts.SyntaxKind.KeyOfKeyword,
-          factory.createTypeReferenceNode(factory.createIdentifier(`${baseName}Responses`), undefined),
-        ),
-      ),
-      modifiers: [factory.modifiers.export],
-    })
-
-    results.push(safePrint(responseNode))
-  } else {
-    const responseNode = factory.createTypeAliasDeclaration({
-      name,
-      modifiers: [factory.modifiers.export],
-      type: getUnknownType(unknownType),
-    })
-
-    results.push(safePrint(responseNode))
-  }
-
-  return results.join('\n\n')
-}
-
-export const typeGenerator = createReactGenerator<PluginTs, '1'>({
+export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
-  version: '1',
-  Operation({ operation, generator, plugin }) {
-    const {
-      options,
-      options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing },
-    } = plugin
+  type: 'react',
+  Operation({ node, adapter, options, config }) {
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options
 
-    const mode = useMode()
-    const pluginManager = usePluginManager()
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
 
-    const oas = useOas()
-    const { getSchemas, getFile, getName, getGroup } = useOperationManager(generator)
-    const schemaManager = useSchemaManager()
-
-    const name = getName(operation, { type: 'type', pluginName: pluginTsName })
-
-    const file = getFile(operation)
-    const schemas = getSchemas(operation)
-    const schemaGenerator = new SchemaGenerator(options, {
-      fabric: generator.context.fabric,
-      oas,
-      events: generator.context.events,
-      plugin,
-      pluginManager,
-      mode,
-      override: options.override,
-    })
+    const file = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
 
-    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
-      .flat()
-      .filter(Boolean)
+    const params = caseParams(node.parameters, paramsCasing)
 
-    const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }: OperationSchemaType) => {
-      // Apply paramsCasing transformation to pathParams, queryParams, and headerParams (not response)
-      const shouldTransform = paramsCasing && isParameterSchema(name)
-      const transformedSchema = shouldTransform ? applyParamsCasing(schema, paramsCasing) : schema
+    function renderSchemaType({
+      node: schemaNode,
+      name,
+      typedName,
+      description,
+      keysToOmit,
+    }: {
+      node: SchemaNode | null
+      name: string
+      typedName: string
+      description?: string
+      keysToOmit?: Array<string>
+    }) {
+      if (!schemaNode) {
+        return null
+      }
 
-      const tree = schemaGenerator.parse({ schema: transformedSchema, name, parentName: null })
-      const imports = getImports(tree)
-      const group = options.operation ? getGroup(options.operation) : undefined
+      const transformedNode = transform(schemaNode, composeTransformers(...transformers))
 
-      const type = {
-        name: schemaManager.getName(name, { type: 'type' }),
-        typedName: schemaManager.getName(name, { type: 'type' }),
-        file: schemaManager.getFile(options.operationName || name, { group }),
-      }
+      const imports = adapter.getImports(transformedNode, (schemaName) => ({
+        name: resolver.default(schemaName, 'type'),
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      }))
 
       return (
         <>
           {mode === 'split' &&
-            imports.map((imp) => (
-              <File.Import key={[name, imp.name, imp.path, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} isTypeOnly />
-            ))}
+            imports.map((imp) => <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} isTypeOnly />)}
           <Type
-            name={type.name}
-            typedName={type.typedName}
+            name={name}
+            typedName={typedName}
+            node={transformedNode}
             description={description}
-            tree={tree}
-            schema={transformedSchema}
-            mapper={mapper}
             enumType={enumType}
             enumKeyCasing={enumKeyCasing}
             optionalType={optionalType}
             arrayType={arrayType}
-            keysToOmit={keysToOmit}
             syntaxType={syntaxType}
+            resolver={resolver}
+            keysToOmit={keysToOmit}
           />
         </>
       )
     }
 
-    const responseName = schemaManager.getName(schemas.response.name, {
-      type: 'type',
+    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: node.requestBody.schema,
+          name: resolver.resolveDataName(node),
+          typedName: resolver.resolveDataTypedName(node),
+          description: node.requestBody.description ?? node.requestBody.schema.description,
+          keysToOmit: node.requestBody.keysToOmit,
+        })
+      : null
+
+    const responseTypes = 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 dataType = renderSchemaType({
+      node: builderTs.buildData({ node: { ...node, parameters: params }, resolver }),
+      name: resolver.resolveRequestConfigName(node),
+      typedName: resolver.resolveRequestConfigTypedName(node),
+    })
+
+    const responsesType = renderSchemaType({
+      node: builderTs.buildResponses({ node, resolver }),
+      name: resolver.resolveResponsesName(node),
+      typedName: resolver.resolveResponsesTypedName(node),
+    })
+
+    const responseType = renderSchemaType({
+      node: builderTs.buildResponseUnion({ node, resolver }),
+      name: resolver.resolveResponseName(node),
+      typedName: resolver.resolveResponseTypedName(node),
+      description: 'Union of all possible responses',
     })
-    const combinedSchemaName = operation.method === 'get' ? `${name}Query` : `${name}Mutation`
 
     return (
       <File
         baseName={file.baseName}
         path={file.path}
         meta={file.meta}
-        banner={getBanner({ oas, output: plugin.options.output, config: pluginManager.config })}
-        footer={getFooter({ oas, output: plugin.options.output })}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
       >
-        {operationSchemas.map(mapOperationSchema)}
-
-        {generator.context.UNSTABLE_NAMING ? (
-          <>
-            <File.Source name={`${name}Request`} isExportable isIndexable isTypeOnly>
-              {printRequestSchema({ baseName: name, operation, schemas, pluginManager })}
-            </File.Source>
-            <File.Source name={responseName} isExportable isIndexable isTypeOnly>
-              {printResponseSchema({ baseName: name, schemas, pluginManager, unknownType })}
-            </File.Source>
-          </>
-        ) : (
-          <File.Source name={combinedSchemaName} isExportable isIndexable isTypeOnly>
-            {printCombinedSchema({ name: combinedSchemaName, schemas, pluginManager })}
-          </File.Source>
-        )}
+        {paramTypes}
+        {responseTypes}
+        {requestType}
+        {dataType}
+        {responsesType}
+        {responseType}
       </File>
     )
   },
-  Schema({ schema, plugin }) {
-    const {
-      options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output },
-    } = plugin
-    const mode = useMode()
+  Schema({ node, adapter, options, config }) {
+    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options
 
-    const oas = useOas()
-    const pluginManager = usePluginManager()
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
 
-    const { getName, getFile } = useSchemaManager()
-    const imports = getImports(schema.tree)
-    const schemaFromTree = schema.tree.find((item) => item.keyword === schemaKeywords.schema)
+    if (!node.name) {
+      return
+    }
 
-    let typedName = getName(schema.name, { type: 'type' })
+    const transformedNode = transform(node, composeTransformers(...transformers))
 
-    if (['asConst', 'asPascalConst'].includes(enumType) && schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.enum)) {
-      typedName = typedName += 'Key' //Suffix for avoiding collisions (https://github.com/kubb-labs/kubb/issues/1873)
-    }
+    const imports = adapter.getImports(transformedNode, (schemaName) => ({
+      name: resolver.default(schemaName, 'type'),
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+    }))
+
+    const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
+
+    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name)
 
     const type = {
-      name: getName(schema.name, { type: 'function' }),
+      name: resolver.resolveName(node.name),
       typedName,
-      file: getFile(schema.name),
-    }
+      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={getBanner({ oas, output, config: pluginManager.config })}
-        footer={getFooter({ oas, output })}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
       >
         {mode === 'split' &&
           imports.map((imp) => (
-            <File.Import key={[schema.name, imp.path, imp.isTypeOnly].join('-')} root={type.file.path} path={imp.path} name={imp.name} isTypeOnly />
+            <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={type.file.path} path={imp.path} name={imp.name} isTypeOnly />
           ))}
         <Type
           name={type.name}
           typedName={type.typedName}
-          description={schema.value.description}
-          tree={schema.tree}
-          schema={schema.value}
-          mapper={mapper}
+          node={transformedNode}
           enumType={enumType}
           enumKeyCasing={enumKeyCasing}
           optionalType={optionalType}
           arrayType={arrayType}
           syntaxType={syntaxType}
+          resolver={resolver}
         />
       </File>
     )