@solidxai/core 0.1.13-beta.7 → 0.1.13-beta.8

package/src/entities/user.entity.ts

@@ -36,12 +36,12 @@ export class User extends CommonEntity {
     @Expose()
     username: string;
 
-    @Index()
+    @Index({ unique: true })
     @Column({ type: "varchar", nullable: true })
     @Expose()
     email: string;
 
-    @Index()
+    @Index({ unique: true })
     @Column({ type: "varchar", nullable: true })
     @Expose()
     mobile: string;

package/src/factories/mail.factory.ts

@@ -30,8 +30,14 @@ export class MailFactory {
         }
 
         const mailServiceProvider = mailProviders.find(provider => provider.name === mailServiceName);
+        if (!mailServiceProvider?.instance) {
+            const registeredProviders = mailProviders.map((provider) => provider?.name).filter(Boolean).join(", ");
+            throw new Error(
+                `Mail provider "${mailServiceName}" is not registered. Registered providers: ${registeredProviders || "none"}`,
+            );
+        }
 
         return mailServiceProvider.instance as IMail;
     }
 
-}
+}

package/src/helpers/field-crud-managers/MediaFieldCrudManager.ts

@@ -1,5 +1,5 @@
 import { FieldCrudManager, ValidationError } from "src/interfaces";
