@kubb/plugin-client 3.0.0-alpha.8 → 3.0.0-beta.1

package/src/generators/clientGenerator.tsx

@@ -0,0 +1,66 @@
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { pluginZodName } from '@kubb/plugin-zod'
+import { File, useApp } from '@kubb/react'
+import { Client } from '../components/Client'
+import type { PluginClient } from '../types'
+
+export const clientGenerator = createReactGenerator<PluginClient>({
+  name: 'client',
+  Operation({ options, operation }) {
+    const {
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginClient>()
+    const { getSchemas, getName, getFile } = useOperationManager()
+
+    const client = {
+      name: getName(operation, { type: 'function' }),
+      file: getFile(operation),
+    }
+
+    const type = {
+      file: getFile(operation, { pluginKey: [pluginTsName] }),
+      schemas: getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' }),
+    }
+
+    const zod = {
+      file: getFile(operation, { pluginKey: [pluginZodName] }),
+      schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
+    }
+
+    return (
+      <File baseName={client.file.baseName} path={client.file.path} meta={client.file.meta} banner={output?.banner} footer={output?.footer}>
+        <File.Import name={'client'} path={options.importPath} />
+        <File.Import name={['RequestConfig']} path={options.importPath} isTypeOnly />
+        {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={client.file.path} path={zod.file.path} />}
+        <File.Import
+          name={[
+            type.schemas.request?.name,
+            type.schemas.response.name,
+            type.schemas.pathParams?.name,
+            type.schemas.queryParams?.name,
+            type.schemas.headerParams?.name,
+            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
+          ].filter(Boolean)}
+          root={client.file.path}
+          path={type.file.path}
+          isTypeOnly
+        />
+
+        <Client
+          name={client.name}
+          baseURL={options.baseURL}
+          dataReturnType={options.dataReturnType}
+          pathParamsType={options.pathParamsType}
+          typeSchemas={type.schemas}
+          operation={operation}
+          parser={options.parser}
+          zodSchemas={zod.schemas}
+        />
+      </File>
+    )
+  },
+})

package/src/generators/groupedClientGenerator.tsx

@@ -0,0 +1,70 @@
+import { camelCase } from '@kubb/core/transformers'
+import type * as KubbFile from '@kubb/fs/types'
+import { pluginClientName } from '@kubb/plugin-client'
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { File, Function, useApp } from '@kubb/react'
+import type { PluginClient } from '../types'
+
+export const groupedClientGenerator = createReactGenerator<PluginClient>({
+  name: 'groupedClient',
+  Operations({ operations }) {
+    const {
+      pluginManager,
+      plugin: { options },
+    } = useApp<PluginClient>()
+    const { getName, getFile } = useOperationManager()
+
+    const controllers = operations.reduce(
+      (acc, operation) => {
+        if (options.group?.type === 'tag') {
+          const tag = operation.getTags().at(0)?.name
+          const name = tag ? options.group?.name?.({ group: camelCase(tag) }) : undefined
+
+          if (!tag || !name) {
+            return acc
+          }
+
+          const file = pluginManager.getFile({
+            name,
+            extname: '.ts',
+            pluginKey: [pluginClientName],
+            options: { tag },
+          })
+
+          const client = {
+            name: getName(operation, { type: 'function' }),
+            file: getFile(operation),
+          }
+
+          const previousFile = acc.find((item) => item.file.path === file.path)
+
+          if (previousFile) {
+            previousFile.clients.push(client)
+          } else {
+            acc.push({ name, file, clients: [client] })
+          }
+        }
+
+        return acc
+      },
+      [] as Array<{ name: string; file: KubbFile.File; clients: Array<{ name: string; file: KubbFile.File }> }>,
+    )
+
+    return controllers.map(({ name, file, clients }) => {
+      return (
+        <File key={file.path} baseName={file.baseName} path={file.path} meta={file.meta} banner={options.output?.banner} footer={options.output?.footer}>
+          {clients.map((client) => (
+            <File.Import key={client.name} name={[client.name]} root={file.path} path={client.file.path} />
+          ))}
+
+          <File.Source name={name} isExportable isIndexable>
+            <Function export name={name}>
+              {`return { ${clients.map((client) => client.name).join(', ')} }`}
+            </Function>
+          </File.Source>
+        </File>
+      )
+    })
+  },
+})

package/src/generators/index.ts

@@ -0,0 +1,3 @@
+export { clientGenerator } from './clientGenerator.tsx'
+export { operationsGenerator } from './operationsGenerator.tsx'
+export { groupedClientGenerator } from './groupedClientGenerator.tsx'

package/src/generators/operationsGenerator.tsx

@@ -0,0 +1,26 @@
+import { pluginClientName } from '@kubb/plugin-client'
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { File, useApp } from '@kubb/react'
+import { Operations } from '../components/Operations'
+import type { PluginClient } from '../types'
+
+export const operationsGenerator = createReactGenerator<PluginClient>({
+  name: 'client',
+  Operations({ operations }) {
+    const {
+      pluginManager,
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginClient>()
+
+    const name = 'operations'
+    const file = pluginManager.getFile({ name, extname: '.ts', pluginKey: [pluginClientName] })
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={output?.banner} footer={output?.footer}>
+        <Operations name={name} operations={operations} />
+      </File>
+    )
+  },
+})

package/src/plugin.ts

@@ -1,22 +1,22 @@
 import path from 'node:path'
 
-import { FileManager, PluginManager, createPlugin } from '@kubb/core'
+import { FileManager, type Group, PluginManager, createPlugin } from '@kubb/core'
 import { camelCase } from '@kubb/core/transformers'
-import { renderTemplate } from '@kubb/core/utils'
 import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
 
-import { clientParser } from './OperationGenerator.tsx'
-import { Client, Operations } from './components/index.ts'
-
 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' },
+    output = { path: 'clients', barrelType: 'named' },
     group,
     exclude = [],
     include,
@@ -24,38 +24,34 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
     transformers = {},
     dataReturnType = 'data',
     pathParamsType = 'inline',
-    templates,
+    operations = false,
+    generators = [clientGenerator, group ? groupedClientGenerator : undefined, operations ? operationsGenerator : undefined].filter(Boolean),
+    importPath = '@kubb/plugin-client/client',
+    parser = 'client',
   } = options
 
