codegen-openapi-ts 0.3.3 → 0.3.6

package/README.md

@@ -2,6 +2,7 @@
 
 [![NPM][npm-image]][npm-url]
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![Build](https://github.com/devTeaa/codegen-openapi-ts/actions/workflows/CI.yml/badge.svg)
 
 > Node.js library that generates Typescript clients based on the OpenAPI specification.
 
@@ -16,6 +17,8 @@
 - Supports generation through Node.js
 - Supports tsc and @babel/plugin-transform-typescript
 - Supports external references using [`json-schema-ref-parser`](https://github.com/APIDevTools/json-schema-ref-parser/)
+- Supports generate multiple api based on config file 
+- Supports fetching single file (well, technically) and generate type from that
 
 ## Install
 
@@ -26,9 +29,34 @@ npm install codegen-openapi-ts --save-dev
 
 ## Usage
 
+**codegen.config.js**
 ```
-const OpenAPI = require('codegen-openapi-ts')
+codegen-openapi-ts --help
+Usage: codegen-openapi-ts [options]
+
+Options:
+  -V, --version     output the version number
+  --config <value>  Path to config file (default: "codegen.config.js")
+  -h, --help        display help for command
+```
+
+**CLI**
+```
+codegen-openapi-ts-cli --help
+Usage: codegen-openapi-ts-cli [options]
+
+Arguments:
+  from           Original response specification version
+  source         Swagger/OpenAPI response url
+  output         Output folder name (default: "output")
 
+Options:
+  -V, --version  output the version number
+  -h, --help     display help for command
+```
+
+**Node**
+```
 OpenAPI.convertAndGenerate({
   from: string,           // swagger_1, swagger_2, openapi_3, api_blueprint, io_docs, google, raml, wadl
   to: string,             // swagger_1, swagger_2, openapi_3, api_blueprint, io_docs, google, raml, wadl
@@ -43,7 +71,31 @@ OpenAPI.convertAndGenerate({
 
 
 ## Example
-**fetch-schema.js**
+**codegen.config.js**
+```javascript
+'use strict';
+
+module.exports = [
+  {
+    source: 'http://pokemon-api/docs/api',
+    from: 'openapi_3',
+    output: 'src/api-types/pokemon-api', // pokemon-api
+  },
+  {
+    source: 'ssh://git@github.com/pokemon/pokemon-api.git HEAD docs/evolution-path.json',
+    from: 'openapi_3',
+    output: 'src/api-types/evolution-path', // evolution-path
+  }, 
+];
+```
+
+**CLI**
+```bash
+codegen-openapi-ts-cli swagger_2 https://pokemonapi/docs/api
+codegen-openapi-ts-cli swagger_2 https://pokemonapi/docs/api pokemon-api
+```
+
+**fetch-schema.js (Node)**
 ```javascript
 // fetch-schema.js
 const OpenAPI = require('codegen-openapi-ts')
@@ -62,9 +114,8 @@ OpenAPI.convertAndGenerate(
   }
 )
 ```
-
-**package.json**
 ```json
+// package.json
 {
     "scripts": {
         "generate": "node fetch-schema.js swagger_2 https://pokemon-api/docs/api pokemon-api"
@@ -78,7 +129,7 @@ OpenAPI.convertAndGenerate(
     ├── ...
     ├── src                         # output value ('src/api-types/')
     │   ├── api-types               
-    │   |   ├── pokemon-api         # process.argv[4]
+    │   |   ├── pokemon-api         # output
     │   |   |   ├── models          # API schema models
     │   |   |   ├── services        # API service level with methods/url/response/request types
     │   |   |   └── index.ts        
@@ -87,103 +138,6 @@ OpenAPI.convertAndGenerate(
 
 
 ## Features
-
-### Enums vs. Union Types `--useUnionTypes`
-The OpenAPI spec allows you to define [enums](https://swagger.io/docs/specification/data-models/enums/) inside the
-data model. By default, we convert these enums definitions to [TypeScript enums](https://www.typescriptlang.org/docs/handbook/enums.html).
-However, these enums are merged inside the namespace of the model, this is unsupported by Babel, [see docs](https://babeljs.io/docs/en/babel-plugin-transform-typescript#impartial-namespace-support).
-Because we also want to support projects that use Babel [@babel/plugin-transform-typescript](https://babeljs.io/docs/en/babel-plugin-transform-typescript),
-we offer the flag `--useUnionTypes` to generate [union types](https://www.typescriptlang.org/docs/handbook/unions-and-intersections.html#union-types)
-instead of the traditional enums. The difference can be seen below:
-
-**Enums:**
-```typescript
-// Model
-export interface Order {
-    id?: number;
-    quantity?: number;
-    status?: Order.status;
-}
-
-export namespace Order {
-    export enum status {
-        PLACED = 'placed',
-        APPROVED = 'approved',
-        DELIVERED = 'delivered',
-    }
-}
-
-// Usage
-const order: Order = {
-    id: 1,
-    quantity: 40,
-    status: Order.status.PLACED
-}
-```
-
-**Union Types:**
-```typescript
-// Model
-export interface Order {
-    id?: number;
-    quantity?: number;
-    status?: 'placed' | 'approved' | 'delivered';
-}
-
-// Usage
-const order: Order = {
-    id: 1,
-    quantity: 40,
-    status: 'placed'
-}
-```
-
-### 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 it's a supported extension
-that can help developers use more meaningful enumerators.
-```json
-{
-    "EnumWithStrings": {
-        "description": "This is a simple enum with strings",
-        "enum": [
-            0,
-            1,
-            2
-        ],
-        "x-enum-varnames": [
-            "Success",
-            "Warning",
-            "Error"
-        ],
-        "x-enum-descriptions": [
-            "Used when the status of something is successful",
-            "Used when the status of something has a warning",
-            "Used when the status of something has an error"
-        ]
-    }
-}
-```
-
-Generated code:
-```typescript
-enum EnumWithStrings {
-    /*
-    * Used when the status of something is successful
-    */
-    Success = 0,
-    /*
-    * Used when the status of something has a warning
-    */
-    Waring = 1,
-    /*
-    * Used when the status of something has an error
-    */
-    Error = 2,
-}
-```
-
-
 ### Nullable in OpenAPI v2
 In the OpenAPI v3 spec you can create properties that can be NULL, by providing a `nullable: true` in your schema.
 However, the v2 spec does not allow you to do this. You can use the unofficial `x-nullable` in your specification

package/bin/cli.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const path = require('path');
+const program = require('commander');
+const pkg = require('../package.json');
+
+const params = program
+    .name('codegen-openapi-ts-cli')
+    .usage('[options]')
+    .version(pkg.version)
+    .argument('<from>', 'Original response specification version')
+    .argument('<source>', 'Swagger/OpenAPI response url')
+    .argument('[output]', 'Output folder name', 'output')
+    .parse(process.argv)
+    .processedArgs;
+
+const OpenAPI = require(path.resolve(__dirname, '../dist/index.js'));
+
+if (OpenAPI) {
+    OpenAPI.convertAndGenerate(
+      {
+        from: params[0],
+        to: 'openapi_3',
+        source: params[1]
+      },
+      {
+        input: 'api-schema.json',
+        output: params[2],
+        useOptions: true,
+        useUnionTypes: true
+      },
+    )
+}

package/bin/index.js

@@ -1,48 +1,46 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 'use strict';
 
 const path = require('path');
 const program = require('commander');
 const pkg = require('../package.json');
+const OpenAPI = require(path.resolve(__dirname, '../dist/index.js'));
+
+const appRoot = process.cwd().split('/node_modules')[0]
 
 const params = program
-    .name('openapi')
+    .name('codegen-openapi-ts')
     .usage('[options]')
     .version(pkg.version)
-    .requiredOption('-i, --input <value>', 'OpenAPI specification, can be a path, url or string content (required)')
-    .requiredOption('-o, --output <value>', 'Output directory (required)')
-    .option('-c, --client <value>', 'HTTP client to generate [fetch, xhr, node, axios]', 'fetch')
-    .option('--useOptions', 'Use options instead of arguments')
-    .option('--useUnionTypes', 'Use union types instead of enums')
-    .option('--exportServices <value>', 'Write services to disk', true)
-    .option('--exportModels <value>', 'Write models to disk', true)
-    .option('--postfix <value>', 'Service name postfix', 'Service')
-    .option('--request <value>', 'Path to custom request file')
+    .option('--config <value>', 'Path to config file', 'codegen.config.js')
     .parse(process.argv)
     .opts();
 
-const OpenAPI = require(path.resolve(__dirname, '../dist/index.js'));
+async function generateOnConfig () {
+  try {
+    const configFile = require(path.join(appRoot, params.config))
 
-if (OpenAPI) {
-    OpenAPI.generate({
-        input: params.input,
-        output: params.output,
-        httpClient: params.client,
-        useOptions: params.useOptions,
-        useUnionTypes: params.useUnionTypes,
-        exportCore: false,
-        exportServices: JSON.parse(params.exportServices) === true,
-        exportModels: JSON.parse(params.exportModels) === true,
-        exportSchemas: false,
-        postfix: params.postfix,
-        request: params.request,
-    })
-        .then(() => {
-            process.exit(0);
-        })
-        .catch(error => {
-            console.error(error);
-            process.exit(1);
-        });
+    for (let i = 0; i < configFile.length; i++) {
+      console.log('Generating ' + configFile[i].source)
+      await OpenAPI.convertAndGenerate(
+        {
+          from: configFile[i].from,
+          to: 'openapi_3',
+          source: configFile[i].source
+        },
+        {
+          input: 'api-schema.json',
+          output: configFile[i].output || 'output',
+          useOptions: true,
+          useUnionTypes: true
+        },
+        configFile[i].urlMethodMapping || [],
+      )
+    }
+  } catch (err) {
+    console.log(err)
+  }
 }
+
+generateOnConfig()