- Working on v2 service generation

Author: ferdikoomen

src/client/interfaces/Model.d.ts

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

src/client/interfaces/ModelEnum.ts

@@ -1,7 +1,7 @@
-import { ModelEnumProperty } from './ModelEnumProperty';
+import { ModelEnumValue } from './ModelEnumValue';
 
 export interface ModelEnum {
     name: string;
     value: string;
-    values: ModelEnumProperty[];
+    values: ModelEnumValue[];
 }

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

@@ -1,5 +1,6 @@
-export interface ModelEnumProperty {
+export interface ModelEnumValue {
     type: string;
     name: string;
+    description?: string;
     value: string | number;
 }

src/client/interfaces/ModelProperties.d.ts

@@ -2,9 +2,13 @@ export interface ModelProperty {
     name: string;
     type: string;
     base: string;
-    template: string | null;
-    description: string | null;
+    template?: string;
+    description?: string;
+    default?: any;
     required: boolean;
+    nullable: boolean;
     readOnly: boolean;
+    extends: string[];
     imports: string[];
+    properties: ModelProperty[];
 }

src/client/interfaces/ModelProperty.d.ts

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

src/client/interfaces/Service.d.ts

@@ -0,0 +1,23 @@
+import { ServiceOperationError } from './ServiceOperationError';
+import { ServiceOperationParameter } from './ServiceOperationParameter';
+import { Model } from './Model';
+import { ServiceOperationResponse } from './ServiceOperationResponse';
+
+export interface ServiceOperation {
+    name: string;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    method: string;
+    path: string;
+    parameters: ServiceOperationParameter[];
+    parametersPath: ServiceOperationParameter[];
+    parametersQuery: ServiceOperationParameter[];
+    parametersForm: ServiceOperationParameter[];
+    parametersHeader: ServiceOperationParameter[];
+    parametersBody: ServiceOperationParameter | null;
+    models: Model[];
+    errors: ServiceOperationError[];
+    response: ServiceOperationResponse | null;
+    result: string;
+}

src/client/interfaces/ServiceOperation.d.ts

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

src/client/interfaces/ServiceOperationError.d.ts

@@ -0,0 +1,13 @@
+export interface ServiceOperationParameter {
+    name: string;
+    type: string;
+    base: string;
+    template: string;
+    description: string;
+    default?: any;
+    required: boolean;
+    nullable: boolean;
+    // extends: string[];
+    // imports: string[];
+    // properties: ModelProperty[];
+}

src/client/interfaces/ServiceOperationParameter.ts

@@ -0,0 +1,5 @@
+export interface ServiceOperationResponse {
+    code: number;
+    text: string;
+    property: any;
+}

src/client/interfaces/ServiceOperationResponse.ts

@@ -20,7 +20,7 @@ export enum HttpClient {
 
 /**
  * Generate the OpenAPI client. This method will read the OpenAPI specification and based on the
- * given language it will generate the client, including the types models, validation schemas,
+ * given language it will generate the client, including the typed models, validation schemas,
  * service layer, etc.
  * @param input The relative location of the OpenAPI spec.
  * @param output The relative location of the output directory
@@ -39,6 +39,8 @@ export function generate(input: string, output: string, language: Language = Lan
     console.log(os.EOL);
 
     try {
+        // Load the specification, read the OpenAPI version and load the
+        // handlebar templates for the given language
         const openApi = getOpenApiSpec(inputPath);
         const openApiVersion = getOpenApiVersion(openApi);
         const templates = readHandlebarsTemplates(language);

src/index.ts

@@ -5,6 +5,11 @@ 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
+ * all the models, services and schema's we should output.
+ * @param openApi The OpenAPI spec  that we have loaded from disk.
+ */
 export function parse(openApi: OpenApi): Client {
     return {
         version: openApi.info.version,

src/openApi/v2/index.ts

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

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

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

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

@@ -15,7 +15,7 @@ export interface OpenApiOperation {
     operationId?: string;
     consumes?: string[];
     produces?: string[];
-    parameters?: OpenApiParameter[] | OpenApiReference[];
+    parameters?: (OpenApiParameter & OpenApiReference)[];
     responses: OpenApiResponses;
     schemes: ('http' | 'https' | 'ws' | 'wss')[];
     deprecated?: boolean;

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

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

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

@@ -6,13 +6,12 @@ import { OpenApiReference } from './OpenApiReference';
  * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#pathItemObject
  */
 export interface OpenApiPath {
-    $ref?: string;
     get?: OpenApiOperation;
     put?: OpenApiOperation;
     post?: OpenApiOperation;
     delete?: OpenApiOperation;
     options?: OpenApiOperation;
     head?: OpenApiOperation;
     patch?: OpenApiOperation;
-    parameters?: OpenApiParameter[] | OpenApiReference[];
+    parameters?: (OpenApiParameter & OpenApiReference)[];
 }

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

@@ -2,5 +2,5 @@
  * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#referenceObject
  */
 export interface OpenApiReference {
-    $ref: string;
+    $ref?: string;
 }

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

@@ -5,7 +5,7 @@ import { OpenApiResponse } from './OpenApiResponse';
  * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#responsesObject
  */
 export interface OpenApiResponses {
-    [httpcode: string]: OpenApiResponse | OpenApiReference;
+    [httpcode: string]: OpenApiResponse & OpenApiReference;
 
-    default: OpenApiResponse | OpenApiReference;
+    default: OpenApiResponse & OpenApiReference;
 }

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

@@ -7,7 +7,6 @@ import { OpenApiXml } from './OpenApiXml';
  * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#schemaObject
  */
 export interface OpenApiSchema {
-    $ref?: string;
     format?: 'int32' | 'int64' | 'float' | 'double' | 'string' | 'boolean' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
     title?: string;
     description?: string;
@@ -26,12 +25,12 @@ export interface OpenApiSchema {
     maxProperties?: number;
     minProperties?: number;
     required?: string[];
-    enum?: string[] | number[];
+    enum?: (string | number)[];
     type?: string;
-    items?: OpenApiReference | OpenApiSchema;
-    allOf?: OpenApiReference[] | OpenApiSchema[];
-    properties?: Dictionary<OpenApiSchema>;
-    additionalProperties?: boolean | OpenApiReference | OpenApiSchema;
+    items?: OpenApiSchema & OpenApiReference;
+    allOf?: (OpenApiSchema & OpenApiReference)[];
+    properties?: Dictionary<OpenApiSchema & OpenApiReference>;
+    additionalProperties?: boolean | (OpenApiSchema & OpenApiReference);
     discriminator?: string;
     readOnly?: boolean;
     xml?: OpenApiXml;

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

@@ -1,14 +1,100 @@
 import { ModelProperty } from '../../../client/interfaces/ModelProperty';
+import { OpenApiSchema } from '../interfaces/OpenApiSchema';
+import { OpenApiReference } from '../interfaces/OpenApiReference';
+import { getType } from './getType';
 
-export function parseModelProperty(): ModelProperty {
-    return {
-        name: '',
+export function getModelProperty(name: string, schema: OpenApiSchema & OpenApiReference): ModelProperty {
+    /**
+     $ref?: string;
+     format?: 'int32' | 'int64' | 'float' | 'double' | 'string' | 'boolean' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
+     title?: string;
+     description?: string;
+     default?: any;
+     multipleOf?: number;
+     maximum?: number;
+     exclusiveMaximum?: boolean;
+     minimum?: number;
+     exclusiveMinimum?: boolean;
+     maxLength?: number;
+     minLength?: number;
+     pattern?: string;
+     maxItems?: number;
+     minItems?: number;
+     uniqueItems?: number;
+     maxProperties?: number;
+     minProperties?: number;
+     required?: string[];
+     enum?: string[] | number[];
+     type?: string;
+     items?: OpenApiReference | OpenApiSchema;
+     allOf?: OpenApiReference[] | OpenApiSchema[];
+     properties?: Dictionary<OpenApiSchema>;
+     additionalProperties?: boolean | OpenApiReference | OpenApiSchema;
+     discriminator?: string;
+     readOnly?: boolean;
+     xml?: OpenApiXml;
+     externalDocs?: OpenApiExternalDocs;
+     example?: any;
+     */
+
+    const prop: ModelProperty = {
+        name: name,
         type: '',
         base: '',
         template: '',
-        description: null,
+        description: schema.description,
+        default: schema.default,
         required: false,
-        readOnly: false,
+        nullable: false,
+        readOnly: schema.readOnly || false,
         imports: [],
+        extends: [],
+        properties: [],
     };
+
+    if (schema.$ref) {
+        // console.log('parse $ref?');
+    }
+
+    if (schema.properties || schema.type === 'object') {
+        prop.type = 'interface';
+        // type is interface!?
+    }
+
+    if (schema.enum) {
+        prop.type = 'enum';
+        // type is enum!
+    }
+
+    console.log('propertyName:', schema);
+    console.log('format:', schema.format);
+    console.log('type:', schema.type);
+
+    const properties = schema.properties;
+    for (const propertyName in properties) {
+        if (properties.hasOwnProperty(propertyName)) {
+            const property = properties[propertyName];
+            console.log('propertyName', propertyName);
+            // getModelProperty(propertyName, property);
+        }
+    }
+
+    if (schema.allOf) {
+        schema.allOf.forEach(parent => {
+            if (parent.$ref) {
+                const extend = getType(parent.$ref);
+                prop.extends.push(extend.type);
+                prop.imports.push(extend.base);
+            }
+            if (parent.properties) {
+                console.log(parent.properties);
+                // const properties: ParsedModelProperties = parseModelProperties(modelClass, definition.allOf[1].properties as SwaggerDefinitions, required);
+                // model.imports.push(...properties.imports);
+                // model.properties.push(...properties.properties);
+                // model.enums.push(...properties.enums);
+            }
+        });
+    }
+
+    return prop;
 }