@kubb/plugin-react-query/dist/chunk-BOWHVFL2.cjs

Generator react-query hooks

'use strict';

var chunkZ6CABIIO_cjs = require('./chunk-Z6CABIIO.cjs');
var path = require('path');
var core = require('@kubb/core');
var transformers = require('@kubb/core/transformers');
var pluginOas = require('@kubb/plugin-oas');
var pluginZod = require('@kubb/plugin-zod');
var hooks = require('@kubb/plugin-oas/hooks');
var utils = require('@kubb/plugin-oas/utils');
var pluginTs = require('@kubb/plugin-ts');
var react = require('@kubb/react');
var jsxRuntime = require('@kubb/react/jsx-runtime');
var remeda = require('remeda');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var path__default = /*#__PURE__*/_interopDefault(path);

var clientGenerator = pluginOas.createReactGenerator({
  name: "client",
  Operation({ options, operation }) {
    const {
      plugin: {
        options: { output, urlType }
      },
      pluginManager
    } = react.useApp();
    const oas = hooks.useOas();
    const { getSchemas, getName, getFile } = hooks.useOperationManager();
    const client = {
      name: getName(operation, { type: "function" }),
      file: getFile(operation)
    };
    const url = {
      name: getName(operation, { type: "function", suffix: "url", prefix: "get" }),
      file: getFile(operation)
    };
    const type = {
      file: getFile(operation, { pluginKey: [pluginTs.pluginTsName] }),
      schemas: getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" })
    };
    const zod = {
      file: getFile(operation, { pluginKey: [pluginZod.pluginZodName] }),
      schemas: getSchemas(operation, { pluginKey: [pluginZod.pluginZodName], type: "function" })
    };
    return /* @__PURE__ */ jsxRuntime.jsxs(
      react.File,
      {
        baseName: client.file.baseName,
        path: client.file.path,
        meta: client.file.meta,
        banner: utils.getBanner({ oas, output, config: pluginManager.config }),
        footer: utils.getFooter({ oas, output }),
        children: [
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: "client", path: options.importPath }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["RequestConfig", "ResponseErrorConfig"], path: options.importPath, isTypeOnly: true }),
          options.parser === "zod" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean), root: client.file.path, path: zod.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(
            react.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: true
            }
          ),
          /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.Url,
            {
              name: url.name,
              baseURL: options.baseURL,
              pathParamsType: options.pathParamsType,
              paramsCasing: options.paramsCasing,
              paramsType: options.paramsType,
              typeSchemas: type.schemas,
              operation,
              isIndexable: urlType === "export",
              isExportable: urlType === "export"
            }
          ),
          /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.Client,
            {
              name: client.name,
              urlName: url.name,
              baseURL: options.baseURL,
              dataReturnType: options.dataReturnType,
              pathParamsType: options.pathParamsType,
              paramsCasing: options.paramsCasing,
              paramsType: options.paramsType,
              typeSchemas: type.schemas,
              operation,
              parser: options.parser,
              zodSchemas: zod.schemas
            }
          )
        ]
      }
    );
  }
});
var operationsGenerator = pluginOas.createReactGenerator({
  name: "client",
  Operations({ operations }) {
    const {
      pluginManager,
      plugin: {
        key: pluginKey,
        options: { output }
      }
    } = react.useApp();
    const oas = hooks.useOas();
    const name = "operations";
    const file = pluginManager.getFile({ name, extname: ".ts", pluginKey });
    return /* @__PURE__ */ jsxRuntime.jsx(
      react.File,
      {
        baseName: file.baseName,
        path: file.path,
        meta: file.meta,
        banner: utils.getBanner({ oas, output, config: pluginManager.config }),
        footer: utils.getFooter({ oas, output }),
        children: /* @__PURE__ */ jsxRuntime.jsx(chunkZ6CABIIO_cjs.Operations, { name, operations })
      }
    );
  }
});
var groupedClientGenerator = pluginOas.createReactGenerator({
  name: "groupedClient",
  Operations({ operations }) {
    const {
      pluginManager,
      plugin: { options, key: pluginKey }
    } = react.useApp();
    const oas = hooks.useOas();
    const { getName, getFile, getGroup } = hooks.useOperationManager();
    const controllers = operations.reduce(
      (acc, operation) => {
        if (options.group?.type === "tag") {
          const group = getGroup(operation);
          const name = group?.tag ? options.group?.name?.({ group: transformers.camelCase(group.tag) }) : void 0;
          if (!group?.tag || !name) {
            return acc;
          }
          const file = pluginManager.getFile({
            name,
            extname: ".ts",
            pluginKey,
            options: { group }
          });
          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;
      },
      []
    );
    return controllers.map(({ name, file, clients }) => {
      return /* @__PURE__ */ jsxRuntime.jsxs(
        react.File,
        {
          baseName: file.baseName,
          path: file.path,
          meta: file.meta,
          banner: utils.getBanner({ oas, output: options.output, config: pluginManager.config }),
          footer: utils.getFooter({ oas, output: options.output }),
          children: [
            clients.map((client) => /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [client.name], root: file.path, path: client.file.path }, client.name)),
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function, { export: true, name, children: `return { ${clients.map((client) => client.name).join(", ")} }` }) })
          ]
        },
        file.path
      );
    });
  }
});

