@solidstarters/solid-core 1.2.95 → 1.2.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.95",
+  "version": "1.2.97",
   "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/dtos/create-saved-filters.dto.ts

@@ -1,12 +1,12 @@
 import { ApiProperty } from '@nestjs/swagger';
 import { IsString } from 'class-validator';
-import { IsOptional, IsNotEmpty, IsBoolean, IsInt } from 'class-validator';
+import { IsOptional, IsNotEmpty, IsBoolean, IsInt, IsJSON } from 'class-validator';
 
 export class CreateSavedFiltersDto {
     @IsOptional()
-    @IsString()
+    @IsJSON()
     @ApiProperty()
-    filterQueryJson: string;
+    filterQueryJson: any;
     @IsNotEmpty()
     @IsString()
     @ApiProperty()

package/src/dtos/update-saved-filters.dto.ts

@@ -1,4 +1,4 @@
-import { IsInt,IsOptional, IsString, IsNotEmpty, IsBoolean } from 'class-validator';
+import { IsInt,IsOptional, IsString, IsNotEmpty, IsBoolean, IsJSON } from 'class-validator';
 import { ApiProperty } from '@nestjs/swagger';
 
 export class UpdateSavedFiltersDto {
@@ -6,9 +6,9 @@ export class UpdateSavedFiltersDto {
     @IsInt()
     id: number;
     @IsOptional()
-    @IsString()
+    @IsJSON()
     @ApiProperty()
-    filterQueryJson: string;
+    filterQueryJson: any;
     @IsNotEmpty()
     @IsOptional()
     @IsString()

package/src/entities/saved-filters.entity.ts

@@ -7,7 +7,7 @@ import { ViewMetadata } from 'src/entities/view-metadata.entity'
 @Entity("ss_saved_fitlers")
 export class SavedFilters extends CommonEntity {
     @Column({ type: "text", nullable: true })
-    filterQueryJson: string;
+    filterQueryJson: any;
     @Column({ type: "varchar" })
     name: string;
     @Column({ type: "boolean", nullable: true, default: false })

package/src/helpers/solid-registry.ts

@@ -3,6 +3,7 @@ import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
 import { ISelectionProvider, ISelectionProviderContext } from "../interfaces";
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { EntityManager } from 'typeorm';
+import { Locale } from 'src/entities/locale.entity';
 
 type ControllerMetadata = {
   name: string;
@@ -33,6 +34,7 @@ export enum RESERVED_SOLID_KEYWORDS {
   userPasswordHistory = "userPasswordHistory",
   userMetadata = "userMetadata",
   user = "user",
+  locale = "locale"
 }
 
 @Injectable()
@@ -44,6 +46,7 @@ export class SolidRegistry {
   private controllers: Set<ControllerMetadata> = new Set();
   private modules: Set<InstanceWrapper> = new Set();
   private securityRules: SecurityRule[] = [];
+  private locales : Locale[] = [];
 
   registerController(name: string, methodNames: string[]): void {
     this.controllers.add({ name: name, methods: methodNames });
@@ -117,6 +120,15 @@ export class SolidRegistry {
     this.securityRules = securityRules;
   }
 
+  registerlocales(locales : Locale[]){
+    this.locales = locales;
+  }
+  
+  //TODO:getlocales from locale model and return default locale where isDefault:true 
+  getDefaultLocale(): Locale | null {
+    return this.locales.find(locale => locale.isDefault === true) || null;
+  }
+
   getSecurityRules(modelSingularName: string, roleNames: string[] = []): SecurityRule[] {
     // If no role is provided, return all security rules for the model
     if (roleNames.length === 0) {

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

@@ -2536,7 +2536,7 @@
           {
             "name": "filterQueryJson",
             "displayName": "Filter Query Json",
-            "type": "longText",
+            "type": "json",
             "ormType": "text",
             "required": false,
             "unique": false,
@@ -4886,13 +4886,6 @@
               "name": "view",
               "isSearchable": true
             }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "filterQueryJson",
-              "isSearchable": true
-            }
           }
         ]
       }

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

@@ -2,12 +2,14 @@ import { Brackets, SelectQueryBuilder, WhereExpressionBuilder } from "typeorm";
 import { BasicFilterDto } from "../dtos/basic-filters.dto";
 import { classify } from "@angular-devkit/core/src/utils/strings";
 import { ActiveUserData } from "src/interfaces/active-user-data.interface";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { Logger } from "@nestjs/common";
+
 
 export class CrudHelperService {
     constructor(
-
     ) { }
-
+    private readonly logger = new Logger(CrudHelperService.name);
 
     private orderOptions(sort: any[] = []) {
         const orderOptions = {};
@@ -53,7 +55,7 @@ export class CrudHelperService {
                 }
                 else { // Recursively call the applyFilters method to handle nested conditions
                     const joinField = `${alias}.${key}`;
-                        if (!this.isRelationJoined(selectQb, joinField)) selectQb.leftJoin(joinField, key);
+                    if (!this.isRelationJoined(selectQb, joinField)) selectQb.leftJoin(joinField, key);
                     this.applyFilters(qb, primaryFilterObj, key, selectQb);
                 }
             });
@@ -154,8 +156,8 @@ export class CrudHelperService {
     private hasJoins(queryBuilder: SelectQueryBuilder<any>): boolean {
         return queryBuilder.expressionMap.joinAttributes.length > 0;
     }
-
-    buildFilterQuery(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string, internationalisation?: boolean, draftPublishWorkflow?: boolean): SelectQueryBuilder<any> { // TODO : Check how to pass a type to SelectQueryBuilder instead of any
+ 
+    buildFilterQuery(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string, internationalisation?: boolean, draftPublishWorkflow?: boolean,moduleRef?:any): 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 = [], populateMedia = [], locale, status } = basicFilterDto;
 
@@ -190,10 +192,14 @@ export class CrudHelperService {
         if (internationalisation) {
             // If locale is not provided in the filter dto, then assume it is the default locale to be used. 
             if (!finalLocale) {
-                // TODO: get the default locale from the database.
-                // This should be replaced with the actual default locale from the database, make sure to cache this request.
-                // @Sundaram consult with Oswald and use a registry based approach to fetch the default locale, making sure that it gets cached and we don't have to query again and again.
-                finalLocale = 'en';
+                //Get default locale from registry
+                const solidRegistry = moduleRef.get(SolidRegistry, { strict: false });
+                const defaultLocale = solidRegistry.getDefaultLocale();
+                if(defaultLocale){
+                    finalLocale = defaultLocale.locale;
+                }else{
+                    finalLocale = 'en';
+                }
             }
             qb.andWhere(`${entityAlias}.localeName = :locale`, { locale: finalLocale });
         }
@@ -280,7 +286,7 @@ export class CrudHelperService {
             else {
                 // Since in populate, we are create a unique alias based on the relation path
                 //If the join is already present, it is probably because of the relation being passed in the where filter i.e applyFilters method
-                qb.addSelect(`${part}`); 
+                qb.addSelect(`${part}`);
             }
             parentAlias = part; // Update the parent alias for the next iteration
         });
@@ -350,6 +356,31 @@ export class CrudHelperService {
         };
     }
 
+    async countGroupedRecords(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string) { //TODO : Check how to pass a type to SelectQueryBuilder instead of any
+        const { limit, offset, ...rest } = basicFilterDto;
+
+        const filteredDto = { ...rest, limit: undefined, offset: undefined };
+
+        const filteredQB = this.buildFilterQuery(qb, filteredDto as BasicFilterDto, entityAlias);
+
+        // Select only the group field and count distinct rows
+        const groupByField = filteredDto.groupBy;
+
+        if (!groupByField || (Array.isArray(groupByField) && groupByField.length !== 1)) {
+            throw new Error('Exactly one groupBy field is required to count grouped records.');
+        }
+
+         const field = Array.isArray(groupByField) ? groupByField[0] : groupByField;
+          const rawResults = await filteredQB
+        .select([]) // Remove prior select fields
+        .addSelect(`${entityAlias}.${field}`, 'groupField')
+        .groupBy(`${entityAlias}.${field}`)
+        .limit(undefined) // Important: prevent LIMIT 1 from propagating
+        .offset(undefined)
+        .getRawMany();
+
+        return rawResults.length;
+    }
 
     hasReadPermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
         const permissionNames = [`${classify(modelName)}Controller.findOne`, `${classify(modelName)}Controller.findMany`];

package/src/services/crud.service.ts

@@ -425,12 +425,21 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
-        qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow);
+        qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+        if(internationalisation && draftPublishWorkflow){
+            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias,internationalisation, draftPublishWorkflow,this.moduleRef);
+        }
 
         if (basicFilterDto.groupBy) {
             // Get the records and the count
-            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia, internationalisation, draftPublishWorkflow);
+            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia);
+            const totalGroups = await this.crudHelperService.countGroupedRecords(qb, basicFilterDto, alias);
+            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+
             return {
+                meta: {
+                    "totalRecords": totalGroups
+                },
                 groupMeta,
                 groupRecords,
             }
@@ -456,7 +465,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return this.wrapFindResponse(offset, limit, count, entities);
     }
 
-    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[], internationalisation: boolean, draftPublishWorkflow: boolean) {
+    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[]) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -465,7 +474,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         for (const group of groupByResult) {
             if (populateGroup) {
                 let groupByQb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias);
-                groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilter, alias, internationalisation, draftPublishWorkflow);
+                groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilter, alias);
                 groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
                 const [entities, count] = await groupByQb.getManyAndCount();
 

