swagger-typescript-api 13.2.7 → 13.2.9

package/dist/lib.d.ts

@@ -1,11 +1,9 @@
-import * as lodash19 from "lodash";
-import * as lodash14 from "lodash";
+import * as lodash0 from "lodash";
 import lodash from "lodash";
-import * as typescript$1 from "typescript";
 import * as typescript from "typescript";
-import * as eta20 from "eta";
+import * as eta0 from "eta";
 import { OpenAPI } from "openapi-types";
-import * as swagger_schema_official16 from "swagger-schema-official";
+import * as swagger_schema_official0 from "swagger-schema-official";
 
 //#region src/schema-components-map.d.ts
 declare class SchemaComponentsMap {
@@ -379,7 +377,7 @@ declare class JavascriptTranslator extends Translator {
   compileTSCode: (input: TranslatorIO) => Record<string, string>;
   translate: (input: any) => Promise<{
     fileName: any;
-    fileExtension: typescript$1.Extension;
+    fileExtension: typescript.Extension;
     fileContent: string;
   }[]>;
 }
@@ -528,7 +526,7 @@ declare class CodeGenProcess {
         }) => string;
         NameResolver: typeof NameResolver;
         _: lodash.LoDashStatic;
-        require: (packageOrPath: string) => Promise<any>;
+        require: (packageOrPath: string) => any;
       };
     };
     getTemplate: (name: string, fileName: string, path?: string) => string | undefined;
@@ -633,7 +631,7 @@ declare class CodeGenProcess {
       }) => string;
       NameResolver: typeof NameResolver;
       _: lodash.LoDashStatic;
-      require: (packageOrPath: string) => Promise<any>;
+      require: (packageOrPath: string) => any;
     };
     config: CodeGenConfig;
   };
