@kubb/swagger-ts 2.9.1 → 2.11.0

package/dist/chunk-QIZFD754.js

@@ -0,0 +1,613 @@
+// src/plugin.ts
+import path from "path";
+import { createPlugin, FileManager, PluginManager } from "@kubb/core";
+import { camelCase, pascalCase } from "@kubb/core/transformers";
+import { renderTemplate } from "@kubb/core/utils";
+import { pluginName as swaggerPluginName } from "@kubb/swagger";
+
+// src/OperationGenerator.tsx
+import { createRoot as createRoot2 } from "@kubb/react";
+import { OperationGenerator as Generator2 } from "@kubb/swagger";
+import { Oas as Oas3 } from "@kubb/swagger/components";
+
+// src/components/OasType.tsx
+import { Editor, File, Type, usePlugin } from "@kubb/react";
+import { useGetFile } from "@kubb/react";
+import { useOas } from "@kubb/swagger/hooks";
+import { Fragment, jsx, jsxs } from "@kubb/react/jsx-runtime";
+function Template({
+  name,
+  typeName,
+  api
+}) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const`,
+    /* @__PURE__ */ jsx("br", {}),
+    /* @__PURE__ */ jsx(Type, { name: typeName, export: true, children: `Infer<typeof ${name}>` })
+  ] });
+}
+var defaultTemplates = { default: Template };
+function OasType({
+  name,
+  typeName,
+  Template: Template2 = defaultTemplates.default
+}) {
+  const oas = useOas();
+  return /* @__PURE__ */ jsx(Template2, { name, typeName, api: oas.api });
+}
+OasType.File = function({ name, typeName, templates = defaultTemplates }) {
+  const { key: pluginKey2 } = usePlugin();
+  const file = useGetFile({ name, extName: ".ts", pluginKey: pluginKey2 });
+  const Template2 = templates.default;
+  return /* @__PURE__ */ jsx(Editor, { language: "typescript", children: /* @__PURE__ */ jsxs(
+    File,
+    {
+      baseName: file.baseName,
+      path: file.path,
+      meta: file.meta,
+      children: [
+        /* @__PURE__ */ jsx(File.Import, { name: ["Infer"], path: "@kubb/swagger-ts/oas", isTypeOnly: true }),
+        /* @__PURE__ */ jsx(File.Source, { children: /* @__PURE__ */ jsx(OasType, { Template: Template2, name, typeName }) })
+      ]
+    }
+  ) });
+};
+OasType.templates = defaultTemplates;
+
+// src/components/OperationSchema.tsx
+import transformers2 from "@kubb/core/transformers";
+import { print as print2 } from "@kubb/parser";
+import * as factory2 from "@kubb/parser/factory";
+import { Editor as Editor2, File as File2, usePlugin as usePlugin2, usePluginManager } from "@kubb/react";
+import { Oas as Oas2, Schema as Schema2 } from "@kubb/swagger/components";
+import { useGetOperationFile, useOas as useOas2, useOperation, useOperationName, useOperationSchemas } from "@kubb/swagger/hooks";
+
+// src/SchemaGenerator.tsx
+import { createRoot } from "@kubb/react";
+import { SchemaGenerator as Generator } from "@kubb/swagger";
+import { Oas, Schema } from "@kubb/swagger/components";
+
+// src/typeParser.ts
+import transformers from "@kubb/core/transformers";
+import { print } from "@kubb/parser";
+import * as factory from "@kubb/parser/factory";
+import { isKeyword, SchemaGenerator, schemaKeywords } from "@kubb/swagger";
+var typeKeywordMapper = {
+  any: () => factory.keywordTypeNodes.any,
+  unknown: () => factory.keywordTypeNodes.unknown,
+  number: () => factory.keywordTypeNodes.number,
+  integer: () => factory.keywordTypeNodes.number,
+  object: (nodes) => {
+    if (!nodes) {
+      return factory.keywordTypeNodes.object;
+    }
+    return factory.createTypeLiteralNode(nodes);
+  },
+  lazy: void 0,
+  string: () => factory.keywordTypeNodes.string,
+  boolean: () => factory.keywordTypeNodes.boolean,
+  undefined: () => factory.keywordTypeNodes.undefined,
+  nullable: void 0,
+  null: () => factory.keywordTypeNodes.null,
+  nullish: void 0,
+  array: (nodes) => {
+    if (!nodes) {
+      return void 0;
+    }
+    return factory.createArrayDeclaration({ nodes });
+  },
+  tuple: (nodes) => {
+    if (!nodes) {
+      return void 0;
+    }
+    return factory.createTupleTypeNode(nodes);
+  },
+  enum: (name) => {
+    if (!name) {
+      return void 0;
+    }
+    return factory.createTypeReferenceNode(name, void 0);
+  },
+  union: (nodes) => {
+    if (!nodes) {
+      return void 0;
+    }
+    return factory.createUnionDeclaration({
+      withParentheses: true,
+      nodes
+    });
+  },
+  const: (name, format) => {
+    if (!name) {
+      return void 0;
+    }
+    if (format === "number") {
+      return factory.createLiteralTypeNode(factory.createNumericLiteral(name));
+    }
+    return factory.createLiteralTypeNode(factory.createStringLiteral(name.toString()));
+  },
+  datetime: () => factory.keywordTypeNodes.string,
+  date: () => factory.createTypeReferenceNode(factory.createIdentifier("Date")),
+  uuid: void 0,
+  url: void 0,
+  strict: void 0,
+  default: void 0,
+  and: (nodes) => {
+    if (!nodes) {
+      return void 0;
+    }
+    return factory.createIntersectionDeclaration({
+      withParentheses: true,
+      nodes
+    });
+  },
+  describe: void 0,
+  min: void 0,
+  max: void 0,
+  optional: void 0,
+  matches: void 0,
+  email: void 0,
+  firstName: void 0,
+  lastName: void 0,
+  password: void 0,
+  phone: void 0,
+  readOnly: void 0,
+  ref: (propertyName) => {
+    if (!propertyName) {
+      return void 0;
+    }
+    return factory.createTypeReferenceNode(propertyName, void 0);
+  },
+  blob: () => factory.createTypeReferenceNode("Blob", []),
+  deprecated: void 0,
+  example: void 0,
+  type: void 0,
+  format: void 0,
+  catchall: void 0
+};
+function parseTypeMeta(item, options) {
+  const mapper = options.mapper || typeKeywordMapper;
+  const value = mapper[item.keyword];
+  if (!value) {
+    return void 0;
+  }
+  if (isKeyword(item, schemaKeywords.union)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.map((orItem) => parseTypeMeta(orItem, options)).filter(Boolean));
+  }
+  if (isKeyword(item, schemaKeywords.and)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.map((orItem) => parseTypeMeta(orItem, options)).filter(Boolean));
+  }
+  if (isKeyword(item, schemaKeywords.array)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.items.map((orItem) => parseTypeMeta(orItem, options)).filter(Boolean));
+  }
+  if (isKeyword(item, schemaKeywords.enum)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.typeName);
+  }
+  if (isKeyword(item, schemaKeywords.ref)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.name);
+  }
+  if (isKeyword(item, schemaKeywords.blob)) {
+    return value();
+  }
+  if (isKeyword(item, schemaKeywords.tuple)) {
+    const value2 = mapper[item.keyword];
+    return value2(
+      item.args.map((tupleItem) => parseTypeMeta(tupleItem, options)).filter(Boolean)
+    );
+  }
+  if (isKeyword(item, schemaKeywords.const)) {
+    const value2 = mapper[item.keyword];
+    return value2(item.args.name, item.args.format);
+  }
+  if (isKeyword(item, schemaKeywords.object)) {
+    const value2 = mapper[item.keyword];
+    const properties = Object.entries(item.args?.properties || {}).filter((item2) => {
+      const schemas = item2[1];
+      return schemas && typeof schemas.map === "function";
+    }).map((item2) => {
+      const name = item2[0];
+      const schemas = item2[1];
+      const isNullish = schemas.some((item3) => item3.keyword === schemaKeywords.nullish);
+      const isNullable = schemas.some((item3) => item3.keyword === schemaKeywords.nullable);
+      const isOptional = schemas.some((item3) => item3.keyword === schemaKeywords.optional);
+      const isReadonly = schemas.some((item3) => item3.keyword === schemaKeywords.readOnly);
+      const describeSchema = schemas.find((item3) => item3.keyword === schemaKeywords.describe);
+      const deprecatedSchema = schemas.find((item3) => item3.keyword === schemaKeywords.deprecated);
+      const defaultSchema = schemas.find((item3) => item3.keyword === schemaKeywords.default);
+      const exampleSchema = schemas.find((item3) => item3.keyword === schemaKeywords.example);
+      const typeSchema = schemas.find((item3) => item3.keyword === schemaKeywords.type);
+      const formatSchema = schemas.find((item3) => item3.keyword === schemaKeywords.format);
+      let type = schemas.map((item3) => parseTypeMeta(item3, options)).filter(Boolean)[0];
+      if (isNullable) {
+        type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.null] });
+      }
+      if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
+        type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.undefined] });
+      }
+      if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
+        type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.undefined] });
+      }
+      const propertySignature = factory.createPropertySignature({
+        questionToken: isOptional && ["questionToken", "questionTokenAndUndefined"].includes(options.optionalType),
+        name,
+        type,
+        readOnly: isReadonly
+      });
+      return factory.appendJSDocToNode({
+        node: propertySignature,
+        comments: [
+          describeSchema ? `@description ${transformers.jsStringEscape(describeSchema.args)}` : void 0,
+          deprecatedSchema ? `@deprecated` : void 0,
+          defaultSchema ? `@default ${defaultSchema.args}` : void 0,
+          exampleSchema ? `@example ${exampleSchema.args}` : void 0,
+          typeSchema ? `@type ${typeSchema.args}${!isOptional ? "" : " | undefined"} ${formatSchema?.args || ""}` : void 0
+        ].filter(Boolean)
+      });
+    });
+    const additionalProperties = item.args?.additionalProperties?.length ? factory.createIndexSignature(item.args.additionalProperties.map((schema) => parseTypeMeta(schema, options)).filter(Boolean).at(0)) : void 0;
+    return value2([...properties, additionalProperties].filter(Boolean));
+  }
+  if (item.keyword in mapper) {
+    return value();
+  }
+  return void 0;
+}
+function typeParser(schemas, options) {
+  const nodes = [];
+  const extraNodes = [];
+  if (!schemas.length) {
+    return "";
+  }
+  const isNullish = schemas.some((item) => item.keyword === schemaKeywords.nullish);
+  const isNullable = schemas.some((item) => item.keyword === schemaKeywords.nullable);
+  const isOptional = schemas.some((item) => item.keyword === schemaKeywords.optional);
+  let type = schemas.map((schema) => parseTypeMeta(schema, options)).filter(Boolean).at(0) || typeKeywordMapper.undefined();
+  if (isNullable) {
+    type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.null] });
+  }
+  if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
+    type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.undefined] });
+  }
+  if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
+    type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.undefined] });
+  }
+  const node = factory.createTypeAliasDeclaration({
+    modifiers: [factory.modifiers.export],
+    name: options.name,
+    type: options.keysToOmit?.length ? factory.createOmitDeclaration({ keys: options.keysToOmit, type, nonNullable: true }) : type
+  });
+  const enumSchemas = SchemaGenerator.deepSearch(schemas, schemaKeywords.enum);
+  if (enumSchemas) {
+    enumSchemas.forEach((enumSchema) => {
+      extraNodes.push(...factory.createEnumDeclaration({
+        name: transformers.camelCase(enumSchema.args.name),
+        typeName: enumSchema.args.typeName,
+        enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers.trimQuotes(item.name?.toString()), item.value]).filter(
+          Boolean
+        ),
+        type: options.enumType
+      }));
+    });
+  }
+  nodes.push(
+    factory.appendJSDocToNode({
+      node,
+      comments: [
+        options.description ? `@description ${transformers.jsStringEscape(options.description)}` : void 0
+      ].filter(Boolean)
+    })
+  );
+  const filterdNodes = nodes.filter(
+    (node2) => !extraNodes.some(
+      (extraNode) => extraNode?.name?.escapedText === node2?.name?.escapedText
+    )
+  );
+  return print([...extraNodes, ...filterdNodes]);
+}
+
+// src/SchemaGenerator.tsx
+import { jsx as jsx2 } from "@kubb/react/jsx-runtime";
+var SchemaGenerator2 = class extends Generator {
+  async schema(name, object) {
+    const { oas, pluginManager, mode, plugin, output } = this.context;
+    const root = createRoot({ logger: pluginManager.logger });
+    root.render(
+      /* @__PURE__ */ jsx2(Oas, { oas, children: /* @__PURE__ */ jsx2(Oas.Schema, { generator: this, name, object, children: /* @__PURE__ */ jsx2(Schema.File, { isTypeOnly: true, output, mode }) }) }),
+      { meta: { pluginManager, plugin } }
+    );
+    return root.files;
+  }
+  // TODO convert to a react component called `Schema.Parser` with props parser as part of the SchemaContext
+  getSource(name, schemas, {
+    keysToOmit,
+    description
+  } = {}) {
+    const texts = [];
+    const resolvedName = this.context.pluginManager.resolveName({ name, pluginKey, type: "function" });
+    const resvoledTypeName = this.context.pluginManager.resolveName({ name, pluginKey, type: "type" });
+    const typeOutput = typeParser(schemas, {
+      name: resolvedName,
+      typeName: resvoledTypeName,
+      description,
+      enumType: this.options.enumType || "asConst",
+      optionalType: this.options.optionalType,
+      keysToOmit
+    });
+    texts.push(typeOutput);
+    return texts;
+  }
+  /**
+   * @deprecated only used for testing
+   */
+  buildSource(name, schema, options = {}) {
+    const schemas = this.buildSchemas(schema, name);
+    return this.getSource(name, schemas, options);
+  }
+};
+
+// src/components/OperationSchema.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs2 } from "@kubb/react/jsx-runtime";
+function printCombinedSchema(name, operation, schemas) {
+  const properties = {
+    "response": factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.response.name),
+      void 0
+    )
+  };
+  if (schemas.request) {
+    properties["request"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.request.name),
+      void 0
+    );
+  }
+  if (schemas.pathParams) {
+    properties["pathParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.pathParams.name),
+      void 0
+    );
+  }
+  if (schemas.queryParams) {
+    properties["queryParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.queryParams.name),
+      void 0
+    );
+  }
+  if (schemas.headerParams) {
+    properties["headerParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.headerParams.name),
+      void 0
+    );
+  }
+  if (schemas.errors) {
+    properties["errors"] = factory2.createUnionDeclaration({
+      nodes: schemas.errors.map((error) => {
+        return factory2.createTypeReferenceNode(
+          factory2.createIdentifier(error.name),
+          void 0
+        );
+      })
+    });
+  }
+  const namespaceNode = factory2.createTypeAliasDeclaration({
+    name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
+    type: factory2.createTypeLiteralNode(
+      Object.keys(properties).map((key) => {
+        const type = properties[key];
+        if (!type) {
+          return void 0;
+        }
+        return factory2.createPropertySignature(
+          {
+            name: transformers2.pascalCase(key),
+            type
+          }
+        );
+      }).filter(Boolean)
+    ),
+    modifiers: [factory2.modifiers.export]
+  });
+  return print2(namespaceNode);
+}
+function OperationSchema({}) {
+  return /* @__PURE__ */ jsx3(Fragment2, {});
+}
+OperationSchema.File = function({ mode = "directory" }) {
+  const plugin = usePlugin2();
+  const pluginManager = usePluginManager();
+  const oas = useOas2();
+  const schemas = useOperationSchemas();
+  const file = useGetOperationFile();
+  const factoryName = useOperationName({ type: "type" });
+  const operation = useOperation();
+  const generator = new SchemaGenerator2(plugin.options, { oas, plugin, pluginManager });
+  const items = [
+    schemas.pathParams,
+    schemas.queryParams,
+    schemas.headerParams,
+    schemas.statusCodes,
+    schemas.request,
+    schemas.response
+  ].flat().filter(Boolean);
+  const mapItem = ({ name, schema: object, ...options }, i) => {
+    return /* @__PURE__ */ jsxs2(Oas2.Schema, { generator, name, object, children: [
+      mode === "directory" && /* @__PURE__ */ jsx3(Schema2.Imports, { isTypeOnly: true }),
+      /* @__PURE__ */ jsx3(File2.Source, { children: /* @__PURE__ */ jsx3(Schema2.Source, { options }) })
+    ] }, i);
+  };
+  return /* @__PURE__ */ jsx3(Editor2, { language: "typescript", children: /* @__PURE__ */ jsxs2(
+    File2,
+    {
+      baseName: file.baseName,
+      path: file.path,
+      meta: file.meta,
+      children: [
+        items.map(mapItem),
+        /* @__PURE__ */ jsx3(File2.Source, { children: printCombinedSchema(factoryName, operation, schemas) })
+      ]
+    }
+  ) });
+};
+
+// src/OperationGenerator.tsx
+import { jsx as jsx4 } from "@kubb/react/jsx-runtime";
+var OperationGenerator = class extends Generator2 {
+  async all(operations) {
+    const { oas, pluginManager, plugin } = this.context;
+    const root = createRoot2({ logger: pluginManager.logger });
+    root.render(
+      /* @__PURE__ */ jsx4(Oas3, { oas, operations, getOperationSchemas: (...props) => this.getSchemas(...props), children: plugin.options.oasType && /* @__PURE__ */ jsx4(OasType.File, { name: "oas", typeName: "Oas" }) }),
+      { meta: { pluginManager, plugin } }
+    );
+    return root.files;
+  }
+  async operation(operation, options) {
+    const { oas, pluginManager, plugin, mode } = this.context;
+    const root = createRoot2({ logger: pluginManager.logger });
+    root.render(
+      /* @__PURE__ */ jsx4(Oas3, { oas, operations: [operation], getOperationSchemas: (...props) => this.getSchemas(...props), children: /* @__PURE__ */ jsx4(Oas3.Operation, { operation, children: /* @__PURE__ */ jsx4(OperationSchema.File, { mode }) }) }),
+      { meta: { pluginManager, plugin: { ...plugin, options } } }
+    );
+    return root.files;
+  }
+  async get() {
+    return null;
+  }
+  async post() {
+    return null;
+  }
+  async put() {
+    return null;
+  }
+  async patch() {
+    return null;
+  }
+  async delete() {
+    return null;
+  }
+};
+
+// src/plugin.ts
+var pluginName = "swagger-ts";
+var pluginKey = [pluginName];
+var definePlugin = createPlugin((options) => {
+  const {
+    output = { path: "types" },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    enumType = "asConst",
+    enumSuffix = "",
+    dateType = "string",
+    unknownType = "any",
+    optionalType = "questionToken",
+    transformers: transformers3 = {},
+    oasType = false
+  } = options;
+  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
+  return {
+    name: pluginName,
+    options: {
+      transformers: transformers3,
+      dateType,
+      optionalType,
+      oasType,
+      enumType,
+      enumSuffix,
+      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
+      usedEnumNames: {},
+      unknownType
+    },
+    pre: [swaggerPluginName],
+    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 === "file") {
+        return path.resolve(root, output.path);
+      }
+      if (options2?.tag && group?.type === "tag") {
+        const tag = camelCase(options2.tag);
+        return path.resolve(root, renderTemplate(template, { tag }), baseName);
+      }
+      return path.resolve(root, output.path, baseName);
+    },
+    resolveName(name, type) {
+      const resolvedName = pascalCase(name, { isFile: type === "file" });
+      if (type) {
+        return transformers3?.name?.(resolvedName, type) || resolvedName;
+      }
+      return resolvedName;
+    },
+    async writeFile(source, writePath) {
+      if (!writePath.endsWith(".ts") || !source) {
+        return;
+      }
+      return this.fileManager.write(source, writePath, { sanity: false });
+    },
+    async buildStart() {
+      const [swaggerPlugin] = PluginManager.getDependedPlugins(this.plugins, [swaggerPluginName]);
+      const oas = await swaggerPlugin.api.getOas();
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const mode = FileManager.getMode(path.resolve(root, output.path));
+      const schemaGenerator = new SchemaGenerator2(
+        this.plugin.options,
+        {
+          oas,
+          pluginManager: this.pluginManager,
+          plugin: this.plugin,
+          contentType: swaggerPlugin.api.contentType,
+          include: void 0,
+          mode,
+          output: output.path
+        }
+      );
+      const schemaFiles = await schemaGenerator.build();
+      await this.addFile(...schemaFiles);
+      const operationGenerator = new OperationGenerator(
+        this.plugin.options,
+        {
+          oas,
+          pluginManager: this.pluginManager,
+          plugin: this.plugin,
+          contentType: swaggerPlugin.api.contentType,
+          exclude,
+          include,
+          override,
+          mode
+        }
+      );
+      const operationFiles = await operationGenerator.build();
+      await this.addFile(...operationFiles);
+    },
+    async buildEnd() {
+      if (this.config.output.write === false) {
+        return;
+      }
+      const root = path.resolve(this.config.root, this.config.output.path);
+      await this.fileManager.addIndexes({
+        root,
+        output,
+        meta: { pluginKey: this.plugin.key }
+      });
+    }
+  };
+});
+
+// src/index.ts
+var definePluginDefault = definePlugin;
+var src_default = definePluginDefault;
+
+export {
+  OasType,
+  OperationSchema,
+  pluginName,
+  pluginKey,
+  definePlugin,
+  src_default
+};
+//# sourceMappingURL=chunk-QIZFD754.js.map