-  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
-
   return {
     name: pluginClientName,
-    output: {
-      exportType: 'barrelNamed',
-      ...output,
-    },
     options: {
-      extName: output.extName,
+      output,
+      group,
+      parser,
       dataReturnType,
-      client: {
-        importPath: '@kubb/plugin-client/client',
-        methods: ['get', 'post', 'delete', 'put'],
-        ...options.client,
-      },
+      importPath,
       pathParamsType,
-      templates: {
-        operations: Operations.templates,
-        client: Client.templates,
-        ...templates,
-      },
       baseURL: undefined,
     },
-    pre: [pluginOasName],
+    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
@@ -64,12 +60,6 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
         return path.resolve(root, output.path)
       }
 
-      if (options?.tag && group?.type === 'tag') {
-        const tag = camelCase(options.tag)
-
-        return path.resolve(root, renderTemplate(template, { tag }), baseName)
-      }
-
       return path.resolve(root, output.path, baseName)
     },
     resolveName(name, type) {
@@ -106,23 +96,22 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
         },
       )
 
-      const files = await operationGenerator.build(clientParser)
+      const files = await operationGenerator.build(...generators)
 
       await this.addFile(...files)
 
-      if (this.config.output.exportType) {
-        const barrelFiles = await this.fileManager.getBarrelFiles({
-          root,
-          output,
-          files: this.fileManager.files,
-          meta: {
-            pluginKey: this.plugin.key,
-          },
-          logger: this.logger,
-        })
-
-        await this.addFile(...barrelFiles)
-      }
+      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

