[+] embedded models

gerasev-kirill · gerasev-kirill · commit 00dbd1a8f4f4 · 2024-05-24T15:34:45.000+03:00
diff --git a/dist/index.js b/dist/index.js
diff --git a/package.json b/package.json
@@ -49,6 +49,7 @@
         "validate": "tsc --project tsconfig.json --noEmit",
         "run": "node ./test/index.js",
         "test": "jest --selectProjects UNIT",
+        "test:index": "jest test/index.spec.ts",
         "test:update": "jest --selectProjects UNIT --updateSnapshot",
         "test:watch": "jest --selectProjects UNIT --watch",
         "test:coverage": "jest --selectProjects UNIT --coverage",
diff --git a/src/client/interfaces/Model.d.ts b/src/client/interfaces/Model.d.ts
@@ -3,6 +3,9 @@ import type { Schema } from './Schema';
 
 export interface Model extends Schema {
     name: string;
+    isEmbedded?: boolean,
+    isNodeModule?: boolean,
+    filePath?: string,
     export: 'reference' | 'generic' | 'enum' | 'array' | 'dictionary' | 'interface' | 'one-of' | 'any-of' | 'all-of';
     type: string;
     base: string;
@@ -11,7 +14,7 @@ export interface Model extends Schema {
     description: string | null;
     deprecated?: boolean;
     default?: string;
-    imports: string[];
+    imports: Array<{typeName: string, path: string, nodeModule?: boolean}|string>;
     enum: Enum[];
     enums: Model[];
     properties: Model[];
diff --git a/src/client/interfaces/ModelComposition.d.ts b/src/client/interfaces/ModelComposition.d.ts
@@ -2,7 +2,7 @@ import type { Model } from './Model';
 
 export interface ModelComposition {
     type: 'one-of' | 'any-of' | 'all-of';
-    imports: string[];
+    imports: Array<{typeName: string, path: string}|string>;
     enums: Model[];
     properties: Model[];
 }
diff --git a/src/client/interfaces/OperationParameters.d.ts b/src/client/interfaces/OperationParameters.d.ts
@@ -1,7 +1,7 @@
 import type { OperationParameter } from './OperationParameter';
 
 export interface OperationParameters {
-    imports: string[];
+    imports: Array<{typeName: string, path: string}|string>;
     parameters: OperationParameter[];
     parametersPath: OperationParameter[];
     parametersQuery: OperationParameter[];
diff --git a/src/client/interfaces/Service.d.ts b/src/client/interfaces/Service.d.ts
@@ -3,5 +3,5 @@ import type { Operation } from './Operation';
 export interface Service {
     name: string;
     operations: Operation[];
-    imports: string[];
+    imports: Array<{typeName: string, path: string}|string>;
 }
diff --git a/src/client/interfaces/Type.d.ts b/src/client/interfaces/Type.d.ts
@@ -2,6 +2,6 @@ export interface Type {
     type: string;
     base: string;
     template: string | null;
-    imports: string[];
+    imports: Array<{typeName: string, path: string, nodeModule?: boolean}|string>;
     isNullable: boolean;
 }
diff --git a/src/openApi/v3/parser/getModels.ts b/src/openApi/v3/parser/getModels.ts
@@ -3,17 +3,49 @@ import type { OpenApi } from '../interfaces/OpenApi';
 import { getModel } from './getModel';
 import { getType } from './getType';
 
+
+function isObject(value: any): value is Record<string,any>{
+    return value !== null && typeof value === 'object'
+}
+
+
+
 export const getModels = (openApi: OpenApi): Model[] => {
+    if (!openApi.components) return [];
+
     const models: Model[] = [];
-    if (openApi.components) {
-        for (const definitionName in openApi.components.schemas) {
-            if (openApi.components.schemas.hasOwnProperty(definitionName)) {
-                const definition = openApi.components.schemas[definitionName];
-                const definitionType = getType(definitionName);
-                const model = getModel(openApi, definition, true, definitionType.base);
-                models.push(model);
+    function collectModel(definition: any, definitionName: string){
+        if (definition.type){
+            const definitionType = getType(definitionName);
+            const model = getModel(openApi, definition, true, definitionType.base);
+            if (isObject(definitionType.imports[0])){
+                model.filePath = definitionType.imports[0]?.path;
             }
+            model.isEmbedded = definitionName.includes('embedded') || 
+                               definition.type === 'node_module';
+            model.isNodeModule = definition.type === 'node_module';
+            models.push(model);
+            return
+        }
+        for(const key in definition){
+            if (!isObject(definition[key])){
+                continue
+            }
+            collectModel(definition[key], definitionName + '/' + key)
         }
     }
+
+
+    for (const definitionName in openApi.components.schemas) {
+        if (!openApi.components.schemas.hasOwnProperty(definitionName)) continue;
+        collectModel(openApi.components.schemas[definitionName], definitionName);
+        /*
+        const definition = openApi.components.schemas[definitionName];
+        const definitionType = getType(definitionName);
+        const model = getModel(openApi, definition, true, definitionType.base);
+        models.push(model);
+        */
+    }
+
     return models;
 };
diff --git a/src/openApi/v3/parser/getType.spec.ts b/src/openApi/v3/parser/getType.spec.ts
@@ -33,7 +33,11 @@ describe('getType', () => {
         expect(type.type).toEqual('Link<string>');
         expect(type.base).toEqual('Link');
         expect(type.template).toEqual('string');
-        expect(type.imports).toEqual(['Link']);
+        expect(type.imports).toEqual([{
+            nodeModule: false,
+            path: 'Link',
+            typeName: 'Link'
+        }]);
         expect(type.isNullable).toEqual(false);
     });
 
@@ -42,7 +46,15 @@ describe('getType', () => {
         expect(type.type).toEqual('Link<Model>');
         expect(type.base).toEqual('Link');
         expect(type.template).toEqual('Model');
-        expect(type.imports).toEqual(['Link', 'Model']);
+        expect(type.imports).toEqual([{
+            nodeModule: false,
+            path: 'Link',
+            typeName: 'Link'
+        },{
+            nodeModule: false,
+            path: 'Model',
+            typeName: 'Model'
+        }]);
         expect(type.isNullable).toEqual(false);
     });
 
@@ -51,7 +63,15 @@ describe('getType', () => {
         expect(type.type).toEqual('Link<Link>');
         expect(type.base).toEqual('Link');
         expect(type.template).toEqual('Link');
-        expect(type.imports).toEqual(['Link', 'Link']);
+        expect(type.imports).toEqual([{
+            nodeModule: false,
+            path: 'Link',
+            typeName: 'Link'
+        },{
+            nodeModule: false,
+            path: 'Link',
+            typeName: 'Link'
+        }]);
         expect(type.isNullable).toEqual(false);
     });
 
@@ -60,7 +80,11 @@ describe('getType', () => {
         expect(type.type).toEqual('model_000');
         expect(type.base).toEqual('model_000');
         expect(type.template).toEqual(null);
-        expect(type.imports).toEqual(['model_000']);
+        expect(type.imports).toEqual([{
+            nodeModule: false,
+            path: 'model.000',
+            typeName: 'model_000'
+        }]);
         expect(type.isNullable).toEqual(false);
     });
 
@@ -69,7 +93,11 @@ describe('getType', () => {
         expect(type.type).toEqual('some_special_schema');
         expect(type.base).toEqual('some_special_schema');
         expect(type.template).toEqual(null);
-        expect(type.imports).toEqual(['some_special_schema']);
+        expect(type.imports).toEqual([{
+            nodeModule: false,
+            path: 'some_special-schema',
+            typeName: 'some_special_schema'
+        }]);
         expect(type.isNullable).toEqual(false);
     });
 
@@ -78,7 +106,11 @@ describe('getType', () => {
         expect(type.type).toEqual('$some_special_schema');
         expect(type.base).toEqual('$some_special_schema');
         expect(type.template).toEqual(null);
-        expect(type.imports).toEqual(['$some_special_schema']);
+        expect(type.imports).toEqual([{
+            nodeModule: false,
+            path: '$some+special+schema',
+            typeName: '$some_special_schema'
+        }]);
         expect(type.isNullable).toEqual(false);
     });
 
diff --git a/src/openApi/v3/parser/getType.ts b/src/openApi/v3/parser/getType.ts
@@ -71,10 +71,26 @@ export const getType = (type: string | string[] = 'any', format?: string): Type
     }
 
     if (typeWithoutNamespace) {
+        let path = typeWithoutNamespace.split('/');
+        const type = encode(path[path.length-1]);
+        const isNodeModule = path[0] === 'node_modules';
+        if (isNodeModule){
+            path.splice(0,1);
+            path.splice(path.length-1, 1);
+        }
+        result.type = type;
+        result.base = type;
+        result.imports.push({
+            typeName: type,
+            path: path.join('/'),
+            nodeModule: isNodeModule
+        });
+        /*
         const type = encode(typeWithoutNamespace);
         result.type = type;
         result.base = type;
         result.imports.push(type);
+        */
         return result;
     }
 
diff --git a/src/templates/exportModel.hbs b/src/templates/exportModel.hbs
@@ -3,7 +3,15 @@
 {{#if imports}}
 
 {{#each imports}}
+{{#if this.typeName}}
+{{#if this.nodeModule}}
+import { {{{this.typeName}}} } from '{{{this.path}}}';
+{{else}}
+import type { {{{this.typeName}}} } from './{{{this.path}}}';
+{{/if}}
+{{else}}
 import type { {{{this}}} } from './{{{this}}}';
+{{/if}}
 {{/each}}
 {{/if}}
 
diff --git a/src/templates/exportService.hbs b/src/templates/exportService.hbs
@@ -13,7 +13,15 @@ import type { Observable } from 'rxjs';
 {{/equals}}
 {{#if imports}}
 {{#each imports}}
+{{#if this.typeName}}
+{{#if this.nodeModule}}
+import { {{{this.typeName}}} } from '{{{this.path}}}';
+{{else}}
+import type { {{{this.typeName}}} } from '../models/{{{this.path}}}';
+{{/if}}
+{{else}}
 import type { {{{this}}} } from '../models/{{{this}}}';
+{{/if}}
 {{/each}}
 
 {{/if}}
diff --git a/src/templates/index.hbs b/src/templates/index.hbs
@@ -17,6 +17,8 @@ export type { OpenAPIConfig } from './core/OpenAPI';
 {{#if models}}
 
 {{#each models}}
+{{#if isEmbedded}}
+{{else}}
 {{#if @root.useUnionTypes}}
 export type { {{{name}}} } from './models/{{{name}}}';
 {{else if enum}}
@@ -26,14 +28,18 @@ export { {{{name}}} } from './models/{{{name}}}';
 {{else}}
 export type { {{{name}}} } from './models/{{{name}}}';
 {{/if}}
+{{/if}}
 {{/each}}
 {{/if}}
 {{/if}}
 {{#if @root.exportSchemas}}
 {{#if models}}
 
 {{#each models}}
+{{#if isEmbedded}}
+{{else}}
 export { ${{{name}}} } from './schemas/${{{name}}}';
+{{/if}}
 {{/each}}
 {{/if}}
 {{/if}}
diff --git a/src/utils/postProcessModelImports.ts b/src/utils/postProcessModelImports.ts
@@ -6,7 +6,7 @@ import { unique } from './unique';
  * Set unique imports, sorted by name
  * @param model The model that is post-processed
  */
-export const postProcessModelImports = (model: Model): string[] => {
+export const postProcessModelImports = (model: Model): Array<{typeName: string, path: string}|string> => {
     return model.imports
         .filter(unique)
         .sort(sort)
diff --git a/src/utils/postProcessServiceImports.ts b/src/utils/postProcessServiceImports.ts
@@ -6,6 +6,6 @@ import { unique } from './unique';
  * Set unique imports, sorted by name
  * @param service
  */
-export const postProcessServiceImports = (service: Service): string[] => {
+export const postProcessServiceImports = (service: Service): Array<{typeName: string, path: string}|string> => {
     return service.imports.filter(unique).sort(sort);
 };
diff --git a/src/utils/sort.ts b/src/utils/sort.ts
@@ -1,5 +1,8 @@
-export const sort = (a: string, b: string): number => {
-    const nameA = a.toLowerCase();
-    const nameB = b.toLowerCase();
+export const sort = (a: string|any, b: string|any): number => {
+    if (a.typeName){
+        return -1;
+    }
+    const nameA = (a.typeName || a).toLowerCase();
+    const nameB = (b.typeName || b).toLowerCase();
     return nameA.localeCompare(nameB, 'en');
 };
diff --git a/src/utils/unique.ts b/src/utils/unique.ts
@@ -1,3 +1,11 @@
 export const unique = <T>(val: T, index: number, arr: T[]): boolean => {
+    if (typeof val === 'object'){
+        for (let i = 0; i < arr.length; i++) {
+            if (JSON.stringify(val) === JSON.stringify(arr[i])){
+                return i === index
+            }
+        }
+        return true
+    }
     return arr.indexOf(val) === index;
 };
diff --git a/src/utils/writeClientModels.ts b/src/utils/writeClientModels.ts
@@ -1,4 +1,5 @@
-import { resolve } from 'path';
+import path from 'path';
+import fs from 'fs';
 
 import type { Model } from '../client/interfaces/Model';
 import type { HttpClient } from '../HttpClient';
@@ -27,7 +28,28 @@ export const writeClientModels = async (
     additionalContext?: Record<string, unknown>
 ): Promise<void> => {
     for (const model of models) {
-        const file = resolve(outputPath, `${model.name}.ts`);
+        if (model.isNodeModule){
+            continue;
+        }
+        const filePath = model.filePath || model.name;
+        fs.mkdirSync(
+            path.dirname(path.join(outputPath, filePath)), 
+            { recursive: true }
+        );
+        if (model.isEmbedded){
+            // нам нужно вычислять относительный импорт
+            model.imports = model.imports.map((imp)=>{
+                if (typeof imp === 'string'){
+                    return imp
+                }
+                if (!imp.nodeModule){
+                    imp.path = path.relative(path.dirname(filePath), imp.path)
+                }
+                return imp
+            })
+        }
+
+        const file = path.resolve(outputPath, `${filePath}.ts`);
         const templateResult = templates.exports.model({
             ...model,
             httpClient,
diff --git a/src/utils/writeClientSchemas.ts b/src/utils/writeClientSchemas.ts
@@ -1,4 +1,5 @@
-import { resolve } from 'path';
+import path from 'path';
+import fs from 'fs';
 
 import type { Model } from '../client/interfaces/Model';
 import type { HttpClient } from '../HttpClient';
@@ -28,7 +29,15 @@ export const writeClientSchemas = async (
     additionalContext?: Record<string, unknown>
 ): Promise<void> => {
     for (const model of models) {
-        const file = resolve(outputPath, `$${model.name}.ts`);
+        if (model.isNodeModule){
+            continue
+        }
+        const filePath = model.filePath || model.name;
+        const dirName = path.dirname(path.join(outputPath, filePath)); 
+        const fileName = path.basename(filePath)
+        fs.mkdirSync(dirName, { recursive: true });
+
+        const file = path.resolve(outputPath, dirName, `$${fileName}.ts`);
         const templateResult = templates.exports.schema({
             ...model,
             httpClient,
diff --git a/test/index.spec.ts b/test/index.spec.ts
diff --git a/test/spec/v3-embedded.json b/test/spec/v3-embedded.json

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ import type { Model } from './Model';`
`2`	`2`
`3`	`3`	`export interface ModelComposition {`
`4`	`4`	`type: 'one-of' \| 'any-of' \| 'all-of';`
`5`		`- imports: string[];`
	`5`	`+ imports: Array<{typeName: string, path: string}\|string>;`
`6`	`6`	`enums: Model[];`
`7`	`7`	`properties: Model[];`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,5 +3,5 @@ import type { Operation } from './Operation';`
`3`	`3`	`export interface Service {`
`4`	`4`	`name: string;`
`5`	`5`	`operations: Operation[];`
`6`		`- imports: string[];`
	`6`	`+ imports: Array<{typeName: string, path: string}\|string>;`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,6 @@ export interface Type {`
`2`	`2`	`type: string;`
`3`	`3`	`base: string;`
`4`	`4`	`template: string \| null;`
`5`		`- imports: string[];`
	`5`	`+ imports: Array<{typeName: string, path: string, nodeModule?: boolean}\|string>;`
`6`	`6`	`isNullable: boolean;`
`7`	`7`	`}`