@solidstarters/solid-core 1.2.192 → 1.2.200

package/src/seeders/system-fields-seeder.service.ts

@@ -9,46 +9,45 @@ import { ModelMetadataRepository } from "src/repository/model-metadata.repositor
 
 @Injectable()
 export class SystemFieldsSeederService {
-   // This service is responsible for seeding the system fields metadata for all models.
-   // It will check if the system fields are already present in the field-metadata table.
-   // If not, it will add them.
-   constructor(
-      private readonly modelHelperService: ModelMetadataHelperService,
+  // This service is responsible for seeding the system fields metadata for all models.
+  // It will check if the system fields are already present in the field-metadata table.
+  // If not, it will add them.
+  constructor(
+    private readonly modelHelperService: ModelMetadataHelperService,
     //   @InjectRepository(ModelMetadata)
     //   private readonly modelRepository: Repository<ModelMetadata>, // Replace with actual model repository type
-      private readonly modelRepository: ModelMetadataRepository, // Replace with actual model repository type
-      private readonly fieldMetadataRepository: FieldMetadataRepository, // Replace with actual field repository type
-   ) {}
-  
-   async seed() {
-     // Get the model repo
-     const models = await this.modelRepository.find({
-       relations: ['fields'], // Assuming 'fields' is the relation to field metadata
-     });
+    private readonly modelRepository: ModelMetadataRepository, // Replace with actual model repository type
+    private readonly fieldMetadataRepository: FieldMetadataRepository, // Replace with actual field repository type
+  ) { }
 
-     for (const model of models) {
-         // Check if the system fields are already present
-         await this.seedMissingSystemFields(model);
-      }
-   }
+  async seed() {
+    // Get the model repo
+    const models = await this.modelRepository.find({
+      relations: ['fields'], // Assuming 'fields' is the relation to field metadata
+    });
 
-    private async seedMissingSystemFields(model: ModelMetadata) {
-        const existingSystemFields = model.fields.filter(field => field.isSystem);
-        const systemFieldsMetadata = this.modelHelperService.getSystemFieldsMetadata();
+    for (const model of models) {
+      // Check if the system fields are already present
+      await this.seedMissingSystemFields(model);
+    }
+  }
+
+  private async seedMissingSystemFields(model: ModelMetadata) {
+    const existingSystemFields = model.fields.filter(field => field.isSystem);
+    const systemFieldsMetadata = this.modelHelperService.getSystemFieldsMetadata(model.isLegacyTable, model.isLegacyTableWithId);
 
-        // Find out which system fields are missing
-        const missingFields = systemFieldsMetadata.filter(
-            sysField => !existingSystemFields.some(field => field.name === sysField.name)
-        );
+    // Find out which system fields are missing
+    const missingFields = systemFieldsMetadata.filter(
+      sysField => !existingSystemFields.some(field => field.name === sysField.name)
+    );
 
-        // If there are missing fields, add them
-        if (missingFields.length > 0) {
-            const newFields = missingFields.map(field => ({
-                ...field,
-                model: model, // Associate the field with the current model
-            }));
-            await this.fieldMetadataRepository.save(newFields);
-        }
+    // If there are missing fields, add them
+    if (missingFields.length > 0) {
+      const newFields = missingFields.map(field => ({
+        ...field,
+        model: model, // Associate the field with the current model
+      }));
+      await this.fieldMetadataRepository.save(newFields);
     }
+  }
 }
-   

package/src/services/ai-interaction.service.ts

@@ -219,7 +219,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
       throw new Error(`Invalid metadata JSON: ${e}`);
     }
 