package/src/services/locale.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef  } from "@nestjs/core";
 import { EntityManager, Repository } from 'typeorm';
@@ -12,8 +12,9 @@ import { CrudHelperService } from 'src/services/crud-helper.service';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { RequestContextService } from './request-context.service';
 import { Locale } from 'src/entities/locale.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
 @Injectable()
-export class LocaleService extends CRUDService<Locale>{
+export class LocaleService extends CRUDService<Locale> implements OnApplicationBootstrap{
   constructor(
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
@@ -29,9 +30,19 @@ export class LocaleService extends CRUDService<Locale>{
     readonly moduleRef: ModuleRef,
     @InjectRepository(ModelMetadata)
     private readonly modelMetadataRepo: Repository<ModelMetadata>,
-    readonly requestContextService: RequestContextService
+    readonly requestContextService: RequestContextService,
+    readonly solidRegistry: SolidRegistry,
  ) {
    super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'locale', 'solid-core', moduleRef);
  }
-
+  private readonly logger = new Logger(LocaleService.name)
+  onApplicationBootstrap() {
+    // Load the security rules from the database
+    this.loadLocales();
+  }
+   async loadLocales() {
+    const locales = await this.repo.find();
+    this.logger.debug(`Loaded ${locales.length} locales into registry`);
+    this.solidRegistry.registerlocales(locales);
+  }
 }

package/src/transformers/datetime-transformer.ts

@@ -1,8 +1,8 @@
+import { Logger } from '@nestjs/common';
 import { TransformFnParams } from 'class-transformer';
-
+const logger = new Logger('datetimeTransformer');
 const datetimeTransformer = ({ value }: TransformFnParams): Date | null => {
-    console.log("date time transformer debug", value);
-
+    logger.debug("date time transformer debug", value);
     if (value === '' || value === undefined || value === null) return null;
 
     const parsed = new Date(value);