@solidstarters/solid-core 1.2.36 → 1.2.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.36",
+  "version": "1.2.38",
   "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/seeders/module-metadata-seeder.service.ts

@@ -205,7 +205,8 @@ export class ModuleMetadataSeederService {
         this.logger.debug(`About to add all permissions to the Admin role`);
         await this.roleService.addAllPermissionsToRole("Admin");
         // 2. Give wrapSettings permissions to the Public role.
-        const internalRolePermission = ['UserController.findMany',
+        const internalRolePermission = [
+            'UserController.findMany',
             'UserController.checkIfPermissionExists',
             'UserController.findOne',
             'MenuItemMetadataController.findMany',
@@ -214,7 +215,10 @@ export class ModuleMetadataSeederService {
             'ViewMetadataController.getLayout',
             'ViewMetadataController.findMany',
             'ViewMetadataController.findOne',
-            'AuthenticationController.changePassword'
+            'AuthenticationController.changePassword',
+            'FieldMetadataController.getSelectionDynamicValues',
+            'FieldMetadataController.getSelectionDynamicValue',
+            'FieldMetadataController.findFieldDefaultMetaData',
         ]
         await this.roleService.addPermissionToRole('Internal User', internalRolePermission);
         await this.roleService.addPermissionToRole('Public', ['SettingController.wrapSettings']);

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

@@ -141,7 +141,7 @@ export class CrudHelperService {
         }, {});
     }
 
-    private normalize(value: string | string[]): string[] {
+    normalize(value: string | string[]): string[] {
         if (!value) return [];// if the value is nullish, then return an empty array
         return Array.isArray(value) ? value : [value];        // if the value is an array, return it as is, otherwise return it as an array
     }

package/src/services/crud.service.ts

@@ -40,7 +40,7 @@ import { SolidRequestContextDto } from "src/dtos/solid-request-context.dto";
 
 const DEFAULT_LIMIT = 10;
 const DEFAULT_OFFSET = 0;
-export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
+export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
     constructor(
         readonly modelMetadataService: ModelMetadataService,
@@ -414,7 +414,6 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
     }
 
-
     async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
         const alias = 'entity';
         // Extract the required keys from the input query
@@ -428,13 +427,19 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
             }
         }
 
+        // 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);
+            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia, relationsExcludedFromInitialQuery);
             return {
                 groupMeta,
                 groupRecords,
@@ -442,7 +447,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
         else {
             // Get the records and the count
-            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit);
+            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit, alias, relationsExcludedFromInitialQuery);
             return {
                 meta,
                 records,
@@ -450,9 +455,28 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
     }
 
-    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number) {
+    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[]) {
         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);
@@ -461,7 +485,36 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         return this.wrapFindResponse(offset, limit, count, entities);
     }
 
-    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[]) {
+    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[]) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -470,15 +523,14 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         for (const group of groupByResult) {
             if (populateGroup) {
                 let groupByQb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias);
-                // For the group by records, apply the basic filter
-                // const basicFilterDto = {
-                //     limit: DEFAULT_LIMIT,
-                //     offset: DEFAULT_OFFSET,
-                // };
                 groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilter, alias);
                 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) {

package/src/services/solid-introspect.service.ts

@@ -1,3 +1,4 @@
+import { classify } from '@angular-devkit/core/src/utils/strings';
 import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
@@ -5,6 +6,7 @@ import { IS_COMPUTED_FIELD_PROVIDER } from 'src/decorators/computed-field-provid
 import { IS_SELECTION_PROVIDER } from 'src/decorators/selection-provider.decorator';
 import { IS_SOLID_DATABASE_MODULE } from 'src/decorators/solid-database-module.decorator';
 import { SolidRegistry } from 'src/helpers/solid-registry';
+import { CRUDService } from './crud.service';
 
 @Injectable()
 export class SolidIntrospectService implements OnApplicationBootstrap {
@@ -16,9 +18,9 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
   ) { }
 
   private readonly logger = new Logger(SolidIntrospectService.name);
-  onApplicationBootstrap() {  
+  onApplicationBootstrap() {
     this.logger.log('Introspecting the application for Solid metadata');
-    
+
     // Register all seeders
     const seeders = this.discoveryService
       .getProviders()
@@ -55,7 +57,7 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
       .getProviders()
       .filter((provider) => this.isSolidDatabaseModule(provider));
 
-      solidDatabaseModules.forEach((solidDatabaseModule) => {
+    solidDatabaseModules.forEach((solidDatabaseModule) => {
       // @ts-ignore
       this.solidRegistry.registerSolidDatabaseModule(solidDatabaseModule);
     });
@@ -128,14 +130,13 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     return !!isSolidDatabaseModule;
   }
 
-
   private isModule(provider: InstanceWrapper): boolean {
     const metatype = provider.metatype;
     // Check if it's a Static Module (Class-Based)
     if (metatype && typeof metatype === 'function' && Reflect.getMetadata('imports', metatype)) {
       return true;
     }
-  
+
     // Ensure provider.instance is an object before checking for 'module'
     if (provider.instance && typeof provider.instance === 'object') {
       // Check if it's a Dynamic Module (Object-Based)
@@ -143,8 +144,21 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
         return true;
       }
     }
-  
+
     return false;
   }
 
+  /**
+   * Given a model singular name this will return the crud service instance.
+   * @param modelSingularName 
+   * @returns 
+   */
+  getCRUDService(modelSingularName: string): CRUDService<any> {
+    const provider = this.getProvider(`${classify(modelSingularName)}Service`);
+    return provider?.instance as CRUDService<any>;
+  }
+
+  getProvider(providerName: string) {
+    return this.discoveryService.getProviders().find((provider) => provider.name === providerName);
+  }
 }

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService } from "@nestjs/core";
 import { EntityManager, Repository } from 'typeorm';
@@ -17,6 +17,8 @@ import { FieldMetadata } from '../entities/field-metadata.entity';
 import { ModelMetadata } from '../entities/model-metadata.entity';
 import { UpdateViewMetadataDto } from '../dtos/update-view-metadata.dto';
 import { ActionMetadataService } from './action-metadata.service';
+import { SolidIntrospectService } from './solid-introspect.service';
+import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
@@ -30,6 +32,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     readonly discoveryService: DiscoveryService,
     readonly crudHelperService: CrudHelperService,
     readonly actionMetadataService: ActionMetadataService,
+    readonly introspectService: SolidIntrospectService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     @InjectRepository(ViewMetadata, 'default')
@@ -58,21 +61,33 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       relations: {
         model: {
           userKeyField: true,  // Nested population of 'someOtherEntity' within 'model'
-        },    
+        },
         module: true,
       }
     });