@@ -1,58 +1,17 @@
-import type { Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type * as KubbFile from '@kubb/fs/types'
+import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 
-import type { HttpMethod } from '@kubb/oas'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { Client, Operations } from './components/index.ts'
-
-type Templates = {
-  operations?: typeof Operations.templates | false
-  client?: typeof Client.templates | false
-}
+import type { Exclude, Generator, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
 
 export type Options = {
-  output?: {
-    /**
-     * Output to save the clients.
-     * @default `"clients"``
-     */
-    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 `'barrelNamed'`
-     */
-    exportType?: 'barrel' | 'barrelNamed' | false
-  }
+  /**
+   * 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?: {
-    /**
-     * Tag will group based on the operation tag inside the Swagger file
-     */
-    type: 'tag'
-    /**
-     * Relative path to save the grouped clients.
-     *
-     * `{{tag}}` will be replaced by the current tagName.
-     * @example `${output}/{{tag}}Controller` => `clients/PetController`
-     * @default `${output}/{{tag}}Controller`
-     */
-    output?: string
-    /**
-     * Name to be used for the `export * as {{exportAs}} from './`
-     * @default `"{{tag}}Service"`
-     */
-    exportAs?: string
-  }
+  group?: Group
   /**
    * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
    */
@@ -65,23 +24,20 @@ export type Options = {
    * Array containing override parameters to override `options` based on tags/operations/methods/paths.
    */
   override?: Array<Override<ResolvedOptions>>
-  client?: {
-    /**
-     * 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.
-     * the path will be applied as is, so relative path should be based on the file being generated.
-     * @default '@kubb/plugin-client/client'
-     */
-    importPath?: string
-    /**
-     * Define which HttpMethods can be used for queries
-     * @default ['get', 'post', 'put', 'delete']
-     */
-    methods?: Array<HttpMethod>
-  }
   /**
-   * ReturnType that needs to be used when calling client().
+   * 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
+  /**
+   * ReturnType that will be used when calling the client.
    *
    * `Data` will return ResponseConfig[data].
    *
@@ -100,6 +56,12 @@ export type Options = {
    * @private
    */
   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.
@@ -107,23 +69,19 @@ export type Options = {
     name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
   }
   /**
-   * Make it possible to override one of the templates
+   * Define some generators next to the client generators
    */
-  templates?: Partial<Templates>
+  generators?: Array<Generator<PluginClient>>
 }
 
 type ResolvedOptions = {
-  extName: KubbFile.Extname | undefined
+  output: Output
+  group?: Options['group']
   baseURL: string | undefined
-  client: Required<NonNullable<Options['client']>>
+  parser: NonNullable<Options['parser']>
+  importPath: NonNullable<Options['importPath']>
   dataReturnType: NonNullable<Options['dataReturnType']>
   pathParamsType: NonNullable<Options['pathParamsType']>
-  templates: NonNullable<Templates>
-}
-
-export type FileMeta = {
-  pluginKey?: Plugin['key']
-  tag?: string
 }
 
 export type PluginClient = PluginFactoryOptions<'plugin-client', Options, ResolvedOptions, never, ResolvePathOptions>

package/dist/chunk-E562RKCC.js

@@ -1,199 +0,0 @@
-// src/components/Client.tsx
-import { URLPath } from "@kubb/core/utils";
-import { File, Function, useApp } from "@kubb/react";
-import { pluginTsName } from "@kubb/plugin-ts";
-import { useOperation, useOperationManager } from "@kubb/plugin-oas/hooks";
-import { getComments, getPathParams } from "@kubb/plugin-oas/utils";
-import { isOptional } from "@kubb/oas";
-import { jsx, jsxs } from "@kubb/react/jsx-runtime";
-function Template({ name, generics, returnType, params, JSDoc, client }) {
-  const isFormData = client.contentType === "multipart/form-data";
-  const headers = [
-    client.contentType !== "application/json" ? `'Content-Type': '${client.contentType}'` : void 0,
-    client.withHeaders ? "...headers" : void 0
-  ].filter(Boolean).join(", ");
-  const clientParams = {
-    data: {
-      mode: "object",
-      children: {
-        method: {
-          type: "string",
-          value: JSON.stringify(client.method)
-        },
-        url: {
-          type: "string",
-          value: client.path.template
-        },
-        baseURL: client.baseURL ? {
-          type: "string",
-          value: JSON.stringify(client.baseURL)
-        } : void 0,
-        params: client.withQueryParams ? {
-          type: "any"
-        } : void 0,
-        data: client.withData ? {
-          type: "any",
-          value: isFormData ? "formData" : void 0
-        } : void 0,
-        headers: headers.length ? {
-          type: "any",
-          value: headers.length ? `{ ${headers}, ...options.headers }` : void 0
-        } : void 0,
-        options: {
-          type: "any",
-          mode: "inlineSpread"
-        }
-      }
-    }
-  };
-  const formData = isFormData ? `
-   const formData = new FormData()
-   if(data) {
-    Object.keys(data).forEach((key) => {
-      const value = data[key];
-      if (typeof key === "string" && (typeof value === "string" || value instanceof Blob)) {
-        formData.append(key, value);
-      }
-    })
-   }
-  ` : void 0;
-  return /* @__PURE__ */ jsx(File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxs(Function, { name, async: true, export: true, generics, returnType, params, JSDoc, children: [
-    formData || "",
-    /* @__PURE__ */ jsx(Function.Call, { name: "res", to: /* @__PURE__ */ jsx(Function, { name: "client", async: true, generics: client.generics, params: clientParams }) }),
-    /* @__PURE__ */ jsx(Function.Return, { children: client.dataReturnType === "data" ? "res.data" : "res" })
-  ] }) });
-}
-function RootTemplate({ children }) {
-  const {
-    plugin: {
-      options: {
-        client: { importPath }
-      }
-    }
-  } = useApp();
-  const { getSchemas, getFile } = useOperationManager();
-  const operation = useOperation();
-  const file = getFile(operation);
-  const fileType = getFile(operation, { pluginKey: [pluginTsName] });
-  const schemas = getSchemas(operation, { pluginKey: [pluginTsName], type: "type" });
-  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    /* @__PURE__ */ jsx(File.Import, { name: "client", path: importPath }),
-    /* @__PURE__ */ jsx(File.Import, { name: ["ResponseConfig"], path: importPath, isTypeOnly: true }),
-    /* @__PURE__ */ jsx(
-      File.Import,
-      {
-        name: [schemas.request?.name, schemas.response.name, schemas.pathParams?.name, schemas.queryParams?.name, schemas.headerParams?.name].filter(Boolean),
-        root: file.path,
-        path: fileType.path,
-        isTypeOnly: true
-      }
-    ),
-    children
-  ] });
-}
-var defaultTemplates = { default: Template, root: RootTemplate };
-function Client({ baseURL, Template: Template3 = defaultTemplates.default }) {
-  const {
-    plugin: {
-      options: { client, dataReturnType, pathParamsType }
-    }
-  } = useApp();
-  const { getSchemas, getName } = useOperationManager();
-  const operation = useOperation();
-  const contentType = operation.getContentType();
-  const name = getName(operation, { type: "function" });
-  const schemas = getSchemas(operation, { pluginKey: [pluginTsName], type: "type" });
-  return /* @__PURE__ */ jsx(
-    Template3,
-    {
-      name,
-      params: {
-        pathParams: {
-          mode: pathParamsType === "object" ? "object" : "inlineSpread",
-          children: getPathParams(schemas.pathParams, { typed: true })
-        },
-        data: schemas.request?.name ? {
-          type: schemas.request?.name,
-          optional: isOptional(schemas.request?.schema)
-        } : void 0,
-        params: schemas.queryParams?.name ? {
-          type: schemas.queryParams?.name,
-          optional: isOptional(schemas.queryParams?.schema)
-        } : void 0,
-        headers: schemas.headerParams?.name ? {
-          type: schemas.headerParams?.name,
-          optional: isOptional(schemas.headerParams?.schema)
-        } : void 0,
-        options: {
-          type: "Partial<Parameters<typeof client>[0]>",
-          default: "{}"
-        }
-      },
-      returnType: dataReturnType === "data" ? `ResponseConfig<${schemas.response.name}>["data"]` : `ResponseConfig<${schemas.response.name}>`,
-      JSDoc: {
-        comments: getComments(operation)
-      },
-      client: {
-        // only set baseURL from serverIndex(swagger) when no custom client(default) is used
-        baseURL: client.importPath === "@kubb/plugin-client/client" ? baseURL : void 0,
-        generics: [schemas.response.name, schemas.request?.name].filter(Boolean),
-        dataReturnType,
-        withQueryParams: !!schemas.queryParams?.name,
-        withData: !!schemas.request?.name,
-        withHeaders: !!schemas.headerParams?.name,
-        method: operation.method,
-        path: new URLPath(operation.path),
-        contentType
-      }
-    }
-  );
-}
-Client.File = function({ baseURL, ...props }) {
-  const templates = { ...defaultTemplates, ...props.templates };
-  const Template3 = templates.default;
-  const RootTemplate3 = templates.root;
-  return /* @__PURE__ */ jsx(RootTemplate3, { children: /* @__PURE__ */ jsx(Client, { baseURL, Template: Template3 }) });
-};
-Client.templates = defaultTemplates;
-
-// src/components/Operations.tsx
-import { URLPath as URLPath2 } from "@kubb/core/utils";
-import { useOperations } from "@kubb/plugin-oas/hooks";
-import { Const, File as File2, useApp as useApp2 } from "@kubb/react";
-import { jsx as jsx2 } from "@kubb/react/jsx-runtime";
-function Template2({ name, operations }) {
-  const operationsObject = {};
-  operations.forEach((operation) => {
-    operationsObject[operation.getOperationId()] = {
-      path: new URLPath2(operation.path).URL,
-      method: operation.method
-    };
-  });
-  return /* @__PURE__ */ jsx2(File2.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx2(Const, { name, export: true, asConst: true, children: JSON.stringify(operationsObject, void 0, 2) }) });
-}
-function RootTemplate2({ children }) {
-  const {
-    pluginManager,
-    plugin: { key: pluginKey }
-  } = useApp2();
-  const file = pluginManager.getFile({ name: "operations", extName: ".ts", pluginKey });
-  return /* @__PURE__ */ jsx2(File2, { baseName: file.baseName, path: file.path, meta: file.meta, children });
-}
-var defaultTemplates2 = { default: Template2, root: RootTemplate2 };
-function Operations({ baseURL, Template: Template3 = defaultTemplates2.default }) {
-  const operations = useOperations();
-  return /* @__PURE__ */ jsx2(Template3, { baseURL, name: "operations", operations });
-}
-Operations.File = function({ baseURL, ...props }) {
-  const templates = { ...defaultTemplates2, ...props.templates };
-  const Template3 = templates.default;
-  const RootTemplate3 = templates.root;
-  return /* @__PURE__ */ jsx2(RootTemplate3, { children: /* @__PURE__ */ jsx2(Operations, { baseURL, Template: Template3 }) });
-};
-Operations.templates = defaultTemplates2;
-
-export {
-  Client,
-  Operations
-};
-//# sourceMappingURL=chunk-E562RKCC.js.map