- Added flag to enable the optional generation of schemas and services

Author: ferdikoomen

.prettierrc.json

@@ -2,6 +2,6 @@
     "semi": true,
     "singleQuote": true,
     "trailingComma": "es5",
-    "printWidth": 500,
+    "printWidth": 200,
     "tabWidth": 4
 }

README.md

@@ -56,59 +56,170 @@ const OpenAPI = require('openapi-typescript-codegen');
 
 OpenAPI.generate({
     input: './api/openapi.json',
-    output: './dist'
+    output: './generated'
 });
 ```
 
 Or by providing the JSON directly:
 
 ```javascript
 const OpenAPI = require('openapi-typescript-codegen');
+
 const spec = require('./api/openapi.json');
 
 OpenAPI.generate({
     input: spec,
-    output: './dist'
+    output: './generated'
 });
 ```
 
 ## Features
 
 ### Argument-style vs. Object-style
-There's no [named parameter](https://en.wikipedia.org/wiki/Named_parameter) in JS/TS, because of that,
-we offer an option `--useOptions` to generate code in two different styles.
+There's no [named parameter](https://en.wikipedia.org/wiki/Named_parameter) in Javascript or Typescript, because of
+that, we offer the flag `--useOptions` to generate code in two different styles.
 
 Argument-style:
 ```typescript
 function createUser(name: string, password: string, type?: string, address?: string) {
     // ...
 }
 
-// usage
+// Usage
 createUser('Jack', '123456', undefined, 'NY US');
 ```
 
 Object-style:
 ```typescript