@@ -670,7 +668,7 @@ declare class TemplatesWorker {
   getTemplatePaths: (config: CodeGenConfig) => CodeGenConfig["templatePaths"];
   cropExtension: (path: string) => string;
   getTemplateFullPath: (path_: string, fileName: string) => string | undefined;
-  requireFnFromTemplate: (packageOrPath: string) => Promise<any>;
+  requireFnFromTemplate: (packageOrPath: string) => any;
   getTemplate: (name: string, fileName: string, path?: string) => string | undefined;
   getTemplates: ({
     templatePaths
@@ -774,6 +772,54 @@ declare class MonoSchemaParser {
 //#endregion
 //#region types/index.d.ts
 type HttpClientType = (typeof HTTP_CLIENT)[keyof typeof HTTP_CLIENT];
+type CodeGenConstruct = {
+  Keyword: {
+    Number: string;
+    String: string;
+    Boolean: string;
+    Any: string;
+    Void: string;
+    Unknown: string;
+    Null: string;
+    Undefined: string;
+    Object: string;
+    File: string;
+    Date: string;
+    Type: string;
+    Enum: string;
+    Interface: string;
+    Array: string;
+    Record: string;
+    Intersection: string;
+    Union: string;
+  };
+  CodeGenKeyword: {
+    UtilRequiredKeys: string;
+  };
+  ArrayType: (content: unknown) => string;
+  StringValue: (content: unknown) => string;
+  BooleanValue: (content: unknown) => string;
+  NumberValue: (content: unknown) => string;
+  NullValue: (content: unknown) => string;
+  UnionType: (content: unknown) => string;
+  ExpressionGroup: (content: unknown) => string;
+  IntersectionType: (content: unknown) => string;
+  RecordType: (content: unknown) => string;
+  TypeField: (content: unknown) => string;
+  InterfaceDynamicField: (content: unknown) => string;
+  EnumUsageKey: (enumStruct: unknown, key: unknown) => string;
+  EnumField: (content: unknown) => string;
+  EnumFieldDescription: (content: unknown) => string;
+  EnumFieldsWrapper: (content: unknown) => string;
+  ObjectWrapper: (content: unknown) => string;
+  MultilineComment: (content: unknown) => string;
+  TypeWithGeneric: (content: unknown) => string;
+  Tuple: (content: unknown) => string;
+};
+type PrimitiveTypeStructValue = string | ((schema: Record<string, unknown>, parser: SchemaParser) => string);
+type PrimitiveTypeStruct = Record<"integer" | "number" | "boolean" | "object" | "file" | "string" | "array", string | ({
+  $default: PrimitiveTypeStructValue;
+} & Record<string, PrimitiveTypeStructValue>)>;
 type BuildRouteParam = {
   /** {bar} */
   $match: string;
@@ -909,7 +955,7 @@ type RawRouteInfo = {
   description?: string;
   tags?: string[];
   summary?: string;
-  responses?: swagger_schema_official16.Spec["responses"];
+  responses?: swagger_schema_official0.Spec["responses"];
   produces?: string[];
   requestBody?: object;
   consumes?: string[];
@@ -1012,18 +1058,45 @@ type ExtractingOptions = {
 };
 interface GenerateApiConfiguration {
   apiConfig: {
+    /** base url from schema */
     baseUrl: string;
+    /** document title */
     title: string;
+    /** document version */
     version: string;
+    /** description split into lines */
     description: string[];
+    /** flag that description is present */
     hasDescription: boolean;
   };
   config: {
+    /** path to swagger schema */
     input: string;
+    /**
+     * generate separated files for http client, data contracts, and routes
+     * @default false
+     */
+    modular: boolean;
+    /**
+     * path to folder where the created api module will be placed.
+     * may be set to `false` to skip writing content to disk; in this case
+     * the `files` array on the return value will contain the generated contents.
+     */
     output: string | false;
+    /** url to swagger schema */
     url: string;
+    /** swagger schema JSON */
     spec: unknown;
+    /**
+     * file name for the generated API module
+     * @default 'Api.ts'
+     */
     fileName: string;
+    /**
+     * path to folder containing custom templates
+     * @default ""
+     */
+    templates: string;
     templatePaths: {
       /** `templates/base` */
       base: string;
@@ -1036,66 +1109,176 @@ interface GenerateApiConfiguration {
       /** custom path to templates (`--templates`) */
       custom: string | null;
     };
+    /** authorisation token for private swagger schema access */
     authorizationToken?: string;
+    /** generate additional information about request responses and error typings */
     generateResponses: boolean;
+    /**
+     * use "default" response status code as success response.
+     * some swagger schemas treat "default" as a successful response.
+     */
     defaultResponseAsSuccess: boolean;
+    /** generate type definitions for API routes */
     generateRouteTypes: boolean;
+    /** generate an API client */
     generateClient: boolean;
+    /** generate all "enum" types as union types (T1 | T2 | TN) */
     generateUnionEnums: boolean;
+    /** parsed swagger schema */
     swaggerSchema: object;
+    /** original swagger schema */
     originalSchema: object;
+    /** map of schema component references */
     componentsMap: Record<string, SchemaComponent>;
+    /** flag indicating the schema was converted from Swagger 2.0 */
     convertedFromSwagger2: boolean;
+    /** determines which path index should be used for routes separation */
     moduleNameIndex: number;
+    /** use the first tag for the module name */
     moduleNameFirstTag: boolean;
+    /** extra templates */
     extraTemplates: {
       name: string;
       path: string;
     }[];
+    /** extract request params to data contract */
     extractRequestParams: boolean;
+    /** unwrap the data item from the response */
     unwrapResponseData: boolean;
+    /** sort data contracts in alphabetical order */
     sortTypes: boolean;
+    /** sort routes in alphabetical order */
     sortRoutes: boolean;
+    /** ability to send HttpClient instance to Api constructor */
     singleHttpClient: boolean;
+    /** prefix string value for type names */
     typePrefix: string;
+    /** suffix string value for type names */
     typeSuffix: string;
+    /** prefix string value for enum keys */
     enumKeyPrefix: string;
+    /** suffix string value for enum keys */
     enumKeySuffix: string;
+    /** fix up small errors in the swagger source definition */
     patch: boolean;
+    /** remove output directory before generating */
     cleanOutput: boolean;
+    /** output debug messages */
     debug: boolean;
+    /**
+     * generate array types as Array<Type>
+     * @default false
+     */
     anotherArrayType: boolean;
+    /** extract request body type to data contract */
     extractRequestBody: boolean;
+    /** generated http client type */
     httpClientType: "axios" | "fetch";
+    /** generate readonly properties */
     addReadonly: boolean;
+    /** customise primitive type mappings */
+    primitiveTypeConstructs?: (struct: PrimitiveTypeStruct) => Partial<PrimitiveTypeStruct>;
+    /** customise code generation constructs */
+    codeGenConstructs?: (struct: CodeGenConstruct) => Partial<CodeGenConstruct>;
+    /** extract response body type to data contract */
     extractResponseBody: boolean;
+    /** extract response error type to data contract */
     extractResponseError: boolean;
+    /** extract all enums from nested types/interfaces to `enum` construction */
     extractEnums: boolean;
+    /** extract all enums from inline interface/type content to typescript enum construction */
     extractResponses: boolean;
+    /**
+     * prefix string value needed to fix invalid type names
+     * @default "Type"
+     */
     fixInvalidTypeNamePrefix: string;
+    /**
+     * prefix string value needed to fix invalid enum keys
+     * @default "Value"
+     */
     fixInvalidEnumKeyPrefix: string;
+    /**
+     * default type for empty response schema
+     * @default "void"
+     */
     defaultResponseType: string;
+    /**
+     * generate js api module with declaration file
+     * @default false
+     */
     toJS: boolean;
+    /** disable throwing on a non-successful response */
     disableThrowOnError: boolean;
+    /**
+     * output only errors to console
+     * @default false
+     */
     silent: boolean;
+    /** hooks for customising the generation process */
     hooks: Partial<Hooks>;
+    /** use enum names as values */
     enumNamesAsValues: boolean;
+    /** package version */
     version: string;
+    /** ts compiler configuration object (for --to-js option) */
     compilerTsConfig: Record<string, unknown>;
+    /** enum key resolver name */
     enumKeyResolverName: string;
+    /** type name resolver name */
     typeNameResolverName: string;
+    /** specific argument name resolver name */
     specificArgNameResolverName: string;
+    /**
+     * custom ts->* translator
+     * do not use constructor args, just send class reference
+     */
     customTranslator?: new () => Translator;
+    /** internal constants */
+    constants: typeof constants_d_exports;
+    /** code generation constructs for TypeScript */
+    Ts: CodeGenConstruct;
+    /**
+     * swagger schema type -> typescript type
+     * https://json-schema.org/understanding-json-schema/reference/string.html#dates-and-times
+     */
+    primitiveTypes: PrimitiveTypeStruct;
+    /** built-in template info */
+    templateInfos: {
+      name: string;
+      fileName: string;
+    }[];
+    /** supported template file extensions */
+    templateExtensions: string[];
+    /** range of HTTP status codes treated as success */
+    successResponseStatusRange: [number, number];
+    /** custom schema parsers */
+    schemaParsers?: {
+      complexOneOf?: MonoSchemaParser;
+      complexAllOf?: MonoSchemaParser;
+      complexAnyOf?: MonoSchemaParser;
+      complexNot?: MonoSchemaParser;
+      enum?: MonoSchemaParser;
+      object?: MonoSchemaParser;
+      complex?: MonoSchemaParser;
+      primitive?: MonoSchemaParser;
+      discriminator?: MonoSchemaParser;
+      array?: MonoSchemaParser;
+    };
+    /** internal options for templates */
     internalTemplateOptions: {
       addUtilRequiredKeysType: boolean;
     };
+    /** resolver for component type names */
     componentTypeNameResolver: ComponentTypeNameResolver;
+    /** generated file names */
     fileNames: {
       dataContracts: string;
       routeTypes: string;
       httpClient: string;
       outOfModuleApi: string;
     };
+    /** Record<templateName, templateContent> */
     templatesToRender: {
       api: string;
       dataContracts: string;
@@ -1108,10 +1291,16 @@ interface GenerateApiConfiguration {
       enumDataContract: string;
       objectFieldJsDoc: string;
     };
+    /** map of duplicate route names */
     routeNameDuplicatesMap: Map<string, string>;
+    /** name of the main exported class */
     apiClassName: string;
-    requestOptions?: RequestInit;
-    extractingOptions: ExtractingOptions;
+    /** configuration for fetching swagger schema requests */
+    requestOptions?: Partial<RequestInit>;
+    /** extra configuration for extracting type names operations */
+    extractingOptions: Partial<ExtractingOptions>;
+    /** update configuration object during generation */
+    update: (update: Partial<GenerateApiConfiguration["config"]>) => void;
   };
   modelTypes: ModelType[];
   hasFormDataRoutes: boolean;
@@ -1142,7 +1331,7 @@ interface GenerateApiConfiguration {
     fmtToJSDocLine: (line: string, params?: {
       eol?: boolean;
     }) => string;
-    _: lodash19.LoDashStatic;
+    _: lodash0.LoDashStatic;
     require: (path: string) => unknown;
   };
 }
@@ -1163,7 +1352,7 @@ interface GenerateApiOutput {
     content: string;
     withPrefix: boolean;
   }) => void;
-  renderTemplate: (templateContent: string, data: Record<string, unknown>, etaOptions?: Partial<eta20.EtaConfig>) => Promise<string> | string;
+  renderTemplate: (templateContent: string, data: Record<string, unknown>, etaOptions?: Partial<eta0.EtaConfig>) => Promise<string> | string;
   getTemplate: (params: {
     fileName?: string;
     name?: string;
@@ -1585,8 +1774,8 @@ declare function generateApi(config: Partial<GenerateApiConfiguration["config"]>
         eol?: boolean | undefined;
       }) => string;
       NameResolver: typeof NameResolver;
-      _: lodash14.LoDashStatic;
-      require: (packageOrPath: string) => Promise<any>;
+      _: lodash0.LoDashStatic;
+      require: (packageOrPath: string) => any;
     };
   };
   getTemplate: (name: string, fileName: string, path?: string) => string | undefined;

package/dist/lib.js

@@ -1,3 +1,3 @@
-import { constants_exports, generateApi, generateTemplates } from "./src-BgBqKQNC.js";
+import { constants_exports, generateApi, generateTemplates } from "./src-BGOGeWR6.js";
 
 export { constants_exports as constants, generateApi, generateTemplates };

package/dist/{src-DYNtMxii.cjs → src-B-cU8h_Y.cjs}

@@ -35,6 +35,7 @@ const __biomejs_js_api = __toESM(require("@biomejs/js-api"));
 const nanoid = __toESM(require("nanoid"));
 const js_yaml = __toESM(require("js-yaml"));
 const swagger2openapi = __toESM(require("swagger2openapi"));
+const node_module = __toESM(require("node:module"));
 const node_url = __toESM(require("node:url"));
 const eta = __toESM(require("eta"));
 const node_fs = __toESM(require("node:fs"));
@@ -181,7 +182,7 @@ const getRandomInt = (min = 0, max = 1) => {
 var ComponentTypeNameResolver = class extends NameResolver {
 	counter = 1;
 	fallbackNameCounter = 1;
-	countersByVariant = new Map();
+	countersByVariant = /* @__PURE__ */ new Map();
 	constructor(config, reservedNames) {
 		super(config, reservedNames, (variants) => {
 			const randomVariant = variants[getRandomInt(0, variants.length - 1)];
@@ -203,7 +204,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.2.7";
+var version = "13.2.9";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 var homepage = "https://github.com/acacode/swagger-typescript-api";
 var bugs = "https://github.com/acacode/swagger-typescript-api/issues";
@@ -243,10 +244,10 @@ var scripts = {
 	"typedoc": "typedoc"
 };
 var dependencies = {
-	"@biomejs/js-api": "1.0.0",
-	"@biomejs/wasm-nodejs": "2.0.5",
+	"@biomejs/js-api": "3.0.0",
+	"@biomejs/wasm-nodejs": "2.2.2",
 	"@types/swagger-schema-official": "^2.0.25",
-	"c12": "^3.0.4",
+	"c12": "^3.2.0",
 	"citty": "^0.1.6",
 	"consola": "^3.4.2",
 	"eta": "^2.2.0",
@@ -255,25 +256,25 @@ var dependencies = {
 	"nanoid": "^5.1.5",
 	"swagger-schema-official": "2.0.0-bab6bed",
 	"swagger2openapi": "^7.0.8",
-	"typescript": "~5.8.3"
+	"typescript": "~5.9.2"
 };
 var devDependencies = {
-	"@biomejs/biome": "2.0.5",
+	"@biomejs/biome": "2.2.2",
 	"@changesets/changelog-github": "0.5.1",
-	"@changesets/cli": "2.29.5",
+	"@changesets/cli": "2.29.6",
 	"@tsconfig/node18": "18.2.4",
 	"@tsconfig/strictest": "2.0.5",
 	"@types/js-yaml": "4.0.9",
-	"@types/lodash": "4.17.18",
-	"@types/node": "24.0.4",
+	"@types/lodash": "4.17.20",
+	"@types/node": "24.3.0",
 	"@types/swagger2openapi": "7.0.4",
-	"axios": "1.10.0",
+	"axios": "1.11.0",
 	"openapi-types": "12.1.3",
-	"tsdown": "0.12.9",
-	"typedoc": "0.28.5",
+	"tsdown": "0.14.2",
+	"typedoc": "0.28.11",
 	"vitest": "3.2.4"
 };
-var packageManager = "yarn@4.9.2";
+var packageManager = "yarn@4.9.4";
 var engines = { "node": ">=20" };
 var publishConfig = {
 	"access": "public",
@@ -452,7 +453,7 @@ var CodeGenConfig = class {
 		httpClient: "http-client",
 		outOfModuleApi: "Common"
 	};
-	routeNameDuplicatesMap = new Map();
+	routeNameDuplicatesMap = /* @__PURE__ */ new Map();
 	hooks = {
 		onPreBuildRoutePath: (_routePath) => void 0,
 		onBuildRoutePath: (_routeData) => void 0,
@@ -719,6 +720,7 @@ var CodeGenConfig = class {
 	}
 	update = (update) => {
 		objectAssign(this, update);
+		if (this.enumNamesAsValues) this.extractEnums = true;
 	};
 };
 
@@ -1175,9 +1177,19 @@ var EnumSchemaParser = class extends MonoSchemaParser {
 		let content = null;
 		const formatValue = (value) => {
 			if (value === null) return this.config.Ts.NullValue(value);
-			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "number" }))) return this.config.Ts.NumberValue(value);
-			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "boolean" }))) return this.config.Ts.BooleanValue(value);
-			return this.config.Ts.StringValue(value);
+			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "number" }))) {
+				const maybeNumber = typeof value === "number" ? value : Number(value);
+				if (!Number.isNaN(maybeNumber)) return this.config.Ts.NumberValue(maybeNumber);
+			}
+			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "boolean" }))) {
+				if (typeof value === "boolean") return this.config.Ts.BooleanValue(value);
+				if (value === "true" || value === "false") return this.config.Ts.BooleanValue(value === "true");
+			}
+			switch (typeof value) {
+				case "number": return this.config.Ts.NumberValue(value);
+				case "boolean": return this.config.Ts.BooleanValue(value);
+				default: return this.config.Ts.StringValue(value);
+			}
 		};
 		if (Array.isArray(enumNames) && lodash.default.size(enumNames)) content = enumNames.map((enumName, index) => {
 			const enumValue = lodash.default.get(this.schema.enum, index);
@@ -1649,7 +1661,7 @@ var SchemaUtils = class {
 		const refTypeInfo = this.getSchemaRefType(schema);
 		if (refTypeInfo) return this.checkAndAddRequiredKeys(schema, this.safeAddNullToType(schema, this.typeNameFormatter.format(refTypeInfo.typeName)));
 		let resultType;
-		if (this.isConstantSchema(schema)) resultType = this.formatJsValue(schema.const);
+		if (this.isConstantSchema(schema) && !schema.enum) resultType = this.formatJsValue(schema.const);
 		else {
 			const primitiveType = this.getSchemaPrimitiveType(schema);
 			if (primitiveType == null) return this.config.Ts.Keyword.Any;
@@ -1673,10 +1685,9 @@ var SchemaUtils = class {
 			case "string": return this.config.Ts.StringValue(value);
 			case "boolean": return this.config.Ts.BooleanValue(value);
 			case "number": return this.config.Ts.NumberValue(value);
-			default: {
+			default:
 				if (value === null) return this.config.Ts.NullValue(value);
 				return this.config.Ts.Keyword.Any;
-			}
 		}
 	};
 };
@@ -2075,7 +2086,7 @@ var SchemaRoutes = class {
 		};
 	};
 	createRequestParamsSchema = ({ queryParams, queryObjectSchema, pathArgsSchemas, extractRequestParams, routeName }) => {
-		if (!queryParams || !queryParams.length) return null;
+		if ((!queryParams || !queryParams.length) && (!pathArgsSchemas || !pathArgsSchemas.length)) return null;
 		const pathParams = pathArgsSchemas.reduce((acc, pathArgSchema) => {
 			if (pathArgSchema.name) acc[pathArgSchema.name] = {
 				...pathArgSchema,
@@ -2368,8 +2379,8 @@ var SchemaRoutes = class {
 var SchemaWalker = class {
 	config;
 	swaggerSchemaResolver;
-	schemas = new Map();
-	caches = new Map();
+	schemas = /* @__PURE__ */ new Map();
+	caches = /* @__PURE__ */ new Map();
 	constructor(config, swaggerSchemaResolver) {
 		this.config = config;
 		this.swaggerSchemaResolver = swaggerSchemaResolver;
@@ -2505,6 +2516,7 @@ var SwaggerSchemaResolver = class {
 
 //#endregion
 //#region src/templates-worker.ts
+const require$1 = node_module.createRequire(require("url").pathToFileURL(__filename).href);
 var TemplatesWorker = class {
 	config;
 	fileSystem;
@@ -2537,10 +2549,10 @@ var TemplatesWorker = class {
 		const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
 		return pathVariants.find((variant) => !!this.fileSystem.pathIsExist(variant));
 	};
-	requireFnFromTemplate = async (packageOrPath) => {
+	requireFnFromTemplate = (packageOrPath) => {
 		const isPath = packageOrPath.startsWith("./") || packageOrPath.startsWith("../");
-		if (isPath) return await import(node_path.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
-		return await import(packageOrPath);
+		if (isPath) return require$1(node_path.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
+		return require$1(packageOrPath);
 	};
 	getTemplate = (name$1, fileName, path$1) => {
 		const { templatePaths } = this.config;
@@ -2658,7 +2670,7 @@ var JavascriptTranslator = class extends Translator {
 //#endregion
 //#region src/type-name-formatter.ts
 var TypeNameFormatter = class {
-	formattedModelNamesMap = new Map();
+	formattedModelNamesMap = /* @__PURE__ */ new Map();
 	config;
 	constructor(config) {
 		this.config = config;
@@ -3236,4 +3248,4 @@ Object.defineProperty(exports, 'package_default', {
     return package_default;
   }
 });
-//# sourceMappingURL=src-DYNtMxii.cjs.map
+//# sourceMappingURL=src-B-cU8h_Y.cjs.map