@solidstarters/solid-core 1.2.93 → 1.2.96

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

@@ -53,7 +53,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);
                 }
             });
@@ -155,10 +155,9 @@ export class CrudHelperService {
         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
+    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
         let { limit, offset, showSoftDeleted, filters } = basicFilterDto;
-        const { fields, sort, groupBy, populate = [], populateMedia=[] } = basicFilterDto;
+        const { fields, sort, groupBy, populate = [], populateMedia = [], locale, status } = basicFilterDto;
 
         // Normalize the fields, sort, groupBy and populate options i.e (since they can be either a string or an array of strings, when coming from the request)
         const normalizedFields = this.normalize(fields);
@@ -187,6 +186,25 @@ export class CrudHelperService {
             }));
         }
 
+        let finalLocale = locale
+        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';
+            }
+            qb.andWhere(`${entityAlias}.localeName = :locale`, { locale: finalLocale });
+        }
+
+        if (draftPublishWorkflow && status) {
+            if (basicFilterDto.status === 'published') {
+                qb.andWhere(`${entityAlias}.publishedAt IS NOT NULL`);
+            } else if (basicFilterDto.status === 'draft') {
+                qb.andWhere(`${entityAlias}.publishedAt IS NULL`);
+            }
+        }
         // Depending upon the select option, apply the select clause
         if (normalizedFields && normalizedFields.length) {
             qb.select(normalizedFields.map(field => {
@@ -223,22 +241,22 @@ export class CrudHelperService {
                 qb.addGroupBy(`${entityAlias}.${field}`);
             });
         }
-        
+
         // 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);
+        if (offset) this.hasJoins(qb) ? qb.skip(offset) : qb.offset(offset);
         return qb;
     }
 
     additionalRelationsRequiredForMediaPopulation(normalizedPopulateMedia: string[]) {
         // Populate relations containing the media field
         return normalizedPopulateMedia
-        .filter(pm => pm.includes("."))
-        .map((pm) => {
-            const mediaPathParts = pm.split('.');
-            if (mediaPathParts.length <= 1) return pm;
-            return  mediaPathParts.slice(0, -1).join('.');
-        });
+            .filter(pm => pm.includes("."))
+            .map((pm) => {
+                const mediaPathParts = pm.split('.');
+                if (mediaPathParts.length <= 1) return pm;
+                return mediaPathParts.slice(0, -1).join('.');
+            });
     }
 
     private buildPopulateQuery(normalizedPopulate: string[], entityAlias: string, qb: SelectQueryBuilder<any>) {
@@ -257,12 +275,12 @@ export class CrudHelperService {
             // 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); 
+                qb.leftJoinAndSelect(joinProperty, joinAlias);
             }
             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
         });
@@ -332,6 +350,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

@@ -52,7 +52,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         //We can just have the Model Entity here
     ) { }
 
-    async create(createDto: any, files: Express.Multer.File[] = [],solidRequestContext :any = {}): Promise<T> {
+    async create(createDto: any, files: Express.Multer.File[] = [], solidRequestContext: any = {}): Promise<T> {
         // This class will be extended by the generated service class i.e PersonService
         // The data required to identify the model and module name will be passed from the generate CrudService subclass
         //TODO: Algorithm to create the entity
@@ -215,7 +215,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 throw new BadRequestException('Forbidden');
             }
         }
