@kubb/plugin-client 0.0.0-canary-20241104172400

package/src/plugin.ts

@@ -0,0 +1,122 @@
+import path from 'node:path'
+
+import { FileManager, type Group, PluginManager, createPlugin } from '@kubb/core'
+import { camelCase } from '@kubb/core/transformers'
+import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
+
+import type { Plugin } from '@kubb/core'
+import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
+import { pluginZodName } from '@kubb/plugin-zod'
+import { operationsGenerator } from './generators'
+import { clientGenerator } from './generators/clientGenerator.tsx'
+import { groupedClientGenerator } from './generators/groupedClientGenerator.tsx'
+import type { PluginClient } from './types.ts'
+
+export const pluginClientName = 'plugin-client' satisfies PluginClient['name']
+
+export const pluginClient = createPlugin<PluginClient>((options) => {
+  const {
+    output = { path: 'clients', barrelType: 'named' },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    transformers = {},
+    dataReturnType = 'data',
+    pathParamsType = 'inline',
+    paramsType = 'inline',
+    operations = false,
+    baseURL,
+    generators = [clientGenerator, group ? groupedClientGenerator : undefined, operations ? operationsGenerator : undefined].filter(Boolean),
+    importPath = '@kubb/plugin-client/client',
+    parser = 'client',
+  } = options
+
+  return {
+    name: pluginClientName,
+    options: {
+      output,
+      group,
+      parser,
+      dataReturnType,
+      importPath,
+      paramsType,
+      pathParamsType: paramsType === 'object' ? 'object' : pathParamsType,
+      baseURL,
+    },
+    pre: [pluginOasName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
+    resolvePath(baseName, pathMode, options) {
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
+
+      if (options?.tag && group?.type === 'tag') {
+        const groupName: Group['name'] = group?.name ? group.name : (ctx) => `${ctx.group}Controller`
+
+        return path.resolve(root, output.path, groupName({ group: camelCase(options.tag) }), baseName)
+      }
+
+      if (mode === 'single') {
+        /**
+         * 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.path)
+      }
+
+      return path.resolve(root, output.path, baseName)
+    },
+    resolveName(name, type) {
+      const resolvedName = camelCase(name, { isFile: type === 'file' })
+
+      if (type) {
+        return transformers?.name?.(resolvedName, type) || resolvedName
+      }
+
+      return resolvedName
+    },
+    async buildStart() {
+      const [swaggerPlugin]: [Plugin<SwaggerPluginOptions>] = PluginManager.getDependedPlugins<SwaggerPluginOptions>(this.plugins, [pluginOasName])
+
+      const oas = await swaggerPlugin.context.getOas()
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const baseURL = await swaggerPlugin.context.getBaseURL()
+
+      const operationGenerator = new OperationGenerator(
+        baseURL
+          ? {
+              ...this.plugin.options,
+              baseURL,
+            }
+          : this.plugin.options,
+        {
+          oas,
+          pluginManager: this.pluginManager,
+          plugin: this.plugin,
+          contentType: swaggerPlugin.context.contentType,
+          exclude,
+          include,
+          override,
+          mode,
+        },
+      )
+
+      const files = await operationGenerator.build(...generators)
+
+      await this.addFile(...files)
+
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
+        root,
+        output,
+        files: this.fileManager.files,
+        meta: {
+          pluginKey: this.plugin.key,
+        },
+        logger: this.logger,
+      })
+
+      await this.addFile(...barrelFiles)
+    },
+  }
+})

package/src/types.ts

@@ -0,0 +1,93 @@
+import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+
+import type { Exclude, Generator, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
+
+export type Options = {
+  /**
+   * Specify the export location for the files and define the behavior of the output
+   * @default { path: 'clients', barrelType: 'named' }
+   */
+  output?: Output
+  /**
+   * Group the clients based on the provided name.
+   */
+  group?: Group
+  /**
+   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   */
+  exclude?: Array<Exclude>
+  /**
+   * Array containing include parameters to include tags/operations/methods/paths.
+   */
+  include?: Array<Include>
+  /**
+   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   */
+  override?: Array<Override<ResolvedOptions>>
+  /**
+   * Create `operations.ts` file with all operations grouped by methods.
+   * @default false
+   */
+  operations?: boolean
+  /**
+   * Path to the client import path that will be used to do the API calls.
+   * It will be used as `import client from '${client.importPath}'`.
+   * It allows both relative and absolute path but be aware that we will not change the path.
+   * @default '@kubb/plugin-client/client'
+   */
+  importPath?: string
+  /**
+   * Allows you to set a custom base url for all generated calls.
+   */
+  baseURL?: string
+  /**
+   * ReturnType that will be used when calling the client.
+   * - 'data' will return ResponseConfig[data].
+   * - 'full' will return ResponseConfig.
+   * @default 'data'
+   */
+  dataReturnType?: 'data' | 'full'
+  /**
+   * How to pass your params
+   * - 'object' will return the params and pathParams as an object.
+   * - 'inline' will return the params as comma separated params.
+   * @default 'inline'
+   */
+  paramsType?: 'object' | 'inline'
+  /**
+   * How to pass your pathParams.
+   * - 'object' will return the pathParams as an object.
+   * - 'inline' will return the pathParams as comma separated params.
+   * @default 'inline'
+   */
+  pathParamsType?: 'object' | 'inline'
+  /**
+   * Which parser can be used before returning the data
+   * - 'zod'  will use `@kubb/plugin-zod` to parse the data.
+   * @default 'client'
+   */
+  parser?: 'client' | 'zod'
+  transformers?: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
+  }
+  /**
+   * Define some generators next to the client generators
+   */
+  generators?: Array<Generator<PluginClient>>
+}
+
+type ResolvedOptions = {
+  output: Output
+  group?: Options['group']
+  baseURL: string | undefined
+  parser: NonNullable<Options['parser']>
+  importPath: NonNullable<Options['importPath']>
+  dataReturnType: NonNullable<Options['dataReturnType']>
+  pathParamsType: NonNullable<Options['pathParamsType']>
+  paramsType: NonNullable<Options['paramsType']>
+}
+
+export type PluginClient = PluginFactoryOptions<'plugin-client', Options, ResolvedOptions, never, ResolvePathOptions>