@kubb/swagger-ts 1.15.0-canary.20231026T165055 → 1.15.0-canary.20231026T182535

package/dist/hooks.cjs

@@ -0,0 +1,653 @@
+'use strict';
+
+var hooks = require('@kubb/swagger/hooks');
+var path = require('path');
+var core = require('@kubb/core');
+var utils = require('@kubb/core/utils');
+var swagger = require('@kubb/swagger');
+var changeCase = require('change-case');
+var parser = require('@kubb/parser');
+var factory = require('@kubb/parser/factory');
+var utils$1 = require('@kubb/swagger/utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var factory__namespace = /*#__PURE__*/_interopNamespace(factory);
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _usedAliasNames, _caseOptions, _getTypeFromSchema, getTypeFromSchema_fn, _getTypeFromProperties, getTypeFromProperties_fn, _getRefAlias, getRefAlias_fn, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn;
+var TypeGenerator = class extends core.SchemaGenerator {
+  constructor(options = {
+    usedEnumNames: {},
+    withJSDocs: true,
+    resolveName: ({ name }) => name,
+    enumType: "asConst",
+    dateType: "string",
+    optionalType: "questionToken"
+  }) {
+    super(options);
+    /**
+     * Creates a type node from a given schema.
+     * Delegates to getBaseTypeFromSchema internally and
+     * optionally adds a union with null.
+     */
+    __privateAdd(this, _getTypeFromSchema);
+    /**
+     * Recursively creates a type literal with the given props.
+     */
+    __privateAdd(this, _getTypeFromProperties);
+    /**
+     * Create a type alias for the schema referenced by the given ReferenceObject
+     */
+    __privateAdd(this, _getRefAlias);
+    /**
+     * This is the very core of the OpenAPI to TS conversion - it takes a
+     * schema and returns the appropriate type.
+     */
+    __privateAdd(this, _getBaseTypeFromSchema);
+    this.refs = {};
+    this.extraNodes = [];
+    this.aliases = [];
+    // Keep track of already used type aliases
+    __privateAdd(this, _usedAliasNames, {});
+    __privateAdd(this, _caseOptions, {
+      delimiter: "",
+      stripRegexp: /[^A-Z0-9$]/gi
+    });
+    return this;
+  }
+  build({
+    schema,
+    baseName,
+    description,
+    keysToOmit
+  }) {
+    const nodes = [];
+    const type = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema, baseName);
+    if (!type) {
+      return this.extraNodes;
+    }
+    const node = factory__namespace.createTypeAliasDeclaration({
+      modifiers: [factory__namespace.modifiers.export],
+      name: this.options.resolveName({ name: baseName }) || baseName,
+      type: keysToOmit?.length ? factory__namespace.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
+    });
+    if (description) {
+      nodes.push(
+        factory__namespace.appendJSDocToNode({
+          node,
+          comments: [`@description ${description}`]
+        })
+      );
+    } else {
+      nodes.push(node);
+    }
+    const filterdNodes = nodes.filter(
+      (node2) => !this.extraNodes.some(
+        (extraNode) => extraNode?.name?.escapedText === node2?.name?.escapedText
+      )
+    );
+    return [...this.extraNodes, ...filterdNodes];
+  }
+};
+_usedAliasNames = new WeakMap();
+_caseOptions = new WeakMap();
+_getTypeFromSchema = new WeakSet();
+getTypeFromSchema_fn = function(schema, name) {
+  const type = __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schema, name);
+  if (!type) {
+    return null;
+  }
+  if (schema && !schema.nullable) {
+    return type;
+  }
+  return factory__namespace.createUnionDeclaration({ nodes: [type, factory__namespace.keywordTypeNodes.null] });
+};
+_getTypeFromProperties = new WeakSet();
+getTypeFromProperties_fn = function(baseSchema, baseName) {
+  const { optionalType } = this.options;
+  const properties = baseSchema?.properties || {};
+  const required = baseSchema?.required;
+  const additionalProperties = baseSchema?.additionalProperties;
+  const members = Object.keys(properties).map((name) => {
+    const schema = properties[name];
+    const isRequired = required && required.includes(name);
+    let type = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema, this.options.resolveName({ name: `${baseName || ""} ${name}` }));
+    if (!type) {
+      return null;
+    }
+    if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
+      type = factory__namespace.createUnionDeclaration({ nodes: [type, factory__namespace.keywordTypeNodes.undefined] });
+    }
+    const propertySignature = factory__namespace.createPropertySignature({
+      questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
+      name,
+      type,
+      readOnly: schema.readOnly
+    });
+    if (this.options.withJSDocs) {
+      return factory__namespace.appendJSDocToNode({
+        node: propertySignature,
+        comments: [
+          schema.description ? `@description ${schema.description}` : void 0,
+          schema.type ? `@type ${schema.type}${isRequired ? "" : " | undefined"} ${schema.format || ""}` : void 0,
+          schema.example ? `@example ${schema.example}` : void 0,
+          schema.deprecated ? `@deprecated` : void 0,
+          schema.default !== void 0 && typeof schema.default === "string" ? `@default '${schema.default}'` : void 0,
+          schema.default !== void 0 && typeof schema.default !== "string" ? `@default ${schema.default}` : void 0
+        ].filter(Boolean)
+      });
+    }
+    return propertySignature;
+  });
+  if (additionalProperties) {
+    const type = additionalProperties === true ? factory__namespace.keywordTypeNodes.any : __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, additionalProperties);
+    if (type) {
+      members.push(factory__namespace.createIndexSignature(type));
+    }
+  }
+  return factory__namespace.createTypeLiteralNode(members.filter(Boolean));
+};
+_getRefAlias = new WeakSet();
+getRefAlias_fn = function(obj, _baseName) {
+  const { $ref } = obj;
+  let ref = this.refs[$ref];
+  if (ref) {
+    return factory__namespace.createTypeReferenceNode(ref.propertyName, void 0);
+  }
+  const originalName = utils.getUniqueName($ref.replace(/.+\//, ""), __privateGet(this, _usedAliasNames));
+  const propertyName = this.options.resolveName({ name: originalName }) || originalName;
+  ref = this.refs[$ref] = {
+    propertyName,
+    originalName
+  };
+  return factory__namespace.createTypeReferenceNode(ref.propertyName, void 0);
+};
+_getBaseTypeFromSchema = new WeakSet();
+getBaseTypeFromSchema_fn = function(schema, baseName) {
+  if (!schema) {
+    return factory__namespace.keywordTypeNodes.any;
+  }
+  if (utils$1.isReference(schema)) {
+    return __privateMethod(this, _getRefAlias, getRefAlias_fn).call(this, schema, baseName);
+  }
+  if (schema.oneOf) {
+    const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
+    const union = factory__namespace.createUnionDeclaration({
+      withParentheses: true,
+      nodes: schema.oneOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutOneOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutOneOf, baseName), union].filter(Boolean)
+      });
+    }
+    return union;
+  }
+  if (schema.anyOf) {
+    const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
+    const union = factory__namespace.createUnionDeclaration({
+      withParentheses: true,
+      nodes: schema.anyOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutAnyOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutAnyOf, baseName), union].filter(Boolean)
+      });
+    }
+    return union;
+  }
+  if (schema.allOf) {
+    const schemaWithoutAllOf = { ...schema, allOf: void 0 };
+    const and = factory__namespace.createIntersectionDeclaration({
+      withParentheses: true,
+      nodes: schema.allOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutAllOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutAllOf, baseName), and].filter(Boolean)
+      });
+    }
+    return and;
+  }
+  if (schema.enum && baseName) {
+    const enumName = utils.getUniqueName(baseName, this.options.usedEnumNames);
+    let enums = [...new Set(schema.enum)].map((key) => [key, key]);
+    if ("x-enumNames" in schema) {
+      enums = [...new Set(schema["x-enumNames"])].map((key, index) => {
+        return [key, schema.enum?.[index]];
+      });
+    }
+    this.extraNodes.push(
+      ...factory__namespace.createEnumDeclaration({
+        name: changeCase.camelCase(enumName, __privateGet(this, _caseOptions)),
+        typeName: this.options.resolveName({ name: enumName }),
+        enums,
+        type: this.options.enumType
+      })
+    );
+    return factory__namespace.createTypeReferenceNode(this.options.resolveName({ name: enumName }), void 0);
+  }
+  if (schema.enum) {
+    return factory__namespace.createUnionDeclaration({
+      nodes: schema.enum.map((name) => {
+        return factory__namespace.createLiteralTypeNode(typeof name === "number" ? factory__namespace.createNumericLiteral(name) : factory__namespace.createStringLiteral(`${name}`));
+      })
+    });
+  }
+  if ("items" in schema) {
+    const node = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema.items, baseName);
+    if (node) {
+      return factory__namespace.createArrayTypeNode(node);
+    }
+  }
+  if ("prefixItems" in schema) {
+    const prefixItems = schema.prefixItems;
+    return factory__namespace.createTupleDeclaration({
+      nodes: prefixItems.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item, void 0);
+      })
+    });
+  }
+  if (schema.properties || schema.additionalProperties) {
+    return __privateMethod(this, _getTypeFromProperties, getTypeFromProperties_fn).call(this, schema, baseName);
+  }
+  if (schema.type) {
+    if (Array.isArray(schema.type)) {
+      const [type, nullable] = schema.type;
+      return factory__namespace.createUnionDeclaration({
+        nodes: [
+          __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, {
+            ...schema,
+            type
+          }, baseName),
+          nullable ? factory__namespace.createLiteralTypeNode(factory__namespace.createNull()) : void 0
+        ].filter(Boolean)
+      });
+    }
+    if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
+      return factory__namespace.createTypeReferenceNode(factory__namespace.createIdentifier("Date"));
+    }
+    if (schema.type in factory__namespace.keywordTypeNodes) {
+      return factory__namespace.keywordTypeNodes[schema.type];
+    }
+  }
+  if (schema.format === "binary") {
+    return factory__namespace.createTypeReferenceNode("Blob", []);
+  }
+  return factory__namespace.keywordTypeNodes.any;
+};
+
+// src/builders/TypeBuilder.ts
+var TypeBuilder = class extends swagger.OasBuilder {
+  configure(options) {
+    if (options) {
+      this.options = options;
+    }
+    if (this.options.fileResolver) {
+      this.options.withImports = true;
+    }
+    return this;
+  }
+  print(name) {
+    const codes = [];
+    const generated = this.items.filter((operationSchema) => name ? operationSchema.name === name : true).sort(utils.transformers.nameSorter).map((operationSchema) => {
+      const generator = new TypeGenerator({
+        usedEnumNames: this.options.usedEnumNames,
+        withJSDocs: this.options.withJSDocs,
+        resolveName: this.options.resolveName,
+        enumType: this.options.enumType,
+        dateType: this.options.dateType,
+        optionalType: this.options.optionalType
+      });
+      const sources = generator.build({
+        schema: operationSchema.schema,
+        baseName: operationSchema.name,
+        description: operationSchema.description,
+        keysToOmit: operationSchema.keysToOmit
+      });
+      return {
+        import: {
+          refs: generator.refs,
+          name: operationSchema.name
+        },
+        sources
+      };
+    }).sort(utils$1.refsSorter);
+    generated.forEach((item) => {
+      codes.push(parser.print(item.sources));
+    });
+    if (this.options.withImports) {
+      const importsGenerator = new swagger.ImportsGenerator({ fileResolver: this.options.fileResolver });
+      const importMeta = importsGenerator.build(generated.map((item) => item.import));
+      if (importMeta) {
+        const nodes = importMeta.map((item) => {
+          return factory__namespace.createImportDeclaration({
+            name: [{ propertyName: item.ref.propertyName }],
+            path: item.path,
+            isTypeOnly: true
+          });
+        });
+        codes.unshift(parser.print(nodes));
+      }
+    }
+    return utils.transformers.combineCodes(codes);
+  }
+};
+var OperationGenerator = class extends swagger.OperationGenerator {
+  resolve(operation) {
+    const { pluginManager, plugin } = this.context;
+    return swagger.resolve({
+      operation,
+      resolveName: pluginManager.resolveName,
+      resolvePath: pluginManager.resolvePath,
+      pluginKey: plugin?.key
+    });
+  }
+  async all() {
+    return null;
+  }
+  async get(operation, schemas, options) {
+    const { mode, enumType, dateType, optionalType, usedEnumNames } = options;
+    const { pluginManager, plugin } = this.context;
+    const type = this.resolve(operation);
+    const fileResolver = (name) => {
+      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginKey: plugin?.key, options: { tag: operation.getTags()[0]?.name } });
+      const resolvedTypeId = pluginManager.resolvePath({
+        baseName: `${name}.ts`,
+        pluginKey: plugin?.key
+      });
+      return utils.getRelativePath(root, resolvedTypeId);
+    };
+    const source = new TypeBuilder({
+      usedEnumNames,
+      fileResolver: mode === "file" ? void 0 : fileResolver,
+      withJSDocs: true,
+      resolveName: (params) => pluginManager.resolveName({ ...params, pluginKey: plugin?.key }),
+      enumType,
+      optionalType,
+      dateType
+    }).add(schemas.pathParams).add(schemas.queryParams).add(schemas.headerParams).add(schemas.response).add(schemas.errors).configure().print();
+    return {
+      path: type.path,
+      baseName: type.baseName,
+      source,
+      meta: {
+        pluginKey: plugin.key,
+        tag: operation.getTags()[0]?.name
+      }
+    };
+  }
+  async post(operation, schemas, options) {
+    const { mode, enumType, dateType, optionalType, usedEnumNames } = options;
+    const { pluginManager, plugin } = this.context;
+    const type = this.resolve(operation);
+    const fileResolver = (name) => {
+      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginKey: plugin?.key, options: { tag: operation.getTags()[0]?.name } });
+      const resolvedTypeId = pluginManager.resolvePath({
+        baseName: `${name}.ts`,
+        pluginKey: plugin?.key
+      });
+      return utils.getRelativePath(root, resolvedTypeId);
+    };
+    const source = new TypeBuilder({
+      usedEnumNames,
+      fileResolver: mode === "file" ? void 0 : fileResolver,
+      withJSDocs: true,
+      resolveName: (params) => pluginManager.resolveName({ ...params, pluginKey: plugin?.key }),
+      enumType,
+      optionalType,
+      dateType
+    }).add(schemas.pathParams).add(schemas.queryParams).add(schemas.headerParams).add(schemas.request).add(schemas.response).add(schemas.errors).configure().print();
+    return {
+      path: type.path,
+      baseName: type.baseName,
+      source,
+      meta: {
+        pluginKey: plugin.key,
+        tag: operation.getTags()[0]?.name
+      }
+    };
+  }
+  async put(operation, schemas, options) {
+    return this.post(operation, schemas, options);
+  }
+  async patch(operation, schemas, options) {
+    return this.post(operation, schemas, options);
+  }
+  async delete(operation, schemas, options) {
+    return this.post(operation, schemas, options);
+  }
+};
+
+// src/plugin.ts
+var pluginName = "swagger-ts";
+var pluginKey = ["schema", pluginName];
+core.createPlugin((options) => {
+  const {
+    output = "types",
+    groupBy,
+    skipBy = [],
+    overrideBy = [],
+    enumType = "asConst",
+    dateType = "string",
+    optionalType = "questionToken",
+    transformers: transformers2 = {},
+    exportAs
+  } = options;
+  const template = groupBy?.output ? groupBy.output : `${output}/{{tag}}Controller`;
+  let pluginsOptions;
+  return {
+    name: pluginName,
+    options,
+    kind: "schema",
+    validate(plugins) {
+      pluginsOptions = core.PluginManager.getDependedPlugins(plugins, [swagger.pluginName]);
+      return true;
+    },
+    resolvePath(baseName, directory, options2) {
+      const root = path__default.default.resolve(this.config.root, this.config.output.path);
+      const mode = core.FileManager.getMode(path__default.default.resolve(root, output));
+      if (mode === "file") {
+        return path__default.default.resolve(root, output);
+      }
+      if (options2?.tag && groupBy?.type === "tag") {
+        const tag = changeCase.camelCase(options2.tag, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
+        return path__default.default.resolve(root, utils.renderTemplate(template, { tag }), baseName);
+      }
+      return path__default.default.resolve(root, output, baseName);
+    },
+    resolveName(name) {
+      const resolvedName = changeCase.pascalCase(name, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: changeCase.pascalCaseTransformMerge });
+      return transformers2?.name?.(resolvedName) || resolvedName;
+    },
+    async writeFile(source, writePath) {
+      if (!writePath.endsWith(".ts") || !source) {
+        return;
+      }
+      return this.fileManager.write(source, writePath);
+    },
+    async buildStart() {
+      const [swaggerPlugin] = pluginsOptions;
+      const oas = await swaggerPlugin.api.getOas();
+      const schemas = await swaggerPlugin.api.getSchemas();
+      const root = path__default.default.resolve(this.config.root, this.config.output.path);
+      const mode = core.FileManager.getMode(path__default.default.resolve(root, output));
+      const usedEnumNames = {};
+      if (mode === "directory") {
+        const builder = await new TypeBuilder({
+          usedEnumNames,
+          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
+          fileResolver: (name) => {
+            const resolvedTypeId = this.resolvePath({
+              baseName: `${name}.ts`,
+              pluginKey: this.plugin.key
+            });
+            const root2 = this.resolvePath({ baseName: ``, pluginKey: this.plugin.key });
+            return utils.getRelativePath(root2, resolvedTypeId);
+          },
+          withJSDocs: true,
+          enumType,
+          dateType,
+          optionalType
+        }).configure();
+        Object.entries(schemas).forEach(([name, schema]) => {
+          return builder.add({
+            schema,
+            name
+          });
+        });
+        const mapFolderSchema = async ([name]) => {
+          const resolvedPath = this.resolvePath({ baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`, pluginKey: this.plugin.key });
+          if (!resolvedPath) {
+            return null;
+          }
+          return this.addFile({
+            path: resolvedPath,
+            baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`,
+            source: builder.print(name),
+            meta: {
+              pluginKey: this.plugin.key
+            }
+          });
+        };
+        const promises = Object.entries(schemas).map(mapFolderSchema);
+        await Promise.all(promises);
+      }
+      if (mode === "file") {
+        const builder = new TypeBuilder({
+          usedEnumNames,
+          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
+          withJSDocs: true,
+          enumType,
+          dateType,
+          optionalType
+        }).configure();
+        Object.entries(schemas).forEach(([name, schema]) => {
+          return builder.add({
+            schema,
+            name
+          });
+        });
+        const resolvedPath = this.resolvePath({ baseName: "", pluginKey: this.plugin.key });
+        if (!resolvedPath) {
+          return;
+        }
+        await this.addFile({
+          path: resolvedPath,
+          baseName: output,
+          source: builder.print(),
+          meta: {
+            pluginKey: this.plugin.key
+          },
+          validate: false
+        });
+      }
+      const operationGenerator = new OperationGenerator(
+        {
+          mode,
+          enumType,
+          dateType,
+          optionalType,
+          usedEnumNames
+        },
+        {
+          oas,
+          pluginManager: this.pluginManager,
+          plugin: this.plugin,
+          contentType: swaggerPlugin.api.contentType,
+          skipBy,
+          overrideBy
+        }
+      );
+      const files = await operationGenerator.build();
+      await this.addFile(...files);
+    },
+    async buildEnd() {
+      if (this.config.output.write === false) {
+        return;
+      }
+      const root = path__default.default.resolve(this.config.root, this.config.output.path);
+      await this.fileManager.addIndexes({
+        root,
+        extName: ".ts",
+        meta: { pluginKey: this.plugin.key },
+        options: {
+          map: (file) => {
+            return {
+              ...file,
+              exports: file.exports?.map((item) => {
+                if (exportAs) {
+                  return {
+                    ...item,
+                    name: exportAs,
+                    asAlias: !!exportAs
+                  };
+                }
+                return item;
+              })
+            };
+          },
+          output,
+          isTypeOnly: true
+        }
+      });
+    }
+  };
+});
+
+// src/hooks/useResolve.ts
+function useResolve(props = {}) {
+  return hooks.useResolve({ pluginKey, ...props });
+}
+
+exports.useResolve = useResolve;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=hooks.cjs.map