-import { DANGEROUS_EXTENSIONS, EXT_TO_MEDIA_TYPE, MediaCategory } from "src/constants/media-file-types";
+import { EXT_TO_MEDIA_TYPE, getLowercaseFileExtension, getUploadedFileName, isDangerousMediaFile, MediaCategory } from "src/constants/media-file-types";
 
 export enum SolidMediaType {
     mediaSingle = 'mediaSingle',
@@ -79,16 +79,15 @@ export class MediaFieldCrudManager implements FieldCrudManager {
     constructor(private readonly options: MediaFieldOptions) {
     }
 
-    private resolveMediaType(mimetype?: string, filename?: string): MediaType | null {
-        const ext = (filename || '').split('.').pop()?.toLowerCase();
-        if (ext && DANGEROUS_EXTENSIONS.has(ext)) {
+    private resolveMediaType(file: Express.Multer.File): MediaType | null {
+        // Belt-and-braces: dangerous files are already rejected outright by
+        // validateDangerousFiles, but never let one resolve to a usable category.
+        if (isDangerousMediaFile(file)) {
             return null;
         }
 
-        const mt = (mimetype || '').toLowerCase().trim();
-        if (mt === 'image/svg+xml' || mt === 'text/html' || mt === 'application/xhtml+xml') {
-            return null;
-        }
+        const ext = getLowercaseFileExtension(getUploadedFileName(file));
+        const mt = (file.mimetype || '').toLowerCase().trim();
         if (mt && MIME_TO_MEDIA_TYPE[mt]) {
             return MIME_TO_MEDIA_TYPE[mt];
         }
@@ -113,16 +112,31 @@ export class MediaFieldCrudManager implements FieldCrudManager {
     }
 
     private applyValidations(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
+        // Runs for every media field type and regardless of the admin-configured mediaTypes
+        // allowlist - a dangerous upload is never acceptable, so this must not sit behind
+        // the optional type checks below.
+        const errors = this.validateDangerousFiles(fieldFiles);
+
         switch (this.options.type) {
             case SolidMediaType.mediaSingle:
-                return this.validateMediaSingle(fieldFiles);
+                return [...errors, ...this.validateMediaSingle(fieldFiles)];
             case SolidMediaType.mediaMultiple:
-                return this.validateMediaMultiple(fieldFiles);
+                return [...errors, ...this.validateMediaMultiple(fieldFiles)];
             default:
-                return [];
+                return errors;
         }
     }
 
+    private validateDangerousFiles(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
+        return fieldFiles
+            .filter(fieldFile => isDangerousMediaFile(fieldFile))
+            .map(fieldFile => ({
+                field: this.options.fieldName,
+                error: `${this.options.fieldName} file type not allowed. ` +
+                    `${getUploadedFileName(fieldFile) || 'File'} is a potentially dangerous file type.`
+            }));
+    }
+
     private validateMediaSingle(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
         const errors: ValidationError[] = [];
         if (!this.options.isUpdate && this.options.required && fieldFiles.length === 0) {
@@ -157,7 +171,7 @@ export class MediaFieldCrudManager implements FieldCrudManager {
             for (let i = 0; i < fieldFiles.length; i++) {
                 const fieldFile = fieldFiles[i];
 
-                const resolvedType = this.resolveMediaType(fieldFile.mimetype, fieldFile.originalname ?? fieldFile.filename ?? '');
+                const resolvedType = this.resolveMediaType(fieldFile);
                 if (!resolvedType || !allowedFileTypes.includes(resolvedType)) {
                     errors.push({
                         field: this.options.fieldName,

package/src/helpers/file-download.helper.ts

@@ -0,0 +1,31 @@
+import type { Response } from "express";
+
+export interface FileDownloadHeaderOptions {
+  fileName: string;
+  mimeType: string;
+  /** Defaults to 'attachment'; only pass 'inline' for types known safe to render. */
+  disposition?: "inline" | "attachment";
+  /** Opt in for assets loaded cross-origin by the UI (e.g. media served to :3000). */
+  crossOriginResourcePolicy?: boolean;
+}
+
+/**
+ * Single place that stamps the response headers for every streamed file download, so the
+ * security headers can't be applied to one endpoint and forgotten on the next.
+ */
+export function setFileDownloadHeaders(res: Response, options: FileDownloadHeaderOptions): void {
+  const disposition = options.disposition ?? "attachment";
+
+  res.setHeader("Content-Disposition", `${disposition}; filename="${options.fileName}"`);
+  res.setHeader("Content-Type", options.mimeType);
+  res.setHeader("Access-Control-Expose-Headers", "Content-Disposition, Content-Type");
+
+  // Prevent the browser from ever content-sniffing a served file into something more
+  // dangerous than its declared Content-Type (e.g. rendering a mislabeled upload as HTML
+  // and executing embedded script).
+  res.setHeader("X-Content-Type-Options", "nosniff");
+
+  if (options.crossOriginResourcePolicy) {
+    res.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
+  }
+}

package/src/helpers/model-metadata-helper.service.ts

@@ -2,6 +2,7 @@
 
 import { forwardRef, Inject, Injectable, Logger } from "@nestjs/common";
 import { _ } from "lodash";
+import { DRAFT_PUBLISH_VERSIONING_FIELD_NAMES } from "src/constants/draft-publish-fields";
 import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity-with-existing-id.entity";
 import { LegacyTableType } from "src/enums/legacy-table-type.enum";
 import { ModelMetadataRepository } from "src/repository/model-metadata.repository";
@@ -87,6 +88,32 @@ export class ModelMetadataHelperService {
                 isSystem: true,
                 enableAuditTracking:true
             },
+            {
+                name: "isPublished",
+                displayName: "Is Published",
+                type: "boolean",
+                isSystem: true,
+                enableAuditTracking: true
+            },
+            {
+                name: "isLatest",
+                displayName: "Is Latest",
+                type: "boolean",
+                isSystem: true,
+                enableAuditTracking: true
+            },
+            {
+                name: "initialEntityVersionId",
+                displayName: "Initial Entity Version Id",
+                type: "int",
+                isSystem: true,
+            },
+            {
+                name: "publishedTracker",
+                displayName: "Published Tracker",
+                type: "shortText",
+                isSystem: true,
+            },
             {
                 name: "localeName",
                 displayName: "Locale",
@@ -117,7 +144,11 @@ export class ModelMetadataHelperService {
     }
 
     private getSystemFieldsMetadataMappingForLegacyTable(withId: boolean=true) {
-        const systemFieldsMetadata = this.getSystemFieldsMetadataMapping();
+        // Legacy tables don't have the draft/publish versioning columns, so exclude
+        // them from the legacy system fields metadata mapping.
+        const legacyExcludedFieldNames: readonly string[] = DRAFT_PUBLISH_VERSIONING_FIELD_NAMES;
+        const systemFieldsMetadata = this.getSystemFieldsMetadataMapping()
+            .filter(field => !legacyExcludedFieldNames.includes(field.name));
         if (!withId) {
             // Remove the id field metadata
             const index = systemFieldsMetadata.findIndex(field => field.name === 'id');

package/src/helpers/solid-registry.ts

@@ -366,7 +366,7 @@ export class SolidRegistry {
   }
 
   getCommonEntityKeys(): (keyof CommonEntity | 'createdBy' | 'updatedBy')[] {
-    return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt'];
+    return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt', 'isPublished', 'isLatest', 'initialEntityVersionId', 'publishedTracker'];
     // return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];
   }
 

package/src/index.ts

@@ -225,6 +225,7 @@ export * from './helpers/environment.helper'
 export * from './helpers/cache.helper'
 export * from './helpers/cors.helper'
 export * from './helpers/security.helper'
+export * from './helpers/file-download.helper'
 export * from './helpers/model-metadata-helper.service'
 export * from './helpers/image-encoding.helper'
 export * from './helpers/solid-microservice-adapter.service'
@@ -337,6 +338,7 @@ export * from './services/action-metadata.service'
 export * from './services/authentication.service'
 export * from './services/bcrypt.service'
 export * from './services/computed-fields/uuid-external-id-computed-field-provider.service'
+export * from './services/draft-publish-helper.service'
 export * from './services/crud-helper.service'
 export * from './services/crud.service'
 export * from './services/email-template.service'

package/src/seeders/module-test-data.service.ts

@@ -12,6 +12,7 @@ import { CreateModelMetadataDto } from 'src/dtos/create-model-metadata.dto';
 import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
 import { getDynamicModuleNamesBasedOnMetadata } from 'src/helpers/module.helper';
 import { SolidRegistry } from 'src/helpers/solid-registry';
+import { InternationalisationHelperService } from 'src/services/internationalisation-helper.service';
 import { MediaRepository } from 'src/repository/media.repository';
 import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
 import { AuthenticationService } from 'src/services/authentication.service';
@@ -30,6 +31,7 @@ export class ModuleTestDataService {
     private readonly moduleRef: ModuleRef,
     private readonly discoveryService: DiscoveryService,
     private readonly solidRegistry: SolidRegistry,
+    private readonly internationalisationHelperService: InternationalisationHelperService,
   ) {}
 
   async setupTestData(modulesToTest?: string[]): Promise<void> {
@@ -246,6 +248,10 @@ export class ModuleTestDataService {
       const entityRepo = this.resolveRepository(modelUserKey);
       const payload: Record<string, any> = { ...(entry.data ?? {}) };
 
+      if (modelDef.internationalisation && !payload.localeName) {
+        payload.localeName = this.internationalisationHelperService.resolveDefaultLocaleName(this.solidRegistry);
+      }
+
       for (const field of modelDef.fields ?? []) {
         if (field.type === 'relation' && field.relationType === 'many-to-one') {
           const userKeyProp = `${field.name}UserKey`;

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

@@ -1808,6 +1808,8 @@
             "index": true,
             "private": false,
             "encrypt": false,
+            "regexPattern": "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$",
+            "regexPatternNotMatchingErrorMsg": "Please enter a valid email address.",
             "isSystem": true,
             "enableAuditTracking": true
           },

package/src/services/1.js

@@ -0,0 +1,6 @@
+1. Do i need to create a storeStreams method for aws service too?
+    - Handle later
+2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
+    - startExport should either return the data or return the transaction id
+3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
+    - show the userKey

package/src/services/authentication.service.ts

@@ -20,7 +20,7 @@ import { SUCCESS_MESSAGES } from "src/constants/success-messages";
 import { CreateUserDto } from "src/dtos/create-user.dto";
 import { MailFactory } from "src/factories/mail.factory";
 import { UserRepository } from "src/repository/user.repository";
-import { DataSource, DeepPartial, Repository } from "typeorm";
+import { DataSource, DeepPartial, FindOptionsWhere, Repository } from "typeorm";
 import { v4 as uuidv4 } from "uuid";
 import {
   ForgotPasswordSendVerificationTokenOn,
@@ -49,6 +49,7 @@ import { SsoCodeStorageService } from "./sso-code-storage.service";
 import { RoleMetadataService } from "./role-metadata.service";
 import { SettingService } from "./setting.service";
 import { UserActivityHistoryService } from "./user-activity-history.service";
+import { MetadataValidationService } from "./metadata-validation.service";
 import { UserService } from "./user.service";
 import { SmsFactory } from "src/factories/sms.factory";
 import { WhatsAppFactory } from "src/factories/whatsapp.factory";
@@ -88,6 +89,7 @@ export class AuthenticationService {
     private readonly roleMetadataService: RoleMetadataService,
     private readonly userActivityHistoryService: UserActivityHistoryService,
     private readonly ssoCodeStorage: SsoCodeStorageService,
+    private readonly metadataValidationService: MetadataValidationService,
 
     @InjectDataSource()
     private readonly dataSource: DataSource,
@@ -225,6 +227,9 @@ export class AuthenticationService {
     preferEntityApiKeyFlag: boolean = false,
   ): Promise<T> {
     try {
+      await this.assertUniqueSignupIdentifiers(signUpDto, repo);
+      await this.metadataValidationService.validateCreateDto("user", signUpDto);
+
       const onForcePasswordChange =
         this.settingService.getConfigValue<SolidCoreSetting>(
           "forceChangePasswordOnFirstLogin",
@@ -276,6 +281,59 @@ export class AuthenticationService {
     }
   }
 
+  private async assertUniqueSignupIdentifiers<T extends User>(
+    signUpDto: SignUpDto,
+    repo: Repository<T>,
+  ): Promise<void> {
+    const username = signUpDto.username?.trim();
+    const email = signUpDto.email?.trim();
+    const mobile = signUpDto.mobile?.trim();
+
+    const where: FindOptionsWhere<T>[] = [];
+
+    if (username) {
+      where.push({ username } as FindOptionsWhere<T>);
+    }
+
+    if (email) {
+      where.push({ email } as FindOptionsWhere<T>);
+    }
+
+    if (mobile) {
+      where.push({ mobile } as FindOptionsWhere<T>);
+    }
+
+    if (where.length === 0) {
+      return;
+    }
+
+    const existingUser = await repo.findOne({ where });
+
+    if (!existingUser) {
+      return;
+    }
+
+    if (email && existingUser.email === email) {
+      throw new ConflictException(
+        `A user with email address "${email}" already exists.`,
+      );
+    }
+
+    if (mobile && existingUser.mobile === mobile) {
+      throw new ConflictException(
+        `A user with mobile number "${mobile}" already exists.`,
+      );
+    }
+
+    if (username && existingUser.username === username) {
+      throw new ConflictException(
+        `A user with username "${username}" already exists.`,
+      );
+    }
+
+    throw new ConflictException(ERROR_MESSAGES.USER_ALREADY_EXISTS);
+  }
+
   private async handlePasswordlessSignupOtp<T extends User>(
     user: T,
     signUpDto: SignUpDto,
@@ -400,11 +458,23 @@ export class AuthenticationService {
     // if forcePasswordChange is true, then we trigger an email to the user to change the password, this needs to be done using a queue.
     // Create a new method like notifyUserOnForcePasswordChange, create a new email template we can call it on-force-password-change this template to include the random password
     if (user.forcePasswordChange && autoGeneratedPwd) {
-      await this.notifyUserOnForcePasswordChange(user, autoGeneratedPwd);
+      try {
+        await this.notifyUserOnForcePasswordChange(user, autoGeneratedPwd);
+      } catch (error: any) {
+        this.logger.error(
+          `Failed to send force-password-change email for user ${user.id}: ${error?.message ?? error}`,
+        );
+      }
     }
 
     // Send welcome notifications (email/SMS) if enabled.
-    await this.notifyUserOnSignup(user);
+    try {
+      await this.notifyUserOnSignup(user);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to send signup notifications for user ${user.id}: ${error?.message ?? error}`,
+      );
+    }
   }
 
   generatePassword(length: number = 8): string {
@@ -1578,7 +1648,7 @@ export class AuthenticationService {
     // Assuming all users do not have mobile as mandatory.
     if (
       forgotPasswordSendVerificationTokenOn ==
-        ForgotPasswordSendVerificationTokenOn.MOBILE &&
+      ForgotPasswordSendVerificationTokenOn.MOBILE &&
       user.mobile
     ) {
       const smsService = this.smsFactory.getSmsService();
@@ -1702,7 +1772,7 @@ export class AuthenticationService {
     // Assuming all users do not have mobile as mandatory.
     if (
       forgotPasswordSendVerificationTokenOn ==
-        ForgotPasswordSendVerificationTokenOn.MOBILE &&
+      ForgotPasswordSendVerificationTokenOn.MOBILE &&
       user.mobile
     ) {
       const smsService = this.smsFactory.getSmsService();
@@ -2342,6 +2412,7 @@ function parseUniqueConstraintError(detail: string): string {
     const fieldMap: Record<string, string> = {
       username: "username",
       email: "email address",
+      mobile: "mobile number",
       full_name_user_key: "full name",
     };
     const friendlyField = fieldMap[field] || field;

package/src/services/chatter-message.service.ts

@@ -6,6 +6,7 @@ import { Brackets, EntityManager, EntityMetadata, In } from 'typeorm';
 
 import { classify } from '@angular-devkit/core/src/utils/strings';
 import { CHATTER_MESSAGE_STATUS, CHATTER_MESSAGE_SUBTYPE, CHATTER_MESSAGE_TYPE, CHATTER_MESSAGE_USER_FIELDS } from 'src/constants/chatter-message.constants';
+import { isDangerousMediaFile } from 'src/constants/media-file-types';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { PostChatterMessageDto } from 'src/dtos/post-chatter-message.dto';
 import { UpdateChatterNoteMessageDto } from 'src/dtos/update-chatter-note-message.dto';
@@ -174,6 +175,17 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }, messageBody || '');
     }
 
+    /**
+     * Chatter attachments bypass MediaFieldCrudManager - they go straight to
+     * storageProvider.store() - so the shared predicate is applied here directly. The rules
+     * themselves live in media-file-types so upload paths can't drift apart.
+     */
+    private validateChatterMediaFiles(files: Express.Multer.File[] = []) {
+        if (Array.isArray(files) && files.some(file => isDangerousMediaFile(file))) {
+            throw new BadRequestException('Dangerous file types are not allowed in chatter attachments.');
+        }
+    }
+
     private async publishChatterMentionNotifications(message: ChatterMessage, model: any) {
         if (message.messageType !== CHATTER_MESSAGE_TYPE.CUSTOM || message.messageSubType !== CHATTER_MESSAGE_SUBTYPE.NOTE) {
             return;
@@ -305,6 +317,8 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             throw new BadRequestException('Message body cannot be empty.');
         }
 
+        this.validateChatterMediaFiles(files);
+
         if (hasMessageBody) {
             message.messageBody = trimmedMessageBody;
         }
@@ -379,6 +393,8 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         const coModelName = lowerFirst(postDto.coModelName);
         await this.assertRecordAccess(coModelName, postDto.coModelEntityId);
 
+        this.validateChatterMediaFiles(files);
+
         const chatterMessage = new ChatterMessage();
         chatterMessage.messageType = CHATTER_MESSAGE_TYPE.CUSTOM;
         chatterMessage.messageSubType = postDto.messageSubType || CHATTER_MESSAGE_SUBTYPE.CUSTOM;

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

@@ -3,9 +3,12 @@ import { BasicFilterDto } from "../dtos/basic-filters.dto";
 import { classify } from '../helpers/string.helper';
 import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 import { SolidRegistry } from "src/helpers/solid-registry";
-import { BadRequestException, Logger } from "@nestjs/common";
+import { BadRequestException, Injectable, Logger } from "@nestjs/common";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 import { buildCastToText } from "src/helpers/typeorm-db-helper";
+import { DraftPublishHelperService } from "./draft-publish-helper.service";
+import { InternationalisationHelperService } from "./internationalisation-helper.service";
+import { normalizeObjectKeys } from "./object.utils";
 
 export enum FilterCombinator {
     AND = '$and',
@@ -36,10 +39,14 @@ export interface ResolvedFieldPath {
     leafIsRelation: boolean;
 }
 
+@Injectable()
 export class CrudHelperService {
+    private readonly logger = new Logger(CrudHelperService.name);
+
     constructor(
+        private readonly draftPublishHelperService: DraftPublishHelperService,
+        private readonly internationalisationHelperService: InternationalisationHelperService,
     ) { }
-    private readonly logger = new Logger(CrudHelperService.name);
 
     /**
      * Resolve a user-supplied dotted path (e.g. "customer.name") against real TypeORM metadata.
@@ -163,7 +170,7 @@ export class CrudHelperService {
     }
 
     applyFilters(qb: WhereExpressionBuilder, filters: any, alias: string = 'entity', selectQb: SelectQueryBuilder<any>) {
-        const normalizedFilters = this.normalizeObjectKeys(filters);
+        const normalizedFilters = normalizeObjectKeys(filters);
         if (normalizedFilters.$and) {
             normalizedFilters.$and.forEach((andFilter: any) => {
                 qb.andWhere(
@@ -182,7 +189,7 @@ export class CrudHelperService {
             // For individual conditions
             Object.keys(normalizedFilters).forEach(key => {
                 const primaryFilterObj = normalizedFilters[key];
-                const normalizedPrimaryFilterObj = this.normalizeObjectKeys(primaryFilterObj);
+                const normalizedPrimaryFilterObj = normalizeObjectKeys(primaryFilterObj);
 
                 const [rawField, funcAlias] = key.split(':');
 
@@ -312,17 +319,6 @@ export class CrudHelperService {
         }
     }
 
-    // Normalize the primary operator object by removing the surrounding brackets in the keys e.g [$eq] => $eq
-    private normalizeObjectKeys(obj: any): any {
-        return Object.keys(obj).reduce((acc, key) => {
-            // Transform the key by removing surrounding brackets
-            const newKey = key.replace(/^\[(.*)\]$/, '$1');
-            // Assign the value to the transformed key in the accumulator object
-            acc[newKey] = obj[key];
-            return acc;
-        }, {});
-    }
-
     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
@@ -359,7 +355,7 @@ export class CrudHelperService {
         applySorting: boolean = true
     ): SelectQueryBuilder<any> { // TODO : Check how to pass a type to SelectQueryBuilder instead of any
         let { limit, offset, showSoftDeleted, filters } = basicFilterDto;
-        const { fields, sort, populate = [], populateMedia = [], locale, status } = basicFilterDto;
+        const { fields, sort, populate = [], populateMedia = [], locale } = 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);
@@ -390,28 +386,14 @@ 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) {
-                //Get default locale from registry
-                const solidRegistry = moduleRef.get(SolidRegistry, { strict: false });
-                const defaultLocale = solidRegistry.getDefaultLocale();
-                if(defaultLocale){
-                    finalLocale = defaultLocale.locale;
-                }else{
-                    finalLocale = 'en';
-                }
-            }
+            // If locale is not provided in the filter dto, then assume it is the default locale to be used.
+            const finalLocale = locale || this.internationalisationHelperService.resolveDefaultLocaleName(moduleRef.get(SolidRegistry, { strict: false }));
             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`);
-            }
+        if (draftPublishWorkflow) {
+            this.draftPublishHelperService.applyDraftPublishFilterDefaults(qb, filters, entityAlias);
         }
         // Depending upon the select option, apply the select clause
         if (normalizedFields && normalizedFields.length) {