@kubb/plugin-client 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/{types-xK4X9e5d.d.ts → types-DETYKDFZ.d.ts}

@@ -1,123 +1,29 @@
 import { PluginFactoryOptions, ResolveNameParams } from '@kubb/core';
 import * as KubbFile from '@kubb/fs/types';
-import { ResolvePathOptions, Exclude, Include, Override } from '@kubb/plugin-oas';
-import { URLPath } from '@kubb/core/utils';
-import { HttpMethod, Operation } from '@kubb/oas';
-import { KubbNode, Params } from '@kubb/react';
-import { ComponentType, ComponentProps } from 'react';
+import { Operation, HttpMethod } from '@kubb/oas';
+import { OperationSchemas, ResolvePathOptions, Exclude, Include, Override } from '@kubb/plugin-oas';
+import { KubbNode } from '@kubb/react/types';
 
-type TemplateProps$1 = {
+type Props = {
     /**
      * Name of the function
      */
     name: string;
-    /**
-     * Parameters/options/props that need to be used
-     */
-    params: Params;
-    /**
-     * Generics that needs to be added for TypeScript
-     */
-    generics?: string;
-    /**
-     * ReturnType(see async for adding Promise type)
-     */
-    returnType?: string;
-    /**
-     * Options for JSdocs
-     */
-    JSDoc?: {
-        comments: string[];
-    };
-    client: {
-        baseURL: string | undefined;
-        generics: string | string[];
-        method: HttpMethod;
-        path: URLPath;
-        dataReturnType: PluginClient['options']['dataReturnType'];
-        withQueryParams: boolean;
-        withData: boolean;
-        withHeaders: boolean;
-        contentType: string;
-    };
-};
-declare function Template$1({ name, generics, returnType, params, JSDoc, client }: TemplateProps$1): KubbNode;
-type RootTemplateProps$1 = {
-    children?: React.ReactNode;
-};
-declare function RootTemplate$1({ children }: RootTemplateProps$1): JSX.Element;
-declare const defaultTemplates$1: {
-    readonly default: typeof Template$1;
-    readonly root: typeof RootTemplate$1;
-};
-type Templates$2 = Partial<typeof defaultTemplates$1>;
-type ClientProps = {
-    baseURL: string | undefined;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: ComponentType<ComponentProps<typeof Template$1>>;
-};
-declare function Client({ baseURL, Template }: ClientProps): KubbNode;
-declare namespace Client {
-    var File: ({ baseURL, ...props }: FileProps$1) => KubbNode;
-    var templates: {
-        readonly default: typeof Template$1;
-        readonly root: typeof RootTemplate$1;
-    };
-}
-type FileProps$1 = {
-    baseURL: string | undefined;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    templates?: Templates$2;
+    options: PluginClient['resolvedOptions'];
+    typedSchemas: OperationSchemas;
+    operation: Operation;
 };
+declare function Client({ name, options, typedSchemas, operation }: Props): KubbNode;
 
-type TemplateProps = {
-    /**
-     * Name of the function
-     */
+type OperationsProps = {
     name: string;
-    operations: Operation[];
-    baseURL: string | undefined;
-};
-declare function Template({ name, operations }: TemplateProps): KubbNode;
-type RootTemplateProps = {
-    children?: React.ReactNode;
-};
-declare function RootTemplate({ children }: RootTemplateProps): JSX.Element;
-declare const defaultTemplates: {
-    readonly default: typeof Template;
-    readonly root: typeof RootTemplate;
-};
-type Templates$1 = Partial<typeof defaultTemplates>;
-type Props = {
-    baseURL: string | undefined;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: ComponentType<ComponentProps<typeof Template>>;
-};
-declare function Operations({ baseURL, Template }: Props): KubbNode;
-declare namespace Operations {
-    var File: ({ baseURL, ...props }: FileProps) => KubbNode;
-    var templates: {
-        readonly default: typeof Template;
-        readonly root: typeof RootTemplate;
-    };
-}
-type FileProps = {
-    baseURL: string | undefined;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    templates?: Templates$1;
+    operations: Array<Operation>;
 };
+declare function Operations({ name, operations }: OperationsProps): JSX.Element;
 
 type Templates = {
-    operations?: typeof Operations.templates | false;
-    client?: typeof Client.templates | false;
+    operations?: typeof Operations | false;
+    client?: typeof Client | false;
 };
 type Options = {
     output?: {
@@ -136,7 +42,7 @@ type Options = {
         extName?: KubbFile.Extname;
         /**
          * Define what needs to exported, here you can also disable the export of barrel files
-         * @default `'barrel'`
+         * @default `'barrelNamed'`
          */
         exportType?: 'barrel' | 'barrelNamed' | false;
     };
@@ -183,6 +89,11 @@ type Options = {
          * @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().

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-client",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.10",
   "description": "Generator plugin-client",
   "keywords": [
     "typescript",
@@ -26,6 +26,11 @@
       "require": "./dist/index.cjs",
       "default": "./dist/index.cjs"
     },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs",
+      "default": "./dist/generators.cjs"
+    },
     "./components": {
       "import": "./dist/components.js",
       "require": "./dist/components.cjs",
@@ -51,6 +56,9 @@
     "*": {
       "components": [
         "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
       ]
     }
   },
@@ -64,27 +72,27 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "@kubb/core": "3.0.0-alpha.1",
-    "@kubb/fs": "3.0.0-alpha.1",
-    "@kubb/oas": "3.0.0-alpha.1",
-    "@kubb/parser-ts": "3.0.0-alpha.1",
-    "@kubb/plugin-oas": "3.0.0-alpha.1",
-    "@kubb/plugin-ts": "3.0.0-alpha.1",
-    "@kubb/react": "3.0.0-alpha.1"
+    "@kubb/core": "3.0.0-alpha.10",
+    "@kubb/fs": "3.0.0-alpha.10",
+    "@kubb/oas": "3.0.0-alpha.10",
+    "@kubb/parser-ts": "3.0.0-alpha.10",
+    "@kubb/plugin-oas": "3.0.0-alpha.10",
+    "@kubb/plugin-ts": "3.0.0-alpha.10",
+    "@kubb/react": "3.0.0-alpha.10"
   },
   "devDependencies": {
-    "@types/react": "^18.3.4",
+    "@types/react": "^18.3.5",
     "axios": "^1.7.5",
     "react": "^18.3.1",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
-    "@kubb/config-biome": "3.0.0-alpha.1",
-    "@kubb/config-ts": "3.0.0-alpha.1",
-    "@kubb/config-tsup": "3.0.0-alpha.1"
+    "@kubb/config-biome": "3.0.0-alpha.10",
+    "@kubb/config-ts": "3.0.0-alpha.10",
+    "@kubb/config-tsup": "3.0.0-alpha.10"
   },
   "peerDependencies": {
     "axios": "^1.7.2",
-    "@kubb/react": "3.0.0-alpha.1"
+    "@kubb/react": "3.0.0-alpha.10"
   },
   "peerDependenciesMeta": {
     "axios": {

package/src/components/Client.tsx

@@ -1,83 +1,85 @@
 import { URLPath } from '@kubb/core/utils'
-import { Parser, 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 type { HttpMethod } from '@kubb/oas'
-import type { KubbNode, Params } from '@kubb/react'
-import type { ComponentProps, ComponentType } from 'react'
-import type { FileMeta, PluginClient } from '../types.ts'
+import { type Operation, isOptional } from '@kubb/oas'
+import type { OperationSchemas } from '@kubb/plugin-oas'
+import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
+import { File, Function, createFunctionParams } from '@kubb/react'
+import type { KubbNode, Params } from '@kubb/react/types'
+import type { PluginClient } from '../types.ts'
 
-type TemplateProps = {
+type Props = {
   /**
    * Name of the function
    */
   name: string
-  /**
-   * Parameters/options/props that need to be used
-   */
-  params: Params
-  /**
-   * Generics that needs to be added for TypeScript
-   */
-  generics?: string
-  /**
-   * ReturnType(see async for adding Promise type)
-   */
-  returnType?: string
-  /**
-   * Options for JSdocs
-   */
-  JSDoc?: {
-    comments: string[]
-  }
-  client: {
-    baseURL: string | undefined
-    generics: string | string[]
-    method: HttpMethod
-    path: URLPath
-    dataReturnType: PluginClient['options']['dataReturnType']
-    withQueryParams: boolean
-    withData: boolean
-    withHeaders: boolean
-    contentType: string
-  }
+  options: PluginClient['resolvedOptions']
+  typedSchemas: OperationSchemas
+  operation: Operation
 }
 
-function Template({ name, generics, returnType, params, JSDoc, client }: TemplateProps): KubbNode {
-  const isFormData = client.contentType === 'multipart/form-data'
+export function Client({ name, options, typedSchemas, operation }: Props): KubbNode {
+  const contentType = operation.getContentType()
+  const baseURL = options.client.importPath === '@kubb/plugin-client/client' ? options.baseURL : undefined
+  const path = new URLPath(operation.path)
+  const isFormData = contentType === 'multipart/form-data'
   const headers = [
-    client.contentType !== 'application/json' ? `'Content-Type': '${client.contentType}'` : undefined,
-    client.withHeaders ? '...headers' : undefined,
-  ]
-    .filter(Boolean)
-    .join(', ')
-  const clientParams: Params = {
+    contentType !== 'application/json' ? `'Content-Type': '${contentType}'` : undefined,
+    typedSchemas.headerParams?.name ? '...headers' : undefined,
+  ].filter(Boolean)
+
+  const params = createFunctionParams({
+    pathParams: {
+      mode: options.pathParamsType === 'object' ? 'object' : 'inlineSpread',
+      children: getPathParams(typedSchemas.pathParams, { typed: true }),
+    },
+    data: typedSchemas.request?.name
+      ? {
+          type: typedSchemas.request?.name,
+          optional: isOptional(typedSchemas.request?.schema),
+        }
+      : undefined,
+    params: typedSchemas.queryParams?.name
+      ? {
+          type: typedSchemas.queryParams?.name,
+          optional: isOptional(typedSchemas.queryParams?.schema),
+        }
+      : undefined,
+    headers: typedSchemas.headerParams?.name
+      ? {
+          type: typedSchemas.headerParams?.name,
+          optional: isOptional(typedSchemas.headerParams?.schema),
+        }
+      : undefined,
+    options: {
+      type: 'Partial<Parameters<typeof client>[0]>',
+      default: '{}',
+    },
+  })
+
+  const clientParams = createFunctionParams({
     data: {
       mode: 'object',
       children: {
         method: {
           type: 'string',
-          value: JSON.stringify(client.method),
+          value: JSON.stringify(operation.method),
         },
         url: {
           type: 'string',
-          value: client.path.template,
+          value: path.template,
         },
-        baseURL: client.baseURL
+        baseURL: baseURL
           ? {
               type: 'string',
-              value: JSON.stringify(client.baseURL),
+              value: JSON.stringify(baseURL),
             }
           : undefined,
-        params: client.withQueryParams
+        params: typedSchemas.queryParams?.name
           ? {
               type: 'any',
             }
           : undefined,
-        data: client.withData
+        data: typedSchemas.request?.name
           ? {
               type: 'any',
               value: isFormData ? 'formData' : undefined,
@@ -86,7 +88,7 @@ function Template({ name, generics, returnType, params, JSDoc, client }: Templat
         headers: headers.length
           ? {
               type: 'any',
-              value: headers.length ? `{ ${headers}, ...options.headers }` : undefined,
+              value: headers.length ? `{ ${headers.join(', ')}, ...options.headers }` : undefined,
             }
           : undefined,
         options: {
@@ -95,7 +97,7 @@ function Template({ name, generics, returnType, params, JSDoc, client }: Templat
         },
       },
     },
-  }
+  })
 
   const formData = isFormData
     ? `
@@ -112,149 +114,26 @@ function Template({ name, generics, returnType, params, JSDoc, client }: Templat
     : undefined
 
   return (
-    <Function name={name} async export generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
-      {formData || ''}
-      <Function.Call name="res" to={<Function name="client" async generics={client.generics} params={clientParams} />} />
-      <Function.Return>{client.dataReturnType === 'data' ? 'res.data' : 'res'}</Function.Return>
-    </Function>
-  )
-}
-
-type RootTemplateProps = {
-  children?: React.ReactNode
-}
-
-function RootTemplate({ children }: RootTemplateProps) {
-  const {
-    plugin: {
-      options: {
-        client: { importPath },
-        extName,
-      },
-    },
-  } = useApp<PluginClient>()
-
-  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 (
-    <Parser language="typescript">
-      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-        <File.Import name={'client'} path={importPath} />
-        <File.Import name={['ResponseConfig']} path={importPath} isTypeOnly />
-        <File.Import
-          extName={extName}
-          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
+    <File.Source name={name} isExportable isIndexable>
+      <Function
+        name={name}
+        async
+        export
+        returnType={
+          options.dataReturnType === 'data' ? `ResponseConfig<${typedSchemas.response.name}>["data"]` : `ResponseConfig<${typedSchemas.response.name}>`
+        }
+        params={params}
+        JSDoc={{
+          comments: getComments(operation),
+        }}
+      >
+        {formData || ''}
+        <Function.Call
+          name="res"
+          to={<Function name="client" async generics={[typedSchemas.response.name, typedSchemas.request?.name].filter(Boolean)} params={clientParams} />}
         />
-        <File.Source>{children}</File.Source>
-      </File>
-    </Parser>
+        <Function.Return>{options.dataReturnType === 'data' ? 'res.data' : 'res'}</Function.Return>
+      </Function>
+    </File.Source>
   )
 }
-
-const defaultTemplates = { default: Template, root: RootTemplate } as const
-
-type Templates = Partial<typeof defaultTemplates>
-
-type ClientProps = {
-  baseURL: string | undefined
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  Template?: ComponentType<ComponentProps<typeof Template>>
-}
-
-export function Client({ baseURL, Template = defaultTemplates.default }: ClientProps): KubbNode {
-  const {
-    plugin: {
-      options: { client, dataReturnType, pathParamsType },
-    },
-  } = useApp<PluginClient>()
-
-  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 (
-    <Template
-      name={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),
-            }
-          : undefined,
-        params: schemas.queryParams?.name
-          ? {
-              type: schemas.queryParams?.name,
-              optional: isOptional(schemas.queryParams?.schema),
-            }
-          : undefined,
-        headers: schemas.headerParams?.name
-          ? {
-              type: schemas.headerParams?.name,
-              optional: isOptional(schemas.headerParams?.schema),
-            }
-          : undefined,
-        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 : undefined,
-        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,
-      }}
-    />
-  )
-}
-
-type FileProps = {
-  baseURL: string | undefined
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  templates?: Templates
-}
-
-Client.File = function ({ baseURL, ...props }: FileProps): KubbNode {
-  const templates = { ...defaultTemplates, ...props.templates }
-
-  const Template = templates.default
-  const RootTemplate = templates.root
-
-  return (
-    <RootTemplate>
-      <Client baseURL={baseURL} Template={Template} />
-    </RootTemplate>
-  )
-}
-
-Client.templates = defaultTemplates

package/src/components/Operations.tsx

@@ -1,22 +1,14 @@
 import { URLPath } from '@kubb/core/utils'
-import { useOperations } from '@kubb/plugin-oas/hooks'
-import { Const, File, Parser, useApp } from '@kubb/react'
+import { Const, File } from '@kubb/react'
 
 import type { HttpMethod, Operation } from '@kubb/oas'
-import type { KubbNode } from '@kubb/react'
-import type { ComponentProps, ComponentType } from 'react'
-import type { FileMeta, PluginClient } from '../types.ts'
 
-type TemplateProps = {
-  /**
-   * Name of the function
-   */
+type OperationsProps = {
   name: string
-  operations: Operation[]
-  baseURL: string | undefined
+  operations: Array<Operation>
 }
 
-function Template({ name, operations }: TemplateProps): KubbNode {
+export function Operations({ name, operations }: OperationsProps) {
   const operationsObject: Record<string, { path: string; method: HttpMethod }> = {}
 
   operations.forEach((operation) => {
@@ -25,70 +17,12 @@ function Template({ name, operations }: TemplateProps): KubbNode {
       method: operation.method,
     }
   })
-  return (
-    <Const name={name} export asConst>
-      {JSON.stringify(operationsObject, undefined, 2)}
-    </Const>
-  )
-}
-
-type RootTemplateProps = {
-  children?: React.ReactNode
-}
-
-function RootTemplate({ children }: RootTemplateProps) {
-  const {
-    pluginManager,
-    plugin: { key: pluginKey },
-  } = useApp<PluginClient>()
-  const file = pluginManager.getFile({ name: 'operations', extName: '.ts', pluginKey })
-
-  return (
-    <Parser language="typescript">
-      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta} exportable={false}>
-        <File.Source>{children}</File.Source>
-      </File>
-    </Parser>
-  )
-}
-
-const defaultTemplates = { default: Template, root: RootTemplate } as const
-
-type Templates = Partial<typeof defaultTemplates>
-
-type Props = {
-  baseURL: string | undefined
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  Template?: ComponentType<ComponentProps<typeof Template>>
-}
-
-export function Operations({ baseURL, Template = defaultTemplates.default }: Props): KubbNode {
-  const operations = useOperations()
-
-  return <Template baseURL={baseURL} name="operations" operations={operations} />
-}
-
-type FileProps = {
-  baseURL: string | undefined
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  templates?: Templates
-}
-
-Operations.File = function ({ baseURL, ...props }: FileProps): KubbNode {
-  const templates = { ...defaultTemplates, ...props.templates }
-
-  const Template = templates.default
-  const RootTemplate = templates.root
 
   return (
-    <RootTemplate>
-      <Operations baseURL={baseURL} Template={Template} />
-    </RootTemplate>
+    <File.Source name={name} isExportable isIndexable>
+      <Const name={name} export asConst>
+        {JSON.stringify(operationsObject, undefined, 2)}
+      </Const>
+    </File.Source>
   )
 }
-
-Operations.templates = defaultTemplates

package/src/components/__snapshots__/Client/showPetById.ts

@@ -2,10 +2,7 @@
  * @summary Info for a specific pet
  * @link /pets/:pet_id
  */
-export async function showPetById(
-  { petId, testId }: { petId: ShowPetByIdPathParams['pet_id']; testId: ShowPetByIdPathParams['testId'] },
-  options: Partial<Parameters<typeof client>[0]> = {},
-): Promise<ResponseConfig<ShowPetByIdQueryResponse>['data']> {
-  const res = await client<ShowPetByIdQueryResponse>({ method: 'get', url: `/pets/${petId}`, ...options })
+export async function showPetById({ petId, testId }: { petId: ShowPetByIdPathParams["pet_id"]; testId: ShowPetByIdPathParams["testId"] }, options: Partial<Parameters<typeof client>[0]> = {}): Promise<ResponseConfig<ShowPetByIdQueryResponse>["data"]> {
+  const res = await client<ShowPetByIdQueryResponse>({ method : "get", url : `/pets/${petId}`, ... options })
   return res.data
-}
+}

package/src/components/__snapshots__/Operations/showPetById.ts

@@ -1,6 +1,6 @@
 export const operations = {
-  showPetById: {
-    path: '/pets/:pet_id',
-    method: 'get',
-  },
-} as const
+      "showPetById": {
+        "path": "/pets/:pet_id",
+        "method": "get"
+      }
+    } as const