@kubb/swagger-ts 2.0.0-beta.3 → 2.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/swagger-ts",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.4",
   "description": "Generator swagger-ts",
   "keywords": [
     "typescript",
@@ -25,6 +25,11 @@
       "require": "./dist/index.cjs",
       "default": "./dist/index.cjs"
     },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs",
+      "default": "./dist/components.cjs"
+    },
     "./package.json": "./package.json",
     "./*": "./*"
   },
@@ -38,21 +43,24 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "change-case": "^4.1.2",
     "typescript": "^5.3.2",
-    "@kubb/core": "2.0.0-beta.3",
-    "@kubb/parser": "2.0.0-beta.2",
-    "@kubb/swagger": "2.0.0-beta.3"
+    "@kubb/core": "2.0.0-beta.4",
+    "@kubb/parser": "2.0.0-beta.4",
+    "@kubb/react": "2.0.0-beta.4",
+    "@kubb/swagger": "2.0.0-beta.4"
   },
   "devDependencies": {
+    "@types/react": "^18.2.38",
     "eslint": "^8.54.0",
+    "react": "^18.2.0",
     "tsup": "^8.0.1",
     "@kubb/eslint-config": "1.1.8",
     "@kubb/ts-config": "0.1.0",
     "@kubb/tsup-config": "1.1.8"
   },
   "peerDependencies": {
-    "typescript": "^5.3.0"
+    "typescript": "^5.3.0",
+    "@kubb/react": "2.0.0-beta.4"
   },
   "packageManager": "pnpm@8.3.0",
   "engines": {

package/src/OperationGenerator.tsx

@@ -0,0 +1,50 @@
+import { createRoot } from '@kubb/react'
+import { OperationGenerator as Generator } from '@kubb/swagger'
+
+import { Mutation } from './components/Mutation.tsx'
+import { Query } from './components/Query.tsx'
+
+import type { KubbFile } from '@kubb/core'
+import type { AppContextProps } from '@kubb/react'
+import type { Operation, OperationMethodResult, OperationSchemas } from '@kubb/swagger'
+import type { FileMeta, PluginOptions } from './types.ts'
+
+export class OperationGenerator extends Generator<PluginOptions['resolvedOptions'], PluginOptions> {
+  async all(): Promise<KubbFile.File | null> {
+    return null
+  }
+
+  async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin, mode = 'directory' } = this.context
+
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
+    root.render(
+      <Query.File mode={mode} />,
+      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+    )
+
+    return root.files
+  }
+
+  async post(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin, mode = 'directory' } = this.context
+
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
+    root.render(
+      <Mutation.File mode={mode} />,
+      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+    )
+
+    return root.files
+  }
+
+  async put(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, schemas, options)
+  }
+  async patch(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, schemas, options)
+  }
+  async delete(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, schemas, options)
+  }
+}

package/src/TypeBuilder.ts

@@ -0,0 +1,58 @@
+import transformers from '@kubb/core/transformers'
+import { print } from '@kubb/parser'
+import { OasBuilder } from '@kubb/swagger'
+import { refsSorter } from '@kubb/swagger/utils'
+
+import { TypeGenerator } from './TypeGenerator.ts'
+
+import type { KubbFile } from '@kubb/core'
+import type { ImportMeta } from '@kubb/swagger'
+import type { PluginOptions } from './types.ts'
+
+export class TypeBuilder extends OasBuilder<PluginOptions['resolvedOptions']> {
+  build(name?: string): Required<Pick<KubbFile.File, 'imports' | 'source'>> {
+    const importMeta: ImportMeta[] = []
+    const codes: string[] = []
+
+    const generated = this.items
+      .filter((operationSchema) => (name ? operationSchema.name === name : true))
+      .sort(transformers.nameSorter)
+      .map((operationSchema) => {
+        const generator = new TypeGenerator(this.options, this.context)
+        const sources = generator.build({
+          schema: operationSchema.schema,
+          baseName: operationSchema.name,
+          description: operationSchema.description,
+          keysToOmit: operationSchema.keysToOmit,
+        })
+
+        importMeta.push(...generator.imports)
+
+        return {
+          import: {
+            refs: generator.refs,
+            name: operationSchema.name,
+          },
+          sources,
+        }
+      })
+      .sort(refsSorter)
+
+    generated.forEach((item) => {
+      codes.push(print(item.sources))
+    })
+
+    const imports: KubbFile.Import[] = importMeta.map((item) => {
+      return {
+        name: [item.ref.propertyName],
+        path: item.path,
+        isTypeOnly: item.isTypeOnly,
+      }
+    })
+
+    return {
+      imports,
+      source: transformers.combineCodes(codes),
+    }
+  }
+}

