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

package/dist/hooks.js

@@ -1,605 +0,0 @@
-import { createRequire } from 'module';
-import { useResolve as useResolve$1 } from '@kubb/swagger/hooks';
-import path from 'path';
-import { createPlugin, PluginManager, FileManager, SchemaGenerator } from '@kubb/core';
-import { renderTemplate, getRelativePath, transformers, getUniqueName } from '@kubb/core/utils';
-import { pluginName as pluginName$1, OasBuilder, ImportsGenerator, OperationGenerator as OperationGenerator$1, resolve } from '@kubb/swagger';
-import { camelCase, camelCaseTransformMerge, pascalCase, pascalCaseTransformMerge } from 'change-case';
-import { print } from '@kubb/parser';
-import * as factory from '@kubb/parser/factory';
-import { refsSorter, isReference } from '@kubb/swagger/utils';
-
-createRequire(import.meta.url);
-var TypeGenerator = class extends SchemaGenerator {
-  refs = {};
-  extraNodes = [];
-  aliases = [];
-  // Keep track of already used type aliases
-  #usedAliasNames = {};
-  #caseOptions = {
-    delimiter: "",
-    stripRegexp: /[^A-Z0-9$]/gi
-  };
-  constructor(options = {
-    usedEnumNames: {},
-    withJSDocs: true,
-    resolveName: ({ name }) => name,
-    enumType: "asConst",
-    dateType: "string",
-    optionalType: "questionToken"
-  }) {
-    super(options);
-    return this;
-  }
-  build({
-    schema,
-    baseName,
-    description,
-    keysToOmit
-  }) {
-    const nodes = [];
-    const type = this.#getTypeFromSchema(schema, baseName);
-    if (!type) {
-      return this.extraNodes;
-    }
-    const node = factory.createTypeAliasDeclaration({
-      modifiers: [factory.modifiers.export],
-      name: this.options.resolveName({ name: baseName }) || baseName,
-      type: keysToOmit?.length ? factory.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
-    });
-    if (description) {
-      nodes.push(
-        factory.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];
-  }
-  /**
-   * Creates a type node from a given schema.
-   * Delegates to getBaseTypeFromSchema internally and
-   * optionally adds a union with null.
-   */
-  #getTypeFromSchema(schema, name) {
-    const type = this.#getBaseTypeFromSchema(schema, name);
-    if (!type) {
-      return null;
-    }
-    if (schema && !schema.nullable) {
-      return type;
-    }
-    return factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.null] });
-  }
-  /**
-   * Recursively creates a type literal with the given props.
-   */
-  #getTypeFromProperties(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 = this.#getTypeFromSchema(schema, this.options.resolveName({ name: `${baseName || ""} ${name}` }));
-      if (!type) {
-        return null;
-      }
-      if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-        type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.undefined] });
-      }
-      const propertySignature = factory.createPropertySignature({
-        questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
-        name,
-        type,
-        readOnly: schema.readOnly
-      });
-      if (this.options.withJSDocs) {
-        return factory.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.keywordTypeNodes.any : this.#getTypeFromSchema(additionalProperties);
-      if (type) {
-        members.push(factory.createIndexSignature(type));
-      }
-    }
-    return factory.createTypeLiteralNode(members.filter(Boolean));
-  }
-  /**
-   * Create a type alias for the schema referenced by the given ReferenceObject
-   */
-  #getRefAlias(obj, _baseName) {
-    const { $ref } = obj;
-    let ref = this.refs[$ref];
-    if (ref) {
-      return factory.createTypeReferenceNode(ref.propertyName, void 0);
-    }
-    const originalName = getUniqueName($ref.replace(/.+\//, ""), this.#usedAliasNames);
-    const propertyName = this.options.resolveName({ name: originalName }) || originalName;
-    ref = this.refs[$ref] = {
-      propertyName,
-      originalName
-    };
-    return factory.createTypeReferenceNode(ref.propertyName, void 0);
-  }
-  /**
-   * This is the very core of the OpenAPI to TS conversion - it takes a
-   * schema and returns the appropriate type.
-   */
-  #getBaseTypeFromSchema(schema, baseName) {
-    if (!schema) {
-      return factory.keywordTypeNodes.any;
-    }
-    if (isReference(schema)) {
-      return this.#getRefAlias(schema, baseName);
-    }
-    if (schema.oneOf) {
-      const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
-      const union = factory.createUnionDeclaration({
-        withParentheses: true,
-        nodes: schema.oneOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== factory.keywordTypeNodes.any;
-        })
-      });
-      if (schemaWithoutOneOf.properties) {
-        return factory.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean)
-        });
-      }
-      return union;
-    }
-    if (schema.anyOf) {
-      const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
-      const union = factory.createUnionDeclaration({
-        withParentheses: true,
-        nodes: schema.anyOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== factory.keywordTypeNodes.any;
-        })
-      });
-      if (schemaWithoutAnyOf.properties) {
-        return factory.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAnyOf, baseName), union].filter(Boolean)
-        });
-      }
-      return union;
-    }
-    if (schema.allOf) {
-      const schemaWithoutAllOf = { ...schema, allOf: void 0 };
-      const and = factory.createIntersectionDeclaration({
-        withParentheses: true,
-        nodes: schema.allOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== factory.keywordTypeNodes.any;
-        })
-      });
-      if (schemaWithoutAllOf.properties) {
-        return factory.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
-        });
-      }
-      return and;
-    }
-    if (schema.enum && baseName) {
-      const enumName = 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.createEnumDeclaration({
-          name: camelCase(enumName, this.#caseOptions),
-          typeName: this.options.resolveName({ name: enumName }),
-          enums,
-          type: this.options.enumType
-        })
-      );
-      return factory.createTypeReferenceNode(this.options.resolveName({ name: enumName }), void 0);
-    }
-    if (schema.enum) {
-      return factory.createUnionDeclaration({
-        nodes: schema.enum.map((name) => {
-          return factory.createLiteralTypeNode(typeof name === "number" ? factory.createNumericLiteral(name) : factory.createStringLiteral(`${name}`));
-        })
-      });
-    }
-    if ("items" in schema) {
-      const node = this.#getTypeFromSchema(schema.items, baseName);
-      if (node) {
-        return factory.createArrayTypeNode(node);
-      }
-    }
-    if ("prefixItems" in schema) {
-      const prefixItems = schema.prefixItems;
-      return factory.createTupleDeclaration({
-        nodes: prefixItems.map((item) => {
-          return this.#getBaseTypeFromSchema(item, void 0);
-        })
-      });
-    }
-    if (schema.properties || schema.additionalProperties) {
-      return this.#getTypeFromProperties(schema, baseName);
-    }
-    if (schema.type) {
-      if (Array.isArray(schema.type)) {
-        const [type, nullable] = schema.type;
-        return factory.createUnionDeclaration({
-          nodes: [
-            this.#getBaseTypeFromSchema(
-              {
-                ...schema,
-                type
-              },
-              baseName
-            ),
-            nullable ? factory.createLiteralTypeNode(factory.createNull()) : void 0
-          ].filter(Boolean)
-        });
-      }
-      if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
-        return factory.createTypeReferenceNode(factory.createIdentifier("Date"));
-      }
-      if (schema.type in factory.keywordTypeNodes) {
-        return factory.keywordTypeNodes[schema.type];
-      }
-    }
-    if (schema.format === "binary") {
-      return factory.createTypeReferenceNode("Blob", []);
-    }
-    return factory.keywordTypeNodes.any;
-  }
-};
-
-// src/builders/TypeBuilder.ts
-var TypeBuilder = class extends 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(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(refsSorter);
-    generated.forEach((item) => {
-      codes.push(print(item.sources));
-    });
-    if (this.options.withImports) {
-      const importsGenerator = new ImportsGenerator({ fileResolver: this.options.fileResolver });
-      const importMeta = importsGenerator.build(generated.map((item) => item.import));
-      if (importMeta) {
-        const nodes = importMeta.map((item) => {
-          return factory.createImportDeclaration({
-            name: [{ propertyName: item.ref.propertyName }],
-            path: item.path,
-            isTypeOnly: true
-          });
-        });
-        codes.unshift(print(nodes));
-      }
-    }
-    return transformers.combineCodes(codes);
-  }
-};
-var OperationGenerator = class extends OperationGenerator$1 {
-  resolve(operation) {
-    const { pluginManager, plugin } = this.context;
-    return 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 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 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];
-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 = PluginManager.getDependedPlugins(plugins, [pluginName$1]);
-      return true;
-    },
-    resolvePath(baseName, directory, options2) {
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = FileManager.getMode(path.resolve(root, output));
-      if (mode === "file") {
-        return path.resolve(root, output);
-      }
-      if (options2?.tag && groupBy?.type === "tag") {
-        const tag = camelCase(options2.tag, { delimiter: "", transform: camelCaseTransformMerge });
-        return path.resolve(root, renderTemplate(template, { tag }), baseName);
-      }
-      return path.resolve(root, output, baseName);
-    },
-    resolveName(name) {
-      const resolvedName = pascalCase(name, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: 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.resolve(this.config.root, this.config.output.path);
-      const mode = FileManager.getMode(path.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 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.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 useResolve$1({ pluginKey, ...props });
-}
-
-export { useResolve };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=hooks.js.map