-    const toolsInvoked = metadata['toolsInvoked'];
+    const toolsInvoked = metadata['tools_invoked'];
     if (!toolsInvoked) {
       // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
       throw new Error(ERROR_MESSAGES.UNABLE_TO_RESOLVE_SOLID_COMMAND);

package/src/services/computed-fields/entity/alpha-num-external-id-computed-field-provider.ts

@@ -14,8 +14,7 @@ export interface AlphaNumExternalIdContext {
 
 @ComputedFieldProvider()
 @Injectable()
-export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, AlphaNumExternalIdContext>
-{
+export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, AlphaNumExternalIdContext> {
   constructor(
     @InjectEntityManager()
     private readonly entityManager: EntityManager
@@ -29,8 +28,8 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return 'Provider used to compute external ID for a CommonEntity with support for static or dynamic prefix.';
   }
 
-  async preComputeValue( triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>
- ) {
+  async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>
+  ) {
     const { prefix, length, dynamicFieldPrefix } =
       computedFieldMetadata.computedFieldValueProviderCtxt;
 
@@ -46,8 +45,10 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
       }
     }
 
-    const uniqueCode = await this.generateUniqueExternalId( codeLength, triggerEntity, computedFieldMetadata.fieldName );
-    triggerEntity[computedFieldMetadata.fieldName] = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
+    const uniqueCode = await this.generateUniqueExternalId(resolvedPrefix, codeLength, triggerEntity, computedFieldMetadata.fieldName);
+    const finalExternalId = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
+
+    triggerEntity[computedFieldMetadata.fieldName] = finalExternalId;
   }
 
   private generateRandomCode(length = 5): string {
@@ -59,7 +60,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return result;
   }
 
-  private async isExternalIdUnique( externalId: string, triggerEntity: T, fieldName: string ): Promise<boolean> {
+  private async isExternalIdUnique(externalId: string, triggerEntity: T, fieldName: string): Promise<boolean> {
     const count = await this.entityManager.count(triggerEntity.constructor as any,
       {
         where: { [fieldName]: externalId },
@@ -68,13 +69,16 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return count === 0;
   }
 
-  private async generateUniqueExternalId(codeLength: number, triggerEntity: T, fieldName: string): Promise<string> {
+  private async generateUniqueExternalId(resolvedPrefix: string, codeLength: number, triggerEntity: T, fieldName: string): Promise<string> {
     const maxAttempts = 10;
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
+
       const newId = this.generateRandomCode(codeLength);
 
-      const isUnique = await this.isExternalIdUnique(newId,triggerEntity,fieldName);
+      const fullId = resolvedPrefix ? `${resolvedPrefix}-${newId}` : newId;
+
+      const isUnique = await this.isExternalIdUnique(fullId, triggerEntity, fieldName);
 
       if (isUnique) {
         return newId;

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

@@ -11,6 +11,11 @@ export enum FilterCombinator {
     OR = '$or'
 }
 
+export enum UserIdFields {
+    CREATED_BY = 'createdBy',
+    UPDATED_BY = 'updatedBy'
+}
+
 export class CrudHelperService {
     constructor(
     ) { }
@@ -154,6 +159,17 @@ export class CrudHelperService {
         return Array.isArray(value) ? value : [value];        // if the value is an array, return it as is, otherwise return it as an array
     }
 
+    private normalizeAndFilterPopulateAttributes(value: string | string[]): string[] {
+        // Normalize and remove the userId fields from the populate filter, since they are handled separately
+        const normalized = this.normalize(value);
+        return normalized.filter(item => item !== UserIdFields.CREATED_BY && item !== UserIdFields.UPDATED_BY);
+    }
+
+    extractUserIdFieldsFromPopulate(value: string | string[]): UserIdFields[] {
+        const normalized = this.normalize(value);
+        return normalized.filter(item => item === UserIdFields.CREATED_BY || item === UserIdFields.UPDATED_BY);
+    }
+
     private isRelationJoined(queryBuilder: SelectQueryBuilder<any>, joinProperty: string): boolean {
         return queryBuilder.expressionMap.joinAttributes.some(join => join.entityOrProperty === joinProperty);
     }
@@ -176,13 +192,13 @@ export class CrudHelperService {
 
         // 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);
-        const normalizedPopulate = this.normalize(populate);
+        const normalizedAndFilteredPopulateAttributes = this.normalizeAndFilterPopulateAttributes(populate);
         const normalizedPopulateMedia = this.normalize(populateMedia);
 
         // if normalizedPopulateMedia, has any nested media paths, then add then to populate excluding the last part
         const additionalPopulate = this.additionalRelationsRequiredForMediaPopulation(normalizedPopulateMedia);
         // Add the additional populate relations to the normalizedPopulate, if they are not already present
-        normalizedPopulate.push(...additionalPopulate.filter((relation) => !normalizedPopulate.includes(relation)));
+        normalizedAndFilteredPopulateAttributes.push(...additionalPopulate.filter((relation) => !normalizedAndFilteredPopulateAttributes.includes(relation)));
 
         const normalizedSort = this.normalize(sort);
         const normalizedGroupBy = this.normalize(groupBy);
@@ -191,8 +207,8 @@ export class CrudHelperService {
         }
 
         // Depending upon the populate option, apply the join clause
-        if (normalizedPopulate && normalizedPopulate.length) {
-            this.buildPopulateQuery(normalizedPopulate, entityAlias, qb);
+        if (normalizedAndFilteredPopulateAttributes && normalizedAndFilteredPopulateAttributes.length) {
+            this.buildPopulateQuery(normalizedAndFilteredPopulateAttributes, entityAlias, qb);
         }
 
         if (filters) {
@@ -419,6 +435,18 @@ export class CrudHelperService {
         return matchingPermssions.length > 0
     }
 
+    hasPublishPermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
+        const permissionNames = [`${classify(modelName)}Controller.publish`];
+        const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+        return matchingPermssions.length > 0
+    }
+
+    hasUnpublishPermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
+        const permissionNames = [`${classify(modelName)}Controller.publish`];
+        const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+        return matchingPermssions.length > 0
+    }
+
     hasDeletePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
         const permissionNames = [`${classify(modelName)}Controller.delete`, `${classify(modelName)}Controller.deleteMany`];
         const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));

package/src/services/crud.service.ts

@@ -2,7 +2,7 @@ import { BadRequestException, NotFoundException } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { isArray } from "class-validator";
-import { CommonEntity, SolidBaseRepository } from "src";
+import { CommonEntity, SolidBaseRepository, User } from "src";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 import { SUCCESS_MESSAGES } from "src/constants/success-messages";
 import { EntityManager, FindOptionsWhere, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
@@ -33,7 +33,7 @@ import { SelectionStaticFieldCrudManager } from "../helpers/field-crud-managers/
 import { ShortTextFieldCrudManager } from "../helpers/field-crud-managers/ShortTextFieldCrudManager";
 import { UUIDFieldCrudManager } from "../helpers/field-crud-managers/UUIDFieldCrudManager";
 import { FieldCrudManager, MediaWithFullUrl } from "../interfaces";
-import { CrudHelperService } from "./crud-helper.service";
+import { CrudHelperService, UserIdFields } from "./crud-helper.service";
 import { FileService } from "./file.service";
 import { HashingService } from "./hashing.service";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
@@ -178,6 +178,10 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
 
+        if (model.draftPublishWorkflow === true && entity.publishedAt) {
+            throw new BadRequestException(`Cannot update a published record for model ${this.modelName}. Unpublish it first.`
+            );
+        }
         updateDto.id = id;
         // 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
@@ -239,6 +243,10 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
 
+        if (model.draftPublishWorkflow === true && entity.publishedAt) {
+            throw new BadRequestException(`Cannot update a published record for model ${this.modelName}, Unpublish it first.`);
+        }
+
         // 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
@@ -430,6 +438,8 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         const alias = 'entity';
         // Extract the required keys from the input query
         let { limit, offset, populateMedia, populateGroup, groupFilter } = basicFilterDto;
+        const populateUserIdFields = this.crudHelperService.extractUserIdFieldsFromPopulate(basicFilterDto.populate);
+
         const { singularName, internationalisation, draftPublishWorkflow } = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
@@ -445,16 +455,19 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
 
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = await this.repo.createSecurityRuleAwareQueryBuilder(alias)
-        qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+        // qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
         if (internationalisation && draftPublishWorkflow) {
             qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef);
         }
+        else {
+            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, populateUserIdFields, populateMedia);
             const totalGroups = await this.crudHelperService.countGroupedRecords(qb, basicFilterDto, alias);
-            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+            // qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
 
             return {
                 meta: {
@@ -466,7 +479,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         }
         else {
             // Get the records and the count
-            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit, alias);
+            const { meta, records } = await this.handleNonGroupFind(qb, populateUserIdFields, populateMedia, offset, limit, alias);
             return {
                 meta,
                 records,
@@ -474,9 +487,14 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         }
     }
 
-    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number, alias: string) {
+    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateUserIdFields: UserIdFields[], populateMedia: string[], offset: number, limit: number, alias: string) {
         const [entities, count] = await qb.getManyAndCount();
 
+        // Populate the entity with the userId fields
+        if (populateUserIdFields && populateUserIdFields.length > 0) {
+            await this.handlePopulateUserIdFields(populateUserIdFields, entities);
+        }
+
         // Populate the entity with the media
         if (populateMedia && populateMedia.length > 0) {
             await this.handlePopulateMedia(populateMedia, entities);
@@ -485,7 +503,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         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, populateUserIdFields: UserIdFields[], populateMedia: string[]) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -498,6 +516,11 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                 groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
                 const [entities, count] = await groupByQb.getManyAndCount();
 
+                // Populate the entity with the userId fields
+                if (populateUserIdFields && populateUserIdFields.length > 0) {
+                    await this.handlePopulateUserIdFields(populateUserIdFields, entities);
+                }
+
                 // Populate the entity with the media
                 if (populateMedia && populateMedia.length > 0) {
                     await this.handlePopulateMedia(populateMedia, entities);
@@ -531,6 +554,25 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return r;
     }
 
+    // entities is an array of T
+    // T can contain createdBy and updatedBy fields
+    // We need to populate the createdBy and updatedBy fields with the User entity
+    private async handlePopulateUserIdFields(userIdFields: UserIdFields[], entities: T[]) {
+        const userRepository = this.entityManager.getRepository(User);
+        for (const entity of entities) {
+            for (const userFieldPath of userIdFields) {
+                const userId = entity[userFieldPath as keyof T] as unknown as number;
+                if (userId) {
+                    const user = await userRepository.findOne({
+                        where: { id: userId },
+                    });
+                    // @ts-ignore
+                    entity[userFieldPath] = user;
+                }
+            }
+        }
+    }
+
     private async handlePopulateMedia(populateMedia: string[], entities: T[]) {
         const model = await this.entityManager.getRepository(ModelMetadata).findOne({
             where: {
@@ -615,7 +657,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return mediaDetails as MediaWithFullUrl[];
     }
 
-    async findOne(id: number, query: any, solidRequestContext: any = {}) {
+    async findOne(id: number, query: any={}, solidRequestContext: any = {}) {
         const { populate = [], fields = [], populateMedia = [] } = query;
 
         // const normalizedFields = this.crudHelperService.normalize(fields);
@@ -731,8 +773,30 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                     id: id,
                 } as unknown as FindOptionsWhere<T>,
             });
+
             removedEntities.push(entity);
         }
+
+
+        // entity-level flag
+        const isDraftPublishEnabled = model?.draftPublishWorkflow === true;
+
+        let publishedEntitiesExists: T[] = [];
+
+        if (isDraftPublishEnabled) {
+            publishedEntitiesExists = removedEntities.filter(
+                (x) => !!x?.publishedAt
+            );
+        }
+
+        if (publishedEntitiesExists.length > 0) {
+            const publishedEntitiesExistsID = publishedEntitiesExists.map(x => x.id);
+
+            throw new BadRequestException(
+                `Cannot delete published record(s) for model ${this.modelName} with Ids ${publishedEntitiesExistsID.join(', ')}. Unpublish them first.`
+            );
+        }
+
         if (model.enableSoftDelete === true) {
             await this.repo.softRemove(removedEntities);
             return this.repo.save(removedEntities);
@@ -767,7 +831,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             await this.repo.update(id, {
                 deletedAt: null, deletedTracker: "not-deleted"
             } as unknown as QueryDeepPartialEntity<T>
-         );
+            );
 
             return { message: SUCCESS_MESSAGES.RECORD_RECOVERED, data: softDeletedRows };
         } catch (error) {
@@ -868,5 +932,89 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         }
         return model.userKeyField?.name || '';
     }
+
+    /* Publish a record - sets publishedAt timestamp */
+    async publishRecord(id: number, solidRequestContext: any = {}): Promise<T> {
+
+        const model = await this.loadModel();
+
+        // Check if publish workflow is enabled for this model
+        if (!model.draftPublishWorkflow) {
+            throw new BadRequestException(
+                `Publish workflow is not enabled for ${this.modelName}`
+            );
+        }
+
+        // Check user permissions
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasPublishPermissionOnModel(
+                solidRequestContext.activeUser,
+                model.singularName
+            );
+            if (!hasPermission) {
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
+            }
+        }
+
+        // Find the entity
+        const entity = await this.repo.findOne({ where: { id } as any });
+        if (!entity) {
+            throw new NotFoundException(`${this.modelName} with id ${id} not found`);
+        }
+
+        // Check if already published
+        if (entity.publishedAt) {
+            throw new BadRequestException(
+                `${this.modelName} with id ${id} is already published`
+            );
+        }
+
+        // Update publish status
+        const updatedEntity = await this.repo.save({ ...entity, publishedAt: new Date() });
+
+        return updatedEntity
+    }
+
+    /* Unpublish a record - clears publishedAt timestamp */
+    async unpublishRecord(id: number, solidRequestContext: any = {}): Promise<T> {
+
+        const model = await this.loadModel();
+
+        // Check if publish workflow is enabled for this model
+        if (!model.draftPublishWorkflow) {
+            throw new BadRequestException(
+                `Publish workflow is not enabled for ${this.modelName}`
+            );
+        }
+
+        // Check user permissions
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasUnpublishPermissionOnModel(
+                solidRequestContext.activeUser,
+                model.singularName
+            );
+            if (!hasPermission) {
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
+            }
+        }
+
+        // Find the entity
+        const entity = await this.repo.findOne({ where: { id } as any });
+        if (!entity) {
+            throw new NotFoundException(`${this.modelName} with id ${id} not found`);
+        }
+
+        // Check if already unpublished
+        if (!entity.publishedAt) {
+            throw new BadRequestException(
+                `${this.modelName} with id ${id} is already unpublished`
+            );
+        }
+
+        // Update unpublish status
+        const updatedEntity = await this.repo.save({ ...entity, publishedAt: null });
+
+        return updatedEntity
+    }
 }