-interface CreateUserOptions {
+function createUser({ name, password, type, address }: {
     name: string,
     password: string,
     type?: string
     address?: string
-}
-
-function createUser({ name, password, type, address }: CreateUserOptions) {
+}) {
     // ...
 }
 
-// usage
+// Usage
 createUser({
     name: 'Jack',
     password: '123456',
     address: 'NY US'
 });
 ```
 
+
+### Runtime schemas
+By default the OpenAPI generator only exports interfaces for your models. These interfaces will help you during
+development, but will not be available in javascript during runtime. However Swagger allows you to define properties
+that can be useful during runtime, for instance: `maxLength` of a string or a `pattern` to match, etc. Let's say
+we have the following model:
+
+```json
+{
+    "MyModel": {
+        "required": [
+            "key",
+            "name"
+        ],
+        "type": "object",
+        "properties": {
+            "key": {
+                "maxLength": 64,
+                "pattern": "^[a-zA-Z0-9_]*$",
+                "type": "string"
+            },
+            "name": {
+                "maxLength": 255,
+                "type": "string"
+            },
+            "enabled": {
+                "type": "boolean",
+                "readOnly": true
+            },
+            "modified": {
+                "type": "string",
+                "format": "date-time",
+                "readOnly": true
+            }
+        }
+    }
+}
+```
+
+This will generate the following interface:
+
+```typescript
+export interface ModelWithPattern {
+    key: string;
+    name: string;
+    readonly enabled?: boolean;
+    readonly modified?: string;
+}
+```
+
+The interface does not contain any properties like `maxLength` or `pattern`. However they could be useful
+if we wanted to create some form where a user could create such a model. In that form you would iterate
+over the properties to render form fields based on their type and validate the input based on the `maxLength`
+or `pattern` property. This requires us to have this information somewhere... For this we can use the
+flag `--exportSchemas` to generate a runtime model next to the normal interface:
+
+```typescript
+export const $ModelWithPattern = {
+    properties: {
+        key: {
+            type: 'string',
+            isRequired: true,
+            maxLength: 64,
+            pattern: '^[a-zA-Z0-9_]*$',
+        },
+        name: {
+            type: 'string',
+            isRequired: true,
+            maxLength: 255,
+        },
+        enabled: {
+            type: 'boolean',
+            isReadOnly: true,
+        },
+        modified: {
+            type: 'string',
+            isReadOnly: true,
+            format: 'date-time',
+        },
+    },
+};
+```
+
+These runtime object are prefixed with a `$` character and expose all the interesting attributes of a model
+and it's properties. We can now use this object to generate the form:
+
+```typescript jsx
+import { $ModelWithPattern } from './generated';
+
+// Some pseudo code to iterate over the properties and return a form field
+// the form field could be some abstract component that renders the correct
+// field type and validation rules based on the given input.
+const formFields = Object.entries($ModelWithPattern.properties).map(([key, value]) => (
+    <FormField
+        name={key}
+        type={value.type}
+        format={value.format}
+        maxLength={value.maxLength}
+        pattern={value.pattern}
+        isReadOnly={value.isReadOnly}
+    />
+));
+
+const MyForm = () => (
+    <form>
+        {formFields}
+    </form>
+);
+
+```
+
+
 ### Enum with custom names and descriptions
 You can use `x-enum-varnames` and `x-enum-descriptions` in your spec to generate enum with custom names and descriptions.
 It's not in official [spec](https://github.com/OAI/OpenAPI-Specification/issues/681) yet. But its a supported extension
@@ -159,6 +270,7 @@ The OpenAPI generator supports Bearer Token authorization. In order to enable th
 of tokens in each request you can set the token using the global OpenAPI configuration:
 
 ```typescript
-import { OpenAPI } from './'
-OpenAPI.TOKEN = 'some-bearer-token'
+import { OpenAPI } from './generated';
+
+OpenAPI.TOKEN = 'some-bearer-token';
 ```

bin/index.js

@@ -13,6 +13,8 @@ program
     .option('--client [value]', 'HTTP client to generate [fetch, xhr]', 'fetch')
     .option('--useOptions', 'Use options vs arguments style functions', false)
     .option('--useUnionTypes', 'Use inclusive union types', false)
+    .option('--exportServices', 'Generate services', true)
+    .option('--exportSchemas', 'Generate schemas', false)
     .parse(process.argv);
 
 const OpenAPI = require(path.resolve(__dirname, '../dist/index.js'));
@@ -23,6 +25,8 @@ if (OpenAPI) {
         output: program.output,
         httpClient: program.client,
         useOptions: program.useOptions,
-        useUnionTypes: program.useUnionTypes
+        useUnionTypes: program.useUnionTypes,
+        exportServices: program.exportServices,
+        exportSchemas: program.exportSchemas,
     });
 }

package.json

@@ -1,6 +1,6 @@
 {
     "name": "openapi-typescript-codegen",
-    "version": "0.2.4",
+    "version": "0.2.5",
     "description": "NodeJS library that generates Typescript or Javascript clients based on the OpenAPI specification.",
     "author": "Ferdi Koomen",
     "homepage": "https://github.com/ferdikoomen/openapi-typescript-codegen",
@@ -63,7 +63,6 @@
     "dependencies": {
         "camelcase": "5.3.1",
         "commander": "4.1.1",
-        "glob": "7.1.6",
         "handlebars": "4.7.3",
         "js-yaml": "3.13.1",
         "mkdirp": "1.0.3",
@@ -86,6 +85,7 @@
         "eslint-config-prettier": "6.10.0",
         "eslint-plugin-prettier": "3.1.2",
         "eslint-plugin-simple-import-sort": "5.0.1",
+        "glob": "7.1.6",
         "jest": "25.1.0",
         "jest-cli": "25.1.0",
         "prettier": "1.19.1",

src/index.ts

@@ -18,6 +18,8 @@ export interface Options {
     httpClient?: HttpClient;
     useOptions?: boolean;
     useUnionTypes?: boolean;
+    exportServices?: boolean;
+    exportSchemas?: boolean;
     write?: boolean;
 }
 
@@ -30,9 +32,11 @@ export interface Options {
  * @param httpClient The selected httpClient (fetch or XHR).
  * @param useOptions Use options or arguments functions.
  * @param useUnionTypes Use inclusive union types.
+ * @param exportServices: Generate services.
+ * @param exportSchemas: Generate schemas.
  * @param write Write the files to disk (true or false).
  */
-export function generate({ input, output, httpClient = HttpClient.FETCH, useOptions = false, useUnionTypes = false, write = true }: Options): void {
+export function generate({ input, output, httpClient = HttpClient.FETCH, useOptions = false, useUnionTypes = false, exportServices = true, exportSchemas = false, write = true }: Options): void {
     try {
         // Load the specification, read the OpenAPI version and load the
         // handlebar templates for the given language
@@ -45,7 +49,7 @@ export function generate({ input, output, httpClient = HttpClient.FETCH, useOpti
                 const client = parseV2(openApi);
                 const clientFinal = postProcessClient(client, useUnionTypes);
                 if (write) {
-                    writeClient(clientFinal, templates, output, httpClient, useOptions);
+                    writeClient(clientFinal, templates, output, httpClient, useOptions, exportServices, exportSchemas);
                 }
                 break;
             }
@@ -54,7 +58,7 @@ export function generate({ input, output, httpClient = HttpClient.FETCH, useOpti
                 const client = parseV3(openApi);
                 const clientFinal = postProcessClient(client, useUnionTypes);
                 if (write) {
-                    writeClient(clientFinal, templates, output, httpClient, useOptions);
+                    writeClient(clientFinal, templates, output, httpClient, useOptions, exportServices, exportSchemas);
                 }
                 break;
             }

src/templates/core/requestUsingFetch.ts

@@ -12,7 +12,6 @@ import { Result } from './Result';
  * @param response Response object from fetch
  */
 async function parseBody(response: Response): Promise<any> {
-
     try {
         const contentType = response.headers.get('Content-Type');
         if (contentType) {

src/templates/core/requestUsingXHR.ts

@@ -28,7 +28,6 @@ function parseBody(xhr: XMLHttpRequest): any {
     } catch (e) {
         console.error(e);
     }
-
     return null;
 }
 

src/templates/index.hbs

@@ -2,25 +2,31 @@
 /* tslint:disable */
 /* eslint-disable */
 /* prettier-ignore */
+{{#if exportServices}}
 
 export { ApiError } from './core/ApiError';
 export { isSuccess } from './core/isSuccess';
 export { OpenAPI } from './core/OpenAPI';
+{{/if}}
 {{#if models}}
 
 {{#each models}}
 export { {{{this}}} } from './models/{{{this}}}';
 {{/each}}
 {{/if}}
+{{#if exportSchemas}}
 {{#if models}}
 
 {{#each models}}
 export { ${{{this}}} } from './schemas/${{{this}}}';
 {{/each}}
 {{/if}}
+{{/if}}
+{{#if exportServices}}
 {{#if services}}
 
 {{#each services}}
 export { {{{this}}} } from './services/{{{this}}}';
 {{/each}}
 {{/if}}
+{{/if}}

src/utils/readHandlebarsTemplate.ts

@@ -6,26 +6,19 @@ import * as Handlebars from 'handlebars';
  * @param filePath
  */
 export function readHandlebarsTemplate(filePath: string): Handlebars.TemplateDelegate {
-    if (fs.existsSync(filePath)) {
-        try {
-            const template = fs
-                .readFileSync(filePath, 'utf8')
-                .toString()
-                .trim();
+    const template = fs
+        .readFileSync(filePath, 'utf8')
+        .toString()
+        .trim();
 
-            return Handlebars.compile(template, {
-                strict: true,
-                noEscape: true,
-                preventIndent: true,
-                knownHelpersOnly: true,
-                knownHelpers: {
-                    equals: true,
-                    notEquals: true,
-                },
-            });
-        } catch (e) {
-            throw new Error(`Could not compile Handlebar template: "${filePath}"`);
-        }
-    }
-    throw new Error(`Could not find Handlebar template: "${filePath}"`);
+    return Handlebars.compile(template, {
+        strict: true,
+        noEscape: true,
+        preventIndent: true,
+        knownHelpersOnly: true,
+        knownHelpers: {
+            equals: true,
+            notEquals: true,
+        },
+    });
 }

src/utils/readHandlebarsTemplates.spec.ts

@@ -1,20 +1,16 @@
 import * as fs from 'fs';
-import * as glob from 'glob';
 
 import { readHandlebarsTemplates } from './readHandlebarsTemplates';
 
 jest.mock('fs');
-jest.mock('glob');
 
 const fsExistsSync = fs.existsSync as jest.MockedFunction<typeof fs.existsSync>;
 const fsReadFileSync = fs.readFileSync as jest.MockedFunction<typeof fs.readFileSync>;
-const globSync = glob.sync as jest.MockedFunction<typeof glob.sync>;
 
 describe('readHandlebarsTemplates', () => {
     it('should read the templates', () => {
         fsExistsSync.mockReturnValue(true);
         fsReadFileSync.mockReturnValue('{{{message}}}');
-        globSync.mockReturnValue([]);
 
         const template = readHandlebarsTemplates();