-    if (entity) {
-      entity.layout = JSON.parse(entity.layout);
-      if (entity?.layout?.attrs?.createAction) {
-        const actionName: string = entity.layout.attrs.createAction;
-        entity.layout.attrs.createAction = await this.actionMetadataService.findOneByUserKey(actionName)
-      }
-      if (entity?.layout?.attrs?.editAction) {
-        const actionName: string = entity.layout.attrs.editAction;
-        entity.layout.attrs.editAction = await this.actionMetadataService.findOneByUserKey(actionName)
-      }
+
+    if (!entity) {
+      throw new BadRequestException(`Unable to identify view for module: ${moduleName}, model: ${modelName} and viewType: ${viewType}`);
+    }
+
+    // If view entity found then convert layout from "string" to "json".
+    entity.layout = JSON.parse(entity.layout);
+    if (entity?.layout?.attrs?.createAction) {
+      const actionName: string = entity.layout.attrs.createAction;
+      entity.layout.attrs.createAction = await this.actionMetadataService.findOneByUserKey(actionName)
+    }
+    if (entity?.layout?.attrs?.editAction) {
+      const actionName: string = entity.layout.attrs.editAction;
+      entity.layout.attrs.editAction = await this.actionMetadataService.findOneByUserKey(actionName)
     }
+
+    // for form views, we need to check if "workflow" field is configured, if configured then return an extra metadata "solidFormViewWorkflowData"
+    let workflowFieldName = null;
+    let workflowField = null;
+    if (viewType === 'form') {
+      workflowFieldName = entity.layout?.attrs?.workflowField;
+    }
+
     // We also need to fetch a map of fields.
     const fields = await this.fieldMetadataRepo.find({
       where: {
@@ -85,6 +100,11 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     for (let i = 0; i < fields.length; i++) {
       const field = fields[i];
 
+      // We need to identify the workflowField metadata if specified. 
+      if (workflowFieldName && field.name === workflowFieldName) {
+        workflowField = field;
+      }
+
       // For fields of type relation & relationType many-to-one
       // We fetch metadata regarding the relationCoModelSingularName
       if (field.type === 'relation') {
@@ -106,10 +126,38 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       }
     }
 
-    return {
+    // Check if we were able to resolve an actual workflowField.
+    let solidFormViewWorkflowData = [];
+    if (viewType === 'form' && workflowField) {
+      // check for type of workflow field. 
+      // for workflowFields of type selectionStatic we simply return the key/values from field metadata AS-IS
+      if (workflowField.type === 'selectionStatic') {
+        solidFormViewWorkflowData = workflowField.selectionStaticValues.map(item => {
+          const [label, value] = item.split(":");
+          return { label, value };
+        });
+      }
+      // for workflowFields of type relation.many-to-one we need to query the co-model, and return data in key/value format.
+      if (workflowField.type === 'relation' && workflowField.relationType === 'many-to-one') {
+        const comodelCrudService = this.introspectService.getCRUDService(workflowField.relationCoModelSingularName);
+        const data = await comodelCrudService.find({ limit: 100, offset: 0, });
+        const records = data.records ?? [];
+        const workflowFieldMetadata = fieldsMap.get(workflowFieldName);
+        const workflowFielUserkey = workflowFieldMetadata['relationModel']['userKeyField']['name'];
+
+        // iterate over the comodel records extracting the label & value. 
+        solidFormViewWorkflowData = records.map(item => ({ 'label': item[workflowFielUserkey], 'value': item['id'] }))
+      }
+
+    }
+
+    const r = {
       'solidView': entity,
       'solidFieldsMetadata': Object.fromEntries(fieldsMap),
-    };
+      'solidFormViewWorkflowData': solidFormViewWorkflowData
+    }
+
+    return r;
   }
 
   async findOneByUserKey(name: string, relations = {}) {
@@ -137,6 +185,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       return this.repo.save(viewData);
     }
   }
+
   async createIfNotPresent(updateSolidViewDto: UpdateViewMetadataDto) {
     // First check if module already exists using name
     const existingSolidView = await this.findOneByUserKey(updateSolidViewDto.name);