@penkov/swagger-code-gen 1.12.0 → 1.14.0

package/dist/method.js

@@ -7,6 +7,12 @@ export const SHARED_BODIES_PREFIX = '#/components/requestBodies/';
 const sortByIn = HashMap.of(['path', 0], ['query', 1], ['header', 2], ['cookie', 3], ['body', 4]);
 export const supportedBodyMimeTypes = HashMap.of(['application/json', 'Json'], ['application/x-www-form-urlencoded', 'Form'], ['multipart/form-data', 'File'], ['application/octet-stream', 'Binary']);
 export class Method {
+    static parseModeByMimeType(mimeType) {
+        if (mimeType.startsWith('text/') || mimeType.includes('xml')) {
+            return 'text';
+        }
+        return 'json';
+    }
     constructor(path, method, def, schemasTypes, options, pool) {
         this.path = path;
         this.method = method;
@@ -132,10 +138,27 @@ export class Method {
             .getOrElseValue({});
         const mimeTypes = option(respDef.content)
             .map(content => Collection.from(Object.keys(content)).toMap(mimeType => [mimeType, content[mimeType]])).getOrElseValue(HashMap.empty);
-        this.response = mimeTypes.get('application/json')
-            .orElseValue(mimeTypes.values.headOption)
-            .filter(p => option(p.schema).isDefined)
+        const responseMimeType = mimeTypes.get('application/json')
+            .map(_ => 'application/json')
+            .orElse(() => mimeTypes.keySet.headOption)
+            .getOrElseValue('application/json');
+        const responseParseMode = Method.parseModeByMimeType(responseMimeType);
+        this.response = mimeTypes.get(responseMimeType)
+            .filter(p => option(p.schema).isDefined || responseParseMode === 'text')
             .map(p => {
+            if (responseParseMode === 'text') {
+                const r = Property.fromDefinition('', '', { type: 'string' }, schemasTypes, options).copy({
+                    nullable: false,
+                    required: true,
+                });
+                return {
+                    asProperty: r,
+                    responseType: 'string',
+                    description: respDef.description,
+                    mimeType: responseMimeType,
+                    parseMode: responseParseMode,
+                };
+            }
             if (p.schema.type === 'object' && p.schema['properties'] && Object.keys(p.schema['properties']).length > 0) {
                 const inPlaceObject = NameUtils.normaliseClassname(def.operationId + 'Response$' + method);
                 const r = Property.fromDefinition(inPlaceObject, '', {
@@ -149,7 +172,9 @@ export class Method {
                     asProperty: r,
                     responseType: inPlaceObject,
                     description: respDef.description,
-                    inPlace: p.schema
+                    inPlace: p.schema,
+                    mimeType: responseMimeType,
+                    parseMode: responseParseMode,
                 };
             }
             else {
@@ -161,12 +186,16 @@ export class Method {
                     asProperty: r,
                     responseType: r.jsType,
                     description: respDef.description,
+                    mimeType: responseMimeType,
+                    parseMode: responseParseMode,
                 };
             }
         })
             .getOrElseValue(({
             asProperty: Property.fromDefinition('', 'UNKNOWN', { type: 'any' }, schemasTypes, options),
             responseType: 'any',
+            mimeType: responseMimeType,
+            parseMode: responseParseMode,
         }));
         this.wrapParamsInObject = this.parameters.size > 2 || (this.body.nonEmpty) && this.parameters.nonEmpty;
     }

package/dist/renderer.js

@@ -3,11 +3,11 @@ import * as fs from 'fs';
 import path, { dirname } from 'path';
 import { fileURLToPath } from 'url';
 import * as scatsLib from 'scats';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+const currentFilename = typeof __filename !== 'undefined' ? __filename : fileURLToPath(import.meta.url);
+const currentDirname = typeof __dirname !== 'undefined' ? __dirname : dirname(currentFilename);
 export class Renderer {
     async renderToFile(schemas, methods, enableScats, targetNode, file) {
-        const view = await ejs.renderFile(path.resolve(__dirname, 'templates/index.ejs'), {
+        const view = await ejs.renderFile(path.resolve(currentDirname, 'templates/index.ejs'), {
             scatsLib: scatsLib,
             schemas: schemas,
             methods: methods,

package/dist/templates/index.ejs

@@ -86,11 +86,17 @@ function objectToFormWwwEncoded(o: Record<string, any>): string {
         .join('&');
 }
 
-async function requestImpl<T>(request: Request, requestOptions: RequestOptions): Promise<T> {
+type ResponseParseMode = 'json' | 'text';
+
+async function requestImpl<T>(request: Request, requestOptions: RequestOptions, parseMode: ResponseParseMode = 'json'): Promise<T> {
     const preProcessed = requestOptions.preProcessRequest ? await requestOptions.preProcessRequest(request) : request;
     const resp = await fetch(preProcessed);
     const postProcessed = requestOptions.postProcessResponse ? await requestOptions.postProcessResponse(preProcessed, resp) : resp;
     if (postProcessed.ok) {
+        if (parseMode === 'text') {
+            return (await postProcessed.text()) as T;
+        }
+
         let json: any = null;
         if (postProcessed.headers.has('content-length')) {
             const ctLent = postProcessed.headers.get('content-length');
@@ -140,4 +146,3 @@ methods.foreach(method => {
 
 <% } %>
 
-

package/dist/templates/method.ejs

@@ -46,7 +46,7 @@ export async function <%= method.endpointName %><%= body.map(b => b.suffix).getO
     <%_ }  -%>
     <%_ }) -%>
     <%_ method.parameters.filter(x => x.in === 'query' && !x.required).foreach(p => { -%>
-    if (!!<%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %>) {
+    if (<%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %> !== undefined) {
         <%_ if (p.isArray) { -%>
         <%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %>.forEach(p => {
             queryParams.push(`<%= p.name %>=${p}`);
@@ -76,7 +76,7 @@ export async function <%= method.endpointName %><%= body.map(b => b.suffix).getO
 
     const headers: HeadersInit = {
         ...requestOptions.headers || {},
-        'Accept': 'application/json',
+        'Accept': '<%= method.response.mimeType %>',
         <%_ if (body.nonEmpty && body.get.mimeType !== 'multipart/form-data') {%>
         'Content-Type': '<%= body.get.mimeType %>',
         <%_ }  -%>
@@ -97,5 +97,5 @@ export async function <%= method.endpointName %><%= body.map(b => b.suffix).getO
         signal: requestOptions.signal,
         headers: headers
     });
-    return requestImpl<<%- method.response.responseType %>>(request, requestOptions);
+    return requestImpl<<%- method.response.responseType %>>(request, requestOptions, '<%= method.response.parseMode %>');
 }

package/jest.config.cjs

@@ -0,0 +1,18 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest/presets/default-esm',
+  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts'],
+  transform: {
+    '^.+\\.(ts|tsx)$': [
+      'ts-jest',
+      {
+        useESM: true,
+        tsconfig: './tsconfig.jest.json'
+      }
+    ]
+  },
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1'
+  }
+};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@penkov/swagger-code-gen",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "type": "module",
   "bin": {
-    "generate-client": "./dist/cli.mjs"
+    "generate-client": "dist/cli.mjs"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/papirosko/swagger-code-gen"
+    "url": "git+https://github.com/papirosko/swagger-code-gen.git"
   },
   "keywords": [
     "swagger",
@@ -22,6 +22,7 @@
   },
   "homepage": "https://github.com/papirosko/swagger-code-gen#readme",
   "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
     "test:petstore": "node --loader ts-node/esm ./src/cli.mjs --enableScats --targetNode --url https://petstore3.swagger.io/api/v3/openapi.json tmp/petstore.ts",
     "clean": "rimraf dist",
     "lint": "eslint \"{src,test}/**/*.ts\" --fix",
@@ -39,10 +40,13 @@
   },
   "devDependencies": {
     "@types/ejs": "^3.1.1",
+    "@types/jest": "^29.5.12",
     "@typescript-eslint/eslint-plugin": "^5.10.2",
     "@typescript-eslint/parser": "^5.10.2",
     "eslint": "^7.30.0",
+    "jest": "^29.7.0",
     "rimraf": "^3.0.2",
+    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
     "typescript": "^4.9.3"
   }

package/tsconfig.jest.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "moduleResolution": "node",
+    "target": "ES2020",
+    "isolatedModules": true,
+    "types": ["jest"]
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.mjs",
+    "test/**/*.ts"
+  ]
+}

package/AGENTS.md

@@ -1,34 +0,0 @@
-# Repository Guidelines
-
-## Project Structure & Module Organization
-- Core TypeScript sources live in `src/` (CLI in `src/cli.mjs`, generators in `src/openapi.ts`, `src/renderer.ts`, helpers in `src/name.utils.ts`, etc.).
-- Handlebars/EJS-style templates for emitted clients are under `src/templates/`; they are copied to `dist/templates/` during build.
-- Built artifacts output to `dist/` (ESM). Keep `dist/` out of PR diffs unless you're publishing.
-- Temporary outputs from local runs can go in `tmp/`; avoid committing generated clients.
-
-## Build, Test, and Development Commands
-- `npm run lint` — ESLint over `src/**/*.ts`; fixes simple style issues.
-- `npm run build` — Type-checks with `tsc`, lints, cleans `dist/`, copies templates, and makes the CLI executable.
-- `npm run test:petstore` — Integration sanity check that generates a client from the public Petstore spec into `tmp/petstore.ts`.
-- Local usage example while developing: `node --loader ts-node/esm ./src/cli.mjs --url <openapi.json> --targetNode tmp/client.ts`.
-
-## Coding Style & Naming Conventions
-- TypeScript, ESM (`"type": "module"`). Prefer `export`/`import` syntax and avoid CommonJS.
-- Indentation: 2 spaces; keep lines concise and avoid trailing whitespace.
-- Naming: PascalCase for types/interfaces/classes; camelCase for functions/variables; kebab-case for filenames (`method.ts`, `components-parse.ts`).
-- Keep pure generation logic inside `src/` modules; CLI wiring belongs in `src/cli.mjs`.
-- Run `npm run lint` before pushing; configure editors to respect the repo’s ESLint/TypeScript settings (`tsconfig.json`, `tsconfig-eslint.json`).
-
-## Testing Guidelines
-- Primary check is code generation parity; use `npm run test:petstore` after generator changes to ensure emitted code compiles and fetch imports are wired when `--targetNode` is used.
-- When adding new parsing/rendering logic, add a minimal fixture OpenAPI snippet under `tmp/` (ignored) and exercise `src/cli.mjs` with `ts-node` to confirm types render as expected.
-- Prefer assertions in future tests under `test/` with `ts-node` if you add unit coverage; mirror file names of the modules under test.
-
-## Commit & Pull Request Guidelines
-- Follow existing history: `release: x.y.z` for version bumps; otherwise use `type: short-description` (e.g., `fix: handle nullable refs`, `feat: add tag filter`).
-- Keep PRs small and scoped (parser vs renderer vs CLI). Describe the OpenAPI inputs you validated against and attach generated output snippets when relevant.
-- Link issues when applicable; include reproduction steps for bugs and the exact CLI command used.
-
-## Security & Configuration Tips
-- Treat remote specs as untrusted; prefer HTTPS URLs and avoid embedding secrets in command examples.
-- Generated clients may import `node-fetch` when `--targetNode` is passed; ensure the consumer installs it if targeting Node.