@kubb/swagger-ts 2.0.0-alpha.9 → 2.0.0-beta.10

package/src/oas/security.ts

@@ -0,0 +1,158 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/ban-types */
+
+import type { Call, Objects, Tuples } from 'hotscript'
+
+namespace Checks {
+  export type Security = { security: { [key: string]: any }[] }
+
+  export namespace AuthParams {
+    export type Basic =
+      | {
+        type: 'http'
+        scheme: 'basic'
+      }
+      | { type: 'basic' }
+    export type Bearer =
+      | {
+        type: 'http'
+        scheme: 'bearer'
+      }
+      | { type: 'bearer' }
+
+    export type OAuth2 = {
+      type: 'oauth2'
+    }
+    export type ApiKey = {
+      type: 'apiKey'
+      in: 'header'
+    }
+  }
+
+  export namespace AuthName {
+    export type Basic = `basic${string}`
+    export type Bearer = `bearer${string}`
+    export type OAuth2 = `oauth${string}`
+  }
+}
+
+type SecuritySchemeName<T extends Checks.Security> = Call<
+  Tuples.Map<Objects.Keys>,
+  T['security']
+>[number]
+
+namespace AuthParams {
+  export type Basic<TSecurityScheme> = TSecurityScheme extends Checks.AuthParams.Basic ? {
+      headers: {
+        /**
+         * `Authorization` header is required for basic authentication
+         * @see https://en.wikipedia.org/wiki/Basic_access_authentication
+         *
+         * It contains the word `Basic` followed by a space and a base64-encoded string `username:password`
+         *
+         * @example
+         * ```
+         * Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
+         * ```
+         */
+        Authorization: `Basic ${string}`
+      }
+    }
+    : {}
+
+  export type Bearer<TSecurityScheme> = TSecurityScheme extends Checks.AuthParams.Bearer ? {
+      /**
+       * `Authorization` header is required for bearer authentication
+       * @see https://swagger.io/docs/specification/authentication/bearer-authentication/
+       */
+      headers: {
+        /**
+         * It contains the word `Bearer` followed by a space and the token
+         *
+         * @example
+         * ```
+         * Authorization: Bearer {token}
+         * ```
+         */
+        Authorization: `Bearer ${string}`
+      }
+    }
+    : {}
+
+  export type ApiKey<TSecurityScheme> = TSecurityScheme extends Checks.AuthParams.ApiKey & { name: infer TApiKeyHeaderName } ? {
+      headers: {
+        /**
+         * Header required for API key authentication
+         */
+        [THeaderName in TApiKeyHeaderName extends string ? TApiKeyHeaderName : never]: string
+      }
+    }
+    : TSecurityScheme extends {
+      type: 'apiKey'
+      in: 'query'
+      name: infer TApiKeyQueryName
+    } ? {
+        query: {
+          /**
+           * Query parameter required for API key authentication
+           */
+          [TQueryName in TApiKeyQueryName extends string ? TApiKeyQueryName : never]: string
+        }
+      }
+    : {}
+
+  export type OAuth2<TSecurityScheme> = TSecurityScheme extends Checks.AuthParams.OAuth2 ? {
+      /**
+       * `Authorization` header is required for OAuth2.
+       */
+      headers: {
+        /**
+         * The access token string as issued by the authorization server.
+         * @example `Authorization: Bearer <access_token>`
+         */
+        Authorization: `Bearer ${string}`
+      }
+    }
+    : {}
+}
+
+type OASSecurityParams<TSecurityScheme> =
+  & AuthParams.Basic<TSecurityScheme>
+  & AuthParams.Bearer<TSecurityScheme>
+  & AuthParams.ApiKey<TSecurityScheme>
+  & AuthParams.OAuth2<TSecurityScheme>
+
+export type SecurityParamsBySecurityRef<TOAS, TSecurityObj> = TSecurityObj extends Checks.Security ? TOAS extends
+    | {
+      components: {
+        securitySchemes: {
+          [
+            TSecuritySchemeNameKey in SecuritySchemeName<TSecurityObj> extends string ? SecuritySchemeName<TSecurityObj>
+              : never
+          ]: infer TSecurityScheme
+        }
+      }
+    }
+    | {
+      securityDefinitions: {
+        [
+          TSecuritySchemeNameKey in SecuritySchemeName<TSecurityObj> extends string ? SecuritySchemeName<TSecurityObj>
+            : never
+        ]: infer TSecurityScheme
+      }
+    } ? OASSecurityParams<TSecurityScheme>
+    // OAS may have a bad reference to a security scheme
+    // So we can assume it
+  : SecuritySchemeName<TSecurityObj> extends Checks.AuthName.Basic ? AuthParams.Basic<{
+      type: 'http'
+      scheme: 'basic'
+    }>
+  : SecuritySchemeName<TSecurityObj> extends Checks.AuthName.Bearer ? AuthParams.Bearer<{
+      type: 'http'
+      scheme: 'bearer'
+    }>
+  : SecuritySchemeName<TSecurityObj> extends Checks.AuthName.OAuth2 ? AuthParams.OAuth2<{
+      type: 'oauth2'
+    }>
+  : {}
+  : {}

