- Added core template files

- Working on v2 parsing

Author: ferdikoomen

package.json

@@ -74,6 +74,7 @@
         "eslint": "6.6.0",
         "eslint-config-prettier": "6.5.0",
         "eslint-plugin-prettier": "3.1.1",
+        "glob": "7.1.6",
         "handlebars": "4.5.1",
         "jest": "24.9.0",
         "jest-cli": "24.9.0",

src/client/interfaces/ArrayType.d.ts

@@ -0,0 +1,7 @@
+export interface ArrayType {
+    type: string;
+    base: string;
+    template: string | null;
+    default?: any;
+    imports: string[];
+}

src/client/interfaces/Client.d.ts

@@ -1,11 +1,9 @@
 import { Model } from './Model';
 import { Service } from './Service';
-import { Schema } from './Schema';
 
 export interface Client {
     version: string;
     server: string;
     models: Map<string, Model>;
-    schemas: Map<string, Schema>;
     services: Map<string, Service>;
 }

src/client/interfaces/Model.d.ts

@@ -5,7 +5,7 @@ export interface Model {
     name: string;
     base: string;
     type: string;
-    template?: string;
+    template: string | null;
     description?: string;
     extends: string[];
     imports: string[];

src/client/interfaces/ModelEnum.ts renamed to src/client/interfaces/ModelEnum.d.ts

@@ -2,7 +2,7 @@ export interface ModelProperty {
     name: string;
     type: string;
     base: string;
-    template?: string;
+    template: string | null;
     description?: string;
     default?: any;
     required: boolean;

src/client/interfaces/ModelEnumValue.ts renamed to src/client/interfaces/ModelEnumValue.d.ts

@@ -0,0 +1,21 @@
+import { OperationError } from './OperationError';
+import { Parameter } from './Parameter';
+
+export interface Operation {
+    service: string;
+    name: string;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    method: string;
+    path: string;
+    parameters: Parameter[];
+    parametersPath: Parameter[];
+    parametersQuery: Parameter[];
+    parametersForm: Parameter[];
+    parametersHeader: Parameter[];
+    parametersBody: Parameter | null;
+    errors: OperationError[];
+    result: string;
+    imports: string[];
+}

src/client/interfaces/ModelProperty.d.ts

@@ -0,0 +1,4 @@
+export interface OperationError {
+    code: number;
+    text: string;
+}

src/client/interfaces/Operation.d.ts

@@ -0,0 +1,11 @@
+import { Parameter } from './Parameter';
+
+export interface OperationParameters {
+    imports: string[];
+    parameters: Parameter[];
+    parametersPath: Parameter[];
+    parametersQuery: Parameter[];
+    parametersForm: Parameter[];
+    parametersHeader: Parameter[];
+    parametersBody: Parameter | null;
+}

src/client/interfaces/OperationError.d.ts

@@ -0,0 +1,4 @@
+export interface OperationResponse {
+    code: number;
+    text: string;
+}

src/client/interfaces/OperationParameters.d.ts

@@ -0,0 +1,4 @@
+export interface OperationResult {
+    type: string;
+    imports: string[];
+}

src/client/interfaces/OperationResponse.d.ts

@@ -0,0 +1,13 @@
+export interface Parameter {
+    prop: string;
+    in: 'path' | 'query' | 'header' | 'formData' | 'body';
+    name: string;
+    type: string;
+    base: string;
+    template: string | null;
+    description?: string;
+    default?: any;
+    required: boolean;
+    nullable: boolean;
+    imports: string[];
+}

src/client/interfaces/OperationResult.d.ts

@@ -1,5 +1,7 @@
 export interface Schema {
-    name: string;
+    type: string;
     base: string;
-    imports: [];
+    template: string | null;
+    default?: any;
+    imports: string[];
 }

src/client/interfaces/Parameter.d.ts

@@ -1,7 +1,7 @@
-import { ServiceOperation } from './ServiceOperation';
+import { Operation } from './Operation';
 
 export interface Service {
     name: string;
-    operations: ServiceOperation[];
+    operations: Operation[];
     imports: string[];
 }

src/client/interfaces/Schema.d.ts

@@ -31,12 +31,12 @@ export function generate(input: string, output: string, language: Language = Lan
     const inputPath = path.resolve(process.cwd(), input);
     const outputPath = path.resolve(process.cwd(), output);
 
-    console.log(chalk.bold.green('Generate:'));
-    console.log(chalk.grey('  Input:'), input);
-    console.log(chalk.grey('  Output:'), output);
-    console.log(chalk.grey('  Language:'), language);
-    console.log(chalk.grey('  HTTP client:'), httpClient);
-    console.log(os.EOL);
+    // console.log(chalk.bold.green('Generate:'));
+    // console.log(chalk.grey('  Input:'), input);
+    // console.log(chalk.grey('  Output:'), output);
+    // console.log(chalk.grey('  Language:'), language);
+    // console.log(chalk.grey('  HTTP client:'), httpClient);
+    // console.log(os.EOL);
 
     try {
         // Load the specification, read the OpenAPI version and load the

src/client/interfaces/Service.d.ts

@@ -3,7 +3,6 @@ import { Client } from '../../client/interfaces/Client';
 import { getServer } from './parser/getServer';
 import { getServices } from './parser/getServices';
 import { getModels } from './parser/getModels';
-import { getSchemas } from './parser/getSchemas';
 
 /**
  * Parse the OpenAPI specification to a Client model that contains
@@ -15,7 +14,6 @@ export function parse(openApi: OpenApi): Client {
         version: openApi.info.version,
         server: getServer(openApi),
         models: getModels(openApi),
-        schemas: getSchemas(openApi),
         services: getServices(openApi),
     };
 }

src/client/interfaces/ServiceOperation.d.ts

@@ -21,6 +21,6 @@ export interface OpenApiHeader {
     maxItems?: number;
     minItems?: number;
     uniqueItems?: boolean;
-    enum?: (string | number)[];
+    enum?: string[];
     multipleOf?: number;
 }

src/client/interfaces/ServiceOperationError.d.ts

@@ -17,6 +17,6 @@ export interface OpenApiItems {
     maxItems?: number;
     minItems?: number;
     uniqueItems?: number;
-    enum?: (string | number)[];
+    enum?: string[];
     multipleOf?: number;
 }

src/client/interfaces/ServiceOperationParameter.ts

@@ -1,5 +1,6 @@
 import { OpenApiItems } from './OpenApiItems';
 import { OpenApiSchema } from './OpenApiSchema';
+import { OpenApiReference } from './OpenApiReference';
 
 /**
  * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#parameterObject
@@ -9,8 +10,8 @@ export interface OpenApiParameter {
     in: 'path' | 'query' | 'header' | 'formData' | 'body';
     description?: string;
     required?: boolean;
-    schema?: OpenApiSchema;
-    type?: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'file';
+    schema?: OpenApiSchema & OpenApiReference;
+    type?: string;
     format?: 'int32' | 'int64' | 'float' | 'double' | 'string' | 'boolean' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
     allowEmptyValue?: boolean;
     items?: OpenApiItems;
@@ -26,6 +27,6 @@ export interface OpenApiParameter {
     maxItems?: number;
     minItems?: number;
     uniqueItems?: boolean;
-    enum?: (string | number)[];
+    enum?: string[];
     multipleOf?: number;
 }

src/client/interfaces/ServiceOperationResponse.ts

@@ -2,13 +2,14 @@ import { Dictionary } from '../../../utils/types';
 import { OpenApiExample } from './OpenApiExample';
 import { OpenApiHeader } from './OpenApiHeader';
 import { OpenApiSchema } from './OpenApiSchema';
+import { OpenApiReference } from './OpenApiReference';
 
 /**
  * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#responseObject
  */
 export interface OpenApiResponse {
     description: string;
-    schema?: OpenApiSchema;
+    schema?: OpenApiSchema & OpenApiReference;
     headers?: Dictionary<OpenApiHeader>;
     examples?: OpenApiExample;
 }

src/index.ts

@@ -7,5 +7,5 @@ import { OpenApiResponse } from './OpenApiResponse';
 export interface OpenApiResponses {
     [httpcode: string]: OpenApiResponse & OpenApiReference;
 
-    default: OpenApiResponse & OpenApiReference;
+    default?: OpenApiResponse & OpenApiReference;
 }

src/openApi/v2/index.ts

@@ -25,7 +25,7 @@ export interface OpenApiSchema {
     maxProperties?: number;
     minProperties?: number;
     required?: string[];
-    enum?: (string | number)[];
+    enum?: string[];
     type?: string;
     items?: OpenApiSchema & OpenApiReference;
     allOf?: (OpenApiSchema & OpenApiReference)[];

src/openApi/v2/interfaces/OpenApiHeader.d.ts

@@ -0,0 +1,45 @@
+import { getType } from './getType';
+import { Type } from '../../../client/interfaces/Type';
+import { OpenApiItems } from '../interfaces/OpenApiItems';
+import { getEnumType } from './getEnumType';
+import { ArrayType } from '../../../client/interfaces/ArrayType';
+
+export function getArrayType(items: OpenApiItems): ArrayType {
+    let itemsType = 'any';
+    let itemsBase = 'any';
+    let itemsTemplate: string | null = null;
+    const itemsImports: string[] = [];
+
+    // If the parameter has a type than it can be a basic or generic type.
+    if (items.type) {
+        const itemsData: Type = getType(items.type);
+        itemsType = itemsData.type;
+        itemsBase = itemsData.base;
+        itemsTemplate = itemsData.template;
+        itemsImports.push(...itemsData.imports);
+
+        // If the parameter is an Array type, we check for the child type,
+        // so we can create a typed array, otherwise this will be a "any[]".
+        if (items.type === 'array' && items.items) {
+            console.log('templated array', items.items);
+            // Parse the child types and create a correct Array type, for example "string[]" or "ActivityData[]"
+            // const child: ParsedProperty = parseProperty(parameter.items, template);
+            // parameterType = `${child.type}[]`;
+            // parameterBase = child.base;
+            // parameterTemplate = child.template;
+            // parameterImports.push(...child.imports);
+        }
+    }
+
+    if (items.enum) {
+        itemsType = getEnumType(items.enum, true);
+    }
+
+    return {
+        type: itemsType,
+        base: itemsBase,
+        template: itemsTemplate,
+        default: items.default,
+        imports: itemsImports,
+    };
+}

src/openApi/v2/interfaces/OpenApiItems.d.ts

@@ -0,0 +1,6 @@
+export function getComment(comment: string | undefined): string | undefined {
+    if (comment) {
+        return comment.replace(/(\r\n|\n|\r)+/g, '$1     * ');
+    }
+    return undefined;
+}

src/openApi/v2/interfaces/OpenApiParameter.d.ts

@@ -0,0 +1,20 @@
+export function getEnumType(values?: string[], addParentheses = false): string {
+    if (Array.isArray(values)) {
+        // Filter out empty and double enum values.
+        // Plus make sure we put quotes around strings!
+        const entries: string[] = values
+            .filter(name => name)
+            .filter((name, index, arr) => arr.indexOf(name) === index)
+            .map(value => `'${String(value)}'`);
+
+        // Add grouping parentheses if needed. This can be handy if enum values
+        // are used in Arrays, so that you will get the following definition:
+        // const myArray: ('EnumValue1' | 'EnumValue2' | 'EnumValue3')[];
+        if (entries.length > 1 && addParentheses) {
+            return `(${entries.join(' | ')})`;
+        }
+
+        return entries.join(' | ');
+    }
+    return 'string';
+}

src/openApi/v2/interfaces/OpenApiResponse.d.ts

@@ -0,0 +1,32 @@
+export function getEnumTypeFromDescription(description: string, addParentheses = false): string | null {
+    // Check if we can find this special format string:
+    // None=0,Something=1,AnotherThing=2
+    const matches: RegExpMatchArray | null = description.match(/((\w+)=([0-9]+)(?:,|$))/g);
+    if (matches) {
+        // Grab the values from the description
+        const values: number[] = [];
+        for (let i = 0, n = matches.length; i < n; i++) {
+            const value = parseInt(matches[i].split('=')[1].replace(/[^0-9]/g, ''));
+            if (Number.isInteger(value)) {
+                values.push(value);
+            }
+        }
+
+        // Filter and sort the values
+        const entries: string[] = values
+            .sort()
+            .filter((name, index, arr) => arr.indexOf(name) === index)
+            .map(value => String(value));
+
+        // Add grouping parentheses if needed. This can be handy if enum values
+        // are used in Arrays, so that you will get the following definition:
+        // const myArray: ('EnumValue1' | 'EnumValue2' | 'EnumValue3')[];
+        if (entries.length > 1 && addParentheses) {
+            return `(${entries.join(' | ')})`;
+        }
+
+        return entries.join(' | ');
+    }
+
+    return null;
+}