package/src/{generators/TypeGenerator.ts → TypeGenerator.ts}

@@ -1,30 +1,26 @@
-import { SchemaGenerator } from '@kubb/core'
+import { Generator } from '@kubb/core'
+import transformers from '@kubb/core/transformers'
 import { getUniqueName } from '@kubb/core/utils'
 import * as factory from '@kubb/parser/factory'
 import { getSchemaFactory, isReference } from '@kubb/swagger/utils'
 
-import { camelCase } from 'change-case'
+import { pluginKey } from './plugin.ts'
 
-import type { PluginContext } from '@kubb/core'
+import type { PluginManager } from '@kubb/core'
 import type { ts } from '@kubb/parser'
-import type { Oas, OasTypes, OpenAPIV3, OpenAPIV3_1, Refs } from '@kubb/swagger'
-import type { Options as CaseOptions } from 'change-case'
+import type { ImportMeta, Oas, OasTypes, OpenAPIV3, OpenAPIV3_1, Refs } from '@kubb/swagger'
+import type { PluginOptions } from './types.ts'
 
 // based on https://github.com/cellular/oazapfts/blob/7ba226ebb15374e8483cc53e7532f1663179a22c/src/codegen/generate.ts#L398
 
-type Options = {
+type Context = {
   oas: Oas
-  usedEnumNames: Record<string, number>
-
-  withJSDocs?: boolean
-  resolveName: PluginContext['resolveName']
-  enumType: 'enum' | 'asConst' | 'asPascalConst'
-  dateType: 'string' | 'date'
-  optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined'
+  pluginManager: PluginManager
 }
 
-export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObject, ts.Node[]> {
+export class TypeGenerator extends Generator<PluginOptions['resolvedOptions'], Context> {
   refs: Refs = {}
+  imports: ImportMeta[] = []
 
   extraNodes: ts.Node[] = []
 
@@ -33,19 +29,6 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
   // Keep track of already used type aliases
   #usedAliasNames: Record<string, number> = {}
 
-  #caseOptions: CaseOptions = {
-    delimiter: '',
-    stripRegexp: /[^A-Z0-9$]/gi,
-  }
-
-  constructor(
-    options: Options,
-  ) {
-    super(options)
-
-    return this
-  }
-
   build({
     schema,
     baseName,
@@ -58,7 +41,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
     keysToOmit?: string[]
   }): ts.Node[] {
     const nodes: ts.Node[] = []
-    const type = this.#getTypeFromSchema(schema, baseName)
+    const type = this.getTypeFromSchema(schema, baseName)
 
     if (!type) {
       return this.extraNodes
@@ -66,7 +49,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
 
     const node = factory.createTypeAliasDeclaration({
       modifiers: [factory.modifiers.export],
-      name: this.options.resolveName({ name: baseName }) || baseName,
+      name: this.context.pluginManager.resolveName({ name: baseName, pluginKey, type: 'type' }),
       type: keysToOmit?.length ? factory.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type,
     })
 
@@ -74,7 +57,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
       nodes.push(
         factory.appendJSDocToNode({
           node,
-          comments: [`@description ${description}`],
+          comments: [`@description ${transformers.trim(description)}`],
         }),
       )
     } else {
@@ -97,7 +80,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
    * Delegates to getBaseTypeFromSchema internally and
    * optionally adds a union with null.
    */
-  #getTypeFromSchema(schema?: OasTypes.SchemaObject, name?: string): ts.TypeNode | null {
+  getTypeFromSchema(schema?: OasTypes.SchemaObject, name?: string): ts.TypeNode | null {
     const type = this.#getBaseTypeFromSchema(schema, name)
 
     if (!type) {
@@ -114,7 +97,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
   /**
    * Recursively creates a type literal with the given props.
    */
-  #getTypeFromProperties(baseSchema?: OasTypes.SchemaObject, baseName?: string) {
+  #getTypeFromProperties(baseSchema?: OasTypes.SchemaObject, baseName?: string): ts.TypeNode | null {
     const { optionalType } = this.options
     const properties = baseSchema?.properties || {}
     const required = baseSchema?.required
@@ -124,39 +107,38 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
       const schema = properties[name] as OasTypes.SchemaObject
 
       const isRequired = Array.isArray(required) ? required.includes(name) : !!required
-      let type = this.#getTypeFromSchema(schema, this.options.resolveName({ name: `${baseName || ''} ${name}` }))
+      let type = this.getTypeFromSchema(schema, this.context.pluginManager.resolveName({ name: `${baseName || ''} ${name}`, pluginKey, type: 'type' }))
 
       if (!type) {
         return null
       }
 
-      if (!isRequired && ['undefined', 'questionTokenAndUndefined'].includes(optionalType)) {
+      if (!isRequired && ['undefined', 'questionTokenAndUndefined'].includes(optionalType as string)) {
         type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.undefined] })
       }
       const propertySignature = factory.createPropertySignature({
-        questionToken: ['questionToken', 'questionTokenAndUndefined'].includes(optionalType) && !isRequired,
+        questionToken: ['questionToken', 'questionTokenAndUndefined'].includes(optionalType as string) && !isRequired,
         name,
         type: type as ts.TypeNode,
         readOnly: schema.readOnly,
       })
-      if (this.options.withJSDocs) {
-        return factory.appendJSDocToNode({
-          node: propertySignature,
-          comments: [
-            schema.description ? `@description ${schema.description}` : undefined,
-            schema.type ? `@type ${schema.type?.toString()}${isRequired ? '' : ' | undefined'} ${schema.format || ''}` : undefined,
-            schema.example ? `@example ${schema.example as string}` : undefined,
-            schema.deprecated ? `@deprecated` : undefined,
-            schema.default !== undefined && typeof schema.default === 'string' ? `@default '${schema.default}'` : undefined,
-            schema.default !== undefined && typeof schema.default !== 'string' ? `@default ${schema.default as string}` : undefined,
-          ].filter(Boolean),
-        })
-      }
+
+      return factory.appendJSDocToNode({
+        node: propertySignature,
+        comments: [
+          schema.description ? `@description ${schema.description}` : undefined,
+          schema.type ? `@type ${schema.type?.toString()}${isRequired ? '' : ' | undefined'} ${schema.format || ''}` : undefined,
+          schema.example ? `@example ${schema.example as string}` : undefined,
+          schema.deprecated ? `@deprecated` : undefined,
+          schema.default !== undefined && typeof schema.default === 'string' ? `@default '${schema.default}'` : undefined,
+          schema.default !== undefined && typeof schema.default !== 'string' ? `@default ${schema.default as string}` : undefined,
+        ].filter(Boolean),
+      })
 
       return propertySignature
     })
     if (additionalProperties) {
-      const type = additionalProperties === true ? factory.keywordTypeNodes.any : this.#getTypeFromSchema(additionalProperties as OasTypes.SchemaObject)
+      const type = additionalProperties === true ? factory.keywordTypeNodes.any : this.getTypeFromSchema(additionalProperties as OasTypes.SchemaObject)
 
       if (type) {
         members.push(factory.createIndexSignature(type))
@@ -177,18 +159,26 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
     }
 
     const originalName = getUniqueName($ref.replace(/.+\//, ''), this.#usedAliasNames)
-    const propertyName = this.options.resolveName({ name: originalName }) || originalName
+    const propertyName = this.context.pluginManager.resolveName({ name: originalName, pluginKey, type: 'type' })
 
     ref = this.refs[$ref] = {
       propertyName,
       originalName,
     }
 
+    const path = this.context.pluginManager.resolvePath({ baseName: propertyName, pluginKey })
+
+    this.imports.push({
+      ref,
+      path: path || '',
+      isTypeOnly: true,
+    })
+
     return factory.createTypeReferenceNode(ref.propertyName, undefined)
   }
 
   #getParsedSchema(schema?: OasTypes.SchemaObject) {
-    const parsedSchema = getSchemaFactory(this.options.oas)(schema)
+    const parsedSchema = getSchemaFactory(this.context.oas)(schema)
     return parsedSchema
   }
 
@@ -218,7 +208,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
         withParentheses: true,
         nodes: schema.oneOf
           .map((item) => {
-            return item && this.#getBaseTypeFromSchema(item as OasTypes.SchemaObject)
+            return item && this.getTypeFromSchema(item as OasTypes.SchemaObject)
           })
           .filter((item) => {
             return item && item !== factory.keywordTypeNodes.any
@@ -227,7 +217,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
 
       if (schemaWithoutOneOf.properties) {
         return factory.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean),
+          nodes: [this.getTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean),
         })
       }
 
@@ -241,7 +231,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
         withParentheses: true,
         nodes: schema.anyOf
           .map((item) => {
-            return item && this.#getBaseTypeFromSchema(item as OasTypes.SchemaObject)
+            return item && this.getTypeFromSchema(item as OasTypes.SchemaObject)
           })
           .filter((item) => {
             return item && item !== factory.keywordTypeNodes.any
@@ -250,7 +240,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
 
       if (schemaWithoutAnyOf.properties) {
         return factory.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAnyOf, baseName), union].filter(Boolean),
+          nodes: [this.getTypeFromSchema(schemaWithoutAnyOf, baseName), union].filter(Boolean),
         })
       }
 