package/src/plugin.ts

@@ -1,24 +1,22 @@
 import path from 'node:path'
 
 import { createPlugin, FileManager, PluginManager } from '@kubb/core'
-import { getRelativePath, renderTemplate } from '@kubb/core/utils'
+import { camelCase, pascalCase } from '@kubb/core/transformers'
+import { renderTemplate } from '@kubb/core/utils'
 import { pluginName as swaggerPluginName } from '@kubb/swagger'
 
-import { camelCase, camelCaseTransformMerge, pascalCase, pascalCaseTransformMerge } from 'change-case'
-
-import { TypeBuilder } from './builders/index.ts'
-import { OperationGenerator } from './generators/index.ts'
+import { OperationGenerator } from './OperationGenerator.tsx'
+import { TypeBuilder } from './TypeBuilder.ts'
 
 import type { KubbFile, KubbPlugin } from '@kubb/core'
-import type { OpenAPIV3, PluginOptions as SwaggerPluginOptions } from '@kubb/swagger'
+import type { OasTypes, PluginOptions as SwaggerPluginOptions } from '@kubb/swagger'
 import type { PluginOptions } from './types.ts'
-
 export const pluginName = 'swagger-ts' satisfies PluginOptions['name']
-export const pluginKey: PluginOptions['key'] = ['schema', pluginName] satisfies PluginOptions['key']
+export const pluginKey: PluginOptions['key'] = [pluginName] satisfies PluginOptions['key']
 
 export const definePlugin = createPlugin<PluginOptions>((options) => {
   const {
-    output = 'types',
+    output = { path: 'types' },
     group,
     exclude = [],
     include,
@@ -27,42 +25,44 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
     dateType = 'string',
     optionalType = 'questionToken',
     transformers = {},
-    exportAs,
+    oasType = false,
   } = options
-  const template = group?.output ? group.output : `${output}/{{tag}}Controller`
-  let pluginsOptions: [KubbPlugin<SwaggerPluginOptions>]
+  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
 
   return {
     name: pluginName,
-    options,
-    kind: 'schema',
-    validate(plugins) {
-      pluginsOptions = PluginManager.getDependedPlugins<SwaggerPluginOptions>(plugins, [swaggerPluginName])
-
-      return true
+    options: {
+      transformers,
+      dateType,
+      enumType,
+      optionalType,
+      oasType,
+      // keep the used enumnames between TypeBuilder and OperationGenerator per plugin(pluginKey)
+      usedEnumNames: {},
     },
+    pre: [swaggerPluginName],
     resolvePath(baseName, directory, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output))
+      const mode = FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
          * 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)
+        return path.resolve(root, output.path)
       }
 
       if (options?.tag && group?.type === 'tag') {
-        const tag = camelCase(options.tag, { delimiter: '', transform: camelCaseTransformMerge })
+        const tag = camelCase(options.tag)
 
         return path.resolve(root, renderTemplate(template, { tag }), baseName)
       }
 
-      return path.resolve(root, output, baseName)
+      return path.resolve(root, output.path, baseName)
     },
     resolveName(name, type) {
-      const resolvedName = pascalCase(name, { delimiter: '', stripRegexp: /[^A-Z0-9$]/gi, transform: pascalCaseTransformMerge })
+      const resolvedName = pascalCase(name)
 
       if (type) {
         return transformers?.name?.(resolvedName, type) || resolvedName
@@ -78,45 +78,24 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       return this.fileManager.write(source, writePath)
     },
     async buildStart() {
-      const [swaggerPlugin] = pluginsOptions
+      const [swaggerPlugin]: [KubbPlugin<SwaggerPluginOptions>] = PluginManager.getDependedPlugins<SwaggerPluginOptions>(this.plugins, [swaggerPluginName])
 
       const oas = await swaggerPlugin.api.getOas()
 
       const schemas = await swaggerPlugin.api.getSchemas()
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output))
-      // keep the used enumnames between TypeBuilder and OperationGenerator per plugin(pluginKey)
-      const usedEnumNames = {}
-
-      if (mode === 'directory') {
-        const builder = await new TypeBuilder({
-          usedEnumNames,
-          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
-          fileResolver: (name) => {
-            const resolvedTypeId = this.resolvePath({
-              baseName: `${name}.ts`,
-              pluginKey: this.plugin.key,
-            })
-
-            const root = this.resolvePath({ baseName: ``, pluginKey: this.plugin.key })
+      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const builder = new TypeBuilder(this.plugin.options, { oas, pluginManager: this.pluginManager })
 
-            return getRelativePath(root, resolvedTypeId)
-          },
-          withJSDocs: true,
-          enumType,
-          dateType,
-          optionalType,
-        }).configure()
-        Object.entries(schemas).forEach(([name, schema]: [string, OpenAPIV3.SchemaObject]) => {
-          // generate and pass through new code back to the core so it can be write to that file
-          return builder.add({
-            schema,
-            name,
-          })
-        })
+      builder.add(
+        Object.entries(schemas).map(([name, schema]: [string, OasTypes.SchemaObject]) => ({ name, schema })),
+      )
 
-        const mapFolderSchema = async ([name]: [string, OpenAPIV3.SchemaObject]) => {
-          const resolvedPath = this.resolvePath({ baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`, pluginKey: this.plugin.key })
+      if (mode === 'directory') {
+        const mapFolderSchema = async ([name]: [string, OasTypes.SchemaObject]) => {
+          const baseName = `${this.resolveName({ name, pluginKey: this.plugin.key, type: 'file' })}.ts` as const
+          const resolvedPath = this.resolvePath({ baseName, pluginKey: this.plugin.key })
+          const { source, imports } = builder.build(name)
 
           if (!resolvedPath) {
             return null
@@ -124,8 +103,9 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
 
           return this.addFile({
             path: resolvedPath,
-            baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`,
-            source: builder.print(name),
+            baseName,
+            source,
+            imports: imports.map(item => ({ ...item, root: resolvedPath })),
             meta: {
               pluginKey: this.plugin.key,
             },
@@ -138,47 +118,26 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       }
 
       if (mode === 'file') {
-        // outside the loop because we need to add files to just one instance to have the correct sorting, see refsSorter
-        const builder = new TypeBuilder({
-          usedEnumNames,
-          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
-          withJSDocs: true,
-          enumType,
-          dateType,
-          optionalType,
-        }).configure()
-        Object.entries(schemas).forEach(([name, schema]: [string, OpenAPIV3.SchemaObject]) => {
-          // generate and pass through new code back to the core so it can be write to that file
-          return builder.add({
-            schema,
-            name,
-          })
-        })
-
         const resolvedPath = this.resolvePath({ baseName: '', pluginKey: this.plugin.key })
+        const { source } = builder.build()
+
         if (!resolvedPath) {
           return
         }
 
         await this.addFile({
           path: resolvedPath,
-          baseName: output as KubbFile.BaseName,
-          source: builder.print(),
+          baseName: output.path as KubbFile.BaseName,
+          source,
+          imports: [],
           meta: {
             pluginKey: this.plugin.key,
           },
-          validate: false,
         })
       }
 
       const operationGenerator = new OperationGenerator(
-        {
-          mode,
-          enumType,
-          dateType,
-          optionalType,
-          usedEnumNames,
-        },
+        this.plugin.options,
         {
           oas,
           pluginManager: this.pluginManager,
@@ -187,6 +146,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
           exclude,
           include,
           override,
+          mode,
         },
       )
 
@@ -199,31 +159,18 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       }
 
       const root = path.resolve(this.config.root, this.config.output.path)
+      const { exportType = 'barrel' } = output
 
-      await this.fileManager.addIndexes({
-        root,
-        extName: '.ts',
-        meta: { pluginKey: this.plugin.key },
-        options: {
-          map: (file) => {
-            return {
-              ...file,
-              exports: file.exports?.map((item) => {
-                if (exportAs) {
-                  return {
-                    ...item,
-                    name: exportAs,
-                    asAlias: !!exportAs,
-                  }
-                }
-                return item
-              }),
-            }
-          },
+      if (exportType === 'barrel') {
+        await this.fileManager.addIndexes({
+          root,
           output,
-          isTypeOnly: true,
-        },
-      })
+          meta: { pluginKey: this.plugin.key },
+          options: {
+            isTypeOnly: true,
+          },
+        })
+      }
     },
   }
 })

