@penkov/swagger-code-gen 1.3.2 → 1.4.0

package/README.md

@@ -10,12 +10,248 @@ npm install -D @penkov/swagger-code-gen
 Usage:
 ```shell
 generate-client --url <URI> output_filename.ts
+generate-client --url <URI> --includeTags tag1 tag2 -- output_filename.ts
 ```
 
 Cli parameters:
 * `--url <URI>` - the swagger url
+* `--includeTags <tags...>` - Space-separated list of tags of paths to be included. Path is included if it contains any of specified tag
+  Path is included if exclusion list is empty or path contains any of the tags from inclusion list.
+  If the tag is both in inclusion and exclusion lists, it gets excluded.
+* `--excludeTags <tags...>` - Space-separated list of tags of paths to be excluded. 
+  Path is excluded if exclusion list is non-empty and path contains any of the tags from exclusion list.
+  If the tag is both in inclusion and exclusion lists, it gets excluded.
 * `--referencedObjectsNullableByDefault` - then specified, the generated code will assume that
   any object's field, that references another object, can be null, unless it is explicitly specified to be not nullable
   (which is default in .net world: asp generates wrong spec)
 * `--enableScats` - generate additional wrappers in [scats](https://www.npmjs.com/package/scats) 
   style for all objects and create a service with methods for each endpoint.
+
+
+
+# Example of generated code:
+
+```shell
+generate-client --enableScats --url https://petstore3.swagger.io/api/v3/openapi.json petstore.ts
+```
+
+Will generate:
+```typescript
+// header skipped
+
+export interface Customer {
+  readonly id: number;
+  readonly username: string;
+  readonly address: ReadonlyArray<Address>;
+}
+
+
+export interface Address {
+  readonly street: string;
+  readonly city: string;
+  readonly state: string;
+  readonly zip: string;
+}
+
+
+export interface Category {
+  readonly id: number;
+  readonly name: string;
+}
+
+
+export interface User {
+  readonly id: number;
+  readonly username: string;
+  readonly firstName: string;
+  readonly lastName: string;
+  readonly email: string;
+  readonly password: string;
+  readonly phone: string;
+  readonly userStatus: number;
+}
+
+
+export interface Tag {
+  readonly id: number;
+  readonly name: string;
+}
+
+
+export interface Pet {
+  readonly id: number;
+  readonly name: string;
+  readonly category: Category;
+  readonly photoUrls: ReadonlyArray<string>;
+  readonly tags: ReadonlyArray<Tag>;
+  readonly status: string;
+}
+
+
+export interface ApiResponse {
+  readonly code: number;
+  readonly type: string;
+  readonly message: string;
+}
+
+
+
+/**
+ * PUT /pet
+ * @summary Update an existing pet
+ * @description Update an existing pet by Id
+ * @param {Pet} body Update an existent pet in the store
+ * @param {RequestOptions} requestOptions Additional request params
+ * @return {Pet} Successful operation
+ */
+export async function updatePet(
+        body: Pet,
+        requestOptions: RequestOptions = defaultRequestOptions()
+): Promise<Pet> {
+  let query = '';
+  const request = new Request(`${requestOptions.apiPrefix}/pet${query}`, {
+    method: 'put',
+    body: JSON.stringify(body),
+    headers: {
+      ...option(requestOptions.headers).getOrElseValue({}),
+    }
+  });
+  return requestImpl<Pet>(request, requestOptions);
+}
+
+
+// ...
+
+
+/**
+ * GET /pet/findByStatus
+ * @summary Finds Pets by status
+ * @description Multiple status values can be provided with comma separated strings
+ * @param {&#39;available&#39; | &#39;pending&#39; | &#39;sold&#39;} status Status values that need to be considered for filter
+ * @param {RequestOptions} requestOptions Additional request params
+ * @return {ReadonlyArray&lt;Pet&gt;} successful operation
+ */
+export async function findPetsByStatus(
+        status: 'available' | 'pending' | 'sold' = 'available',
+        requestOptions: RequestOptions = defaultRequestOptions()
+): Promise<ReadonlyArray<Pet>> {
+  let query = '';
+  const queryParams = [];
+  queryParams.push(`status=${status}`);
+  if (queryParams.length > 0) {
+    query = '?' + queryParams.join('&');
+  }
+  const request = new Request(`${requestOptions.apiPrefix}/pet/findByStatus${query}`, {
+    method: 'get',
+    body: undefined,
+    headers: {
+      ...option(requestOptions.headers).getOrElseValue({}),
+    }
+  });
+  const preProcessed = option(requestOptions.preProcessRequest).map(cb => cb(request)).getOrElseValue(request);
+  const resp = await fetch(preProcessed);
+  if (resp.ok) {
+    const postProcessed = option(requestOptions.postProcessResponse)
+            .map(cb => cb(preProcessed, resp))
+            .getOrElseValue(resp);
+    const json = option(resp.headers.get('content-length'))
+            .map(x => parseInt(x))
+            .getOrElseValue(0) > 0 ? await postProcessed.json() : null;
+    return json as ReadonlyArray<Pet>;
+  } else {
+    throw resp;
+  }
+}
+
+
+// ...
+
+
+
+// scats wrappers
+
+export class OrderDto {
+
+  constructor(
+          readonly id: number,
+          readonly petId: number,
+          readonly quantity: number,
+          readonly shipDate: string,
+          readonly status: string,
+          readonly complete: boolean,
+  ) {}
+
+
+  static fromJson(json: Order): OrderDto {
+    return new OrderDto(
+            json.id,
+            json.petId,
+            json.quantity,
+            json.shipDate,
+            json.status,
+            json.complete,
+    );
+  }
+
+  copy(fields: Partial<OrderDto>): OrderDto {
+    return new OrderDto(
+            option(fields.id).getOrElseValue(this.id),
+            option(fields.petId).getOrElseValue(this.petId),
+            option(fields.quantity).getOrElseValue(this.quantity),
+            option(fields.shipDate).getOrElseValue(this.shipDate),
+            option(fields.status).getOrElseValue(this.status),
+            option(fields.complete).getOrElseValue(this.complete),
+    );
+  }
+
+  get toJson(): Order {
+    return {
+      id: this.id,
+      petId: this.petId,
+      quantity: this.quantity,
+      shipDate: this.shipDate,
+      status: this.status,
+      complete: this.complete,
+    };
+  }
+}
+
+
+export class ApiClient {
+
+  constructor(private readonly requestOptions: RequestOptions = defaultRequestOptions()) {
+  }
+
+
+  async updatePet(
+          body: Pet,
+          requestOptions: RequestOptions = this.requestOptions
+  ): Promise<TryLike<PetDto>> {
+    return (await Try.promise(() =>
+            updatePet(
+                    body,
+                    requestOptions
+            )
+    ))
+            .map(res => PetDto.fromJson(res))
+            ;
+  }
+
+  async addPet(
+          body: Pet,
+          requestOptions: RequestOptions = this.requestOptions
+  ): Promise<TryLike<PetDto>> {
+    return (await Try.promise(() =>
+            addPet(
+                    body,
+                    requestOptions
+            )
+    ))
+            .map(res => PetDto.fromJson(res))
+            ;
+  }
+
+//...
+}
+
+```

package/dist/cli.mjs

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 import { main } from './index.js';
 import { Command } from "commander";
+import { HashSet } from "scats";
 const program = new Command();
 program
     .name('Swagger client code generator')
     .description('CLI to generate client based on swagger definitions')
     .version('1.0.0')
-    .option('--url <URI>', 'The url with swagger definitions')
+    .requiredOption('--url <URI>', 'The url with swagger definitions')
     .option('--referencedObjectsNullableByDefault', 'Assume that referenced objects can be null (say hello to .net assholes)', false)
+    .option('--includeTags <tags...>', 'Space-separated list of tags of paths to be included. Path is included if it contains any of specified tag')
+    .option('--excludeTags <tags...>', 'Space-separated list of tags of paths to be excluded. Path is excluded if it contains any of specified tag')
     .option('--enableScats', 'Generate scats', false)
     .argument('outputFile', 'File with generated code')
     .parse();
@@ -15,7 +18,11 @@ const url = program.opts().url;
 const referencedObjectsNullableByDefault = program.opts().referencedObjectsNullableByDefault;
 const enableScats = program.opts().enableScats;
 const outputFile = program.args[0];
+const includeTags = HashSet.from(program.opts().includeTags || []);
+const excludeTags = HashSet.from(program.opts().excludeTags || []);
 main(url, enableScats, outputFile, {
-    referencedObjectsNullableByDefault: referencedObjectsNullableByDefault
+    referencedObjectsNullableByDefault: referencedObjectsNullableByDefault,
+    includeTags: includeTags,
+    excludeTags: excludeTags
 }).then(() => {
 });

package/dist/components-parse.js

@@ -17,5 +17,9 @@ export function resolvePaths(json, schemasTypes, options) {
     return Collection.from(Object.keys(jsonSchemas)).flatMap(path => {
         const methods = jsonSchemas[path];
         return Collection.from(Object.keys(methods)).map(methodName => new Method(path, methodName, methods[methodName], schemasTypes, options));
+    }).filter(m => {
+        const included = options.includeTags.isEmpty || options.includeTags.intersect(m.tags).nonEmpty;
+        const excluded = options.excludeTags.nonEmpty && options.excludeTags.intersect(m.tags).nonEmpty;
+        return included && !excluded;
     });
 }

package/dist/method.js

@@ -1,15 +1,17 @@
-import { Collection, HashMap, identity, option } from 'scats';
+import { Collection, HashMap, HashSet, identity, option } from 'scats';
 import { Property } from './property.js';
 import { Parameter } from './parameter.js';
 import { SchemaFactory } from './schemas.js';
-const sortByIn = HashMap.of(['path', 0], ['query', 1], ['header', 2], ['body', 3]);
+const sortByIn = HashMap.of(['path', 0], ['query', 1], ['header', 2], ['cookie', 3], ['body', 4]);
 export class Method {
     constructor(path, method, def, schemasTypes, options) {
         this.path = path;
         this.method = method;
-        this.tags = option(def.tags).getOrElseValue([]);
+        this.tags = HashSet.from(option(def.tags).getOrElseValue([]));
         this.summary = def.summary;
-        const parameters = Collection.from(def.parameters)
+        this.description = def.description;
+        this.operationId = option(def.operationId);
+        const parameters = Collection.from(option(def.parameters).getOrElseValue([]))
             .map(p => Parameter.fromDefinition(p, schemasTypes, options))
             .sort((a, b) => {
             const r1 = a.required ? 1 : 0;
@@ -41,12 +43,15 @@ export class Method {
                 .orElseValue(mimeTypes.headOption)
                 .map(mt => SchemaFactory.build('body', body[mt].schema, schemasTypes, options));
         });
+        this.bodyDescription = option(def.requestBody).flatMap(body => option(body.description));
         const statusCodes = Collection.from(Object.keys(def.responses))
             .map(x => parseInt(x));
         const successCode = statusCodes
             .filter(code => code / 100 === 2)
             .minByOption(identity);
-        const respDef = successCode.map(_ => def.responses[_]).getOrElseValue(def.responses[statusCodes.head]);
+        const respDef = successCode.map(_ => def.responses[_])
+            .orElse(() => option(def.responses['default']))
+            .getOrElseValue(def.responses[statusCodes.head]);
         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')
@@ -63,12 +68,13 @@ export class Method {
             asProperty: Property.fromDefinition('UNKNOWN', { type: 'any' }, schemasTypes, options),
             responseType: 'any'
         }));
+        this.wrapParamsInObject = this.parameters.size > 2 || (this.body.isDefined) && this.parameters.nonEmpty;
     }
     get endpointName() {
-        return `${this.method}${Method.pathToName(this.path)}`;
+        return this.operationId.getOrElse(() => `${this.method}${Method.pathToName(this.path)}`);
     }
     get pathWithSubstitutions() {
-        const paramPrefix = `${this.parameters.size > 2 ? 'params.' : ''}`;
+        const paramPrefix = `${this.wrapParamsInObject ? 'params.' : ''}`;
         return this.path.replace(/\{(\w+?)\}/g, (matched, group) => {
             const remappedName = this.parameters.find(p => p.name === group && p.in === 'path')
                 .map(_ => _.uniqueName)

package/dist/parameter.js

@@ -1,13 +1,14 @@
 import { SchemaEnum, SchemaFactory, SchemaObject } from './schemas.js';
-import { Collection, identity, option } from 'scats';
+import { Collection, identity, none, option } from 'scats';
 import { Method } from './method.js';
 import { Property } from './property.js';
 export class Parameter {
-    constructor(name, uniqueName, inValue, jsType, required, description) {
+    constructor(name, uniqueName, inValue, jsType, required, defaultValue, description) {
         this.name = name;
         this.uniqueName = uniqueName;
         this.jsType = jsType;
         this.required = required;
+        this.defaultValue = defaultValue;
         this.description = description;
         this.in = inValue;
     }
@@ -15,14 +16,33 @@ export class Parameter {
         const name = Parameter.toJSName(def.name);
         const inValue = def.in;
         const desc = option(def.description);
-        const required = option(def.required).exists(identity);
+        let defaultValue = none;
         const schema = SchemaFactory.build(def.name, def.schema, schemas, options);
         let jsType;
         if (schema instanceof SchemaObject) {
             jsType = schema.type;
         }
         else if (schema instanceof SchemaEnum) {
-            jsType = schema.name;
+            if (schemas.containsKey(schema.name)) {
+                jsType = schema.name;
+            }
+            else if (schema.type === 'string') {
+                jsType = `${schema.values.map(x => `'${x}'`).mkString(' | ')}`;
+            }
+            else if (schema.type === 'integer') {
+                jsType = `${schema.values.map(x => `${x}`).mkString(' | ')}`;
+            }
+            else {
+                jsType = schema.type;
+            }
+            defaultValue = schema.defaultValue.map(x => {
+                if (schema.type === 'string') {
+                    return `'${x}'`;
+                }
+                else {
+                    return x;
+                }
+            });
         }
         else if (schema instanceof Property) {
             jsType = schema.jsType;
@@ -30,7 +50,8 @@ export class Parameter {
         else {
             throw new Error('Unknown schema type');
         }
-        return new Parameter(name, name, inValue, jsType, required, desc);
+        const required = option(def.required).exists(identity) || defaultValue.nonEmpty;
+        return new Parameter(name, name, inValue, jsType, required, defaultValue, desc);
     }
     static toJSName(path) {
         const tokens = Collection.from(path.split(/\W/)).filter(t => t.length > 0);
@@ -39,6 +60,6 @@ export class Parameter {
         }).mkString();
     }
     copy(p) {
-        return new Parameter(option(p.name).getOrElseValue(this.name), option(p.uniqueName).getOrElseValue(this.uniqueName), option(p.in).getOrElseValue(this.in), option(p.jsType).getOrElseValue(this.jsType), option(p.required).getOrElseValue(this.required), option(p.description).getOrElseValue(this.description));
+        return new Parameter(option(p.name).getOrElseValue(this.name), option(p.uniqueName).getOrElseValue(this.uniqueName), option(p.in).getOrElseValue(this.in), option(p.jsType).getOrElseValue(this.jsType), option(p.required).getOrElseValue(this.required), option(p.defaultValue).getOrElseValue(this.defaultValue), option(p.description).getOrElseValue(this.description));
     }
 }

package/dist/schemas.js

@@ -37,15 +37,16 @@ export class SchemaFactory {
     }
 }
 export class SchemaEnum {
-    constructor(name, title, type, values) {
+    constructor(name, title, type, defaultValue, values) {
         this.name = name;
         this.title = title;
         this.type = type;
+        this.defaultValue = defaultValue;
         this.values = values;
         this.schemaType = 'enum';
     }
     static fromDefinition(name, def) {
-        return new SchemaEnum(name, def.title, def.type, option(def.enum).map(Collection.from).getOrElseValue(Nil));
+        return new SchemaEnum(name, def.title, def.type, option(def.default), option(def.enum).map(Collection.from).getOrElseValue(Nil));
     }
 }
 export class SchemaObject {

package/dist/templates/index.ejs

@@ -33,6 +33,26 @@ export const defaultReqOpts: RequestOptions = {
 
 const defaultRequestOptions = () => defaultReqOpts;
 
+
+async function requestImpl<T>(request: Request, requestOptions: RequestOptions): Promise<T> {
+    const preProcessed = requestOptions.preProcessRequest ? requestOptions.preProcessRequest(request) : request;
+    const resp = await fetch(preProcessed);
+    if (resp.ok) {
+        const postProcessed = requestOptions.postProcessResponse ? requestOptions.postProcessResponse(preProcessed, resp) : resp;
+        let json: any = null;
+        if (postProcessed.headers.has('content-length')) {
+            const ct = parseInt(postProcessed.headers.get('content-length'));
+            if (ct > 0) {
+                json = await postProcessed.json()
+            }
+        }
+        return json as T;
+    } else {
+        throw resp;
+    }
+
+}
+
 <% schemas.foreach(schema => { %>
 <%- include('schema.ejs', {schema: schema}); %>
 <% }); %>

package/dist/templates/method.ejs

@@ -1,22 +1,27 @@
 /**
  * <%= method.method.toUpperCase() %> <%= method.path %>
-<% if (method.parameters.size > 2) { -%>
+<% if (method.summary) { -%>
+ * @summary <%= method.summary %>
+<% } -%>
+<% if (method.description) { -%>
+ * @description <%= method.description %>
+<% } -%>
+<% if (method.wrapParamsInObject) { -%>
  * @param {Object} params
 <% } -%>
 <% method.parameters.foreach(p => { -%>
- * @param {<%= p.jsType %>} <%= method.parameters.size > 2 ? 'params.' : '' %><%= p.uniqueName %> <%= p.description.getOrElseValue('')%>
+ * @param {<%= p.jsType %>} <%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %> <%= p.description.getOrElseValue('')%>
 <% }); -%>
 <%_ if (method.body.nonEmpty) { -%>
- * @param {<%= method.body.get.type %>} body
+ * @param {<%= method.body.get.jsType %>} body <%= method.bodyDescription.getOrElseValue('') %>
 <%_ } -%>
  * @param {RequestOptions} requestOptions Additional request params
- * @summary <%= method.summary %>
  * @return {<%= method.response.responseType %>} <%= method.response.description %>
  */
 export async function <%= method.endpointName %>(
-    <%_ if (method.parameters.size <= 2) { -%>
+    <%_ if (!method.wrapParamsInObject) { -%>
     <%_ method.parameters.foreach(p => { -%>
-    <%= p.uniqueName %><%= p.required ? '' : '?'%>: <%- p.jsType %>,
+    <%= p.uniqueName %><%= p.required ? '' : '?'%>: <%- p.jsType %><%- p.defaultValue.map(x => ` = ${x}`).getOrElseValue('') %>,
     <%_ }) -%>
     <%_ } else { -%>
     params: {
@@ -26,7 +31,7 @@ export async function <%= method.endpointName %>(
     },
     <%_ } -%>
     <%_ if (method.body.nonEmpty) { -%>
-    body: <%= method.body.get.type %>,
+    body: <%- method.body.get.jsType %>,
     <%_ } -%>
     requestOptions: RequestOptions = defaultRequestOptions()
 ): Promise<<%- method.response.responseType %>> {
@@ -35,17 +40,17 @@ export async function <%= method.endpointName %>(
     const queryParams = [];
     <%_ method.parameters.filter(x => x.in === 'query' && x.required).foreach(p => { -%>
     <%_ if (p.jsType === 'string') { -%>
-    queryParams.push(`<%= p.name %>=${encodeURIComponent(<%= method.parameters.size > 2 ? 'params.' : '' %><%= p.uniqueName %>)}`);
+    queryParams.push(`<%= p.name %>=${encodeURIComponent(<%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %>)}`);
     <%_ } else { -%>
-    queryParams.push(`<%= p.name %>=${<%= method.parameters.size > 2 ? 'params.' : '' %><%= p.uniqueName %>}`);
+    queryParams.push(`<%= p.name %>=${<%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %>}`);
     <%_ }  -%>
     <%_ }) -%>
     <%_ method.parameters.filter(x => x.in === 'query' && !x.required).foreach(p => { -%>
-    if (!!<%= method.parameters.size > 2 ? 'params.' : '' %><%= p.uniqueName %>) {
+    if (!!<%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %>) {
         <%_ if (p.jsType === 'string') { -%>
-        queryParams.push(`<%= p.name %>=${encodeURIComponent(<%= method.parameters.size > 2 ? 'params.' : '' %><%= p.uniqueName %>)}`);
+        queryParams.push(`<%= p.name %>=${encodeURIComponent(<%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %>)}`);
         <%_ } else { -%>
-        queryParams.push(`<%= p.name %>=${<%= method.parameters.size > 2 ? 'params.' : '' %><%= p.uniqueName %>}`);
+        queryParams.push(`<%= p.name %>=${<%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %>}`);
         <%_ }  -%>
     }
     <%_ }) -%>
@@ -57,25 +62,13 @@ export async function <%= method.endpointName %>(
         method: '<%= method.method %>',
         body: <%= method.body.map(() => 'JSON.stringify(body)').getOrElseValue('undefined') %>,
         headers: {
-            ...option(requestOptions.headers).getOrElseValue({}),
+            ...requestOptions.headers || {},
             <%_ if (method.parameters.filter(x => x.in === 'header').nonEmpty) { -%>
             <%_ method.parameters.filter(x => x.in === 'header').foreach(p => { -%>
-            <%= p.name %>: <%= method.parameters.size > 2 ? 'params.' : '' %><%= p.uniqueName %>
+            <%= p.name %>: <%= method.wrapParamsInObject ? 'params.' : '' %><%= p.uniqueName %>
             <%_ }) -%>
             <%_ }  -%>
         }
     });
-    const preprocessed = option(requestOptions.preProcessRequest).map(cb => cb(request)).getOrElseValue(request);
-    const resp = await fetch(preprocessed);
-    if (resp.ok) {
-        const postprocessed = option(requestOptions.postProcessResponse)
-            .map(cb => cb(preprocessed, resp))
-            .getOrElseValue(resp);
-        const json = option(resp.headers.get('content-length'))
-            .map(x => parseInt(x))
-            .getOrElseValue(0) > 0 ? await postprocessed.json() : null;
-        return json as <%- method.response.responseType %>;
-    } else {
-        throw resp;
-    }
+    return requestImpl<<%- method.response.responseType %>>(request, requestOptions);
 }

package/dist/templates/scats-method.ejs

@@ -6,7 +6,7 @@ export class ApiClient {
 
     <% methods.foreach(method => { %>
     async <%= method.endpointName %>(
-        <%_ if (method.parameters.size <= 2) { -%>
+        <%_ if (!method.wrapParamsInObject) { -%>
         <%_ method.parameters.foreach(p => { -%>
         <%= p.uniqueName %>: <%- p.required && !p.nullable ? p.jsType : `Option<${p.jsType}> = none` %>,
         <%_ }) -%>
@@ -18,13 +18,13 @@ export class ApiClient {
         },
         <%_ } -%>
         <%_ method.body.foreach(body => { -%>
-        body: <%= body.type %>,
+        body: <%- body.jsType %>,
         <%_ }); -%>
         requestOptions: RequestOptions = this.requestOptions
     ): Promise<TryLike<<%- method.response.asProperty.scatsWrapperType %>>> {
         return (await Try.promise(() =>
                 <%= method.endpointName %>(
-                    <%_ if (method.parameters.size <= 2) { -%>
+                    <%_ if (!method.wrapParamsInObject) { -%>
                     <%_ method.parameters.foreach(p => { -%>
                     <%= p.uniqueName %><%- p.required && !p.nullable ? '' : `.orUndefined` %>,
                     <%_ }) -%>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@penkov/swagger-code-gen",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "type": "module",
   "bin": {
     "generate-client": "./dist/cli.mjs"
@@ -22,6 +22,7 @@
   },
   "homepage": "https://github.com/papirosko/swagger-code-gen#readme",
   "scripts": {
+    "test:petstore": "mkdir -p tmp && ts-node-esm ./src/cli.mjs --enableScats --url https://petstore3.swagger.io/api/v3/openapi.json tmp/petstore.ts",
     "clean": "rimraf dist",
     "lint": "eslint \"{src,test}/**/*.ts\" --fix",
     "prebuild": "npm run lint && npm run clean",