@@ -264,7 +254,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
         withParentheses: true,
         nodes: schema.allOf
           .map((item) => {
-            return item && this.#getBaseTypeFromSchema(item as OasTypes.SchemaObject)
+            return item && this.getTypeFromSchema(item as OasTypes.SchemaObject)
           })
           .filter((item) => {
             return item && item !== factory.keywordTypeNodes.any
@@ -273,7 +263,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
 
       if (schemaWithoutAllOf.properties) {
         return factory.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean),
+          nodes: [this.getTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean),
         })
       }
 
@@ -296,13 +286,13 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
 
       this.extraNodes.push(
         ...factory.createEnumDeclaration({
-          name: camelCase(enumName, this.#caseOptions),
-          typeName: this.options.resolveName({ name: enumName }),
+          name: transformers.camelCase(enumName),
+          typeName: this.context.pluginManager.resolveName({ name: enumName, pluginKey, type: 'type' }),
           enums,
           type: this.options.enumType,
         }),
       )
-      return factory.createTypeReferenceNode(this.options.resolveName({ name: enumName }), undefined)
+      return factory.createTypeReferenceNode(this.context.pluginManager.resolveName({ name: enumName, pluginKey, type: 'type' }), undefined)
     }
 
     if (schema.enum) {
@@ -315,7 +305,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
 
     if ('items' in schema) {
       // items -> array
-      const node = this.#getTypeFromSchema(schema.items as OasTypes.SchemaObject, baseName)
+      const node = this.getTypeFromSchema(schema.items as OasTypes.SchemaObject, baseName)
       if (node) {
         return factory.createArrayTypeNode(node)
       }
@@ -332,7 +322,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
       return factory.createTupleDeclaration({
         nodes: prefixItems.map((item) => {
           // no baseType so we can fall back on an union when using enum
-          return this.#getBaseTypeFromSchema(item, undefined)
+          return this.getTypeFromSchema(item, undefined)
         }) as Array<ts.TypeNode>,
       })
     }
@@ -349,7 +339,7 @@ export class TypeGenerator extends SchemaGenerator<Options, OasTypes.SchemaObjec
 
         return factory.createUnionDeclaration({
           nodes: [
-            this.#getBaseTypeFromSchema(
+            this.getTypeFromSchema(
               {
                 ...schema,
                 type,

package/src/components/Mutation.tsx

@@ -0,0 +1,137 @@
+import transformers from '@kubb/core/transformers'
+import { print } from '@kubb/parser'
+import * as factory from '@kubb/parser/factory'
+import { File, usePlugin, usePluginManager } from '@kubb/react'
+import { useOas, useOperation, useOperationFile, useOperationName, useSchemas } from '@kubb/swagger/hooks'
+
+import { TypeBuilder } from '../TypeBuilder.ts'
+
+import type { ts } from '@kubb/parser'
+import type { Operation, OperationSchemas } from '@kubb/swagger'
+import type { ReactNode } from 'react'
+import type { FileMeta, PluginOptions } from '../types.ts'
+import type { KubbFile } from '@kubb/core'
+
+type Props = {
+  builder: TypeBuilder
+}
+
+function printCombinedSchema(name: string, operation: Operation, schemas: OperationSchemas): string {
+  const properties: Record<string, ts.TypeNode> = {
+    'response': factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.response.name),
+      undefined,
+    ),
+  }
+
+  if (schemas.request) {
+    properties['request'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.request.name),
+      undefined,
+    )
+  }
+
+  if (schemas.pathParams) {
+    properties['pathParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.pathParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.queryParams) {
+    properties['queryParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.queryParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.headerParams) {
+    properties['headerParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.headerParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.errors) {
+    properties['errors'] = factory.createUnionDeclaration({
+      nodes: schemas.errors.map(error => {
+        return factory.createTypeReferenceNode(
+          factory.createIdentifier(error.name),
+          undefined,
+        )
+      }),
+    })!
+  }
+
+  const namespaceNode = factory.createNamespaceDeclaration({
+    name: operation.method === 'get' ? `${name}Query` : `${name}Mutation`,
+    statements: Object.keys(properties).map(key => {
+      const type = properties[key]
+      if (!type) {
+        return undefined
+      }
+      return factory.createTypeAliasDeclaration({
+        modifiers: [factory.modifiers.export],
+        name: transformers.pascalCase(key),
+        type,
+      })
+    }).filter(Boolean),
+  })
+
+  return print(namespaceNode)
+}
+
+export function Mutation({
+  builder,
+}: Props): ReactNode {
+  const { source } = builder.build()
+
+  return (
+    <>
+      {source}
+    </>
+  )
+}
+
+type FileProps = {
+  mode: KubbFile.Mode
+}
+
+Mutation.File = function({ mode }: FileProps): ReactNode {
+  const { options } = usePlugin<PluginOptions>()
+
+  const schemas = useSchemas()
+  const pluginManager = usePluginManager()
+  const oas = useOas()
+  const file = useOperationFile()
+  const factoryName = useOperationName({ type: 'type' })
+  const operation = useOperation()
+
+  const builder = new TypeBuilder(options, { oas, pluginManager })
+    .add(schemas.pathParams)
+    .add(schemas.queryParams)
+    .add(schemas.headerParams)
+    .add(schemas.response)
+    .add(schemas.request)
+    .add(schemas.errors)
+
+  const { source, imports } = builder.build()
+
+  return (
+    <>
+      <File<FileMeta>
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+      >
+        {mode === 'directory' && imports.map((item, index) => {
+          return <File.Import key={index} root={file.path} {...item} />
+        })}
+        <File.Source>
+          {source}
+          {printCombinedSchema(factoryName, operation, schemas)}
+        </File.Source>
+      </File>
+    </>
+  )
+}