fixes for frontend

.gitignore

@@ -48,3 +48,5 @@ lerna-debug.log*
 
 # Generated reports
 /public/reports/generated/
+
+/.gii-fs.json

gii-fs.json.sample

@@ -0,0 +1,6 @@
+{
+    "port": 9876,
+    "projects": [
+        "/Users/ivanov_ivan/projects/my_project/backend-nest"
+    ]
+}

package.json

@@ -16,8 +16,7 @@
     "prebuild": "rimraf dist",
     "build": "nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
-    "start": "nest start",
-    "start:dev": "nest start --watch --",
+    "start": "nest start --watch --",
     "start:debug": "nest start --debug --watch",
     "start:prod": "node dist/main",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",

src/config/main.ts

@@ -1,18 +1,22 @@
 import * as process from 'process';
 import * as path from 'path';
+import * as fs from 'fs';
 
 export default () => ({
     name: '@steroidsjs/gii-fs',
     title: 'FS Developer Server',
     version: '1.0',
     cors: {
         allowDomains: [
-            '127.0.0.1:9350',
+            '127.0.0.1:9991',
         ],
     },
     project: {
         configRoute: process.argv.at(-1).endsWith('.json')
             ? process.argv.at(-1)
-            : path.resolve(require('os').homedir(), 'gii-fs.json'),
+            : (fs.existsSync(path.resolve(require('os').homedir(), 'gii-fs.json'))
+                    ? path.resolve(require('os').homedir(), 'gii-fs.json')
+                    : path.resolve(process.cwd(), 'gii-fs.json')
+            )
     }
 });

src/project/domain/enums/ModelFieldOptionsEnum.ts

