codegen-openapi-ts 0.3.1 → 0.3.5

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.
 
@@ -11,11 +12,12 @@
 - Frontend ❤️ OpenAPI, but we do not want to use JAVA codegen in our builds
 - Quick, lightweight, robust and framework-agnostic 🚀
 - Supports generation of TypeScript clients
-- Supports conversion from Swagger 1.x/2.x to OpenAPI 2.x/3.x
+- Supports conversion from Swagger 1.x/2.x to OpenAPI 2.x/3.x with [`api-spec-converter`](https://github.com/LucyBot-Inc/api-spec-converter)
 - Supports JSON and YAML files for input
-- Supports generation through CLI, Node.js and NPX
+- 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 
 
 ## Install
 
@@ -26,162 +28,110 @@ npm install codegen-openapi-ts --save-dev
 
 ## Usage
 
+**codegen.config.js**
 ```
-$ openapi --help
-
-  Usage: openapi [options]
-
-  Options:
-    -V, --version             output the version number
-    -i, --input <value>       OpenAPI specification, can be a path, url or string content (required)
-    -o, --output <value>      Output directory (required)
-    --useUnionTypes           Use union types instead of enums
-    --exportServices <value>  Write services to disk (default: true)
-    --exportModels <value>    Write models to disk (default: true)
-    --postfix <value>         Service name postfix (default: "Service")
-    --request <value>         Path to custom request file
-    -h, --help                display help for command
-
-  Examples
-    $ openapi --input ./spec.json
-    $ openapi --input ./spec.json --output ./dist
-    $ openapi --input ./spec.json --output ./dist --client xhr
+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]
 
-## Example
+Arguments:
+  from           Original response specification version
+  source         Swagger/OpenAPI response url
+  output         Output folder name (default: "output")
 
-**package.json**
-```json
-{
-    "scripts": {
-        "generate": "openapi --input ./spec.json --output ./dist"
-    }
-}
+Options:
+  -V, --version  output the version number
+  -h, --help     display help for command
 ```
 
-**NPX**
-
+**Node**
 ```
-npx codegen-openapi-ts --input ./spec.json --output ./dist
+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
+  source: string          // url or local file (JSON, YAML)
+}, {
+  input: string,          // generated conversion output path, also used as input
+  output: string,         // generated output folder location
+  useOptions: boolean,    // use options as url methods argument
+  useUnionTypes: boolean  // use union types instead of enum
+})
 ```
 
-**Node.js API**
 
+## Example
+**codegen.config.js**
 ```javascript
-const OpenAPI = require('codegen-openapi-ts');
-
-OpenAPI.generate({
-    input: './spec.json',
-    output: './dist'
-});
-
-// Or by providing the content of the spec directly 🚀
-OpenAPI.generate({
-    input: require('./spec.json'),
-    output: './dist'
-});
+'use strict';
+
+module.exports = [
+  {
+    source: 'http://pokemon-api/docs/api',
+    from: 'openapi_3',
+    output: 'src/api-types/pokemon-api', // pokemon-api
+  },
+];
 ```
 
-
-## 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
-}
+**CLI**
+```bash
+codegen-openapi-ts-cli swagger_2 https://pokemonapi/docs/api
+codegen-openapi-ts-cli swagger_2 https://pokemonapi/docs/api pokemon-api
 ```
 
-**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'
-}
+**fetch-schema.js (Node)**
+```javascript
+// fetch-schema.js
+const OpenAPI = require('codegen-openapi-ts')
+
+OpenAPI.convertAndGenerate(
+  {
+    from: process.argv[2], // swagger_2
+    to: 'openapi_3',
+    source: process.argv[3] // https://pokemon-api/docs/api
+  },
+  {
+    input: 'scripts/api-schema.json',
+    output: 'src/api-types/' + process.argv[4], // pokemon-api
+    useOptions: true,
+    useUnionTypes: true
+  }
+)
 ```
-
-### 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
+// package.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"
-        ]
+    "scripts": {
+        "generate": "node fetch-schema.js swagger_2 https://pokemon-api/docs/api pokemon-api"
     }
 }
-```
 
-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,
-}
+// npm run generate
 ```
+### Output folder
+    .
+    ├── ...
+    ├── src                         # output value ('src/api-types/')
+    │   ├── api-types               
+    │   |   ├── pokemon-api         # output
+    │   |   |   ├── models          # API schema models
+    │   |   |   ├── services        # API service level with methods/url/response/request types
+    │   |   |   └── index.ts        
+    |   |   └── ...
+    └── ...
 
 
+## Features
 ### 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()