Support non-ascii (unicode) enum and type names.

.github/workflows/unittest.yml

@@ -0,0 +1,37 @@
+name: unittest
+
+on: [pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4.1.1
+
+      - name: Setup Node environment
+        uses: actions/setup-node@v4.0.1
+        with:
+          node-version: 20
+
+      - name: Cache Modules
+        uses: actions/cache@v4
+        with:
+          path: "**/node_modules"
+          key: ${{ runner.os }}-modules-${{ hashFiles('**/package-lock.json') }}
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build library
+        run: npm run release
+
+      - name: Run unit tests
+        run: npm run test
+
+      # - name: Run e2e tests
+      #   run: npm run test:e2e
+
+      # - name: Submit to Codecov
+      #   run: npm run codecov
+

.gitignore

@@ -15,3 +15,4 @@ test/e2e/generated
 samples/generated
 samples/swagger-codegen-cli-v2.jar
 samples/swagger-codegen-cli-v3.jar
+.env

README.md

@@ -43,8 +43,8 @@ $ openapi --help
     --useOptions              Use options instead of arguments
     --useUnionTypes           Use union types instead of enums
     --exportCore <value>      Write core files to disk (default: true)
-    --exportServices <value>  Write services to disk (default: true)
-    --exportModels <value>    Write models to disk (default: true)
+    --exportServices <value>  Write services to disk [true, false, regexp] (default: true)
+    --exportModels <value>    Write models to disk [true, false, regexp] (default: true)
     --exportSchemas <value>   Write schemas to disk (default: false)
     --indent <value>          Indentation options [4, 2, tab] (default: "4")
     --postfixServices         Service name postfix (default: "Service")

bin/index.js

@@ -16,6 +16,7 @@ const params = program
     .option('--name <value>', 'Custom client class name')
     .option('--useOptions', 'Use options instead of arguments')
     .option('--useUnionTypes', 'Use union types instead of enums')
+    .option('--autoformat', 'Process generated files with autoformatter', false)
     .option('--exportCore <value>', 'Write core files to disk', true)
     .option('--exportServices <value>', 'Write services to disk', true)
     .option('--exportModels <value>', 'Write models to disk', true)
@@ -29,6 +30,14 @@ const params = program
 
 const OpenAPI = require(path.resolve(__dirname, '../dist/index.js'));
 
+const parseBooleanOrString = value => {
+    try {
+        return JSON.parse(value) === true;
+    } catch (error) {
+        return value;
+    }
+};
+
 if (OpenAPI) {
     OpenAPI.generate({
         input: params.input,
@@ -37,9 +46,10 @@ if (OpenAPI) {
         clientName: params.name,
         useOptions: params.useOptions,
         useUnionTypes: params.useUnionTypes,
+        autoformat: JSON.parse(params.autoformat) === true,
         exportCore: JSON.parse(params.exportCore) === true,
-        exportServices: JSON.parse(params.exportServices) === true,
-        exportModels: JSON.parse(params.exportModels) === true,
+        exportServices: parseBooleanOrString(params.exportServices),
+        exportModels: parseBooleanOrString(params.exportModels),
         exportSchemas: JSON.parse(params.exportSchemas) === true,
         indent: params.indent,
         postfixServices: params.postfixServices,

bin/index.spec.js

@@ -43,6 +43,35 @@ describe('bin', () => {
         expect(result.stderr.toString()).toBe('');
     });
 
+    it('it should support regexp params', async () => {
+        const result = crossSpawn.sync('node', [
+            './bin/index.js',
+            '--input',
+            './test/spec/v3.json',
+            '--output',
+            './test/generated/bin',
+            '--exportServices',
+            '^(Simple|Types)',
+            '--exportModels',
+            '^(Simple|Types)',
+        ]);
+        expect(result.stdout.toString()).toBe('');
+        expect(result.stderr.toString()).toBe('');
+    });
+
+    it('should autoformat with Prettier', async () => {
+        const result = crossSpawn.sync('node', [
+            './bin/index.js',
+            '--input',
+            './test/spec/v3.json',
+            '--output',
+            './test/generated/bin',
+            '--autoformat',
+        ]);
+        expect(result.stdout.toString()).toBe('');
+        expect(result.stderr.toString()).toBe('');
+    });
+
     it('it should throw error without params', async () => {
         const result = crossSpawn.sync('node', ['./bin/index.js']);
         expect(result.stdout.toString()).toBe('');

package.json

@@ -1,12 +1,12 @@
 {
-    "name": "openapi-typescript-codegen",
-    "version": "0.27.0",
+    "name": "@nicolas-chaulet/openapi-typescript-codegen",
+    "version": "0.27.6",
     "description": "Library that generates Typescript clients based on the OpenAPI specification.",
     "author": "Ferdi Koomen",
-    "homepage": "https://github.com/ferdikoomen/openapi-typescript-codegen",
+    "homepage": "https://github.com/CanoaPBC/openapi-typescript-codegen",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/ferdikoomen/openapi-typescript-codegen.git"
+        "url": "git+https://github.com/CanoaPBC/openapi-typescript-codegen.git"
     },
     "bugs": {
         "url": "https://github.com/ferdikoomen/openapi-typescript-codegen/issues"

src/client/interfaces/Model.d.ts

@@ -3,7 +3,17 @@ import type { Schema } from './Schema';
 
 export interface Model extends Schema {
     name: string;
-    export: 'reference' | 'generic' | 'enum' | 'array' | 'dictionary' | 'interface' | 'one-of' | 'any-of' | 'all-of';
+    export:
+        | 'reference'
+        | 'generic'
+        | 'enum'
+        | 'array'
+        | 'dictionary'
+        | 'interface'
+        | 'one-of'
+        | 'any-of'
+        | 'all-of'
+        | 'const';
     type: string;
     base: string;
     template: string | null;

src/client/interfaces/ModelComposition.d.ts

@@ -1,8 +1,8 @@
 import type { Model } from './Model';
 
 export interface ModelComposition {
-    type: 'one-of' | 'any-of' | 'all-of';
-    imports: string[];
     enums: Model[];
+    export: 'one-of' | 'any-of' | 'all-of';
+    imports: string[];
     properties: Model[];
 }

src/index.ts

@@ -19,9 +19,10 @@ export type Options = {
     clientName?: string;
     useOptions?: boolean;
     useUnionTypes?: boolean;
+    autoformat?: boolean;
     exportCore?: boolean;
-    exportServices?: boolean;
-    exportModels?: boolean;
+    exportServices?: boolean | string;
+    exportModels?: boolean | string;
     exportSchemas?: boolean;
     indent?: Indent;
     postfixServices?: string;
@@ -57,6 +58,7 @@ export const generate = async ({
     clientName,
     useOptions = false,
     useUnionTypes = false,
+    autoformat = false,
     exportCore = true,
     exportServices = true,
     exportModels = true,
@@ -75,42 +77,32 @@ export const generate = async ({
         useOptions,
     });
 
+    let parser: typeof parseV2 | typeof parseV3;
+
     switch (openApiVersion) {
         case OpenApiVersion.V2: {
-            const client = parseV2(openApi);
-            const clientFinal = postProcessClient(client);
-            if (!write) break;
-            await writeClient(
-                clientFinal,
-                templates,
-                output,
-                httpClient,
-                useOptions,
-                useUnionTypes,
-                exportCore,
-                exportServices,
-                exportModels,
-                exportSchemas,
-                indent,
-                postfixServices,
-                postfixModels,
-                clientName,
-                request
-            );
+            parser = parseV2;
             break;
         }
 
         case OpenApiVersion.V3: {
-            const client = parseV3(openApi);
-            const clientFinal = postProcessClient(client);
-            if (!write) break;
+            parser = parseV3;
+            break;
+        }
+    }
+
+    if (parser) {
+        const client = parser(openApi);
+        const clientFinal = postProcessClient(client);
+        if (write) {
             await writeClient(
                 clientFinal,
                 templates,
                 output,
                 httpClient,
                 useOptions,
                 useUnionTypes,
+                autoformat,
                 exportCore,
                 exportServices,
                 exportModels,
@@ -121,7 +113,6 @@ export const generate = async ({
                 clientName,
                 request
             );
-            break;
         }
     }
 };

src/openApi/v2/parser/escapeName.ts

@@ -1,6 +1,8 @@
+import validTypescriptIdentifierRegex from '../../../utils/validTypescriptIdentifierRegex';
+
 export const escapeName = (value: string): string => {
     if (value || value === '') {
-        const validName = /^[a-zA-Z_$][\w$]+$/g.test(value);
+        const validName = validTypescriptIdentifierRegex.test(value);
         if (!validName) {
             return `'${value}'`;
         }

src/openApi/v2/parser/getEnum.ts

@@ -1,4 +1,5 @@
 import type { Enum } from '../../../client/interfaces/Enum';
+import sanitizeEnumName from '../../../utils/sanitizeEnumName';
 
 export const getEnum = (values?: (string | number)[]): Enum[] => {
     if (Array.isArray(values)) {
@@ -19,11 +20,7 @@ export const getEnum = (values?: (string | number)[]): Enum[] => {
                     };
                 }
                 return {
-                    name: String(value)
-                        .replace(/\W+/g, '_')
-                        .replace(/^(\d+)/g, '_$1')
-                        .replace(/([a-z])([A-Z]+)/g, '$1_$2')
-                        .toUpperCase(),
+                    name: sanitizeEnumName(String(value)),
                     value: `'${value.replace(/'/g, "\\'")}'`,
                     type: 'string',
                     description: null,

src/openApi/v2/parser/getModel.ts

@@ -112,7 +112,7 @@ export const getModel = (
 
     if (definition.allOf?.length) {
         const composition = getModelComposition(openApi, definition, definition.allOf, 'all-of', getModel);
-        model.export = composition.type;
+        model.export = composition.export;
         model.imports.push(...composition.imports);
         model.properties.push(...composition.properties);
         model.enums.push(...composition.enums);

src/openApi/v2/parser/getModelComposition.ts

@@ -17,9 +17,9 @@ export const getModelComposition = (
     getModel: GetModelFn
 ): ModelComposition => {
     const composition: ModelComposition = {
-        type,
-        imports: [],
         enums: [],
+        export: type,
+        imports: [],
         properties: [],
     };
 

src/openApi/v2/parser/getOperationResponse.ts

@@ -18,8 +18,8 @@ export const getOperationResponse = (
         code: responseCode,
         description: response.description || null,
         export: 'generic',
-        type: 'any',
-        base: 'any',
+        type: responseCode !== 204 ? 'any' : 'void',
+        base: responseCode !== 204 ? 'any' : 'void',
         template: null,
         link: null,
         isDefinition: false,

src/openApi/v2/parser/getOperationResults.ts

@@ -12,36 +12,14 @@ const areEqual = (a: Model, b: Model): boolean => {
 export const getOperationResults = (operationResponses: OperationResponse[]): OperationResponse[] => {
     const operationResults: OperationResponse[] = [];
 
-    // Filter out success response codes, but skip "204 No Content"
+    // Filter out success response codes
     operationResponses.forEach(operationResponse => {
         const { code } = operationResponse;
-        if (code && code !== 204 && code >= 200 && code < 300) {
+        if (code && code >= 200 && code < 300) {
             operationResults.push(operationResponse);
         }
     });
 
-    if (!operationResults.length) {
-        operationResults.push({
-            in: 'response',
-            name: '',
-            code: 200,
-            description: '',
-            export: 'generic',
-            type: 'void',
-            base: 'void',
-            template: null,
-            link: null,
-            isDefinition: false,
-            isReadOnly: false,
-            isRequired: false,
-            isNullable: false,
-            imports: [],
-            enum: [],
-            enums: [],
-            properties: [],
-        });
-    }
-
     return operationResults.filter((operationResult, index, arr) => {
         return (
             arr.findIndex(item => {

src/openApi/v2/parser/getType.ts

@@ -1,10 +1,9 @@
 import type { Type } from '../../../client/interfaces/Type';
+import sanitizeTypeName from '../../../utils/sanitizeTypeName';
 import { getMappedType } from './getMappedType';
 import { stripNamespace } from './stripNamespace';
 
-const encode = (value: string): string => {
-    return value.replace(/^[^a-zA-Z_$]+/g, '').replace(/[^\w$]+/g, '_');
-};
+const encode = (value: string): string => sanitizeTypeName(value);
 
 /**
  * Parse any string value into a type object.

src/openApi/v3/interfaces/OpenApiRequestBody.d.ts

@@ -6,8 +6,9 @@ import type { OpenApiReference } from './OpenApiReference';
  * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#requestBodyObject
  */
 export interface OpenApiRequestBody extends OpenApiReference {
-    description?: string;
+    'x-body-name'?: string;
     content: Dictionary<OpenApiMediaType>;
-    required?: boolean;
+    description?: string;
     nullable?: boolean;
+    required?: boolean;
 }