@solidstarters/solid-core 1.2.54 → 1.2.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.54",
+  "version": "1.2.57",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/controllers/field-metadata.controller.ts

@@ -64,7 +64,7 @@ export class FieldMetadataController {
     @ApiBearerAuth("jwt")
     @Delete(':id')
     async delete(@Param('id') id: number) {
-        return this.fieldMetadataService.remove(id);
+        return this.fieldMetadataService.delete(id);
     }
 
 

package/src/controllers/media-storage-provider-metadata.controller.ts

@@ -57,8 +57,8 @@ export class MediaStorageProviderMetadataController {
 
     @ApiBearerAuth("jwt")
     @Delete(':id')
-    remove(@Param('id') id: number) {
-        return this.mediaStorageProviderService.remove(id);
+    delete(@Param('id') id: number) {
+        return this.mediaStorageProviderService.delete(id);
     }
 
 }

package/src/controllers/module-metadata.controller.ts

@@ -82,7 +82,7 @@ export class ModuleMetadataController {
 
   @ApiBearerAuth("jwt")
   @Delete(':id')
-  remove(@Param('id') id: number) {
+  delete(@Param('id') id: number) {
     return this.moduleMetadataService.remove(id);
   }
 }

package/src/helpers/schematic.service.ts

@@ -15,6 +15,7 @@ type FieldOptions = {
   fields: any[]; //FIXME This type can be improved
   modelEnableSoftDelete?: boolean;
   parentModel?: string;
+  parentModule?: string;
 };
 export const REMOVE_FIELDS_COMMAND = 'remove-fields';
 export const REFRESH_MODEL_COMMAND = 'refresh-model';
@@ -31,7 +32,7 @@ enum SYSTEM_FIELDS_TO_IGNORE_FOR_CODE_GENERATION {
 export class SchematicService {
   private readonly logger = new Logger(SchematicService.name);
   private readonly SCHEMATIC_PROJECT = '@solidstarters/solid-code-builder';
-  constructor(private readonly commandService: CommandService) {}
+  constructor(private readonly commandService: CommandService) { }
 
   async executeSchematicCommand(
     command: string,
@@ -62,7 +63,7 @@ export class SchematicService {
       if (fieldOptions.table) {
         modelCommand += ` --table=${fieldOptions.table}`;
       }
-      
+
       if (fieldOptions.dataSource) {
         modelCommand += ` --data-source=${fieldOptions.dataSource}`;
       }
@@ -70,26 +71,29 @@ export class SchematicService {
       if (fieldOptions.modelEnableSoftDelete) {
         modelCommand += ` --model-enable-soft-delete=${fieldOptions.modelEnableSoftDelete}`;
       }
-      
+
       if (fieldOptions.parentModel) {
         modelCommand += ` --parent-model=${fieldOptions.parentModel}`;
       }
-      
+      if (fieldOptions.parentModule) {
+        modelCommand += ` --parent-module=${fieldOptions.parentModule}`;
+      }
+
       let fieldCommand = fieldOptions.fields
         .filter((field) => {
           return !Object.values(SYSTEM_FIELDS_TO_IGNORE_FOR_CODE_GENERATION).includes(field.name);
-        }) 
+        })
         .map((field) => {
           return `--fields='${JSON.stringify(field)}'`;
         })
         .join(' ');
-      const schematicCommand =  modelCommand + ' ' + fieldCommand;
+      const schematicCommand = modelCommand + ' ' + fieldCommand;
       // console.log('schematicCommand', schematicCommand);
       return schematicCommand;
     } else if (command === ADD_MODULE_COMMAND) {
       const moduleOptions = options as GenerateModuleOptions;
       // console.log('moduleOptions', moduleOptions);
-      const schematicCommand =  ` ${baseCommand} --module=${moduleOptions.module}`;
+      const schematicCommand = ` ${baseCommand} --module=${moduleOptions.module}`;
       // console.log('schematicCommand', schematicCommand);
       this.logger.debug('schematicCommand', schematicCommand);
       return schematicCommand;
@@ -97,5 +101,5 @@ export class SchematicService {
       throw new Error('Schematic command not supported.');
     }
   }
-  
+
 }

package/src/seeders/module-metadata-seeder.service.ts

@@ -208,7 +208,7 @@ export class ModuleMetadataSeederService {
             this.logger.debug(`[End] Processing security rules for ${moduleMetadata.name}`);
 
             // List Of Values
-            this.logger.debug(`[Start] Processing security rules for ${moduleMetadata.name}`);
+            this.logger.debug(`[Start] Processing List Of Values for ${moduleMetadata.name}`);
             const listOfValues: CreateListOfValuesDto[] = overallMetadata.listOfValues;
             await this.seedListOfValues(listOfValues);
             this.logger.debug(`[End] Processing List Of Values for ${moduleMetadata.name}`);

package/src/seeders/seed-data/solid-core-metadata.json

@@ -5355,7 +5355,7 @@
                               {
                                 "type": "field",
                                 "attrs": {
-                                  "name": "view"
+                                  "name": "viewMetadata"
                                 }
                               }
                             ]
@@ -5813,7 +5813,7 @@
                     "type": "field",
                     "attrs": {
                       "name": "roles",
-                      "renderMode": "checkbox",
+                      "widget": "checkbox",
                       "inlineCreateAutoSave": "true",
                       "renderModeCheckboxPreprocessor": "MenuItemMetadataRolesFormFieldPreprocessor",
                       "inlineCreate": "true",
@@ -5899,7 +5899,7 @@
             "type": "field",
             "attrs": {
               "name": "relativeUri",
-              "renderMode": "image",
+              "widget": "image",
               "isSearchable": true
             }
           },
@@ -5986,7 +5986,7 @@
                         "attrs": {
                           "name": "relativeUri",
                           "label": "relativeUri",
-                          "renderMode": "image"
+                          "widget": "image"
                         }
                       },
                       {
@@ -7029,7 +7029,7 @@
             "attrs": {
               "name": "permissions",
               "isSearchable": true,
-              "renderMode": "checkbox",
+              "widget": "checkbox",
               "inlineCreate": "true"
             }
           },
@@ -7122,7 +7122,7 @@
                             "type": "field",
                             "attrs": {
                               "name": "permissions",
-                              "renderMode": "inputSwitch",
+                              "widget": "inputSwitch",
                               "showLabel": false
                             }
                           }

package/src/services/authentication.service.ts

@@ -1009,7 +1009,14 @@ export class AuthenticationService {
         const tokens = await this.generateTokens(user);
 
         const response = {
-            ...user,
+            user: {
+                email: user.email,
+                mobile: user.mobile,
+                username: user.username,
+                // forcePasswordChange: user.forcePasswordChange,
+                id: user.id,
+                roles: user.roles.map((role, idx, roles) => role.name)
+            },
             ...tokens
         }
         return response;

package/src/services/crud-helper.service.ts

@@ -52,7 +52,8 @@ export class CrudHelperService {
                     return;
                 }
                 else { // Recursively call the applyFilters method to handle nested conditions
-                    selectQb.leftJoin(`${alias}.${key}`, key);
+                    const joinField = `${alias}.${key}`;
+                    if (!this.isRelationJoined(selectQb, joinField)) selectQb.leftJoin(joinField, key);
                     this.applyFilters(qb, primaryFilterObj, key, selectQb);
                 }
             });
@@ -150,6 +151,11 @@ export class CrudHelperService {
         return queryBuilder.expressionMap.joinAttributes.some(join => join.entityOrProperty === joinProperty);
     }
 
+    private hasJoins(queryBuilder: SelectQueryBuilder<any>): boolean {
+        return queryBuilder.expressionMap.joinAttributes.length > 0;
+    }
+
+
     buildFilterQuery(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string): SelectQueryBuilder<any> { //TODO : Check how to pass a type to SelectQueryBuilder instead of any
         let { limit, offset, showSoftDeleted, filters } = basicFilterDto;
         const { fields, sort, groupBy, populate = [] } = basicFilterDto;
@@ -163,6 +169,11 @@ export class CrudHelperService {
             throw new Error('buildFilterQuery: Only 1 Group by field is supported currently');
         }
 
+        // Depending upon the populate option, apply the join clause
+        if (normalizedPopulate && normalizedPopulate.length) {
+            this.buildPopulateQuery(normalizedPopulate, entityAlias, qb);
+        }
+
         if (filters) {
             qb.where(new Brackets(whereQb => {
                 this.applyFilters(whereQb, filters, entityAlias, qb);
@@ -177,15 +188,6 @@ export class CrudHelperService {
             }));
         }
 
-        // Depending upon the populate option, apply the join clause
-        if (normalizedPopulate && normalizedPopulate.length) {
-            normalizedPopulate.forEach((relation) => {
-                // Check if the relation is already joined, if not then join it
-                const joinProperty = `${entityAlias}.${relation}`;
-                if (!this.isRelationJoined(qb, joinProperty)) qb.leftJoinAndSelect(joinProperty, relation);
-            });
-        }
-
         // Depending upon the order option, apply the order by clause
         if (normalizedSort && normalizedSort.length) {
             const orderOptions = this.orderOptions(normalizedSort);
@@ -214,9 +216,33 @@ export class CrudHelperService {
                 qb.addGroupBy(`${entityAlias}.${field}`);
             });
         }
-        // Apply the pagination options
-        if (limit) qb.limit(limit);
-        if (offset) qb.offset(offset);
+        
+        // Apply the pagination options & handle the case when the query has joins
+        if (limit) this.hasJoins(qb) ? qb.take(limit) : qb.limit(limit);
+        if (offset) this.hasJoins(qb) ? qb.skip(offset): qb.offset(offset);
+        return qb;
+    }
+
+    private buildPopulateQuery(normalizedPopulate: string[], entityAlias: string, qb: SelectQueryBuilder<any>) {
+        normalizedPopulate.forEach((relation) => {
+            this.buildJoinQueryForRelation(qb, entityAlias, relation);
+        });
+        return qb;
+    }
+
+    private buildJoinQueryForRelation(qb: SelectQueryBuilder<any>, entityAlias: string, relation: string) {
+        // We split the joinProperty to get the alias of the entity we are joining
+        const relationParts = relation.split('.');
+        let parentAlias = entityAlias;
+        relationParts.forEach((part, i) => {
+            const joinProperty = `${parentAlias}.${part}`;
+            // Check if the relation is already joined, if not then join it
+            if (!this.isRelationJoined(qb, joinProperty)) {
+                const joinAlias = relationParts.slice(0, i + 1).join('_');
+                qb.leftJoinAndSelect(joinProperty, joinAlias); 
+            }
+            parentAlias = part; // Update the parent alias for the next iteration
+        });
         return qb;
     }
 

package/src/services/crud.service.ts

@@ -99,20 +99,6 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
-    private async loadInverseRelationFields() {
-        const fieldMetadataRepo = this.entityManager.getRepository(FieldMetadata);
-        // Since the fields in the dto could be a result of being on a inverse side of a relation, we need to get the field configuration from the inverse side to process it
-        const inverseRelationFields = await fieldMetadataRepo.find({
-            where: {
-                type: 'relation',
-                relationCoModelSingularName: this.modelName,
-                relationCreateInverse: true,
-            },
-            relations: ['model'],
-        });
-        return inverseRelationFields;
-    }
-
     private async loadModel() {
         return await this.modelMetadataService.findOneBySingularName(this.modelName, {
             fields: {
@@ -414,28 +400,22 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         const alias = 'entity';
         // Extract the required keys from the input query
         let { limit, offset, populateMedia, populateGroup, groupFilter } = basicFilterDto;
-        const model = await this.loadModel();
+        const {singularName} = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
-            const hasPermission = this.crudHelperService.hasReadPermissionOnModel(solidRequestContext.activeUser, model.singularName);
+            const hasPermission = this.crudHelperService.hasReadPermissionOnModel(solidRequestContext.activeUser, singularName);
             if (!hasPermission) {
                 throw new BadRequestException('Forbidden');
             }
         }
 
-        // Exclude one-to-many and many-to-one relations from the initial filter query, since they will be queried separately
-        const relationsExcludedFromInitialQuery = this.relationsExcludedFromInitialQuery(model, basicFilterDto.populate);
-        basicFilterDto = this.getRevisedFilterDto(basicFilterDto, relationsExcludedFromInitialQuery);
-        
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
         qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
         
         if (basicFilterDto.groupBy) {
-            const relationsExcludedFromInitialQuery = this.relationsExcludedFromInitialQuery(model, groupFilter.populate);
-            groupFilter = this.getRevisedFilterDto(groupFilter, relationsExcludedFromInitialQuery);
             // Get the records and the count
-            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia, relationsExcludedFromInitialQuery);
+            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia);
             return {
                 groupMeta,
                 groupRecords,
@@ -443,7 +423,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
         else {
             // Get the records and the count
-            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit, alias, relationsExcludedFromInitialQuery);
+            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit, alias);
             return {
                 meta,
                 records,
@@ -451,28 +431,9 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
-    private getRevisedFilterDto(basicFilterDto: BasicFilterDto, relationsExcludedFromInitialQuery: string[]): BasicFilterDto {
-        const normalizedPopulate = this.crudHelperService.normalize(basicFilterDto.populate);
-        if (normalizedPopulate.length === 0 || relationsExcludedFromInitialQuery.length === 0) return basicFilterDto;
-        return  { ...basicFilterDto, populate: normalizedPopulate.filter(populate => !relationsExcludedFromInitialQuery.includes(populate)) };
-    }
-
-    private relationsExcludedFromInitialQuery(model: ModelMetadata, relationsToBePopulated: string[] = []): string[] {
-        const  relationToBeExcluded =
-         model.fields
-        .filter(field => field.type === 'relation' && [RelationType.manyTomany, RelationType.oneToMany].includes(field.relationType as RelationType))
-        .map(field => field.name);
-        return relationsToBePopulated.filter(relation => relationToBeExcluded.includes(relation));
-    }
-
-    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number, alias: string, relationsExcludedFromInitialQuery: string[]) {
+    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number, alias: string) {
         const [entities, count] = await qb.getManyAndCount();
 
-        // Populate the excluded relations for the entities
-        if (relationsExcludedFromInitialQuery.length > 0) {
-            await this.populateExcludedRelations(entities, relationsExcludedFromInitialQuery, alias);
-        }
-
         // Populate the entity with the media
         if (populateMedia && populateMedia.length > 0) {
             await this.handlePopulateMedia(populateMedia, entities);
@@ -481,36 +442,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return this.wrapFindResponse(offset, limit, count, entities);
     }
 
-    private async populateExcludedRelations(entities: T[], relationsExcludedFromInitialQuery: string[], alias: string) {
-        //@ts-ignore
-        const ids = entities.map(entity => entity.id);
-
-        // Fire a query to get the records from the relation entity which match the ids
-        // Create a map with key as the entity id and value as the qb records
-        const relationEntitiesMap = {};
-        for (const relation of relationsExcludedFromInitialQuery) {
-            const qb = this.repo.createQueryBuilder(`${alias}`)
-                .leftJoinAndSelect(`${alias}.${relation}`, relation)
-                .where(`${alias}.id IN (:...ids)`, { ids })
-                // .limit(DEFAULT_LIMIT)
-                // .offset(DEFAULT_OFFSET);
-            const relationEntities = await qb.getMany();
-            relationEntitiesMap[relation] = relationEntities;
-        }
-
-        // Iterate over the map and assign the relation entities to the entity
-        for (const relation of relationsExcludedFromInitialQuery) {
-            for (const entity of entities) {
-                const entityRelations = relationEntitiesMap[relation]
-                    //@ts-ignore
-                    .filter((joinedEntity: T) => joinedEntity.id === entity.id)
-                    .flatMap((joinedEntity: T) => joinedEntity[relation]);
-                entity[relation] = entityRelations;
-            }
-        }
-    }
-
-    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[], relationsExcludedFromInitialQuery: string[]) {
+    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[]) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -523,11 +455,6 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
                 const [entities, count] = await groupByQb.getManyAndCount();
 
-                // Populate the excluded relations for the entities
-                if (relationsExcludedFromInitialQuery.length > 0) {
-                    await this.populateExcludedRelations(entities, relationsExcludedFromInitialQuery, alias);
-                }
-
                 // Populate the entity with the media
                 if (populateMedia && populateMedia.length > 0) {
                     await this.handlePopulateMedia(populateMedia, entities);

package/src/services/field-metadata.service.ts

@@ -308,7 +308,7 @@ export class FieldMetadataService {
     //     return this.moduleMetadataRepo.save(country);
     // }
 
-    async remove(id: number) {
+    async delete(id: number) {
         const entity = await this.findOne(id);
         return this.fieldMetadataRepo.remove(entity);
     }
@@ -855,9 +855,7 @@ export class FieldMetadataService {
                     "encrypt",
                     "encryptionType",
                     "decryptWhen",
-                    "columnName",
-                    "isUserKey"
-
+                    "columnName"
                 ];
 
             case SolidFieldType.selectionDynamic:

package/src/services/media-storage-provider-metadata.service.ts

@@ -145,7 +145,7 @@ export class MediaStorageProviderMetadataService {
         return removedEntities
     }
 
-    async remove(id: number) {
+    async delete(id: number) {
         const lov = await this.findOne(id);
         return this.mediaStorageProviderRepo.remove(lov);
     }

package/src/services/model-metadata.service.ts

@@ -622,8 +622,8 @@ export class ModelMetadataService {
         dataSourceType: model.dataSourceType,
         tableName: model.tableName,
         userKeyFieldUserKey: model.fields.find(field => field.isUserKey)?.name,
-        isChild: model.isChild,
-        parentModelUserKey: model.parentModel.singularName,
+        isChild: model?.isChild,
+        parentModelUserKey: model?.parentModel?.singularName,
         fields: []
       }
 
@@ -897,7 +897,7 @@ export class ModelMetadataService {
     // Remove the fields from the database as well. This also checks, if the field is marked for removal
     fieldsForRemoval.forEach((field: FieldMetadata) => {
       if (field.isMarkedForRemoval) {
-        this.fieldMetadataService.remove(field.id);
+        this.fieldMetadataService.delete(field.id);
       }
     });
     return removeOutput;
@@ -909,7 +909,7 @@ export class ModelMetadataService {
     }
 
     const query = {
-      populate: ["module", "fields", "parentModel"]
+      populate: ["module", "fields", "parentModel", "parentModel.module"]
     };
     const model = options.modelId ? await this.findOne(options.modelId, query) : await this.findOneByUserKey(options.modelUserKey, query.populate);
 
@@ -932,7 +932,9 @@ export class ModelMetadataService {
         table: model.tableName,
         fields: fieldsForRefresh,
         modelEnableSoftDelete: model.enableSoftDelete,
-        parentModel: model.parentModel?.singularName
+        parentModel: model.parentModel?.singularName,
+        parentModule: model.parentModel?.module?.name,
+
       },
       dryRun
     );