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

package/src/components/Client.tsx

@@ -1,258 +1,159 @@
 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 type { HttpMethod } from '@kubb/oas'
-import type { KubbNode, Params } from '@kubb/react/types'
-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, FunctionParams } from '@kubb/react'
+import type { KubbNode } 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
-  }
+  isExportable?: boolean
+  isIndexable?: boolean
+
+  baseURL: string | undefined
+  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
+  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
+  parser: PluginClient['resolvedOptions']['parser'] | undefined
+  typeSchemas: OperationSchemas
+  zodSchemas: OperationSchemas | undefined
+  operation: Operation
+}
+
+type GetParamsProps = {
+  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
+  typeSchemas: OperationSchemas
+}
+
+function getParams({ pathParamsType, typeSchemas }: GetParamsProps) {
+  return FunctionParams.factory({
+    pathParams: {
+      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
+      children: getPathParams(typeSchemas.pathParams, { typed: true }),
+    },
+    data: typeSchemas.request?.name
+      ? {
+          type: typeSchemas.request?.name,
+          optional: isOptional(typeSchemas.request?.schema),
+        }
+      : undefined,
+    params: typeSchemas.queryParams?.name
+      ? {
+          type: typeSchemas.queryParams?.name,
+          optional: isOptional(typeSchemas.queryParams?.schema),
+        }
+      : undefined,
+    headers: typeSchemas.headerParams?.name
+      ? {
+          type: typeSchemas.headerParams?.name,
+          optional: isOptional(typeSchemas.headerParams?.schema),
+        }
+      : undefined,
+    config: {
+      type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>>` : 'Partial<RequestConfig>',
+      default: '{}',
+    },
+  })
 }
 
-function Template({ name, generics, returnType, params, JSDoc, client }: TemplateProps): KubbNode {
-  const isFormData = client.contentType === 'multipart/form-data'
+export function Client({
+  name,
+  isExportable = true,
+  isIndexable = true,
+  typeSchemas,
+  baseURL,
+  dataReturnType,
+  parser,
+  zodSchemas,
+  pathParamsType,
+  operation,
+}: Props): KubbNode {
+  const path = new URLPath(operation.path)
+  const contentType = operation.getContentType()
+  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 = {
-    data: {
+    contentType !== 'application/json' ? `'Content-Type': '${contentType}'` : undefined,
+    typeSchemas.headerParams?.name ? '...headers' : undefined,
+  ].filter(Boolean)
+
+  const generics = [
+    typeSchemas.response.name,
+    typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error',
+    typeSchemas.request?.name || 'unknown',
+  ].filter(Boolean)
+  const params = getParams({ pathParamsType, typeSchemas })
+  const clientParams = FunctionParams.factory({
+    config: {
       mode: 'object',
       children: {
         method: {
-          type: 'string',
-          value: JSON.stringify(client.method),
+          value: JSON.stringify(operation.method.toUpperCase()),
         },
         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: typeSchemas.queryParams?.name ? {} : undefined,
+        data: typeSchemas.request?.name
           ? {
-              type: 'any',
-            }
-          : undefined,
-        data: client.withData
-          ? {
-              type: 'any',
               value: isFormData ? 'formData' : undefined,
             }
           : undefined,
         headers: headers.length
           ? {
-              type: 'any',
-              value: headers.length ? `{ ${headers}, ...options.headers }` : undefined,
+              value: headers.length ? `{ ${headers.join(', ')}, ...config.headers }` : undefined,
             }
           : undefined,
-        options: {
-          type: 'any',
+        config: {
           mode: 'inlineSpread',
         },
       },
     },
-  }
+  })
 
   const formData = isFormData
     ? `
    const formData = new FormData()
    if(data) {
     Object.keys(data).forEach((key) => {
-      const value = data[key];
+      const value = data[key as keyof typeof data];
       if (typeof key === "string" && (typeof value === "string" || value instanceof Blob)) {
         formData.append(key, value);
       }
     })
    }
   `
-    : undefined
+    : ''
 
   return (
-    <File.Source name={name} isExportable isIndexable>
-      <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>
+    <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
+      <Function
+        name={name}
+        async
+        export={isExportable}
+        params={params.toConstructor()}
+        JSDoc={{
+          comments: getComments(operation),
+        }}
+      >
+        {formData}
+        {`const res = await client<${generics.join(', ')}>(${clientParams.toCall()})`}
+        <br />
+        {dataReturnType === 'full' && parser === 'zod' && zodSchemas && `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`}
+        {dataReturnType === 'data' && parser === 'zod' && zodSchemas && `return ${zodSchemas.response.name}.parse(res.data)`}
+        {dataReturnType === 'full' && parser === 'client' && 'return res'}
+        {dataReturnType === 'data' && parser === 'client' && 'return res.data'}
       </Function>
     </File.Source>
   )
 }
 
-type RootTemplateProps = {
-  children?: React.ReactNode
-}
-
-function RootTemplate({ children }: RootTemplateProps) {
-  const {
-    plugin: {
-      options: {
-        client: { importPath },
-      },
-    },
-  } = 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 (
-    <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
-        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
-      />
-      {children}
-    </File>
-  )
-}
-
-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
+Client.getParams = getParams

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, useApp } from '@kubb/react'
+import { Const, File } from '@kubb/react'
 
 import type { HttpMethod, Operation } from '@kubb/oas'
-import type { KubbNode } from '@kubb/react/types'
-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,6 +17,7 @@ function Template({ name, operations }: TemplateProps): KubbNode {
       method: operation.method,
     }
   })
+
   return (
     <File.Source name={name} isExportable isIndexable>
       <Const name={name} export asConst>
@@ -33,62 +26,3 @@ function Template({ name, operations }: TemplateProps): KubbNode {
     </File.Source>
   )
 }
-
-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 (
-    <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-      {children}
-    </File>
-  )
-}
-
-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>
-  )
-}
-
-Operations.templates = defaultTemplates

package/src/generators/__snapshots__/deletePet.ts

@@ -0,0 +1,13 @@
+/* eslint-disable no-alert, no-console */
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ /**
+ * @description delete a pet
+ * @summary Deletes a pet
+ * @link /pet/:petId
+ */
+export async function deletePet(petId: DeletePetPathParams["petId"], headers?: DeletePetHeaderParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<DeletePetMutationResponse, DeletePet400, unknown>({ method: "DELETE", url: `/pet/${petId}`, headers: { ...headers, ...config.headers }, ...config });
+    return res.data;
+}

package/src/generators/__snapshots__/deletePetObject.ts

@@ -0,0 +1,15 @@
+/* eslint-disable no-alert, no-console */
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ /**
+ * @description delete a pet
+ * @summary Deletes a pet
+ * @link /pet/:petId
+ */
+export async function deletePet({ petId }: {
+    petId: DeletePetPathParams["petId"];
+}, headers?: DeletePetHeaderParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<DeletePetMutationResponse, DeletePet400, unknown>({ method: "DELETE", url: `/pet/${petId}`, headers: { ...headers, ...config.headers }, ...config });
+    return res.data;
+}

package/src/generators/__snapshots__/findByTags.ts

@@ -0,0 +1,13 @@
+/* eslint-disable no-alert, no-console */
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export async function findPetsByTags(params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "GET", url: `/pet/findByTags`, params, ...config });
+    return res.data;
+}

package/src/generators/__snapshots__/findByTagsFull.ts

@@ -0,0 +1,13 @@
+/* eslint-disable no-alert, no-console */
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export async function findPetsByTags(params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "GET", url: `/pet/findByTags`, params, ...config });
+    return res;
+}

package/src/generators/__snapshots__/findByTagsWithZod.ts

@@ -0,0 +1,13 @@
+/* eslint-disable no-alert, no-console */
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export async function findPetsByTags(params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "GET", url: `/pet/findByTags`, params, ...config });
+    return findPetsByTagsQueryResponse.parse(res.data);
+}

package/src/generators/__snapshots__/findByTagsWithZodFull.ts

@@ -0,0 +1,13 @@
+/* eslint-disable no-alert, no-console */
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export async function findPetsByTags(params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "GET", url: `/pet/findByTags`, params, ...config });
+    return { ...res, data: findPetsByTagsQueryResponse.parse(res.data) };
+}

package/src/generators/__snapshots__/importPath.ts

@@ -0,0 +1,13 @@
+/* eslint-disable no-alert, no-console */
+import client from "axios";
+import type { RequestConfig } from "axios";
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export async function findPetsByTags(params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "GET", url: `/pet/findByTags`, params, ...config });
+    return res.data;
+}

package/src/generators/__snapshots__/operations.ts

@@ -0,0 +1,82 @@
+export const operations = {
+    "updatePet": {
+        "path": "/pet",
+        "method": "put"
+    },
+    "addPet": {
+        "path": "/pet",
+        "method": "post"
+    },
+    "findPetsByStatus": {
+        "path": "/pet/findByStatus",
+        "method": "get"
+    },
+    "findPetsByTags": {
+        "path": "/pet/findByTags",
+        "method": "get"
+    },
+    "getPetById": {
+        "path": "/pet/:petId",
+        "method": "get"
+    },
+    "updatePetWithForm": {
+        "path": "/pet/:petId",
+        "method": "post"
+    },
+    "deletePet": {
+        "path": "/pet/:petId",
+        "method": "delete"
+    },
+    "uploadFile": {
+        "path": "/pet/:petId/uploadImage",
+        "method": "post"
+    },
+    "getInventory": {
+        "path": "/store/inventory",
+        "method": "get"
+    },
+    "placeOrder": {
+        "path": "/store/order",
+        "method": "post"
+    },
+    "placeOrderPatch": {
+        "path": "/store/order",
+        "method": "patch"
+    },
+    "getOrderById": {
+        "path": "/store/order/:orderId",
+        "method": "get"
+    },
+    "deleteOrder": {
+        "path": "/store/order/:orderId",
+        "method": "delete"
+    },
+    "createUser": {
+        "path": "/user",
+        "method": "post"
+    },
+    "createUsersWithListInput": {
+        "path": "/user/createWithList",
+        "method": "post"
+    },
+    "loginUser": {
+        "path": "/user/login",
+        "method": "get"
+    },
+    "logoutUser": {
+        "path": "/user/logout",
+        "method": "get"
+    },
+    "getUserByName": {
+        "path": "/user/:username",
+        "method": "get"
+    },
+    "updateUser": {
+        "path": "/user/:username",
+        "method": "put"
+    },
+    "deleteUser": {
+        "path": "/user/:username",
+        "method": "delete"
+    }
+} as const;

package/src/generators/__snapshots__/updatePetById.ts

@@ -0,0 +1,12 @@
+/* eslint-disable no-alert, no-console */
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+export async function updatePetWithForm(petId: UpdatePetWithFormPathParams["petId"], params?: UpdatePetWithFormQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, unknown>({ method: "POST", url: `/pet/${petId}`, params, ...config });
+    return res.data;
+}