@@ -40,7 +40,7 @@ export class ModelFieldOptionsEnum extends BaseEnum {
         [this.ENUM]: 'enumId',
         [this.TYPE]: 'relation.type',
         [this.IS_OWNING_SIDE]: 'relation.isOwningSide',
-        [this.RELATION_CLASS]: 'relation.modelId',
+        [this.RELATION_CLASS]: 'relation',
         [this.INVERSE_SIDE]: 'relation.inverseSide',
         [this.RELATION_NAME]: 'relationName',
         [this.IS_ARRAY]: 'isArray',

src/project/infrastructure/ProjectModule.ts

@@ -5,6 +5,7 @@ import {ProjectController} from './controllers/ProjectController';
 import {ProjectService} from '../usecases/services/ProjectService';
 import {ProjectModelService} from '../usecases/services/ProjectModelService';
 import {ProjectEnumService} from '../usecases/services/ProjectEnumService';
+import {ProjectParserService} from '../usecases/services/ProjectParserService';
 
 @Module({
     imports: [
@@ -14,9 +15,15 @@ import {ProjectEnumService} from '../usecases/services/ProjectEnumService';
         ProjectController,
     ],
     providers: [
-        ModuleHelper.provide(ProjectService, [ConfigService]),
-        ModuleHelper.provide(ProjectModelService, [ProjectService]),
-        ModuleHelper.provide(ProjectEnumService, [ProjectService]),
+        ModuleHelper.provide(ProjectParserService, [ConfigService]),
+        ModuleHelper.provide(ProjectModelService, [ProjectParserService]),
+        ModuleHelper.provide(ProjectEnumService, [ProjectParserService]),
+        ModuleHelper.provide(ProjectService, [
+            ProjectParserService,
+            ProjectModelService,
+            ProjectEnumService,
+            ConfigService,
+        ]),
     ]
 })
 export class ProjectModule {}

src/project/infrastructure/controllers/ProjectController.ts

@@ -8,6 +8,7 @@ import {EnumSaveDto} from '../../usecases/dtos/EnumSaveDto';
 import {ModelSaveDto} from '../../usecases/dtos/ModelSaveDto';
 import {ModelScheme} from '../schemes/ModelScheme';
 import {EnumScheme} from '../schemes/EnumScheme';
+import {ProjectDetailScheme} from '../schemes/ProjectDetailScheme';
 
 @ApiTags('Информация о проекте')
 @Controller()
@@ -23,12 +24,20 @@ export class ProjectController {
         private enumService: ProjectEnumService,
     ) {}
 
-    @Get('/projects')
+    @Get('/project')
     @ApiOkResponse({type: ProjectScheme, isArray: true})
     async getProjects() {
         return this.projectService.getProjects();
     }
 
+    @Get('/project/:name')
+    @ApiOkResponse({type: ProjectDetailScheme})
+    async getProject(
+        @Param('name') name: string,
+    ) {
+        return this.projectService.getProject(name);
+    }
+
     @Get('/model/:id')
     @ApiOkResponse({type: ModelScheme, isArray: true})
     async getModel(

src/project/infrastructure/schemes/ModuleDetailScheme.ts

@@ -0,0 +1,21 @@
+import {ExtendField} from '@steroidsjs/nest/infrastructure/decorators/fields/ExtendField';
+import {ModelEnumScheme} from './ModelEnumScheme';
+import {ProjectModuleModel} from '../../domain/models/ProjectModuleModel';
+import {EnumEnumScheme} from './EnumEnumScheme';
+import {ModelScheme} from './ModelScheme';
+import {EnumScheme} from './EnumScheme';
+
+export class ModuleDetailScheme {
+    @ExtendField(ProjectModuleModel)
+    name: string;
+
+    @ExtendField(ProjectModuleModel, {
+        relationClass: () => ModelScheme,
+    })
+    models: ModelScheme[];
+
+    @ExtendField(ProjectModuleModel, {
+        relationClass: () => ModelScheme,
+    })
+    enums: EnumScheme[];
+}

src/project/infrastructure/schemes/ProjectDetailScheme.ts

@@ -0,0 +1,13 @@
+import {ModuleDetailScheme} from './ModuleDetailScheme';
+import {ExtendField} from '@steroidsjs/nest/infrastructure/decorators/fields/ExtendField';
+import {ProjectModel} from '../../domain/models/ProjectModel';
+
+export class ProjectDetailScheme {
+    @ExtendField(ProjectModel)
+    name: string;
+
+    @ExtendField(ProjectModel, {
+        relationClass: () => ModuleDetailScheme,
+    })
+    modules: ModuleDetailScheme[];
+}

src/project/usecases/services/ProjectEnumService.ts

@@ -8,13 +8,13 @@ import {ProjectEnumModel} from '../../domain/models/ProjectEnumModel';
 import {ProjectEnumFieldModel} from '../../domain/models/ProjectEnumFieldModel';
 import {tab, updateFileContent} from '../helpers';
 import {EnumSaveDto} from '../dtos/EnumSaveDto';
-import {ProjectService} from './ProjectService';
+import {ProjectParserService} from './ProjectParserService';
 
 const LABELS_FUNCTION_NAME = 'getLabels';
 
 export class ProjectEnumService {
     constructor(
-        private projectService: ProjectService,
+        private projectParserService: ProjectParserService,
     ) {}
 
     public getEnumInfo(id: string) {
@@ -37,22 +37,27 @@ export class ProjectEnumService {
         enumDto.name = enumNode.name?.escapedText;
 
         const labelsFunction = enumNode.members.find(member => member.name.escapedText === LABELS_FUNCTION_NAME);
-        for (const member of enumNode.members) {
-            if (!member.name.escapedText || member.parameters) {
-                continue;
+        if (labelsFunction) {
+            for (const member of enumNode.members) {
+                if (!member.name.escapedText || member.parameters) {
+                    continue;
+                }
+                const fieldDto = new ProjectEnumFieldModel();
+                fieldDto.id = member.name.escapedText;
+
+                if (labelsFunction.body?.statements?.[0]?.expression?.properties) {
+                    const labelProperty = labelsFunction.body.statements[0].expression.properties.find(property => (
+                        property.name.expression.name.escapedText === fieldDto.id
+                    ));
+                    if (labelProperty) {
+                        fieldDto.label = labelProperty.initializer.text;
+                    }
+                }
+
+                enumDto.fields.push(fieldDto);
             }
-            const fieldDto = new ProjectEnumFieldModel();
-            fieldDto.id = member.name.escapedText;
-
-            const labelProperty = labelsFunction.body.statements[0].expression.properties.find(property => (
-                property.name.expression.name.escapedText === fieldDto.id
-            ));
-            fieldDto.label = labelProperty.initializer.text;
-
-            enumDto.fields.push(fieldDto);
         }
 
-
         return enumDto;
     }
 
@@ -187,7 +192,7 @@ export class ProjectEnumService {
         const PROPERTIES_DECLARATIONS_KEY = '%propertiesDeclarations%';
         const LABELS_DECLARATIONS_KEY = '%labelsDeclarations%';
 
-        const modulePath = this.projectService.getModulePathByName(projectName, moduleName);
+        const modulePath = this.projectParserService.getModulePathByName(projectName, moduleName);
 
         const enumsPath = path.resolve(modulePath, 'domain', 'enums');
         if (!fs.existsSync(enumsPath)) {

src/project/usecases/services/ProjectModelService.ts

@@ -10,13 +10,13 @@ import {SteroidsFieldsEnum} from '../../domain/enums/SteroidsFieldsEnum';
 import {ProjectModelModel} from '../../domain/models/ProjectModelModel';
 import {ModelSaveDto} from '../dtos/ModelSaveDto';
 import {clearObject, tab, updateFileContent} from '../helpers';
-import {ProjectService} from './ProjectService';
 import {ModelFieldSaveDto} from '../dtos/ModelFieldSaveDto';
 import {ModelFieldOptionsEnum} from '../../domain/enums/ModelFieldOptionsEnum';
+import {ProjectParserService} from './ProjectParserService';
 
 export class ProjectModelService {
     constructor(
-        private projectService: ProjectService,
+        private projectParserService: ProjectParserService,
     ) {}
 
     public getModelInfo(id: string) {
@@ -27,7 +27,7 @@ export class ProjectModelService {
     private parseModelField(fileContent: string, tsMember: any, projectName: string): ProjectModelFieldModel | null {
         let fieldDecorator = tsMember.decorators?.find(decorator => decorator.expression.expression.escapedText.includes('Field'));
         if (!fieldDecorator) {
-            fieldDecorator = tsMember.modifiers?.find(decorator => decorator.expression.expression.escapedText.includes('Field'));
+            fieldDecorator = tsMember.modifiers?.find(decorator => decorator.expression?.expression?.escapedText?.includes('Field'));
         }
         if (!fieldDecorator) {
             return null;
@@ -48,21 +48,24 @@ export class ProjectModelService {
 
             if (initializer?.kind === SyntaxKind.PropertyAccessExpression) {
                 return {
-                    entityId: this.projectService.getEntityIdByName(projectName, initializer.expression?.escapedText),
+                    entityId: this.projectParserService.getEntityIdByName(projectName, initializer.expression?.escapedText),
                     property: initializer.name?.escapedText,
                 };
             }
 
             // Пока что inverseSide получается как строка, нужно подумать, как с ней работать в дальнейшем
             if (initializer?.kind === SyntaxKind.ArrowFunction) {
                 if (initializer.body.kind === SyntaxKind.Identifier) {
-                    return this.projectService.getEntityIdByName(projectName, initializer.body.escapedText);
+                    return {
+                        modelId: this.projectParserService.getEntityIdByName(projectName, initializer.body.escapedText),
+                        modelName: initializer.body.escapedText,
+                    };
                 }
                 return fileContent.slice(initializer.pos + 1, initializer.end);
             }
 
             if (initializer?.kind === SyntaxKind.Identifier) {
-                return this.projectService.getEntityIdByName(projectName, initializer.escapedText);
+                return this.projectParserService.getEntityIdByName(projectName, initializer.escapedText);
             }
 
             if (initializer?.text) {
@@ -72,16 +75,28 @@ export class ProjectModelService {
             return initializer;
         }
 
-        const findPropertyValue = (propertyName: string) => getValue(fieldDecorator.expression.arguments?.[0]?.properties?.find(property => (
-            property.name.escapedText === propertyName
-        ))?.initializer)
+        const findPropertyValue = (propertyName: string) => getValue(
+            fieldDecorator.expression.arguments?.[0]?.properties
+            ?.find(property => property.name.escapedText === propertyName)
+            ?.initializer
+        )
 
         let fieldDto = new ProjectModelFieldModel();
         fieldDto.name = tsMember.name.escapedText;
         fieldDto.type = fieldDecorator.expression.expression.escapedText;
 
         for (const fieldKey of ModelFieldOptionsEnum.getKeys()) {
-            _set(fieldDto, ModelFieldOptionsEnum.getDtoField(fieldKey), findPropertyValue(fieldKey))
+            const key = ModelFieldOptionsEnum.getDtoField(fieldKey);
+            const value = findPropertyValue(fieldKey);
+
+            if (typeof fieldDto[key] === 'object' && typeof value === 'object') {
+                fieldDto[key] = {
+                    ...fieldDto[key],
+                    ...value,
+                };
+            } else {
+                _set(fieldDto, ModelFieldOptionsEnum.getDtoField(fieldKey), findPropertyValue(fieldKey))
+            }
         }
 
         fieldDto = clearObject(fieldDto);
@@ -90,7 +105,7 @@ export class ProjectModelService {
     }
 
     private parseModel(modelPath: string): ProjectModelModel {
-        const projectName = this.projectService.getProjectNameByEntityPath(modelPath);
+        const projectName = this.projectParserService.getProjectNameByEntityPath(modelPath);
 
         let fileContent = fs.readFileSync(modelPath).toString();
         const ast: any = ts.createSourceFile(
@@ -285,7 +300,7 @@ export class ProjectModelService {
         fs.writeFileSync(dto.id, fileContent);
 
         // Обновляем блок импортов
-        this.projectService.updateFileImports(dto.id, {
+        this.projectParserService.updateFileImports(dto.id, {
             projectEntities: entitiesToImport,
             steroidsFields: steroidsFieldsToImport,
         });
@@ -302,7 +317,7 @@ export class ProjectModelService {
         let type = SteroidsFieldsEnum.getFieldType(fieldDto.type);
 
         if (type === 'object' && fieldDto.type === SteroidsFieldsEnum.RELATION_FIELD) {
-            type = this.projectService.getEntityNameByPath(fieldDto.relation?.modelId);
+            type = this.projectParserService.getEntityNameByPath(fieldDto.relation?.modelId);
             entitiesToImport.push(fieldDto.relation?.modelId);
         }
         if (['OneToMany', 'ManyToMany'].includes(fieldDto.relation?.type)) {
@@ -338,14 +353,14 @@ export class ProjectModelService {
             };
         }
         if (optionName === ModelFieldOptionsEnum.RELATION_CLASS) {
-            const modelName = this.projectService.getEntityNameByPath(fieldValue);
+            const modelName = this.projectParserService.getEntityNameByPath(fieldValue);
             return {
                 code: `relationClass: () => ${modelName},`,
                 entitiesToImport: [fieldValue],
             };
         }
         if (optionName === ModelFieldOptionsEnum.ENUM) {
-            const enumName = this.projectService.getEntityNameByPath(fieldValue);
+            const enumName = this.projectParserService.getEntityNameByPath(fieldValue);
             return {
                 code: `enum: ${enumName},`,
                 entitiesToImport: [fieldValue],
@@ -358,7 +373,7 @@ export class ProjectModelService {
             };
         }
         if (typeof fieldValue === 'object' && fieldValue.entityId && fieldValue.property) {
-            const entityName = this.projectService.getEntityNameByPath(fieldValue.entityId);
+            const entityName = this.projectParserService.getEntityNameByPath(fieldValue.entityId);
             return {
                 code: `${optionName}: ${entityName}.${fieldValue.property},`,
                 entitiesToImport: [fieldValue.entityId],
@@ -380,7 +395,7 @@ export class ProjectModelService {
         const MODELS_NAME_KEY = '%modelName%';
         const PROPERTIES_DECLARATIONS_KEY = '%propertiesDeclarations%';
 
-        const modulePath = this.projectService.getModulePathByName(projectName, moduleName);
+        const modulePath = this.projectParserService.getModulePathByName(projectName, moduleName);
 
         const modelsPath = path.resolve(modulePath, 'domain', 'models');
         if (!fs.existsSync(modelsPath)) {
@@ -407,7 +422,7 @@ export class ProjectModelService {
         fs.writeFileSync(filename, resultFileContent);
 
         // Обновляем блок импортов
-        this.projectService.updateFileImports(filename, {
+        this.projectParserService.updateFileImports(filename, {
             projectEntities,
             steroidsFields,
         });