@kubb/plugin-client/dist/index.js

API client generator plugin for Kubb, creating type-safe HTTP clients (Axios, Fetch) from OpenAPI specifications for making API requests.

import { clientGenerator, groupedClientGenerator, operationsGenerator } from './chunk-QNFXNUH5.js';
import './chunk-LNJCFB5O.js';
import path from 'path';
import { createPlugin, PluginManager, FileManager } from '@kubb/core';
import { camelCase } from '@kubb/core/transformers';
import { pluginOasName, OperationGenerator } from '@kubb/plugin-oas';
import { pluginZodName } from '@kubb/plugin-zod';

var pluginClientName = "plugin-client";
var pluginClient = createPlugin((options) => {
  const {
    output = { path: "clients", barrelType: "named" },
    group,
    urlType = false,
    exclude = [],
    include,
    override = [],
    transformers = {},
    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: [pluginOasName, parser === "zod" ? pluginZodName : void 0].filter(Boolean),
    resolvePath(baseName, pathMode, options2) {
      const root = path.resolve(this.config.root, this.config.output.path);
      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path));
      if (mode === "single") {
        return path.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 `${camelCase(ctx.group)}Controller`;
        };
        return path.resolve(
          root,
          output.path,
          groupName({
            group: group.type === "path" ? options2.group.path : options2.group.tag
          }),
          baseName
        );
      }
      return path.resolve(root, output.path, baseName);
    },
    resolveName(name, type) {
      const resolvedName = camelCase(name, { isFile: type === "file" });
      if (type) {
        return transformers?.name?.(resolvedName, type) || resolvedName;
      }
      return resolvedName;
    },
    async buildStart() {
      const [swaggerPlugin] = PluginManager.getDependedPlugins(this.plugins, [pluginOasName]);
      const oas = await swaggerPlugin.context.getOas();
      const root = path.resolve(this.config.root, this.config.output.path);
      const mode = FileManager.getMode(path.resolve(root, output.path));
      const baseURL2 = await swaggerPlugin.context.getBaseURL();
      const operationGenerator = new 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,
        meta: {
          pluginKey: this.plugin.key
        },
        logger: this.logger
      });
      await this.addFile(...barrelFiles);
    }
  };
});

export { pluginClient, pluginClientName };
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map