// ../plugin-client/src/plugin.ts
var pluginClientName = "plugin-client";
core.createPlugin((options) => {
  const {
    output = { path: "clients", barrelType: "named" },
    group,
    urlType = false,
    exclude = [],
    include,
    override = [],
    transformers: transformers$1 = {},
    dataReturnType = "data",
    paramsType = "inline",
    pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline",
    operations = false,
    baseURL,
    paramsCasing,
    generators = [clientGenerator, group ? groupedClientGenerator : void 0, operations ? operationsGenerator : void 0].filter(Boolean),
    parser = "client",
    client = "axios",
    importPath = client === "fetch" ? "@kubb/plugin-client/clients/fetch" : "@kubb/plugin-client/clients/axios",
    contentType
  } = options;
  return {
    name: pluginClientName,
    options: {
      output,
      group,
      parser,
      dataReturnType,
      importPath,
      paramsType,
      paramsCasing,
      pathParamsType,
      baseURL,
      urlType
    },
    pre: [pluginOas.pluginOasName, parser === "zod" ? pluginZod.pluginZodName : void 0].filter(Boolean),
    resolvePath(baseName, pathMode, options2) {
      const root = path__default.default.resolve(this.config.root, this.config.output.path);
      const mode = pathMode ?? core.FileManager.getMode(path__default.default.resolve(root, output.path));
      if (mode === "single") {
        return path__default.default.resolve(root, output.path);
      }
      if (group && (options2?.group?.path || options2?.group?.tag)) {
        const groupName = group?.name ? group.name : (ctx) => {
          if (group?.type === "path") {
            return `${ctx.group.split("/")[1]}`;
          }
          return `${transformers.camelCase(ctx.group)}Controller`;
        };
        return path__default.default.resolve(
          root,
          output.path,
          groupName({
            group: group.type === "path" ? options2.group.path : options2.group.tag
          }),
          baseName
        );
      }
      return path__default.default.resolve(root, output.path, baseName);
    },
    resolveName(name, type) {
      const resolvedName = transformers.camelCase(name, { isFile: type === "file" });
      if (type) {
        return transformers$1?.name?.(resolvedName, type) || resolvedName;
      }
      return resolvedName;
    },
    async buildStart() {
      const [swaggerPlugin] = core.PluginManager.getDependedPlugins(this.plugins, [pluginOas.pluginOasName]);
      const oas = await swaggerPlugin.context.getOas();
      const root = path__default.default.resolve(this.config.root, this.config.output.path);
      const mode = core.FileManager.getMode(path__default.default.resolve(root, output.path));
      const baseURL2 = await swaggerPlugin.context.getBaseURL();
      const operationGenerator = new pluginOas.OperationGenerator(
        baseURL2 ? {
          ...this.plugin.options,
          baseURL: baseURL2
        } : this.plugin.options,
        {
          oas,
          pluginManager: this.pluginManager,
          plugin: this.plugin,
          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);
    }
  };
});
var queryGenerator = pluginOas.createReactGenerator({
  name: "react-query",
  Operation({ options, operation }) {
    const {
      plugin: {
        options: { output }
      },
      pluginManager
    } = react.useApp();
    const oas = hooks.useOas();
    const { getSchemas, getName, getFile } = hooks.useOperationManager();
    const isQuery = typeof options.query === "boolean" ? true : options.query?.methods.some((method) => operation.method === method);
    const isMutation = remeda.difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some(
      (method) => operation.method === method
    );
    const importPath = options.query ? options.query.importPath : "@tanstack/react-query";
    const query = {
      name: getName(operation, { type: "function", prefix: "use" }),
      typeName: getName(operation, { type: "type" }),
      file: getFile(operation, { prefix: "use" })
    };
    const hasClientPlugin = !!pluginManager.getPluginByKey([pluginClientName]);
    const client = {
      name: hasClientPlugin ? getName(operation, {
        type: "function",
        pluginKey: [pluginClientName]
      }) : getName(operation, {
        type: "function"
      }),
      file: getFile(operation, { pluginKey: [pluginClientName] })
    };
    const queryOptions = {
      name: getName(operation, { type: "function", suffix: "QueryOptions" })
    };
    const queryKey = {
      name: getName(operation, { type: "const", suffix: "QueryKey" }),
      typeName: getName(operation, { type: "type", suffix: "QueryKey" })
    };
    const type = {
      file: getFile(operation, { pluginKey: [pluginTs.pluginTsName] }),
      //todo remove type?
      schemas: getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" })
    };
    const zod = {
      // grouping is coming from react-query instead of zod option, we need to pass the options of zod instead
      file: getFile(operation, { pluginKey: [pluginZod.pluginZodName] }),
      schemas: getSchemas(operation, { pluginKey: [pluginZod.pluginZodName], type: "function" })
    };
    if (!isQuery || isMutation) {
      return null;
    }
    return /* @__PURE__ */ jsxRuntime.jsxs(
      react.File,
      {
        baseName: query.file.baseName,
        path: query.file.path,
        meta: query.file.meta,
        banner: utils.getBanner({ oas, output, config: pluginManager.config }),
        footer: utils.getFooter({ oas, output }),
        children: [
          options.parser === "zod" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean), root: query.file.path, path: zod.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: "client", path: options.client.importPath }),
          hasClientPlugin && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [client.name], root: query.file.path, path: client.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["RequestConfig", "ResponseErrorConfig"], path: options.client.importPath, isTypeOnly: true }),
          options.client.dataReturnType === "full" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["ResponseConfig"], path: options.client.importPath, isTypeOnly: true }),
          /* @__PURE__ */ jsxRuntime.jsx(
            react.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: query.file.path,
              path: type.file.path,
              isTypeOnly: true
            }
          ),
          /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.QueryKey,
            {
              name: queryKey.name,
              typeName: queryKey.typeName,
              operation,
              pathParamsType: options.pathParamsType,
              typeSchemas: type.schemas,
              paramsCasing: options.paramsCasing,
              transformer: options.queryKey
            }
          ),
          !hasClientPlugin && /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.Client,
            {
              name: client.name,
              baseURL: options.client.baseURL,
              operation,
              typeSchemas: type.schemas,
              zodSchemas: zod.schemas,
              dataReturnType: options.client.dataReturnType,
              paramsType: options.paramsType,
              paramsCasing: options.paramsCasing,
              pathParamsType: options.pathParamsType,
              parser: options.parser
            }
          ),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["queryOptions"], path: importPath }),
          /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.QueryOptions,
            {
              name: queryOptions.name,
              clientName: client.name,
              queryKeyName: queryKey.name,
              typeSchemas: type.schemas,
              paramsCasing: options.paramsCasing,
              paramsType: options.paramsType,
              pathParamsType: options.pathParamsType,
              dataReturnType: options.client.dataReturnType
            }
          ),
          options.query && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["useQuery"], path: importPath }),
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["QueryKey", "QueryClient", "QueryObserverOptions", "UseQueryResult", "QueryClient"], path: importPath, isTypeOnly: true }),
            /* @__PURE__ */ jsxRuntime.jsx(
              chunkZ6CABIIO_cjs.Query,
              {
                name: query.name,
                queryOptionsName: queryOptions.name,
                typeSchemas: type.schemas,
                paramsCasing: options.paramsCasing,
                paramsType: options.paramsType,
                pathParamsType: options.pathParamsType,
                operation,
                dataReturnType: options.client.dataReturnType,
                queryKeyName: queryKey.name,
                queryKeyTypeName: queryKey.typeName
              }
            )
          ] })
        ]
      }
    );
  }
});
var mutationGenerator = pluginOas.createReactGenerator({
  name: "react-query",
  Operation({ options, operation }) {
    const {
      plugin: {
        options: { output }
      },
      pluginManager
    } = react.useApp();
    const oas = hooks.useOas();
    const { getSchemas, getName, getFile } = hooks.useOperationManager();
    const isQuery = !!options.query && options.query?.methods.some((method) => operation.method === method);
    const isMutation = !isQuery && remeda.difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some((method) => operation.method === method);
    const importPath = options.mutation ? options.mutation.importPath : "@tanstack/react-query";
    const mutation = {
      name: getName(operation, { type: "function", prefix: "use" }),
      typeName: getName(operation, { type: "type" }),
      file: getFile(operation, { prefix: "use" })
    };
    const type = {
      file: getFile(operation, { pluginKey: [pluginTs.pluginTsName] }),
      //todo remove type?
      schemas: getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" })
    };
    const zod = {
      file: getFile(operation, { pluginKey: [pluginZod.pluginZodName] }),
      schemas: getSchemas(operation, { pluginKey: [pluginZod.pluginZodName], type: "function" })
    };
    const hasClientPlugin = !!pluginManager.getPluginByKey([pluginClientName]);
    const client = {
      name: hasClientPlugin ? getName(operation, {
        type: "function",
        pluginKey: [pluginClientName]
      }) : getName(operation, {
        type: "function"
      }),
      file: getFile(operation, { pluginKey: [pluginClientName] })
    };
    const mutationKey = {
      name: getName(operation, { type: "const", suffix: "MutationKey" }),
      typeName: getName(operation, { type: "type", suffix: "MutationKey" })
    };
    if (!isMutation) {
      return null;
    }
    return /* @__PURE__ */ jsxRuntime.jsxs(
      react.File,
      {
        baseName: mutation.file.baseName,
        path: mutation.file.path,
        meta: mutation.file.meta,
        banner: utils.getBanner({ oas, output, config: pluginManager.config }),
        footer: utils.getFooter({ oas, output }),
        children: [
          options.parser === "zod" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean), root: mutation.file.path, path: zod.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: "client", path: options.client.importPath }),
          !!hasClientPlugin && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [client.name], root: mutation.file.path, path: client.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["RequestConfig", "ResponseConfig", "ResponseErrorConfig"], path: options.client.importPath, isTypeOnly: true }),
          /* @__PURE__ */ jsxRuntime.jsx(
            react.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: mutation.file.path,
              path: type.file.path,
              isTypeOnly: true
            }
          ),
          /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.MutationKey,
            {
              name: mutationKey.name,
              typeName: mutationKey.typeName,
              operation,
              pathParamsType: options.pathParamsType,
              typeSchemas: type.schemas,
              paramsCasing: options.paramsCasing,
              transformer: options.mutationKey
            }
          ),
          !hasClientPlugin && /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.Client,
            {
              name: client.name,
              baseURL: options.client.baseURL,
              operation,
              typeSchemas: type.schemas,
              zodSchemas: zod.schemas,
              dataReturnType: options.client.dataReturnType,
              paramsCasing: options.paramsCasing,
              paramsType: options.paramsType,
              pathParamsType: options.pathParamsType,
              parser: options.parser
            }
          ),
          options.mutation && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["useMutation"], path: importPath }),
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["UseMutationOptions", "QueryClient"], path: importPath, isTypeOnly: true }),
            /* @__PURE__ */ jsxRuntime.jsx(
              chunkZ6CABIIO_cjs.Mutation,
              {
                name: mutation.name,
                clientName: client.name,
                typeName: mutation.typeName,
                typeSchemas: type.schemas,
                operation,
                dataReturnType: options.client.dataReturnType,
                paramsCasing: options.paramsCasing,
                paramsType: options.paramsType,
                pathParamsType: options.pathParamsType,
                mutationKeyName: mutationKey.name
              }
            )
          ] })
        ]
      }
    );
  }
});
var infiniteQueryGenerator = pluginOas.createReactGenerator({
  name: "react-infinite-query",
  Operation({ options, operation }) {
    const {
      plugin: {
        options: { output }
      },
      pluginManager
    } = react.useApp();
    const oas = hooks.useOas();
    const { getSchemas, getName, getFile } = hooks.useOperationManager();
    const isQuery = typeof options.query === "boolean" ? true : options.query?.methods.some((method) => operation.method === method);
    const isMutation = remeda.difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some(
      (method) => operation.method === method
    );
    const isInfinite = !!options.infinite;
    const importPath = options.query ? options.query.importPath : "@tanstack/react-query";
    const query = {
      name: getName(operation, { type: "function", prefix: "use", suffix: "infinite" }),
      typeName: getName(operation, { type: "type" }),
      file: getFile(operation, { prefix: "use", suffix: "infinite" })
    };
    const hasClientPlugin = !!pluginManager.getPluginByKey([pluginClientName]);
    const client = {
      name: hasClientPlugin ? getName(operation, {
        type: "function",
        pluginKey: [pluginClientName]
      }) : getName(operation, {
        type: "function",
        suffix: "infinite"
      }),
      file: getFile(operation, { pluginKey: [pluginClientName] })
    };
    const queryOptions = {
      name: getName(operation, { type: "function", suffix: "InfiniteQueryOptions" })
    };
    const queryKey = {
      name: getName(operation, { type: "const", suffix: "InfiniteQueryKey" }),
      typeName: getName(operation, { type: "type", suffix: "InfiniteQueryKey" })
    };
    const type = {
      file: getFile(operation, { pluginKey: [pluginTs.pluginTsName] }),
      //todo remove type?
      schemas: getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" })
    };
    const zod = {
      file: getFile(operation, { pluginKey: [pluginZod.pluginZodName] }),
      schemas: getSchemas(operation, { pluginKey: [pluginZod.pluginZodName], type: "function" })
    };
    if (!isQuery || isMutation || !isInfinite) {
      return null;
    }
    return /* @__PURE__ */ jsxRuntime.jsxs(
      react.File,
      {
        baseName: query.file.baseName,
        path: query.file.path,
        meta: query.file.meta,
        banner: utils.getBanner({ oas, output, config: pluginManager.config }),
        footer: utils.getFooter({ oas, output }),
        children: [
          options.parser === "zod" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean), root: query.file.path, path: zod.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: "client", path: options.client.importPath }),
          hasClientPlugin && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [client.name], root: query.file.path, path: client.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["RequestConfig", "ResponseErrorConfig"], path: options.client.importPath, isTypeOnly: true }),
          options.client.dataReturnType === "full" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["ResponseConfig"], path: options.client.importPath, isTypeOnly: true }),
          /* @__PURE__ */ jsxRuntime.jsx(
            react.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: query.file.path,
              path: type.file.path,
              isTypeOnly: true
            }
          ),
          /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.QueryKey,
            {
              name: queryKey.name,
              typeName: queryKey.typeName,
              operation,
              paramsCasing: options.paramsCasing,
              pathParamsType: options.pathParamsType,
              typeSchemas: type.schemas,
              transformer: options.queryKey
            }
          ),
          !hasClientPlugin && /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.Client,
            {
              name: client.name,
              baseURL: options.client.baseURL,
              operation,
              typeSchemas: type.schemas,
              zodSchemas: zod.schemas,
              dataReturnType: options.client.dataReturnType,
              paramsCasing: options.paramsCasing,
              paramsType: options.paramsType,
              pathParamsType: options.pathParamsType,
              parser: options.parser
            }
          ),
          options.infinite && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["InfiniteData"], isTypeOnly: true, path: importPath }),
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["infiniteQueryOptions"], path: importPath }),
            /* @__PURE__ */ jsxRuntime.jsx(
              chunkZ6CABIIO_cjs.InfiniteQueryOptions,
              {
                name: queryOptions.name,
                clientName: client.name,
                queryKeyName: queryKey.name,
                typeSchemas: type.schemas,
                paramsCasing: options.paramsCasing,
                paramsType: options.paramsType,
                pathParamsType: options.pathParamsType,
                dataReturnType: options.client.dataReturnType,
                cursorParam: options.infinite.cursorParam,
                initialPageParam: options.infinite.initialPageParam,
                queryParam: options.infinite.queryParam
              }
            )
          ] }),
          options.infinite && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["useInfiniteQuery"], path: importPath }),
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["QueryKey", "QueryClient", "InfiniteQueryObserverOptions", "UseInfiniteQueryResult"], path: importPath, isTypeOnly: true }),
            /* @__PURE__ */ jsxRuntime.jsx(
              chunkZ6CABIIO_cjs.InfiniteQuery,
              {
                name: query.name,
                queryOptionsName: queryOptions.name,
                typeSchemas: type.schemas,
                paramsCasing: options.paramsCasing,
                paramsType: options.paramsType,
                pathParamsType: options.pathParamsType,
                operation,
                dataReturnType: options.client.dataReturnType,
                queryKeyName: queryKey.name,
                queryKeyTypeName: queryKey.typeName
              }
            )
          ] })
        ]
      }
    );
  }
});
var suspenseQueryGenerator = pluginOas.createReactGenerator({
  name: "react-suspense-query",
  Operation({ options, operation }) {
    const {
      plugin: {
        options: { output }
      },
      pluginManager
    } = react.useApp();
    const oas = hooks.useOas();
    const { getSchemas, getName, getFile } = hooks.useOperationManager();
    const isQuery = typeof options.query === "boolean" ? true : options.query?.methods.some((method) => operation.method === method);
    const isMutation = remeda.difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some(
      (method) => operation.method === method
    );
    const isSuspense = !!options.suspense;
    const importPath = options.query ? options.query.importPath : "@tanstack/react-query";
    const query = {
      name: getName(operation, { type: "function", prefix: "use", suffix: "suspense" }),
      typeName: getName(operation, { type: "type" }),
      file: getFile(operation, { prefix: "use", suffix: "suspense" })
    };
    const hasClientPlugin = !!pluginManager.getPluginByKey([pluginClientName]);
    const client = {
      name: hasClientPlugin ? getName(operation, {
        type: "function",
        pluginKey: [pluginClientName]
      }) : getName(operation, {
        type: "function",
        suffix: "suspense"
      }),
      file: getFile(operation, { pluginKey: [pluginClientName] })
    };
    const queryOptions = {
      name: getName(operation, { type: "function", suffix: "SuspenseQueryOptions" })
    };
    const queryKey = {
      name: getName(operation, { type: "const", suffix: "SuspenseQueryKey" }),
      typeName: getName(operation, { type: "type", suffix: "SuspenseQueryKey" })
    };
    const type = {
      file: getFile(operation, { pluginKey: [pluginTs.pluginTsName] }),
      //todo remove type?
      schemas: getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" })
    };
    const zod = {
      file: getFile(operation, { pluginKey: [pluginZod.pluginZodName] }),
      schemas: getSchemas(operation, { pluginKey: [pluginZod.pluginZodName], type: "function" })
    };
    if (!isQuery || isMutation || !isSuspense) {
      return null;
    }
    return /* @__PURE__ */ jsxRuntime.jsxs(
      react.File,
      {
        baseName: query.file.baseName,
        path: query.file.path,
        meta: query.file.meta,
        banner: utils.getBanner({ oas, output, config: pluginManager.config }),
        footer: utils.getFooter({ oas, output }),
        children: [
          options.parser === "zod" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean), root: query.file.path, path: zod.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: "client", path: options.client.importPath }),
          hasClientPlugin && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [client.name], root: query.file.path, path: client.file.path }),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["RequestConfig", "ResponseErrorConfig"], path: options.client.importPath, isTypeOnly: true }),
          options.client.dataReturnType === "full" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["ResponseConfig"], path: options.client.importPath, isTypeOnly: true }),
          /* @__PURE__ */ jsxRuntime.jsx(
            react.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: query.file.path,
              path: type.file.path,
              isTypeOnly: true
            }
          ),
          /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.QueryKey,
            {
              name: queryKey.name,
              typeName: queryKey.typeName,
              operation,
              paramsCasing: options.paramsCasing,
              pathParamsType: options.pathParamsType,
              typeSchemas: type.schemas,
              transformer: options.queryKey
            }
          ),
          !hasClientPlugin && /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.Client,
            {
              name: client.name,
              baseURL: options.client.baseURL,
              operation,
              typeSchemas: type.schemas,
              zodSchemas: zod.schemas,
              dataReturnType: options.client.dataReturnType,
              paramsCasing: options.paramsCasing,
              paramsType: options.paramsType,
              pathParamsType: options.pathParamsType,
              parser: options.parser
            }
          ),
          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["queryOptions"], path: importPath }),
          /* @__PURE__ */ jsxRuntime.jsx(
            chunkZ6CABIIO_cjs.QueryOptions,
            {
              name: queryOptions.name,
              clientName: client.name,
              queryKeyName: queryKey.name,
              typeSchemas: type.schemas,
              paramsCasing: options.paramsCasing,
              paramsType: options.paramsType,
              pathParamsType: options.pathParamsType,
              dataReturnType: options.client.dataReturnType
            }
          ),
          options.suspense && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["useSuspenseQuery"], path: importPath }),
            /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["QueryKey", "QueryClient", "UseSuspenseQueryOptions", "UseSuspenseQueryResult"], path: importPath, isTypeOnly: true }),
            options.client.dataReturnType === "full" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["ResponseConfig"], path: options.client.importPath, isTypeOnly: true }),
            /* @__PURE__ */ jsxRuntime.jsx(
              chunkZ6CABIIO_cjs.SuspenseQuery,
              {
                name: query.name,
                queryOptionsName: queryOptions.name,
                typeSchemas: type.schemas,
                paramsType: options.paramsType,
                paramsCasing: options.paramsCasing,
                pathParamsType: options.pathParamsType,
                operation,
                dataReturnType: options.client.dataReturnType,
                queryKeyName: queryKey.name,
                queryKeyTypeName: queryKey.typeName
              }
            )
          ] })
        ]
      }
    );
  }
});

exports.infiniteQueryGenerator = infiniteQueryGenerator;
exports.mutationGenerator = mutationGenerator;
exports.queryGenerator = queryGenerator;
exports.suspenseQueryGenerator = suspenseQueryGenerator;
//# sourceMappingURL=chunk-BOWHVFL2.cjs.map
//# sourceMappingURL=chunk-BOWHVFL2.cjs.map