-        
+
         const model = await this.modelMetadataService.findOneBySingularName(this.modelName, {
             fields: {
                 model: true,
@@ -232,10 +232,26 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         if (!entity) {
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
+
+        // If the model has internationalisation enabled, delete children with defaultEntityLocaleId === this entity's id
+        if (model.internationalisation) {
+            // Find all child entities where defaultEntityLocaleId === this entity's id
+            const childEntities = await this.repo.find({
+                where: { defaultEntityLocaleId: id } as any
+            });
+
+            if (childEntities.length > 0) {
+                if (model.enableSoftDelete === true) {
+                    await this.repo.softRemove(childEntities);
+                } else {
+                    await this.repo.remove(childEntities);
+                }
+            }
+        }
+
         if (model.enableSoftDelete === true) {
             await this.repo.softRemove(entity);
             return this.repo.save(entity);
-
         } else {
             return this.repo.remove(entity);
         }
@@ -365,7 +381,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 //     Validation against the selectionStatic values. No transformation is required
                 //     If the value is not in the selectionStatic values, then throw
                 //     Also validate against the selectionType
-                const options = { ...commonOptions, selectionStaticValues: fieldMetadata.selectionStaticValues, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, isMultiSelect: fieldMetadata.isMultiSelect};
+                const options = { ...commonOptions, selectionStaticValues: fieldMetadata.selectionStaticValues, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, isMultiSelect: fieldMetadata.isMultiSelect };
                 return new SelectionStaticFieldCrudManager(options);
             }
             case SolidFieldType.selectionDynamic: {// [HOLD]
@@ -374,7 +390,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 //     dataSource: string; // The name of the selection provider
                 //     filterSchema : json // This is a custom json object that every data source will handle accordingly. We could validate the query against the selection provider
                 //     values : string[]; // The values returned by the selection provider
-                const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: fieldMetadata.selectionDynamicProviderCtxt, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService, isMultiSelect: fieldMetadata.isMultiSelect};
+                const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: fieldMetadata.selectionDynamicProviderCtxt, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService, isMultiSelect: fieldMetadata.isMultiSelect };
                 return new SelectionDynamicFieldCrudManager(options);
             }
             case SolidFieldType.uuid: {
@@ -398,7 +414,7 @@ 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 {singularName} = await this.loadModel();
+        const { singularName, internationalisation, draftPublishWorkflow } = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasReadPermissionOnModel(solidRequestContext.activeUser, singularName);
@@ -410,11 +426,18 @@ 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);
-        
+
+
         if (basicFilterDto.groupBy) {
             // 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, internationalisation, draftPublishWorkflow);
+            const totalGroups = await this.crudHelperService.countGroupedRecords(qb, basicFilterDto, alias);
+            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow);
+
             return {
+                meta: {
+                    "totalRecords": totalGroups
+                },
                 groupMeta,
                 groupRecords,
             }
@@ -440,7 +463,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[]) {
+    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[], internationalisation: boolean, draftPublishWorkflow: boolean) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -449,7 +472,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);
+                groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilter, alias, internationalisation, draftPublishWorkflow);
                 groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
                 const [entities, count] = await groupByQb.getManyAndCount();
 
@@ -486,12 +509,12 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return r;
     }
 
-   private async handlePopulateMedia(populateMedia: string[], entities: T[]) {
+    private async handlePopulateMedia(populateMedia: string[], entities: T[]) {
         const model = await this.entityManager.getRepository(ModelMetadata).findOne({
             where: {
                 singularName: this.modelName,
             },
-            relations: ['fields', 'fields.mediaStorageProvider', 'fields.model','module'],
+            relations: ['fields', 'fields.mediaStorageProvider', 'fields.model', 'module'],
         });
 
         // Will iterate through every entity &  all populateMedia & call getMediaDetails for each field
@@ -501,7 +524,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             }
         }
         return entities;
-   } 
+    }
 
     // Adds the media with full URL to the entity / nested entity
     private async populateMediaObject(mediaFieldPath: string, model: ModelMetadata, entity: T) {
@@ -515,12 +538,12 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             // We can assume that the media field entity model is already populated as part of the entity data
             const mediaFieldEntities = this.getMediaFieldEntities(entity, pathParts);
             if (!mediaFieldEntities || mediaFieldEntities.length === 0) {
-               return ;//no need to populate data if relation not exists
+                return;//no need to populate data if relation not exists
             }
             // Populate the media field entities with the full URL
             for (const mediaFieldEntity of mediaFieldEntities) {
                 const mediaWithFullUrl = await this.getMediaWithFullUrl(mediaFieldEntity, mediaFieldMetadata);
-                this.appendMediaKey(mediaWithFullUrl, mediaFieldEntity,  mediaFieldMetadata.name);
+                this.appendMediaKey(mediaWithFullUrl, mediaFieldEntity, mediaFieldMetadata.name);
                 // mediaFieldEntity['_media'][mediaFieldPath] = mediaWithFullUrl
             }
         }
@@ -546,7 +569,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             entity['_media'] = {
                 [mediaFieldPath]: mediaWithFullUrl
             };
-        } 
+        }
     }
 
     private getMediaFieldEntities(entity: T, mediaPathParts: string[]): T[] {
@@ -562,12 +585,12 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return isArray(entityPart) ? entityPart : [entityPart];
     }
 
-    async getMediaWithFullUrl(mediaEntity: any, mediaFieldMetadata: FieldMetadata): Promise<MediaWithFullUrl[]>{
-            const storageProviderMetadata = mediaFieldMetadata.mediaStorageProvider;
-            const storageProviderType = storageProviderMetadata.type as MediaStorageProviderType;
-            const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
-            const mediaDetails = await storageProvider.retrieve(mediaEntity, mediaFieldMetadata);
-            return mediaDetails as MediaWithFullUrl[];
+    async getMediaWithFullUrl(mediaEntity: any, mediaFieldMetadata: FieldMetadata): Promise<MediaWithFullUrl[]> {
+        const storageProviderMetadata = mediaFieldMetadata.mediaStorageProvider;
+        const storageProviderType = storageProviderMetadata.type as MediaStorageProviderType;
+        const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
+        const mediaDetails = await storageProvider.retrieve(mediaEntity, mediaFieldMetadata);
+        return mediaDetails as MediaWithFullUrl[];
     }
 
     async findOne(id: number, query: any, solidRequestContext: any = {}) {
@@ -610,7 +633,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return entity;
     }
 
-    async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = [],solidRequestContext: any = {}): Promise<T[]> {
+    async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = [], solidRequestContext: any = {}): Promise<T[]> {
 
 
         // if (createDtos.length !== filesArray.length) {
@@ -669,7 +692,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return savedEntities;
     }
 