package/src/types.ts

@@ -1,13 +1,28 @@
-import type { KubbPlugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { KubbFile, KubbPlugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 
 export type Options = {
-  /**
-   * Relative path to save the TypeScript types.
-   * When output is a file it will save all models inside that file else it will create a file per schema item.
-   * @default 'types'
-   */
-  output?: string
+  output?: {
+    /**
+     * Relative path to save the TypeScript types.
+     * When output is a file it will save all models inside that file else it will create a file per schema item.
+     * @default 'types'
+     */
+    path: string
+    /**
+     * Name to be used for the `export * as {{exportAs}} from './'`
+     */
+    exportAs?: string
+    /**
+     * Add an extension to the generated imports and exports, default it will not use an extension
+     */
+    extName?: KubbFile.Extname
+    /**
+     * Define what needs to exported, here you can also disable the export of barrel files
+     * @default `'barrel'`
+     */
+    exportType?: 'barrel' | false
+  }
   /**
    * Group the TypeScript types based on the provided name.
    */
@@ -25,10 +40,6 @@ export type Options = {
      */
     output?: string
   }
-  /**
-   * Name to be used for the `export * as {{exportAs}} from './`
-   */
-  exportAs?: string
   /**
    * Array containing exclude paramaters to exclude/skip tags/operations/methods/paths.
    */
@@ -65,6 +76,19 @@ export type Options = {
      */
     name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
   }
+  /**
+   * Export an Oas object as Oas type with `import type { Infer } from '@kubb/swagger-ts/oas'`
+   */
+  oasType?: 'infer' | false
+}
+
+type ResolvedOptions = {
+  enumType: NonNullable<Options['enumType']>
+  dateType: NonNullable<Options['dateType']>
+  optionalType: NonNullable<Options['optionalType']>
+  transformers: NonNullable<Options['transformers']>
+  oasType: NonNullable<Options['oasType']>
+  usedEnumNames: Record<string, number>
 }
 
 export type FileMeta = {
@@ -73,10 +97,14 @@ export type FileMeta = {
   tag?: string
 }
 
-export type PluginOptions = PluginFactoryOptions<'swagger-ts', 'schema', Options, Options, never, ResolvePathOptions>
+type AppMeta = SwaggerAppMeta
+
+export type PluginOptions = PluginFactoryOptions<'swagger-ts', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
 
 declare module '@kubb/core' {
   export interface _Register {
     ['@kubb/swagger-ts']: PluginOptions
   }
 }
+// external packages
+export * as Oas from './oas/index.ts'

package/src/builders/TypeBuilder.ts

@@ -1,93 +0,0 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-import { transformers } from '@kubb/core/utils'
-import { print } from '@kubb/parser'
-import * as factory from '@kubb/parser/factory'
-import { ImportsGenerator, OasBuilder } from '@kubb/swagger'
-import { refsSorter } from '@kubb/swagger/utils'
-
-import { TypeGenerator } from '../generators/TypeGenerator.ts'
-
-import type { PluginContext } from '@kubb/core'
-import type { FileResolver } from '@kubb/swagger'
-
-type Options = {
-  usedEnumNames: Record<string, number>
-
-  resolveName: PluginContext['resolveName']
-  fileResolver?: FileResolver
-  withJSDocs?: boolean
-  withImports?: boolean
-  enumType: 'enum' | 'asConst' | 'asPascalConst'
-  dateType: 'string' | 'date'
-  optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined'
-}
-
-export class TypeBuilder extends OasBuilder<Options, never> {
-  configure(options?: Options) {
-    if (options) {
-      this.options = options
-    }
-
-    if (this.options.fileResolver) {
-      this.options.withImports = true
-    }
-
-    return this
-  }
-
-  print(name?: string): string {
-    const codes: string[] = []
-
-    const generated = this.items
-      .filter((operationSchema) => (name ? operationSchema.name === name : true))
-      .sort(transformers.nameSorter)
-      .map((operationSchema) => {
-        const generator = new TypeGenerator({
-          usedEnumNames: this.options.usedEnumNames,
-          withJSDocs: this.options.withJSDocs,
-          resolveName: this.options.resolveName,
-          enumType: this.options.enumType,
-          dateType: this.options.dateType,
-          optionalType: this.options.optionalType,
-        })
-        const sources = generator.build({
-          schema: operationSchema.schema,
-          baseName: operationSchema.name,
-          description: operationSchema.description,
-          keysToOmit: operationSchema.keysToOmit,
-        })
-
-        return {
-          import: {
-            refs: generator.refs,
-            name: operationSchema.name,
-          },
-          sources,
-        }
-      })
-      .sort(refsSorter)
-
-    generated.forEach((item) => {
-      codes.push(print(item.sources))
-    })
-
-    if (this.options.withImports) {
-      const importsGenerator = new ImportsGenerator({ fileResolver: this.options.fileResolver })
-      const importMeta = importsGenerator.build(generated.map((item) => item.import))
-
-      if (importMeta) {
-        const nodes = importMeta.map((item) => {
-          return factory.createImportDeclaration({
-            name: [{ propertyName: item.ref.propertyName }],
-            path: item.path,
-            isTypeOnly: true,
-          })
-        })
-
-        codes.unshift(print(nodes))
-      }
-    }
-
-    return transformers.combineCodes(codes)
-  }
-}

package/src/builders/index.ts

@@ -1 +0,0 @@
-export * from './TypeBuilder.ts'