-    async deleteMany(ids: number[],solidRequestContext: any = {}): Promise<any> {
+    async deleteMany(ids: number[], solidRequestContext: any = {}): Promise<any> {
 
         if (!ids || ids.length === 0) {
             throw new Error('At least one ID is required for deletion');
@@ -713,7 +736,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // return removedEntities
     }
 
-    async recover(id: number,solidRequestContext: any = {}) {
+    async recover(id: number, solidRequestContext: any = {}) {
         try {
             const loadedmodel = await this.loadModel();
             // Check wheather user has update permission for model
@@ -753,7 +776,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
-    async recoverMany(ids: number[],solidRequestContext: any = {}) {
+    async recoverMany(ids: number[], solidRequestContext: any = {}) {
         try {
             const loadedmodel = await this.loadModel();
             // Check wheather user has update permission for model
@@ -808,32 +831,32 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         if (!pathParts || pathParts.length === 0) {
             throw new BadRequestException('Path parts cannot be empty');
         }
-    
+
         const [currentPart, ...remainingParts] = pathParts;
         const field = fields.find(field => field.name === currentPart);
-    
+
         if (!field) {
             throw new BadRequestException(`Field ${currentPart} not found in model ${this.modelName}`);
         }
-    
+
         // Base case: last part, return the field
         if (remainingParts.length === 0) {
             return field;
         }
-    
+
         if (!field.relationCoModelSingularName) {
             throw new BadRequestException(`Field ${field.name} does not define a relationCoModelSingularName`);
         }
-    
+
         const relationCoModel = await this.entityManager.getRepository(ModelMetadata).findOne({
             where: { singularName: field.relationCoModelSingularName },
             relations: ['fields', 'fields.mediaStorageProvider', 'fields.model'],
         });
-    
+
         if (!relationCoModel) {
             throw new BadRequestException(`Model ${field.relationCoModelSingularName} not found`);
         }
-    
+
         return this.getFieldMetadataRecursively(remainingParts, relationCoModel.fields);
     }
 }

package/src/services/locale.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef  } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from 'src/services/file.service';
+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';
+@Injectable()
+export class LocaleService extends CRUDService<Locale>{
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(Locale, 'default')
+    readonly repo: Repository<Locale>,
+    @InjectRepository(Locale, 'default')
+    readonly moduleRef: ModuleRef,
+    @InjectRepository(ModelMetadata)
+    private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    readonly requestContextService: RequestContextService
+ ) {
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'locale', 'solid-core', moduleRef);
+ }
+
+}

package/src/services/mediaStorageProviders/file-storage-provider.ts

@@ -45,7 +45,7 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
             await this.fileService.deleteFile(file.path);
 
             // Create an entry in the media table
-            const mediaEntity = await this.mediaRepository.createMedia({
+        const mediaEntity = await this.mediaRepository.createMedia({
                 entityId: entity.id,
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: this.getFileName(file),

package/src/services/selection-providers/locale-list-selection-provider.service.ts

@@ -0,0 +1,58 @@
+import { Injectable } from "@nestjs/common";
+import { ModelMetadataService } from "src/services/model-metadata.service";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
+// import localeCodes from 'locale-codes';
+import * as locale from 'locale-codes'
+
+
+@SelectionProvider()
+@Injectable()
+export class LocaleListSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
+
+    constructor() {
+    }
+
+    help(): string {
+        return "# Gets all locales available to the user";
+    }
+
+    name(): string {
+        return 'LocaleListSelectionProvider';
+    }
+
+    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
+        const locales = locale.all
+            .filter(code => code.tag === optionValue)
+            .map(code => ({ label: `${code.name} (${code.tag})`, value: code.tag }));
+
+        return locales.length > 0 ? locales[0] : null;
+    }
+
+    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+
+        const locales = locale.all
+            .filter(code => {
+                // Look at the documentation here - https://www.npmjs.com/package/locale-codes
+                // In this if you check the section - https://www.npmjs.com/package/locale-codes#locale-list
+
+                // We disabled this because this was not returning the basic locale codes like 'en', 'fr', etc.
+                // We are only interested in the locales that have a tag with a hyphen (-) in it.
+                // if (code.tag.includes('-')) {
+                if (query) {
+                    const lowerCaseQuery = query.toLowerCase();
+                    return code.name.toLowerCase().includes(lowerCaseQuery) || code.tag.toLowerCase().includes(lowerCaseQuery);
+                }
+                return true;
+                // }
+                return false;
+            })
+            .map(code => ({
+                label: `${code.name} (${code.tag})`,
+                value: code.tag,
+            }));
+
+        return locales;
+
+    }
+}